.NET Core 跨平台串口通信，Windows/Linux 串口通信，flyfire.CustomSerialPort 的使用

时间 2019-11-12 标签 core 跨平台串口通信 windows linux flyfire.customserialport flyfire customserialport 使用

1，前言

开发环境：在 Visual Studio 2017，.NET Core 2.xhtml

串口通信用于设备之间，传递数据，物联网设备中普遍使用串口方式链接通信，物联网通信协议：Modbus 协议 ASCII、RTU、TCP模式是应用层的协议，与通信方式无关。数组

笔者如今实现的是串口通讯，实现后，能够在上层加上 Modbus 协议，笔者的另外一篇文章便是在串口上实现 Modbus 协议，计算中心向物联网设备发送消息，要求设备响应，传送设备信息、检测状态等。服务器

本文是串口通信的实现。框架

2，安装虚拟串口软件

因为开发在 Windows，也为了调试方便，使用须要安装虚拟串口软件： Virtual Serial Port Driveride

安装完成后

添加串口

请添加 4-6 个串口，COM1，COM2，COM3，COM4 ... ...this

关机重启

好了，为了使串口生效，请关机重启(不必定要关机，不过为了不出现问题，仍是关机重启比较好)。spa

开机后，打开设备管理器，查看设备 - 端口(COM 和 LPT)，出现以下图所示，说明正常线程

原理

由于是虚拟串口，有些问题须要注意一下设计

A B(或者说服务端、客户端)不能使用同一个串口，你在设备管理器查看串口时(上面也有图)，是否是看到3d

COM1 -> COM2

COM2 -> COM1

由于这是一个虚拟串口，因此只能是单方向的，因此 A、B 须要分别使用两个串口进行通信，而虚拟串口把 COM1 - COM2 链接起来了。咱们不须要关心这个，这里只是说明一下。

3，新建项目，加入 flyfire.CustomSerialPort

新建一个 .NET Core 控制台项目

名字能够随便起，笔者用了 SerialPortTest ，那咱们都用这个吧

添加 flyfire.CustomSerialPort

在项目中添加 Nuget，搜索 flyfire.CustomSerialPort ，而后安装

把类库须要的 Linux 依赖库添加到项目中，关于缘由、添加方法，能够看笔者的另外一篇文章 https://www.cnblogs.com/whuanle/p/10499498.html#4

4，flyfire.CustomSerialPort 说明

CustomSerialPort 类，全部功能都集中在这里面了，笔者将详细说明此类下字段、方法等的使用

protected SerialPortStream sp;

支持通信串口通信的类

public CustomSerialPort(string portName, int baudRate = 115200,
 Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One);

用于初始化一个串口，使用此串口进行通信

portName　　串口名称
baudRate　　比特率，是指每秒传送的比特(bit)数，默认115200bps，不清楚 -> 百度
parity　　　表示奇偶性校验方式，枚举，None：没有校验为，Odd：奇校验，Even：偶检验，Space：总为0，Mark：总为1
databits　　设置数据位，这里表示 8位
stopBits　　中止位，One，One5，Twe方便表示一、1.五、2个中止位

由于串口设备通信是在 OSI 七层的传输层，因此对这些都有相应的规定。TCP/IP 相对于串口来讲，没必要要关注这些。

        public int ReceiveTimeout { get; set; }　　//接收超时时间
        public bool ReceiveTimeoutEnable { get; set; }　　
        public bool RtsEnable { get; set; }　　　　//不详
        public bool DtrEnable { get; set; }　　　　//不详
        public bool IsOpen { get; }　　　　　　　　//检测是否在使用
        public StopBits StopBits { get; set; }　　//枚举，上面说明的
        public int DataBits { get; set; }　　　　//上面说明了
        public Parity Parity { get; set; }　　　　//枚举，上面说明了
        public int BaudRate { get; set; }
        public int BufSize { get; set; }
        public string PortName { get; set; }　　　　//使用的串口名

　　　　　public event CustomSerialPortReceivedEventHandle ReceivedEvent;　　　　//一个事件，能够把接收到消息后须要触发的时间绑定到此事件

        public static string ByteToHexStr(byte[] bytes);　　　　　　　　　　　　　　//把比特流转为字符串
        public static string[] GetPortNames();
        public void Close();　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//关闭串口
        public void Dispose();
        public bool Open();　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//释放串口
        public void Write(string text);　　　　　　　　　　　　　　　　　　　　　　　　//以字符串的形式写入串口
        public void Write(byte[] buffer);　　　　　　　　　　　　　　　　　　　　　　　//以字节流的方式写入串口(推荐)
        public void WriteLine(string text);　　　　　　　　　　　　　　　　　　　　　　//写入字符串，应该是与Modbus ASCII有关，Ascii方式须要在数据后面加上换行符表示已经结束传送
        protected void ReceiveTimeoutCheckFunc();
        protected void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e);　　//后台线程处理，表示收到串口消息后，触发那些事件

