Gitee

https://gitee.com/WangXi_Chn/RttOs_ModuleLib

开发环境

CubeMX
MDK5 IDE
STM32F407IGH6TR 芯片
HC06蓝牙通信模块
Android SPP蓝牙串口助手（下载见文末）
大疆开发板 C型
RT-Thread操作系统
面向对象模块接口设计

大疆M3508直流无刷电机（遥控对象）
大疆C620无刷电机调速器（遥控对象）

硬件条件

  • HC06蓝牙通信模块供电5V

  • STM32与HC06串口通信

    添加驱动

    CubeMX

  • 打开连接蓝牙模块的串口引脚

image.png

  • 注意是否需要引脚重映射，即右侧引脚使能是否正确

    Kconfig

    1.   menuconfig BSP_USING_UART
    2.       bool "Enable UART"
    3.       default y
    4.       select RT_USING_SERIAL
    5.       if BSP_USING_UART
    6.           config BSP_USING_UART1
    7.              bool "Enable UART1"
    8.              default y
    9.           config BSP_USING_UART6
    10.               bool "Enable UART6"
    11.               default y
    12.           config BSP_UART6_RX_USING_DMA
    13.               bool "Enable UART6 RX DMA"
    14.               depends on BSP_USING_UART6 && RT_SERIAL_USING_DMA
    15.               default y        
    16.       endif

  • UART1为RTT操作系统命令行串口

  • 这里添加了UART6，并且使能DMA

    Env

    image.pngimage.png

