精华内容
下载资源
问答
  • 串口协议解析

    2020-09-25 18:05:13
    C#可以制作 解析串口接收数据 的工具吗?有没有实例可以参考?
  • 10X串口协议解析

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

    10X串口协议解析

    1、串口协议解析
    首先所有命令都要带传感器地址,一般传感器的地址都是1,所以如果没有修改修改传感器地址的话,那么命令的前面都是01(16进制),最大地址是127,即是7F。
    常用命令
    1、获取传感器ID信息4个字节:0x0181(01是传感器地址,8固定,1是指获取传感器ID的代码)
    返回值16个字节:
    – device type(2个字节,设备类型)
    – modification(2个字节,版本)
    – serial number(4个字节,序列号)
    – max distance(4个字节,起始量程)
    – range(4个字节,量程)

    例子:
    设备类型是:65,版本是00;
    序列号是:0402;
    起始量程是:300;
    量程是:25;
    那么其返回值就是:
    91h, 94h (设备类型);
    90h, 90h (版本);
    92h, 99h, 91h, 90h (序列号);
    9Ch, 92h, 91h, 90h (起始量程);
    99h, 91h, 90h, 90h (量程)。
    每个字节只取后面4位的数,然后再组成16进制的数,再转换成10进制就可以了
    91h, 94h:就取1和4,根据传感器返回来数据是先低位再高位,所以就组成0x41,换成10进制就是65
    同理:90h, 90h就是0x00,换成10进制就是0,92h, 99h, 91h, 90h就是0x0192,换成10进制就是402,9Ch, 92h, 91h, 90h就是0x012C,换成10进制就是300,99h, 91h, 90h, 90h就是0x19,换成10进制就是25

    2、
    获取测量结果有两种方式,一种是慢速测量(每发一次慢速测量命令就得到一个测量结果),一种是快速测量(发送一次快速测量命令,传感器连续不断的上来测量结果,直接你发停止快速测量命令),但两种方式得到的测量数据都要通过一个公式来获取测量结果,该公式就是:X=D*S/16384 (mm),其中X是指测量结果,单位是mm,D是指传感器上来的数据,S是指传感器量程,16384是指传感器的分辨率(常数,固定不变)
    (1)慢速测量4个字节:0x0186(01是传感器地址,8固定,6是指让传感器启动慢速测量的代码)
    返回值4个字节:
    B5h, BAh, B2h, B0h,那么其组成的值就是0x02A5,那么测量值就为:
    X=677(02A5h)*25/16384=1.033mm

    注意:每次读取到测量值时,需要比较每个字节的高4位是不是一样,像B5h, BAh, B2h, B0h这4个字节的前面4位都是B,那么该测量值就是有效值。如果像A5h, BAh, B2h, B0h这种,那么这个值就不对,去掉。

    (2)同理,快速测量也是4个字节,0x0187(01是传感器地址,8固定,7是指让传感器启动快速测量的代码),0x0188就是停止快速测量命令(01是传感器地址,8固定,7是指让传感器启动慢速测量的代码)
    发了0x0187命令,传感器就会不连续不断的上来测量值,我们就必须每4个组成一个值来获取测量结果。

    例子:
    C5 CA C2 C0 D5 DA D2 D0 E5 EA E2 E0 F5 FA F2 F0 C5 CA C2 C0……
    我们每4个字节的数组成一起,再判断是否是同一个测量值就可以了,如果不是则丢掉,其校验位是C,D,E,F这样轮换

    修改参数命令慎用,一般我们传感器发货过去,参数都已设置好,不需要再设置,所以下面的命令如无必要请不要乱设置
    3、修改参数命令
    0x0183(01是传感器地址,8固定,3是指让传感器修改参数代码),详细命令请看ZLDS100硬件使用说明(38页)
    (1)修改波特率(代码04h),其值从1-192之间,每个值代表2400的增量
    例:
    修改波特率为9600,那么我们只需要把值设成4(16进制为04),那么其代表的波特率就为:4*2400=9600,命令如下:
    0183 8480 8480

    (2)修改采样周期(代码低位08h,高位09h),其值由两个字节组成,而且每个值代表0.01ms
    例:
    修改采样周期为50,那么我们只需要把值设成50(16进制为0032),那么其代表的采样周期就为50*0.01=0.5ms,命令如下:
    低位:0183 8880 8283
    高位:0183 8980 8080

    4、把修改的参数写入闪存(如果没有发送该命令,那么修改的参数在传感器断电后会回复修改前的设置)
    0184 8a8a
    请慎用该命令,防止写入闪存,导致通讯不上的状况
    使用外部触发模式的方法:
    (1)接线;需要给传感器提供5V的TTL方波脉冲,传感器白线接脉冲正,传感器灰线接脉冲地;
    (2)参数设置:
    测量模式:018382808180
    采样周期:
    低位:018388808180
    高位:018389808080

    展开全文
  • 电子-基于STM32单片机的串口协议解析.zip,单片机/嵌入式STM32-F0/F1/F2
  • 协议解析-串口协议解析

    千次阅读 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;
    }

    展开全文
  • 自定义串口协议解析

    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);
    }
    
    展开全文
  • 一,android串口通信串口通信采用一个第三方开源项目,实现串口数据收发。1. 使用了http://code.google.com/p/android-serialport-api/的项目的serialport api和jni;2. 支持4串口同时收发,有定时自动发送功能,...

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

    转载于:https://www.cnblogs.com/cliuwei/p/5799915.html

    展开全文
  • 基于32位MCU,解析GPS协议完整代码
  • 别找了,本人搜集的,史上最全,另外还有惊喜,长期积累的结果
  • 本文介绍了利用C#接收串口数据(文本)并进行分析的标准过程。
  • 本文介绍了利用C#接收串口数据(二进制)并进行分析的常规过程。
  • 串口协议解析

    2013-06-26 11:35:05
    这些也就是串口协议当中所包含的一些内容。所以为了更好地了解一些接口串口协议标准我们就来对这类问题进行一下详细的介绍。 串口协议插口种类及转换 串口协议是一种接口标准,它规定了接口的电气标准,简单说...
  • ROS串口通信协议解析

    2020-08-12 11:27:04
    ROSserial 串口通信协议解析 1. 总览 ROS-serial是用于包装标准ROS序列化消息并在外部设备(例如串行端口或网络套接字)上多路复用多个主题和服务的协议。 2. 局限性 这里定义了发布主题消息的最大大小,发布者/订阅...
  • C#串口文本协议解析

    千次阅读 2018-06-12 16:39:39
    https://blog.csdn.net/LSGO_MYP/article/details/60964974本文介绍了利用C#接收串口数据(文本)并进行分析的标准过程。 版权声明:本文为博主原创文章,未经博主允许不得转载。 ...
  • 串口通信指串口按位(bit)发送和接收字节。尽管比按字节(byte)的并行通信慢,但是串口可以在使用一根线发送数据的同时用另一根线接收数据。物理接口标准1.串行通信接口的基本任务(1)实现数据格式化:因为来自CPU的是...
  • 在IAR中用寄存器实现STM8S003串口通信,在接收中断中解析通信协议。通信协议为两位数据作为头,两位数据作为尾。数据长度为任意长。并且允许发送的数据可以和协议头尾数据相同。大大减小了误判和漏判的几率。
  • vb串口通信协议解析

    2015-06-13 14:51:06
    2,回复给我的代码“AA 12 40 00 43 44 10 00 00 AA AA 06 AF 10 00 00 AA xx 6F 55 73 55 ”,然后对这个xx进行解析。 主发 AA 为起始帧 10 00 00 AA 为表ID, 0x2F 为指令码,只用于测试 接收: xx 为测试结果 ...
  • a,监视计算机串口收发数据源码,对于串口使用Modbus_Rtu协议的通讯,可进行协议解析,即说明帧数据信息 b,监视计算机网卡指定端口数据,当前只监视了使用TCP或UDP协议的数据。对Modbus_Tcp协议的通讯,可进行...
  • 串口协议包的接收及解析处理

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

    2013-10-15 12:58:47
    开始“{” + 数据长度 + 数据内容 + 回应命令(1未通过,0为不通过) +校验位+结尾”}“ 请问如何解析这条命令,要将回应命令取出来 拜托各位了!急求!!!!!!!
  • 最近做了几个机型的售货机以及自动贩卖机相关的串口通讯协议对接,包括ADH815、新众聚联标准通信协议TF-SCP 等,如果有需要的可以联系我...
  • 串口的数据协议解析

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

空空如也

空空如也

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

串口协议解析