精华内容
下载资源
问答
  • 后来又需要调试UART串口,将MCU传输的协议数据分参数在桌面打印出来,这样应该利于第一时间检查协议数据每一个参数是否满足要求。 这个现有在串口调试助手中尽管可以打印,可以过滤,但是并不能满足自定义的个性要求...
  • a,监视计算机串口收发数据源码,对于串口使用Modbus_Rtu协议的通讯,可进行协议解析,即说明帧数据信息 b,监视计算机网卡指定端口数据,当前只监视了使用TCP或UDP协议数据。对Modbus_Tcp协议的通讯,可进行...
  • 串口数据协议解析

    万次阅读 2010-03-05 15:43:00
    接收来自串口数据解析,看起来是件容易的事情。而实际上,当协议变得复杂时,处理不好或者考虑不完善,会产生很多问题。 一般来说,通过串口传输的单个数据包都不会太大,否则,会导致数据被覆盖。对于通过串口...

    接收来自串口的数据并解析,看起来是件容易的事情。而实际上,当协议变得复杂时,处理不好或者考虑不完善,会产生很多问题。

     

    一般来说,通过串口传输的单个数据包都不会太大,否则,会导致数据被覆盖。对于通过串口传输的大数据,处理的办法是分割成多个小的数据包。可能出现的情况是因为接收和读取的不同步,接收到的数据需要分为多次读取,每次读取的单个数据包的一部分或者是一个数据包的后半部分和一个数据包的前半部分。另一种可能性是通过蓝牙或者红外等技术传输时,在数据流中加入了多余的数据。当传输的通道变得不可靠时,就需要引入一些冗余和机制来保证上层数据的正确性。

     

     

    解析数据的第一步是要从字节流中提取出一个完整的数据包,我在这里只是对如何抓取一个完整的数据包并解析记录一些思路。

     

    对于一个完整的数据包来说,必须要有可识别的部分。通常的识别方法是确定的前缀、后缀和数据结构。一般来说,前缀很好识别,而后缀,可能要结合数据结构来识别。

     

     

    使用一个队列来存储中间数据,思路如下:

    1. 如果队列非空;

       将队列中的数据取出,与新到达的数据合在一起,按照队列为空处理。

    2. 如果队列为空;

      扫描字节流:

          如果找到了前缀,则判断以该前缀开始的数据是否一个完整的数据包。如果是,则处理,并将该数据包的结尾作为新的扫描起点。如果找不到前缀,则将从该次扫描起点的所有数据压入队列。

     

     

     

     

     

     

     

     

    展开全文
  • 关于FPGA在解析带有数据包协议数据存储问题。FPGA先根据数据包协议接收数据并存储到RAM,在接收到完整一包数据后,将数据从RAM转移到FIFO中,后端的数据处理或者数据转发可以直接从FIFO读取。本代码模拟数据写入...
  • 本文介绍了利用C#接收串口数据(文本)并进行分析的标准过程。

    本文介绍了利用C#接收串口数据(文本)并进行分析的标准过程。

    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述

    展开全文
  • 本文介绍了利用C#接收串口数据(二进制)并进行分析的常规过程。

    本文介绍了利用C#接收串口数据(二进制)并进行分析的常规过程。

    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述

    展开全文
  • 协议解析-串口协议解析

    千次阅读 2015-11-24 21:48:19
    #define MU_IN_BF_LEN (150) #define MU_OUT_BF_LEN (150) ... //用于保存:从RX中断缓冲buffer中读出的数据 uint8_t outbuf[MU_OUT_BF_LEN]={0};//用于保存:提取出的一个完整帧 #define UART1_RX_RINGBUF_LEN

    #define MU_IN_BF_LEN (150)
    #define MU_OUT_BF_LEN (150)
    uint8_t inbuf[MU_IN_BF_LEN]={0};  //用于保存:从RX中断缓冲buffer中读出的数据
    uint8_t outbuf[MU_OUT_BF_LEN]={0};//用于保存:提取出的一个完整帧

    #define UART1_RX_RINGBUF_LEN    (250)
    static uint8_t uart1_rx_ringbuf[UART1_RX_RINGBUF_LEN]={0};
    static struct rt_ringbuffer uart1_rx_ringbuffer_controller={0};

    #define UART1_TX_RINGBUF_LEN    (250)
    static uint8_t uart1_tx_ringbuf[UART1_TX_RINGBUF_LEN]={0};
    static struct rt_ringbuffer uart1_tx_ringbuffer_controller={0};

    int init_uart1_link(void)
    {
     rt_ringbuffer_init(&uart1_rx_ringbuffer_controller,
          uart1_rx_ringbuf,
          UART1_RX_RINGBUF_LEN);
     
     rt_ringbuffer_init(&uart1_tx_ringbuffer_controller,
           uart1_tx_ringbuf,
           UART1_TX_RINGBUF_LEN);
     
     uart1_send_state=UART1_SEND_IDLE;

     return 0;
    }


    /*
    direct : 0->left move(low bytes out) ,1->right move(high bytes out)
    len    : move len                              */
    void buffShift(unsigned char *buf,int bufLen,unsigned char direct,int moveLen)
    {
     int i=0;
     if(direct==0)
     {//left move
      for(i=0;i<bufLen;i++) 
      {
       if(i+moveLen>=bufLen)
       {
        buf[i]=0;
       }
       else
       {
        buf[i]=buf[i+moveLen];
       }
      }
     }
     else
     {//right move
      for(i=bufLen-1;i>=0;i--) 
      {
       if(i-moveLen<0)
       {
        buf[i]=0;
       }
       else
       {
        buf[i]=buf[i-moveLen];
       }
      }
     }
    }

    /*
    start feed at buf[StartFeedAddr],StartFeedAddr++, total feedLen Bytes,
    cycle loop mode

    return :the real feed bytes ,should not over the DstbufMax;
    */
    uint16_t buffFeed(unsigned char *Dstbuf,
          unsigned char *Srcbuf,
          uint16_t StartFeedAddr,
           uint16_t feedLen,
           uint16_t DstbufMax
        )
    {
     uint16_t i=0;
     for(i=0;i<feedLen;i++)
     {
      Dstbuf[StartFeedAddr+i]=Srcbuf[i];
      if(StartFeedAddr+i>=DstbufMax)
      {
       return i;
      }
     }
     return 0;
    }

    /*
     brief: write one byte to the rx linkbuf

     input:
       databyte: UART1 rx reg data
     return:
       0:failed
       1:success
    */
    rt_inline int uart1_wr_rx_link_buffer(uint8_t *buf, int len)
    {  
     //return rt_ringbuffer_putchar(&uart1_rx_ringbuffer_controller,databyte);
     return rt_ringbuffer_put(&uart1_rx_ringbuffer_controller,buf,len);
    }

    /*
     brief: read data from rx link buffer
     input:
       len: bytes amount that want to read out
     output:
       buf: contain the read out datas
     return:
       the really read out bytes amount
    note:
      APP call this function to read UART1 rx datas

    */
    int uart1_rd_rx_link_buffer(uint8_t *buf,int len)

     return rt_ringbuffer_get(&uart1_rx_ringbuffer_controller,buf,(rt_uint16_t)len);
    }

    static int multi_parse_one_multi_frame(uint8_t *frame,int multi_len)
    {
     OS_ERR os_err;
     int j;
     int dlci;
     int len;
     uint8_t *ptr=NULL;

     //InfoPrintf("\r\n\r\n********************解析长度为%d的帧\r\n");
     //--------提取出一个完整帧--------------------
     #if 0
     InfoPrintf("解析长度为%d的帧:",multi_len);
     
     for(j=0;j<multi_len;j++)
     InfoPrintf("%02X",frame[j]); 
     InfoPrintf("\r\n");
     
     for(j=0;j<multi_len;j++)
     InfoPrintf("%c",frame[j]);
     InfoPrintf("\r\n");
     #endif
    }

    /* 
    brief: extract one frame from the ringbuffer

    input:
       buf    : wait for extract buf
       buf_len: wait buf`s len
     output:
       outbuf   : contain one right extracted multi frame if extract successful
       outbuf_len : out buffer len,if >0 : extract one frame ok
     return:
       -1  : out buf length is error
       others : need_shift_out_amount
    */
    int multi_extract_one_rx_frame(uint8_t *buf,   int inbuf_len,
              uint8_t *outbuf,int *outbuf_len,
              int outbuf_max_len,
              int *remain_len
             )
    {
     enum extract_multi_stp_t ems_extract_step=EMS_SEARCH_HEAD;
     int i=0;
     uint8_t info_len,outbuf_ptr=0;
     
     uint8_t rx_crc,counting_crc=0;
     //uint8_t add_f,ctl_f,len_f=0;

     int unuseful_amount=0;
     int need_shift_out_amount=0;
     
     //InfoPrintf("当前step=%d\r\n",ems_extract_step);
     
    /* InfoPrintf("内部读出\r\n");
     InfoPrintf("当前step=%d\r\n",ems_extract_step);
     InfoPrintf("将处理%d个字节:",inbuf_len);
     for(i=0;i<inbuf_len;i++)
     {
      InfoPrintf("%02X",buf[i]);
      //PrintHex(buf[i]);
     }
     InfoPrintf("\r\n");*/
     

     if(outbuf_max_len < 134 || inbuf_len==0)//(134=4+128+1+1) head,addr,control,length,infoMAX...,crc,tail
     {
      return -1;
     }

     for(i=0;i<inbuf_len;i++)
     { 
      if((ems_extract_step==EMS_SEARCH_HEAD)&&(buf[i]==EMS_HEAD))
      {
       info_len=0;
       outbuf_ptr=0;
       outbuf[outbuf_ptr++]=buf[i];
       ems_extract_step=EMS_SEARCH_ADDR_FIELD;
      }
      else if(ems_extract_step==EMS_SEARCH_ADDR_FIELD)
      {
       outbuf[outbuf_ptr++]=buf[i];
       ems_extract_step=EMS_SEARCH_CTL_FIELD;
       //add_f=buf[i];
      }
      else if(ems_extract_step==EMS_SEARCH_CTL_FIELD)
      {
       outbuf[outbuf_ptr++]=buf[i];
       ems_extract_step=EMS_SEARCH_LEN_FIELD;
       //ctl_f=buf[i];
      }
      else if(ems_extract_step==EMS_SEARCH_LEN_FIELD)
      {
       outbuf[outbuf_ptr++]=buf[i];
       ems_extract_step=EMS_SEARCH_INFO;
       //len_f=buf[i];
       
       info_len=buf[i]>>1;
       //InfoPrintf("消息体长度=%d\r\n",info_len);
      }
      else if(ems_extract_step==EMS_SEARCH_INFO)
      {
       outbuf[outbuf_ptr++]=buf[i];
       if(info_len)
       {
        if(info_len==1)
        {
         ems_extract_step=EMS_SEARCH_CRC;
        }
        info_len--;
       }
      }
      else if(ems_extract_step==EMS_SEARCH_CRC)
      {
       outbuf[outbuf_ptr++]=buf[i];
       
       ems_extract_step=EMS_SEARCH_TAIL;
       rx_crc=buf[i];
       counting_crc=mux_cal_fcs(outbuf+unuseful_amount+1,3);
       //InfoPrintf("校验码=%02X\r\n",counting_crc);
       if(rx_crc==counting_crc)// && rx_crc!=0x5F)//0xA9
       {
        //InfoPrintf("校验码正确=%02X\r\n",counting_crc);
       }
       else
       {
        //InfoPrintf("校验码错误,rx=%02X,count=%02X\r\n",rx_crc,counting_crc);
        ems_extract_step=EMS_SEARCH_HEAD;

        need_shift_out_amount=unuseful_amount+1;//+1:means shift out EMS_HEAD(0xF9)
        return need_shift_out_amount;
       }
      }
      else if(ems_extract_step==EMS_SEARCH_TAIL)
      {
       outbuf[outbuf_ptr++]=buf[i];
       if(buf[i]==EMS_TAIL)
       {
        ems_extract_step=EMS_SEARCH_HEAD;
        *outbuf_len=outbuf_ptr;
        
        need_shift_out_amount=unuseful_amount+outbuf_ptr;
        return need_shift_out_amount;
       }
       else
       {
        //TAIL ERROR
        ems_extract_step=EMS_SEARCH_HEAD;
        need_shift_out_amount=unuseful_amount+1;//+1:means shift out EMS_HEAD(0xF9)
        return need_shift_out_amount;
       }
      }
      else
      {//unuseful bytes
       unuseful_amount++;
      }
     }

     //all inbuf data has been pro

     if(unuseful_amount<inbuf_len)
     {
      *remain_len=inbuf_len-unuseful_amount;
      //InfoPrintf("======分析完毕,存在未完整的有效数据%d字节...=====\r\n",*remain_len);
      
      need_shift_out_amount=unuseful_amount;
      return need_shift_out_amount;
     }
     else
     {
      *remain_len=0;  
      //InfoPrintf("======分析完毕,无有效帧=====\r\n");
      
      need_shift_out_amount=inbuf_len;
      return need_shift_out_amount;
     }
    }

    //#define multi_pro_rx_data_print
    /*
    在main()中循环调用此函数:
    功能:
    读出RX中断的缓冲buffer里的数据,提取完整帧。
    提取出完整帧后,剩余的有效数据要保留在inbuf中,下一次从RX中断的缓冲buffer里读出的
    数据,将跟在上一次保留的数据后面.
    */
    int multi_pro_rx_data(void)
    {
     int inbuf_len;
     int outbuf_len;
     int shift_len=0;
     static int remain_len=0;//当剩余有效的数据,但未构成一个完整帧,需要下一次从ringbuffer
             //读取到后续的数据后,才能构成一个完整帧时,remain_len返回>0,
             //其他情况返回 0 !!!! 
     
     inbuf_len=uart1_rd_rx_link_buffer(inbuf+remain_len,MU_IN_BF_LEN-remain_len);

     if(inbuf_len>0)  
     {  
      inbuf_len+=remain_len;//本次读出+上次剩余
      
      #ifdef multi_pro_rx_data_print
      InfoPrintf("读取到+上次剩余,共%d字节有效数据:\r\n",inbuf_len);
      #endif
      while(1) 
      {
       #ifdef multi_pro_rx_data_print
       InfoPrintf("待处理%d字节:",inbuf_len);
       for(j=0;j<inbuf_len;j++)
       {
        InfoPrintf("%02X",inbuf[j]);
       } 
       InfoPrintf("=====\r\n");
       #endif
       
       outbuf_len=0;
       remain_len=0;
       shift_len=multi_extract_one_rx_frame(  inbuf,inbuf_len,outbuf,&outbuf_len,
                    MU_OUT_BF_LEN,
                    &remain_len//>0 表示:剩余不到一个完整帧的数据
                         //=0 表示:剩余超过一个完整帧的数据 或 剩余0字节 
                   );
       if(shift_len>=0)
       {
        if(outbuf_len>0)
        {//提取出完整帧
         multi_parse_one_multi_frame(outbuf,outbuf_len);
        }
        
        #ifdef multi_pro_rx_data_print
        InfoPrintf("左移--%d--字节\r\n",shift_len);
        #endif
        buffShift(inbuf,MU_IN_BF_LEN,0,shift_len);

        inbuf_len=inbuf_len-shift_len;

        if(remain_len>0 || inbuf_len<=0)
        {
         #ifdef multi_pro_rx_data_print
         InfoPrintf("处理完毕(剩余%d字节):",remain_len);
         for(j=0;j<remain_len;j++)
         {
          InfoPrintf("%02X",inbuf[j]);
         } 
         InfoPrintf("重新读取...\r\n\r\n\r\n"); 
         #endif
         
         break;
        }
        else
        {
         #ifdef multi_pro_rx_data_print
         InfoPrintf("左移后,剩余-%d-字节,继续处理...\r\n",inbuf_len);
         #endif
         
        }
       }
       else
       {
        InfoPrintf("MULTI参数错误!!!!\r\n");
        break;
       }  
      }
     }
     return 0;
    }

    展开全文
  • C 解析串口数据

    千次阅读 2019-07-09 17:07:52
    最近面试,收到一份面试题,特此研究下C的串口解析 题目要求如下: 用C语言写一个程序,此程序持续从串口读取数据(串口速率是115200,偶校验),串口数据有可能包含DL-T 645协议格式或者DL-T 698协议格式的数据帧...
  • 在IAR中用寄存器实现STM8S003串口通信,在接收中断中解析通信协议。通信协议为两位数据作为头,两位数据作为尾。数据长度为任意长。并且允许发送的数据可以和协议头尾数据相同。大大减小了误判和漏判的几率。
  • 2.主要解析及返回数据 使用说明: 1.主函数调用初始化函数wifi_buff_init() 2.串口中断调用add_message_queue() 3.主函数循环处理analyze_queue() 解释说明: 此协议固定协议长度为12 加密码0x03f7 4个帧...
  • 文本方式的数据比较容易分析。如果数据缓存,可以考虑用StringBuilder。或是不缓存也可以。文本格式数据大多有换行结尾。稍微修改即可。例如分析常见的NMEA 0183格式的卫星坐标数据GGA。 $GPGGA,121252.000,3937....
  • 一,android串口通信串口通信采用一个第三方开源项目,实现串口数据收发。1. 使用了http://code.google.com/p/android-serialport-api/的项目的serialport api和jni;2. 支持4串口同时收发,有定时自动发送功能,...
  • 串口通信协议简介:https://blog.csdn.net/Chen_qi_hai/article/details/96473076 串口通讯分层可以分: (1)物理层 用于支撑数据的传输:如发送和接收 (2)协议层 用于对传输的数据进行定义:如哪些字节...
  • C#串口文本协议解析

    千次阅读 2018-06-12 16:39:39
    https://blog.csdn.net/LSGO_MYP/article/details/60964974本文介绍了利用C#接收串口数据(文本)并进行分析的标准过程。 版权声明:本文为博主原创文章,未经博主允许不得转载。 ...
  • 1.一般自定义的串口协议  串口传输接口底层是按位(bit)发送的,上层是按byte发送和接收的,但协议为了方便描述,每个byte用十六进制数(0x00~0xFF)表示,范相当于十进制的0~255,而byte为八位且是有符号类型,...
  • 关于串口通信协议解析,该怎么解决 www.MyException.Cn 发布于:2012-01-22 22:38:43 浏览:184次 0 关于串口通信协议解析 帧头标志 版本号 类别 帧头校验和 帧号 数据总长度 保留 ...
  • 我们的串口程序,除了通用的,进行串口监听收发的简单工具,大多都和下位机有关,这就需要关心我们的通讯协议如何缓存,分析,以及通知界面。 我们先说一下通讯协议。通讯协议就是通讯双方共同遵循的一套规则,定义...
  • C# 串口操作系列(4) -- 协议篇,文本协议数据解析2010年06月09日 01:50:00阅读数:23821上一篇已经介绍了协议的组成,一个协议,一般具有 :协议头+长度+数据+校验 , 文本格式可以直观的定义回车换行是协议的结尾...
  • 串口数据读取解析

    2014-01-17 11:17:37
    c#,通过调用类函数来进行各种串口数据的操作与协议解析,经过大量使用、稳定可靠,希望对串口编写人员有所帮助。
  • 我们的串口程序,除了通用的,进行串口监听收发的简单工具,大多都和下位机有关,这就需要关心我们的通讯协议如何缓存,分析,以及通知界面。 我们先说一下通讯协议。通讯协议就是通讯双方共同遵循的一套规则,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 510
精华内容 204
关键字:

串口解析协议数据