以上，就是对 flyfire.CustomSerialPort 的说明，下面笔者说明怎么使用。

5，开始使用 flyfire.CustomSerialPort

新建一个类 SerialSerice.cs

新建一个类 SerialSerice.cs ，设计此类用于提供串口通信服务。

在 SerialSerice.cs 引入

using flyfire.IO.Ports;
using RJCP.IO.Ports;
using System.Threading;

编写如下代码(你可能以为有些奇怪，缘由后面说)，先无论这些东西，也不要管为何这样写

namespace SerialPortTest
{
    /// <summary>
    ///  用于封装须要的串口通信
    /// </summary>
    public class SerialSerice
    {
        /// <summary>
        /// 获取计算机的全部串口
        /// </summary>
        public void GetSerial()
        {
　　　　　　　　//CustomSerialPort.GetPortNames() 静态方法，获取计算机的全部串口名称
　　　　　　　　//由于已经继承，也可使用 string[] vs = 串口通信.GetPortNames();
            string[] vs = CustomSerialPort.GetPortNames();
            Console.WriteLine("你电脑的串口列表：");
            foreach (var i in vs)
            {
                Console.WriteLine(i);
            }
        }
    }

    public class 串口通信 : CustomSerialPort
    {
        public 串口通信(string portName, int baudRate = 115200, Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One)
            :base(portName, baudRate, parity, databits, stopBits)
        {

        }
    }
}

开始在 Program.cs 中使用

 　　　　static void Main(string[] args)
        {
            SerialSerice serialSerice = new SerialSerice();
            serialSerice.GetSerial();
            Console.ReadKey();
        }

运行试试

6，实现把数据写入串口

上面已经获取到串口，要把数据写入一个串口，就要初始化串口类，实现使用串口、向串口写入不一样类型、不一样进制的数据

为了简单一些，咱们使用默认配置。

把代码 Copy 到你的项目，笔者已经详细列举出步骤

namespace SerialPortTest
{
    /// <summary>
    ///  用于封装须要的串口通信
    /// </summary>
    public class SerialSerice
    {
        //实现串口通信的对象
        串口通信 串口;
        /// <summary>
        /// 获取计算机的全部串口 步骤 1
        /// </summary>
        public void GetSerial()
        {
            string[] vs = 串口通信.GetPortNames();
            Console.WriteLine("你电脑的串口列表(输入名称此端口，注意大小写)：");

            foreach (var i in vs)
            {
                Console.WriteLine(i);
            }
        }
        //初始化串口 步骤 2
        public void 初始化(string portname)
        {
            串口 = new 串口通信(portname);
　　　　　　　　串口.Open();
        }
        //向串口写入数据 步骤 3
        public void 写入(string str)
        {
            //方式 1
            串口.Write(str);
            Console.WriteLine("已经向串口输入：" + str);
　　　　　　　　Thread.Sleep(500);
            //方式 二、3
            byte[] b_字符 = Encoding.Default.GetBytes(str);
            byte[] b_16进制 = new byte[b_字符.Length];

            //转16进制再发送
            Console.WriteLine("发送的16进制数据：");
            for (int i = 0; i < b_字符.Length; i++)
            {
                b_16进制[i] = Convert.ToByte(b_字符[i].ToString(), 16);
                Console.Write(b_16进制[i] + " ");
            }
　　　　　　　　Console.WriteLine();
            //方式 二、3 写入串口
            串口.Write(b_字符);
　　　　　　　　Thread.Sleep(500);
            串口.Write(b_16进制);
　　　　　　　　Thread.Sleep(500);
        }
    }

    public class 串口通信 : CustomSerialPort
    {
        public 串口通信(string portName, int baudRate = 115200, Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One)
            : base(portName, baudRate, parity, databits, stopBits)
        {

        }
    }
}

服务已经配置好，接下来就是使用写好的服务了。