image.pngimage.png

  • SCON命令生成MDK5工程

    接口函数

    见官方使用手册
    https://www.rt-thread.org/document/site/programming-manual/device/uart/uart/

    官方例程

  • 不定长帧接收，直到收到指定的结束码 ```c /*

    • 程序清单：这是一个串口设备接收不定长数据的示例代码
    • 例程导出了 uart_dma_sample 命令到控制终端
    • 命令调用格式：uart_dma_sample uart2
    • 命令解释：命令第二个参数是要使用的串口设备名称，为空则使用默认的串口设备
    • 程序功能：通过串口 uart2 输出字符串”hello RT-Thread!”，并通过串口 uart2 输入一串字符（不定长），再通过数据解析后，使用控制台显示有效数据。 */

include

define SAMPLE_UART_NAME “uart2”

define DATA_CMD_END ‘\r’ / 结束位设置为 \r，即回车符 /

define ONE_DATA_MAXLEN 20 / 不定长数据的最大长度 /

/ 用于接收消息的信号量 / static struct rt_semaphore rx_sem; static rt_device_t serial;

/ 接收数据回调函数 / static rt_err_t uart_rx_ind(rt_device_t dev, rt_size_t size) { / 串口接收到数据后产生中断，调用此回调函数，然后发送接收信号量 / if (size > 0) { rt_sem_release(&rx_sem); } return RT_EOK; }

static char uart_sample_get_char(void) { char ch;

  1. while (rt_device_read(serial, 0, &ch, 1) == 0)
  2. {
  3.     rt_sem_control(&rx_sem, RT_IPC_CMD_RESET, RT_NULL);
  4.     rt_sem_take(&rx_sem, RT_WAITING_FOREVER);
  5. }
  6. return ch;

}

/ 数据解析线程 / static void data_parsing(void) { char ch; char data[ONE_DATA_MAXLEN]; static char i = 0;

  1. while (1)
  2. {
  3.     ch = uart_sample_get_char();
  4.     rt_device_write(serial, 0, &ch, 1);
  5.     if(ch == DATA_CMD_END)
  6.     {
  7.         data[i++] = '\0';
  8.         rt_kprintf("data=%s\r\n",data);
  9.         i = 0;
  10.         continue;
  11.     }
  12.     i = (i >= ONE_DATA_MAXLEN-1) ? ONE_DATA_MAXLEN-1 : i;
  13.     data[i++] = ch;
  14. }

}

static int uart_data_sample(int argc, char *argv[]) { rt_err_t ret = RT_EOK; char uart_name[RT_NAME_MAX]; char str[] = “hello RT-Thread!\r\n”;

  1. if (argc == 2)
  2. {
  3.     rt_strncpy(uart_name, argv[1], RT_NAME_MAX);
  4. }
  5. else
  6. {
  7.     rt_strncpy(uart_name, SAMPLE_UART_NAME, RT_NAME_MAX);
  8. }
  10. /* 查找系统中的串口设备 */
  11. serial = rt_device_find(uart_name);
  12. if (!serial)
  13. {
  14.     rt_kprintf("find %s failed!\n", uart_name);
  15.     return RT_ERROR;
  16. }
  18. /* 初始化信号量 */
  19. rt_sem_init(&rx_sem, "rx_sem", 0, RT_IPC_FLAG_FIFO);
  20. /* 以中断接收及轮询发送模式打开串口设备 */
  21. rt_device_open(serial, RT_DEVICE_FLAG_INT_RX);
  22. /* 设置接收回调函数 */
  23. rt_device_set_rx_indicate(serial, uart_rx_ind);
  24. /* 发送字符串 */
  25. rt_device_write(serial, 0, str, (sizeof(str) - 1));
  27. /* 创建 serial 线程 */
  28. rt_thread_t thread = rt_thread_create("serial", (void (*)(void *parameter))data_parsing, RT_NULL, 1024, 25, 10);
  29. /* 创建成功则启动线程 */
  30. if (thread != RT_NULL)
  31. {
  32.     rt_thread_startup(thread);
  33. }
  34. else
  35. {
  36.     ret = RT_ERROR;
  37. }
  39. return ret;

}

/ 导出到 msh 命令列表中 / MSH_CMD_EXPORT(uart_data_sample, uart device sample);

  1. <a name="E8ys4"></a>
  2. # 适配模块接口
  3. <a name="vMj9O"></a>
  4. ## Module_BlueToothHC06.h
  5. ```c
  6. /*
  7.  * Copyright (c) 2020 - ~, HIT_HERO Team
  8.  *
  9.  * BLUETOOTH HC06 MODULE HEAD FILE
  10.  * Used in RT-Thread Operate System
  11.  *
  12.  * Change Logs:
  13.  * Date           Author       Notes                Mail
  14.  * 2020-08-09     WangXi       first version        WangXi_chn@foxmail.com
  15.  */
  16. #include <rtthread.h>
  17. #include <rtdevice.h>
  18. #include <board.h>
  20. #ifndef _MODULE_BLUETOOTHHC06_H_
  21. #define _MODULE_BLUETOOTHHC06_H_
  23. typedef enum funcFlag
  24. {
  25.     LED_BlUE_1     = 0xE1,
  26.     LED_GREEN_1,
  27.     LED_RED_1,
  28.     LED_YELLOW_1,
  29.     LED_BlUE_2,
  30.     LED_GREEN_2,
  31.     LED_RED_2,
  32.     LED_YELLOW_2,
  34.     PARAM_SHOW_1 = 0xC1,
  35.     PARAM_SHOW_2,
  36.     PARAM_SHOW_3,
  37.     PARAM_SHOW_4,
  38.     PARAM_SHOW_5,
  39.     PARAM_SHOW_6,
  41.     WAVE_SHOW = 0x01,
  43. }FuncFlag;
  45. enum ConnectStatusFlag
  46. {
  47.     DISCONNECTED = PIN_LOW,
  48.     CONNECTED = PIN_HIGH,
  50. };
  52. struct _MODULE_BLUETOOTHHC06
  53. {
  54.     /* Property */
  55.     char *                 Property_UartDevName; 
  56.     rt_base_t             ConnectStatusPin;
  57.     rt_uint8_t            ConnectCheckSwitch;
  59.     /* Value */
  60.     rt_device_t         Value_uart_dev;
  61.     rt_uint8_t            Value_sendData[8];
  62.     rt_uint8_t            Value_feedData[8];
  64.     rt_uint32_t            ConnectStatus;
  65.     rt_uint16_t            Value_keyMask;
  67.     /* Method */
  68.     void (*Method_Init)(struct _MODULE_BLUETOOTHHC06 *module);
  69.     void (*Method_Send)(struct _MODULE_BLUETOOTHHC06 *module,FuncFlag funcflag,rt_int16_t param);
  70.     void (*Method_Feed)(struct _MODULE_BLUETOOTHHC06 *module);
  71.     void (*Method_Code)(struct _MODULE_BLUETOOTHHC06 *module,FuncFlag funcflag,rt_int16_t param);
  72.     void (*Method_Encode)(struct _MODULE_BLUETOOTHHC06 *module);
  73.     rt_err_t (*Method_Handle)(rt_device_t dev, rt_size_t size);
  75. };
  76. typedef struct _MODULE_BLUETOOTHHC06 MODULE_BLUETOOTHHC06;
  78. rt_err_t Module_BlueToothHC06_Config(MODULE_BLUETOOTHHC06 *module);
  80. #endif
  82. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

