Gitee

https://gitee.com/WangXi_Chn/RttOs_ModuleLib

开发环境

CubeMX
MDK5 IDE
STM32F429IGT6 芯片
正点原子开发板 阿波罗
STM32F103C8T6 芯片
Stm32最小系统板
RT-Thread操作系统
面向对象模块接口设计

硬件条件

  • 两块板通过串口线连接，同时正点原子开发板为最小系统板供电，共地
  • 实现一个光电正交脉冲编码器数据读取功能

  • 通过最小系统板读取编码器信息，再通过串口将该编码器信息发送至开发板

    核心思想

  • 模块实现串口设备的初始化

  • 对发送数据的协议打包和协议拆包
  • 固定帧头帧尾和计算校验帧，保证数据可靠性

  • 添加包数据功能指示帧

    帧格式

    | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 5 | 8 | 9 | 10 | | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | :—-: | | 0xA5 | 0x5A | 0x00 | 0x01 | 0x01 | 0x00 | 0x00 | 0x00 | 0x00 | 0x01 | 0xAA |

  • 红色：固定帧格式，帧头帧尾，只有接收到帧头才开始接收，只有接收到帧尾才结束接收

  • 青色：目标器件的ID，用来标识信息想要发送于谁
  • 紫色：我的器件ID，与使用的外设有关，用来标识信息来源于谁
  • 蓝色：功能指示帧（也可视为帧ID），通过宏定义(M0_D1)规定，0x01意为功能0的第1个数据，0x12(M0_D2)意为功能1的第2个数据，由通信双方规定和解释
  • 绿色：数据内容，支持一个int类型数据传输，5-8分别对应高8位和低8位
  • 橙色：校验帧，将ID和数据（即2~8），每8位求和计算结果的低八位作为校验帧，接收到一帧数据时会先验证，验证未通过数据会被丢弃

    源文件

    Module_BSPCommunicate.h

    ```c /*
    • Copyright (c) 2020 - ~, HIT_HERO Team *
    • BSP COMMUNICATE MODULE HEAD FILE
    • Used in RT-Thread Operate System *
    • Change Logs:
    • Date Author Notes Mail
    • 2020-08-25 WangXi first version WangXi_chn@foxmail.com
    • Note */

      include

      include

      include

ifndef MODULE_BSPCOMMUNICATE_H

define MODULE_BSPCOMMUNICATE_H

typedef enum PACKETID { M0_D1 = 0x01, M0_D2 = 0x02,

  1. M1_D1 = 0x11,
  2. M1_D2 = 0x12,

}PacketID;

struct _MODULE_BSPCOMMUNICATE { / Property / char * Property_UartDevName; 

  1. /* Value */
  2. rt_device_t         Value_uart_dev;
  3. rt_uint8_t          Value_sendData[9];
  4. rt_uint8_t          Value_feedData[9];
  6. //User data means define begin--------------------------------------------------------
  7. rt_int32_t            Value_RotaryEncoder;    
  14. //User data means define end--------------------------------------------------------
  16. /* Method */
  17. void (*Method_Init)(struct _MODULE_BSPCOMMUNICATE *module);
  18. void (*Method_Send)(struct _MODULE_BSPCOMMUNICATE *module,PacketID funcflag,rt_int32_t param);
  19. void (*Method_Feed)(struct _MODULE_BSPCOMMUNICATE *module);
  20. void (*Method_Encode)(struct _MODULE_BSPCOMMUNICATE *module,PacketID funcflag,rt_int32_t param);
  21. void (*Method_Decode)(struct _MODULE_BSPCOMMUNICATE *module);
  22. rt_err_t (*Method_Handle)(rt_device_t dev, rt_size_t size);

}; typedef struct _MODULE_BSPCOMMUNICATE MODULE_BSPCOMMUNICATE;

rt_err_t Module_BspCommunicate_Config(MODULE_BSPCOMMUNICATE *module);

endif

/** (C) COPYRIGHT 2020 WANGXI **END OF FILE**/

  1. <a name="LJBUe"></a>
  2. ## Module_BSPCommunicate.c
  3. ```c
  4. /*
  5.  * Copyright (c) 2020 - ~, HIT_HERO Team
  6.  *
  7.  * BSP COMMUNICATE MODULE SOUCE FILE
  8.  * Used in RT-Thread Operate System
  9.  *
  10.  * Change Logs:
  11.  * Date           Author       Notes                Mail
  12.  * 2020-08-25     WangXi       first version        WangXi_chn@foxmail.com
  13.  */
  14. #include "Module_BSPCommunicate.h"
  16. static void     Module_BspCommunicateInit(MODULE_BSPCOMMUNICATE *module);
  17. static void     Module_BspCommunicateSend(MODULE_BSPCOMMUNICATE *module,PacketID funcflag,rt_int32_t param);
  18. static void     Module_BspCommunicateFeed(MODULE_BSPCOMMUNICATE *module);
  20. static void     Module_BspCommunicateEncode(MODULE_BSPCOMMUNICATE *module,PacketID funcflag,rt_int32_t param);
  21. static void     Module_BspCommunicateDecode(MODULE_BSPCOMMUNICATE *module);
  23. static rt_err_t Module_BspCommunicateHandle(rt_device_t dev, rt_size_t size);
  25. static struct rt_semaphore uartBspCommunicate_sem;
  27. /* Global Method */
  28. rt_err_t Module_BspCommunicate_Config(MODULE_BSPCOMMUNICATE *module)
  29. {
  30.     if( module->Method_Init     ==NULL &&
  31.         module->Method_Handle   ==NULL &&
  32.         module->Method_Send     ==NULL &&
  33.         module->Method_Feed     ==NULL &&
  34.         module->Method_Encode   ==NULL &&
  35.         module->Method_Decode   ==NULL
  37.     ){  
  38.         /* Link the Method */
  39.         module->Method_Init         = Module_BspCommunicateInit;
  40.         module->Method_Handle       = Module_BspCommunicateHandle;
  41.         module->Method_Send         = Module_BspCommunicateSend;
  42.         module->Method_Feed         = Module_BspCommunicateFeed;
  43.         module->Method_Encode       = Module_BspCommunicateEncode;
  44.         module->Method_Decode       = Module_BspCommunicateDecode;
  46.     }
  47.     else{
  48.         rt_kprintf("Warning: Module BspCommunicate is Configed twice\n");
  49.         return RT_ERROR;
  50.     }
  52.     /* Device Init */
  53.     module->Method_Init(module);
  55.     return RT_EOK;
  56. }
  58. static void Module_BspCommunicateInit(MODULE_BSPCOMMUNICATE *module)
  59. {
  60.     module->Value_uart_dev = rt_device_find(module->Property_UartDevName);
  61.     if (!module->Value_uart_dev)
  62.     {
  63.         rt_kprintf("find %s failed!\n", module->Value_uart_dev);
  64.         return;
  65.     }
  67.     rt_sem_init(&uartBspCommunicate_sem, "uartBspCommunicate_sem", 0, RT_IPC_FLAG_FIFO);
  69.     struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;  /* 初始化配置参数 */
  70.     /* step2：修改串口配置参数 */
  71.     config.baud_rate = BAUD_RATE_9600;        //修改波特率为 9600
  72.     config.data_bits = DATA_BITS_8;           //数据位 8
  73.     config.stop_bits = STOP_BITS_1;           //停止位 1
  74.     config.bufsz     = 128;                   //修改缓冲区 buff size 为 128
  75.     config.parity    = PARITY_NONE;           //无奇偶校验位
  77.     /* step3：控制串口设备。通过控制接口传入命令控制字，与控制参数 */
  78.     rt_device_control(module->Value_uart_dev, RT_DEVICE_CTRL_CONFIG, &config);  
  79.     rt_device_open(module->Value_uart_dev, RT_DEVICE_FLAG_DMA_RX);
  80.     rt_device_set_rx_indicate(module->Value_uart_dev, module->Method_Handle);
  82. }
  84. static void Module_BspCommunicateSend(MODULE_BSPCOMMUNICATE *module,PacketID packetID,rt_int32_t param)
  85. {
  86.     module->Method_Encode(module,packetID,param);
  88.     rt_device_write(    module->Value_uart_dev, 0, 
  89.                         &(module->Value_sendData), 
  90.                         sizeof(module->Value_sendData));
  91. }
  93. static void Module_BspCommunicateFeed(MODULE_BSPCOMMUNICATE *module)
  94. {
  95.     rt_uint8_t ch;
  96.     rt_uint8_t i = 0;
  98.     while (1)
  99.     {   
  100.         while (rt_device_read(module->Value_uart_dev, -1, &ch, 1) == 0)
  101.         {
  102.             rt_sem_control(&uartBspCommunicate_sem, RT_IPC_CMD_RESET, RT_NULL);
  103.             rt_sem_take(&uartBspCommunicate_sem, RT_WAITING_FOREVER);
  104.         }
  106.         if((rt_uint8_t)ch == 0xAA)
  107.         {
  108.             /* get the frame end flag and start encode the frame */
  109.             module->Method_Decode(module);
  111.             i = 0;
  112.             continue;
  113.         }
  114.         i = (i >= 9-1) ? 9-1 : i;
  115.         module->Value_feedData[i++] = ch;
  116.     }   
  117. }
  119. static rt_err_t Module_BspCommunicateHandle(rt_device_t dev, rt_size_t size)
  120. {   
  121.     rt_sem_release(&uartBspCommunicate_sem);
  123.     return RT_EOK;
  124. }
  126. static void Module_BspCommunicateEncode(MODULE_BSPCOMMUNICATE *module,PacketID packetID,rt_int32_t param)
  127. {
  128.     module->Value_sendData[0] = 0xA5;
  129.     module->Value_sendData[1] = 0x5A;
  130.     module->Value_sendData[2] = packetID;
  131.     module->Value_sendData[3] = (rt_uint8_t)((param&0xFF000000)>>24);
  132.     module->Value_sendData[4] = (rt_uint8_t)((param&0x00FF0000)>>16);
  133.     module->Value_sendData[5] = (rt_uint8_t)((param&0x0000FF00)>>8);
  134.     module->Value_sendData[6] = (rt_uint8_t)((param&0x000000FF));
  135.     module->Value_sendData[7] = (rt_uint8_t)((module->Value_sendData[2])+
  136.                                 (module->Value_sendData[3])+(module->Value_sendData[4])+
  137.                                 (module->Value_sendData[5])+(module->Value_sendData[6]));
  138.     module->Value_sendData[8] = 0xAA;       
  139. }
  141. static void Module_BspCommunicateDecode(MODULE_BSPCOMMUNICATE *module)
  142. {
  143.     if(    (rt_uint8_t)(module->Value_feedData[0])==0xA5 &&
  144.         (rt_uint8_t)(module->Value_feedData[1])==0x5A &&
  145.         (rt_uint8_t)((module->Value_feedData[2])+
  146.         (module->Value_feedData[3])+(module->Value_feedData[4])+
  147.         (module->Value_feedData[5])+(module->Value_feedData[6]))
  148.         ==(module->Value_feedData[7]))
  149.     {
  150.         //Split the data
  151.         rt_int32_t Date = ((module->Value_feedData[3])<<24) + ((module->Value_feedData[4])<<16)
  152.                         +((module->Value_feedData[5])<<8) + ((module->Value_feedData[6]));    
  155.         //User data Translate begin-----------------------------------------------------------------------------
  156.         switch(module->Value_feedData[2])
  157.         {
  158.             case M0_D1:
  159.                 module->Value_RotaryEncoder = Date;
  161.             break;
  163.             case M0_D2:
  165.             break;
  167.             case M1_D1:
  169.             break;
  171.             case M1_D2:
  173.             break;                
  174.         }
  175.         //User data Translate end-----------------------------------------------------------------------------
  177.     }
  178.     else
  179.     {
  180.         return;
  181.     }
  182. }
  184. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

