串口数据处理

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO.Ports;
using System.Runtime.CompilerServices;
using System.Diagnostics;
using System.Threading;
using Util.Log;

namespace SerialLibrary
{
    public class SerialLib
    {
        #region Custom
        private bool running; //当前运行状态
        private SerialPort sp; //串口控件
        private long received_count, send_count; //发送总字节，接收总字节
        private byte[] Received; //所有接收数据的缓存
        private int received_offset; //当前缓冲存在空闲的位置
        private int cmd_offset; //已解出的命令的位置，下一个可用的开始位置
        const int BUF_SIZE = 512;
        const byte STX = 0x02; //STX
        const byte ETX = 0x03; //ETX
        private Dictionary<byte, WaitEvent> waitList;
        #endregion
        public SerialLib()
        {
            send_count = 0;
            received_count = 0;
            received_offset = 0;
            cmd_offset = 0;
            waitList = new Dictionary<byte, WaitEvent>();

            running = false;
            sp = new SerialPort();
            sp.ReadBufferSize = 512;
            sp.WriteBufferSize = 512;
            sp.BaudRate = 9600;
            sp.StopBits = StopBits.One;
            sp.DataBits = 8;
            sp.Parity = Parity.None;
            Received = new byte[BUF_SIZE];
            sp.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);
        }
        ///
        /// 命令等待回应
        ///
        class WaitEvent : IDisposable
        {
            public ManualResetEvent Event;
            public byte[] recv;
            public WaitEvent()
            {
                recv = null;
                Event = new ManualResetEvent(false);
            }
            public void Dispose()
            {
                recv = null;
                Event.Dispose();
                Event = null;
            }
        }
        /// 接收串口数据，取出有效命令，发到线程池待处理
        /// 整个方法加锁，防止多次进入接收影响全局变量的值。必须完成一次后才能再次进入接收
        [MethodImpl(MethodImplOptions.Synchronized)]
        private void sp_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (!running) return;
            SerialPort sp = (SerialPort)sender;
            int n = sp.BytesToRead;
            if (received_offset + n > BUF_SIZE) //数据包超大，放不下，只接收能放下的字节数
            {
                pack_received_buffer(); //压缩
                if (received_offset + n > BUF_SIZE) //压缩后仍不能接收的，减少接收空间
                {
                    n = BUF_SIZE - received_offset;
                }
            }
            received_count += n; //接收的总字节数
            byte[] buf = new byte[n];
            sp.Read(buf, 0, n);
            Array.Copy(buf, 0, Received, received_offset, n);
            received_offset += n; //移入后偏移
            Debug.WriteLine("接收位置-{0},命令位置-{1},接收总字节-{2},发送总字节-{3}", received_offset, cmd_offset, received_count, send_count);
            Debug.WriteLine("接收数据:" + dump_buffer(buf));


            //按协议中长度找协议末尾
            int datalen = get_int(Received, cmd_offset + 1, 2);
            int end_offset = cmd_offset + 3 + datalen; //结束符的位置
            end_offset = end_offset < received_offset ? end_offset : cmd_offset + 1; //防止超过当前已读字节，读到垃圾字节
            if (Received[end_offset] != ETX) return; //接收数据不完整，等待下次接收
            while (Received[end_offset] != ETX && end_offset < received_offset) end_offset++;
            if (end_offset == received_offset)
            {
                //如果找了超过256字节仍无有效内容，直接清空全部。单包数据应该不超过128
                if (end_offset > cmd_offset + 256)
                {
                    received_offset = 0;
                    cmd_offset = 0;
                }
                return; //没有找到结束符
            }

            end_offset++; //后移一字节，包插进 LRC校验值
            byte[] cmd_buf = new byte[end_offset - cmd_offset + 1];
            Array.Copy(Received, cmd_offset, cmd_buf, 0, cmd_buf.Length); //复制出一条完整的命令
            ThreadPool.QueueUserWorkItem(receive_serial_data, cmd_buf);
            cmd_offset = end_offset + 1; //跳过LRC，到下一条