Module_BlueToothHC06.c

  1. /*
  2.  * Copyright (c) 2020 - ~, HIT_HERO Team
  3.  *
  4.  * BLUETOOTH HC06 MODULE SOUCE FILE
  5.  * Used in RT-Thread Operate System
  6.  *
  7.  * Change Logs:
  8.  * Date           Author       Notes                Mail
  9.  * 2020-08-09     WangXi       first version        WangXi_chn@foxmail.com
  10.  */
  11. #include "Module_BlueToothHC06.h"
  13. static void     Module_BlueToothHC06Init(MODULE_BLUETOOTHHC06 *module);
  14. static void     Module_BlueToothHC06Send(MODULE_BLUETOOTHHC06 *module,FuncFlag funcflag,rt_int16_t param);
  15. static void     Module_BlueToothHC06Feed(MODULE_BLUETOOTHHC06 *module);
  17. static void     Module_BlueToothHC06Code(MODULE_BLUETOOTHHC06 *module,FuncFlag funcflag,rt_int16_t param);
  18. static void     Module_BlueToothHC06Encode(MODULE_BLUETOOTHHC06 *module);
  20. static rt_err_t Module_BlueToothHC06Handle(rt_device_t dev, rt_size_t size);
  22. static struct rt_semaphore uartBluetoothHC06_sem;
  24. /* Global Method */
  25. rt_err_t Module_BlueToothHC06_Config(MODULE_BLUETOOTHHC06 *module)
  26. {
  27.     if( module->Method_Init        ==NULL &&
  28.         module->Method_Handle    ==NULL &&
  29.         module->Method_Send        ==NULL &&
  30.         module->Method_Feed        ==NULL &&
  31.         module->Method_Code        ==NULL &&
  32.         module->Method_Encode    ==NULL
  34.     ){  
  35.         /* Link the Method */
  36.         module->Method_Init         = Module_BlueToothHC06Init;
  37.         module->Method_Handle        = Module_BlueToothHC06Handle;
  38.         module->Method_Send            = Module_BlueToothHC06Send;
  39.         module->Method_Feed            = Module_BlueToothHC06Feed;
  40.         module->Method_Code            = Module_BlueToothHC06Code;
  41.         module->Method_Encode        = Module_BlueToothHC06Encode;
  43.     }
  44.     else{
  45.         rt_kprintf("Warning: Module BlueTooth HC06 is Configed twice\n");
  46.         return RT_ERROR;
  47.     }
  49.     /* Device Init */
  50.     module->Method_Init(module);
  52.     return RT_EOK;
  53. }
  55. static void Module_BlueToothHC06Init(MODULE_BLUETOOTHHC06 *module)
  56. {
  57.     module->Value_uart_dev = rt_device_find(module->Property_UartDevName);
  58.     if (!module->Value_uart_dev)
  59.     {
  60.         rt_kprintf("find %s failed!\n", module->Value_uart_dev);
  61.         return;
  62.     }
  64.     rt_sem_init(&uartBluetoothHC06_sem, "uartBluetoothHC06_sem", 0, RT_IPC_FLAG_FIFO);
  66.     struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;  /* 初始化配置参数 */
  67.     /* step2：修改串口配置参数 */
  68.     config.baud_rate = BAUD_RATE_9600;        //修改波特率为 9600
  69.     config.data_bits = DATA_BITS_8;           //数据位 8
  70.     config.stop_bits = STOP_BITS_1;           //停止位 1
  71.     config.bufsz     = 128;                   //修改缓冲区 buff size 为 128
  72.     config.parity    = PARITY_NONE;           //无奇偶校验位
  74.     /* step3：控制串口设备。通过控制接口传入命令控制字，与控制参数 */
  75.     rt_device_control(module->Value_uart_dev, RT_DEVICE_CTRL_CONFIG, &config);
  77.     rt_device_open(module->Value_uart_dev, RT_DEVICE_FLAG_DMA_RX);
  79.     rt_device_set_rx_indicate(module->Value_uart_dev, module->Method_Handle);
  81.     /* Enable Connect Status GPIO */
  82.      rt_pin_mode(module->ConnectStatusPin, PIN_MODE_INPUT_PULLDOWN);
  84. }
  86. static void Module_BlueToothHC06Send(MODULE_BLUETOOTHHC06 *module,FuncFlag funcflag,rt_int16_t param)
  87. {
  88.     module->ConnectStatus = rt_pin_read(module->ConnectStatusPin);
  90.     module->Method_Code(module,funcflag,param);
  92.     rt_device_write(    module->Value_uart_dev, 0, 
  93.                         &(module->Value_sendData), 
  94.                         sizeof(module->Value_sendData));
  95. }
  97. static void Module_BlueToothHC06Feed(MODULE_BLUETOOTHHC06 *module)
  98. {
  99.     char ch;
  100.     static char i = 0;
  102.     while (1)
  103.     {    
  104.         while (rt_device_read(module->Value_uart_dev, 0, &ch, 1) == 0)
  105.         {
  106.             rt_sem_control(&uartBluetoothHC06_sem, RT_IPC_CMD_RESET, RT_NULL);
  107.             rt_sem_take(&uartBluetoothHC06_sem, RT_WAITING_FOREVER);
  108.         }
  110.         if((rt_uint8_t)ch == 0xAA)
  111.         {
  112.             /* get the frame end flag and start encode the frame */
  113.             module->Method_Encode(module);
  115.             i = 0;
  116.             continue;
  117.         }
  118.         i = (i >= 8-1) ? 8-1 : i;
  119.         module->Value_feedData[i++] = ch;
  120.     }    
  121. }
  123. static rt_err_t Module_BlueToothHC06Handle(rt_device_t dev, rt_size_t size)
  124. {    
  126.     rt_sem_release(&uartBluetoothHC06_sem);
  128.     return RT_EOK;
  129. }
  131. static void Module_BlueToothHC06Code(MODULE_BLUETOOTHHC06 *module,FuncFlag funcflag,rt_int16_t param)
  132. {
  133.     module->Value_sendData[0] = 0xA5;
  134.     module->Value_sendData[1] = 0x5A;
  136.     switch (funcflag>>4)
  137.     {
  138.         case 0x0E: //LED Show
  139.             module->Value_sendData[2] = 0x05;
  140.             module->Value_sendData[3] = funcflag;
  141.             module->Value_sendData[4] = param;
  142.             module->Value_sendData[5] = (0x05 + funcflag + param)&0xFF;
  143.             module->Value_sendData[6] = 0xAA;
  144.             break;
  145.         case 0x0C: //Param Show
  146.             module->Value_sendData[2] = 0x06;
  147.             module->Value_sendData[3] = funcflag;
  148.             module->Value_sendData[4] = param >> 8;
  149.             module->Value_sendData[5] = param & 0xFF;
  150.             module->Value_sendData[6] = (0x06 + funcflag + (param>>8) + (param&0xFF))&0xFF;
  151.             module->Value_sendData[7] = 0xAA;
  152.             break;
  153.         case 0x00: //Wave Show
  154.             module->Value_sendData[2] = 0x06;
  155.             module->Value_sendData[3] = funcflag;
  156.             module->Value_sendData[4] = param >> 8;
  157.             module->Value_sendData[5] = param & 0xFF;
  158.             module->Value_sendData[6] = (0x06 + funcflag + (param>>8) + (param&0xFF))&0xFF;
  159.             module->Value_sendData[7] = 0xAA;
  160.             break;    
  161.     }        
  162. }
  164. static void Module_BlueToothHC06Encode(MODULE_BLUETOOTHHC06 *module)
  165. {
  166.     if((rt_uint8_t)(module->Value_feedData[0])==0xA5 && (rt_uint8_t)(module->Value_feedData[1])==0x5A)
  167.     {
  168.         rt_uint8_t funcFlag = (rt_uint8_t)(module->Value_feedData[3])>>4;
  169.         rt_uint8_t numFlag  = (rt_uint8_t)(module->Value_feedData[3])&0x0F;
  171.         switch(funcFlag)
  172.         {
  173.             case 0x0B:
  174.                 module->Value_keyMask |= (0x01 << (numFlag-1));break;
  175.         }
  176.     }
  177.     else
  178.     {
  179.         return;
  180.     }
  181. }
  183. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

