串口通信之数据接收处理1

　　如果通信物理设备连接如下图1所示，即计算机有1到多个串口，而每个串口设备下仅仅挂载1个采集器，那么协议就没必要地址码，协议可以是：同步头 + 命令字 + 数据长度 + 数据正文 + 校验码。此时各个串口通信是互不相关的。        

             

       接收数据可以采用一个队列，每当串口有数据，就直接进入数据队列，另一边再出队列，试图查找一个完整的合法数据包。接收数据时的进出队可以在一个线程里执行；也可以在两个线程处理，但得同步队列。

       下面我贴出我的VC代码（进出数据队列在同一个线程）：

//MSComm控件消息

void CSSRRDlg::OnOnCommMscommRadio()

{

    int                        nEvent;

 

    nEvent    = m_msCom.GetCommEvent();

    switch(nEvent)

    {

    case 2:            //接收缓冲区有数据

           g_bCommDataRcv = true;     //为了控制数据接收线程

           break;

    case 3:

           break;

    default:

           break;

    }

}

每当串口接收缓冲区有数据时，触发g_bCommDataRcv = true告诉数据接收线程，可以读串口数据。

 

下面数据接收线程在开机或用户控制下启动，等待数据接收和处理。

UINT CSSRRDlg::FetchRadioComMsgThread(LPVOID p)

{    

       int                        i, flag=0;

       unsigned char  tmpQBuf[200];

       CSSRRDlg            *pThis = (CSSRRDlg *)p;

 

       BOOL                   bHead = FALSE;

       int                        Head;

       UINT                    iCount;

       int                        getLen;

       int                        f, r, len, max, tt;

 

       int                        test;

       while(pThis->rcvComData)   //一直成立，不停检测队列

       {

              if (pThis->nExitCode_Radio == 1)       //主线程控制此线程退出标识

              {

                     ::AfxEndThread(pThis->nExitCode_Radio);

              }

              //从串口读数据到队列--检测同步头

              if (pThis->g_bCommDataRcv)      //OnOnCommMscommRadio事件设置的标识

              {

                     pThis->ReadRadioCommData(pThis->hBuf);      //读串口缓冲区当前所有数据到全局(字节)队列

                     pThis->g_bCommDataRcv = false;

              }

              //检测同步头

              bHead = FALSE;

              getLen = 0;

              iCount = 0;

              int          bOne=TRUE;

 

              while (pThis->hBuf->GetLength() > 4)        //从全局数据队列hBuf查找一个完整的合法数据包

              {

                     len=pThis->hBuf->GetLength();   //

 

                     f = pThis->hBuf->front;

                     r = pThis->hBuf->rear;

                     max = pThis->hBuf->maxSize;

 

                     tt = (f+1)%max;

                    //验证数据包的同步头

　　　　　　   if (pThis->hBuf->GetElement(tt)==0x5D && pThis->hBuf->GetElement(tt+1)==0x5D             

                            && pThis->hBuf->GetElement(tt+2)==0x5D && pThis->hBuf->GetElement(tt+3)==0x02)

                     {

                            bHead = TRUE;

                            Head = tt-1;    //记录同步头front位置

                            iCount = 0;

                     }

 

                     //防止多个合法的数据包，只取最后一个-----包内又可能新同步头,重新计算

                     if (bOne && bHead)

                     {

                            if (pThis->hBuf->GetElement(Head+1+4)==0x01)     //命令字1

                            {

                                   getLen = 86;

                                   bOne = FALSE;

                            }

                            else if (pThis->hBuf->GetElement(Head+1+4)==0x54) //命令字2

                            {

                                   getLen = 7;

                                   bOne = FALSE;

                            }

                     }

                     if (iCount > (UINT)(getLen-1 -4))

                     {

                            if (pThis->hBuf->GetElement(Head+getLen)!=0x03)  //尾不对

                            {

                                   pThis->hBuf->DeSqueue(tmpQBuf, 4);       //剔除此次不完整包的同步头5d 5d 5d 02

                                   bHead = FALSE;

                                   iCount = 0;

 

                                   bOne = TRUE;

                                   pThis->hBuf->front = Head+4;           

                                   continue;

                            }

                            else  //包完整

                            {

                                   break;

                            }

                     }

 

                     iCount++;       //队列同步头检测移动了一步

                     pThis->hBuf->front++;

              }

              if (bHead && getLen)

              {

                     pThis->hBuf->front = Head;

                     memset(tmpQBuf, 0, sizeof(tmpQBuf));

                     if ( (test=pThis->hBuf->DeSqueue(tmpQBuf, getLen)) == getLen)　　//出接收数据队列

                     {

                            pThis->CheckRadioCommData(tmpQBuf, getLen);            //进一步检查数据合法性，并(通知界面)处理

                     }

                     else

                     {

                            Sleep(20);

                     }

              }

       }

       return 0;

}

 本程序把协议同步头 + 命令字 + 数据长度 + 数据正文 + 校验码中的校验码改成了同步尾，因为我的正文数据80字节，如果用CRC之类校验太耗时了。

上面代码的CheckRadioCommData函数就不贴了，涉及具体的业务处理，没必要贴出来。

//具体实现从串口m_msCom.GetInput数据

void CSSRRDlg::ReadRadioCommData(BtyeSqu *squ)