class Program
    {
        static void Main(string[] args)
        {
            // 初始化串口通信服务
            SerialSerice 串口功能 = new SerialSerice();

            //显示串口列表、并让用户选择串口
            串口功能.GetSerial();
            string portname= Console.ReadLine();

            //步骤 2 
            串口功能.初始化(portname);

            Console.WriteLine("输入你想发送给客户端的内容,退出请输入 exit");
            //由于示例了三种写入方法，第三种方法须要转换，非数字会报错
            //实际上你能够发送如何类型的数据，就看你怎么写步骤 3 的方法
            Console.WriteLine("只能输入数字！8进制、10进制、16进制都可，请勿输入字符串");
            while (true)
            {
                string str = Console.ReadLine();
                if (str == "exit")
                    break;

                //步骤 3
                串口功能.写入(str);
            }

            Console.ReadKey();
        }

示例：

关于进制转换这些，能够找一些文章看，串口通信对 byte、int1六、int3二、string 等类型间的转换要求比较高。

7，实现监听串口消息、多设备进行通信

在开始前，看一下图：

点击展开代码

protected void Sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            int canReadBytesLen = 0;
            if (ReceiveTimeoutEnable)
            {
                while (sp.BytesToRead > 0)
                {
                    canReadBytesLen = sp.BytesToRead;
                    if (receiveDatalen + canReadBytesLen > BufSize)
                    {
                        receiveDatalen = 0;
                        throw new Exception("Serial port receives buffer overflow!");
                    }
                    var receiveLen = sp.Read(recviceBuffer, receiveDatalen, canReadBytesLen);
                    if (receiveLen != canReadBytesLen)
                    {
                        receiveDatalen = 0;
                        throw new Exception("Serial port receives exception!");
                    }
                    //Array.Copy(recviceBuffer, 0, receivedBytes, receiveDatalen, receiveLen);
                    receiveDatalen += receiveLen;
                    lastReceiveTick = Environment.TickCount;
                    if (!TimeoutCheckThreadIsWork)
                    {
                        TimeoutCheckThreadIsWork = true;
                        Thread thread = new Thread(ReceiveTimeoutCheckFunc)
                        {
                            Name = "ComReceiveTimeoutCheckThread"
                        };
                        thread.Start();
                    }
                }
            }
            else
            {
                if (ReceivedEvent != null)
                {
                    // 获取字节长度
                    int bytesNum = sp.BytesToRead;
                    if (bytesNum == 0)
                        return;
                    // 建立字节数组
                    byte[] resultBuffer = new byte[bytesNum];

                    int i = 0;
                    while (i < bytesNum)
                    {
                        // 读取数据到缓冲区
                        int j = sp.Read(recviceBuffer, i, bytesNum - i);
                        i += j;
                    }
                    Array.Copy(recviceBuffer, 0, resultBuffer, 0, i);
                    ReceivedEvent(this, resultBuffer);
                    //System.Diagnostics.Debug.WriteLine("len " + i.ToString() + " " + ByteToHexStr(resultBuffer));
                }
                //Array.Clear (receivedBytes,0,receivedBytes.Length );
                receiveDatalen = 0;
            }
        }

后台接收消息的实现

上面是 flyfire.CustomSerialPort 的属性、字段和方法，Sp_DataReceived() 这个方法是实现后台监控数据，并触发预设事件的方法，开辟新线程不断循环接收数据。不过这里的实现并不那么好。

框架做者的博客 http://www.javashuo.com/article/p-nuxutmyp-kk.html

经过上面能够发现，这个监控方法是 protected 的，因此须要使用一个类继承，才能使用此方法。

另外，事件委托为

public delegate void CustomSerialPortReceivedEventHandle(object sender, byte[] bytes)

基于以上，来作一个能够后台接收数据并在控制台输出的代码。

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using flyfire.IO.Ports;
using RJCP.IO.Ports;

namespace SerialPortTest
{
    /// <summary>
    ///  用于封装须要的串口通信
    /// </summary>
    public class SerialSerice
    {
        //实现串口通信的对象
        串口通信 串口;
        /// <summary>
        /// 获取计算机的全部串口 步骤 1
        /// </summary>
        public void GetSerial()
        {
            string[] vs = 串口通信.GetPortNames();
            Console.WriteLine("你电脑的串口列表(输入名称此端口，注意大小写)：");

            foreach (var i in vs)
            {
                Console.WriteLine(i);
            }
        }
        //初始化串口 步骤 2
        public void 初始化(string portname)
        {
            串口 = new 串口通信(portname);
            串口.Open();
        }
        //向串口写入数据 步骤 3
        public void 写入(string str)
        {
            //方式 1
            串口.Write(str);
            Console.WriteLine("已经向串口输入：" + str);
            Thread.Sleep(500);
            //方式 二、3
            byte[] b_字符 = Encoding.Default.GetBytes(str);
            byte[] b_16进制 = new byte[b_字符.Length];

            //转16进制再发送
            Console.WriteLine("发送的16进制数据：");
            for (int i = 0; i < b_字符.Length; i++)
            {
                b_16进制[i] = Convert.ToByte(b_字符[i].ToString(), 16);
                Console.Write(b_16进制[i] + " ");
            }
            Console.WriteLine();
            //方式 二、3 写入串口
            串口.Write(b_字符);
            Thread.Sleep(500);
            串口.Write(b_16进制);
            Thread.Sleep(500);
        }
        public void 开启后台监听()
        {
            //收到消息时要触发的事件
            串口.ReceivedEvent += 被触发的事件_1;

            串口.开始后台监控();

        }
        public static void 被触发的事件_1(object sender, byte[] bytes)
        {
            Console.WriteLine("收到数据");
            foreach (var i in bytes)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine("");
        }

    }

