From ce9c1b7d1790ca093c953e3da0a5cc14dd9c4977 Mon Sep 17 00:00:00 2001 From: zhaohe Date: Sun, 21 Jan 2024 18:28:46 +0800 Subject: [PATCH] update --- .vscode/settings.json | 4 +- app/main.c | 18 +++- app/src/zdatachannel_service.c | 215 +++++++++++++++++------------------------ app/src/zdatachannel_service.h | 56 +++++------ 4 files changed, 133 insertions(+), 160 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 9ba7cb6..c05f83c 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -39,6 +39,8 @@ "nrf_log_default_backends.h": "c", "nrf_delay.h": "c", "zhrs_service.h": "c", - "ble_srv_common.h": "c" + "ble_srv_common.h": "c", + "zdatachannel_service.h": "c", + "ble_link_ctx_manager.h": "c" } } \ No newline at end of file diff --git a/app/main.c b/app/main.c index 90c0794..dd75ef7 100644 --- a/app/main.c +++ b/app/main.c @@ -21,7 +21,8 @@ void qingfengboard_test(void) { } #endif -ZDATACANNEL_DEF(m_zhrs, 2 /*回调事件优先级*/, 1 /*client num*/); +ZDATACHANNEL_DEF(m_zhrs, 2 /*回调事件优先级*/, 1 /*client num*/); +APP_TIMER_DEF(m_test_tx_timer); static const char* hex2str(const uint8_t* data, int32_t len) { static char rx[64] = {0}; @@ -36,13 +37,12 @@ void zdatachannel_data_handler(zdatachannel_evt_t* p_evt) { /** * @brief 接收到指令数据 */ - if (p_evt->type == ZDATACANNEL_EVT_RX_DATA) { + if (p_evt->type == ZDATACHANNEL_EVT_RX_DATA) { ZLOGI("rx:%s", hex2str(p_evt->params.rx_data.p_data, p_evt->params.rx_data.length)); } } static void ble_evt_handler(ble_evt_t const* p_ble_evt, void* p_context) { - uint32_t err_code; switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: ZLOGI("Connected"); @@ -66,6 +66,13 @@ void on_service_init(void) { ZERROR_CHECK(zdatachannel_init(&m_zhrs, &zdatachannle_init)); } +static void test_tx_timer_cb(void* p_context) { + static uint32_t data; + uint16_t txlen = 4; + data++; + zdatachannel_data_send((uint8_t*)&data, &txlen); +} + int main(void) { zsys_init(); NRF_LOG_INFO("compile time :%s", __TIME__); @@ -74,12 +81,15 @@ int main(void) { static zble_module_cfg_t cfg = // { - .deviceName = "iflytop", + .deviceName = "iflytop2", .on_service_init = on_service_init, }; zble_module_init(&cfg); NRF_SDH_BLE_OBSERVER(m_ble_observer, 3, ble_evt_handler, NULL); + ZERROR_CHECK(app_timer_create(&m_test_tx_timer, APP_TIMER_MODE_REPEATED, test_tx_timer_cb)); + ZERROR_CHECK(app_timer_start(m_test_tx_timer, APP_TIMER_TICKS(5), NULL)); + zble_module_start_adv(); zsys_loop(); } diff --git a/app/src/zdatachannel_service.c b/app/src/zdatachannel_service.c index 4a45c70..7a9e2af 100644 --- a/app/src/zdatachannel_service.c +++ b/app/src/zdatachannel_service.c @@ -5,55 +5,35 @@ #include "nrf_log.h" #include "sdk_common.h" -#define BLE_UUID_NUS_TX_CHARACTERISTIC 0x0003 /**< The UUID of the TX Characteristic. */ -#define BLE_UUID_NUS_RX_CHARACTERISTIC 0x0002 /**< The UUID of the RX Characteristic. */ +#define ZDATACHANNEL_UUID_NUS_SERVICE 0x0001 /**< The UUID of the Nordic UART Service. */ +#define ZDATACHANNEL_TX_CHARACTERISTIC 0x0003 /**< The UUID of the TX Characteristic. */ +#define ZDATACHANNEL_RX_CHARACTERISTIC 0x0002 /**< The UUID of the RX Characteristic. */ +#define ZDATACHANNEL_DATABLOCK_TX_CHARACTERISTIC 0x0004 /**< The UUID of the RX Characteristic. */ -#define ZDATACANNEL_MAX_RX_CHAR_LEN ZDATACANNEL_MAX_DATA_LEN /**< Maximum length of the RX Characteristic (in bytes). */ -#define ZDATACANNEL_MAX_TX_CHAR_LEN ZDATACANNEL_MAX_DATA_LEN /**< Maximum length of the TX Characteristic (in bytes). */ +#define ZDATACHANNEL_MAX_RX_CHAR_LEN ZDATACHANNEL_MAX_DATA_LEN /**< Maximum length of the RX Characteristic (in bytes). */ +#define ZDATACHANNEL_MAX_TX_CHAR_LEN ZDATACHANNEL_MAX_DATA_LEN /**< Maximum length of the TX Characteristic (in bytes). */ +#define ZDATACHANNEL_DATABLOCK_TX_CHAR_LEN ZDATACHANNEL_MAX_DATA_LEN /**< Maximum length of the TX Characteristic (in bytes). */ #define NUS_BASE_UUID \ { \ { 0x9E, 0xCA, 0xDC, 0x24, 0x0E, 0xE5, 0xA9, 0xE0, 0x93, 0xF3, 0xA3, 0xB5, 0x00, 0x00, 0x40, 0x6E } \ } /**< Used vendor specific UUID. */ -/**@brief Function for handling the @ref BLE_GAP_EVT_CONNECTED event from the SoftDevice. - * - * @param[in] p_nus Nordic UART Service structure. - * @param[in] p_ble_evt Pointer to the event received from BLE stack. - */ -static void on_connect(zdatachannel_t *p_nus, ble_evt_t const *p_ble_evt) { - ret_code_t err_code; - zdatachannel_evt_t evt; - ble_gatts_value_t gatts_val; - uint8_t cccd_value[2]; - zdatachannel_client_context_t *p_client = NULL; - - err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage, p_ble_evt->evt.gap_evt.conn_handle, (void *)&p_client); - if (err_code != NRF_SUCCESS) { - NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.", p_ble_evt->evt.gap_evt.conn_handle); - } +static zdatachannel_t *p_datachannel; - /* Check the hosts CCCD value to inform of readiness to send data using the RX characteristic */ +static bool notification_enable(uint16_t conn_handle, uint16_t cccd_handle) { + ret_code_t err_code; + ble_gatts_value_t gatts_val; + uint8_t cccd_value[2]; memset(&gatts_val, 0, sizeof(ble_gatts_value_t)); gatts_val.p_value = cccd_value; gatts_val.len = sizeof(cccd_value); gatts_val.offset = 0; - - err_code = sd_ble_gatts_value_get(p_ble_evt->evt.gap_evt.conn_handle, p_nus->tx_handles.cccd_handle, &gatts_val); - - if ((err_code == NRF_SUCCESS) && (p_nus->data_handler != NULL) && ble_srv_is_notification_enabled(gatts_val.p_value)) { - if (p_client != NULL) { - p_client->is_notification_enabled = true; - } - - memset(&evt, 0, sizeof(zdatachannel_evt_t)); - evt.type = ZDATACANNEL_EVT_COMM_STARTED; - evt.p_nus = p_nus; - evt.conn_handle = p_ble_evt->evt.gap_evt.conn_handle; - evt.p_link_ctx = p_client; - - p_nus->data_handler(&evt); + err_code = sd_ble_gatts_value_get(conn_handle, cccd_handle, &gatts_val); + if ((err_code == NRF_SUCCESS) && ble_srv_is_notification_enabled(gatts_val.p_value)) { + return true; } + return false; } /**@brief Function for handling the @ref BLE_GATTS_EVT_WRITE event from the SoftDevice. @@ -62,37 +42,25 @@ static void on_connect(zdatachannel_t *p_nus, ble_evt_t const *p_ble_evt) { * @param[in] p_ble_evt Pointer to the event received from BLE stack. */ static void on_write(zdatachannel_t *p_nus, ble_evt_t const *p_ble_evt) { - ret_code_t err_code; - zdatachannel_evt_t evt; - zdatachannel_client_context_t *p_client; - ble_gatts_evt_write_t const *p_evt_write = &p_ble_evt->evt.gatts_evt.params.write; - - err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage, p_ble_evt->evt.gatts_evt.conn_handle, (void *)&p_client); - if (err_code != NRF_SUCCESS) { - NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.", p_ble_evt->evt.gatts_evt.conn_handle); - } + zdatachannel_evt_t evt; + ble_gatts_evt_write_t const *p_evt_write = &p_ble_evt->evt.gatts_evt.params.write; memset(&evt, 0, sizeof(zdatachannel_evt_t)); - evt.p_nus = p_nus; - evt.conn_handle = p_ble_evt->evt.gatts_evt.conn_handle; - evt.p_link_ctx = p_client; - - if ((p_evt_write->handle == p_nus->tx_handles.cccd_handle) && (p_evt_write->len == 2)) { - if (p_client != NULL) { - if (ble_srv_is_notification_enabled(p_evt_write->data)) { - p_client->is_notification_enabled = true; - evt.type = ZDATACANNEL_EVT_COMM_STARTED; - } else { - p_client->is_notification_enabled = false; - evt.type = ZDATACANNEL_EVT_COMM_STOPPED; - } - - if (p_nus->data_handler != NULL) { - p_nus->data_handler(&evt); - } + + if ((p_evt_write->handle == p_nus->cmd_tx_handles.cccd_handle) && (p_evt_write->len == 2)) { + if (ble_srv_is_notification_enabled(p_evt_write->data)) { + p_nus->cmd_tx_channel_is_notification_enabled = true; + } else { + p_nus->cmd_tx_channel_is_notification_enabled = false; + } + } else if ((p_evt_write->handle == p_nus->datablock_tx_handles.cccd_handle) && (p_evt_write->len == 2)) { + if (ble_srv_is_notification_enabled(p_evt_write->data)) { + p_nus->datablock_tx_channel_is_notification_enabled = true; + } else { + p_nus->datablock_tx_channel_is_notification_enabled = false; } - } else if ((p_evt_write->handle == p_nus->rx_handles.value_handle) && (p_nus->data_handler != NULL)) { - evt.type = ZDATACANNEL_EVT_RX_DATA; + } else if ((p_evt_write->handle == p_nus->cmd_tx_handles.value_handle) && (p_nus->data_handler != NULL)) { + evt.type = ZDATACHANNEL_EVT_RX_DATA; evt.params.rx_data.p_data = p_evt_write->data; evt.params.rx_data.length = p_evt_write->len; @@ -102,33 +70,6 @@ static void on_write(zdatachannel_t *p_nus, ble_evt_t const *p_ble_evt) { } } -/**@brief Function for handling the @ref BLE_GATTS_EVT_HVN_TX_COMPLETE event from the SoftDevice. - * - * @param[in] p_nus Nordic UART Service structure. - * @param[in] p_ble_evt Pointer to the event received from BLE stack. - */ -static void on_hvx_tx_complete(zdatachannel_t *p_nus, ble_evt_t const *p_ble_evt) { - ret_code_t err_code; - zdatachannel_evt_t evt; - zdatachannel_client_context_t *p_client; - - err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage, p_ble_evt->evt.gatts_evt.conn_handle, (void *)&p_client); - if (err_code != NRF_SUCCESS) { - NRF_LOG_ERROR("Link context for 0x%02X connection handle could not be fetched.", p_ble_evt->evt.gatts_evt.conn_handle); - return; - } - - if ((p_client->is_notification_enabled) && (p_nus->data_handler != NULL)) { - memset(&evt, 0, sizeof(zdatachannel_evt_t)); - evt.type = ZDATACANNEL_EVT_TX_RDY; - evt.p_nus = p_nus; - evt.conn_handle = p_ble_evt->evt.gatts_evt.conn_handle; - evt.p_link_ctx = p_client; - - p_nus->data_handler(&evt); - } -} - void zdatachannel_on_ble_evt(ble_evt_t const *p_ble_evt, void *p_context) { if ((p_context == NULL) || (p_ble_evt == NULL)) { return; @@ -138,17 +79,16 @@ void zdatachannel_on_ble_evt(ble_evt_t const *p_ble_evt, void *p_context) { switch (p_ble_evt->header.evt_id) { case BLE_GAP_EVT_CONNECTED: - on_connect(p_nus, p_ble_evt); + p_nus->conn_handle = p_ble_evt->evt.gap_evt.conn_handle; + p_nus->cmd_tx_channel_is_notification_enabled = notification_enable(p_ble_evt->evt.gap_evt.conn_handle, p_nus->cmd_tx_handles.cccd_handle); + p_nus->datablock_tx_channel_is_notification_enabled = notification_enable(p_ble_evt->evt.gap_evt.conn_handle, p_nus->cmd_tx_handles.cccd_handle); + break; + case BLE_GAP_EVT_DISCONNECTED: + p_nus->conn_handle = BLE_CONN_HANDLE_INVALID; break; - case BLE_GATTS_EVT_WRITE: on_write(p_nus, p_ble_evt); break; - - case BLE_GATTS_EVT_HVN_TX_COMPLETE: - on_hvx_tx_complete(p_nus, p_ble_evt); - break; - default: // No implementation needed. break; @@ -156,6 +96,7 @@ void zdatachannel_on_ble_evt(ble_evt_t const *p_ble_evt, void *p_context) { } uint32_t zdatachannel_init(zdatachannel_t *p_nus, zdatachannel_init_t const *p_nus_init) { + p_datachannel = p_nus; ret_code_t err_code; ble_uuid_t ble_uuid; ble_uuid128_t nus_base_uuid = NUS_BASE_UUID; @@ -173,7 +114,7 @@ uint32_t zdatachannel_init(zdatachannel_t *p_nus, zdatachannel_init_t const *p_n VERIFY_SUCCESS(err_code); ble_uuid.type = p_nus->uuid_type; - ble_uuid.uuid = BLE_UUID_NUS_SERVICE; + ble_uuid.uuid = ZDATACHANNEL_UUID_NUS_SERVICE; // Add the service. err_code = sd_ble_gatts_service_add(BLE_GATTS_SRVC_TYPE_PRIMARY, &ble_uuid, &p_nus->service_handle); @@ -182,28 +123,25 @@ uint32_t zdatachannel_init(zdatachannel_t *p_nus, zdatachannel_init_t const *p_n // Add the RX Characteristic. memset(&add_char_params, 0, sizeof(add_char_params)); - add_char_params.uuid = BLE_UUID_NUS_RX_CHARACTERISTIC; + add_char_params.uuid = ZDATACHANNEL_RX_CHARACTERISTIC; add_char_params.uuid_type = p_nus->uuid_type; - add_char_params.max_len = ZDATACANNEL_MAX_RX_CHAR_LEN; + add_char_params.max_len = ZDATACHANNEL_MAX_RX_CHAR_LEN; add_char_params.init_len = sizeof(uint8_t); add_char_params.is_var_len = true; add_char_params.char_props.write = 1; add_char_params.char_props.write_wo_resp = 1; - add_char_params.read_access = SEC_OPEN; + add_char_params.read_access = SEC_NO_ACCESS; add_char_params.write_access = SEC_OPEN; - err_code = characteristic_add(p_nus->service_handle, &add_char_params, &p_nus->rx_handles); - if (err_code != NRF_SUCCESS) { - return err_code; - } + VERIFY_SUCCESS(characteristic_add(p_nus->service_handle, &add_char_params, &p_nus->cmd_rx_handles)); // Add the TX Characteristic. /**@snippet [Adding proprietary characteristic to the SoftDevice] */ memset(&add_char_params, 0, sizeof(add_char_params)); - add_char_params.uuid = BLE_UUID_NUS_TX_CHARACTERISTIC; + add_char_params.uuid = ZDATACHANNEL_TX_CHARACTERISTIC; add_char_params.uuid_type = p_nus->uuid_type; - add_char_params.max_len = ZDATACANNEL_MAX_TX_CHAR_LEN; + add_char_params.max_len = ZDATACHANNEL_MAX_TX_CHAR_LEN; add_char_params.init_len = sizeof(uint8_t); add_char_params.is_var_len = true; add_char_params.char_props.notify = 1; @@ -212,38 +150,67 @@ uint32_t zdatachannel_init(zdatachannel_t *p_nus, zdatachannel_init_t const *p_n add_char_params.write_access = SEC_OPEN; add_char_params.cccd_write_access = SEC_OPEN; - return characteristic_add(p_nus->service_handle, &add_char_params, &p_nus->tx_handles); + VERIFY_SUCCESS(characteristic_add(p_nus->service_handle, &add_char_params, &p_nus->cmd_tx_handles)); + + // Add the TX Characteristic. /**@snippet [Adding proprietary characteristic to the SoftDevice] */ -} + memset(&add_char_params, 0, sizeof(add_char_params)); + add_char_params.uuid = ZDATACHANNEL_DATABLOCK_TX_CHARACTERISTIC; + add_char_params.uuid_type = p_nus->uuid_type; + add_char_params.max_len = ZDATACHANNEL_DATABLOCK_TX_CHAR_LEN; + add_char_params.init_len = sizeof(uint8_t); + add_char_params.is_var_len = true; + add_char_params.char_props.notify = 1; -uint32_t zdatachannel_data_send(zdatachannel_t *p_nus, uint8_t *p_data, uint16_t *p_length, uint16_t conn_handle) { - ret_code_t err_code; - ble_gatts_hvx_params_t hvx_params; - zdatachannel_client_context_t *p_client; + add_char_params.read_access = SEC_OPEN; + add_char_params.write_access = SEC_OPEN; + add_char_params.cccd_write_access = SEC_OPEN; - VERIFY_PARAM_NOT_NULL(p_nus); + VERIFY_SUCCESS(characteristic_add(p_nus->service_handle, &add_char_params, &p_nus->datablock_tx_handles)); - err_code = blcm_link_ctx_get(p_nus->p_link_ctx_storage, conn_handle, (void *)&p_client); - VERIFY_SUCCESS(err_code); + return NRF_SUCCESS; + /**@snippet [Adding proprietary characteristic to the SoftDevice] */ +} - if ((conn_handle == BLE_CONN_HANDLE_INVALID) || (p_client == NULL)) { - return NRF_ERROR_NOT_FOUND; - } +uint32_t zdatachannel_data_send(uint8_t *p_data, uint16_t *p_length) { + ret_code_t err_code; + ble_gatts_hvx_params_t hvx_params; - if (!p_client->is_notification_enabled) { + if (!p_datachannel->cmd_tx_channel_is_notification_enabled) { return NRF_ERROR_INVALID_STATE; } - if (*p_length > ZDATACANNEL_MAX_DATA_LEN) { + if (*p_length > ZDATACHANNEL_MAX_DATA_LEN) { return NRF_ERROR_INVALID_PARAM; } memset(&hvx_params, 0, sizeof(hvx_params)); - hvx_params.handle = p_nus->tx_handles.value_handle; + hvx_params.handle = p_datachannel->cmd_tx_handles.value_handle; + hvx_params.p_data = p_data; + hvx_params.p_len = p_length; + hvx_params.type = BLE_GATT_HVX_NOTIFICATION; + + return sd_ble_gatts_hvx(p_datachannel->conn_handle, &hvx_params); +} + +uint32_t zdatachannel_block_data_send(uint8_t *p_data, uint16_t *p_length) { + ret_code_t err_code; + ble_gatts_hvx_params_t hvx_params; + + if (!p_datachannel->datablock_tx_channel_is_notification_enabled) { + return NRF_ERROR_INVALID_STATE; + } + + if (*p_length > ZDATACHANNEL_MAX_DATA_LEN) { + return NRF_ERROR_INVALID_PARAM; + } + memset(&hvx_params, 0, sizeof(hvx_params)); + + hvx_params.handle = p_datachannel->datablock_tx_handles.value_handle; hvx_params.p_data = p_data; hvx_params.p_len = p_length; hvx_params.type = BLE_GATT_HVX_NOTIFICATION; - return sd_ble_gatts_hvx(conn_handle, &hvx_params); + return sd_ble_gatts_hvx(p_datachannel->conn_handle, &hvx_params); } diff --git a/app/src/zdatachannel_service.h b/app/src/zdatachannel_service.h index f9cffd0..7941ed7 100644 --- a/app/src/zdatachannel_service.h +++ b/app/src/zdatachannel_service.h @@ -1,5 +1,5 @@ -#ifndef ZDATACANNEL_H__ -#define ZDATACANNEL_H__ +#ifndef ZDATACHANNEL_H__ +#define ZDATACHANNEL_H__ #include #include @@ -20,30 +20,24 @@ extern "C" { * @param[in] _nus_max_clients Maximum number of NUS clients connected at a time. * @hideinitializer */ -#define ZDATACANNEL_DEF(_name, _ble_observer_prio,_nus_max_clients) \ - BLE_LINK_CTX_MANAGER_DEF(CONCAT_2(_name, _link_ctx_storage), (_nus_max_clients), sizeof(zdatachannel_client_context_t)); \ - static zdatachannel_t _name = {.p_link_ctx_storage = &CONCAT_2(_name, _link_ctx_storage)}; \ +#define ZDATACHANNEL_DEF(_name, _ble_observer_prio, _nus_max_clients) \ + static zdatachannel_t _name; \ NRF_SDH_BLE_OBSERVER(_name##_obs, _ble_observer_prio, zdatachannel_on_ble_evt, &_name) -#define BLE_UUID_NUS_SERVICE 0x0001 /**< The UUID of the Nordic UART Service. */ - #define OPCODE_LENGTH 1 #define HANDLE_LENGTH 2 /**@brief Maximum length of data (in bytes) that can be transmitted to the peer by the Nordic UART service module. */ #if defined(NRF_SDH_BLE_GATT_MAX_MTU_SIZE) && (NRF_SDH_BLE_GATT_MAX_MTU_SIZE != 0) -#define ZDATACANNEL_MAX_DATA_LEN (NRF_SDH_BLE_GATT_MAX_MTU_SIZE - OPCODE_LENGTH - HANDLE_LENGTH) +#define ZDATACHANNEL_MAX_DATA_LEN (NRF_SDH_BLE_GATT_MAX_MTU_SIZE - OPCODE_LENGTH - HANDLE_LENGTH) #else -#define ZDATACANNEL_MAX_DATA_LEN (BLE_GATT_MTU_SIZE_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH) +#define ZDATACHANNEL_MAX_DATA_LEN (BLE_GATT_MTU_SIZE_DEFAULT - OPCODE_LENGTH - HANDLE_LENGTH) #warning NRF_SDH_BLE_GATT_MAX_MTU_SIZE is not defined. #endif /**@brief Nordic UART Service event types. */ typedef enum { - ZDATACANNEL_EVT_RX_DATA, /**< Data received. */ - ZDATACANNEL_EVT_TX_RDY, /**< Service is ready to accept new data to be transmitted. */ - ZDATACANNEL_EVT_COMM_STARTED, /**< Notification has been enabled. */ - ZDATACANNEL_EVT_COMM_STOPPED, /**< Notification has been disabled. */ + ZDATACHANNEL_EVT_RX_DATA, /**< Data received. */ } zdatachannel_evt_type_t; typedef struct zdatachannel_s zdatachannel_t; @@ -54,42 +48,42 @@ typedef struct { } zdatachannel_evt_rx_data_t; typedef struct { - bool is_notification_enabled; /**< Variable to indicate if the peer has enabled notification of the RX characteristic.*/ -} zdatachannel_client_context_t; - -typedef struct { - zdatachannel_evt_type_t type; /**< Event type. */ - zdatachannel_t* p_nus; /**< A pointer to the instance. */ - uint16_t conn_handle; /**< Connection handle. */ - zdatachannel_client_context_t* p_link_ctx; /**< A pointer to the link context. */ + zdatachannel_evt_type_t type; /**< Event type. */ union { - zdatachannel_evt_rx_data_t rx_data; /**< @ref ZDATACANNEL_EVT_RX_DATA event data. */ + zdatachannel_evt_rx_data_t rx_data; /**< @ref ZDATACHANNEL_EVT_RX_DATA event data. */ } params; } zdatachannel_evt_t; typedef void (*zdatachannel_data_handler_t)(zdatachannel_evt_t* p_evt); typedef struct { - zdatachannel_data_handler_t data_handler; /**< Event handler to be called for handling received data. */ + zdatachannel_data_handler_t data_handler; } zdatachannel_init_t; struct zdatachannel_s { - uint8_t uuid_type; /**< UUID type for Nordic UART Service Base UUID. */ - uint16_t service_handle; /**< Handle of Nordic UART Service (as provided by the SoftDevice). */ - ble_gatts_char_handles_t tx_handles; /**< Handles related to the TX characteristic (as provided by the SoftDevice). */ - ble_gatts_char_handles_t rx_handles; /**< Handles related to the RX characteristic (as provided by the SoftDevice). */ - blcm_link_ctx_storage_t* const p_link_ctx_storage; /**< Pointer to link context storage with handles of all current connections and its context. */ - zdatachannel_data_handler_t data_handler; /**< Event handler to be called for handling received data. */ + uint8_t uuid_type; /**< UUID type for Nordic UART Service Base UUID. */ + uint16_t service_handle; /**< Handle of Nordic UART Service (as provided by the SoftDevice). */ + ble_gatts_char_handles_t cmd_tx_handles; /**< 指令发送句柄 */ + ble_gatts_char_handles_t cmd_rx_handles; /**< 指令接收句柄 */ + ble_gatts_char_handles_t datablock_tx_handles; /**< 数据块发送句柄 */ + zdatachannel_data_handler_t data_handler; /**< Event handler to be called for handling received data. */ + + // 状态 + int16_t conn_handle; + bool cmd_tx_channel_is_notification_enabled; + bool datablock_tx_channel_is_notification_enabled; }; uint32_t zdatachannel_init(zdatachannel_t* p_nus, zdatachannel_init_t const* p_nus_init); void zdatachannel_on_ble_evt(ble_evt_t const* p_ble_evt, void* p_context); -uint32_t zdatachannel_data_send(zdatachannel_t* p_nus, uint8_t* p_data, uint16_t* p_length, uint16_t conn_handle); + +uint32_t zdatachannel_data_send(uint8_t* p_data, uint16_t* p_length); +uint32_t zdatachannel_block_data_send(uint8_t* p_data, uint16_t* p_length); #ifdef __cplusplus } #endif -#endif // ZDATACANNEL_H__ +#endif // ZDATACHANNEL_H__ /** @} */