{

       VARIANT                    vResponse;

       int                        len, i;

       unsigned char  buf[200];

       COleSafeArray      Oledata;

       BYTE                   data[200];

 

       len =m_msCom.GetInBufferCount();          //获取串口接收缓冲区数据字节数

       if (len > 0)

       {

              vResponse = m_msCom.GetInput();     //读取缓冲区数据

              Oledata = vResponse;

              len = Oledata.GetOneDimSize();

 

              for(i=0; i<len; i++)

              {

                     Oledata.GetElement((long *)&i, data+i);

              }

              for(i=0; i<len; i++)

              {

                     char a = *(char *)(data+i);

                     buf[i] = (unsigned char)a;

              }

 

              //串口数据进入字符队列

              if( !squ->IsFull() )

              {

                     squ->EnSqueue(buf, len);

              }

       }

}

 

 

　　不使用用户自定义线程，而采用DataReceive事件，C#代码基本如下：

　　void comm_DataReceived(object sender, SerialDataReceivedEventArgs e)
        {
            if (Closing) return;//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环
            try
            {
                Listening = true;//设置标记，说明我已经开始处理数据，一会儿要使用系统UI的。
                int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致
                byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据
                received_count += n;//增加接收计数
                comm.Read(buf, 0, n);//读取缓冲数据

                /////////////////////////////////////////////////////////////////////////////////////////////////////////////
                //<协议解析>
                bool data_1_catched = false;//缓存记录数据是否捕获到
                //1.缓存数据
                buffer.AddRange(buf);
                //2.完整性判断
                while (buffer.Count >= 4)//至少要包含头（2字节）+长度（1字节）+校验（1字节）
                {
                    //请不要担心使用>=，因为>=已经和>,<,=一样，是独立操作符，并不是解析成>和=2个符号
                    //2.1 查找数据头
                    if (buffer[0] == 0xAA && buffer[1] == 0x44)
                    {
                        //2.2 探测缓存数据是否有一条数据的字节，如果不够，就不用费劲的做其他验证了
                        //前面已经限定了剩余长度>=4，那我们这里一定能访问到buffer[2]这个长度
                        int len = buffer[2];//数据长度
                        //数据完整判断第一步，长度是否足够
                        //len是数据段长度,4个字节是while行注释的3部分长度
                        if (buffer.Count < len + 4) break;//数据不够的时候什么都不做
                        //这里确保数据长度足够，数据头标志找到，我们开始计算校验
                        //2.3 校验数据，确认数据正确
                        //异或校验，逐个字节异或得到校验码
                        byte checksum = 0;
                        for (int i = 0; i < len + 3; i++)//len+3表示校验之前的位置
                        {
                            checksum ^= buffer[i];
                        }
                        if (checksum != buffer[len + 3]) //如果数据校验失败，丢弃这一包数据
                        {
                            buffer.RemoveRange(0, len + 4);//从缓存中删除错误数据
                            continue;//继续下一次循环
                        }
                        //至此，已经被找到了一条完整数据。我们将数据直接分析，或是缓存起来一起分析
                        //我们这里采用的办法是缓存一次，好处就是如果你某种原因，数据堆积在缓存buffer中
                        //已经很多了，那你需要循环的找到最后一组，只分析最新数据，过往数据你已经处理不及时
                        //了，就不要浪费更多时间了，这也是考虑到系统负载能够降低。
                        buffer.CopyTo(0, binary_data_1, 0, len + 4);//复制一条完整数据到具体的数据缓存
                        data_1_catched = true;
                        buffer.RemoveRange(0, len + 4);//正确分析一条数据，从缓存中移除数据。
                    }
                    else
                    {
                        //这里是很重要的，如果数据开始不是头，则删除数据
                        buffer.RemoveAt(0);
                    }
                }
                //分析数据
                if (data_1_catched)
                {
                    //我们的数据都是定好格式的，所以当我们找到分析出的数据1，就知道固定位置一定是这些数据，我们只要显示就可以了
                    string data = binary_data_1[3].ToString("X2") + " " + binary_data_1[4].ToString("X2") + " " +
                        binary_data_1[5].ToString("X2") + " " + binary_data_1[6].ToString("X2") + " " +
                        binary_data_1[7].ToString("X2");
                    //更新界面
                    this.Invoke((EventHandler)(delegate { txData.Text = data; }));
                }
                //如果需要别的协议，只要扩展这个data_n_catched就可以了。往往我们协议多的情况下，还会包含数据编号，给来的数据进行
                //编号，协议优化后就是： 头+编号+长度+数据+校验
                //</协议解析>
                /////////////////////////////////////////////////////////////////////////////////////////////////////////////

                builder.Clear();//清除字符串构造器的内容
                //因为要访问ui资源，所以需要使用invoke方式同步ui。
                this.Invoke((EventHandler)(delegate
                {
                    //判断是否是显示为16禁止
                    if (checkBoxHexView.Checked)
                    {
                        //依次的拼接出16进制字符串
                        foreach (byte b in buf)
                        {
                            builder.Append(b.ToString("X2") + " ");
                        }
                    }
                    else
                    {
                        //直接按ASCII规则转换成字符串
                        builder.Append(Encoding.ASCII.GetString(buf));
                    }
                    //追加的形式添加到文本框末端，并滚动到最后。
                    this.txGet.AppendText(builder.ToString());
                    //修改接收计数
                    labelGetCount.Text = "Get:" + received_count.ToString();
                }));
            }
            finally
            {
                Listening = false;//我用完了，ui可以关闭串口了。
            }
        }