使用

  1. /*
  2.  * Copyright (c) 2020 - ~, HIT_HERO Team
  3.  *
  4.  * MAIN SOUCE FILE
  5.  * Used in RT-Thread Operate System
  6.  *
  7.  * Change Logs:
  8.  * Date           Author       Notes                Mail
  9.  * 2020-08-08     WangXi       first version        WangXi_chn@foxmail.com
  10.  */
  12. #include <rtthread.h>
  13. #include <rtdevice.h>
  14. #include <board.h>
  16. #include "Module_3508MotorGroup.h"
  17. #include "Module_BlueToothHC06.h"
  19. /* Module param list ---------------------------------------------------------------------------------------- */
  21. MODULE_BLUETOOTHHC06 dev_communicate = 
  22.     {
  23.         .Property_UartDevName    = "uart6",
  24.     };
  26. MODULE_MOTOR3508GROUP dev_motor3508group = 
  27. {
  28.     .Property_CanDevName = "can1",
  29.     .Value_module_motor3508[MOTOR3508ID_1] = 
  30.     {
  31.         .Enable = 1,
  32.         .Mode    = MOTOR3508MODE_SPEED,
  33.         .PID_Speed = 
  34.         {
  35.             .Property_Kp = 6,
  36.             .Property_Ki = 2,
  37.             .Property_Kd = 0,
  38.             .Property_dt = 0.005,
  39.             .Property_integralMax = 500,
  40.             .Property_AimMax = 9000,
  41.             .Property_OutputMax =16300            
  42.         }
  43.     },
  44.     .Value_module_motor3508[MOTOR3508ID_2] = 
  45.     {
  46.         .Enable = 1,
  47.         .Mode    = MOTOR3508MODE_SPEED,
  48.         .PID_Speed = 
  49.         {
  50.             .Property_Kp = 6,
  51.             .Property_Ki = 2,
  52.             .Property_Kd = 0,
  53.             .Property_dt = 0.005,
  54.             .Property_integralMax = 500,
  55.             .Property_AimMax = 9000,
  56.             .Property_OutputMax =16300            
  57.         }
  58.     },
  59.     .Value_module_motor3508[MOTOR3508ID_3] = 
  60.     {
  61.         .Enable = 1,
  62.         .Mode    = MOTOR3508MODE_ANGLE,
  63.         .PID_Speed = 
  64.         {
  65.             .Property_Kp = 6,
  66.             .Property_Ki = 2,
  67.             .Property_Kd = 0,
  68.             .Property_dt = 0.005,
  69.             .Property_integralMax = 500,
  70.             .Property_AimMax = 9000,
  71.             .Property_OutputMax =10000            
  72.         },
  73.         .PID_Angle = 
  74.         {
  75.             .Property_Kp = 4,
  76.             .Property_Ki = 2,
  77.             .Property_Kd = 0,
  78.             .Property_dt = 0.005,
  79.             .Property_integralMax = 500,
  80.             .Property_AimMax = 7200,
  81.             .Property_OutputMax =300    
  82.         },
  83.     },
  84. };
  86. /* thread entry list ---------------------------------------------------------------------------------------- */
  87. static void motor_entry(void *parameter)
  88. {
  89.     while (1)
  90.     {    
  91.         /* Communicate with motor group */        
  92.         dev_motor3508group.Method_Feed(&dev_motor3508group);
  93.         rt_thread_mdelay(1);
  94.         dev_motor3508group.Method_Send(&dev_motor3508group);
  95.     }
  96. }
  98. static void bluetupdata_entry(void *parameter)
  99. {
  100.     dev_communicate.Method_Feed(&dev_communicate);
  101. }
  103. static void bluetcontrol_entry(void *parameter)
  104. {
  105.     static rt_uint32_t time_1000m = 0;
  106.     while(1)
  107.     {
  108.         rt_thread_mdelay(1);
  109.         time_1000m++;
  111.         switch(dev_communicate.Value_keyMask)
  112.         {
  113.             case (0x0001<<0):      //speed up the friction wheel
  114.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_1].Value_motor_AimRPM -= 200;
  115.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_2].Value_motor_AimRPM += 200;
  116.                 break;
  117.             case (0x0001<<1):    //start up the friction wheel
  118.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_1].Value_motor_AimRPM = -1400;
  119.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_2].Value_motor_AimRPM = 1400;
  120.                 break;
  121.             case (0x0001<<2):    //slow down the friction wheel
  122.                 if(dev_motor3508group.Value_module_motor3508[MOTOR3508ID_2].Value_motor_AimRPM >= 200)
  123.                 {
  124.                     dev_motor3508group.Value_module_motor3508[MOTOR3508ID_1].Value_motor_AimRPM += 200;
  125.                     dev_motor3508group.Value_module_motor3508[MOTOR3508ID_2].Value_motor_AimRPM -= 200;
  126.                 }
  127.                 break;
  128.             case (0x0001<<3):    //raise up the paw
  130.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_Kp = 4;
  131.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_Ki = 2;
  132.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_Kd = 0;
  133.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_dt = 0.005;
  134.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_integralMax = 500;
  135.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_AimMax = 7200;
  136.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_OutputMax = 300;
  137.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Speed.Property_OutputMax = 10000;
  139.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].Value_motor_AimAngle = -720;
  140.                 break;
  141.             case (0x0001<<4):    //stop the friction wheel
  142.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_1].Value_motor_AimRPM = 0;
  143.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_2].Value_motor_AimRPM = 0;                
  144.                 break;
  145.             case (0x0001<<5):    //put down the paw
  147.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_Kp = 0.05;
  148.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_Ki = 0.0001;
  149.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_Kd = 0;
  150.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_dt = 0.005;
  151.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_integralMax = 500;
  152.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_AimMax = 7200;
  153.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Angle.Property_OutputMax = 100;
  154.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].PID_Speed.Property_OutputMax = 100;
  156.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_3].Value_motor_AimAngle = 0;
  157.                 break;
  158.             case (0x0001<<6):
  159.                 break;
  160.             case (0x0001<<7):
  161.                 break;
  162.             case (0x0001<<8):
  163.                 break;
  164.             case (0x0001<<9):
  165.                 break;
  166.             case (0x0001<<10):
  167.                 break;
  168.             case (0x0001<<11):
  169.                 break;        
  170.         }
  171.         dev_communicate.Value_keyMask = 0x0000;
  173.         if(time_1000m >= 1000)
  174.         {
  175.             time_1000m = 0;
  177.             dev_communicate.Method_Send(&dev_communicate,PARAM_SHOW_1,
  178.                 dev_motor3508group.Value_module_motor3508[MOTOR3508ID_2].Value_motor_AimRPM/200);            
  179.         }
  180.     }
  181. }
  183. int main(void)
  184. {
  185.     /* Config module ---------------------------------------------------------------------------------------- */
  186.     Module_Motor3508Group_Config(&dev_motor3508group);
  188.     Module_BlueToothHC06_Config(&dev_communicate);
  190.     /* Enable task thread ---------------------------------------------------------------------------------------- */    
  192.     /* motor control thread */
  193.     rt_thread_t motor_thread = rt_thread_create("motor", motor_entry, RT_NULL,
  194.                                   1024, RT_THREAD_PRIORITY_MAX - 2, 20);
  195.     if (motor_thread != RT_NULL){
  196.         rt_thread_startup(motor_thread);
  197.     }
  199.     /* blue tooth updata thread */
  200.     rt_thread_t bluetupdata_thread = rt_thread_create("bluetupdata", bluetupdata_entry, RT_NULL,
  201.                                   512, RT_THREAD_PRIORITY_MAX - 5, 20);
  202.     if (bluetupdata_thread != RT_NULL){
  203.         rt_thread_startup(bluetupdata_thread);
  204.     }    
  206.     /* blue tooth updata thread */
  207.     rt_thread_t bluetcontrol_thread = rt_thread_create("bluetcontrol", bluetcontrol_entry, RT_NULL,
  208.                                   512, RT_THREAD_PRIORITY_MAX - 5, 20);
  209.     if (bluetcontrol_thread != RT_NULL){
  210.         rt_thread_startup(bluetcontrol_thread);
  211.     }
  213. }
  216. /************************ (C) COPYRIGHT 2020 WANGXI **************END OF FILE****/

说明

  • 配合Android手机蓝牙串口助手SPP使用
  • 模块内部已集成遵循软件协议的编码和解码
  • 使用示例中，已实现通过按键调节电机转速，并每一秒一次返回电机转速
  • 按键的使能中也参考了掩码的思想，通过读取一个16位数据的每一位，判断哪个按键被按下
  • 最终留出的函数接口是三个
    • 初始化模块config（全局函数）
    • 发送指令Send（成员函数，即方法）
    • 读取指令Feed（成员函数）
  • 发送指令的参数有三个
    • 模块自身指针
    • 发送指令的功能（用枚举限定，对应手机端的LED、参数、示波）
    • 发送参数（LED仅1和0，其他功能填写想呈现的数据）
  • 现已可实现波形显示功能 2020-8-12

  • 修复了参数回显功能 2020-8-12

    手机SPP下载

    BlueToothSerier.rar

  • 尽可能不要修改手机端默认协议以保持一致