1.水平一般，不喜勿喷 

2.思路

将串口缓冲区的数据全部读出来，并做缓存，报文格式找到符合报文规范的一段数据，从缓冲区中取出这段数据

本文中1.首先查找是否同时包含报文头和报文尾，如果包含，2.找到第一个报文头字节和第一个报文尾字节，提取这两个字节中的数据，判断是否满足报文规范，如果满足，表示这是一条完整的报文，如果不满足 查找第二个个报文尾，3.重复步骤2直到不在包含报文尾或找到一条完整报文，4.如果查找到数据缓冲区最后还是没有找到完整报文或不在包含报文尾，则在数据缓冲区查找第二个报文头，并重复步骤2，3

3.本文中用到的报文格式

4.代码

        /// <summary>
        /// 包头
        /// </summary>
        private const byte _sof = 0xAA;

        /// <summary>
        /// 包尾
        /// </summary>
        private const byte _eof = 0x55;

           //var _buffer = new List<byte>() { 0xAA, 0x00, 0x08, 0x06, 0x00, 0x01, 0x12, 0x60, 0xCF, 0x55 };
                    var _buffer = new List<byte>() { 0xAA, 0x55, 0x55, 0x00, 0x08, 0x06, 0xAA, 0x55, 0xAA, 0x00, 0x08, 0x06, 0x00, 0x01, 0x12, 0x60, 0xCF, 0x55 };
                    if (_buffer.Contains(_sof) && _buffer.Contains(_eof))//包含包头和包尾
                    {
                        var tempMsg = new List<byte>();
                        var sofIndex = -1;
                        int sofIndexCache = 0;
                        var eofIndex = -1;
                        int eofIndexCache;
                        do
                        {
                            eofIndexCache = 0;
                            sofIndex++;
                            sofIndexCache += sofIndex;
                            sofIndex = _buffer.Skip(sofIndexCache).ToList().IndexOf(_sof);
                            if (sofIndex != -1)
                            {
                                eofIndex = sofIndex + sofIndexCache;
                                do
                                {
                                    eofIndex++;
                                    eofIndexCache += eofIndex;
                                    eofIndex = _buffer.Skip(eofIndexCache).ToList().IndexOf(_eof);
                                    if (eofIndex != -1)
                                    {
                                        if (eofIndex + eofIndexCache - sofIndex - sofIndexCache >= 7)//长度至少为8
                                        {
                                            var tempLen = new byte[2];
                                            Buffer.BlockCopy(_buffer.ToArray(), sofIndex + sofIndexCache + 1, tempLen, 0, tempLen.Length);
                                            var len = BitConverter.ToUInt16(tempLen.Reverse().ToArray(), 0);
                                            if (eofIndex + eofIndexCache - sofIndex - sofIndexCache - 1 == len)//校验长度
                                            {
                                                var crcData = new byte[len - 2];
                                                Buffer.BlockCopy(_buffer.ToArray(), sofIndex + sofIndexCache + 1, crcData, 0, crcData.Length);
                                                var crc = CRCHelper.CalcutateCRC(crcData);
                                                if (crc[0] == _buffer[eofIndex + eofIndexCache - 2] && crc[1] == _buffer[eofIndex + eofIndexCache - 1])//crc校验
                                                {
                                                    var res = new byte[eofIndex + eofIndexCache - sofIndex - sofIndexCache + 1];
                                                    Buffer.BlockCopy(_buffer.ToArray(), sofIndex + sofIndexCache, res, 0, res.Length);
                                                    _buffer = _buffer.Skip(eofIndex + eofIndexCache + 1).ToList();
                                                    foreach (var item in res)
                                                    {
                                                        Console.WriteLine(item);
                                                    }
                                                    Console.WriteLine("___________________");
                                                    foreach (var item in _buffer)
                                                    {
                                                        Console.WriteLine(item);
                                                    }
                                                    Console.ReadLine();
                                                }
                                            }
                                        }
                                    }
                                } while (eofIndex != -1);
                            }
                        } while (sofIndex != -1);
                    }
                    else
                    {
                        //
                    }

5.crc16检验算法

        /// <summary>
        /// 计算CRC16校验码
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] CalcutateCRC(byte[] data)
        {
            int crc = 0xFFFF;
            for (int n = 0; n < data.Length; n++)
            {
                byte i;
                crc ^= data[n];
                for (i = 0; i < 8; i++)
                {
                    int TT;
                    TT = crc & 1;
                    crc >>= 1;
                    crc &= 0x7FFF;
                    if (TT == 1)
                    {
                        crc ^= 0xA001;
                    }
                    crc &= 0xFFFF;
                }
            }
            return new byte[] { (byte)(crc & 0xFF), (byte)((crc >> 8) & 0xFF) };
        }

        /// <summary>
        /// 计算CRC16校验码
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] CalcutateCRC(List<byte> data)
        {
            return CalcutateCRC(data.ToArray());
        }

        /// <summary>
        /// 计算CRC16校验码
        /// 以空格隔开数据，数据格式为16进制
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] CalcutateCRC(string data)
        {
            string[] datas = data.Split(' ');
            List<byte> bytedata = new List<byte>();
            foreach (string str in datas)
            {
                bytedata.Add(byte.Parse(str, NumberStyles.AllowHexSpecifier));
            }
            return CalcutateCRC(bytedata);
        }