            if (received_offset > BUF_SIZE * 0.85) //缓存位置超过85%。实际不太可能，除非受干扰全乱码
            {
                pack_received_buffer();
            }

        }
        private void receive_serial_data(object data)
        {
            byte[] cmd_buf = (byte[])data;
            Debug.WriteLine("处理数据:" + dump_buffer(cmd_buf));
            Log.Info("处理数据:" + dump_buffer(cmd_buf));
            byte lrc = cmd_buf[cmd_buf.Length - 1]; //取最后一字节，lrc
            if (lrc != calc_lrc(cmd_buf, 3, cmd_buf.Length - 2))
            {
                Debug.WriteLine("数据LRC校验失败，不处理");
            }

            byte cmdtype = cmd_buf[3];
            lock (waitList)
            {
                if (waitList.ContainsKey(cmdtype))
                {
                    int dlength = get_int(cmd_buf, 1, 2);
                    WaitEvent we = waitList[cmdtype];
                    if (dlength > 0)
                    {
                        we.recv = new byte[dlength + 5];
                        Array.Copy(cmd_buf, 0, we.recv, 0, dlength + 5); //如果有数据返回，包括命令类型一起返回
                    }
                    we.Event.Set();
                }
            }
        }
        ///
        /// 启动串口
        ///
        ///通卡模块所在的串口号
        ///
        public int Start(int port)
        {
            if (running) return 0; //已经打开过的，直接返回成功
            sp.PortName = string.Format("COM{0}", port);
            try
            {
                sp.Open();
                sp.DiscardInBuffer();
                sp.DiscardOutBuffer();
                running = true;
                Log.Info("通卡模块串口COM" + port.ToString() + "启动成功");
                return 0;
            }
            catch (Exception e)
            {
                Log.Error("启动串口失败: ", e);
                return 1;
            }
        }
        ///
        /// 关闭串口
        ///
        public void Stop()
        {
            if (running)
            {
                try
                {
                    if (sp.IsOpen) sp.Close();
                    Log.Info("通卡模块串口关闭成功");
                }
                catch (Exception e)
                {
                    Log.Error("串口关闭异常: ", e);
                }
                running = false;
            }
        }
        ///
        /// 发送串口命令
        ///
        ///命令类型
        ///发送数据
        ///接收数据。可能为 null
        ///0为处理成功， 3为无响应，其他为失败
        public int process(byte cmdType, byte[] data, out byte[] recvdata, int Wait)
        {
            recvdata = null;
            cmd_offset = 0;
            int dlength = data.Length;
            byte[] cmd = new byte[dlength + 6]; //1头长+2长度(bcd)+1命令长度(bcd)+4长度终端编号(bcd)+4长度表文流水号(bcd)+N长度报文+1尾长+1校验长
            int datalen = data.Length + 1;
            bcdstr_to_byte_array(datalen.ToString(), ref cmd, 1, 2);//设置数据长度两个字节
            cmd[0] = STX;
            cmdType = int2bcd(cmdType);
            cmd[3] = cmdType;
            Array.Copy(data, 0, cmd, 4, dlength);
            cmd[4 + dlength] = ETX;
            cmd[5 + dlength] = calc_lrc(cmd, 3, cmd.Length - 2);
            send_count += cmd.Length;
            Debug.WriteLine("发送命令:" + dump_buffer(cmd));
            Log.Info("发送命令:" + dump_buffer(cmd));
            try
            {
                sp.Write(cmd, 0, cmd.Length);
                if (Wait == 0) return 0; //不需要接收回复
                //等待回复，超时 Wait 秒
                WaitEvent we = new WaitEvent();
                lock (waitList)
                {
                    waitList[cmdType] = we;
                }
                DateTime dt = DateTime.Now;
                dt = dt.AddSeconds(Wait);
                while (!we.Event.WaitOne(50) && DateTime.Now < dt)
                {
                    Thread.Sleep(50);
                }
                if (!we.Event.WaitOne(1))
                {
                    lock (waitList)
                    {
                        waitList.Remove(cmdType);
                    }
                    Debug.WriteLine("命令超时，没收到回应");
                    return 3; //未收到响应
                }
                if (we.recv != null)
                {
                    recvdata = new byte[we.recv.Length];
                    Array.Copy(we.recv, recvdata, we.recv.Length);
                    Log.Info("接受命令:" + dump_buffer(recvdata));
                }
                lock (waitList)
                {
                    waitList.Remove(cmdType);
                }
                we.Dispose();
                we = null;
                return 0;
            }
            catch (Exception e)
            {
                Log.Error("串口处理异常: ", e);
                return 1;
            }
        }
        ///
        /// 整数转为bcd码， 12(dec) --> 0x12
        ///
        ///
        ///
        private byte int2bcd(int x)
        {
            x = (byte)x;
            return (byte)((x / 10 * 16) + x % 10);
        }
        ///
        /// bcd转为整数， 0x12 --> 12(dec)
        ///
        ///
        ///
        private int bcd2int(byte x)
        {
            return (x / 16 * 10) + (x % 16);
        }
        ///
        /// 将bcd字符串转换成字节数据，填充到指定位置的指定长度
        ///
        ///
        ///
        ///
        ///
        private void bcdstr_to_byte_array(string bcdstr, ref byte[] array, int Start, int Length)
        {
            int i = bcdstr.Length;
            int k = 0;
            byte x;
            string st;
            while (i > 0)
            {
                if (i > 1) st = bcdstr.Substring(i - 2, 2);
                else st = bcdstr.Substring(0, 1); //不是双字符对齐时，会剩下一个字符要转换
                if (!byte.TryParse(st, out x)) x = 0;
                array[Start + Length - k - 1] = int2bcd(x);
                k++;
                i -= 2;
            }
            while (Start + Length - k - 1 >= Start)
            {
                array[Start + Length - k - 1] = 0;
                k++;
            }
        }
        ///
        /// 压缩接收缓冲，使有效数据前移，空间后方空间
        ///
        private void pack_received_buffer()
        {
            //后续缓存空间不够，向前移动，覆盖前面已用过的空间
            byte[] swap = new byte[BUF_SIZE];
            Array.Copy(Received, cmd_offset, swap, 0, received_offset - cmd_offset);
            Array.Copy(swap, 0, Received, 0, received_offset - cmd_offset);
            received_offset = received_offset - cmd_offset;
            cmd_offset = 0;
        }
        private string dump_buffer(byte[] buffer)
        {
            StringBuilder sp = new StringBuilder(1024);
            int n = 0;
            foreach (byte x in buffer)
            {
                sp.AppendFormat("{0:X2}", x);
                n++;
                if (n > 512) break; //缓存有限，只处理最长512字节
            }
            return sp.ToString();
        }
        private int get_int(byte[] buffer, int Start, int Length)
        {
            int n = 0;
            StringBuilder strBuilder = new StringBuilder();
            for (int i = Start; i < Start + Length && i < buffer.Length; i++)
            {
                strBuilder.AppendFormat("{0:X2}",buffer[i]);
            }
            n = Convert.ToInt32(strBuilder.ToString());
            return n;
        }
        ///
        /// 计算LRC校验, xor异或
        ///
        ///
        ///
        ///
        /// 
        private byte calc_lrc(byte[] data, int Start, int End)
        {
            byte lrc = 0;
            int dlength = data.Length;
            for (int i = Start; i < End && i < dlength; i++)
            {
                lrc ^= data[i];
            }
            return lrc;
        }
    }
}