如题，比如想在BLE HID的工程上新增数传服务，用来进行自定义数据传输，可以在HID的例子基础上增加数传 service,具体操作如下
比如以CH573为例子，在EXAM\BLE\HID_Keyboard例子的基础上增加自己的数传service,具体操作如下：
第一步：
找到EXAM\BLE\BLE_UART\APP目录，把下图的文件夹复制到
直接编译，会报错，没有gattprofile.h这个文件
（实际是未用到gattprofile.h，直接屏蔽保护关系即可），文件保护只用这两个，其他不参与编译，然后重新编译
编译OK
/********************************** (C) COPYRIGHT ******************************* * File Name : hidkbd.c * Author : WCH * Version : V1.0 * Date : 2018/12/10 * Description : 蓝牙键盘应用程序，初始化广播连接参数，然后广播，直至连接主机后，定时上传键值 * Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd. * SPDX-License-Identifier: Apache-2.0 *******************************************************************************/ /********************************************************************* * INCLUDES */ #include "CONFIG.h" #include "devinfoservice.h" #include "battservice.h" #include "hidkbdservice.h" #include "hiddev.h" #include "hidkbd.h" #include "ble_uart_service.h" #include "app_drv_fifo.h" /********************************************************************* * MACROS */ // HID keyboard input report length #define HID_KEYBOARD_IN_RPT_LEN 8 // HID LED output report length #define HID_LED_OUT_RPT_LEN 1 /********************************************************************* * CONSTANTS */ // Param update delay #define START_PARAM_UPDATE_EVT_DELAY 12800 // HID idle timeout in msec; set to zero to disable timeout #define DEFAULT_HID_IDLE_TIMEOUT 60000 // Minimum connection interval (units of 1.25ms) #define DEFAULT_DESIRED_MIN_CONN_INTERVAL 8 // Maximum connection interval (units of 1.25ms) #define DEFAULT_DESIRED_MAX_CONN_INTERVAL 8 // Slave latency to use if parameter update request #define DEFAULT_DESIRED_SLAVE_LATENCY 0 // Supervision timeout value (units of 10ms) #define DEFAULT_DESIRED_CONN_TIMEOUT 500 // Default passcode #define DEFAULT_PASSCODE 0 // Default GAP pairing mode #define DEFAULT_PAIRING_MODE GAPBOND_PAIRING_MODE_WAIT_FOR_REQ // Default MITM mode (TRUE to require passcode or OOB when pairing) #define DEFAULT_MITM_MODE FALSE // Default bonding mode, TRUE to bond #define DEFAULT_BONDING_MODE TRUE // Default GAP bonding I/O capabilities #define DEFAULT_IO_CAPABILITIES GAPBOND_IO_CAP_NO_INPUT_NO_OUTPUT // Battery level is critical when it is less than this % #define DEFAULT_BATT_CRITICAL_LEVEL 6 /********************************************************************* * TYPEDEFS */ /********************************************************************* * GLOBAL VARIABLES */ // Task ID static uint8_t hidEmuTaskId = INVALID_TASK_ID; /********************************************************************* * EXTERNAL VARIABLES */ /********************************************************************* * EXTERNAL FUNCTIONS */ /********************************************************************* * LOCAL VARIABLES */ // GAP Profile - Name attribute for SCAN RSP data static uint8_t scanRspData[] = { 0x0D, // length of this data GAP_ADTYPE_LOCAL_NAME_COMPLETE, // AD Type = Complete local name 'H', 'I', 'D', ' ', 'K', 'e', 'y', 'b', 'r', 'o', 'a', 'd', // connection interval range 0x05, // length of this data GAP_ADTYPE_SLAVE_CONN_INTERVAL_RANGE, LO_UINT16(DEFAULT_DESIRED_MIN_CONN_INTERVAL), // 100ms HI_UINT16(DEFAULT_DESIRED_MIN_CONN_INTERVAL), LO_UINT16(DEFAULT_DESIRED_MAX_CONN_INTERVAL), // 1s HI_UINT16(DEFAULT_DESIRED_MAX_CONN_INTERVAL), // service UUIDs 0x05, // length of this data GAP_ADTYPE_16BIT_MORE, LO_UINT16(HID_SERV_UUID), HI_UINT16(HID_SERV_UUID), LO_UINT16(BATT_SERV_UUID), HI_UINT16(BATT_SERV_UUID), // Tx power level 0x02, // length of this data GAP_ADTYPE_POWER_LEVEL, 0 // 0dBm }; // Advertising data static uint8_t advertData[] = { // flags 0x02, // length of this data GAP_ADTYPE_FLAGS, GAP_ADTYPE_FLAGS_LIMITED | GAP_ADTYPE_FLAGS_BREDR_NOT_SUPPORTED, // appearance 0x03, // length of this data GAP_ADTYPE_APPEARANCE, LO_UINT16(GAP_APPEARE_HID_KEYBOARD), HI_UINT16(GAP_APPEARE_HID_KEYBOARD)}; // Device name attribute value static CONST uint8_t attDeviceName[GAP_DEVICE_NAME_LEN] = "HID Keyboard"; // HID Dev configuration static hidDevCfg_t hidEmuCfg = { DEFAULT_HID_IDLE_TIMEOUT, // Idle timeout HID_FEATURE_FLAGS // HID feature flags }; static uint16_t hidEmuConnHandle = GAP_CONNHANDLE_INIT; /********************************************************************* * LOCAL FUNCTIONS */ static void hidEmu_ProcessTMOSMsg(tmos_event_hdr_t *pMsg); static void hidEmuSendKbdReport(uint8_t keycode); static uint8_t hidEmuRcvReport(uint8_t len, uint8_t *pData); static uint8_t hidEmuRptCB(uint8_t id, uint8_t type, uint16_t uuid, uint8_t oper, uint16_t *pLen, uint8_t *pData); static void hidEmuEvtCB(uint8_t evt); static void hidEmuStateCB(gapRole_States_t newState, gapRoleEvent_t *pEvent); static void peripheralParamUpdateCB(uint16_t connHandle, uint16_t connInterval, uint16_t connSlaveLatency, uint16_t connTimeout); // GAP Role Callbacks static gapRolesCBs_t Peripheral_PeripheralCBs = { NULL, // Profile State Change Callbacks NULL, // When a valid RSSI is read from controller (not used by application) peripheralParamUpdateCB }; /********************************************************************* * PROFILE CALLBACKS */ static hidDevCB_t hidEmuHidCBs = { hidEmuRptCB, hidEmuEvtCB, NULL, hidEmuStateCB}; #define UART_TO_BLE_SEND_EVT 0x0010 // Connection item list static peripheralConnItem_t peripheralConnList; //for send to ble typedef enum { SEND_TO_BLE_TO_SEND = 1, SEND_TO_BLE_ALLOC_FAILED, SEND_TO_BLE_SEND_FAILED, } send_to_ble_state_t; send_to_ble_state_t send_to_ble_state = SEND_TO_BLE_TO_SEND; // static uint8_t to_test_buffer[BLE_BUFF_MAX_LEN - 4 - 3]; //The buffer length should be a power of 2 #define APP_UART_TX_BUFFER_LENGTH 512U #define APP_UART_RX_BUFFER_LENGTH 2048U //The tx buffer and rx buffer for app_drv_fifo //length should be a power of 2 static uint8_t app_uart_tx_buffer[APP_UART_TX_BUFFER_LENGTH] = {0}; static uint8_t app_uart_rx_buffer[APP_UART_RX_BUFFER_LENGTH] = {0}; static app_drv_fifo_t app_uart_tx_fifo; static app_drv_fifo_t app_uart_rx_fifo; //interupt uart rx flag ,clear at main loop bool uart_rx_flag = false; //for interrupt rx blcak hole ,when uart rx fifo full uint8_t for_uart_rx_black_hole = 0; //fifo length less that MTU-3, retry times uint32_t uart_to_ble_send_evt_cnt = 0; void app_uart_process(void) { UINT32 irq_status; SYS_DisableAllIrq(&irq_status); if(uart_rx_flag) { tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); uart_rx_flag = false; // PRINT("@1\n"); } SYS_RecoverIrq(irq_status); //tx process if(R8_UART3_TFC < UART_FIFO_SIZE) { app_drv_fifo_read_to_same_addr(&app_uart_tx_fifo, (uint8_t *)&R8_UART3_THR, UART_FIFO_SIZE - R8_UART3_TFC); } } void app_uart_init() { //tx fifo and tx fifo //The buffer length should be a power of 2 app_drv_fifo_init(&app_uart_tx_fifo, app_uart_tx_buffer, APP_UART_TX_BUFFER_LENGTH); app_drv_fifo_init(&app_uart_rx_fifo, app_uart_rx_buffer, APP_UART_RX_BUFFER_LENGTH); //uart tx io GPIOA_SetBits(bTXD3); GPIOA_ModeCfg(bTXD3, GPIO_ModeOut_PP_5mA); //uart rx io GPIOA_SetBits(bRXD3); GPIOA_ModeCfg(bRXD3, GPIO_ModeIN_PU); //uart3 init UART3_DefInit(); //enable interupt UART3_INTCfg(ENABLE, RB_IER_RECV_RDY | RB_IER_LINE_STAT); PFIC_EnableIRQ(UART3_IRQn); } void app_uart_tx_data(uint8_t *data, uint16_t length) { uint16_t write_length = length; app_drv_fifo_write(&app_uart_tx_fifo, data, &write_length); } // //Not every uart reception will end with a UART_II_RECV_TOUT //UART_II_RECV_TOUT can only be triggered when R8_UARTx_RFC is not 0 //Here we cannot rely UART_II_RECV_TOUT as the end of a uart reception __attribute__((interrupt("WCH-Interrupt-fast"))) __attribute__((section(".highcode"))) void UART3_IRQHandler(void) { uint16_t error; switch(UART3_GetITFlag()) { case UART_II_LINE_STAT: UART3_GetLinSTA(); break; case UART_II_RECV_RDY: case UART_II_RECV_TOUT: error = app_drv_fifo_write_from_same_addr(&app_uart_rx_fifo, (uint8_t *)&R8_UART3_RBR, R8_UART3_RFC); if(error != APP_DRV_FIFO_RESULT_SUCCESS) { for(uint8_t i = 0; i < R8_UART3_RFC; i++) { //fifo full,put to fifo black hole for_uart_rx_black_hole = R8_UART3_RBR; } } uart_rx_flag = true; break; case UART_II_THR_EMPTY: break; case UART_II_MODEM_CHG: break; default: break; } } //ble uart service callback handler void on_bleuartServiceEvt(uint16_t connection_handle, ble_uart_evt_t *p_evt) { switch(p_evt->type) { case BLE_UART_EVT_TX_NOTI_DISABLED: PRINT("%02x:bleuart_EVT_TX_NOTI_DISABLED\r\n", connection_handle); break; case BLE_UART_EVT_TX_NOTI_ENABLED: PRINT("%02x:bleuart_EVT_TX_NOTI_ENABLED\r\n", connection_handle); break; case BLE_UART_EVT_BLE_DATA_RECIEVED: PRINT("BLE RX DATA len:%d\r\n", p_evt->data.length); // // for notify back test // to ble // uint16_t to_write_length = p_evt->data.length; // app_drv_fifo_write(&app_uart_rx_fifo, (uint8_t *)p_evt->data.p_data, &to_write_length); // tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); //end of nofify back test //ble to uart app_uart_tx_data((uint8_t *)p_evt->data.p_data, p_evt->data.length); break; default: break; } } /********************************************************************* * PUBLIC FUNCTIONS */ /********************************************************************* * @fn HidEmu_Init * * @brief Initialization function for the HidEmuKbd App Task. * This is called during initialization and should contain * any application specific initialization (ie. hardware * initialization/setup, table initialization, power up * notificaiton ... ). * * @param task_id - the ID assigned by TMOS. This ID should be * used to send messages and set timers. * * @return none */ void HidEmu_Init() { hidEmuTaskId = TMOS_ProcessEventRegister(HidEmu_ProcessEvent); // Setup the GAP Peripheral Role Profile { uint8_t initial_advertising_enable = TRUE; // Set the GAP Role Parameters GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &initial_advertising_enable); GAPRole_SetParameter(GAPROLE_ADVERT_DATA, sizeof(advertData), advertData); GAPRole_SetParameter(GAPROLE_SCAN_RSP_DATA, sizeof(scanRspData), scanRspData); } // Set the GAP Characteristics GGS_SetParameter(GGS_DEVICE_NAME_ATT, GAP_DEVICE_NAME_LEN, (void *)attDeviceName); // Setup the GAP Bond Manager { uint32_t passkey = DEFAULT_PASSCODE; uint8_t pairMode = DEFAULT_PAIRING_MODE; uint8_t mitm = DEFAULT_MITM_MODE; uint8_t ioCap = DEFAULT_IO_CAPABILITIES; uint8_t bonding = DEFAULT_BONDING_MODE; GAPBondMgr_SetParameter(GAPBOND_PERI_DEFAULT_PASSCODE, sizeof(uint32_t), &passkey); GAPBondMgr_SetParameter(GAPBOND_PERI_PAIRING_MODE, sizeof(uint8_t), &pairMode); GAPBondMgr_SetParameter(GAPBOND_PERI_MITM_PROTECTION, sizeof(uint8_t), &mitm); GAPBondMgr_SetParameter(GAPBOND_PERI_IO_CAPABILITIES, sizeof(uint8_t), &ioCap); GAPBondMgr_SetParameter(GAPBOND_PERI_BONDING_ENABLED, sizeof(uint8_t), &bonding); } // Setup Battery Characteristic Values { uint8_t critical = DEFAULT_BATT_CRITICAL_LEVEL; Batt_SetParameter(BATT_PARAM_CRITICAL_LEVEL, sizeof(uint8_t), &critical); } // Set up HID keyboard service Hid_AddService(); // Set up bleuart service ble_uart_add_service(on_bleuartServiceEvt); // Register for HID Dev callback HidDev_Register(&hidEmuCfg, &hidEmuHidCBs); // Setup a delayed profile startup tmos_set_event(hidEmuTaskId, START_DEVICE_EVT); } /********************************************************************* * @fn HidEmu_ProcessEvent * * @brief HidEmuKbd Application Task event processor. This function * is called to process all events for the task. Events * include timers, messages and any other user defined events. * * @param task_id - The TMOS assigned task ID. * @param events - events to process. This is a bit map and can * contain more than one event. * * @return events not processed */ uint16_t HidEmu_ProcessEvent(uint8_t task_id, uint16_t events) { static uint8_t send_char = 4; static attHandleValueNoti_t noti; if(events & SYS_EVENT_MSG) { uint8_t *pMsg; if((pMsg = tmos_msg_receive(hidEmuTaskId)) != NULL) { hidEmu_ProcessTMOSMsg((tmos_event_hdr_t *)pMsg); // Release the TMOS message tmos_msg_deallocate(pMsg); } // return unprocessed events return (events ^ SYS_EVENT_MSG); } if(events & START_DEVICE_EVT) { return (events ^ START_DEVICE_EVT); } if(events & START_PARAM_UPDATE_EVT) { // Send connect param update request GAPRole_PeripheralConnParamUpdateReq(hidEmuConnHandle, DEFAULT_DESIRED_MIN_CONN_INTERVAL, DEFAULT_DESIRED_MAX_CONN_INTERVAL, DEFAULT_DESIRED_SLAVE_LATENCY, DEFAULT_DESIRED_CONN_TIMEOUT, hidEmuTaskId); return (events ^ START_PARAM_UPDATE_EVT); } if(events & START_REPORT_EVT) { hidEmuSendKbdReport(send_char); send_char++; if(send_char >= 29) { // LowPower_Sleep(RB_PWR_RAM2K | RB_PWR_RAM16K | RB_PWR_EXTEND); // send_char = 4; } hidEmuSendKbdReport(0x00); tmos_start_task(hidEmuTaskId, START_REPORT_EVT, 2000); return (events ^ START_REPORT_EVT); } if(events & UART_TO_BLE_SEND_EVT) { static uint16_t read_length = 0; uint8_t result = 0xff; // PRINT("@%x \n",send_to_ble_state); switch(send_to_ble_state) { case SEND_TO_BLE_TO_SEND: //notify is not enabled if(!ble_uart_notify_is_ready(peripheralConnList.connHandle)) { if(peripheralConnList.connHandle == GAP_CONNHANDLE_INIT) { //connection lost, flush rx fifo here app_drv_fifo_flush(&app_uart_rx_fifo); } break; } read_length = ATT_GetMTU(peripheralConnList.connHandle) - 3; if(app_drv_fifo_length(&app_uart_rx_fifo) >= read_length) { PRINT("FIFO_LEN:%d\r\n", app_drv_fifo_length(&app_uart_rx_fifo)); result = app_drv_fifo_read(&app_uart_rx_fifo, to_test_buffer, &read_length); uart_to_ble_send_evt_cnt = 0; } else { if(uart_to_ble_send_evt_cnt > 10) { result = app_drv_fifo_read(&app_uart_rx_fifo, to_test_buffer, &read_length); uart_to_ble_send_evt_cnt = 0; } else { tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 4); uart_to_ble_send_evt_cnt++; PRINT("NO TIME OUT\r\n"); } } if(APP_DRV_FIFO_RESULT_SUCCESS == result) { noti.len = read_length; noti.pValue = GATT_bm_alloc(peripheralConnList.connHandle, ATT_HANDLE_VALUE_NOTI, noti.len, NULL, 0); if(noti.pValue != NULL) { tmos_memcpy(noti.pValue, to_test_buffer, noti.len); result = ble_uart_notify(peripheralConnList.connHandle, ¬i, 0); if(result != SUCCESS) { PRINT("R1:%02x\r\n", result); send_to_ble_state = SEND_TO_BLE_SEND_FAILED; GATT_bm_free((gattMsg_t *)¬i, ATT_HANDLE_VALUE_NOTI); tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); } else { send_to_ble_state = SEND_TO_BLE_TO_SEND; //app_fifo_write(&app_uart_tx_fifo,to_test_buffer,&read_length); //app_drv_fifo_write(&app_uart_tx_fifo,to_test_buffer,&read_length); read_length = 0; tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); } } else { send_to_ble_state = SEND_TO_BLE_ALLOC_FAILED; tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); } } else { //send_to_ble_state = SEND_TO_BLE_FIFO_EMPTY; } break; case SEND_TO_BLE_ALLOC_FAILED: case SEND_TO_BLE_SEND_FAILED: noti.len = read_length; noti.pValue = GATT_bm_alloc(peripheralConnList.connHandle, ATT_HANDLE_VALUE_NOTI, noti.len, NULL, 0); if(noti.pValue != NULL) { tmos_memcpy(noti.pValue, to_test_buffer, noti.len); result = ble_uart_notify(peripheralConnList.connHandle, ¬i, 0); if(result != SUCCESS) { PRINT("R2:%02x\r\n", result); send_to_ble_state = SEND_TO_BLE_SEND_FAILED; GATT_bm_free((gattMsg_t *)¬i, ATT_HANDLE_VALUE_NOTI); tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); } else { send_to_ble_state = SEND_TO_BLE_TO_SEND; //app_drv_fifo_write(&app_uart_tx_fifo,to_test_buffer,&read_length); read_length = 0; tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); } } else { send_to_ble_state = SEND_TO_BLE_ALLOC_FAILED; tmos_start_task(hidEmuTaskId, UART_TO_BLE_SEND_EVT, 2); } break; default: break; } return (events ^ UART_TO_BLE_SEND_EVT); } return 0; } /********************************************************************* * @fn hidEmu_ProcessTMOSMsg * * @brief Process an incoming task message. * * @param pMsg - message to process * * @return none */ static void hidEmu_ProcessTMOSMsg(tmos_event_hdr_t *pMsg) { switch(pMsg->event) { default: break; } } /********************************************************************* * @fn hidEmuSendKbdReport * * @brief Build and send a HID keyboard report. * * @param keycode - HID keycode. * * @return none */ static void hidEmuSendKbdReport(uint8_t keycode) { uint8_t buf[HID_KEYBOARD_IN_RPT_LEN]; buf[0] = 0; // Modifier keys buf[1] = 0; // Reserved buf[2] = keycode; // Keycode 1 buf[3] = 0; // Keycode 2 buf[4] = 0; // Keycode 3 buf[5] = 0; // Keycode 4 buf[6] = 0; // Keycode 5 buf[7] = 0; // Keycode 6 HidDev_Report(HID_RPT_ID_KEY_IN, HID_REPORT_TYPE_INPUT, HID_KEYBOARD_IN_RPT_LEN, buf); } /********************************************************************* * @fn hidEmuStateCB * * @brief GAP state change callback. * * @param newState - new state * * @return none */ static void hidEmuStateCB(gapRole_States_t newState, gapRoleEvent_t *pEvent) { switch(newState) { case GAPROLE_STARTED: { uint8_t ownAddr[6]; GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddr); GAP_ConfigDeviceAddr(ADDRTYPE_STATIC, ownAddr); PRINT("Initialized..\n"); } break; case GAPROLE_ADVERTISING: PRINT("Advertising..\n"); break; case GAPROLE_CONNECTED: { gapEstLinkReqEvent_t *event = (gapEstLinkReqEvent_t *)pEvent; // get connection handle hidEmuConnHandle = event->connectionHandle; peripheralConnList.connHandle=hidEmuConnHandle; tmos_start_task(hidEmuTaskId, START_PARAM_UPDATE_EVT, START_PARAM_UPDATE_EVT_DELAY); PRINT("Connected..\n"); } break; case GAPROLE_CONNECTED_ADV: PRINT("Connected Advertising..\n"); break; case GAPROLE_WAITING: if(pEvent->gap.opcode == GAP_END_DISCOVERABLE_DONE_EVENT) { PRINT("Waiting for advertising..\n"); } else if(pEvent->gap.opcode == GAP_LINK_TERMINATED_EVENT) { PRINT("Disconnected.. Reason:%x\n", pEvent->linkTerminate.reason); } else if(pEvent->gap.opcode == GAP_LINK_ESTABLISHED_EVENT) { PRINT("Advertising timeout..\n"); } // Enable advertising { uint8_t initial_advertising_enable = TRUE; // Set the GAP Role Parameters GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t), &initial_advertising_enable); } break; case GAPROLE_ERROR: PRINT("Error..\n"); break; default: break; } } /********************************************************************* * @fn hidEmuRcvReport * * @brief Process an incoming HID keyboard report. * * @param len - Length of report. * @param pData - Report data. * * @return status */ static uint8_t hidEmuRcvReport(uint8_t len, uint8_t *pData) { // verify data length if(len == HID_LED_OUT_RPT_LEN) { // set LEDs return SUCCESS; } else { return ATT_ERR_INVALID_VALUE_SIZE; } } /********************************************************************* * @fn hidEmuRptCB * * @brief HID Dev report callback. * * @param id - HID report ID. * @param type - HID report type. * @param uuid - attribute uuid. * @param oper - operation: read, write, etc. * @param len - Length of report. * @param pData - Report data. * * @return GATT status code. */ static uint8_t hidEmuRptCB(uint8_t id, uint8_t type, uint16_t uuid, uint8_t oper, uint16_t *pLen, uint8_t *pData) { uint8_t status = SUCCESS; // write if(oper == HID_DEV_OPER_WRITE) { if(uuid == REPORT_UUID) { // process write to LED output report; ignore others if(type == HID_REPORT_TYPE_OUTPUT) { status = hidEmuRcvReport(*pLen, pData); } } if(status == SUCCESS) { status = Hid_SetParameter(id, type, uuid, *pLen, pData); } } // read else if(oper == HID_DEV_OPER_READ) { status = Hid_GetParameter(id, type, uuid, pLen, pData); } // notifications enabled else if(oper == HID_DEV_OPER_ENABLE) { tmos_start_task(hidEmuTaskId, START_REPORT_EVT, 500); } return status; } /********************************************************************* * @fn hidEmuEvtCB * * @brief HID Dev event callback. * * @param evt - event ID. * * @return HID response code. */ static void hidEmuEvtCB(uint8_t evt) { // process enter/exit suspend or enter/exit boot mode return; } /********************************************************************* * @fn peripheralParamUpdateCB * * @brief Parameter update complete callback * * @param connHandle - connect handle * connInterval - connect interval * connSlaveLatency - connect slave latency * connTimeout - connect timeout * * @return none */ static void peripheralParamUpdateCB(uint16_t connHandle, uint16_t connInterval, uint16_t connSlaveLatency, uint16_t connTimeout) { if(connHandle == hidEmuConnHandle) { peripheralConnList.connHandle= peripheralConnList.connInterval = connInterval; peripheralConnList.connSlaveLatency = connSlaveLatency; peripheralConnList.connTimeout = connTimeout; PRINT("Update %x - Int %x \n", connHandle, connInterval); } else { PRINT("ERR..\n"); } } /********************************************************************* *********************************************************************/
/********************************** (C) COPYRIGHT ******************************* * File Name : hidkbd.h * Author : WCH * Version : V1.0 * Date : 2018/12/10 * Description : * Copyright (c) 2021 Nanjing Qinheng Microelectronics Co., Ltd. * SPDX-License-Identifier: Apache-2.0 *******************************************************************************/ #ifndef HIDKBD_H #define HIDKBD_H #ifdef __cplusplus extern "C" { #endif /********************************************************************* * INCLUDES */ /********************************************************************* * CONSTANTS */ // Task Events #define START_DEVICE_EVT 0x0001 #define START_REPORT_EVT 0x0002 #define START_PARAM_UPDATE_EVT 0x0004 /********************************************************************* * MACROS */ /********************************************************************* * MACROS */ typedef struct { uint16 connHandle; // Connection handle of current connection uint16 connInterval; uint16 connSlaveLatency; uint16 connTimeout; } peripheralConnItem_t; /********************************************************************* * FUNCTIONS */ /********************************************************************* * GLOBAL VARIABLES */ /* * Task Initialization for the BLE Application */ extern void HidEmu_Init(void); /* * Task Event Processor for the BLE Application */ extern uint16_t HidEmu_ProcessEvent(uint8_t task_id, uint16_t events); extern void app_uart_process(void); extern void app_uart_init(); /********************************************************************* *********************************************************************/ #ifdef __cplusplus } #endif #endif
注意：未加低功耗休眠管理（自行处理）
