瑞萨单片机论坛
直播中

jf_1137202360

8年用户 1359经验值
擅长:嵌入式技术
私信 关注
[经验]

【RA4M2设计挑战赛】+网关设计

前言
前面我们详细介绍从0开始搭建开发环境，不使用fsp等而是从0开始的原因就是，希望从0开始搭建一个清爽简洁的环境，抛去不必要的干扰，以便更容易理解。介绍了如何根据手册直接配置寄存器进行LED,时钟,Systick定时器等的配置，并实现了比较好用的串口驱动。我们使用串口驱动作为第一条主要使用的通讯链路，后面WIFI,蓝牙模块都可以基于此。
后面再逐渐完善USB,CAN等通讯链路,IIC外设,SPI外设等各模块信号的采集。目前先完成框架搭建，设计一个完备的通讯协议,暂时先实现按键信号的采集,LED的控制,实现上位机的Demo,通过串口与上位机通讯实现上位机显示按键状态和控制LED，实现一个基本的网关的框架，也就是完成主体构建，后面就是装修的事了(添加温湿度等等传感器支持)。

所以有几条路径
开发板->串口->PC->服务器
开发板->串口->蓝牙WIFI->服务器->移动端
开发板->串口->蓝牙WIFI->移动端->服务器
目前先实现第一条路径,后面无非就是添加蓝牙wifi的路径而已。
只要设计好协议,能兼容任意个数的任意类型的传感器与执行构建的采集与控制即可，
不管直接走串口还是蓝牙wifi本质都是只是一条通讯链路不同而已。
通讯协议设计
该协议具有能伸缩,可扩展,自适应,效率高,可靠性高的特点。
1. 可支多个类型,每个类型多个数量的子块. 每一个子块的内容代表一项数据,可以是一个部件也可以是一条指令也可以是其他数据.数据长度不定长,只传输需要的数据.
2. 多种类型的数据格式统一,比如部件的数据和设备的配置数据等数据都采用统一的格式.通过帧类型区分.
3. 数据有校验能保证数据正确性.
协议格式如下:
字节
2
2
1
1
1
1
n
1
1
1
m
1
含义
开始标志
总长度
帧类型
子块1长度
子块1类型
子块1
子类型
子块1
内容
子块2长度
子块2类型
子块2
子类型
子块2
内容
......
累加和
内容
AA55
xx
xx
xx
xx
xx
xx
xx
xx
xx
xx
xx
xx
标志
长度
帧类型
子块1
子块2
子块i
累加和
l 开始标志:2字节,BYTE[0]=0xAA BYTE[1]=0x55
l 总长度:2字节,大端序,包括整个数据包的长度(标志+长度+子块1+...+子块i+累加和)
l 帧类型: 0代表上位机发给设备的数据 1代表计算机发给设备的命令 2代表设备发送给上位机的数据,其他值预留扩展使用.
不同帧类型字块n的内容的含义也不同.
l 子块  可以任意子块组合
子块长度:1字节,子块的所有长度=子块长度+子块类型+子块子类型+子块内容
子块类型:1字节按下表定义:
部件
子块类型/设备编号
LED
1
按键
2
温湿度
3
空气质量
4
开关
5
...
0-其他值保留扩展使用
...
子块子类型:1字节,对于一个类型有多个的数据,该字段表示数据的序号 从0开始计数。
子块内容: x字节,根据不同的数据类型具体的意义不一样. 对不同的部件进行了抽象,具备通用性.
l 累加和:
前面所有数据的无符号8位累加和。
协议解析与上位机
串口接收到任意长度数据则调用pc_protocol_handle进行处理,先将数据存储到缓冲区，然后按照协议进行头的搜查，长度的匹配校验和的匹配，只有获取完整的一帧才进行处理，如果未找到有效帧则丢掉头继续往后搜索重复之前过程。
处理过程考虑到了帧可能会丢数,不完整，长度错误，校验错误等各种情况，设计健壮。
发送数据则参考pc_protocol_apendbuffer
核心协议处理代码见
  1. #define READ_BUFF_MAX 256   /*读一次串口大小*/

  3. #define READ_TIMEOUT 10   /*读一次串口超时时间*/



  7. #define FRAME_MINI_SIZE 6   /*一帧数据最小长度*/

  9. #define FRAME_HEAD_SIZE 5   /*帧头长度*/

  11. #define FRAME_BUFF_MAX 512  /*帧处理缓冲区大小*/



  15. #define HEAD_FLAG1 0xAA

  17. #define HEAD_FLAG2 0x55



  21. static uint32_t rcvsum=0;

  23. static uint32_t rcvnum=0;

  25. static uint8_t s_framebuff_au8[FRAME_BUFF_MAX];   /*帧处理缓冲区*/

  27. static uint32_t s_framebuff_size=0;              /*帧缓冲区中数据长度*/



  31. static uint32_t s_dev_state_u32 = 0xFFFFFFFF;              /*设备是否静默的状态 1静默 0不静默*/



  35. /**

  37. *  模拟数据帧                 磁强计  10001nT 10002nT 10003nT              星敏  (0i+0j+0k,1)   10000S  2mS                                                                                           太敏  (0i+0j+0k,1)   10000S  2mS

  39. *  数据帧      AA 55 00 9D 00 0F 01 00 00 00 27 11 00 00 27 12 00 00 27 13 29 02 00 00 00 00 00 00 00 00 00 00 00 00 00 7F FF FF FF 00 00 27 11 00 00 00 31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1C 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

  41. *                             GPS                                                                        20年2月18日 15时43分01秒900mS 陀螺                                                          飞轮                                  校验和

  43. *                             23 04 00 00 00 27 11 00 00 27 12 00 00 27 13 00 00 27 11 00 00 27 12 00 00 27 13 14 02 12 0F 2B 01 03 84 15 05 00 00 00 27 11 00 00 27 12 00 00 27 13 07 D0 07 D0 07 D0 0C 06 00 13 88 13 88 13 88 13 88 00  B5  

  45. *                             磁力矩器

  47. *

  49. * AA 55 00 9E 00 0F 01 00 00 00 27 11 00 00 27 12 00 00 27 13 29 02 00 00 00 00 00 00 00 00 00 00 00 00 00 7F FF FF FF 00 00 27 11 00 00 00 31 00 00 00 00 00 00 00 00 00 00 00 00 00 00 1C 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 23 04 00 00 00 27 11 00 00 27 12 00 00 27 13 00 00 27 11 00 00 27 12 00 00 27 13 14 02 12 0F 2B 01 03 84 15 05 00 00 00 27 11 00 00 27 12 00 00 27 13 07 D0 07 D0 07 D0 0C 06 00 13 88 13 88 13 88 13 88 00 B6

  51. *  命令帧     AA 55 xx xx 01

  53. */



  57. /**

  59. *******************************************************************************

  61. * fn          static int32_t pc_protocol_gethead(uint8_t* buff, uint32_t* index)

  63. * rief       搜寻帧头标志.

  65. *
  66. ote        查找帧头标志HEAD_FLAG1 HEAD_FLAG2.

  68. * param[in]   buff     指向帧缓冲区数据.

  70. * param[in]   index    指向索引计数.

  72. *
    etval      >=0      查找到的索引位置

  74. *
    etval      <0       查找失败

  76. *******************************************************************************

  78. */

  80. static int32_t pc_protocol_gethead(uint8_t* buff, uint32_t* index)

  82. {

  84.     uint32_t i = 0;

  86.     int32_t position = -1;

  88.     if(*index < 2)

  90.     {

  92.         return -1;  /*小于最小帧长度 直接返回*/

  94.     }

  96.     for(i=0; i<(*index-1); i++)

  98.     {

  100.         if((buff[i] == HEAD_FLAG1) && (buff[i+1] == HEAD_FLAG2))

  102.         {

  104.             position = i;

  106.             break;

  108.         }

  110.     }

  112.     return position;

  114. }



  118. /**

  120. *******************************************************************************

  122. * fn          static int32_t pc_protocol_handle_data(uint8_t* buff, uint32_t size)

  124. * rief       PC发过来的数据帧处理.

  126. *
  127. ote        处理数据帧内容.

  129. * param[in]   buff     指向子块内容不包括帧标志 长度 类型 校验和 buff可能被改写.

  131. * param[in]   size     子块内容长度不包括帧标志 长度 类型 校验和.

  133. *
    etval      0 成功

  135. *
    etval      其他值 失败

  137. *******************************************************************************

  139. */

  141. static int32_t pc_protocol_handle_data(uint8_t* buff, uint32_t size)

  143. {

  145.     uint16_t datalen = 0;

  147.     int32_t res = 0;   /*处理状态  1需要继续处理 0不需要继续处理成功 -1不需要继续处理失败*/

  149.     do

  151.     {

  153.         datalen = buff[0];

  155.         if(size > 0)

  157.         {

  159.             if(size >= datalen)

  161.             {

  163.                 /*有效数据长度 处理数据*/

  165.                 switch(buff[1])

  167.                 {

  169.                     case DATA_MAGTM:

  171.                         res = dev_magtmdata_handle(&buff[3], buff[2], datalen-3);  /*传递子块内容和长度(不包括子块长度 子块类型 子块子类型)*/

  173.                     break;

  175.                     case DATA_STARSENSOR:

  177.                         res = dev_starsensordata_handle(&buff[3], buff[2], datalen-3);  /*传递子块内容和长度(不包括子块长度 子块类型 子块子类型)*/

  179.                     break;

  181.                     case DATA_SSOC:

  183.                         res = dev_ssocdata_handle(&buff[3], buff[2], datalen-3);  /*传递子块内容和长度(不包括子块长度 子块类型 子块子类型)*/

  185.                     break;

  187.                     case DATA_GPS:

  189.                         res = dev_gpsdata_handle(&buff[3], buff[2], datalen-3);  /*传递子块内容和长度(不包括子块长度 子块类型 子块子类型)*/

  191.                     break;

  193.                     case DATA_GYRO:

  195.                         res = dev_gyrodata_handle(&buff[3], buff[2], datalen-3);  /*传递子块内容和长度(不包括子块长度 子块类型 子块子类型)*/

  197.                     break;

  199.                     case DATA_WHEEL:

  201.                         res = dev_wheeldata_handle(&buff[3], buff[2], datalen-3);  /*传递子块内容和长度(不包括子块长度 子块类型 子块子类型)*/

  203.                     break;

  205.                     default:

  207.                         res = -1;

  209.                     break;

  211.                

  213.                 }

  215.                 /*调整数据继续处理*/

  217.                 if(res == 0)

  219.                 {

  221.                     memmove(buff,buff+datalen,size - datalen);

  223.                     size -= datalen;

  225.                     res = 1;

  227.                 }

  229.                 else

  231.                 {

  233.                     /*处理失败*/

  235.                     res = -1;

  237.                 }

  239.             }

  241.             else

  243.             {

  245.                 /*无效数据长度*/

  247.                 res = -1;

  249.             }

  251.         }

  253.         else

  255.         {

  257.             res = 0;   /*数据处理完*/

  259.         }

  261.     }while(res == 1);  /*如果需要继续处理从头开始*/



  265.     return res;

  267. }



  271. /**

  273. *******************************************************************************

  275. * fn          static int32_t pc_protocol_handle_cmd(uint8_t* buff, uint32_t size)

  277. * rief       PC发过来的命令帧处理.

  279. *
  280. ote        处理命令帧内容.

  282. * param[in]   buff     指向子块内容不包括帧标志 长度 类型 校验和 buff可能被改写.

  284. * param[in]   size     子块内容长度不包括帧标志 长度 类型 校验和.

  286. *
    etval      0 成功

  288. *
    etval      其他值 失败

  290. *******************************************************************************

  292. */

  294. static int32_t pc_protocol_handle_cmd(uint8_t* buff, uint32_t size)

  296. {

  298.     uint16_t datalen = 0;

  300.     uint32_t state=0;

  302.     int32_t res = 0;   /*处理状态  1需要继续处理 0不需要继续处理成功 -1不需要继续处理失败*/

  304.     do

  306.     {

  308.         datalen = buff[0];

  310.         if(size > 0)

  312.         {

  314.             if(size >= datalen)

  316.             {

  318.                 /*有效数据长度 处理数据*/

  320.                 switch(buff[1])

  322.                 {

  324.                     case 0:  /*静默指令*/

  326.                       state = (uint32_t)buff[3] | ((uint32_t)buff[4]<<8) | ((uint32_t)buff[5]<<16) | ((uint32_t)buff[6]<<24);

  328.                       if(buff[2] == 0)

  330.                       {

  332.                           s_dev_state_u32 = state;

  334.                       }

  336.                       else if(buff[2] == 1)

  338.                       {

  340.                           s_dev_state_u32 |= buff[3];

  342.                       }

  344.                       else if(buff[2] == 2)

  346.                       {

  348.                           s_dev_state_u32 &= ~buff[3];

  350.                       }

  352.                       else

  354.                       {}

  356.                     break;

  358.                     case 1:

  360.                       /*飞轮类型设置指令*/

  362.                       dev_set_wheeltype(buff[2],buff[3]);

  364.                     break;

  366.                     case 2:

  368.                       /*继电器参数设置指令*/

  370.                     pc_protocol_setswitch(&buff[2]);

  372.                     break;

  374.                     case 3:

  376.                       /*继电器参数获取指令*/

  378.                       pc_protocol_ackswitch(buff[2]);

  380.                     break;

  382.                

  384.                 }

  386.                 /*调整数据继续处理*/

  388.                 memmove(buff,buff+datalen,size - datalen);

  390.                 size -= datalen;

  392.                 res = 1;

  394.             }

  396.             else

  398.             {

  400.                 /*无效数据长度*/

  402.                 res = -1;

  404.             }

  406.         }

  408.         else

  410.         {

  412.             res = 0;   /*数据处理完*/

  414.         }

  416.     }while((res == 1) && (datalen>0));  /*如果需要继续处理从头开始*/



  420.     return res;

  422. }



  426. /**

  428. *******************************************************************************

  430. * fn          static int32_t pc_protocol_handle(uint8_t* buff, uint32_t* size)

  432. * rief       PC发过来的帧数据处理.

  434. *
  435. ote        接收到串口数据后调用该函数处理.

  437. * param[in]   buff     指向帧缓冲区数据,内容可能被改写.

  439. * param[in]   size     帧数据长度,内容可能会被改写.

  441. *
    etval      0 成功

  443. *
    etval      其他值 失败

  445. *******************************************************************************

  447. */

  449. static int32_t pc_protocol_handle(uint8_t* buff, uint32_t* size)

  451. {

  453.     int32_t headposition = -1;

  455.     int32_t res = 0;   /*处理状态  1需要继续处理 0不需要继续处理成功 -1不需要继续处理失败*/

  457.     uint16_t datalen = 0;

  459.     if(*size <= 6)

  461.     {

  463.         return 0;  /*小于最小帧长度 直接返回*/

  465.     }else{}

  467.    

  469.     do

  471.     {

  473.         headposition = pc_protocol_gethead(buff,size);

  475.         if(headposition >= 0)

  477.         {

  479.             /*调整删除前面无效的数据*/

  481.             if(headposition > 0)

  483.             {

  485.                 memmove(buff,buff+headposition,*size- headposition);

  487.                 *size -= headposition;

  489.             }

  491.             else

  493.             {

  495.                 /*headposition == 0不需要调整*/

  497.             }

  499.            

  501.             if(*size > FRAME_MINI_SIZE)

  503.             {

  505.                 datalen = ((uint16_t)buff[2]<<8) | (uint16_t)buff[3];  /*长度*/

  507.                 if((datalen<=FRAME_BUFF_MAX) && (datalen>=FRAME_MINI_SIZE))

  509.                 {

  511.                     if(*size >= datalen)

  513.                     {

  515.                         /*数据已收全*/

  517.                         if(buffer_checksum(buff, datalen-1) == buff[datalen-1])

  519.                         {

  521.                              /*数据校验成功  处理数据*/

  523.                             OsPrintf(OSAPI_DEBUG_INFO,"get frame type=%d framelen=%d
  524. ", buff[4],datalen);

  526.                             switch(buff[4])

  528.                             {

  530.                                 case 0:

  532.                                     rcvnum++;

  534.                                     pc_protocol_handle_data(buff+FRAME_HEAD_SIZE,datalen-FRAME_MINI_SIZE);  /*处理数据帧*/

  536.                                     pc_protocol_ackhandle(); /*发送返回帧数据*/

  538.                                 break;

  540.                                 case 1:

  542.                                     pc_protocol_handle_cmd(buff+FRAME_HEAD_SIZE,datalen-FRAME_MINI_SIZE);  /*处理命令帧*/

  544.                                 break;

  546.                                 default:

  548.                                 break;

  550.                             }

  552.                             memmove(buff,buff+datalen,*size - datalen);  /*删除本次已经处理完的帧数据*/

  554.                             *size -= datalen;

  556.                             res = 1;                            /*需要继续处理*/

  558.                         }

  560.                         else

  562.                         {

  564.                             /*数据校验错误  删掉帧头继续处理*/

  566.                             memmove(buff,buff+2,*size - 2);  

  568.                             *size -= 2;

  570.                             res = 1;  /*需要继续处理*/

  572.                         }

  574.                     }

  576.                     else

  578.                     {

  580.                         res = -1;  /*数据未收全 无需处理*/  

  582.                     }

  584.                

  586.                 }

  588.                 else

  590.                 {

  592.                     /*长度错误  删掉帧头继续处理*/

  594.                     memmove(buff,buff+2,*size - 2);  

  596.                     *size -= 2;

  598.                     res = 1;  /*需要继续处理*/

  600.                 }

  602.             }

  604.             else

  606.             {

  608.                 res = -1;  /*数据太短无需处理*/

  610.             }

  612.         }

  614.         else

  616.         {

  618.             /*没有找到标志  回写索引值 使得所有数据无效 从头开始*/

  620.             *size = 0;

  622.             res = -1;

  624.         }

  626.       

  628.     }while(res == 1);  /*如果需要继续处理从头开始*/

  630.     return res;

  632. }




  637. /**

  639. * 与PC通讯串口协议处理任务

  641. */

  643. void uarttask(void *pvParameters )

  645. {

  647.     uint32_t readlen = 0;                   /*本次实际读到的字节数*/

  649.     uint32_t toreadlen = 0;                 /*本次需要读的字节数*/

  651.     uint8_t readbuff[READ_BUFF_MAX] = {0};  /*本次的读缓冲*/

  653.     int32_t erro = 0;                       /*读错误码*/

  655.     /*初始化与PC通讯的串口*/

  657.     HAL_UART_CFG_t cfg;

  659.     cfg.id = HAL_UART_4;

  661.     cfg.baud = HAL_UART_BAUD_115200;

  663.     cfg.datalen = HAL_UART_DATA_8;

  665.     cfg.parity = HAL_UART_PARITY_NONE;

  667.     cfg.stopb = HAL_UART_STOPB_1;

  669.     driver_uart_set(&cfg);

  671.     driver_uart_flush(HAL_UART_4);



  675. //  cfg.id = HAL_UART_5;

  677. //  cfg.baud = HAL_UART_BAUD_115200;

  679. //  cfg.datalen = HAL_UART_DATA_8;

  681. //  cfg.parity = HAL_UART_PARITY_NONE;

  683. //  cfg.stopb = HAL_UART_STOPB_1;

  685. //  driver_uart_set(&cfg);

  687. //  driver_uart_flush(HAL_UART_5);



  691.     while(1)

  693.     {

  695.         /*串口收到数据进行转发*/

  697.         do

  699.         {

  701.             if((FRAME_BUFF_MAX-s_framebuff_size)>=READ_BUFF_MAX)

  703.             {

  705.                 toreadlen = READ_BUFF_MAX;  /*如果帧缓冲区能放的下数据大于 读缓冲区 那么一次读缓冲区大小*/

  707.             }

  709.             else

  711.             {

  713.                 toreadlen = FRAME_BUFF_MAX-s_framebuff_size;  /*如果帧缓冲区能放的下数据小于 读缓冲区 那么只读能存的下的大小*/

  715.             }

  717.             readlen = driver_uart_recv(HAL_UART_4, readbuff, toreadlen, READ_TIMEOUT, &erro);

  719.             rcvsum += readlen;

  721.             if(readlen > 0)

  723.             {

  725.                 memcpy(&s_framebuff_au8[s_framebuff_size],readbuff,readlen);

  727.                 s_framebuff_size += readlen;

  729.             }

  731.             else

  733.             {

  735.                 /*未读到数据继续读*/

  737.             }

  739.             /*调用帧处理接口*/

  741.             pc_protocol_handle(s_framebuff_au8, &s_framebuff_size);

  743.         }

  745.         while(readlen);

  747.         // OsTimeDelay(10);   // driver_uart_recv有任务延时功能 不需要再调用.

  749.     }

  751. }



  755. /**

  757. *******************************************************************************

  759. * fn          int32_t pc_protocol_initbuffer(uint8_t* buff, uint32_t* size,uint32_t bufflen)

  761. * rief       打包一个和pc通讯初始化的空包.

  763. *
  764. ote        .

  766. * param[in]   buff     指向帧缓冲区数据,内容可能被改写 调用者分配.

  768. * param[in]   size     有效帧数据长度,内容可能会被改写.

  770. * param[in]   bufflen  有效帧数据长度,内容可能会被改写 调用者指定.

  772. *
    etval      0 成功

  774. *
    etval      其他值 失败

  776. *******************************************************************************

  778. */

  780. int32_t pc_protocol_initbuffer(uint8_t* buff, uint32_t* size,uint32_t bufflen)

  782. {

  784.     if((bufflen < FRAME_MINI_SIZE) || (buff==0) || (size==0))

  786.     {

  788.         return -1;

  790.     }

  792.     buff[0] = 0xAA;

  794.     buff[1] = 0x55;

  796.     buff[2] = 0x00;

  798.     buff[3] = 0x06;

  800.     buff[4] = 0x02;  /*返回数据包*/

  802.     buff[5] = 0x02;

  804.     *size = 6;

  806.     return 0;

  808. }



  812. /**

  814. *******************************************************************************

  816. * fn          int32_t pc_protocol_apendbuffer(uint8_t* buff, uint32_t* size,uint32_t bufflen,void* adddata,uint32_t adddatalen,uint8_t type, uint8_t subtype)

  818. * rief       添加一个数据块.

  820. *
  821. ote        .

  823. * param[in]   buff     指向帧缓冲区数据,内容可能被改写 调用者分配.

  825. * param[in]   size     有效帧数据长度,内容可能会被改写.

  827. * param[in]   adddata  待添加的数据.

  829. * param[in]   adddatalen  待添加数据类型.

  831. * param[in]   type  类型.

  833. * param[in]   subtype  子类型.

  835. *
    etval      0 成功

  837. *
    etval      其他值 失败

  839. *******************************************************************************

  841. */

  843. int32_t pc_protocol_apendbuffer(uint8_t* buff, uint32_t* size,uint32_t bufflen,void* adddata,uint32_t adddatalen,uint8_t type, uint8_t subtype)

  845. {

  847.     uint16_t len;

  849.     if((adddatalen <= 3) || (buff==0) || (size==0) || (adddata==0))

  851.     {

  853.         return -1;

  855.     }

  857.     len = *size + adddatalen + 3;

  859.     if(len > bufflen)

  861.     {

  863.         return -1;

  865.     }

  867.     //buff[0] = 0xAA;

  869.     //buff[1] = 0x55;

  871.     buff[2] = (uint8_t)(len>>8);

  873.     buff[3] = (uint8_t)(len & 0xFF);

  875.     //buff[4] = 0x02;  /*返回数据包*/

  877.    

  879.     buff[*size-1] = adddatalen+3;

  881.     buff[*size] = type;

  883.     buff[*size+1] = subtype;

  885.     memcpy(&buff[*size+2],adddata,adddatalen);

  887.    

  889.     *size += (3+adddatalen);

  891.    

  893.     buff[*size-1] = buffer_checksum(buff,*size-1);

  895.    

  897.     return 0;

  899. }



  903. /**

  905. *******************************************************************************

  907. * fn          int32_t pc_protocol_ackhandle(void)

  909. * rief       PC发过来的帧数据回应处理(返回数据包).

  911. *
  912. ote        接收到串口数据后调用该函数处理.

  914. *
    etval      0 成功

  916. *
    etval      其他值 失败

  918. *******************************************************************************

  920. */

  922. int32_t pc_protocol_ackhandle(void)

  924. {

  926.     uint8_t sendbufff[128] = {0};

  928.     uint32_t topcsize=0;

  930.     int32_t erro;

  932.    

  934.     MAGT_Data_t magtdata;

  936.     WHEEL_Data_t wheeldata;

  938.     //GYRO_Data_t gyrodata;

  940.     //MAGTM_Data_t magtmdata;

  942.     dev_magtdata_get(&magtdata,0,1);

  944.     pc_protocol_initbuffer(sendbufff, &topcsize,sizeof(sendbufff));

  946.     pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&magtdata,sizeof(magtdata),DATA_MAGT,0);

  948.    

  950.     dev_wheeldata_get(&wheeldata,0);

  952.     pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&wheeldata,sizeof(WHEEL_Data_t),DATA_WHEEL,0);

  954.    

  956.     dev_wheeldata_get(&wheeldata,1);

  958.     pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&wheeldata,sizeof(WHEEL_Data_t),DATA_WHEEL,1);

  960.    

  962.     dev_wheeldata_get(&wheeldata,2);

  964.     pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&wheeldata,sizeof(WHEEL_Data_t),DATA_WHEEL,2);

  966.    

  968.     dev_wheeldata_get(&wheeldata,3);

  970.     pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&wheeldata,sizeof(WHEEL_Data_t),DATA_WHEEL,3);



  974.     //dev_gyrodata_get(&gyrodata,0);

  976.     //pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&gyrodata,sizeof(gyrodata),DATA_GYRO,0);

  978.    

  980.     //dev_gyrodata_get(&gyrodata,1);

  982.     //pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&gyrodata,sizeof(gyrodata),DATA_GYRO,1);

  984.    

  986.     //dev_magtmdata_get(&magtmdata,0);

  988.     //pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&magtmdata,sizeof(magtmdata),DATA_MAGTM,0);

  990.    

  992.     //dev_magtmdata_get(&magtmdata,1);

  994.     //pc_protocol_apendbuffer(sendbufff,&topcsize,sizeof(sendbufff),&magtmdata,sizeof(magtmdata),DATA_MAGTM,1);

  996.     driver_uart_send(HAL_UART_4, sendbufff, topcsize, 10, &erro);

  998.     return 0;

  1000. }



  1004. /**

  1006. *******************************************************************************

  1008. * fn          int32_t pc_protocol_ackswitch(uint8_t ch)

  1010. * rief       返回继电器参数.

  1012. *
  1013. ote        接收到读取参数指令后返回.

  1015. *
    etval      0 成功

  1017. *
    etval      其他值 失败

  1019. *******************************************************************************

  1021. */

  1023. int32_t pc_protocol_ackswitch(uint8_t ch)

  1025. {

  1027.     int32_t erro;

  1029.     uint8_t buff[32];



  1033.         uint32_t onmin,onmax,offmin,offmax;

  1035.         switch_get_par(ch,&onmin,&onmax,&offmin,&offmax);

  1037.     buff[0] = 0xAA;

  1039.     buff[1] = 0x55;

  1041.     buff[2] = 0;  /*长度 大端*/

  1043.     buff[3] = 25;



  1047.     buff[4] = 2;    /*返回帧*/



  1051.     /*子块*/

  1053.     buff[5] = 19;

  1055.     buff[6] = 8;                       /*子块类型 命令类型*/

  1057.     buff[7] = ch;                     /*子块子类型 继电器序号*/

  1059.         buff[8] = (onmin>>24) & 0xFF;        /*On最小时间 大端*/

  1061.         buff[9] = (onmin>>16) & 0xFF;

  1063.     buff[10] = (onmin>>8) & 0xFF;

  1065.     buff[11] = (onmin>>0) & 0xFF;

  1067.         buff[12] = (onmax>>24) & 0xFF;        /*On最大时间 大端*/

  1069.         buff[13] = (onmax>>16) & 0xFF;

  1071.         buff[14] = (onmax>>8) & 0xFF;

  1073.     buff[15] = (onmax>>0) & 0xFF;

  1075.         buff[16] = (offmin>>24) & 0xFF;        /*Off最小时间 大端*/

  1077.         buff[17] = (offmin>>16) & 0xFF;

  1079.     buff[18] = (offmin>>8) & 0xFF;

  1081.     buff[19] = (offmin>>0) & 0xFF;

  1083.         buff[20] = (offmax>>24) & 0xFF;        /*Off最大时间 大端*/

  1085.         buff[21] = (offmax>>16) & 0xFF;

  1087.     buff[22] = (offmax>>8) & 0xFF;

  1089.     buff[23] = (offmax>>0) & 0xFF;

  1091.     buff[24] = buffer_checksum(buff,24);

  1093.         driver_uart_send(HAL_UART_4, buff, 25, 10, &erro);

  1095.         return 0;

  1097.       

  1099. }



  1103. /**

  1105. *******************************************************************************

  1107. * fn          int32_t pc_protocol_setswitch(uint8_t* buff)

  1109. * rief       设置继电器参数.

  1111. *
  1112. ote        

  1114. *
    etval      0 成功

  1116. *
    etval      其他值 失败

  1118. *******************************************************************************

  1120. */

  1122. int32_t pc_protocol_setswitch(uint8_t* buff)

  1124. {

  1126.   uint32_t onmin,onmax,offmin,offmax;

  1128.   onmin = ((uint32_t)buff[1]<<24)|((uint32_t)buff[2]<<16)|((uint32_t)buff[3]<<8)|((uint32_t)buff[4]<<0);

  1130.   onmax = ((uint32_t)buff[5]<<24)|((uint32_t)buff[6]<<16)|((uint32_t)buff[7]<<8)|((uint32_t)buff[8]<<0);

  1132.   offmin = ((uint32_t)buff[9]<<24)|((uint32_t)buff[10]<<16)|((uint32_t)buff[11]<<8)|((uint32_t)buff[12]<<0);

  1134.   offmax = ((uint32_t)buff[13]<<24)|((uint32_t)buff[14]<<16)|((uint32_t)buff[15]<<8)|((uint32_t)buff[16]<<0);

  1136.   switch_set_par(buff[0],onmin,onmax,offmin,offmax);

  1138.   return 0;

  1140.       

  1142. }

  1144. /**

  1146. *******************************************************************************

  1148. * fn          uint32_t get_dev_state(void)

  1150. * rief       获取设备静默状态.

  1152. *
  1153. ote        .

  1155. *
    eturn      uint32_t 状态值

  1157. *******************************************************************************

  1159. */

  1161. uint32_t get_dev_state(void)

  1163. {

  1165.     return s_dev_state_u32;

  1167. }

上位机处理过程与上述完全一样。
测试
测试任意个负载数据，误码，丢数，校验错误等异常情况，都能正确的丢掉异常帧处理正常帧。
总结
以上设计了可伸缩,自适应,健壮的网关通讯协议,实现了串口的链路实现该协议数据的传输，基本实现了网关的雏形，后面就是不断完善各传感器采集与控制，完善上位机。

更多回帖

0 0 0

相关帖子

RA4M2 RA4M2设计挑战赛
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分