精华内容
下载资源
问答
  • 基于32位MCU,解析GPS协议完整代码
  • 后来又需要调试UART串口,将MCU传输的协议数据分参数在桌面打印出来,这样应该利于第一时间检查协议数据每一个参数是否满足要求。 这个现有在串口调试助手中尽管可以打印,可以过滤,但是并不能满足自定义的个性要求...
  • 一个基于Qt的串口通信协议解析串口通信的程序,能实现串口的读写,和自定串口协议的解析,十分方便。
  • 串口协议解析方法

    2021-06-04 23:29:33
    这个逻辑就比较yani
    展开全文
  • 别找了,本人搜集的,史上最全,另外还有惊喜,长期积累的结果
  • 电子-基于STM32单片机的串口协议解析.zip,单片机/嵌入式STM32-F0/F1/F2
  • 自定义串口协议解析

    2020-07-22 13:21:01
    直接上代码 if (count == 0) { while (getUartData() != (bs[0] & 0xFF)) ; count = 1; } else if (count == 1) { read = getUartData(); if (read == (bs[0] & 0xFF)) ...} else if (c

    直接上代码

    if (count == 0) {
    	while (getUartData() != (bs[0] & 0xFF))
    		;
    	count = 1;
    } else if (count == 1) {
    	read = getUartData();
    	if (read == (bs[0] & 0xFF))
    		count = 1;
    	if (read == (bs[1] & 0xFF))
    		count = 2;
    	else
    		count = 0;
    } else if (count == 2) {
    	read = getUartData();
    	if (read == (bs[0] & 0xFF))
    		count = 1;
    	if (read == (bs[2] & 0xFF))
    		count = 3;
    	else
    		count = 0;
    } else if (count == 3) {
    	read = getUartData();
    	if (read == (bs[0] & 0xFF))
    		count = 1;
    	if (read == (bs[3] & 0xFF))
    		count = 4;
    	else
    		count = 0;
    } else if (count == 4) {
    	read = getUartData();
    	if (read == (bs[0] & 0xFF))
    		count = 1;
    	if (read == (bs[4] & 0xFF))
    		count = 5;
    	else
    		count = 0;
    } else if (count == 5) {
    	read = getUartData();
    	if (read == (bs[0] & 0xFF))
    		count = 1;
    	if (read == (bs[5] & 0xFF))
    		count = 6;
    } else if (count == 6) {
    	read = getUartData();
    	if (read == (bs[0] & 0xFF))
    		count = 1;
    	if (read == (bs[6] & 0xFF))
    		count = 7;
    }
    
    if (count == 7) {
    	count = 0;
    	Logcat.d(TAG, "send...");
    	mOutputStream.write(bs);
    }
    
    展开全文
  • 关于FPGA在解析带有数据包协议的数据存储问题。FPGA先根据数据包协议接收数据并存储到RAM,在接收到完整一包数据后,将数据从RAM转移到FIFO中,后端的数据处理或者数据转发可以直接从FIFO读取。本代码模拟数据写入...
  • 协议解析-串口协议解析

    千次阅读 2015-11-24 21:48:19
     //InfoPrintf("\r\n\r\n********************解析长度为%d的帧\r\n");  //--------提取出一个完整帧--------------------  #if 0  InfoPrintf("解析长度为%d的帧:",multi_len);    for(j=0;j;j++) ...

    #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;
    }

    展开全文
  • uart数据解析,针对串口通信的数据进行解析,每次读一个字节,首先寻找协议包头;中断调用或者while(1)调用;
  • android串口通信以及串口协议解析

    千次阅读 2017-05-26 10:59:43
    把之前在新浪博客里写的分享也备份移植到CSDN博客,之前本文博客地址是:...串口通信采用一个第三方开源项目,实现串口数据收发。 1. 使用了http://code.google.com/p/android-serialport-api/的项目的serialpor

    把之前在新浪博客里写的分享也备份移植到CSDN博客,之前本文博客地址是:http://blog.sina.com.cn/s/blog_14ed06d6c0102wqdm.html

    一,android串口通信
    串口通信采用一个第三方开源项目,实现串口数据收发。
    1. 使用了http://code.google.com/p/android-serialport-api/的项目的serialport api和jni;
    2. 支持4串口同时收发,有定时自动发送功能,收发模式可选Txt或Hex模式;
    3.  n,8,1,没得选;
    4. 为减轻界面卡顿的情况,接收区的刷新采用单独的线程进行定时刷新;
    5. 发送区的数据以及一些设置项,在程序关闭时会自动保存,打开时自动载入;
    6. jni使用最新的NDKr8b重新编译了一下


    简单编写步骤:
    1.新建一个项目,自己起个名字
    2.直接复制serialport api和jni文件夹到新建的工程,如果不想自己编译jni,就连libs文件夹也一起复制
    3.去android官方网站下载NDK,解压,在CMD中转到jni目录,并执行 绝对路径\ndk-build
    4.自己再封装一个工具类或直接使用SerialPort类都行,举个直接使用的例:
    直接剽窃原项目的SerialPortActivity.java,并稍微改一下,重点改这里
    mSerialPort = mApplication.getSerialPort();
    这里可以改成
    new SerialPort(new File("/dev/s3c2410_serial0"), 9600, 0);//COM0,波特率9600
    5. SerialPortFinder的使用就没什么好讲的了,实例化后用.getAllDevicesPath()就能获取到所有设备了。
    其它如数据转换等请参考源码


    源码可以参考谷歌android-serialport-api例子 
    http://code.google.com/p/android-serialport-api/source/checkout 
    svn checkout http://android-serialport-api.googlecode.com/svn/trunk


    二,串口通信协议解析
    1.通信基本格式
    字段 描述 长度(字节)
    起始符 0F,十六进制码  1
    信息类型 一个字节,十六进制码(0F,F0,FF等保留码不用)1
    信息长度 是信息内容的长度,ASCII码表示(0~9,A~F,最大长度为256)(例如长为11个,十六进制是0B,则两个字节就写0x30 0x42)。
    注:因为最大长度256不能满足有些指令的要求,所以对长度做了扩展,下面是扩展说明:
    如果第一个字节的最高位为1,则表示扩展长度。在扩展长度状态下,其他15个字节通过16进制大端模式来保存长度。比如:0x80 0x12表示长度为0x001 2,0x81 0x12表示长度为0x0112。2
    信息内容 一组十六进制码  N
    校验 一个字节,十六进制码,是自信息类型起至对象号止所有码的异或。1
    结束符 F0,一个字节,十六进制码 (为了保证可靠性,车机下发的结束符为F0 FF)1

    2.协议解析

     

    [java]  view plain  copy
    1.   
    2.     private class ReadThread extends Thread  
    3.   
    4.         @Override  
    5.         public void run()  
    6.             super.run();  
    7.   
    8.             // 定义一个包的最大长度  
    9.             int maxLength 2048 
    10.             byte[] buffer new byte[maxLength];  
    11.             // 每次收到实际长度  
    12.             int available 0 
    13.             // 当前已经收到包的总长度  
    14.             int currentLength 0 
    15.             // 协议头长度4个字节(开始符1,类型1,长度2)  
    16.             int headerLength 4 
    17.   
    18.             while (!isInterrupted())  
    19.                 try  
    20.                     available mInputStream.available();  
    21.                     if (available 0 
    22.                         // 防止超出数组最大长度导致溢出  
    23.                         if (available maxLength currentLength)  
    24.                             available maxLength currentLength;  
    25.                          
    26.                         mInputStream.read(buffer, currentLength, available);  
    27.                         currentLength += available;  
    28.                      
    29.                       
    30.                  
    31.                 catch (Exception e)  
    32.                     e.printStackTrace();  
    33.                  
    34.   
    35.                 int cursor 0 
    36.                 // 如果当前收到包大于头的长度,则解析当前包  
    37.                 while (currentLength >= headerLength)  
    38.                     // 取到头部第一个字节  
    39.                     if (buffer[cursor] != 0x0F 
    40.                         --currentLength;  
    41.                         ++cursor;  
    42.                         continue 
    43.                      
    44.                       
    45.                     int contentLenght parseLen(buffer, cursor, headerLength);  
    46.                     // 如果内容包的长度大于最大内容长度或者小于等于0,则说明这个包有问题,丢弃  
    47.                     if (contentLenght <= 0 || contentLenght maxLength 5 
    48.                         currentLength 0 
    49.                         break 
    50.                      
    51.                     // 如果当前获取到长度小于整个包的长度,则跳出循环等待继续接收数据  
    52.                     int factPackLen contentLenght 5 
    53.                     if (currentLength contentLenght 5 
    54.                         break 
    55.                      
    56.   
    57.                     // 一个完整包即产生  
    58.                     // proceOnePacket(buffer,i,factPackLen);  
    59.                     onDataReceived(buffer, cursor, factPackLen);  
    60.                     currentLength -= factPackLen;  
    61.                     cursor += factPackLen;   
    62.                  
    63.                 // 残留字节移到缓冲区首  
    64.                 if (currentLength 0 && cursor 0 
    65.                     System.arraycopy(buffer, cursor, buffer, 0currentLength);  
    66.                  
    67.              
    68.          
    69.      
    70.   
    71.       
    72.     public int parseLen(byte buffer[], int index, int headerLength)  
    73.   
    74. //      if (buffer.length index headerLength) return 0; }  
    75.         byte buffer[index 2];  
    76.         byte buffer[index 3];  
    77.         int rlt 0 
    78.         if (((a >> 70x1== 0x1 
    79.             rlt (((a 0x7f<< 8b);  
    80.          
    81.         else  
    82.             char[] tmp new char[2];  
    83.             tmp[0(chara;  
    84.             tmp[1(charb;  
    85.             String new String(tmp, 02);  
    86.             rlt Integer.parseInt(s, 16);  
    87.          
    88.   
    89.         return rlt;  
    90.      
    91.   
    92. protected void onDataReceived(final byte[] buffer, final int index, final int packlen)  
    93.         System.out.println("收到信息");  
    94.         byte[] buf new byte[packlen];  
    95.         System.arraycopy(buffer, index, buf, 0packlen);  
    96.         ProtocolAnalyze.getInstance(myHandler).analyze(buf);   
    97.     }  

    展开全文
  • UART串口通讯协议解析

    万次阅读 2021-02-26 11:44:04
    UART串口通讯协议解析概述接口通信协议 概述 通用异步收发传输器(Universal Asynchronous Receiver/Transmitter),通常称作UART。它将要传输的资料在串行通信与并行通信之间加以转换。作为把并行输入信号转成串行...
  • vc串口数据解析

    2018-01-22 16:05:26
    串口数据解析,vc读取串口数据,获取完整数据包并解析出其中数据 抱歉,上传时默认了下载所需积分,之后不能编辑,下载了的可以联系我返还部分积分
  • 10X串口协议解析

    2019-01-18 11:28:02
    10X串口协议解析 1、串口协议解析 首先所有命令都要带传感器地址,一般传感器的地址都是1,所以如果没有修改修改传感器地址的话,那么命令的前面都是01(16进制),最大地址是127,即是7F。 常用命令 1、获取传感器...
  • 协议解析串口调试助手

    千次阅读 2019-08-11 20:42:03
    ①每次打开软件自动扫描可用串口并添加到串口名列表中,也可在菜单”串口基本设置”里手动刷新串口列表. ②波特率提供了9600和115200两个常用选项. ③可调节 数据位(8,7)、校验位(无,奇,偶)、停止位(1,2) ...
  • C#可以制作 解析串口接收数据 的工具吗?有没有实例可以参考?
  • 串口编程 - 通信协议解析 规定了串口通信协议之后,接下来就是如何解析通信协议
  • C#串口文本协议解析

    千次阅读 2018-06-12 16:39:39
    https://blog.csdn.net/LSGO_MYP/article/details/60964974本文介绍了利用C#接收串口数据(文本)并进行分析的标准过程。 版权声明:本文为博主原创文章,未经博主允许不得转载。 ...
  • 串口协议包的接收及解析处理

    千次阅读 2020-03-10 15:34:07
    串口协议包的接收及解析处理 串口是单片机应用中应用最多的外设之一。很多电子硬件都会提供串口,如蓝牙模块、WIFI模块、串口屏等。如果我们想开发基于串口通信的产品或使用基于串口通信的电子硬件时,都避不开通信...
  • 376.2协议解析软件

    2018-09-26 09:54:36
    DLT376.2协议解析软件,里面有解析的软件,另外有东软的376.2的工具,串口选择小于5的口,如果你的串口号大于这个,在属性里面改下,另外注册的话用管理员身份运行东软的软件。只是软件,不是源码,主要是这个上面要...
  • 在IAR中用寄存器实现STM8S003串口通信,在接收中断中解析通信协议。通信协议为两位数据作为头,两位数据作为尾。数据长度为任意长。并且允许发送的数据可以和协议头尾数据相同。大大减小了误判和漏判的几率。
  • 通过C#实现串口通信,里面的代码展示了如何监听计算机中的串口解析数据或者发送数据,做串口开发的可以参考
  • 串口变长协议解析案例 解析的关键方法直接看SerialControl.java类即可! (为毛这么短的README?因为我编辑了半天的文章一下子就没!) ======================================================== 补上文章链接: ...
  • 摘要:文中详细介绍了PS/2接口协议的内容、电气特性和标准键盘的第二套键盘扫描码集。给出了基于嵌入式系统的PS/2接口的软、硬件实现方法,并介绍了工控PC外接双键盘的解决方案。通过使用模拟开关CD4052巧妙地解决了...
  •  //<协议解析>  //因为恢复的代码在finally中。你可以直接的return   if(line[0] != '$') return;//虽然可能有点垃圾,但是数据不重要。直接丢弃就可以了。后续的都是对的  int star = line....
  • dlt645-2007电能表协议解析源码+串口编程源码,利用串口编程直接与电能表通信,Java源码

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,539
精华内容 14,615
关键字:

串口协议解析

友情链接: changgou_parent.rar