使用（发送方）main

  1. #include <rtthread.h>
  2. #include <rtdevice.h>
  3. #include <board.h>
  4. #include <stdlib.h>
  5. #include "Module_BSPCommunicate.h"
  7. #define PULSE_ENCODER_DEV_NAME    "pulse4"    /* 脉冲编码器名称 */
  9. MODULE_BSPCOMMUNICATE dev_BspCommunicate = 
  10.     {
  11.         .Property_UartDevName    = "uart2",
  12.     };
  14. int main(void)
  15. {
  16.     rt_err_t ret = RT_EOK;
  17.     rt_device_t pulse_encoder_dev = RT_NULL;   /* 脉冲编码器设备句柄 */
  19.     /* 查找脉冲编码器设备 */
  20.     pulse_encoder_dev = rt_device_find(PULSE_ENCODER_DEV_NAME);
  21.     if (pulse_encoder_dev == RT_NULL)
  22.     {
  23.         rt_kprintf("pulse encoder sample run failed! can't find %s device!\n", PULSE_ENCODER_DEV_NAME);
  24.         return RT_ERROR;
  25.     }
  27.     /* 以只读方式打开设备 */
  28.     ret = rt_device_open(pulse_encoder_dev, RT_DEVICE_OFLAG_RDONLY);
  29.     if (ret != RT_EOK)
  30.     {
  31.         rt_kprintf("open %s device failed!\n", PULSE_ENCODER_DEV_NAME);
  32.         return ret;
  33.     }
  35.     rt_pin_mode(GET_PIN(B,  6), PIN_MODE_INPUT_PULLUP);
  36.     rt_pin_mode(GET_PIN(B,  7), PIN_MODE_INPUT_PULLUP);
  38.     rt_pin_mode(GET_PIN(C,  13), PIN_MODE_OUTPUT);
  40.     //初始化串口板级通信模块
  41.     Module_BspCommunicate_Config(&dev_BspCommunicate);
  43.     while(1)
  44.     {
  45.         rt_thread_mdelay(1);
  47.         //发送指示灯点亮
  48.         rt_pin_write(GET_PIN(C,  13), PIN_LOW);
  50.         /* 读取脉冲编码器计数值 */
  51.         rt_device_read(pulse_encoder_dev, 0, &(dev_BspCommunicate.Value_RotaryEncoder), 1);        
  52.         if(abs(dev_BspCommunicate.Value_RotaryEncoder)>20000)
  53.         {
  54.             /* 读到了错误数据清空脉冲编码器计数值 */
  55.             rt_device_control(pulse_encoder_dev, PULSE_ENCODER_CMD_CLEAR_COUNT, RT_NULL);
  56.         }
  58.         //发送数据，指示包功能为M0_D1
  59.         dev_BspCommunicate.Method_Send(&dev_BspCommunicate,M0_D1,dev_BspCommunicate.Value_RotaryEncoder);
  61.         //发送指示灯熄灭
  62.         rt_pin_write(GET_PIN(C,  13), PIN_HIGH);
  63.     }
  64. }
  • 即发送方需要发送数据时，仅需调用模块的Send方法即可

    使用（接收方）main

    ```c /*
    • Copyright (c) 2020 - ~, HIT_HERO Team *
    • MAIN SOUCE FILE
    • Used in RT-Thread Operate System *
    • Change Logs:
    • Date Author Notes Mail
    • 2020-08-08 WangXi first version WangXi_chn@foxmail.com
    • 2020-08-13 WangXi second version WangXi_chn@foxmail.com *
    • Note:
    • Used for friction gear shot Rugby /

include

include

include

include “Module_LED.h”

include “Module_DjiC610620Group.h”

include “Module_BlueToothHC06.h”

include “Module_BSPCommunicate.h”

/ Module param list ———————————————————————————————————————————— / MODULE_LED dev_led_state = {
.pin = GET_PIN(B, 0), .LED_TIME_CYCLE = 4000, .LED_TIME_OUTPUT = 200 };

MODULE_BSPCOMMUNICATE dev_BspCommunicate = { .Property_UartDevName = “uart3”, };

/ thread entry list ———————————————————————————————————————————— / static void led_shine_entry(void *parameter) { while (1) { rt_thread_mdelay(1);
dev_led_state.Handle(&dev_led_state);
} }

static void bspCommnicate_entry(void *parameter) { dev_BspCommunicate.Method_Feed(&dev_BspCommunicate); }

int main(void) { / Config module ———————————————————————————————————————————— / Module_Led_Config(&dev_led_state);
dev_led_state.Set(&dev_led_state,9);

  1. Module_BspCommunicate_Config(&dev_BspCommunicate);
  3. /* Enable task thread ---------------------------------------------------------------------------------------- */
  4. /* system running shine led thread */
  5. rt_thread_t led_thread = rt_thread_create("ledshine", led_shine_entry, RT_NULL,
  6.                               512, RT_THREAD_PRIORITY_MAX - 3, 20);
  7. if (led_thread != RT_NULL){
  8.     rt_thread_startup(led_thread);
  9. }    
  11. /* bsp communicate thread */
  12. rt_thread_t bspCommnicate_thread = rt_thread_create("bspCommnicate", bspCommnicate_entry, RT_NULL,
  13.                               512, RT_THREAD_PRIORITY_MAX - 6, 20);
  14. if (bspCommnicate_thread != RT_NULL){
  15.     rt_thread_startup(bspCommnicate_thread);
  16. }

}

/** (C) COPYRIGHT 2020 WANGXI **END OF FILE**/

  2. - 即接收方仅需在一个线程中调用模块的Feed方法即可
  3. - 而对接收数据的解释需要在模块的Decode方法中编辑
  4. - 建议通过添加模块的结构体成员，在Decode方法中对包ID所对应的结构体成员赋值
  5. - 这样做的好处是，可以保证模块与模块之间相互分离，所有的数据交互仅在main下进行，尽可能降低耦合
  6. <a name="TaPm9"></a>
  7. # 版本更新
  9. - 去除对数据解释部分，仅实现透明传输功能
  10. - 解释由上层封装，应用程序规定和解释(根据传输的帧ID即功能指示子节)
  11. - 在帧中加入了自身ID对方ID的说明和识别
  12. - 添加了对JC24B无线透传模块的使用选项和驱动
  13. - 更大程度上降低耦合，提升模块复用效率
  14. <a name="VO21Y"></a>
  15. ## Module_UartCom.h
  16. ```c
  17. /*
  18.  * Copyright (c) 2020 - ~, HIT_HERO Team
  19.  *
  20.  * UARTCOM MODULE HEAD FILE
  21.  * Used in RT-Thread Operate System
  22.  *
  23.  * Change Logs:
  24.  * Date           Author       Notes                Mail
  25.  * 2020-08-25     WangXi       first version        WangXi_chn@foxmail.com
  26.  * 2020-09-06     WangXi       second version       WangXi_chn@foxmail.com
  27.  * Note
  28.  */
  29. #ifndef _MODULE_UARTCOM_H_
  30. #define _MODULE_UARTCOM_H_
  32. #include <rtthread.h>
  33. #include <rtdevice.h>
  34. #include <board.h>
  36. #define UARTCOM_FRAME_LENGTH 11
  38. typedef rt_uint8_t UARTCOM_MYID;
  39. typedef rt_uint8_t UARTCOM_NETID;
  40. typedef rt_uint8_t UARTCOM_AIMID;
  41. typedef rt_uint8_t UARTCOM_GETID;
  42. typedef rt_uint8_t UARTCOM_PACKETID;
  44. typedef enum{
  45.     SIMPLEUART = 0,
  46.     JC24B,
  48. }UARTCOM_DEVICE;
  50. struct _MODULE_UARTCOM
  51. {
  52.     /* Property */
  53.     char *              Property_UartDevName; 
  54.     rt_uint32_t            Property_BaudRate;
  55.     UARTCOM_MYID         Property_MyID;
  56.     UARTCOM_NETID        Property_NetID;
  57.     UARTCOM_DEVICE        Property_Device;
  59.     rt_base_t             Property_JC24BsetPin;          /*!< Only used when Property_Device is JC24B as set pin. >
  60.                                         This parameter is defined by function @ref GET_PIN(GPIOPORT, GPIO_PIN_NUM) */
  62.     /* Value */
  63.     rt_device_t         Value_uart_dev;
  64.     rt_uint8_t          Value_sendData[UARTCOM_FRAME_LENGTH];
  65.     rt_uint8_t          Value_feedData[UARTCOM_FRAME_LENGTH];
  66.     UARTCOM_AIMID         Value_AimID;
  67.     UARTCOM_GETID         Value_GetID;
  69.     /* Method */
  70.     void (*Method_Init)(struct _MODULE_UARTCOM *module);
  71.     void (*Method_Send)(struct _MODULE_UARTCOM *module,UARTCOM_PACKETID packetID,rt_int32_t param);
  72.     void (*Method_Feed)(struct _MODULE_UARTCOM *module,UARTCOM_PACKETID* packetID,rt_int32_t* param);
  73.     void (*Method_Encode)(struct _MODULE_UARTCOM *module,UARTCOM_PACKETID packetID,rt_int32_t param);
  74.     void (*Method_Decode)(struct _MODULE_UARTCOM *module,UARTCOM_PACKETID* packetID,rt_int32_t* param);
  75.     rt_err_t (*Method_Handle)(rt_device_t dev, rt_size_t size);
  77. };
  78. typedef struct _MODULE_UARTCOM MODULE_UARTCOM;
  80. rt_err_t Module_UartCom_Config(MODULE_UARTCOM *module);
  82. #endif
  84. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

