串口通用帮助类 SerialPortHelper

Demo

private readonly SerialPortHelper _spHelper;
ctor()
{
    _spHelper = new SerialPortHelper();
    _spHelper.DataReceivedEvent += SerialPort_DataReceivedEvent;
    _spHelper.Close();
    if (_spHelper.Init("COM1"))
    {
        _spHelper.SetStartIdentifier(new byte[] { 0xFA, 0xFA });
        _spHelper.SetEndIdentifier(new byte[] { 0xFB, 0xFB });
    }
    _spHelper.WriteXORCheck(command, WatchdogIdentifiers.读取数据);
}
private void SerialPort_DataReceivedEvent(object sender, EventArgs e)
{       
    if (e is CustomSerialPortEventArgs arg)
    {
        var data = arg.Message;
        if (_spHelper.DataXORCheck(data))
        {
            switch (data[1])
            {
                case (byte)WatchdogIdentifiers.设置数据:
                    {
                    }
                    break;
                case (byte)WatchdogIdentifiers.读取数据:
                    {
                    }
                    break;
            }
        }
    }
}

/// <summary>
/// 看门狗的通信标识
/// </summary>
internal enum WatchdogIdentifiers
{
    /// <summary>
    /// 1_1
    /// </summary>
    [Description("1")]
    设置数据 = 1,

    /// <summary>
    /// 1_2
    /// </summary>
    [Description("2")]
    读取数据 = 2,
}

SerialPortHelper

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO.Ports;


/// <summary>
/// 串行端口通信帮助类(有帧头、帧尾检测)
/// </summary>
internal class SerialPortHelper
{
    private readonly WeakEvent<EventArgs> _dataReceivedEvent = new WeakEvent<EventArgs>();

    /// <summary>
    /// 返回的消息数据弱事件
    /// </summary>
    public event EventHandler<EventArgs> DataReceivedEvent
    {
        add => _dataReceivedEvent.Add(value, value.Invoke);
        remove => _dataReceivedEvent.Remove(value);
    }

    public bool IsOpen => _serialPort != null && _serialPort.IsOpen;

    private CustomSerialPort _serialPort;

    /// <summary>
    /// 设置结尾标识符
    /// </summary>
    /// <param name="end"></param>
    public void SetEndIdentifier(byte[] end)
    {
        if (_serialPort != null)
        {
            _serialPort.EndIdentifier = end;
        }
    }

    /// <summary>
    /// 设置开始标识符
    /// </summary>
    /// <param name="start"></param>
    public void SetStartIdentifier(byte[] start)
    {
        if (_serialPort != null)
        {
            _serialPort.StartIdentifier = start;
        }
    }

    /// <summary>
    /// 延迟接收数据。
    /// 默认不设置帧头、帧尾，根据实际情况判断数据完整性！
    /// </summary>
    /// <param name="millionsecond">默认500(ms)</param>
    public void SetDelayDataReceived(int millionsecond = 500)
    {
        if (_serialPort != null)
        {
            _serialPort.StartIdentifier = null;
            _serialPort.EndIdentifier = null;
            _serialPort.DelayRecived(millionsecond);
        }
    }

    public bool Init(string portName, int baudRate = 9600, Parity parity = Parity.None, int dataBits = 8, StopBits stopBits = StopBits.One)
    {
        try
        {
            _serialPort = new CustomSerialPort(portName, baudRate, parity, dataBits, stopBits);
            _serialPort.DataReceivedEvent += SerialPort_DataReceivedEvent;
            return _serialPort.IsOpen;
        }
        catch (Exception ex)
        {
            LogFactory.GetInstance().Info(ex.Message);
        }
        return false;
    }

    /// <summary>
    /// 串口数据写（带数据异或校验）
    /// </summary>
    /// <param name="data"></param>
    /// <param name="identifier">通信标识</param>
    /// <param name="version">版本</param>
    public void WriteXORCheck(byte[] data, WatchdogIdentifiers identifier, int version = 1)
    {
        if (IsOpen)
        {
            // 通信命令格式： 起始符(FA FA) + 版本 + 通信标识 + 数据长度(mod 255) + 数据内容(DATA) + 数据校验 + 结束符(F5 F5)
            int len = data.Length % 255;
            byte xor = WSCommFunc.GetXOR(data);
            List<byte> tmp = new List<byte>(data.Length + 4) { (byte)version, (byte)identifier, (byte)len };
            tmp.AddRange(data);
            tmp.Add(xor);

            _serialPort.WritePort(tmp.ToArray());
        }
    }

    /// <summary>
    /// 获取的数据异或校验
    /// </summary>
    /// <param name=""></param>
    /// <returns>true校验成功</returns>
    public bool DataXORCheck(byte[] data)
    {
        // 数据格式： 版本 + 通信标识 + 数据长度(mod 255) + 数据内容(DATA) + 数据校验
        int length = data.Length;
        if (length <= 4)
        {
            return false;
        }
        // 长度不一致，异常数据
        if (data[2] != length - 4)
        {
            return false;
        }
        byte[] temp = new byte[length - 4];
        Array.Copy(data, 3, temp, 0, length - 4);
        byte xor = WSCommFunc.GetXOR(temp);
        return xor == data[length - 1];
    }

    /// <summary>
    /// 串口数据写
    /// </summary>
    /// <param name="data"></param>
    public void Write(byte[] data)
    {
        if (IsOpen)
        {
            _serialPort.WritePort(data);
        }
    }

    /// <summary>
    /// 串口数据写
    /// </summary>
    /// <param name="data"></param>
    public void Write(string data)
    {
        if (IsOpen)
        {
            _serialPort.WritePort(data);
        }
    }

    public void Close()
    {
        if (_serialPort != null)
        {
            _serialPort.DataReceivedEvent -= SerialPort_DataReceivedEvent;
            _serialPort.Close();
            _serialPort = null;
        }
    }

    private void SerialPort_DataReceivedEvent(object sender, EventArgs e)
    {
        _dataReceivedEvent.Invoke(this, e);
    }
}

其中，CustomSerialPort是一般串口通信的基本功能，可自行实现。