SXDT-Embedded
/
BLE_TYQ_BJQ_CH32V303
mirror of https://gitee.com/SXDT-Embedded/ble_-tyq_-bjq_-ch32-v303.git
6
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

解决了报警器短时间掉电，蓝牙不重启导致的蓝牙连接事件不上报的bug

This commit is contained in:
小马_666 2025-05-12 09:10:25 +08:00
parent de488708ef
commit 4aff0a236e
1 changed files with 273 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

534
bsp/src/bsp_bt.c
View File

@ -4,9 +4,9 @@
* @LastEditors: mbw && 1600520629@qq.com
* @LastEditTime: 2025-05-09 16:48:18
* @FilePath: \ble_bjq_ch303rct6_ml307\bsp\src\bsp_bt.c
* @Description:
*
* Copyright (c) 2025 by ${git_name_email}, All Rights Reserved.
* @Description:
*
* Copyright (c) 2025 by ${git_name_email}, All Rights Reserved.
*/
#include "bsp_bt.h"
#include "bsp_ml307.h"
@ -24,43 +24,45 @@
static rt_device_t rt_bt_device;
static struct rt_semaphore bt_rx_sem; //
struct rt_semaphore bt_ctr_sem; // 控制阀门信号量
struct rt_semaphore bt_reg_sem; // 注册阀门信号量
struct rt_semaphore bt_rem_sem; // 移除阀门信号量
struct rt_semaphore bt_rep_sem; // 更换阀门信号量
static struct rt_semaphore bt_rx_sem; //
struct rt_semaphore bt_ctr_sem; // 控制阀门信号量
struct rt_semaphore bt_reg_sem; // 注册阀门信号量
struct rt_semaphore bt_rem_sem; // 移除阀门信号量
struct rt_semaphore bt_rep_sem; // 更换阀门信号量
#define BT_THREAD_TIMESLICE (20)
#define BT_THREAD_PRIORITY (10)
#define BT_THREAD_TIMESLICE (20)
#define BT_THREAD_PRIORITY (10)
#define BT_THREAD_STACK_SIZE (2048)
ALIGN(RT_ALIGN_SIZE)
ALIGN (RT_ALIGN_SIZE)
static rt_uint8_t bt_thread_stack[BT_THREAD_STACK_SIZE] = {0};
static struct rt_thread bt_thread = {0};
static struct rt_thread bt_thread = {0};
lwrb_t bt_lwrb_rx;
static char bt_rx_buffer[1024] = {0};
BTFrameData bt_frame = {0};
BTFrameData bt_frame = {0};
valve_data valve[MAX_VALVE_NUM] = {0};
rt_size_t BSP_Bt_Send_Data(uint8_t *data, size_t size)
rt_uint8_t to_sever_send_bt_connect_flag = 0;
rt_size_t BSP_Bt_Send_Data (uint8_t *data, size_t size)
{
return rt_device_write(rt_bt_device, 0, data, size);
return rt_device_write (rt_bt_device, 0, data, size);
}
rt_size_t BSP_Bt_Recv_Data(uint8_t *data, size_t size)
rt_size_t BSP_Bt_Recv_Data (uint8_t *data, size_t size)
{
return lwrb_read(&bt_lwrb_rx, data, size);
return lwrb_read (&bt_lwrb_rx, data, size);
}
static rt_err_t bt_getchar(char *ch, rt_int32_t timeout)
static rt_err_t bt_getchar (char *ch, rt_int32_t timeout)
{
rt_err_t result = RT_EOK;
while (rt_device_read(rt_bt_device, 0, ch, 1) == 0)
while (rt_device_read (rt_bt_device, 0, ch, 1) == 0)
{
result = rt_sem_take(&bt_rx_sem, rt_tick_from_millisecond(timeout));
result = rt_sem_take (&bt_rx_sem, rt_tick_from_millisecond (timeout));
if (result != RT_EOK)
{
return result;
@ -69,7 +71,7 @@ static rt_err_t bt_getchar(char *ch, rt_int32_t timeout)
return RT_EOK;
}
static int bt_recv_readline(void)
static int bt_recv_readline (void)
{
rt_size_t read_len = 0;
char ch = 0, last_ch = 0;
@ -77,10 +79,10 @@ static int bt_recv_readline(void)
while (1)
{
bt_getchar(&ch, RT_WAITING_FOREVER);
if (read_len < lwrb_get_free(&bt_lwrb_rx))
bt_getchar (&ch, RT_WAITING_FOREVER);
if (read_len < lwrb_get_free (&bt_lwrb_rx))
{
lwrb_write(&bt_lwrb_rx, &ch, 1);
lwrb_write (&bt_lwrb_rx, &ch, 1);
}
else
{
@ -90,7 +92,7 @@ static int bt_recv_readline(void)
{
if (is_full)
{
LOG_E("read line failed. The line data length is out of buffer size(%d)!", lwrb_get_free(&bt_lwrb_rx));
LOG_E ("read line failed. The line data length is out of buffer size(%d)!", lwrb_get_free (&bt_lwrb_rx));
return -RT_EFULL;
}
@ -98,27 +100,27 @@ static int bt_recv_readline(void)
}
last_ch = ch;
}
return lwrb_get_full(&bt_lwrb_rx);
return lwrb_get_full (&bt_lwrb_rx);
}
/*发送数据帧处理*/
rt_uint8_t BT_GenerateRawFrame(BTFrameData *pRawData, const rt_uint8_t *p_src, rt_uint8_t src_len)
rt_uint8_t BT_GenerateRawFrame (BTFrameData *pRawData, const rt_uint8_t *p_src, rt_uint8_t src_len)
{
pRawData->len = src_len + 4;
rt_memset(pRawData->buf, 0, sizeof(pRawData->buf));
rt_memset (pRawData->buf, 0, sizeof (pRawData->buf));
pRawData->buf[0] = BT_FRAME_HEAD_DATA;
pRawData->buf[1] = src_len;
rt_memmove(&pRawData->buf[2], p_src, src_len);
rt_memmove (&pRawData->buf[2], p_src, src_len);
// 从帧起始符开始到校验码之前所有字节的和的模256
// ，即各字节不计超过255的溢出值的二进制算术和。
pRawData->buf[pRawData->len - 2] = XOR_CheckSum(&pRawData->buf[0], pRawData->len - 2);
pRawData->buf[pRawData->len - 2] = XOR_CheckSum (&pRawData->buf[0], pRawData->len - 2);
pRawData->buf[pRawData->len - 1] = BT_FRAME_TAIL_DATA;
LOG_HEX("BTFrameData", 16, &pRawData->buf[0], pRawData->len);
LOG_HEX ("BTFrameData", 16, &pRawData->buf[0], pRawData->len);
return RT_EOK;
}
@ -128,19 +130,19 @@ rt_uint8_t BT_GenerateRawFrame(BTFrameData *pRawData, const rt_uint8_t *p_src, r
* mac_addr: 6字节
* status: 0-关闭 1-打开
*/
int BSP_Bt_Valve_Ctr(rt_uint8_t id, rt_uint8_t *mac_addr, WireLessState status)
int BSP_Bt_Valve_Ctr (rt_uint8_t id, rt_uint8_t *mac_addr, WireLessState status)
{
rt_uint8_t ret = 0;
BtData_t *ptr = (BtData_t *)rt_malloc(sizeof(BtData_t) + 8);
ptr->cmd = kValveCmdCtr;
ptr->buf[0] = id;
rt_memcpy(&ptr->buf[1], mac_addr, 6);
BtData_t *ptr = (BtData_t *)rt_malloc (sizeof (BtData_t) + 8);
ptr->cmd = kValveCmdCtr;
ptr->buf[0] = id;
rt_memcpy (&ptr->buf[1], mac_addr, 6);
ptr->buf[7] = status;
BT_GenerateRawFrame(&bt_frame, (rt_uint8_t *)ptr, 9);
rt_free(ptr);
BT_GenerateRawFrame (&bt_frame, (rt_uint8_t *)ptr, 9);
rt_free (ptr);
ret = BSP_Bt_Send_Data((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
ret = BSP_Bt_Send_Data ((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
if (ret == bt_frame.len)
{
return RT_EOK;
@ -150,16 +152,16 @@ int BSP_Bt_Valve_Ctr(rt_uint8_t id, rt_uint8_t *mac_addr, WireLessState status)
}
/*注册阀门信息*/
int BSP_Bt_Register_Valve(rt_uint8_t id, rt_uint8_t *mac_addr)
int BSP_Bt_Register_Valve (rt_uint8_t id, rt_uint8_t *mac_addr)
{
rt_uint8_t ret = 0;
BtData_t *ptr = (BtData_t *)rt_malloc(sizeof(BtData_t) + 7);
ptr->cmd = kValveCmdReg;
ptr->buf[0] = id;
rt_memcpy(&ptr->buf[1], mac_addr, 6);
BT_GenerateRawFrame(&bt_frame, (rt_uint8_t *)ptr, 8);
rt_free(ptr);
ret = BSP_Bt_Send_Data((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
BtData_t *ptr = (BtData_t *)rt_malloc (sizeof (BtData_t) + 7);
ptr->cmd = kValveCmdReg;
ptr->buf[0] = id;
rt_memcpy (&ptr->buf[1], mac_addr, 6);
BT_GenerateRawFrame (&bt_frame, (rt_uint8_t *)ptr, 8);
rt_free (ptr);
ret = BSP_Bt_Send_Data ((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
if (ret == bt_frame.len)
{
return RT_EOK;
@ -169,18 +171,18 @@ int BSP_Bt_Register_Valve(rt_uint8_t id, rt_uint8_t *mac_addr)
}
/*移除阀门信息*/
int BSP_Bt_Remove_Valve(rt_uint8_t id, rt_uint8_t *mac_addr)
int BSP_Bt_Remove_Valve (rt_uint8_t id, rt_uint8_t *mac_addr)
{
rt_uint8_t ret = 0;
BtData_t *ptr = (BtData_t *)rt_malloc(sizeof(BtData_t) + 7);
ptr->cmd = kValveCmdRem;
ptr->buf[0] = id;
rt_memcpy(&ptr->buf[1], mac_addr, 6);
BT_GenerateRawFrame(&bt_frame, (rt_uint8_t *)ptr, 8);
rt_free(ptr);
BtData_t *ptr = (BtData_t *)rt_malloc (sizeof (BtData_t) + 7);
ptr->cmd = kValveCmdRem;
ptr->buf[0] = id;
rt_memcpy (&ptr->buf[1], mac_addr, 6);
BT_GenerateRawFrame (&bt_frame, (rt_uint8_t *)ptr, 8);
rt_free (ptr);
ret = BSP_Bt_Send_Data((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
ret = BSP_Bt_Send_Data ((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
if (ret == bt_frame.len)
{
return RT_EOK;
@ -190,17 +192,17 @@ int BSP_Bt_Remove_Valve(rt_uint8_t id, rt_uint8_t *mac_addr)
}
/*移除所有阀门信息*/
int BSP_Bt_Remove_All_Valve(void)
int BSP_Bt_Remove_All_Valve (void)
{
rt_uint8_t ret = 0;
BtData_t *ptr = (BtData_t *)rt_malloc(sizeof(BtData_t) + 7);
ptr->cmd = kValveCmdRemAll;
ptr->buf[0] = 0;
BT_GenerateRawFrame(&bt_frame, (rt_uint8_t *)ptr, 2);
rt_free(ptr);
BtData_t *ptr = (BtData_t *)rt_malloc (sizeof (BtData_t) + 7);
ptr->cmd = kValveCmdRemAll;
ptr->buf[0] = 0;
BT_GenerateRawFrame (&bt_frame, (rt_uint8_t *)ptr, 2);
rt_free (ptr);
ret = BSP_Bt_Send_Data((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
ret = BSP_Bt_Send_Data ((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
if (ret == bt_frame.len)
{
return RT_EOK;
@ -210,19 +212,19 @@ int BSP_Bt_Remove_All_Valve(void)
}
/*更换阀门信息*/
int BSP_Bt_Replace_Valve(rt_uint8_t id, rt_uint8_t *mac_addr, rt_uint8_t *new_mac_addr)
int BSP_Bt_Replace_Valve (rt_uint8_t id, rt_uint8_t *mac_addr, rt_uint8_t *new_mac_addr)
{
rt_uint8_t ret = 0;
BtData_t *ptr = (BtData_t *)rt_malloc(sizeof(BtData_t) + 14);
ptr->cmd = kValveCmdRep;
ptr->buf[0] = id;
rt_memcpy(&ptr->buf[1], mac_addr, 6);
rt_memcpy(&ptr->buf[7], new_mac_addr, 6);
BT_GenerateRawFrame(&bt_frame, (rt_uint8_t *)ptr, (sizeof(BtData_t) + 14));
rt_free(ptr);
BtData_t *ptr = (BtData_t *)rt_malloc (sizeof (BtData_t) + 14);
ptr->cmd = kValveCmdRep;
ptr->buf[0] = id;
rt_memcpy (&ptr->buf[1], mac_addr, 6);
rt_memcpy (&ptr->buf[7], new_mac_addr, 6);
BT_GenerateRawFrame (&bt_frame, (rt_uint8_t *)ptr, (sizeof (BtData_t) + 14));
rt_free (ptr);
ret = BSP_Bt_Send_Data((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
ret = BSP_Bt_Send_Data ((rt_uint8_t *)&bt_frame.buf[0], bt_frame.len);
if (ret == bt_frame.len)
{
return RT_EOK;
@ -231,56 +233,56 @@ int BSP_Bt_Replace_Valve(rt_uint8_t id, rt_uint8_t *mac_addr, rt_uint8_t *new_ma
return RT_ERROR;
}
int Bt_Valve_Handler(ValveCmdType type, rt_uint8_t id, rt_uint8_t *data)
int Bt_Valve_Handler (ValveCmdType type, rt_uint8_t id, rt_uint8_t *data)
{
int ret = RT_EOK;
switch (type)
{
case kValveCmdCtr: // 阀门控制
ret = BSP_Bt_Valve_Ctr(id, &data[0], WirelessValveClose); // 关阀门
break;
case kValveCmdReg: // 阀门注册
ret = BSP_Bt_Register_Valve(id, &data[0]);
break;
case kValveCmdRem: // 阀门移除
ret = BSP_Bt_Remove_Valve(id, &data[0]);
break;
case kValveCmdRep: // 阀门更换
ret = BSP_Bt_Replace_Valve(id, &data[0], &data[6]);
break;
case kValveCmdRemAll: // 阀门更换
case kValveCmdCtr: // 阀门控制
ret = BSP_Bt_Valve_Ctr (id, &data[0], WirelessValveClose); // 关阀门
break;
case kValveCmdReg: // 阀门注册
ret = BSP_Bt_Register_Valve (id, &data[0]);
break;
case kValveCmdRem: // 阀门移除
ret = BSP_Bt_Remove_Valve (id, &data[0]);
break;
case kValveCmdRep: // 阀门更换
ret = BSP_Bt_Replace_Valve (id, &data[0], &data[6]);
break;
case kValveCmdRemAll: // 阀门更换
ret = BSP_Bt_Remove_All_Valve();
break;
default:
ret = -RT_ERROR;
LOG_E("unknown valve command type");
break;
default:
ret = -RT_ERROR;
LOG_E ("unknown valve command type");
break;
}
return ret;
}
int BSP_Bt_Process(uint8_t *data, uint16_t len)
int BSP_Bt_Process (uint8_t *data, uint16_t len)
{
int ret = 0;
uint16_t index = 0;
int ret = 0;
uint16_t index = 0;
rt_uint8_t end_index = 0;
uint8_t data_buf[256] = {0};
// 解析接收到的数据帧，先寻找AA开头，然后再找AA下一个字节，其代表了数据长度，然后找到代表长度的值的长度的下一位，其为校验码，校验码后为结束码0x55，
// 如果数据正确，则提取数据，不正确，则不处理
LOG_HEX("BT_RX_DATA", 16, data, len);
LOG_D("len = %d", len);
LOG_HEX ("BT_RX_DATA", 16, data, len);
LOG_D ("len = %d", len);
if (len < 4)
{ // 至少需要 4 个字节：起始码、长度、校验码、结束码
LOG_E("长度不对 [1]");
{ // 至少需要 4 个字节：起始码、长度、校验码、结束码
LOG_E ("长度不对 [1]");
;
return 1;
}
while (index < len && data[index] != 0xAA) // 寻找起始码 0xAA
while (index < len && data[index] != 0xAA) // 寻找起始码 0xAA
{
index++;
}
for (size_t i = 0; i < (len - 3); i++)//发现了一种情况，会出现两个AA，用这种方法排除一下
for (size_t i = 0; i < (len - 3); i++) // 发现了一种情况，会出现两个AA，用这种方法排除一下
{
if (data[index + i + 1] == 0XAA)
{
@ -291,174 +293,182 @@ int BSP_Bt_Process(uint8_t *data, uint16_t len)
break;
}
}
while (end_index < len && data[end_index] != 0x55) // 寻找起始码 0xAA
while (end_index < len && data[end_index] != 0x55) // 寻找起始码 0xAA
{
end_index++;
}
uint16_t datalength = data[index + 1]; // 读取数据长度
LOG_D("datalength = %d", datalength);
uint16_t datalength = data[index + 1]; // 读取数据长度
LOG_D ("datalength = %d", datalength);
uint8_t rx_sum = data[index + 2 + datalength]; // 读取校验码
uint8_t calculated_sum = XOR_CheckSum(&data[index], datalength + 2); // 计算校验码
uint8_t rx_sum = data[index + 2 + datalength]; // 读取校验码
uint8_t calculated_sum = XOR_CheckSum (&data[index], datalength + 2); // 计算校验码
if (rx_sum != calculated_sum)
{
LOG_E("校验和不对 rx_sum[%02X] != calculated_sum[%02X]", rx_sum, calculated_sum);
LOG_HEX("bt_rx_data:", 16, data, len);
lwrb_reset(&bt_lwrb_rx);
LOG_E ("校验和不对 rx_sum[%02X] != calculated_sum[%02X]", rx_sum, calculated_sum);
LOG_HEX ("bt_rx_data:", 16, data, len);
lwrb_reset (&bt_lwrb_rx);
return 4;
}
if (data[index + 1 + datalength + 2] != data[end_index])// 检查结束码
if (data[index + 1 + datalength + 2] != data[end_index]) // 检查结束码
{
LOG_E("结束码位置错误");
LOG_HEX("bt_rx_data:", 16, data, len);
lwrb_reset(&bt_lwrb_rx);
LOG_E ("结束码位置错误");
LOG_HEX ("bt_rx_data:", 16, data, len);
lwrb_reset (&bt_lwrb_rx);
return 5;
}
rt_uint8_t fram_len = datalength + 4;
// 当程序走到这里时，就说明接收到了正确的数据帧，开始解析响应
rt_memcpy(data_buf, &data[index], fram_len);
rt_memcpy (data_buf, &data[index], fram_len);
switch (data[index + 2])
{
case kValveEventCtr:
LOG_D("valve control event");
if (data_buf[fram_len - 3] == WirelessValveClose) // 关闭成功
{
rt_sem_release(&bt_ctr_sem);
}
break;
case kValveEventReg:
if (data_buf[fram_len - 3] == RT_TRUE) // 注册成功)
{
LOG_I("接收到阀门注册响应:");
LOG_HEX("bt_rx_data:", 16, data_buf, fram_len);
case kValveEventCtr:
LOG_D ("valve control event");
if (data_buf[fram_len - 3] == WirelessValveClose) // 关闭成功
{
rt_sem_release (&bt_ctr_sem);
}
break;
case kValveEventReg:
if (data_buf[fram_len - 3] == RT_TRUE) // 注册成功)
{
LOG_I ("接收到阀门注册响应:");
LOG_HEX ("bt_rx_data:", 16, data_buf, fram_len);
rt_sem_release(&bt_reg_sem);
}
break;
case kValveEventRem:
if (data_buf[fram_len - 3] == RT_TRUE) // 移除成功
rt_sem_release (&bt_reg_sem);
}
break;
case kValveEventRem:
if (data_buf[fram_len - 3] == RT_TRUE) // 移除成功
{
LOG_D ("移除阀门响应成功");
rt_sem_release (&bt_rem_sem);
}
break;
case kValveEventRep:
if (data_buf[fram_len - 3] == RT_TRUE) // 更换成功
{
LOG_D ("阀门更换响应成功");
rt_sem_release (&bt_rep_sem);
}
else
{
LOG_E ("阀门更换失败");
}
break;
case kValveEventRemAll:
LOG_I ("接收到移除所有阀门信息回应");
LOG_HEX ("bt_rx_data:", 16, data_buf, fram_len);
if (data_buf[fram_len - 3] == RT_TRUE) // 移除成功
{
LOG_D ("移除阀门响应成功");
rt_sem_release (&bt_rem_sem);
}
break;
case kValveEventStatus:
LOG_I ("接收到阀门心跳数据：");
LOG_HEX ("bt_rx_data:", 16, data_buf, fram_len);
// TODO:添加阀门数据处理函数
rt_memcpy (&valve[data_buf[3] - 1], &data_buf[3], sizeof (struct valve_t));
LOG_HEX ("valve_data:", 16, (rt_uint8_t *)&valve[data_buf[3] - 1], sizeof (struct valve_t));
if (!to_sever_send_bt_connect_flag)
{
while (!power_on_send_flag)
{
LOG_D("移除阀门响应成功");
rt_sem_release(&bt_rem_sem);
rt_thread_mdelay (100);
}
break;
case kValveEventRep:
if (data_buf[fram_len - 3] == RT_TRUE) // 更换成功
{
LOG_D("阀门更换响应成功");
rt_sem_release(&bt_rep_sem);
}
else
{
LOG_E("阀门更换失败");
}
break;
case kValveEventRemAll:
LOG_I("接收到移除所有阀门信息回应");
LOG_HEX("bt_rx_data:", 16, data_buf, fram_len);
if (data_buf[fram_len - 3] == RT_TRUE) // 移除成功
{
LOG_D("移除阀门响应成功");
rt_sem_release(&bt_rem_sem);
}
break;
case kValveEventStatus:
LOG_I("接收到阀门心跳数据：");
LOG_HEX("bt_rx_data:", 16, data_buf, fram_len);
// TODO:添加阀门数据处理函数
rt_memcpy(&valve[data_buf[3] - 1], &data_buf[3], sizeof(struct valve_t));
LOG_HEX("valve_data:", 16, (rt_uint8_t *)&valve[data_buf[3] - 1], sizeof(struct valve_t));
to_sever_send_bt_connect_flag = 1;
Ml307_Send_Event (kMl307ValveConnectEvent);
}
break;
case kValveEventConnect:
LOG_I ("接收到阀门连接状态数据");
LOG_HEX ("bt_rx_data:", 16, data_buf, fram_len);
break;
case kValveEventConnect:
LOG_I("接收到阀门连接状态数据");
LOG_HEX("bt_rx_data:", 16, data_buf, fram_len);
rt_memcpy(&valve[data_buf[3] - 1], &data_buf[3], sizeof(struct valve_t) - 14);//只要前面的一部分数据，后面的不要
LOG_HEX("valve_data:", 16, (rt_uint8_t *)&valve[data_buf[3] - 1], sizeof(struct valve_t));
if(valve[data_buf[3] - 1].valve_connct_status == 1)
rt_memcpy (&valve[data_buf[3] - 1], &data_buf[3], sizeof (struct valve_t) - 14); // 只要前面的一部分数据，后面的不要
LOG_HEX ("valve_data:", 16, (rt_uint8_t *)&valve[data_buf[3] - 1], sizeof (struct valve_t));
if (valve[data_buf[3] - 1].valve_connct_status == 1)
{
LOG_D ("阀门连接");
while (!power_on_send_flag)
{
LOG_D("阀门连接");
while (!power_on_send_flag)
{
rt_thread_mdelay(100);
}
Ml307_Send_Event(kMl307ValveConnectEvent);
rt_thread_mdelay (100);
}
else
to_sever_send_bt_connect_flag = 1;
Ml307_Send_Event (kMl307ValveConnectEvent);
}
else
{
LOG_D ("阀门断开");
while (!power_on_send_flag)
{
LOG_D("阀门断开");
while (!power_on_send_flag)
{
rt_thread_mdelay(100);
}
Ml307_Send_Event(KMl307ValveDisconnectEvent);
rt_thread_mdelay (100);
}
break;
default:
LOG_W("unknow cmd: %02X", data[index + 2]);
break;
to_sever_send_bt_connect_flag = 0;
Ml307_Send_Event (KMl307ValveDisconnectEvent);
}
break;
default:
LOG_W ("unknow cmd: %02X", data[index + 2]);
break;
}
return ret;
}
static void BSP_Bt_Parse_Data(void)
static void BSP_Bt_Parse_Data (void)
{
rt_size_t len = lwrb_get_full(&bt_lwrb_rx);
char *rx_ptr = rt_malloc(len + 1);
rt_size_t len = lwrb_get_full (&bt_lwrb_rx);
char *rx_ptr = rt_malloc (len + 1);
// rt_uint8_t bt_rx_buf[256] = {0};
BSP_Bt_Recv_Data((uint8_t *)rx_ptr, len);
BSP_Bt_Recv_Data ((uint8_t *)rx_ptr, len);
// 发送过来的数据格式为：帧头 + 数据长度 + 事件类型 + 数据 + 校验码 + 帧尾
BSP_Bt_Process((uint8_t *)rx_ptr, len);
rt_free(rx_ptr);
BSP_Bt_Process ((uint8_t *)rx_ptr, len);
rt_free (rx_ptr);
}
void BSP_Bt_Valve_Updata(void)
void BSP_Bt_Valve_Updata (void)
{
uint8_t cnt = 0;
uint8_t cnt = 0;
uint8_t mac[6] = {0};
uint8_t num = Flash_Get_Valve_Num();
LOG_D("BSP_Bt_Valve_Updata num: %d ", num);
uint8_t num = Flash_Get_Valve_Num();
LOG_D ("BSP_Bt_Valve_Updata num: %d ", num);
if (num == 0)
{
return;
}
rt_memset(&valve[0], 0, sizeof(valve_data));
for (int i = 1; i <= MAX_VALVE_NUM; i++) // 这个循环是为了将数据拷贝到valve_list中， 并且保证id号和flash对应起来
rt_memset (&valve[0], 0, sizeof (valve_data));
for (int i = 1; i <= MAX_VALVE_NUM; i++) // 这个循环是为了将数据拷贝到valve_list中， 并且保证id号和flash对应起来
{
if (Flash_Get_Mac_Addr(mac, i) == RT_EOK) // 说明有MAC数据
if (Flash_Get_Mac_Addr (mac, i) == RT_EOK) // 说明有MAC数据
{
rt_memcpy(valve[cnt].valve_mac, mac, 6); // 这样做的目的就是读取方便，只需要根据flash中读取到的数量进行读取前N个值
rt_memcpy (valve[cnt].valve_mac, mac, 6); // 这样做的目的就是读取方便，只需要根据flash中读取到的数量进行读取前N个值
valve[cnt].valve_id = i;
LOG_D("updata valve_id: %d, valve_mac: %02X %02X %02X %02X %02X %02X",
valve[cnt].valve_id,
valve[cnt].valve_mac[0],
valve[cnt].valve_mac[1],
valve[cnt].valve_mac[2],
valve[cnt].valve_mac[3],
valve[cnt].valve_mac[4],
valve[cnt].valve_mac[5]);
LOG_D ("updata valve_id: %d, valve_mac: %02X %02X %02X %02X %02X %02X",
valve[cnt].valve_id,
valve[cnt].valve_mac[0],
valve[cnt].valve_mac[1],
valve[cnt].valve_mac[2],
valve[cnt].valve_mac[3],
valve[cnt].valve_mac[4],
valve[cnt].valve_mac[5]);
cnt++;
break;
}
else
{
LOG_D("BSP_Bt_Valve_Updata: flash read error");
LOG_D ("BSP_Bt_Valve_Updata: flash read error");
break;
}
}
Flash_Set_Valve_Num(cnt);
Flash_Set_Valve_Num (cnt);
}
static void Bt_Thread_Entry(void *parameter)
static void Bt_Thread_Entry (void *parameter)
{
#if 0
// 初始化阀门信息 测试用
@ -472,13 +482,13 @@ static void Bt_Thread_Entry(void *parameter)
Flash_Set_Mac_Addr(valve[0].valve_mac, 0);
Flash_Set_Valve_Num(1);
#endif //0
#endif // 0
BSP_Bt_Valve_Updata();
lwrb_init(&bt_lwrb_rx, bt_rx_buffer, sizeof(bt_rx_buffer));
lwrb_reset(&bt_lwrb_rx);
lwrb_init (&bt_lwrb_rx, bt_rx_buffer, sizeof (bt_rx_buffer));
lwrb_reset (&bt_lwrb_rx);
LOG_D("Bt_Thread_Entry");
LOG_D ("Bt_Thread_Entry");
while (1)
{
if (bt_recv_readline())
@ -489,88 +499,90 @@ static void Bt_Thread_Entry(void *parameter)
}
/* 接收数据回调函数 */
static rt_err_t Bt_Rcv_Cb(rt_device_t dev, rt_size_t size)
static rt_err_t Bt_Rcv_Cb (rt_device_t dev, rt_size_t size)
{
rt_sem_release(&bt_rx_sem);
rt_sem_release (&bt_rx_sem);
return RT_EOK;
}
int BSP_Bt_Init(void)
int BSP_Bt_Init (void)
{
rt_err_t ret = RT_EOK;
rt_sem_init(&bt_rx_sem, "bt_rx_sem", 0, RT_IPC_FLAG_PRIO); /* 接收来自蓝牙主机的信号量 */
rt_sem_init(&bt_ctr_sem, "bt_ctr_sem", 0, RT_IPC_FLAG_PRIO);
rt_sem_init(&bt_reg_sem, "bt_reg_sem", 0, RT_IPC_FLAG_PRIO);
rt_sem_init(&bt_rem_sem, "bt_rem_sem", 0, RT_IPC_FLAG_PRIO);
rt_sem_init(&bt_rep_sem, "bt_rep_sem", 0, RT_IPC_FLAG_PRIO);
rt_sem_init (&bt_rx_sem, "bt_rx_sem", 0, RT_IPC_FLAG_PRIO); /* 接收来自蓝牙主机的信号量 */
rt_sem_init (&bt_ctr_sem, "bt_ctr_sem", 0, RT_IPC_FLAG_PRIO);
rt_sem_init (&bt_reg_sem, "bt_reg_sem", 0, RT_IPC_FLAG_PRIO);
rt_sem_init (&bt_rem_sem, "bt_rem_sem", 0, RT_IPC_FLAG_PRIO);
rt_sem_init (&bt_rep_sem, "bt_rep_sem", 0, RT_IPC_FLAG_PRIO);
/* 查找系统中的串口设备 */
rt_bt_device = rt_device_find(BT_UART);
rt_bt_device = rt_device_find (BT_UART);
if (!rt_bt_device)
{
LOG_E("find %s failed!\n", BT_UART);
LOG_E ("find %s failed!\n", BT_UART);
return RT_ERROR;
}
/* 以中断接收模式打开串口设备 */
if (rt_device_open(rt_bt_device, RT_DEVICE_FLAG_INT_RX) != RT_EOK)
if (rt_device_open (rt_bt_device, RT_DEVICE_FLAG_INT_RX) != RT_EOK)
{
LOG_E("rt_device_open failed!\n");
LOG_E ("rt_device_open failed!\n");
return RT_ERROR;
}
/* 设置接收回调函数 */
if (rt_device_set_rx_indicate(rt_bt_device, Bt_Rcv_Cb) != RT_EOK)
if (rt_device_set_rx_indicate (rt_bt_device, Bt_Rcv_Cb) != RT_EOK)
{
LOG_E("rt_device_set_rx_indicate failed!\n");
LOG_E ("rt_device_set_rx_indicate failed!\n");
return RT_ERROR;
}
/* 静态初始化线程 1*/
ret = rt_thread_init(&bt_thread, // 该线程用于数据解析
"bt_thread",
Bt_Thread_Entry,
RT_NULL,
&bt_thread_stack[0],
sizeof(bt_thread_stack),
BT_THREAD_PRIORITY,
BT_THREAD_TIMESLICE);
ret = rt_thread_init (&bt_thread, // 该线程用于数据解析
"bt_thread",
Bt_Thread_Entry,
RT_NULL,
&bt_thread_stack[0],
sizeof (bt_thread_stack),
BT_THREAD_PRIORITY,
BT_THREAD_TIMESLICE);
/* 创建成功则启动线程 */
rt_thread_startup(&bt_thread);
rt_thread_startup (&bt_thread);
return ret;
}
// INIT_COMPONENT_EXPORT(BSP_Bt_Init);
#ifdef TEST_ENABLE
static void TEST_BT_Send_Data(int argc, char **argv)
static void TEST_BT_Send_Data (int argc, char **argv)
{
if (argc == 3)
{
int mode = atoi(argv[1]);
int id = atoi(argv[2]) - 1;
int mode = atoi (argv[1]);
int id = atoi (argv[2]) - 1;
switch (mode)
{
case 1:
Bt_Valve_Handler(kValveCmdCtr, id, RT_NULL);
break;
case 2:
Flash_Set_Valve_Num(1);
Bt_Valve_Handler(kValveCmdReg, id, RT_NULL);
break;
case 3:
Bt_Valve_Handler(kValveCmdRem, id, RT_NULL);
rt_memset(valve[0].valve_mac, 0, sizeof(struct valve_t));
Flash_Set_Mac_Addr(valve[0].valve_mac, 0);
Flash_Set_Valve_Num(0);
break;
case 4:
Bt_Valve_Handler(kValveCmdRep, id, RT_NULL);
break;
default:
break;
case 1:
Bt_Valve_Handler (kValveCmdCtr, id, RT_NULL);
break;
case 2:
Flash_Set_Valve_Num (1);
Bt_Valve_Handler (kValveCmdReg, id, RT_NULL);
break;
case 3:
Bt_Valve_Handler (kValveCmdRem, id, RT_NULL);
rt_memset (valve[0].valve_mac, 0, sizeof (struct valve_t));
Flash_Set_Mac_Addr (valve[0].valve_mac, 0);
Flash_Set_Valve_Num (0);
break;
case 4:
Bt_Valve_Handler (kValveCmdRep, id, RT_NULL);
break;
default:
break;
}
}
}
MSH_CMD_EXPORT(TEST_BT_Send_Data, "TEST_BT_Send_Data");
MSH_CMD_EXPORT (TEST_BT_Send_Data, "TEST_BT_Send_Data");
#endif