1896 lines
79 KiB
C
1896 lines
79 KiB
C
/*----------------------------------------------------------------------------
|
||
* Copyright (c) Fenda Technologies Co., Ltd. 2021. All rights reserved.
|
||
*
|
||
* Description: ble_api.c
|
||
*
|
||
* Author: even
|
||
*
|
||
* Create: 2022-08-04
|
||
*--------------------------------------------------------------------------*/
|
||
|
||
#include "sys_config.h"
|
||
#include <stdlib.h>
|
||
#include <time.h>
|
||
// #include "ble_data_transmission.h"
|
||
#include "alipay_feature.h"
|
||
#include "at_cmd_api.h"
|
||
#include "ate_rx_manager.h"
|
||
#include "ble_api.h"
|
||
#include "ble_bas_client.h"
|
||
#include "ble_fmp_locator.h"
|
||
#include "ble_gatts_callbacks.h"
|
||
#include "ble_port.h"
|
||
#include "ble_port_protocol.h"
|
||
#include "ble_pro_dis_client.h"
|
||
// #include "bts_a2dp_source.h"
|
||
#include "bts_avrcp_controller.h"
|
||
#include "bts_avrcp_target.h"
|
||
#include "bts_hfp_hf.h"
|
||
#include "bts_uuid.h"
|
||
#include "cmsis_os2.h"
|
||
#include "osal_addr.h"
|
||
#include "service_bt.h"
|
||
#include "soc_osal.h"
|
||
#include "sql_bt.h"
|
||
#include "ble_port_hid_service.h"
|
||
#include "ble_port_hfp_service.h"
|
||
#include "ble_protocol_file_upload.h"
|
||
#include "ble_protocol_file_download.h"
|
||
#include "ble_protocol_ota_service.h"
|
||
#include "bts_le_gap.h"
|
||
#include "bts_feature.h"
|
||
#include "sql_bt.h"
|
||
#include "systick.h"
|
||
#include "service_bt.h"
|
||
#include "ohos_bt_gatt_client.h"
|
||
#include "tjd_ble_ancs_server.h"
|
||
// #include "ble_port_ancs_service.h"
|
||
// #include "bt_audio_manager_wrapper.h"
|
||
|
||
#define BLE_AT_FAIL 1
|
||
#define BLE_AT_SUCC 0
|
||
#define MALLOC_FAIL -1
|
||
|
||
// #define configSUPPORT_DYNAMIC_ALLOCATION 1
|
||
|
||
#define ENABLE_STATIC_PRINT 0
|
||
#define static_print_error(...) sys_bt_log_e(__VA_ARGS__) //错误信息打印一般常开
|
||
#define static_print_warn(...) sys_bt_log_w(__VA_ARGS__) //警告信息打印一般常开
|
||
#if ENABLE_STATIC_PRINT
|
||
#define static_print_debug(...) sys_bt_log_d(__VA_ARGS__)
|
||
#define static_print_info(...) sys_bt_log_i(__VA_ARGS__)
|
||
#else
|
||
#define static_print_debug(...)
|
||
#define static_print_info(...)
|
||
#endif
|
||
|
||
#define UUID_SIZE 16
|
||
#define MEMORY_MINI 1
|
||
#define GENE_ADV_ID 1
|
||
#define INVALID_SERVER_ID 1
|
||
#define CENTRAL_DEMO_MTU 23
|
||
#define GATT_CHARACTERISTIC_MAX_LENGTH 517
|
||
#define GATT_RX_MAX_LENGTH 64
|
||
#define MUT_SIZE 517
|
||
// #define BLE_NAME_LEN 11
|
||
#define PROTOCOL_FRAME_HEAD 0xAB
|
||
#define PROTOCOL_FRAME_HEAD_2 0xAC
|
||
#define TIMEOUT_MS 10000 // 超时时间，单位毫秒
|
||
/* Gatt service UUID */
|
||
#define GATT_SERVICE_ID 0xD018
|
||
/* Gatt Characteristic UUID */
|
||
#define GATT_CHARACTERISTIC_ID 0x012D
|
||
#define GATT_CHARACTERISTIC_READ_ID 0x002D
|
||
#define GATT_AT_CHARACTERISTIC_ID 0x022D
|
||
// #define GATT_AT_CHARACTERISTIC_READ_ID 0x002D
|
||
/* Client Characteristic Configuration UUID */
|
||
#define GATT_BLE_UUID_CLIENT_CHARACTERISTIC_CONF 0x0229
|
||
/* Gatt Characteristic max length */
|
||
#define GATT_BLE_ADV_ID 1
|
||
#define GATT_BLE_ADV_DATA_MAX_LENGTH 31
|
||
#define GATT_BLE_ADV_BLE_NAME_MAX_LENGTH 12 // 31-4-2-3-9 = 13
|
||
#define GATT_BLE_NAME_LENGTH 20
|
||
#define GATT_BLE_ADV_MAC_HEAD_LENTH 4
|
||
#define GATT_BLE_ADV_MAC_LENTH 8
|
||
#define GATT_BLE_ADV_TYPE_LENTH 3
|
||
#define GATT_BLE_ADV_UUID_LENTH 4
|
||
#define GATT_BLE_DEFAULT_NAME "18THALefun"
|
||
#define GATT_BLE_DEFAULT_NAME_LEN 9
|
||
|
||
#define GAP_BLE_LOWPWR_INTERVAL_MIN 50
|
||
#define GAP_BLE_LOWPWR_INTERVAL_MAX 50
|
||
#define GAP_BLE_LOWPWR_LATENCY 10
|
||
#define GAP_BLE_LOWPWR_OUTTIME 500
|
||
|
||
#define GAP_BLE_FAST_INTERVAL_MIN 12
|
||
#define GAP_BLE_FAST_INTERVAL_MAX 12
|
||
#define GAP_BLE_FAST_LATENCY 5
|
||
#define GAP_BLE_FAST_OUTTIME 400
|
||
|
||
#define CONNECT_PARAM_UPDATE_TIME 15000 // 连接参数更新时间,单位ms
|
||
|
||
/* Gatt service UUID */
|
||
#define ALIPAYY_SERVICE_ID 0x0238
|
||
#define BLE_UUID_AT_CMD_SERVICE 0xD218
|
||
/* Gatt Characteristic UUID */
|
||
#define ALIPAYY_CHARACTERISTIC_ID 0x024A
|
||
#define ALIPAY_CHARACTERISTIC_MAX_LENGTH 256
|
||
|
||
/* HID service UUID */
|
||
#define BLE_UUID_HUMAN_INTERFACE_DEVICE 0x1218
|
||
|
||
#define uint16_to_byte(n) ((uint8_t)(n)), ((uint8_t)((n) >> 8))
|
||
/* HID information flag remote wakeup */
|
||
#define BLE_HID_INFO_FLAG_REMOTE_WAKE_UP_MSK 0x01
|
||
/* HID information flag normally connectable */
|
||
#define BLE_HID_INFO_FLAG_NORMALLY_CONNECTABLE_MSK 0x02
|
||
/* HID information country code */
|
||
#define BLE_HID_INFO_COUNTRY_CODE 0x00
|
||
/* HID spec version 1.11 */
|
||
#define BLE_HID_VERSION 0x0101
|
||
/* HID input report id */
|
||
#define BLE_HID_REPORT_ID 1
|
||
/* HID input report type */
|
||
#define BLE_REPORT_REFERENCE_REPORT_TYPE_INPUT_REPORT 1
|
||
/* HID output report type */
|
||
#define BLE_REPORT_REFERENCE_REPORT_TYPE_OUTPUT_REPORT 2
|
||
/* HID gatt server id */
|
||
#define BLE_HID_SERVER_ID 1
|
||
/* HID ble connect id */
|
||
#define BLE_SINGLE_LINK_CONNECT_ID 1
|
||
/* HID gatt attribute num */
|
||
#define BLE_HID_ATTRIBUTE_NUM 10
|
||
/* HID gatt notification flag, do not need confirm */
|
||
#define GATT_NOTIFICATION_FLAG 0
|
||
/* HID gatt indication flag, need confirm */
|
||
#define GATT_INDICATION_FLAG 1
|
||
/* Report UUID */
|
||
#define BLE_UUID_REPORT 0x4D2A
|
||
/* HID character value handle offset */
|
||
#define BLE_HID_CHARACTER_INPUT_REPORT_VALUE_HANDLE_OFFSET 8
|
||
|
||
#define pdFALSE ((BaseType_t)0)
|
||
#define pdTRUE ((BaseType_t)1)
|
||
|
||
#define pdPASS (pdTRUE)
|
||
#define pdFAIL (pdFALSE)
|
||
|
||
static time_t last_received_time = 0;
|
||
// extern unsigned long g_ate_at_queue;
|
||
// GATT 蓝牙模块全局变量
|
||
// static gap_ble_callbacks_t gatt_gapble_cbs;
|
||
// static gatts_callbacks_t gatt_gatts_cbs;
|
||
|
||
/* gatt server ID */
|
||
uint8_t g_server_id = INVALID_SERVER_ID;
|
||
uint16_t gatt_server_id = 1;
|
||
uint16_t g_server_conn_id = 0;
|
||
uint16_t g_server_handle = 0;
|
||
uint16_t g_tjd_alipay_handle = 0;
|
||
uint16_t g_tjd_lefun_handle = 0;
|
||
uint16_t g_tjd_at_handle = 0;
|
||
uint8_t g_tjd_hid_server_id = 0;
|
||
uint16_t g_tjd_hid_srv_handle = 0;
|
||
/* hid input report att handle */
|
||
uint32_t g_tjd_hid_input_report_att_hdl = 0;
|
||
bd_addr_t g_tjd_lastconned_addr = {0};
|
||
uint16_t g_tjd_hid_service_handle = 0;
|
||
uint32_t g_tjd_ble_mtu_size = 0;
|
||
static uint8_t g_character_buf[GATT_CHARACTERISTIC_MAX_LENGTH] = {0};
|
||
static uint8_t g_character_read_buf[GATT_CHARACTERISTIC_MAX_LENGTH] = {0};
|
||
static uint8_t g_rx_buf[GATT_RX_MAX_LENGTH] = {0};
|
||
|
||
bd_addr_t g_conn_addr = {0};
|
||
osSemaphoreId_t g_tjd_upload_file_done_sem = NULL;
|
||
|
||
// Alipay 蓝牙模块全局变量
|
||
static uint16_t g_alipay_server_id = 1;
|
||
static uint16_t g_at_server_id = 1;
|
||
static uint8_t g_alipay_character_buf[ALIPAY_CHARACTERISTIC_MAX_LENGTH] = {0};
|
||
|
||
// static uint16_t gatt_server_id = 1;
|
||
static uint16_t gatt_server_handle = 0;
|
||
static uint16_t gatt_conn_id = 0;
|
||
static uint8_t gatt_character_buf[GATT_CHARACTERISTIC_MAX_LENGTH] = {0};
|
||
static bool gatt_ble_init_flag = false;
|
||
static const uint8_t gatt_adv_type[GATT_BLE_ADV_TYPE_LENTH] = {2, 1, 0};
|
||
// static const uint8_t gatt_adv_type[GATT_BLE_ADV_TYPE_LENTH] = {0x0e, 0xff};
|
||
static const uint8_t gatt_adv_uuid[GATT_BLE_ADV_UUID_LENTH] = {0x3, 0x3, 0x02, 0x38};
|
||
static gap_connect_state_callback_t g_gap_connect_state_callback = NULL;
|
||
|
||
uint16_t server_handle_protocol = 0;
|
||
uint16_t server_handle_alipay = 0;
|
||
uint16_t server_handle_at = 0;
|
||
void add_gatt_server_protocol(uint16_t server_id, uint16_t *handle);
|
||
void add_gatt_server_alipay(uint16_t server_id, uint16_t *handle);
|
||
void add_gatt_server_at(uint16_t server_id, uint16_t *handle);
|
||
int32_t clion_id = 0;
|
||
|
||
bool bt_linkStatus = false;
|
||
|
||
typedef struct
|
||
{
|
||
uint8_t service_id;
|
||
uint8_t conn_id;
|
||
uint16_t attr_handle;
|
||
uint8_t *value;
|
||
uint16_t value_len;
|
||
} notify_params_t;
|
||
|
||
bool g_tjd_bt_adv_statue = false;
|
||
bool g_tjd_bt_is_connected = false;
|
||
bool g_tjd_ble_is_connected = false;
|
||
bool g_tjd_ble_into_camera_flag = false;
|
||
|
||
typedef struct
|
||
{
|
||
uint32_t buffer_data_len;
|
||
uint8_t buffer[4150];
|
||
struct timespec last_time;
|
||
uint8_t protoclo_title; //包头信息
|
||
uint8_t packet_index; //分包号,用于拼包
|
||
} ble_cmd_info_t;
|
||
ble_cmd_info_t g_cmd_info = {0};
|
||
|
||
void ble_api_cmd_info_reset(void)
|
||
{
|
||
memset(&g_cmd_info, 0, sizeof(g_cmd_info));
|
||
}
|
||
|
||
errcode_t ble_api_cmd_enable(void)
|
||
{
|
||
errcode_t ret = enable_ble();
|
||
static_print_debug("ble_enable ret(errcode_t): %x mac: ", ret);
|
||
if (ret == ERRCODE_BT_SUCCESS) {
|
||
static_print_debug("enable success");
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_disable(void)
|
||
{
|
||
errcode_t ret = disable_ble();
|
||
static_print_debug("ble_disable ret(errcode_t): %x mac: ", ret);
|
||
if (ret == ERRCODE_BT_SUCCESS) {
|
||
static_print_debug("disable success");
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_set_local_name(uint8_t *name, int len)
|
||
{
|
||
errcode_t ret = gap_ble_set_local_name(name, len);
|
||
static_print_debug("ble_set_local_name inputName: \"%s\" inputLen: %d ret(errcode_t): %x", name, len, ret);
|
||
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_get_local_name(void)
|
||
{
|
||
uint8_t name[20] = {0};
|
||
uint8_t len = 0;
|
||
errcode_t ret = gap_ble_get_local_name(name, &len);
|
||
static_print_debug("ble_get_local_name inputName: \"%s\" inputLen: %d ret(errcode_t): %x", name, len, ret);
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_set_local_addr(const bd_addr_t *addr)
|
||
{
|
||
errcode_t ret = gap_ble_set_local_addr(addr);
|
||
static_print_debug("ble_set_local_addr inputName: \"%s\" ret(errcode_t): %x", addr, ret);
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_get_local_addr(void)
|
||
{
|
||
bd_addr_t addr = {0};
|
||
errcode_t ret = gap_ble_get_local_addr(&addr);
|
||
static_print_debug("gap_ble_get_local_addr addr: %x : %x : %x : %x : %x : %x ret(errcode_t): %x", addr.addr[5], addr.addr[4],
|
||
addr.addr[3], addr.addr[2], addr.addr[1], addr.addr[0], ret);
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_get_bt_local_addr(void)
|
||
{
|
||
unsigned char mac_addr[6] = {0};
|
||
errcode_t ret = bluetooth_get_local_addr(mac_addr,6);
|
||
static_print_debug("bluetooth_get_local_addr addr: %x : %x : %x : %x : %x : %x ret(errcode_t): %x", mac_addr[5], mac_addr[4],
|
||
mac_addr[3], mac_addr[2], mac_addr[1], mac_addr[0], ret);
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_set_adv_data(uint8_t adv_id, const gap_ble_config_adv_data_t *data)
|
||
{
|
||
|
||
errcode_t ret = gap_ble_set_adv_data(adv_id, data);
|
||
static_print_debug("ble_set_adv_data ret(errcode_t): %x mac: ", ret);
|
||
return ret;
|
||
}
|
||
|
||
errcode_t ble_api_cmd_start_adv(uint8_t adv_id)
|
||
{
|
||
|
||
errcode_t ret = gap_ble_start_adv(adv_id);
|
||
static_print_debug("ble_start_adv ret(errcode_t): %x mac: ", ret);
|
||
return ret;
|
||
}
|
||
|
||
void tjd_ble_upload_file(const char *file_name, uint8_t file_type)
|
||
{
|
||
tjd_ble_protocol_upload_file_description(file_name, file_type);
|
||
static_print_debug("ble_upload_file file_name: %s", file_name);
|
||
}
|
||
|
||
void tjd_ble_request_gps(void)
|
||
{
|
||
uint8_t pack_head = 0x5B;
|
||
tjd_ble_protocol_send_lefun_data(&pack_head,NULL,0,REQUEST_GPS_INFORMATION);
|
||
static_print_debug("ble_request_gps");
|
||
}
|
||
|
||
void tjd_ble_request_synchrodata(void)
|
||
{
|
||
uint8_t pack_head = 0x5B;
|
||
tjd_ble_protocol_send_lefun_data(&pack_head,NULL,0,REQUEST_SYNCHRONOUS_DATA);
|
||
static_print_debug("ble_request_synchrodata");
|
||
}
|
||
|
||
void tjd_ble_request_flover(void)
|
||
{
|
||
uint8_t pack_head = 0x5B;
|
||
tjd_ble_protocol_send_lefun_data(&pack_head,NULL,0,REQUEST_LUCKY_CLOVER_DATA);
|
||
static_print_debug("ble_request_gps");
|
||
}
|
||
|
||
bool ble_api_cmd_start_discovery(void)
|
||
{
|
||
// errcode_t re = gap_ble_stop_adv(GATT_BLE_ADV_ID);
|
||
// static_print_debug("gap_ble_stop_adv ret(errcode_t): %x mac: ", re);
|
||
if (is_bt_discovering(BT_TRANSPORT_BR_EDR)) {
|
||
gap_br_cancel_discovery();
|
||
osDelay(50);
|
||
}
|
||
tjd_reset_found_dev_list();
|
||
(void)gap_br_set_inquiry_paramters(DEVICE_MAJOR_CLASS_AUDIO_VIDEO, 250);
|
||
bool ret = gap_br_start_discovery();
|
||
static_print_debug("gap_br_start_discovery ret(errcode_t): %d mac: ", ret);
|
||
return ret;
|
||
}
|
||
|
||
bool ble_api_cmd_stop_discovery(void)
|
||
{
|
||
if (is_bt_discovering(BT_TRANSPORT_BR_EDR)) {
|
||
return gap_br_cancel_discovery();
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void tjd_ble_remove_all_pairs(void)
|
||
{
|
||
errcode_t ret = gap_ble_remove_all_pairs();
|
||
static_print_warn("gap_ble_remove_all_pairs ret(errcode_t): %d", ret);
|
||
if(gap_remove_all_pairs()){
|
||
static_print_warn("gap_remove_all_pairs success");
|
||
}else{
|
||
static_print_warn("gap_remove_all_pairs failed");
|
||
}
|
||
if(bluetooth_factory_reset()){
|
||
static_print_warn("bluetooth_factory_reset success");
|
||
}else {
|
||
static_print_warn("bluetooth_factory_reset failed");
|
||
}
|
||
}
|
||
|
||
void tjd_set_lastconned_addr(const bd_addr_t *bd_addr)
|
||
{
|
||
int ret = memcpy_s(&g_tjd_lastconned_addr, sizeof(bd_addr_t), bd_addr, sizeof(bd_addr_t));
|
||
static_print_debug("tjd_set_lastconned_addr [] %d", ret);
|
||
}
|
||
|
||
void ble_api_cmd_show_scan_list(void)
|
||
{
|
||
tjd_update_found_dev_list();
|
||
tjd_show_found_dev_list();
|
||
}
|
||
|
||
// /* set adv data. */
|
||
static void svr_gap_ble_adv_data_set(int adv_id)
|
||
{
|
||
|
||
uint8_t ble_name[GATT_BLE_NAME_LENGTH] = {0};
|
||
uint8_t ble_name_len = GATT_BLE_NAME_LENGTH;
|
||
uint8_t adv_data[GATT_BLE_ADV_DATA_MAX_LENGTH] = {0};
|
||
uint8_t adv_data_len = 0;
|
||
uint8_t ble_data_name[GATT_BLE_ADV_BLE_NAME_MAX_LENGTH + 1] = {0}; // +TYPE LENGTH
|
||
uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
uint8_t adv_mac_head[GATT_BLE_ADV_MAC_LENTH] = {0x9, 0x16, 0x02, 0x38};
|
||
|
||
gap_ble_config_adv_data_t adv_data_info;
|
||
memset_s(&adv_data_info, sizeof(gap_ble_config_adv_data_t), 0, sizeof(gap_ble_config_adv_data_t));
|
||
// int32_t ret = gap_ble_get_local_name(ble_name, &ble_name_len);
|
||
errcode_t ret = bluetooth_get_local_name(ble_name, &ble_name_len);
|
||
if (ret != 0 || ble_name_len == 0) {
|
||
static_print_debug("gap_ble_get_local_name fail, name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);
|
||
memset_s(ble_name, GATT_BLE_NAME_LENGTH, 0, GATT_BLE_NAME_LENGTH);
|
||
memcpy_s(ble_name, GATT_BLE_NAME_LENGTH, GATT_BLE_DEFAULT_NAME, GATT_BLE_DEFAULT_NAME_LEN);
|
||
ble_name_len = GATT_BLE_DEFAULT_NAME_LEN + 1;
|
||
}
|
||
static_print_debug("gap_ble_get_local_name name:%s,len:%u,ret:%u.", ble_name, ble_name_len, ret);
|
||
|
||
// bd_addr_t addr_info;
|
||
unsigned char mac_addr[BT_MAC_LEN] = {0};
|
||
ret = bluetooth_get_local_addr(mac_addr,BT_MAC_LEN);
|
||
// ret = gap_ble_get_local_addr(&addr_info);
|
||
static_print_debug("gap_ble_get_local_addr, ret:%u.", ret);
|
||
memcpy_s(adv_data, sizeof(gatt_adv_type), gatt_adv_type, sizeof(gatt_adv_type));
|
||
adv_data_len = sizeof(gatt_adv_type);
|
||
|
||
if (ble_name_len > GATT_BLE_ADV_BLE_NAME_MAX_LENGTH) {
|
||
ble_name_len = GATT_BLE_ADV_BLE_NAME_MAX_LENGTH;
|
||
}
|
||
ble_data_name[0] = ble_name_len;
|
||
ble_data_name[1] = 0x9;
|
||
memcpy_s(&ble_data_name[2], ble_name_len - 1, ble_name, ble_name_len - 1);
|
||
|
||
memcpy_s(adv_data + adv_data_len, ble_name_len + 1, ble_data_name, ble_name_len + 1);
|
||
|
||
adv_data_len = adv_data_len + ble_name_len + 1;
|
||
// memcpy_s(adv_data + adv_data_len, sizeof(gatt_adv_uuid), gatt_adv_uuid, sizeof(gatt_adv_uuid));
|
||
// adv_data_len = adv_data_len + sizeof(gatt_adv_uuid);
|
||
|
||
int k = BD_ADDR_LEN;
|
||
for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
// ble_data_mac_switch[--k] = addr_info.addr[i];
|
||
ble_data_mac_switch[--k] = mac_addr[i];
|
||
}
|
||
static_print_debug("ble_info:%02x:%02x:%02x:%02x:%02x:%02x", ble_data_mac_switch[0], ble_data_mac_switch[1],
|
||
ble_data_mac_switch[2], ble_data_mac_switch[3], ble_data_mac_switch[4], ble_data_mac_switch[5]);
|
||
|
||
uint8_t adv_mac_head_1[GATT_BLE_ADV_MAC_LENTH] = {0x0e, 0xff};
|
||
memcpy_s(adv_mac_head_1 + 2, BD_ADDR_LEN, ble_data_mac_switch, BD_ADDR_LEN);
|
||
|
||
// 1.包头(2字节) + MAC地址(6字节)
|
||
memcpy_s(adv_data + adv_data_len, sizeof(adv_mac_head_1), adv_mac_head_1, sizeof(adv_mac_head_1));
|
||
adv_data_len = adv_data_len + sizeof(adv_mac_head_1);
|
||
// 3. TJD厂商号(4个字节) eg. 0x544a444a
|
||
// uint8_t tjd_uuid[4] = {0x54, 0x4a, 0x44, 0x4a};
|
||
uint8_t tjd_uuid[4] = {0x54, 0x48, 0x53, 0x41};
|
||
memcpy_s(adv_data + adv_data_len, sizeof(tjd_uuid), tjd_uuid, sizeof(tjd_uuid));
|
||
adv_data_len = adv_data_len + sizeof(tjd_uuid);
|
||
|
||
// 4. 设备类型(1个字节) eg. 0x00
|
||
uint8_t dev_type = 0x01;
|
||
adv_data[adv_data_len++] = dev_type;
|
||
|
||
// 5. 项目ID(2个字节) eg. 0x3757
|
||
uint8_t project_id[2] = {0x37, 0x57};
|
||
memcpy_s(adv_data + adv_data_len, sizeof(project_id), project_id, sizeof(project_id));
|
||
adv_data_len = adv_data_len + sizeof(project_id);
|
||
|
||
// // 6. 设备类型(4个字节) eg. 0x0319C103
|
||
// uint8_t dev_type_info[4] = {0x03, 0x19, 0xC1, 0x03};
|
||
// memcpy_s(adv_data + adv_data_len, sizeof(dev_type_info), dev_type_info, sizeof(dev_type_info));
|
||
// adv_data_len = adv_data_len + sizeof(dev_type_info);
|
||
|
||
adv_data_info.adv_data = adv_data;
|
||
adv_data_info.adv_length = adv_data_len;
|
||
static_print_debug("adv_data_info.adv_length:%u.", adv_data_len);
|
||
|
||
// for(int i = 0; i < adv_data_len; i++) {
|
||
// static_print_debug("%02x ", adv_data_info.adv_data[i]);
|
||
// }
|
||
|
||
gap_ble_set_adv_data(adv_id, &adv_data_info);
|
||
return;
|
||
}
|
||
|
||
static void sample_gap_ble_enable_changed_callback(errcode_t status)
|
||
{
|
||
static_print_debug("gap_ble_enable_changed_callback status: %d", status);
|
||
}
|
||
|
||
static void sample_gap_ble_disable_changed_callback(errcode_t status)
|
||
{
|
||
static_print_debug("gap_ble_disable_changed_callback status: %d", status);
|
||
}
|
||
|
||
static void sample_gap_set_adv_param_changed_callback(uint8_t adv_id, errcode_t status)
|
||
{
|
||
static_print_debug("gap_set_adv_param_changed_callback adv_id: %u status: \"%d\"", adv_id, status);
|
||
}
|
||
|
||
static void sample_gap_start_adv_changed_callback(uint8_t adv_id, adv_status_t status)
|
||
{
|
||
static_print_debug("gap_start_adv_changed_callback adv_id: %u status: \"%d\"", adv_id, status);
|
||
if(adv_id == GATT_BLE_ADV_ID){
|
||
tjd_svr_gatt_set_adv_start_state(true);
|
||
}
|
||
}
|
||
|
||
static void svr_bt_gatts_service_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t handle, errcode_t status)
|
||
{
|
||
static_print_debug("svr_bt_gatts_service_add_cb");
|
||
/*
|
||
static_print_debug("BtGattsServiceAddCallback 0x%x 0x%x 0x%x 0x%x", status, server_id, handle,
|
||
*((uint16_t *)uuid->uuid));
|
||
int ret;
|
||
if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == GATT_SERVICE_ID)) {
|
||
uint16_t id = GATT_CHARACTERISTIC_ID;
|
||
gatts_add_chara_info_t character;
|
||
uint16_t value = 0;
|
||
|
||
memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character.chara_uuid.uuid_len = sizeof(id);
|
||
memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
|
||
character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character.properties = GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP | GATT_CHARACTER_PROPERTY_BIT_WRITE;
|
||
character.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
character.value = g_character_buf;
|
||
|
||
ret = gatts_add_characteristic(server_id, handle, &character);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_add_characteristic success, ret:%u.", ret);
|
||
|
||
uint16_t read_id = GATT_CHARACTERISTIC_READ_ID;
|
||
gatts_add_chara_info_t character_read;
|
||
|
||
memset_s(&character_read, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character_read.chara_uuid.uuid_len = sizeof(read_id);
|
||
memcpy_s(character_read.chara_uuid.uuid, sizeof(character_read.chara_uuid.uuid), (char *)&read_id,
|
||
sizeof(read_id));
|
||
character_read.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character_read.properties = GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
|
||
character_read.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
character_read.value = g_character_read_buf;
|
||
|
||
ret = gatts_add_characteristic(server_id, handle, &character_read);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_add_characteristic success, ret:%u.", ret);
|
||
} else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == ALIPAYY_SERVICE_ID)) {
|
||
g_alipay_server_id = server_id;
|
||
// 添加alipay characteristic
|
||
uint16_t read_id = ALIPAYY_CHARACTERISTIC_ID;
|
||
gatts_add_chara_info_t character;
|
||
memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character.chara_uuid.uuid_len = sizeof(read_id);
|
||
memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&read_id, sizeof(read_id));
|
||
character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character.properties =
|
||
GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_WRITE | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
|
||
character.value_len = ALIPAY_CHARACTERISTIC_MAX_LENGTH;
|
||
character.value = g_alipay_character_buf;
|
||
|
||
ret = gatts_add_characteristic(server_id, handle, &character);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_add_characteristic success, ret:%u.", ret);
|
||
} else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_UUID_HUMAN_INTERFACE_DEVICE)) {
|
||
g_tjd_hid_service_handle = handle;
|
||
// tjd_ble_hid_add_characters_and_descriptors(server_id, handle);
|
||
// gatts_start_service(server_id, handle);
|
||
} else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_UUID_AT_CMD_SERVICE)) {
|
||
g_at_server_id = server_id;
|
||
// 添加at characteristic
|
||
uint16_t id = GATT_AT_CHARACTERISTIC_ID;
|
||
gatts_add_chara_info_t character;
|
||
uint16_t value = 0;
|
||
|
||
memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character.chara_uuid.uuid_len = sizeof(id);
|
||
memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
|
||
character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character.properties = GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP | GATT_CHARACTER_PROPERTY_BIT_WRITE;
|
||
character.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
character.value = g_character_buf;
|
||
|
||
ret = gatts_add_characteristic(server_id, handle, &character);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_add_characteristic success, ret:%u.", ret);
|
||
|
||
// uint16_t read_id = GATT_CHARACTERISTIC_READ_ID;
|
||
// gatts_add_chara_info_t character_read;
|
||
|
||
// memset_s(&character_read, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
// character_read.chara_uuid.uuid_len = sizeof(read_id);
|
||
// memcpy_s(character_read.chara_uuid.uuid, sizeof(character_read.chara_uuid.uuid), (char *)&read_id,
|
||
// sizeof(read_id));
|
||
// character_read.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
// character_read.properties = GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
|
||
// character_read.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
// character_read.value = g_character_read_buf;
|
||
|
||
// ret = gatts_add_characteristic(server_id, handle, &character_read);
|
||
// if (ret != ERRCODE_SUCC) {
|
||
// static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
// }
|
||
// static_print_debug("gatts_add_characteristic success, ret:%u.", ret);
|
||
}
|
||
*/
|
||
}
|
||
|
||
static void svr_gatt_bt_gatts_characteristic_add_cb(uint8_t server_id, bt_uuid_t *uuid, uint16_t srv_handle,
|
||
gatts_add_character_result_t *result, errcode_t status)
|
||
{
|
||
static_print_debug("svr_gatt_bt_gatts_characteristic_add_cb");
|
||
/*
|
||
static_print_debug("BtGattsCharacteristicAddCallback 0x%x 0x%x 0x%x 0x%x 0x%x , uuid: 0x%x uuid_len: %u", status,
|
||
server_id, srv_handle, result->handle, result->value_handle, *((uint16_t *)uuid->uuid),
|
||
uuid->uuid_len);
|
||
|
||
if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == GATT_CHARACTERISTIC_ID)) {
|
||
g_tjd_lefun_handle = result->value_handle;
|
||
uint8_t bas_ccc_val[] = {0x01, 0x00};
|
||
bt_uuid_t ccc_uuid = {0};
|
||
bts_data_to_uuid_len2(0x2902, &ccc_uuid);
|
||
gatts_add_desc_info_t descriptor;
|
||
descriptor.desc_uuid = ccc_uuid;
|
||
descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
|
||
descriptor.value = bas_ccc_val;
|
||
int ret = 0;
|
||
ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor fail, ret:%u.", ret);
|
||
}
|
||
bd_addr_t addr_info;
|
||
gatts_add_desc_info_t descriptor_ap;
|
||
gap_ble_get_local_addr(&addr_info);
|
||
bts_data_to_uuid_len2(0x4b02, &ccc_uuid);
|
||
descriptor_ap.desc_uuid = ccc_uuid;
|
||
descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor_ap.value_len = BD_ADDR_LEN;
|
||
uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
int k = BD_ADDR_LEN;
|
||
for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
ble_data_mac_switch[--k] = addr_info.addr[i];
|
||
}
|
||
descriptor_ap.value = ble_data_mac_switch;
|
||
ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_ap);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor second fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_add_descriptor success, ret:%u.", ret);
|
||
ret = gatts_start_service(server_id, srv_handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_start_service fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_start_service success, ret:%u.", ret);
|
||
} else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == ALIPAYY_CHARACTERISTIC_ID)) {
|
||
g_tjd_alipay_handle = result->value_handle;
|
||
uint8_t bas_ccc_val[] = {0x01, 0x00};
|
||
bt_uuid_t ccc_uuid = {0};
|
||
bts_data_to_uuid_len2(0x2902, &ccc_uuid);
|
||
gatts_add_desc_info_t descriptor;
|
||
descriptor.desc_uuid = ccc_uuid;
|
||
descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
|
||
descriptor.value = bas_ccc_val;
|
||
int ret = 0;
|
||
ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor fail, ret:%u.", ret);
|
||
}
|
||
bd_addr_t addr_info;
|
||
gatts_add_desc_info_t descriptor_ap;
|
||
gap_ble_get_local_addr(&addr_info);
|
||
bts_data_to_uuid_len2(0x4b02, &ccc_uuid);
|
||
descriptor_ap.desc_uuid = ccc_uuid;
|
||
descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor_ap.value_len = BD_ADDR_LEN;
|
||
uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
int k = BD_ADDR_LEN;
|
||
for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
ble_data_mac_switch[--k] = addr_info.addr[i];
|
||
}
|
||
descriptor_ap.value = ble_data_mac_switch;
|
||
ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_ap);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor second fail, ret:%u.", ret);
|
||
}
|
||
ret = gatts_start_service(server_id, srv_handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_start_service fail, ret:%u.", ret);
|
||
}
|
||
} else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == GATT_CHARACTERISTIC_READ_ID)) {
|
||
g_server_handle = result->value_handle;
|
||
} else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == BLE_UUID_REPORT)) {
|
||
if ((srv_handle == 0) || (g_tjd_hid_service_handle != srv_handle)) {
|
||
static_print_debug("[hid][ERROR]add report error, service_handle:%d", srv_handle);
|
||
return;
|
||
}
|
||
g_tjd_hid_server_id = server_id;
|
||
g_tjd_hid_srv_handle = srv_handle;
|
||
static_print_debug("[hid][INFO]add report success, server_id : %d, service_handle:%d", g_tjd_hid_server_id ,g_tjd_hid_srv_handle);
|
||
g_tjd_hid_input_report_att_hdl = srv_handle + BLE_HID_CHARACTER_INPUT_REPORT_VALUE_HANDLE_OFFSET;
|
||
|
||
// gatts_start_service(server_id, srv_handle);
|
||
} else if ((uuid->uuid_len == sizeof(uint16_t)) && (*((uint16_t *)uuid->uuid) == GATT_AT_CHARACTERISTIC_ID)) {
|
||
g_tjd_at_handle = result->value_handle;
|
||
// errcode_t ret1 = gatts_set_mtu_size(server_id,64);
|
||
// static_print_debug("gatts_set_mtu_size ret:%d", ret1);
|
||
uint8_t bas_ccc_val[] = {0x01, 0x00};
|
||
bt_uuid_t ccc_uuid = {0};
|
||
bts_data_to_uuid_len2(0x2902, &ccc_uuid);
|
||
gatts_add_desc_info_t descriptor;
|
||
descriptor.desc_uuid = ccc_uuid;
|
||
descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
|
||
descriptor.value = bas_ccc_val;
|
||
int ret = 0;
|
||
ret = gatts_add_descriptor(server_id, srv_handle, &descriptor);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor fail, ret:%u.", ret);
|
||
}
|
||
bd_addr_t addr_info;
|
||
gatts_add_desc_info_t descriptor_ap;
|
||
gap_ble_get_local_addr(&addr_info);
|
||
bts_data_to_uuid_len2(0x4b02, &ccc_uuid);
|
||
descriptor_ap.desc_uuid = ccc_uuid;
|
||
descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor_ap.value_len = BD_ADDR_LEN;
|
||
uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
int k = BD_ADDR_LEN;
|
||
for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
ble_data_mac_switch[--k] = addr_info.addr[i];
|
||
}
|
||
descriptor_ap.value = ble_data_mac_switch;
|
||
ret = gatts_add_descriptor(server_id, srv_handle, &descriptor_ap);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor second fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_add_descriptor success, ret:%u.", ret);
|
||
ret = gatts_start_service(server_id, srv_handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_start_service fail, ret:%u.", ret);
|
||
}
|
||
static_print_debug("gatts_start_service success, ret:%u.", ret);
|
||
}
|
||
*/
|
||
}
|
||
|
||
static void svr_bt_gatts_write_request_cb(uint8_t server_id, uint16_t conn_id, gatts_req_write_cb_t *write_cb_para, errcode_t status)
|
||
{
|
||
static_print_info(" svr_bt_gatts_write_request_cb(len:%d):\r\n",write_cb_para->length);
|
||
#if 0
|
||
for(int i = 0 ; i < write_cb_para->length ; ){
|
||
static_print_info("%02x", write_cb_para->value[i]);
|
||
i++;
|
||
if(i % 10 == 0){
|
||
static_print_info("\r\n");
|
||
}
|
||
if(i>=20){ break;}
|
||
}
|
||
static_print_info("\r\n");
|
||
#endif
|
||
|
||
tjd_connect_param_update();
|
||
tjd_service_connect_param_send_star();
|
||
|
||
if (write_cb_para->handle == g_tjd_alipay_handle) {
|
||
uint8_t *msg_data = write_cb_para->value;
|
||
errcode_t ret = svr_alipay_msg_write(ALIPAY_MSG_BT, msg_data, write_cb_para->length, false);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("svr_alipay_msg_write fail, ret:%u.", ret);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (write_cb_para->handle == g_tjd_at_handle && strncmp((char *)write_cb_para->value, "AT^", 3) == 0) {
|
||
static_print_debug("get AT^ cmd");
|
||
tjd_ate_send_at_msg(write_cb_para->value, write_cb_para->length);
|
||
return;
|
||
}
|
||
|
||
if(write_cb_para->handle == g_tjd_lefun_handle){
|
||
// time_t current_time = time(NULL);
|
||
struct timespec time = {0};
|
||
clock_gettime(CLOCK_MONOTONIC, &time);
|
||
if(g_cmd_info.packet_index == write_cb_para->value[0]){
|
||
memcpy(&g_cmd_info.buffer[g_cmd_info.buffer_data_len], &write_cb_para->value[1], write_cb_para->length - 1);
|
||
g_cmd_info.buffer_data_len += write_cb_para->length - 1;
|
||
g_cmd_info.packet_index++;
|
||
}else if(write_cb_para->value[0] == PROTOCOL_FRAME_HEAD || write_cb_para->value[0] == PROTOCOL_FRAME_HEAD_2){
|
||
memcpy(&g_cmd_info.buffer[g_cmd_info.buffer_data_len], write_cb_para->value, write_cb_para->length);
|
||
g_cmd_info.buffer_data_len += write_cb_para->length;
|
||
}else if(strncmp((const char *)write_cb_para->value, "AT^",3) == 0){
|
||
memcpy(&g_cmd_info.buffer[g_cmd_info.buffer_data_len], write_cb_para->value, write_cb_para->length);
|
||
g_cmd_info.buffer_data_len += write_cb_para->length;
|
||
}else{
|
||
// 解析失败，重置状态并记录错误
|
||
static_print_warn("Resolution failed. Reset the status");
|
||
static_print_debug("write_cb_para->value: ");
|
||
for(int i = 0; i < write_cb_para->length;) {
|
||
static_print_info("%x ", write_cb_para->value[i]);
|
||
i++;
|
||
if(i % 10 == 0){
|
||
static_print_info("\n");
|
||
}
|
||
if(i>=20) { break; }
|
||
}
|
||
static_print_info("\n");
|
||
g_cmd_info.packet_index = 0;
|
||
g_cmd_info.buffer_data_len = 0;
|
||
memset(g_cmd_info.buffer, 0, sizeof(g_cmd_info.buffer));
|
||
g_cmd_info.last_time = time;
|
||
return;
|
||
}
|
||
|
||
if(g_cmd_info.buffer[0] == PROTOCOL_FRAME_HEAD && (g_cmd_info.buffer_data_len == g_cmd_info.buffer[1] || g_cmd_info.buffer[1] == 0x30)){
|
||
uint16_t length = g_cmd_info.buffer[1];
|
||
g_cmd_info.buffer_data_len = 0;
|
||
g_cmd_info.protoclo_title = PROTOCOL_RES_FRAME_HEAD;
|
||
tjd_ble_protocol_ctrlcmd_ab(server_id, conn_id, g_cmd_info.buffer , length);
|
||
memset(g_cmd_info.buffer, 0, sizeof(g_cmd_info.buffer));
|
||
g_cmd_info.last_time = time; // 更新最后接收时间
|
||
return;
|
||
}else if(g_cmd_info.buffer[0] == PROTOCOL_FRAME_HEAD_2 && g_cmd_info.buffer_data_len == (g_cmd_info.buffer[1] << 8 | g_cmd_info.buffer[2])){
|
||
uint16_t length = g_cmd_info.buffer[1] << 8 | g_cmd_info.buffer[2];
|
||
g_cmd_info.buffer_data_len = 0;
|
||
g_cmd_info.protoclo_title = PROTOCOL_RES_FRAME_HEAD_2;
|
||
tjd_ble_protocol_ctrlcmd_ac(server_id, conn_id, g_cmd_info.buffer , length);
|
||
memset(g_cmd_info.buffer, 0, sizeof(g_cmd_info.buffer));
|
||
g_cmd_info.packet_index = 0;
|
||
g_cmd_info.last_time = time; // 更新最后接收时间
|
||
return;
|
||
}else if(strncmp((char *)g_cmd_info.buffer, "AT^", 3) == 0) {
|
||
static_print_debug("get AT^ cmd");
|
||
tjd_ate_send_at_msg(g_cmd_info.buffer, g_cmd_info.buffer_data_len);
|
||
memset(g_cmd_info.buffer, 0, sizeof(g_cmd_info.buffer));
|
||
g_cmd_info.buffer_data_len = 0;
|
||
g_cmd_info.last_time = time; // 更新最后接收时间
|
||
return;
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
static void svr_bt_gatts_read_request_cb(uint8_t server_id, uint16_t conn_id, gatts_req_read_cb_t *cb_para,
|
||
errcode_t status)
|
||
{
|
||
static_print_debug("[BLE]server read req server: %u status: %u conn_id:%hu handle: %hu ", server_id, status,
|
||
conn_id, cb_para->handle);
|
||
}
|
||
|
||
static void svr_bt_gatts_service_start_cb(uint8_t server_id, uint16_t srv_handle, errcode_t status)
|
||
{
|
||
if(srv_handle == server_handle_protocol){
|
||
add_gatt_server_alipay(server_id, &server_handle_alipay);
|
||
}else if(srv_handle == server_handle_alipay){
|
||
add_gatt_server_at(server_id, &server_handle_at);
|
||
}
|
||
|
||
static_print_debug("BtGattsServiceStartCallback 0x%x 0x%x 0x%x", status, server_id, srv_handle);
|
||
}
|
||
|
||
static void svr_bt_gatts_mtu_change_cbk(uint8_t server_id, uint16_t conn_id, uint32_t mtu_size, errcode_t status)
|
||
{
|
||
static_print_debug("BtGattsService mtu change server: %u status: %u conn_id: %hu mtu_size: %u ",
|
||
server_id, status, conn_id, mtu_size);
|
||
|
||
g_tjd_ble_mtu_size = mtu_size;
|
||
static_print_debug("g_tjd_ble_mtu_size: %u ", g_tjd_ble_mtu_size);
|
||
}
|
||
|
||
static void ble_server_descriptor_add_cbk(uint8_t server_id, bt_uuid_t *uuid, uint16_t service_handle,
|
||
uint16_t handle, errcode_t status)
|
||
{
|
||
static_print_debug("[BLE]server add descriptor server: %u status: %u srv_hdl: %hu desc_hdl: %hu "
|
||
"uuid_len:%u, uuid: ", server_id, status, service_handle, handle, uuid->uuid_len);
|
||
}
|
||
|
||
static void ble_server_service_delete_cbk(uint8_t server_id, errcode_t status)
|
||
{
|
||
static_print_debug("[BLE]server delete service server: %u status: %u ",
|
||
server_id, status);
|
||
}
|
||
|
||
static void ble_server_service_stop_cbk(uint8_t server_id, uint16_t handle, errcode_t status)
|
||
{
|
||
static_print_debug("[BLE]server stop service server: %u status: %u handle: %hu ",
|
||
server_id, status, handle);
|
||
}
|
||
|
||
static void sample_gap_ble_conn_state_change_cbk(uint16_t conn_id, bd_addr_t *addr, gap_acl_state_t conn_state,
|
||
gap_pair_state_t pair_state, gap_ble_disc_reason_t disc_reason)
|
||
{
|
||
errcode_t update_ret;
|
||
if (addr == NULL) {
|
||
static_print_debug("gap_ble_conn_state_change_cbk addr is null ");
|
||
return;
|
||
}
|
||
static_print_debug("ConnectStateChanged conn_id:%u addr:0x%02x:%02x:%02x:%02x:%02x:%02x addr_type:%u"
|
||
"conn_state:%d pair_state:%d",
|
||
conn_id, addr->addr[0], addr->addr[1], addr->addr[2], addr->addr[3], addr->addr[4],
|
||
addr->addr[5], addr->type, conn_state, pair_state);
|
||
g_server_conn_id = conn_id;
|
||
memcpy_s(g_conn_addr.addr, sizeof(g_conn_addr.addr), addr->addr, sizeof(addr->addr));
|
||
|
||
switch (conn_state) {
|
||
case GAP_ACL_STATE_CONNECTED:
|
||
if (g_gap_connect_state_callback != NULL) {
|
||
g_gap_connect_state_callback(GAP_ACL_STATE_DISCONNECTED);
|
||
}
|
||
static_print_debug("ConnectStateChanged GAP_ACL_STATE_CONNECTED");
|
||
g_tjd_ble_is_connected = false;
|
||
svr_gap_ble_adv_data_set(GATT_BLE_ADV_ID);
|
||
osDelay(100);
|
||
svr_ble_adv_start();
|
||
tjd_set_lastconned_addr(addr);
|
||
tjd_service_ble_sync_data_close();
|
||
tjd_ota_breakpoint_callback();
|
||
tjd_service_connect_param_send_stop();
|
||
gap_ble_set_ctkd_enable(false);
|
||
break;
|
||
case GAP_ACL_STATE_DISCONNECTED:
|
||
if (g_gap_connect_state_callback != NULL) {
|
||
g_gap_connect_state_callback(GAP_ACL_STATE_CONNECTED);
|
||
}
|
||
static_print_debug("ConnectStateChanged GAP_ACL_STATE_DISCONNECTED");
|
||
g_tjd_ble_is_connected = true;
|
||
tjd_service_ble_sync_data_open();
|
||
if(!g_tjd_bt_adv_statue){
|
||
gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE_GENERAL_DISCOVERABLE,180);
|
||
}
|
||
tjd_set_lastconned_addr(addr);
|
||
gattc_exchange_mtu_req(clion_id,conn_id,MUT_SIZE);
|
||
ble_ancs_client_setup_service(clion_id,conn_id);
|
||
if(!bt_is_acl_connected(addr)){
|
||
errcode_t ret = gap_ble_connect_remote_device(addr);
|
||
if(ret != ERRCODE_SUCC){
|
||
static_print_debug("gap_ble_connect_remote_device fail, ret:%u.", ret);
|
||
}else{
|
||
// static_print_debug("gap_ble_connect_remote_device success, ret:%u.", ret);
|
||
// ret = gattc_exchange_mtu_req(clion_id,conn_id,MUT_SIZE);
|
||
// static_print_debug("gattc_exchange_mtu_req ret:%x", ret);
|
||
// bt_uuid_t service_uuid = {0};
|
||
// service_uuid.uuid_len = BT_UUID_MAX_LEN;
|
||
// /* ANCS服务UUID，小端序 */
|
||
// uint8_t ancs_uuid[BT_UUID_MAX_LEN] = {
|
||
// 0xD0, 0x00, 0x2D, 0x12, 0x1E, 0x4B, 0x0F, 0xA4, 0x99, 0x4E, 0xCE, 0xB5, 0x31, 0xF4, 0x05, 0x79};
|
||
// if (memcpy_s(service_uuid.uuid, BT_UUID_MAX_LEN, ancs_uuid, BT_UUID_MAX_LEN) != EOK) {
|
||
// static_print_error("[btsrv][ERROR] uuid memcpy fail!\r\n");
|
||
// }
|
||
// ret = gattc_discovery_service(clion_id,conn_id,&service_uuid);
|
||
// static_print_debug("gattc_discovery_service ancs srv , ret:%x", ret);
|
||
}
|
||
}
|
||
gap_conn_param_update_t conn_param = { 0 };
|
||
conn_param.conn_handle = conn_id; /* param 0: conn_handle */
|
||
conn_param.interval_min = GAP_BLE_LOWPWR_INTERVAL_MIN; /* param 1: interval_min */
|
||
conn_param.interval_max = GAP_BLE_LOWPWR_INTERVAL_MAX; /* param 2: interval_max */
|
||
conn_param.slave_latency = GAP_BLE_LOWPWR_LATENCY; /* param 3: slave_latency */
|
||
conn_param.timeout_multiplier = GAP_BLE_LOWPWR_OUTTIME; /* param 4: timeout_multiplier */
|
||
update_ret = gap_ble_connect_param_update(&conn_param);
|
||
static_print_debug("gap ble update connection parameters ret: %u", update_ret);
|
||
break;
|
||
case GAP_ACL_STATE_LE_CONNECTED:
|
||
static_print_debug("ConnectStateChanged GAP_ACL_STATE_LE_CONNECTED");
|
||
tjd_set_lastconned_addr(addr);
|
||
g_tjd_ble_is_connected = true;
|
||
gap_ble_stop_adv(GATT_BLE_ADV_ID);
|
||
break;
|
||
case GAP_ACL_STATE_LE_DISCONNECTED:
|
||
static_print_debug("ConnectStateChanged GAP_ACL_STATE_LE_DISCONNECTED");
|
||
tjd_set_lastconned_addr(addr);
|
||
g_tjd_ble_is_connected = false;
|
||
|
||
|
||
svr_ble_adv_start();
|
||
break;
|
||
}
|
||
// errcode_t ret = gap_connect_remote_device(addr);
|
||
// if(ret != ERRCODE_SUCC) {
|
||
// static_print_debug("gap_connect_remote_device fail, ret:%x.", ret);
|
||
// return;
|
||
// }
|
||
// if (conn_state == 1 || conn_state == 3) { /* 断连时，清理 client profile的远端列表 */
|
||
// static_print_debug("ConnectStateChanged disc_reason:%x", disc_reason);
|
||
// sql_bt_set_bind(0);
|
||
// static_print_debug("sql_bt_set_bind 0");
|
||
// svr_ble_adv_start();
|
||
// // gap_ble_stop_adv(GATT_BLE_ADV_ID);
|
||
// // static_print_debug("gap_ble_stop_adv ");
|
||
// // gap_ble_start_adv(GATT_BLE_ADV_ID);
|
||
// // static_print_debug("gap_ble_start_adv ");
|
||
|
||
// } else if (conn_state == 0 || conn_state == GAP_ACL_STATE_LE_CONNECTED) { /* 连接成功时，添加 client
|
||
// profile的远端列表 */
|
||
// static_print_debug("ConnectStateChanged conn_state:%d pair_state:%d", conn_state, pair_state);
|
||
// sql_bt_set_bind(1);
|
||
// static_print_debug("sql_bt_set_bind 1");
|
||
// sql_bt_set_phone_name(addr->addr, sizeof(addr->addr));
|
||
// }
|
||
}
|
||
|
||
/* 设置安全参数 params: bondable io_capability sc_enable sc_mode */
|
||
static errcode_t gatt_ble_set_sec_param(uint8_t bondable, uint8_t io_capability, uint8_t sc_enable, uint8_t sc_mode)
|
||
{
|
||
gap_ble_sec_params_t sec_params = {0};
|
||
sec_params.bondable = bondable;
|
||
sec_params.io_capability = io_capability;
|
||
sec_params.sc_enable = sc_enable;
|
||
sec_params.sc_mode = sc_mode;
|
||
errcode_t ret = gap_ble_set_sec_param(&sec_params);
|
||
static_print_debug("gap ble set sec param ret(errcode_t): %x", ret);
|
||
return ret;
|
||
}
|
||
|
||
static void sample_gap_ble_set_adv_data_callback(uint8_t adv_id, errcode_t status)
|
||
{
|
||
static_print_debug("gap_ble_set_adv_data_callback adv_id: %d status: %d", adv_id, status);
|
||
}
|
||
|
||
// static void sample_gap_ble_scan_result_cbk(const gap_scan_result_data_t *scan_result_data)
|
||
// {
|
||
// if (scan_result_data == NULL) {
|
||
// static_print_debug("gap_ble_scan_result_cbk scan_result_data is null ");
|
||
// return;
|
||
// }
|
||
// static_print_debug("addr_type: %u addr:0x%02x:%02x:%02x:%02x:%02x:%02x.", scan_result_data->addr.type,
|
||
// scan_result_data->addr.addr[0], scan_result_data->addr.addr[1], scan_result_data->addr.addr[2],
|
||
// scan_result_data->addr.addr[3], scan_result_data->addr.addr[4], scan_result_data->addr.addr[5]);
|
||
// }
|
||
|
||
static void sample_gap_ble_connect_param_update_cbk(uint16_t conn_id, errcode_t status,
|
||
const gap_ble_conn_param_update_t *param)
|
||
{
|
||
static_print_debug("connect param changed conn_id:%u status:%u", conn_id, status);
|
||
if (param != NULL) {
|
||
static_print_debug(" interval:%u latency:%u timeout:%u", param->interval, param->latency, param->timeout);
|
||
}
|
||
}
|
||
|
||
static void sample_gap_ble_auth_complete_cbk(uint16_t conn_id, const bd_addr_t *addr, errcode_t status,
|
||
const ble_auth_info_evt_t* evt)
|
||
{
|
||
static_print_debug("auth_complete_cbk conn_id:%u status:0x%x", conn_id, status);
|
||
if (addr != NULL) {
|
||
static_print_debug("addr:0x%02x:**:**:**:%02x:%02x addr_type:%u",
|
||
addr->addr[0], addr->addr[4], addr->addr[5], addr->type);
|
||
}
|
||
if (evt != NULL) {
|
||
static_print_debug("ltk_len:%u ltk:", evt->ltk_len);
|
||
for (uint8_t i = 0; i < evt->ltk_len; i++) {
|
||
static_print_info("%02x", evt->ltk[i]);
|
||
}
|
||
static_print_info("\r\n");
|
||
}
|
||
}
|
||
|
||
static void sample_gap_ble_pair_result_cbk(uint16_t conn_id, const bd_addr_t *addr, errcode_t status)
|
||
{
|
||
static_print_debug("pair_result_cbk conn_id:%u status:0x%x", conn_id, status);
|
||
if (addr != NULL) {
|
||
static_print_debug("addr:0x%02x:**:**:**:%02x:%02x addr_type:%u",
|
||
addr->addr[0], addr->addr[4], addr->addr[5], addr->type);
|
||
}
|
||
}
|
||
|
||
static void sample_gap_ble_read_rssi_cb_cbk(uint16_t conn_id, int8_t rssi, errcode_t status)
|
||
{
|
||
static_print_debug("read_rssi_cb conn_id:%u status:0x%x rssi:%u", conn_id, status, rssi);
|
||
}
|
||
|
||
static void sample_gap_ble_scan_result_cbk(gap_scan_result_data_t *scan_result_data)
|
||
{
|
||
if (scan_result_data == NULL) {
|
||
static_print_debug("scan_result_data is null");
|
||
return;
|
||
}
|
||
static_print_debug("event_type:%u addr_type: %u addr:0x%02x:**:**:**:%02x:%02x adv_len:%u.",
|
||
scan_result_data->event_type, scan_result_data->addr.type, scan_result_data->addr.addr[0],
|
||
scan_result_data->addr.addr[4], scan_result_data->addr.addr[5], scan_result_data->adv_len);
|
||
}
|
||
|
||
static void sample_gap_ble_set_scan_param_cbk(errcode_t status)
|
||
{
|
||
static_print_debug("SetScanParameterCallback status: %u", status);
|
||
}
|
||
|
||
static void sample_gap_ble_stop_adv_cbk(uint8_t adv_id, adv_status_t status)
|
||
{
|
||
static_print_debug("stop_adv_cbk adv_id: %u status: %d", adv_id, status);
|
||
if(adv_id == GATT_BLE_ADV_ID){
|
||
tjd_svr_gatt_set_adv_start_state(false);
|
||
}
|
||
}
|
||
|
||
static void sample_gap_ble_terminate_adv_cbk(uint8_t adv_id, adv_status_t status)
|
||
{
|
||
static_print_debug("terminate_adv_cbk adv_id: %u status: %d", adv_id, status);
|
||
if(adv_id == GATT_BLE_ADV_ID){
|
||
tjd_svr_gatt_set_adv_start_state(false);
|
||
}
|
||
}
|
||
|
||
void tjd_add_descriptor_protocol(uint16_t sever_id, uint16_t sever_handle)
|
||
{
|
||
uint8_t bas_ccc_val[] = {0x01, 0x00};
|
||
bt_uuid_t ccc_uuid = {0};
|
||
bts_data_to_uuid_len2(0x2902, &ccc_uuid);
|
||
gatts_add_desc_info_t descriptor;
|
||
descriptor.desc_uuid = ccc_uuid;
|
||
descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
|
||
descriptor.value = bas_ccc_val;
|
||
int ret = 0;
|
||
uint16_t handle = 0;
|
||
ret = gatts_add_descriptor_sync(sever_id, sever_handle, &descriptor, &handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor fail, ret:%u.", ret);
|
||
}
|
||
bd_addr_t addr_info;
|
||
gatts_add_desc_info_t descriptor_ap;
|
||
gap_ble_get_local_addr(&addr_info);
|
||
bts_data_to_uuid_len2(0x4b02, &ccc_uuid);
|
||
descriptor_ap.desc_uuid = ccc_uuid;
|
||
descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor_ap.value_len = BD_ADDR_LEN;
|
||
uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
int k = BD_ADDR_LEN;
|
||
for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
ble_data_mac_switch[--k] = addr_info.addr[i];
|
||
}
|
||
descriptor_ap.value = ble_data_mac_switch;
|
||
uint16_t handle_ap = 0;
|
||
ret = gatts_add_descriptor_sync(sever_id, sever_handle, &descriptor_ap, &handle_ap);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor second fail, ret:%u.", ret);
|
||
}
|
||
}
|
||
|
||
void tjd_add_characters_descriptor_protocol(uint16_t sever_id, uint16_t sever_handle)
|
||
{
|
||
errcode_t ret;
|
||
uint16_t id = GATT_CHARACTERISTIC_ID;
|
||
gatts_add_chara_info_t character;
|
||
uint16_t value = 0;
|
||
gatts_add_character_result_t result = {0};
|
||
|
||
memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character.chara_uuid.uuid_len = sizeof(id);
|
||
memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
|
||
character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character.properties = GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP | GATT_CHARACTER_PROPERTY_BIT_WRITE;
|
||
character.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
character.value = g_character_buf;
|
||
ret = gatts_add_characteristic_sync(sever_id, sever_handle, &character, &result); //注册特征
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
g_tjd_lefun_handle = result.value_handle;
|
||
// tjd_add_descriptor_protocol(sever_id, sever_handle); //注册描述符
|
||
|
||
uint16_t read_id = GATT_CHARACTERISTIC_READ_ID;
|
||
gatts_add_chara_info_t character_read;
|
||
gatts_add_character_result_t result_read = {0};
|
||
|
||
memset_s(&character_read, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character_read.chara_uuid.uuid_len = sizeof(read_id);
|
||
memcpy_s(character_read.chara_uuid.uuid, sizeof(character_read.chara_uuid.uuid), (char *)&read_id,
|
||
sizeof(read_id));
|
||
character_read.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character_read.properties = GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
|
||
character_read.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
character_read.value = g_character_read_buf;
|
||
ret = gatts_add_characteristic_sync(sever_id, sever_handle, &character_read, &result_read); //注册特征
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
g_server_handle = result_read.value_handle;
|
||
tjd_add_descriptor_protocol(sever_id, sever_handle); //注册描述符
|
||
}
|
||
|
||
void tjd_add_descriptor_alipay(uint16_t sever_id, uint16_t sever_handle)
|
||
{
|
||
uint8_t bas_ccc_val[] = {0x01, 0x00};
|
||
bt_uuid_t ccc_uuid = {0};
|
||
bts_data_to_uuid_len2(0x2902, &ccc_uuid);
|
||
gatts_add_desc_info_t descriptor;
|
||
descriptor.desc_uuid = ccc_uuid;
|
||
descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
|
||
descriptor.value = bas_ccc_val;
|
||
int ret = 0;
|
||
uint16_t handle = 0;
|
||
ret = gatts_add_descriptor_sync(sever_id, sever_handle, &descriptor, &handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor fail, ret:%u.", ret);
|
||
}
|
||
bd_addr_t addr_info;
|
||
gatts_add_desc_info_t descriptor_ap;
|
||
gap_ble_get_local_addr(&addr_info);
|
||
bts_data_to_uuid_len2(0x4b02, &ccc_uuid);
|
||
descriptor_ap.desc_uuid = ccc_uuid;
|
||
descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor_ap.value_len = BD_ADDR_LEN;
|
||
uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
int k = BD_ADDR_LEN;
|
||
for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
ble_data_mac_switch[--k] = addr_info.addr[i];
|
||
}
|
||
descriptor_ap.value = ble_data_mac_switch;
|
||
uint16_t handle_ap = 0;
|
||
ret = gatts_add_descriptor_sync(sever_id, sever_handle, &descriptor_ap, &handle_ap);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor second fail, ret:%u.", ret);
|
||
}
|
||
}
|
||
|
||
void tjd_add_characters_descriptor_alipay(uint16_t sever_id, uint16_t sever_handle)
|
||
{
|
||
int ret = 0;
|
||
gatts_add_character_result_t result = {0};
|
||
g_alipay_server_id = sever_id;
|
||
// 添加alipay characteristic
|
||
uint16_t read_id = ALIPAYY_CHARACTERISTIC_ID;
|
||
gatts_add_chara_info_t character;
|
||
memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character.chara_uuid.uuid_len = sizeof(read_id);
|
||
memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&read_id, sizeof(read_id));
|
||
character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character.properties =
|
||
GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_WRITE | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
|
||
character.value_len = ALIPAY_CHARACTERISTIC_MAX_LENGTH;
|
||
character.value = g_alipay_character_buf;
|
||
|
||
ret = gatts_add_characteristic_sync(sever_id, sever_handle, &character, &result);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
g_tjd_alipay_handle = result.value_handle;
|
||
tjd_add_descriptor_alipay(sever_id, sever_handle);
|
||
}
|
||
|
||
void tjd_add_descriptor_at(uint16_t sever_id, uint16_t sever_handle)
|
||
{
|
||
// errcode_t ret1 = gatts_set_mtu_size(server_id,64);
|
||
// static_print_debug("gatts_set_mtu_size ret:%d", ret1);
|
||
uint8_t bas_ccc_val[] = {0x01, 0x00};
|
||
bt_uuid_t ccc_uuid = {0};
|
||
bts_data_to_uuid_len2(0x2902, &ccc_uuid);
|
||
gatts_add_desc_info_t descriptor;
|
||
descriptor.desc_uuid = ccc_uuid;
|
||
descriptor.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor.value_len = (uint16_t)sizeof(bas_ccc_val);
|
||
descriptor.value = bas_ccc_val;
|
||
int ret = 0;
|
||
uint16_t handle = 0;
|
||
ret = gatts_add_descriptor_sync(sever_id, sever_handle, &descriptor, &handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor fail, ret:%u.", ret);
|
||
}
|
||
bd_addr_t addr_info;
|
||
gatts_add_desc_info_t descriptor_ap;
|
||
gap_ble_get_local_addr(&addr_info);
|
||
bts_data_to_uuid_len2(0x4b02, &ccc_uuid);
|
||
descriptor_ap.desc_uuid = ccc_uuid;
|
||
descriptor_ap.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
descriptor_ap.value_len = BD_ADDR_LEN;
|
||
uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
int k = BD_ADDR_LEN;
|
||
for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
ble_data_mac_switch[--k] = addr_info.addr[i];
|
||
}
|
||
descriptor_ap.value = ble_data_mac_switch;
|
||
uint16_t handle_ap = 0;
|
||
ret = gatts_add_descriptor_sync(sever_id, sever_handle, &descriptor_ap, &handle_ap);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_descriptor second fail, ret:%u.", ret);
|
||
}
|
||
}
|
||
|
||
void tjd_add_characters_descriptor_at(uint16_t sever_id, uint16_t sever_handle)
|
||
{
|
||
g_at_server_id = sever_id;
|
||
// 添加at characteristic
|
||
uint16_t id = GATT_AT_CHARACTERISTIC_ID;
|
||
gatts_add_chara_info_t character;
|
||
uint16_t value = 0;
|
||
gatts_add_character_result_t result = {0};
|
||
int ret = 0;
|
||
|
||
memset_s(&character, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
character.chara_uuid.uuid_len = sizeof(id);
|
||
memcpy_s(character.chara_uuid.uuid, sizeof(character.chara_uuid.uuid), (char *)&id, sizeof(id));
|
||
character.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
character.properties = GATT_CHARACTER_PROPERTY_BIT_WRITE_NO_RSP | GATT_CHARACTER_PROPERTY_BIT_WRITE;
|
||
character.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
character.value = g_character_buf;
|
||
|
||
ret = gatts_add_characteristic_sync(sever_id, sever_handle, &character, &result);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
}
|
||
|
||
// uint16_t read_id = GATT_CHARACTERISTIC_READ_ID;
|
||
// gatts_add_chara_info_t character_read;
|
||
|
||
// memset_s(&character_read, sizeof(gatts_add_chara_info_t), 0, sizeof(gatts_add_chara_info_t));
|
||
// character_read.chara_uuid.uuid_len = sizeof(read_id);
|
||
// memcpy_s(character_read.chara_uuid.uuid, sizeof(character_read.chara_uuid.uuid), (char *)&read_id,
|
||
// sizeof(read_id));
|
||
// character_read.permissions = GATT_ATTRIBUTE_PERMISSION_READ | GATT_ATTRIBUTE_PERMISSION_WRITE;
|
||
// character_read.properties = GATT_CHARACTER_PROPERTY_BIT_READ | GATT_CHARACTER_PROPERTY_BIT_NOTIFY;
|
||
// character_read.value_len = GATT_CHARACTERISTIC_MAX_LENGTH;
|
||
// character_read.value = g_character_read_buf;
|
||
|
||
// ret = gatts_add_characteristic(server_id, handle, &character_read);
|
||
// if (ret != ERRCODE_SUCC) {
|
||
// static_print_debug("gatts_add_characteristic fail, ret:%u.", ret);
|
||
// }
|
||
// static_print_debug("gatts_add_characteristic success, ret:%u.", ret);
|
||
g_tjd_at_handle = result.value_handle;
|
||
tjd_add_descriptor_at(sever_id, sever_handle);
|
||
}
|
||
|
||
void add_gatt_server_protocol(uint16_t server_id, uint16_t *handle)
|
||
{
|
||
//注册协议GATT服务
|
||
errcode_t ret = 0;
|
||
bt_uuid_t uuid;
|
||
uint16_t service_id = GATT_SERVICE_ID;
|
||
gatt_server_id = server_id;
|
||
memset(&uuid, 0, sizeof(bt_uuid_t));
|
||
uuid.uuid_len = sizeof(service_id);
|
||
memcpy(uuid.uuid, &service_id, sizeof(service_id));
|
||
ret = gatts_add_service_sync(server_id, &uuid, true, handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_error("gatts_add_app_service ret:%u.", ret);
|
||
}
|
||
tjd_add_characters_descriptor_protocol(server_id, *handle); //特征+描述
|
||
gatts_start_service(server_id, *handle);
|
||
}
|
||
|
||
void add_gatt_server_alipay(uint16_t server_id, uint16_t *handle)
|
||
{
|
||
// 注册支付宝GATT服务
|
||
errcode_t ret = 0;
|
||
bt_uuid_t uuid;
|
||
uint16_t service_id = ALIPAYY_SERVICE_ID;
|
||
memset(&uuid, 0, sizeof(bt_uuid_t));
|
||
// g_alipay_server_id = server_id;
|
||
uuid.uuid_len = sizeof(service_id);
|
||
memcpy_s(uuid.uuid, sizeof(uuid.uuid), (char *)&service_id, sizeof(service_id));
|
||
ret = gatts_add_service_sync(server_id, &uuid, true, handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_error("gatts_add_alipay_service ret:%u.", ret);
|
||
}
|
||
tjd_add_characters_descriptor_alipay(server_id, *handle); //特征+描述
|
||
gatts_start_service(server_id, *handle);
|
||
}
|
||
|
||
void add_gatt_server_at(uint16_t server_id, uint16_t *handle)
|
||
{
|
||
//注册接收AT指令的服务
|
||
errcode_t ret = 0;
|
||
bt_uuid_t uuid;
|
||
uint16_t service_id = BLE_UUID_AT_CMD_SERVICE;
|
||
memset(&uuid, 0, sizeof(bt_uuid_t));
|
||
// g_alipay_server_id = server_id;
|
||
uuid.uuid_len = sizeof(service_id);
|
||
memcpy_s(uuid.uuid, sizeof(uuid.uuid), (char *)&service_id, sizeof(service_id));
|
||
ret = gatts_add_service_sync(server_id, &uuid, true, handle);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_error("gatts_add_alipay_service ret:%u.", ret);
|
||
}
|
||
tjd_add_characters_descriptor_at(server_id, *handle); //特征+描述
|
||
gatts_start_service(server_id, *handle);
|
||
}
|
||
|
||
/* @brief GAP 打开双模蓝牙BT开关。
|
||
* @param void
|
||
* @return 执行结果错误码
|
||
*/
|
||
errcode_t tjd_ble_api_cmd_open(void)
|
||
{
|
||
// 设置自动回连，ios一键双连依赖此配置
|
||
bts_feature_t bts_feature = { 0 };
|
||
bts_feature.bt_auto_reconnect_closed = 0;
|
||
errcode_t ret = bts_set_features(&bts_feature);
|
||
|
||
// 初始化bt链路
|
||
// BT使能
|
||
ret = enable_bt_stack();
|
||
static_print_debug("enable_bt ret(errcode_t): %x", ret);
|
||
if (ret != BLE_AT_SUCC)
|
||
return ret;
|
||
|
||
register_gap_service_callback();
|
||
tjd_ble_protocol_file_download_callback_init();
|
||
tjd_ble_protocol_file_download_transfer_reset();
|
||
tjd_ble_protocol_file_upload_callback_init();
|
||
|
||
gap_ble_callbacks_t ble_cb = {
|
||
.set_adv_data_cb = sample_gap_ble_set_adv_data_callback,
|
||
.ble_enable_cb = sample_gap_ble_enable_changed_callback,
|
||
.set_adv_param_cb = sample_gap_set_adv_param_changed_callback,
|
||
.start_adv_cb = sample_gap_start_adv_changed_callback,
|
||
.conn_state_change_cb = sample_gap_ble_conn_state_change_cbk,
|
||
.conn_param_update_cb = sample_gap_ble_connect_param_update_cbk,
|
||
.auth_complete_cb = sample_gap_ble_auth_complete_cbk,
|
||
.ble_disable_cb = sample_gap_ble_disable_changed_callback,
|
||
.pair_result_cb = sample_gap_ble_pair_result_cbk,
|
||
.read_rssi_cb = sample_gap_ble_read_rssi_cb_cbk,
|
||
.scan_result_cb = sample_gap_ble_scan_result_cbk,
|
||
.set_scan_param_cb = sample_gap_ble_set_scan_param_cbk,
|
||
.stop_adv_cb = sample_gap_ble_stop_adv_cbk,
|
||
.terminate_adv_cb = sample_gap_ble_terminate_adv_cbk,
|
||
};
|
||
|
||
gatts_callbacks_t gatt_cb = {
|
||
.add_service_cb = svr_bt_gatts_service_add_cb,
|
||
.add_characteristic_cb = svr_gatt_bt_gatts_characteristic_add_cb,
|
||
.start_service_cb = svr_bt_gatts_service_start_cb,
|
||
.write_request_cb = svr_bt_gatts_write_request_cb,
|
||
.read_request_cb = svr_bt_gatts_read_request_cb,
|
||
.mtu_changed_cb = svr_bt_gatts_mtu_change_cbk,
|
||
.add_descriptor_cb = ble_server_descriptor_add_cbk,
|
||
.delete_service_cb = ble_server_service_delete_cbk,
|
||
.stop_service_cb = ble_server_service_stop_cbk,
|
||
};
|
||
|
||
int callbacks_ret = gap_ble_register_callbacks(&ble_cb);
|
||
static_print_debug("gap ble reg cbk ret %x", callbacks_ret);
|
||
callbacks_ret = gatts_register_callbacks(&gatt_cb);
|
||
static_print_debug("gatts reg cbk ret %x", callbacks_ret);
|
||
|
||
// register_hfp_hf_servers_callback();
|
||
|
||
// register_a2dpsrc_servers_callbacks();
|
||
// register_a2dpsnk_servers_callback();
|
||
// register_avrcp_ct_servers_callbacks();
|
||
// register_avrcp_tg_servers_callbacks();
|
||
register_bt_avrcp_tg_bts_callback();
|
||
register_hfp_hf_servers_callbacks();
|
||
ble_client_register_gatt_callbacks();
|
||
tjd_ble_ancs_client_register_cbk();
|
||
|
||
tjd_music_mutex_init();
|
||
tjd_ble_mutex_init();
|
||
//设置手表名称
|
||
uint8_t *local_name =
|
||
(uint8_t *)malloc(sizeof(TJD_PCB_NAME) + sizeof(TJD_BLE_NAME_PREFIX) + 1);
|
||
if (local_name == NULL) {
|
||
static_print_debug("malloc local_name faile");
|
||
return MALLOC_FAIL;
|
||
}
|
||
memset_s(local_name, sizeof(local_name), 0, sizeof(local_name));
|
||
sprintf((char *)local_name, "%s%s-T", TJD_PCB_NAME, TJD_BLE_NAME_PREFIX);
|
||
|
||
static_print_debug("local name : %s", local_name);
|
||
ret = bluetooth_set_local_name((const unsigned char *)local_name, strlen((const char *)local_name) + 1);
|
||
static_print_debug("bt_set_local_name ret(errcode_t): %x mac: ", ret);
|
||
|
||
// if (ret != BLE_AT_SUCC)
|
||
// return ret;
|
||
//获取手表名称
|
||
// uint8_t get_local_name[14] = {0};
|
||
// uint8_t length = sizeof(TJD_PCB_NAME) + sizeof(TJD_BLE_NAME_PREFIX);
|
||
// ret = bluetooth_get_local_name(get_local_name, &length);
|
||
// static_print_debug("bt_get_local_name ret(errcode_t): %x mac: local name : %s , length : %d", ret, get_local_name,
|
||
// length);
|
||
// if (ret != BLE_AT_SUCC)
|
||
// return ret;
|
||
bd_addr_t addr = {0};
|
||
uint8_t mac_addr[MAC_ADDR_LEN] = {0};
|
||
if (tjd_service_nv_read_mac_addr(mac_addr) == ERRCODE_SUCC) {
|
||
static_print_info("The MAC address is: ");
|
||
for (int i = 0; i < 6; i++) {
|
||
static_print_info("%02x", mac_addr[i]);
|
||
if (i < 5) {
|
||
static_print_info(":");
|
||
}
|
||
}
|
||
static_print_info("\n");
|
||
memcpy_s(addr.addr, sizeof(addr.addr), mac_addr, sizeof(addr.addr));
|
||
static_print_debug("addr.addr: %x:%x:%x:%x:%x:%x", addr.addr[0], addr.addr[1], addr.addr[2], addr.addr[3],
|
||
addr.addr[4], addr.addr[5]);
|
||
}else{
|
||
uint8_t *mac_addr = sql_bt_get_mac_addr();
|
||
memcpy_s(addr.addr, sizeof(addr.addr), mac_addr, sizeof(addr.addr));
|
||
static_print_debug("addr.addr: %x:%x:%x:%x:%x:%x", addr.addr[0], addr.addr[1], addr.addr[2], addr.addr[3],
|
||
addr.addr[4], addr.addr[5]);
|
||
}
|
||
|
||
|
||
|
||
// uint8_t ble_data_mac_switch[BD_ADDR_LEN] = {0};
|
||
// int k = BD_ADDR_LEN;
|
||
// for (int i = 0; i < BD_ADDR_LEN; i++) {
|
||
// ble_data_mac_switch[--k] = addr.addr[i];
|
||
// }
|
||
// errcode_t res = bluetooth_set_local_addr(addr.addr, sizeof(addr.addr));
|
||
// errcode_t res = bluetooth_set_local_addr(ble_data_mac_switch, sizeof(ble_data_mac_switch));
|
||
errcode_t res = bluetooth_set_local_addr(addr.addr, BD_ADDR_LEN);
|
||
if (res != BLE_AT_SUCC) {
|
||
static_print_error("bluetooth_set_local_addr fail");
|
||
return ERRCODE_FAIL;
|
||
}else{
|
||
static_print_debug("bluetooth_set_local_addr succ");
|
||
uint8_t mac_addr[6] = {0};
|
||
res = bluetooth_get_local_addr(mac_addr, sizeof(mac_addr));
|
||
static_print_debug("br mac_addr: %x:%x:%x:%x:%x:%x", mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3],
|
||
mac_addr[4], mac_addr[5]);
|
||
if (res != BLE_AT_SUCC) {
|
||
static_print_error("bluetooth_get_local_addr fail");
|
||
return ERRCODE_FAIL;
|
||
}else{
|
||
static_print_debug("bluetooth_get_local_addr succ");
|
||
}
|
||
}
|
||
// res = gap_ble_set_local_addr(&addr);
|
||
// if (res == BLE_AT_SUCC) {
|
||
// static_print_debug("bluetooth_set_local_addr OK");
|
||
// bd_addr_t addr = {0};
|
||
// res = gap_ble_get_local_addr(&addr);
|
||
// static_print_debug("ble mac: %x:%x:%x:%x:%x:%x", addr.addr[0], addr.addr[1], addr.addr[2], addr.addr[3], addr.addr[4], addr.addr[5]);
|
||
// if (res != BLE_AT_SUCC)
|
||
// return res;
|
||
// } else {
|
||
// static_print_error("bluetooth_set_local_addr fail");
|
||
// return ERRCODE_FAIL;
|
||
// }
|
||
|
||
//设置ble名称
|
||
// memset_s(local_name, sizeof(local_name), 0, sizeof(local_name));
|
||
char ble_name[BLE_NAME_LEN] = {0};
|
||
sql_bt_get_ble_name(ble_name);
|
||
static_print_debug("strlen(ble_name) : %d",strlen(ble_name));
|
||
if(strlen(ble_name) != 0){
|
||
ret = bluetooth_set_local_name((const uint8_t *)ble_name, strlen(ble_name) + 1);
|
||
static_print_debug("bluetooth_set_local_name ret(errcode_t): %x , ble_name : %s", ret, ble_name);
|
||
// ret = gap_ble_set_local_name((const uint8_t *)ble_name, strlen(ble_name) + 1);
|
||
// static_print_debug("gap_ble_set_local_name ret(errcode_t): %x , ble_name : %s", ret, ble_name);
|
||
}else{
|
||
ret = bluetooth_set_local_name((const uint8_t *)"TH18ALefun", strlen(ble_name) + 1);
|
||
static_print_debug("bluetooth_set_local_name ret(errcode_t): %x , ble_name : %s", ret, ble_name);
|
||
// ret = gap_ble_set_local_name((const uint8_t *)"TH18ALefun", strlen(ble_name) + 1);
|
||
// static_print_debug("gap_ble_set_local_name ret(errcode_t): %x , ble_name : %s", ret, ble_name);
|
||
}
|
||
// sql_bt_get_ble_name(ble_name);
|
||
// sprintf((char *)local_name, "%s%s", TJD_PCB_NAME, TJD_BLE_NAME_PREFIX);
|
||
// // ret = gap_ble_set_local_name(local_name, strlen((const char *)local_name) + 1);
|
||
|
||
// free(local_name);
|
||
// local_name = NULL;
|
||
// if (ret != BLE_AT_SUCC)
|
||
// return ret;
|
||
// 2.3 设置设备的可发现模式
|
||
bool set_scan_mode = gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE_GENERAL_DISCOVERABLE, 1000);
|
||
if (set_scan_mode == false) {
|
||
static_print_debug("ble_gap_br_set_bt_scan_mode faile");
|
||
return ret;
|
||
}
|
||
// 2.4 创建GATT服务
|
||
uint16_t service_id = GATT_SERVICE_ID;
|
||
uint8_t server_id = INVALID_SERVER_ID;
|
||
bt_uuid_t uuid;
|
||
uuid.uuid_len = sizeof(service_id);
|
||
memcpy(uuid.uuid, &service_id, sizeof(service_id));
|
||
ret = gatts_register_server(&uuid, &server_id); /* 注册gatt server */
|
||
static_print_debug("ble_gatts_register_server ret(errcode_t): %x mac: ", ret);
|
||
if (ret != BLE_AT_SUCC)
|
||
return ret;
|
||
//注册协议GATT服务
|
||
add_gatt_server_protocol(server_id, &server_handle_protocol);
|
||
//注册HID服务
|
||
// service_id = BLE_UUID_HUMAN_INTERFACE_DEVICE;
|
||
// memset(&uuid, 0, sizeof(bt_uuid_t));
|
||
// // g_alipay_server_id = server_id;
|
||
// uuid.uuid_len = sizeof(service_id);
|
||
// memcpy_s(uuid.uuid, sizeof(uuid.uuid), (char *)&service_id, sizeof(service_id));
|
||
// ret = gatts_add_service(server_id, &uuid, true);
|
||
// if (ret != ERRCODE_SUCC) {
|
||
// static_print_error("gatts_add_hid_service ret:%u.", ret);
|
||
// }
|
||
|
||
//注册客户端
|
||
uint16_t client_id = 0xD020;
|
||
BtUuid appUuid;
|
||
appUuid.uuidLen = sizeof(client_id);
|
||
appUuid.uuid = (char *)malloc(appUuid.uuidLen);
|
||
memcpy(appUuid.uuid, &client_id, sizeof(client_id));
|
||
clion_id = BleGattcRegister(appUuid);
|
||
static_print_debug("clion_id = %d ",clion_id);
|
||
free(appUuid.uuid);
|
||
//SPP初始化
|
||
// ble_spp_servers_init();
|
||
int adv_id = GATT_BLE_ADV_ID;
|
||
gap_ble_adv_params_t adv_para;
|
||
memset_s(&adv_para, sizeof(gap_ble_adv_params_t), 0, sizeof(gap_ble_adv_params_t));
|
||
|
||
adv_para.min_interval = 0x640;
|
||
adv_para.max_interval = 0x960;
|
||
adv_para.adv_type = GAP_BLE_ADV_CONN_SCAN_UNDIR;
|
||
adv_para.channel_map = 0x7;
|
||
adv_para.duration = 0;
|
||
adv_para.tx_power = 0;
|
||
gap_ble_set_adv_param(adv_id, &adv_para);
|
||
// 3.1 设置广播数据
|
||
svr_gap_ble_adv_data_set(adv_id);
|
||
|
||
// smp加密
|
||
gatt_ble_set_sec_param(1, GAP_BLE_IO_CAPABILITY_NOINPUTNOOUTPUT, 1, GAP_BLE_GAP_SECURITY_MODE1_LEVEL3);
|
||
|
||
// ret = gap_ble_set_ctkd_enable(false);
|
||
// static_print_debug("gap_ble_set_ctkd_enable ret = %u", ret);
|
||
|
||
// 3.2 打开广播
|
||
svr_ble_adv_start();
|
||
|
||
|
||
return ret;
|
||
}
|
||
|
||
/* @brief GAP 关闭单模蓝牙BLE开关。
|
||
* @param void
|
||
* @return 执行结果错误码
|
||
*/
|
||
errcode_t ble_api_cmd_close(void)
|
||
{
|
||
// 1.去使能蓝牙协议栈
|
||
tjd_music_mutex_deinit();
|
||
tjd_ble_mutex_deinit();
|
||
errcode_t ret = disable_bt_stack();
|
||
if (ret != ERRCODE_BT_SUCCESS) {
|
||
static_print_debug("disable ble faile");
|
||
return BLE_AT_FAIL;
|
||
}
|
||
static_print_debug("diable ble success");
|
||
return ret;
|
||
}
|
||
|
||
/* @brief GATT 向对端发送通知或指示。
|
||
* @param uint8_t *data, 数据
|
||
uint16_t data_len 数据长度
|
||
* @return 执行结果错误码
|
||
*/
|
||
errcode_t svr_bt_gatts_notify(uint8_t *data, uint16_t data_len)
|
||
{
|
||
gatts_ntf_ind_t data_info;
|
||
data_info.attr_handle = g_server_handle;
|
||
data_info.value = data;
|
||
data_info.value_len = data_len;
|
||
|
||
errcode_t ret = gatts_notify_indicate(g_server_id, gatt_conn_id, &data_info);
|
||
static_print_debug("gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.", ret, g_server_id,
|
||
gatt_conn_id, g_server_handle);
|
||
return ret;
|
||
}
|
||
|
||
void tjd_bt_set_mac_addr(void)
|
||
{
|
||
bd_addr_t addr = {0};
|
||
uint8_t mac_addr[MAC_ADDR_LEN] = {0};
|
||
if (tjd_service_nv_read_mac_addr(mac_addr) == ERRCODE_SUCC) {
|
||
static_print_info("The MAC address is: ");
|
||
for (int i = 0; i < 6; i++) {
|
||
static_print_info("%02x", mac_addr[i]);
|
||
if (i < 5) {
|
||
static_print_info(":");
|
||
}
|
||
}
|
||
static_print_info("\n");
|
||
memcpy_s(addr.addr, sizeof(addr.addr), mac_addr, sizeof(addr.addr));
|
||
static_print_debug("addr.addr: %x:%x:%x:%x:%x:%x", addr.addr[0], addr.addr[1], addr.addr[2], addr.addr[3],
|
||
addr.addr[4], addr.addr[5]);
|
||
}else{
|
||
uint8_t soc_id[20]; // 20 is soc id length
|
||
uapi_soc_read_id(soc_id, 20); // 20 is soc id length
|
||
// bd_addr_t addr = {.type = 0, .addr = {soc_id[5], soc_id[4], soc_id[7], soc_id[6], soc_id[11], soc_id[10]}};
|
||
addr.addr[0] = soc_id[5];
|
||
addr.addr[1] = soc_id[4];
|
||
addr.addr[2] = soc_id[7];
|
||
addr.addr[3] = soc_id[6];
|
||
addr.addr[4] = soc_id[11];
|
||
addr.addr[5] = soc_id[10];
|
||
static_print_debug("addr.addr: %x:%x:%x:%x:%x:%x", addr.addr[0], addr.addr[1], addr.addr[2], addr.addr[3],
|
||
addr.addr[4], addr.addr[5]);
|
||
}
|
||
sql_bt_set_mac_addr(addr.addr, sizeof(addr.addr));
|
||
}
|
||
|
||
bool tjd_get_bt_statue(void)
|
||
{
|
||
if(!g_tjd_bt_is_connected && !g_tjd_bt_adv_statue){
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool tjd_get_bt_adv_statue(void) { return g_tjd_bt_adv_statue; }
|
||
|
||
bool tjd_get_bt_is_connect(void) { return g_tjd_bt_is_connected; }
|
||
|
||
bool tjd_get_ble_is_connect(void) { return g_tjd_ble_is_connected; }
|
||
|
||
bool tjd_get_ble_into_camera_flag(void) { return g_tjd_ble_into_camera_flag; }
|
||
|
||
bool tjd_get_ble_is_link_to_app(void) { return bt_linkStatus; }
|
||
|
||
void tjd_alipay_bt_gatts_noyify(uint8_t *data, uint16_t data_len)
|
||
{
|
||
gatts_ntf_ind_t data_info;
|
||
data_info.attr_handle = g_tjd_alipay_handle;
|
||
data_info.value = data;
|
||
data_info.value_len = data_len;
|
||
|
||
errcode_t ret = gatts_notify_indicate(gatt_server_id, g_server_conn_id, &data_info);
|
||
static_print_debug("gatts_notify_indicate ret:0x%x. serverid:%u,conn_id:%u,handle:%u.", ret, gatt_server_id,
|
||
g_server_conn_id, g_tjd_alipay_handle);
|
||
}
|
||
|
||
void tjd_get_gatt_server_conn_handle_id(uint8_t *server_id, uint16_t *conn_id, uint16_t *handle)
|
||
{
|
||
if (server_id == NULL || conn_id == NULL || handle == NULL) {
|
||
return;
|
||
}
|
||
*server_id = gatt_server_id;
|
||
*conn_id = g_server_conn_id;
|
||
*handle = g_server_handle;
|
||
}
|
||
|
||
bd_addr_t *tjd_get_lastconned_addr(void) { return &g_tjd_lastconned_addr; }
|
||
|
||
/* device向host发送数据：input report */
|
||
errcode_t tjd_ble_hid_server_send_input_report(void *data, uint8_t len)
|
||
{
|
||
gatts_ntf_ind_t param = {0};
|
||
uint8_t *report_data = (uint8_t *)data;
|
||
param.attr_handle = (uint16_t)g_tjd_hid_input_report_att_hdl;
|
||
// param.attr_handle = 0x22;
|
||
param.value_len = len;
|
||
param.value = malloc(len);
|
||
if (param.value == NULL) {
|
||
static_print_debug("[hid][ERROR]send input report new fail");
|
||
return ERRCODE_BT_MALLOC_FAIL;
|
||
}
|
||
if (memcpy_s(param.value, param.value_len, report_data, len) != EOK) {
|
||
static_print_debug("[hid][ERROR]send input report memcpy fail");
|
||
free(param.value);
|
||
return ERRCODE_BT_FAIL;
|
||
}
|
||
// errcode_t ret = gatts_notify_indicate(gatt_server_id, BLE_SINGLE_LINK_CONNECT_ID, ¶m);
|
||
errcode_t ret = gatts_notify_indicate(gatt_server_id, g_server_conn_id, ¶m);
|
||
if (ret != ERRCODE_SUCC) {
|
||
static_print_debug("[hid][ERROR]send input report gatts_notify_indicate fail");
|
||
}
|
||
static_print_debug("[hid][INFO]send input report ret:0x%x, serverid:%u,conn_id:%u,handle:0x%02x.", ret, gatt_server_id,
|
||
g_server_conn_id, param.attr_handle);
|
||
static_print_debug("[hid][INFO]send input report data");
|
||
for(int i = 0; i < len; i++) {
|
||
static_print_debug("[%d]:0x%02x.", i, report_data[i]);
|
||
}
|
||
free(param.value);
|
||
return ERRCODE_BT_SUCCESS;
|
||
}
|
||
|
||
uint32_t tjd_ble_get_mtu_size(void)
|
||
{
|
||
return g_tjd_ble_mtu_size;
|
||
}
|
||
|
||
void tjd_open_bluetooth_only(void)
|
||
{
|
||
//打开BT蓝牙广播
|
||
gap_br_set_bt_scan_mode(GAP_SCAN_MODE_CONNECTABLE_GENERAL_DISCOVERABLE,180);
|
||
// osDelay(50);
|
||
// errcode_t ret = gap_connect_remote_device(tjd_get_lastconned_addr());
|
||
// static_print_debug("gap_connect_remote_device ret:0x%x", ret);
|
||
}
|
||
|
||
void tjd_close_bluetooth_only(void)
|
||
{
|
||
//断开BT连接
|
||
gap_disconnect_remote_device(tjd_get_lastconned_addr());
|
||
//关闭蓝牙广播
|
||
gap_br_set_bt_scan_mode(GAP_SCAN_MODE_NONE,30);
|
||
}
|
||
|
||
uint8_t tjd_ble_get_hid_service_id(void)
|
||
{
|
||
return g_tjd_hid_server_id;
|
||
}
|
||
|
||
uint16_t tjd_ble_get_hid_srv_handle(void)
|
||
{
|
||
return g_tjd_hid_srv_handle;
|
||
}
|
||
|
||
void tjd_test_dial_config_json_file(void)
|
||
{
|
||
custom_dial_parameter_t dial_param = {0};
|
||
dial_param.setting_mode = 1;
|
||
dial_param.images_number = 0;
|
||
dial_param.switching_mode = 0;
|
||
tjd_service_save_dial_parameter(&dial_param);
|
||
}
|
||
|
||
void register_gap_connect_state_callback_t(gap_connect_state_callback_t callback)
|
||
{
|
||
g_gap_connect_state_callback = callback;
|
||
}
|
||
|
||
void unregister_gap_connect_state_callback_t(void)
|
||
{
|
||
g_gap_connect_state_callback = NULL;
|
||
}
|
||
|
||
// uint16_t tjd_ble_get_lefun_handle(void)
|
||
// {
|
||
// return g_tjd_lefun_handle;
|
||
// }
|
||
#define SLOW 0
|
||
#define FAST 1
|
||
bool ble_connect_param_mode = SLOW;
|
||
|
||
void tjd_connect_param_update(void)
|
||
{
|
||
gap_ble_conn_param_update_t g_conn_param = { 0 };
|
||
gap_ble_get_connection_param(g_server_conn_id, &g_conn_param);
|
||
if(g_conn_param.interval >= GAP_BLE_LOWPWR_INTERVAL_MIN){ // 连接参数更新
|
||
if(ble_connect_param_mode == SLOW){
|
||
printf("fast param update!!! \r\n");
|
||
ble_connect_param_mode = FAST;
|
||
gap_conn_param_update_t conn_param = { 0 };
|
||
conn_param.conn_handle = g_server_conn_id;
|
||
conn_param.interval_min = GAP_BLE_FAST_INTERVAL_MIN;
|
||
conn_param.interval_max = GAP_BLE_FAST_INTERVAL_MAX;
|
||
conn_param.slave_latency = GAP_BLE_FAST_LATENCY;
|
||
conn_param.timeout_multiplier = GAP_BLE_FAST_OUTTIME;
|
||
gap_ble_connect_param_update(&conn_param);
|
||
}
|
||
}
|
||
}
|
||
|
||
errcode_t tjd_connect_param_revert(void)
|
||
{
|
||
errcode_t revert_ret = false;
|
||
gap_ble_conn_param_update_t g_conn_param = { 0 };
|
||
gap_ble_get_connection_param(g_server_conn_id, &g_conn_param);
|
||
if(g_conn_param.interval < GAP_BLE_LOWPWR_INTERVAL_MIN){ // 连接参数回退
|
||
revert_ret = true;
|
||
printf("revert param update!!! \r\n");
|
||
gap_conn_param_update_t conn_param = { 0 };
|
||
conn_param.conn_handle = g_server_conn_id;
|
||
conn_param.interval_min = GAP_BLE_LOWPWR_INTERVAL_MIN;
|
||
conn_param.interval_max = GAP_BLE_LOWPWR_INTERVAL_MAX;
|
||
conn_param.slave_latency = GAP_BLE_LOWPWR_LATENCY;
|
||
conn_param.timeout_multiplier = GAP_BLE_LOWPWR_OUTTIME;
|
||
gap_ble_connect_param_update(&conn_param);
|
||
}
|
||
return revert_ret;
|
||
}
|
||
|
||
int tjd_service_connect_param_handle(void)
|
||
{
|
||
struct timespec time = {0};
|
||
clock_gettime(CLOCK_MONOTONIC, &time);
|
||
if(time.tv_sec - g_cmd_info.last_time.tv_sec >= CONNECT_PARAM_UPDATE_TIME/1000){
|
||
ble_connect_param_mode = SLOW;
|
||
if(tjd_connect_param_revert()){ //回退成功关闭消息队列
|
||
return 0;
|
||
}
|
||
}
|
||
return CONNECT_PARAM_UPDATE_TIME;
|
||
}
|
||
|
||
void tjd_service_connect_param_send_star(void)
|
||
{
|
||
queue_default_info_t data = {tjd_service_connect_param_handle, NULL, CONNECT_PARAM_UPDATE_TIME, NULL};
|
||
osal_msg_queue_write_copy(tjd_task_service_timer_get_queue_id(), (void *)&data, sizeof(queue_default_info_t), 0);
|
||
}
|
||
|
||
void tjd_service_connect_param_send_stop(void)
|
||
{
|
||
queue_default_info_t data = {tjd_service_connect_param_handle, NULL, 0, NULL};
|
||
osal_msg_queue_write_copy(tjd_task_service_timer_get_queue_id(), (void *)&data, sizeof(queue_default_info_t), 0);
|
||
} |