778 lines
18 KiB
C
778 lines
18 KiB
C
#include "ble_demo.h"
|
||
#include "at_host.h"
|
||
#include "rtthread.h"
|
||
#include "stdlib.h"
|
||
#include "string.h"
|
||
#include <stdio.h>
|
||
|
||
// 在同一个线程中调用则不需要加临界区
|
||
#if 1
|
||
#include "rthw.h"
|
||
#define IRQ_DISABLE() rt_enter_critical()
|
||
#define IRQ_ENABLE() rt_exit_critical()
|
||
#else
|
||
#define IRQ_DISABLE() \
|
||
{ \
|
||
}
|
||
#define IRQ_ENABLE() \
|
||
{ \
|
||
}
|
||
#endif
|
||
|
||
/*------------------------buff相关操作函数---------------------------*/
|
||
|
||
// 清空buff
|
||
static int buff_clear(ble_buff *buff);
|
||
|
||
// 初始化buff
|
||
static void buff_init(ble_buff *buff) {
|
||
buff->buff_len = BLE_BUFF_LEN;
|
||
buff_clear(buff);
|
||
}
|
||
|
||
// 写入一个字节
|
||
static int buff_save_byte(ble_buff *buff, uint8_t data) {
|
||
IRQ_DISABLE();
|
||
if (buff->buff_used < buff->buff_len) {
|
||
buff->buff[buff->save_ptr] = data;
|
||
buff->buff_used++;
|
||
buff->save_ptr++;
|
||
if (buff->save_ptr >= buff->buff_len)
|
||
buff->save_ptr = 0;
|
||
IRQ_ENABLE();
|
||
return 1;
|
||
}
|
||
IRQ_ENABLE();
|
||
return 0;
|
||
}
|
||
|
||
// 读取一个字节
|
||
static int buff_read_byte(ble_buff *buff, uint8_t *data) {
|
||
IRQ_DISABLE();
|
||
if (buff->buff_used) {
|
||
*data = buff->buff[buff->read_ptr];
|
||
buff->buff_used--;
|
||
buff->read_ptr++;
|
||
if (buff->read_ptr >= buff->buff_len)
|
||
buff->read_ptr = 0;
|
||
IRQ_ENABLE();
|
||
return 1;
|
||
}
|
||
IRQ_ENABLE();
|
||
return 0;
|
||
}
|
||
|
||
// 查找buff中是否有指定字符
|
||
static int buff_find_char(ble_buff *buff, uint8_t data) {
|
||
int ptr = buff->read_ptr;
|
||
int len = buff->buff_used;
|
||
while (len--) {
|
||
if (data == buff->buff[ptr])
|
||
return 1;
|
||
ptr++;
|
||
if (ptr >= buff->buff_len)
|
||
ptr = 0;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 清空buff
|
||
static int buff_clear(ble_buff *buff) {
|
||
IRQ_DISABLE();
|
||
buff->buff_used = 0;
|
||
buff->read_ptr = 0;
|
||
buff->save_ptr = 0;
|
||
IRQ_ENABLE();
|
||
return 0;
|
||
}
|
||
|
||
/*------------------------buff相关操作函数End---------------------------*/
|
||
|
||
/*------------------------device相关操作函数---------------------------*/
|
||
|
||
// 初始化蓝牙设备
|
||
int device_init(ble_device *device) {
|
||
device->conn_handle = 0;
|
||
device->linked = 0;
|
||
memset(device->mac, 0, 6);
|
||
buff_init(&device->buff_recv);
|
||
return 1;
|
||
}
|
||
|
||
// 设置此设备的mac地址
|
||
int device_set_mac(ble_device *device, uint8_t mac[6]) {
|
||
memcpy(device->mac, mac, 6);
|
||
return 1;
|
||
}
|
||
|
||
// 设置此设备的conn_handle
|
||
int device_set_handle(ble_device *device, uint16_t handle) {
|
||
device->conn_handle = handle;
|
||
return 1;
|
||
}
|
||
|
||
// 把数据存入设备缓冲
|
||
int device_save_buff(ble_device *device, uint8_t *buff, int size) {
|
||
int ret = 0;
|
||
while (size--) {
|
||
if (buff_save_byte(&device->buff_recv, buff[ret]) == 0)
|
||
return ret;
|
||
ret++;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// 读取设备缓冲,直到遇到界定符
|
||
int device_read_buff(ble_device *device, uint8_t *buff, int buff_size,
|
||
uint8_t end_par) {
|
||
if (buff_find_char(&device->buff_recv, end_par) == 0)
|
||
return 0;
|
||
|
||
int ret = 0;
|
||
uint8_t t = 0;
|
||
while (1) {
|
||
if (buff_read_byte(&device->buff_recv, &t) == 0)
|
||
return ret;
|
||
if (buff_size) {
|
||
buff[ret] = t;
|
||
buff_size--;
|
||
ret++;
|
||
}
|
||
if (t == end_par)
|
||
return ret;
|
||
}
|
||
}
|
||
|
||
// 读取设备缓冲,指定长度
|
||
int device_read_buff_by_len(ble_device *device, uint8_t *buff, int read_len) {
|
||
|
||
int ret = 0;
|
||
uint8_t t = 0;
|
||
while (1) {
|
||
if (buff_read_byte(&device->buff_recv, &t) == 0)
|
||
return ret;
|
||
if (read_len) {
|
||
buff[ret] = t;
|
||
read_len--;
|
||
ret++;
|
||
} else
|
||
return ret;
|
||
}
|
||
}
|
||
|
||
/*------------------------device相关操作函数End---------------------------*/
|
||
|
||
static void ble_print_data(uint8_t *data, int len) {
|
||
for (int i = 0; i < len; i++) {
|
||
printf("%02X ", data[i]);
|
||
}
|
||
printf("\r\n");
|
||
}
|
||
|
||
/*--------------------------ble相关操作函数----------------------------*/
|
||
|
||
// 添加通知消息
|
||
int ble_add_notice(ble_struct *ble, uint8_t *obj, int obj_size, uint8_t op,
|
||
uint8_t *par, int par_size);
|
||
|
||
// 连接事务改变
|
||
int ble_linked_change(ble_struct *ble, uint16_t handle, uint16_t state);
|
||
|
||
// 收到数据
|
||
int ble_save_data(ble_struct *ble, uint16_t handle, uint8_t *data, int len);
|
||
|
||
// 返回指定句柄的设备
|
||
ble_device *ble_find_device(ble_struct *ble, uint16_t handle);
|
||
|
||
// 添加设备
|
||
int ble_add_device(ble_struct *ble, uint16_t handle);
|
||
|
||
// 删除设备
|
||
int ble_sub_device(ble_struct *ble, uint16_t handle);
|
||
|
||
static int ble_service_on(void *t);
|
||
static int ble_service_off(void);
|
||
|
||
// ble初始化
|
||
void ble_init(ble_struct *ble) {
|
||
if (ble == 0)
|
||
return;
|
||
memset(ble, 0, sizeof(ble_struct));
|
||
at_init();
|
||
ble->mode = 'i';
|
||
ble->linked = 0;
|
||
for (int i = 0; i < BLE_MAX_LINKED; i++) {
|
||
device_init(&ble->device[i]);
|
||
}
|
||
at_clear_buff();
|
||
ble->ret_event = rt_event_create("ble_ret", RT_IPC_FLAG_FIFO);
|
||
ble->kno_event = rt_event_create("ble_kno", RT_IPC_FLAG_FIFO);
|
||
rt_event_send(ble->kno_event, 2);
|
||
ble_service_on(ble);
|
||
ble_reboot(ble);
|
||
}
|
||
|
||
// ble去初始化
|
||
void ble_deinit(ble_struct *ble) {
|
||
if (ble == 0)
|
||
return;
|
||
ble_reboot(ble);
|
||
ble_service_off();
|
||
at_deinit();
|
||
if (ble->ret_event)
|
||
rt_event_delete(ble->ret_event);
|
||
if (ble->kno_event)
|
||
rt_event_delete(ble->kno_event);
|
||
}
|
||
|
||
// 设置回调函数
|
||
int ble_set_callback_linked_change(ble_struct *ble,
|
||
void (*linked_change)(uint16_t handle,
|
||
uint16_t state)) {
|
||
ble->linked_change = linked_change;
|
||
return 1;
|
||
}
|
||
int ble_set_callback_recv_data(ble_struct *ble,
|
||
void (*recv_data)(uint16_t handle, uint8_t *data,
|
||
int len)) {
|
||
ble->recv_data = recv_data;
|
||
return 1;
|
||
}
|
||
int ble_set_callback_user_irq(ble_struct *ble,
|
||
void (*user_irq)(uint8_t *data, int len)) {
|
||
ble->user_irq = user_irq;
|
||
return 1;
|
||
}
|
||
|
||
// 处理通知消息
|
||
int ble_deal_notice(ble_struct *ble) {
|
||
if (ble == 0)
|
||
return 0;
|
||
int len = 0;
|
||
uint8_t *data = ble->return_line;
|
||
len = at_get_return_line(data);
|
||
if (len == -1) {
|
||
return 0;
|
||
}
|
||
uint8_t *par = 0;
|
||
int par_size = 0;
|
||
uint8_t *obj = 0;
|
||
int obj_size = 0;
|
||
uint8_t op = 0;
|
||
if (at_decode_line(data, len, &obj, &obj_size, &op, &par, &par_size) == -1) {
|
||
return 0;
|
||
}
|
||
|
||
if (op == CMDAT_CMD_RET) {
|
||
// 命令返回消息,存储到通知缓冲区
|
||
ble_add_notice(ble, obj, obj_size, op, par, par_size);
|
||
} else if (op == CMDAT_CMD_ACT) {
|
||
// 通知消息,进一步区分
|
||
if (obj[0] == 0x01) {
|
||
// 连接事务改变
|
||
ble_linked_change(ble, *(uint16_t *)par, *(uint16_t *)(par + 2));
|
||
} else if (obj[0] == 0x02) {
|
||
// 收到新数据
|
||
if (ble->recv_data == 0)
|
||
ble_save_data(ble, *(uint16_t *)par, par + 2, par_size - 2);
|
||
else
|
||
ble->recv_data(*(uint16_t *)par, par + 2, par_size - 2);
|
||
} else if (obj[0] == 0xff) {
|
||
// 用户中断
|
||
if (ble->user_irq)
|
||
ble->user_irq(par, par_size);
|
||
}
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
// 添加通知消息
|
||
int ble_add_notice(ble_struct *ble, uint8_t *obj, int obj_size, uint8_t op,
|
||
uint8_t *par, int par_size) {
|
||
notice_t *n = &ble->notice;
|
||
if (ble->kno_event) {
|
||
// 等待接收方查看通知
|
||
rt_uint32_t ev;
|
||
rt_event_recv(ble->kno_event, 0xffffffff,
|
||
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 1000, &ev);
|
||
}
|
||
// ble_print_data(par,par_size);
|
||
IRQ_DISABLE();
|
||
memcpy(n->obj, obj, obj_size);
|
||
memcpy(n->par, par, par_size);
|
||
n->obj_size = obj_size;
|
||
n->par_size = par_size;
|
||
IRQ_ENABLE();
|
||
if (ble->ret_event) {
|
||
// 发送通知提醒接收方查看
|
||
rt_event_send(ble->ret_event, 1);
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
// 获取通知消息,返回0失败
|
||
int ble_get_notice(ble_struct *ble, uint8_t *obj, int *obj_size, uint8_t *op,
|
||
uint8_t *par, int *par_size) {
|
||
rt_uint32_t ev;
|
||
if (ble->ret_event) {
|
||
if (rt_event_recv(ble->ret_event, 0xffffffff,
|
||
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 1000,
|
||
&ev) == RT_EOK) {
|
||
IRQ_DISABLE();
|
||
notice_t *n = &ble->notice;
|
||
if (obj)
|
||
memcpy(obj, n->obj, n->obj_size);
|
||
if (obj_size)
|
||
*obj_size = n->obj_size;
|
||
if (par)
|
||
memcpy(par, n->par, n->par_size);
|
||
if (par_size)
|
||
*par_size = n->par_size;
|
||
n->obj_size = 0;
|
||
n->par_size = 0;
|
||
IRQ_ENABLE();
|
||
if (ble->kno_event) {
|
||
// 通知已查看
|
||
rt_event_send(ble->kno_event, 1);
|
||
}
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 连接事务改变
|
||
int ble_linked_change(ble_struct *ble, uint16_t handle, uint16_t state) {
|
||
if (state == 1) {
|
||
// 添加连接设备
|
||
ble_add_device(ble, handle);
|
||
} else if (state == 0) {
|
||
// 删除连接设备
|
||
ble_sub_device(ble, handle);
|
||
} else {
|
||
return 0;
|
||
}
|
||
// 调用用户回调函数
|
||
if (ble->linked_change)
|
||
ble->linked_change(handle, state);
|
||
|
||
return 1;
|
||
}
|
||
|
||
// 收到数据
|
||
int ble_save_data(ble_struct *ble, uint16_t handle, uint8_t *data, int len) {
|
||
ble_device *device = ble_find_device(ble, handle);
|
||
if (device) {
|
||
// printf("%s:recved %d\r\n",__func__,len);
|
||
return device_save_buff(device, data, len);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 返回指定句柄的设备
|
||
ble_device *ble_find_device(ble_struct *ble, uint16_t handle) {
|
||
if (handle == 0)
|
||
return 0;
|
||
for (int i = 0; i < BLE_MAX_LINKED; i++) {
|
||
if (ble->device[i].conn_handle == handle)
|
||
return &ble->device[i];
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 返回指定索引的蓝牙设备
|
||
ble_device *ble_find_device_by_index(ble_struct *ble, int index) {
|
||
if (ble == 0)
|
||
return 0;
|
||
if (index < BLE_MAX_LINKED) {
|
||
if (ble->device[index].conn_handle)
|
||
return &ble->device[index];
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 添加设备
|
||
int ble_add_device(ble_struct *ble, uint16_t handle) {
|
||
if (handle == 0)
|
||
return 0;
|
||
IRQ_DISABLE();
|
||
for (int i = 0; i < BLE_MAX_LINKED; i++) {
|
||
ble_device *device = &ble->device[i];
|
||
if (device->conn_handle == 0) {
|
||
memcpy(device->mac, ble->conn_mac, 6);
|
||
device->conn_handle = handle;
|
||
device->linked = 1;
|
||
ble->linked++;
|
||
IRQ_ENABLE();
|
||
return 1;
|
||
}
|
||
}
|
||
IRQ_ENABLE();
|
||
return 0;
|
||
}
|
||
|
||
// 删除设备
|
||
int ble_sub_device(ble_struct *ble, uint16_t handle) {
|
||
if (handle == 0)
|
||
return 0;
|
||
IRQ_DISABLE();
|
||
for (int i = 0; i < BLE_MAX_LINKED; i++) {
|
||
ble_device *device = &ble->device[i];
|
||
if (device->conn_handle == handle) {
|
||
device->conn_handle = 0;
|
||
device->linked = 0;
|
||
memset(device->mac, 0, 6);
|
||
buff_clear(&device->buff_recv);
|
||
ble->linked--;
|
||
IRQ_ENABLE();
|
||
return 1;
|
||
}
|
||
}
|
||
IRQ_ENABLE();
|
||
return 0;
|
||
}
|
||
|
||
// 读取数据直到出现界定符
|
||
int ble_get_recv_data_by_end(ble_struct *ble, uint16_t handle, uint8_t *buff,
|
||
int buff_size, uint8_t end_par) {
|
||
if (ble == 0)
|
||
return 0;
|
||
ble_device *device = ble_find_device(ble, handle);
|
||
if (device) {
|
||
return device_read_buff(device, buff, buff_size, end_par);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 读取指定长度的数据
|
||
int ble_get_recv_data(ble_struct *ble, uint16_t handle, uint8_t *buff,
|
||
int read_len) {
|
||
if (ble == 0)
|
||
return 0;
|
||
ble_device *device = ble_find_device(ble, handle);
|
||
if (device) {
|
||
return device_read_buff_by_len(device, buff, read_len);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 获取命令返回
|
||
int ble_get_cmd_return(ble_struct *ble, uint8_t *buff, int *buff_size) {
|
||
int ret = 0;
|
||
|
||
ret = ble_get_notice(ble, 0, 0, 0, buff, buff_size);
|
||
return ret;
|
||
}
|
||
|
||
// 设置设备名称
|
||
int ble_set_name(ble_struct *ble, char *name) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_set_event(0x01, name, strlen(name));
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1)
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 获取设备mac地址
|
||
int ble_get_mac(ble_struct *ble, uint8_t mac[6]) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_get_event(0x02, 0, 0);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (size == 6) {
|
||
memcpy(mac, data, 6);
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 重启
|
||
int ble_reboot(ble_struct *ble) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
int time_out = 100;
|
||
|
||
do {
|
||
at_send_set_event(0x03, 0, 0);
|
||
rt_thread_delay(2);
|
||
ble_get_notice(ble, 0, 0, 0, data, &size);
|
||
if ((size == 1) && (data[0] == 1)) {
|
||
rt_thread_delay(100);
|
||
at_clear_buff();
|
||
return 1;
|
||
}
|
||
} while (time_out--);
|
||
|
||
return 0;
|
||
}
|
||
|
||
// 设置uuid
|
||
int ble_set_uuid(ble_struct *ble, uint8_t sub, uint8_t type, uint8_t *uuid) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
|
||
data[0] = sub;
|
||
data[1] = type;
|
||
memcpy(&data[2], uuid, type / 8);
|
||
at_send_set_event(0x05, data, 2 + type / 8);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1)
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 打开/关闭数据传输
|
||
int ble_set_data_transport(ble_struct *ble, uint8_t power) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_set_event(0x06, &power, 1);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1)
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 发送数据
|
||
int ble_send_data(ble_struct *ble, uint16_t handle, uint8_t *buff, int len) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
int pack_len = 0;
|
||
while (len) {
|
||
data[0] = handle;
|
||
data[1] = handle >> 8;
|
||
if (len > 20)
|
||
pack_len = 20;
|
||
else
|
||
pack_len = len;
|
||
memcpy(&data[2], buff, pack_len);
|
||
at_send_set_event(0x07, data, pack_len + 2);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1) {
|
||
if (len == 0)
|
||
return 1;
|
||
} else {
|
||
return 0;
|
||
}
|
||
} else
|
||
return 0;
|
||
len -= pack_len;
|
||
buff += pack_len;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 设置为从机模式
|
||
int ble_set_slave(ble_struct *ble) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_set_event(0x10, 0, 0);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1) {
|
||
ble->mode = 's';
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 设置为主机模式
|
||
int ble_set_host(ble_struct *ble) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_set_event(0x20, 0, 0);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1) {
|
||
ble->mode = 'h';
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 连接指定的从机
|
||
int ble_connect_by_mac(ble_struct *ble, uint8_t mac[6]) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_set_event(0x21, mac, 6);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1) {
|
||
memcpy(ble->conn_mac, mac, 6);
|
||
return 1;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 断开指定的从机
|
||
int ble_discon_by_mac(ble_struct *ble, uint8_t mac[6]) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_set_event(0x22, mac, 6);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (data[0] == 1)
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 扫描
|
||
int ble_scan(ble_struct *ble, ble_mac_name mac[32], int *mac_num) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
*mac_num = 0;
|
||
at_send_set_event(0x23, 0, 0);
|
||
rt_thread_delay(3500);
|
||
while (1) {
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (size == 1) {
|
||
if (data[0] == 1)
|
||
return 1;
|
||
else
|
||
return 0;
|
||
} else if (size >= 7) {
|
||
memcpy(mac[*mac_num].mac, data, 6);
|
||
mac[*mac_num].rssi = data[6];
|
||
if (size > 7) {
|
||
int len = size - 7;
|
||
memcpy(mac[*mac_num].name, data + 7, len);
|
||
mac[*mac_num].name[len] = 0;
|
||
} else
|
||
mac[*mac_num].name[0] = 0;
|
||
(*mac_num)++;
|
||
}
|
||
} else
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
// 发送用户设置数据
|
||
int ble_user_cmd_set(ble_struct *ble, uint8_t *tx, int tx_len) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
at_send_set_event(0xff, tx, tx_len);
|
||
if (ble_get_cmd_return(ble, data, &size) == 1) {
|
||
if (size == 1)
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
// 发送用户获取数据,rx_len获取的数据长度,失败返回0
|
||
int ble_user_cmd_get(ble_struct *ble, uint8_t *tx, int tx_len, uint8_t *rx,
|
||
int *rx_len) {
|
||
if (ble == 0)
|
||
return 0;
|
||
uint8_t *data = ble->data_temp;
|
||
int size = 0;
|
||
int recv_len = 0;
|
||
uint8_t obj;
|
||
int obj_size;
|
||
at_send_get_event(0xff, tx, tx_len);
|
||
while (1) {
|
||
if (ble_get_notice(ble, &obj, &obj_size, 0, data, &size) == 1) {
|
||
if (obj_size == 0)
|
||
return data[0];
|
||
else {
|
||
if (recv_len == 0) {
|
||
if (size > *rx_len)
|
||
recv_len = *rx_len;
|
||
else
|
||
recv_len = size;
|
||
memcpy(rx, data, recv_len);
|
||
// ble_print_data(rx,recv_len);
|
||
*rx_len = recv_len;
|
||
}
|
||
}
|
||
} else
|
||
break;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static int g_service_work;
|
||
static int g_service_done = 1;
|
||
// ble 服务线程
|
||
static void ble_service_thread(void *t) {
|
||
ble_struct *ble = t;
|
||
g_service_done = 0;
|
||
|
||
int ev;
|
||
while (g_service_work) {
|
||
ev = at_get_event();
|
||
if (ev & CMDAT_EVENT_RECV) {
|
||
ev &= ~CMDAT_EVENT_RECV;
|
||
while (ble_deal_notice(ble) == 1)
|
||
;
|
||
}
|
||
if (ev & CMDAT_EVENT_USER) {
|
||
ev &= ~CMDAT_EVENT_USER;
|
||
at_send_packet();
|
||
}
|
||
if (ev) {
|
||
}
|
||
}
|
||
|
||
g_service_done = 1;
|
||
}
|
||
|
||
static int ble_service_on(void *t) {
|
||
rt_err_t result = RT_EOK;
|
||
rt_thread_t tid;
|
||
|
||
// 保证线程没有被创建
|
||
if (g_service_done) {
|
||
g_service_work = 1;
|
||
tid = rt_thread_create("ble_service_thread", ble_service_thread, t, 2048,
|
||
11, 10);
|
||
if (tid != NULL && result == RT_EOK)
|
||
rt_thread_startup(tid);
|
||
return 0;
|
||
} else {
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
static int ble_service_off(void) {
|
||
// 保证线程已经被创建
|
||
if (g_service_work) {
|
||
g_service_work = 0;
|
||
at_send_user_event(0x04);
|
||
while (g_service_done == 0) {
|
||
rt_thread_delay(10);
|
||
}
|
||
return 0;
|
||
} else {
|
||
return -1;
|
||
}
|
||
}
|