Module_UartCom.c

  1. /*
  2.  * Copyright (c) 2020 - ~, HIT_HERO Team
  3.  *
  4.  * UARTCOM MODULE SOUCE FILE
  5.  * Used in RT-Thread Operate System
  6.  *
  7.  * Change Logs:
  8.  * Date           Author       Notes                Mail
  9.  * 2020-08-25     WangXi       first version        WangXi_chn@foxmail.com
  10.  * 2020-09-06     WangXi       second version       WangXi_chn@foxmail.com
  11.  */
  12. #include "Module_UartCom.h"
  14. static void     Module_UartComInit(MODULE_UARTCOM *module);
  15. static void     Module_UartComSend(MODULE_UARTCOM *module,rt_uint8_t packetID,rt_int32_t param);
  16. static void     Module_UartComFeed(MODULE_UARTCOM *module,rt_uint8_t* packetID,rt_int32_t* param);
  17. static void     Module_UartComEncode(MODULE_UARTCOM *module,rt_uint8_t packetID,rt_int32_t param);
  18. static void     Module_UartComDecode(MODULE_UARTCOM *module,rt_uint8_t* packetID,rt_int32_t* param);
  19. static rt_err_t Module_UartComHandle(rt_device_t dev, rt_size_t size);
  21. static struct rt_semaphore uartCom_sem;
  23. static void        Module_UartComJC24BConfig(MODULE_UARTCOM *module);
  25. /* Global Method */
  26. rt_err_t Module_UartCom_Config(MODULE_UARTCOM *module)
  27. {
  28.     if( module->Method_Init     ==NULL &&
  29.         module->Method_Handle   ==NULL &&
  30.         module->Method_Send     ==NULL &&
  31.         module->Method_Feed     ==NULL &&
  32.         module->Method_Encode   ==NULL &&
  33.         module->Method_Decode   ==NULL
  35.     ){  
  36.         /* Link the Method */
  37.         module->Method_Init         = Module_UartComInit;
  38.         module->Method_Handle       = Module_UartComHandle;
  39.         module->Method_Send         = Module_UartComSend;
  40.         module->Method_Feed         = Module_UartComFeed;
  41.         module->Method_Encode       = Module_UartComEncode;
  42.         module->Method_Decode       = Module_UartComDecode;
  44.     }
  45.     else{
  46.         rt_kprintf("Warning: Module uart Communication is Configed twice\n");
  47.         return RT_ERROR;
  48.     }
  50.     /* Device Init */
  51.     module->Method_Init(module);
  53.     return RT_EOK;
  54. }
  56. static void Module_UartComInit(MODULE_UARTCOM *module)
  57. {
  58.     module->Value_uart_dev = rt_device_find(module->Property_UartDevName);
  59.     if (!module->Value_uart_dev)
  60.     {
  61.         rt_kprintf("find %s failed!\t\n", module->Value_uart_dev);
  62.         return;
  63.     }
  65.     rt_sem_init(&uartCom_sem, "uartCom_sem", 0, RT_IPC_FLAG_FIFO);
  67.     struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;  /* 初始化配置参数 */
  69.     /* step2：修改串口配置参数 */
  70.     if(module->Property_BaudRate == 9600)
  71.     {
  72.         config.baud_rate = BAUD_RATE_9600;        //修改波特率为 9600
  73.     }
  74.     else if(module->Property_BaudRate == 115200)
  75.     {
  76.         config.baud_rate = BAUD_RATE_115200;       //修改波特率为 115200
  77.     }
  78.     else
  79.     {
  80.         rt_kprintf("warning: Uartcom's baudrate %d set failed, will be default value 115200\t\n",module->Property_BaudRate);
  81.     }
  83.     config.data_bits = DATA_BITS_8;           //数据位 8
  84.     config.stop_bits = STOP_BITS_1;           //停止位 1
  85.     config.bufsz     = 128;                   //修改缓冲区 buff size 为 128
  86.     config.parity    = PARITY_NONE;           //无奇偶校验位
  88.     /* step3：控制串口设备。通过控制接口传入命令控制字，与控制参数 */
  89.     rt_device_control(module->Value_uart_dev, RT_DEVICE_CTRL_CONFIG, &config);  
  90.     rt_device_open(module->Value_uart_dev, RT_DEVICE_FLAG_DMA_RX);
  91.     rt_device_set_rx_indicate(module->Value_uart_dev, module->Method_Handle);
  93.     if(module->Property_Device == JC24B)
  94.     {
  95.         Module_UartComJC24BConfig(module);
  96.     }
  98. }
  100. static void Module_UartComSend(MODULE_UARTCOM *module,rt_uint8_t packetID,rt_int32_t param)
  101. {
  102.     module->Method_Encode(module,packetID,param);
  104.     rt_device_write(    module->Value_uart_dev, 0, 
  105.                         &(module->Value_sendData), 
  106.                         sizeof(module->Value_sendData));
  107. }
  109. static void Module_UartComFeed(MODULE_UARTCOM *module,rt_uint8_t* packetID,rt_int32_t* param)
  110. {
  111.     rt_uint8_t ch;
  112.     rt_uint8_t i = 0;
  114.     while (1)
  115.     {   
  116.         while (rt_device_read(module->Value_uart_dev, -1, &ch, 1) == 0)
  117.         {
  118.             rt_sem_control(&uartCom_sem, RT_IPC_CMD_RESET, RT_NULL);
  119.             rt_sem_take(&uartCom_sem, RT_WAITING_FOREVER);
  120.         }
  122.         if((rt_uint8_t)ch == 0xAA)
  123.         {
  124.             /* get the frame end flag and start encode the frame */
  125.             module->Method_Decode(module,packetID,param);
  127.             i = 0;
  128.             continue;
  129.         }
  130.         i = (i >= UARTCOM_FRAME_LENGTH-1) ? UARTCOM_FRAME_LENGTH-1 : i;
  131.         module->Value_feedData[i++] = ch;
  132.     }   
  133. }
  135. static rt_err_t Module_UartComHandle(rt_device_t dev, rt_size_t size)
  136. {   
  137.     rt_sem_release(&uartCom_sem);
  139.     return RT_EOK;
  140. }
  142. static void Module_UartComEncode(MODULE_UARTCOM *module,rt_uint8_t packetID,rt_int32_t param)
  143. {
  144.     module->Value_sendData[0] = 0xA5;
  145.     module->Value_sendData[1] = 0x5A;
  146.     module->Value_sendData[2] = module->Value_AimID;
  147.     module->Value_sendData[3] = module->Property_MyID;
  148.     module->Value_sendData[4] = packetID;
  149.     module->Value_sendData[5] = (rt_uint8_t)((param&0xFF000000)>>24);
  150.     module->Value_sendData[6] = (rt_uint8_t)((param&0x00FF0000)>>16);
  151.     module->Value_sendData[7] = (rt_uint8_t)((param&0x0000FF00)>>8);
  152.     module->Value_sendData[8] = (rt_uint8_t)((param&0x000000FF));
  153.     module->Value_sendData[9] = (rt_uint8_t)((module->Value_sendData[2])+
  154.                                 (module->Value_sendData[3])+(module->Value_sendData[4])+
  155.                                 (module->Value_sendData[5])+(module->Value_sendData[6])+
  156.                                 (module->Value_sendData[7])+(module->Value_sendData[8]));
  157.     module->Value_sendData[10] = 0xAA;       
  158. }
  160. static void Module_UartComDecode(MODULE_UARTCOM *module,rt_uint8_t* packetID,rt_int32_t* param)
  161. {
  162.     if(    (rt_uint8_t)(module->Value_feedData[0])==    0xA5                     &&
  163.         (rt_uint8_t)(module->Value_feedData[1])==    0x5A                     &&
  164.         (rt_uint8_t)(module->Value_feedData[2])==    module->Property_MyID     &&
  165.         (rt_uint8_t)((module->Value_feedData[2])+
  166.         (module->Value_feedData[3])+(module->Value_feedData[4])+
  167.         (module->Value_feedData[5])+(module->Value_feedData[6])+
  168.         (module->Value_feedData[7])+(module->Value_feedData[8]))
  169.         ==(module->Value_feedData[9]))
  170.     {
  171.         //Split the data
  172.         module->Value_GetID = module->Value_sendData[3];
  174.         rt_int32_t Date = ((module->Value_feedData[5])<<24) + ((module->Value_feedData[6])<<16)
  175.                         +((module->Value_feedData[7])<<8) + ((module->Value_feedData[8]));    
  177.         *packetID = module->Value_feedData[4];
  178.         param[*packetID] = Date;
  179.     }
  180.     else
  181.     {
  182.         return;
  183.     }
  184. }
  186. static void    Module_UartComJC24BConfig(MODULE_UARTCOM *module)
  187. {
  188.     char Config_data[18];
  190.     rt_pin_mode(module->Property_JC24BsetPin, PIN_MODE_OUTPUT);
  191.     rt_pin_write(module->Property_JC24BsetPin, PIN_LOW);
  193.     //0       1    2   3    4   5    6    7      8    9        10    11     12   13     14   15    16    17
  194.     //AA   5A    00  00   00  10   00   00     00   04       00      1F     00      01     00      12    00      06
  195.     //0xaa 0x5a 模块ID   组网ID   0x00 RF功率 0x00 波特率   0x00  RF信道 0x00 速率   0x00 0x12  0x00  和校验
  196.     rt_thread_mdelay(1);
  198.     Config_data[0] = 0xAA;
  199.     Config_data[1] = 0x5A;
  200.     Config_data[2] = 0x00;
  201.     Config_data[3] = module->Property_MyID;
  202.     Config_data[4] = 0x00;
  203.     Config_data[5] = module->Property_NetID;
  204.     Config_data[6] = 0x00;
  205.     Config_data[7] = 0x00;
  206.     Config_data[8] = 0x00;
  207.     Config_data[9] = 0x04;
  208.     Config_data[10] = 0x00;
  209.     Config_data[11] = 0x1F;
  210.     Config_data[12] = 0x00;
  211.     Config_data[13] = 0x01;
  212.     Config_data[14] = 0x00;
  213.     Config_data[15] = 0x12;
  214.     Config_data[16] = 0x00;
  215.     for(int i = 0;i<17;i++)
  216.         Config_data[17] += Config_data[i];
  218.     rt_device_write(    module->Value_uart_dev, 0, 
  219.                         Config_data, sizeof(Config_data));
  221.     rt_thread_mdelay(1);
  223.     rt_pin_write(module->Property_JC24BsetPin, PIN_HIGH);
  224. }
  226. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

JC24B无线串口模块资料

物联电子JC24B无线透传模块规格书V1.0.zip

辅助工具

  • 为方便检查帧格式是否正确
  • 以及与串口助手进行数据对比等

  • 用C#窗体设计了一个简易协议帧的生成器

    使用

  • 运行.exe文件

image.png

  • 输入项默认均为0
  • 输入项不可为空否则会报格式错误
  • 以十六进制填入目标系统ID和自身系统ID，以及帧的功能指示ID（帧ID）
  • 以整形int格式填入要传输的数据
  • 点击生成按键，或者直接敲击回车键
  • 即可在帧内容中自动生成
  • 支持复制粘贴
  • 帧头帧尾以及校验计算自动进行
  • 二维码为该篇文章的地址

    执行文件

    BspComProtocolMaker.rar

    源文件

    简易协议帧生成器.rar