    public class 串口通信 : CustomSerialPort
    {
        public 串口通信(string portName, int baudRate = 115200, Parity parity = Parity.None, int databits = 8, StopBits stopBits = StopBits.One)
            : base(portName, baudRate, parity, databits, stopBits)
        {

        }
        //无心义，只是由于父类的 Sp_DataReceived() 不是 public
        public void 开始后台监控()
        {
            
            Sp_DataReceived(new object(), new SerialDataReceivedEventArgs(SerialData.Eof));
        }
    }
}

using System;

namespace SerialPortTest
{
    class Program
    {
        static void Main(string[] args)
        {
            // 初始化串口通信服务
            SerialSerice 串口功能 = new SerialSerice();

            //显示串口列表、并让用户选择串口
            串口功能.GetSerial();
            string portname= Console.ReadLine();

            //步骤 2 
            串口功能.初始化(portname);
            串口功能.开启后台监听();
            Console.WriteLine("输入你想发送给客户端的内容,退出请输入 exit");
            //由于示例了三种写入方法，第三种方法须要转换，非数字会报错
            //实际上你能够发送如何类型的数据，就看你怎么写步骤 3 的方法
            Console.WriteLine("只能输入数字！8进制、10进制、16进制都可，请勿输入字符串");
            while (true)
            {
                string str = Console.ReadLine();
                if (str == "exit")
                    break;

                //步骤 3
                串口功能.写入(str);
            }

            Console.ReadKey();
        }
    }
}

为了实现串口通信，咱们把这个项目复制到别的目录，另外打开运行。即同一份代码变成两份，运行时就有两个控制台了。

注：你会发现，输入一条消息，会收到几条信息。那是由于笔者在写入方法那部分，给出了三个写入方式，删除2个便可。

为了便于理解，笔者使用了中文对方法进行命名。

串口通信已经已经实现了，如何实现 Modbus 协议，跟设备(单片机、开发板之类的小设备)进行约定通信呢~笔者的另外一篇文章~

项目源码已经上传到 http://pan.whuanle.cn/?dir=uploads/dotnet-core-串口

8，Modbus 协议的实现例子

因为时间和篇幅问题，这里简单说一下 Modbus 和实现的示例。

Modbus 是一种通讯协议，有 ASCII、RTU、TCP等实现方式，普遍应用于物联网设备、工业控制、自动化场景等。

协议的实现，由一台主机、多个从机组成，咱们把它想象成智能家居吧，一台电脑是主机，空调、电视机、冰箱等是从机。那么多设备，它们只能向主机发送数据，不能直接通信，每台设备都有其地址。

传输的数据流格式以下

(以上两张图来自互联网)

而后，我实现了Modbus协议，对要发送的消息进行检验、封装、打包成帧、接收、处理发送。

分为服务器、客户端。每一个客户端都有一个地址，下面示范，

我在服务器使用了 02 04 00 01 25 26，

表明：客户端地址02，功能码：04(表明要设备要干吗)，要读取设备的温湿度数据：00 01(00 02,00 03表明读取其余数据)，后面 25 26 有其余功能做用，不过笔者手里没有真实的设备，因此没对其进行实现，理解就行。

服务端向客户端(02)发送数据，功能是读取寄存器(04)，而后是读取温度数据仍是湿度数据(00 01 表明两个都读取)，25 26( 转为10进制为 9510 ) 能够定义为要客户端发返回 9510 条记录。

返回的2 4 0 1 25 26 BB 4B，后面两个是 CRC 检验，因为数据传输可能发送丢失或出错，使用后面两位因为检验数据是否正确接收。

上面是在控制台输入 16 进制的数，下面是直接输入 10 进制的数。

刚刚实习工做~愿一切顺利~~~

水平有限，文章有错请评论指出~谢谢啦~

.NET Core 跨平台 串口通信 ，Windows/Linux 串口通信，flyfire.CustomSerialPort 的使用

目录