解析代码WORD Length; switch(Type) { case 1://设备地址 Length = sizeof( StateRecord.Device_ID ); break; case 2://继电器状态 Length = sizeof( StateRecord.RelayCtrRecord ); break; case 3://隔离CT控制状态 Length = sizeof( StateRecord.CT_CtrRecord ); break; case 4://电磁阀控制状态 Length = sizeof( StateRecord.ValveCtrRecord ); break; default: Length = 0; break; } return Length;
时间: 2024-04-16 20:26:09 浏览: 12
这段代码是一个函数,根据给定的Type值返回不同的长度值。根据Type的不同,代码会进入不同的case分支,并给Length赋上相应的值。如果Type是1,Length会被赋上StateRecord.Device_ID的大小;如果Type是2,Length会被赋上StateRecord.RelayCtrRecord的大小;如果Type是3,Length会被赋上StateRecord.CT_CtrRecord的大小;如果Type是4,Length会被赋上StateRecord.ValveCtrRecord的大小;如果Type不是1、2、3、4中的任何一个,Length会被赋值为0。最后,函数返回Length的值。
相关问题
nrf52830蓝牙加密是怎么一回事?用sdk或者其他代码来讲解
nRF52830 是一款支持加密的蓝牙芯片,可以使用 Nordic 官方提供的 SDK 或者其他库来实现加密功能。下面是一个使用 Nordic SDK 实现 nRF52830 蓝牙加密的代码示例:
```c
#include "nrf_ble_gatt.h"
#include "nrf_ble_qwr.h"
#include "nrf_sdh_ble.h"
#include "nrf_sdh_soc.h"
#include "nrf_ble_scan.h"
#include "nrf_ble_conn_params.h"
#include "nrf_ble_gq.h"
#include "nrf_crypto.h"
#include "nrf_crypto_error.h"
#define DEVICE_NAME "MyDevice" // 设备名称
#define APP_BLE_OBSERVER_PRIO 3 // BLE事件观察者优先级
static ble_gap_sec_params_t m_sec_params; // 安全参数
static ble_gap_conn_params_t m_conn_params; // 连接参数
static uint16_t m_conn_handle = BLE_CONN_HANDLE_INVALID;// 连接句柄
void ble_stack_init(void)
{
ret_code_t err_code;
// 初始化 SoftDevice
err_code = nrf_sdh_enable_request();
APP_ERROR_CHECK(err_code);
// 配置 SoftDevice 协议栈
nrf_sdh_ble_default_cfg_set(APP_BLE_OBSERVER_PRIO);
// 配置 BLE GAP
ble_gap_conn_sec_mode_t sec_mode;
BLE_GAP_CONN_SEC_MODE_SET_OPEN(&sec_mode);
err_code = sd_ble_gap_device_name_set(&sec_mode, (const uint8_t *)DEVICE_NAME, strlen(DEVICE_NAME));
APP_ERROR_CHECK(err_code);
// 配置安全参数
memset(&m_sec_params, 0, sizeof(m_sec_params));
m_sec_params.bond = 1;
m_sec_params.mitm = 1;
m_sec_params.lesc = 1;
m_sec_params.keypress = 0;
m_sec_params.io_caps = BLE_GAP_IO_CAPS_NONE;
m_sec_params.oob = 0;
m_sec_params.min_key_size = 7;
m_sec_params.max_key_size = 16;
// 配置连接参数
memset(&m_conn_params, 0, sizeof(m_conn_params));
m_conn_params.min_conn_interval = MSEC_TO_UNITS(20, UNIT_1_25_MS);
m_conn_params.max_conn_interval = MSEC_TO_UNITS(75, UNIT_1_25_MS);
m_conn_params.slave_latency = 0;
m_conn_params.conn_sup_timeout = MSEC_TO_UNITS(4000, UNIT_10_MS);
// 初始化 BLE GATT
err_code = nrf_ble_gatt_init(&m_gatt, NULL);
APP_ERROR_CHECK(err_code);
// 初始化 BLE QWR
err_code = nrf_ble_qwr_init(&m_qwr, &m_qwr_buffer);
APP_ERROR_CHECK(err_code);
// 初始化 BLE Scan
err_code = nrf_ble_scan_init(&m_scan, NULL, NULL);
APP_ERROR_CHECK(err_code);
// 初始化 BLE Connection Parameters
err_code = nrf_ble_conn_params_init(&m_conn_params);
APP_ERROR_CHECK(err_code);
// 初始化 BLE GQ
err_code = nrf_ble_gq_init(&m_ble_gq, ble_gatt_evt_handler);
APP_ERROR_CHECK(err_code);
// 启用 BLE Stack
err_code = nrf_sdh_ble_enable(&m_sec_params);
APP_ERROR_CHECK(err_code);
}
void ble_gap_evt_handler(ble_gap_evt_t const * p_gap_evt, void * p_context)
{
ret_code_t err_code;
switch (p_gap_evt->evt_id)
{
case BLE_GAP_EVT_CONNECTED:
m_conn_handle = p_gap_evt->conn_handle;
break;
case BLE_GAP_EVT_DISCONNECTED:
m_conn_handle = BLE_CONN_HANDLE_INVALID;
break;
case BLE_GAP_EVT_SEC_PARAMS_REQUEST:
err_code = sd_ble_gap_sec_params_reply(m_conn_handle, BLE_GAP_SEC_STATUS_SUCCESS, &m_sec_params, NULL);
APP_ERROR_CHECK(err_code);
break;
case BLE_GAP_EVT_AUTH_STATUS:
if (p_gap_evt->params.auth_status.auth_status == BLE_GAP_SEC_STATUS_SUCCESS)
{
// 认证通过,加密连接
err_code = nrf_ble_gatt_authenticate(m_conn_handle, NULL);
APP_ERROR_CHECK(err_code);
}
break;
case BLE_GAP_EVT_CONN_PARAM_UPDATE_REQUEST:
err_code = sd_ble_gap_conn_param_update(m_conn_handle, &p_gap_evt->params.conn_param_update_request.conn_params);
APP_ERROR_CHECK(err_code);
break;
default:
// 不处理其他事件
break;
}
}
void ble_gatt_evt_handler(nrf_ble_gatt_t * p_gatt, nrf_ble_gatt_evt_t const * p_evt)
{
ret_code_t err_code;
switch (p_evt->evt_id)
{
case NRF_BLE_GATT_EVT_MTU_CHANGED:
break;
case NRF_BLE_GATT_EVT_ATT_MTU_UPDATED:
break;
case NRF_BLE_GATT_EVT_DATA_LENGTH_UPDATED:
break;
case NRF_BLE_GATT_EVT_ATT_EXCHANGE_MTU_REQUEST:
err_code = nrf_ble_gatt_att_mtu_reply(p_gatt, p_evt->conn_handle, BLE_GATT_ATT_MTU_DEFAULT);
APP_ERROR_CHECK(err_code);
break;
case NRF_BLE_GATT_EVT_HVX:
break;
case NRF_BLE_GATT_EVT_WRITE:
break;
case NRF_BLE_GATT_EVT_READ:
break;
case NRF_BLE_GATT_EVT_TIMEOUT:
break;
case NRF_BLE_GATT_EVT_EXCHANGE_MTU_RSP:
break;
case NRF_BLE_GATT_EVT_CHAR_DISC_RSP:
break;
case NRF_BLE_GATT_EVT_DESC_DISC_RSP:
break;
case NRF_BLE_GATT_EVT_CHAR_VALS_READ_RSP:
break;
case NRF_BLE_GATT_EVT_WRITE_RSP:
break;
case NRF_BLE_GATT_EVT_HANDLE_VALUE_INDICATION_CONFIRMED:
break;
default:
// 不处理其他事件
break;
}
}
void ble_stack_start(void)
{
ret_code_t err_code;
// 启动 BLE Scan
err_code = nrf_ble_scan_start(&m_scan);
APP_ERROR_CHECK(err_code);
// 启动 BLE Connection Parameters
err_code = nrf_ble_conn_params_enable();
APP_ERROR_CHECK(err_code);
}
```
在上述代码中,我们使用了 Nordic SDK 提供的函数来初始化蓝牙协议栈、配置安全参数、配置连接参数、初始化 GATT、初始化 QWR、初始化 BLE Scan、初始化 BLE Connection Parameters 等,最终启动 BLE Stack,实现了 nRF52830 蓝牙加密功能。
需要注意的是,在安全参数中我们设置了 mitm 和 lesc 为 1,这表示我们需要进行双向身份验证和安全连接。在 BLE_GAP_EVT_AUTH_STATUS 事件中,当认证成功时,我们通过调用 nrf_ble_gatt_authenticate 函数来进行加密连接,从而实现了蓝牙加密功能。
esp32 蓝牙启动流程_ESP32教你简单进行蓝牙串口调试
ESP32的蓝牙启动流程如下:
1. 初始化蓝牙协议栈
2. 配置蓝牙参数,如设备名称、服务UUID等
3. 注册蓝牙事件回调函数
4. 启动蓝牙广播
5. 开启蓝牙可见性
6. 等待连接
以下是一个简单的ESP32蓝牙串口调试的示例:
```C
#include "esp_bt.h"
#include "esp_bt_main.h"
#include "esp_gap_ble_api.h"
#define GATTS_TAG "GATTS_DEMO"
#define TEST_DEVICE_NAME "ESP32_BLE_UART"
#define TEST_MANUFACTURER_DATA_LEN 17
/* The max length of characteristic value. When the gatt client write or prepare write,
* the data length must be less than MAX_VALUE_LENGTH.
*/
#define MAX_VALUE_LENGTH 500
/* Declare global variable */
static uint8_t test_manufacturer[TEST_MANUFACTURER_DATA_LEN] = {0x4c, 0x00, 0x02, 0x15, 0xE2, 0x0A, 0x39, 0xF4, 0x73, 0xF5, 0x4B, 0xC4, 0xA1, 0x2F, 0x17, 0xD1, 0xAD};
static uint8_t test_service_uuid128[32] = {
/* LSB <--------------------------------------------------------------------------------> MSB */
//first uuid, 16bit, [12],[13] is the value
0x13, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
//second uuid, 32bit, [12], [13], [14], [15] is the value
0x14, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
};
static uint8_t test_service_uuid[16] = {
/* LSB <--------------------------------------------------------------------------------> MSB */
//first uuid, 16bit, [12],[13] is the value
0x01, 0x2B,
//second uuid, 32bit, [12], [13], [14], [15] is the value
0x01, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
};
static uint8_t test_char_uuid[16] = {
/* LSB <--------------------------------------------------------------------------------> MSB */
//first uuid, 16bit, [12],[13] is the value
0x02, 0x2B,
//second uuid, 32bit, [12], [13], [14], [15] is the value
0x02, 0x2B, 0x01, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB,
};
static esp_gatt_char_prop_t test_property = 0;
static uint8_t char1_str[] = {0x11,0x22,0x33};
static esp_attr_value_t gatts_demo_char1_val = {
.attr_max_len = MAX_VALUE_LENGTH,
.attr_len = sizeof(char1_str),
.attr_value = char1_str,
};
static uint16_t gatts_demo_handle_table[3];
/* Full Database Description - Used to add attributes into the database */
static const esp_gatts_attr_db_t gatt_db[HRS_IDX_NB] =
{
// Service Declaration
[IDX_SVC] =
{
{ESP_GATT_AUTO_RSP},
{ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ,
sizeof(test_service_uuid), sizeof(test_service_uuid), (uint8_t *)&test_service_uuid},
ESP_GATT_UUID_PRI_SERVICE,
ESP_GATT_PERM_READ,
sizeof(test_service_uuid),
sizeof(test_service_uuid),
(uint8_t *)&test_service_uuid,
0
},
/* Characteristic Declaration */
[IDX_CHAR_READ] =
{
{ESP_GATT_AUTO_RSP},
{ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ,
CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, (uint8_t *)&test_property},
ESP_GATT_UUID_CHAR_DECLARE,
ESP_GATT_PERM_READ,
CHAR_DECLARATION_SIZE,
CHAR_DECLARATION_SIZE,
(uint8_t *)&test_property,
0
},
/* Characteristic Value */
[IDX_CHAR_VAL_READ] =
{
{ESP_GATT_AUTO_RSP},
{ESP_UUID_LEN_128, (uint8_t *)&test_char_uuid, ESP_GATT_PERM_READ,
MAX_VALUE_LENGTH, sizeof(gatts_demo_char1_val), gatts_demo_char1_val.attr_value},
ESP_UUID_LEN_128,
ESP_GATT_PERM_READ,
MAX_VALUE_LENGTH,
sizeof(gatts_demo_char1_val),
gatts_demo_char1_val.attr_value,
0
},
};
static esp_ble_adv_data_t adv_data = {
.set_scan_rsp = false,
.include_name = true,
.include_txpower = true,
.min_interval = 0x20,
.max_interval = 0x40,
.appearance = 0x00,
.manufacturer_len = TEST_MANUFACTURER_DATA_LEN,
.p_manufacturer_data = test_manufacturer,
.service_data_len = 0,
.p_service_data = NULL,
.service_uuid_len = sizeof(test_service_uuid),
.p_service_uuid = test_service_uuid,
.flag = (ESP_BLE_ADV_FLAG_GEN_DISC | ESP_BLE_ADV_FLAG_BREDR_NOT_SPT),
};
static esp_ble_adv_params_t adv_params = {
.adv_int_min = 0x20,
.adv_int_max = 0x40,
.adv_type = ADV_TYPE_IND,
.own_addr_type = BLE_ADDR_TYPE_PUBLIC,
.peer_addr = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
.peer_addr_type = BLE_ADDR_TYPE_PUBLIC,
.channel_map = ADV_CHNL_ALL,
.adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY,
};
static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param)
{
switch (event) {
case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT:
esp_ble_gap_start_advertising(&adv_params);
break;
case ESP_GAP_BLE_ADV_START_COMPLETE_EVT:
if (param->adv_start_cmpl.status != ESP_BT_STATUS_SUCCESS) {
ESP_LOGE(GATTS_TAG, "advertising start failed");
}
break;
default:
break;
}
}
static void gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, esp_ble_gatts_cb_param_t *param)
{
switch (event) {
case ESP_GATTS_REG_EVT:
esp_ble_gap_set_device_name(TEST_DEVICE_NAME);
esp_ble_gap_config_adv_data(&adv_data);
break;
case ESP_GATTS_CREAT_ATTR_TAB_EVT:
if (param->add_attr_tab.status != ESP_GATT_OK){
ESP_LOGE(GATTS_TAG, "create attribute table failed, error code=0x%x", param->add_attr_tab.status);
}
else if (param->add_attr_tab.num_handle != HRS_IDX_NB) {
ESP_LOGE(GATTS_TAG, "create attribute table abnormally, num_handle (%d) \
doesn't equal to HRS_IDX_NB(%d)", param->add_attr_tab.num_handle, HRS_IDX_NB);
}
else {
ESP_LOGI(GATTS_TAG, "create attribute table successfully, the number handle = %d\n",param->add_attr_tab.num_handle);
memcpy(gatts_demo_handle_table, param->add_attr_tab.handles, sizeof(gatts_demo_handle_table));
esp_ble_gatts_start_service(gatts_demo_handle_table[IDX_SVC]);
}
break;
case ESP_GATTS_CONNECT_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONNECT_EVT");
break;
case ESP_GATTS_DISCONNECT_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_DISCONNECT_EVT");
esp_ble_gap_start_advertising(&adv_params);
break;
case ESP_GATTS_WRITE_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_WRITE_EVT");
break;
case ESP_GATTS_MTU_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_MTU_EVT, MTU %d", param->mtu.mtu);
break;
case ESP_GATTS_CONF_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONF_EVT");
break;
case ESP_GATTS_EXEC_WRITE_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_EXEC_WRITE_EVT");
break;
case ESP_GATTS_START_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_START_EVT");
break;
case ESP_GATTS_STOP_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_STOP_EVT");
break;
case ESP_GATTS_OPEN_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_OPEN_EVT");
break;
case ESP_GATTS_CANCEL_OPEN_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_CANCEL_OPEN_EVT");
break;
case ESP_GATTS_CLOSE_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_CLOSE_EVT");
break;
case ESP_GATTS_LISTEN_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_LISTEN_EVT");
break;
case ESP_GATTS_CONGEST_EVT:
ESP_LOGI(GATTS_TAG, "ESP_GATTS_CONGEST_EVT");
break;
case ESP_GATTS_UNREG_EVT:
case ESP_GATTS_DELETE_EVT:
default:
break;
}
}
void app_main()
{
esp_err_t ret;
ESP_LOGI(GATTS_TAG, "ESP_BLUETOOTH_BLE example started.");
esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT();
ret = esp_bt_controller_init(&bt_cfg);
if (ret) {
ESP_LOGE(GATTS_TAG, "%s initialize controller failed\n", __func__);
return;
}
ret = esp_bt_controller_enable(ESP_BT_MODE_BLE);
if (ret) {
ESP_LOGE(GATTS_TAG, "%s enable controller failed\n", __func__);
return;
}
ret = esp_bluedroid_init();
if (ret) {
ESP_LOGE(GATTS_TAG, "%s init bluetooth failed\n", __func__);
return;
}
ret = esp_bluedroid_enable();
if (ret) {
ESP_LOGE(GATTS_TAG, "%s enable bluetooth failed\n", __func__);
return;
}
ret = esp_ble_gatts_register_callback(gatts_event_handler);
if (ret){
ESP_LOGE(GATTS_TAG, "gatts register error, error code = %x", ret);
return;
}
ret = esp_ble_gap_register_callback(gap_event_handler);
if (ret){
ESP_LOGE(GATTS_TAG, "gap register error, error code = %x", ret);
return;
}
ret = esp_ble_gatts_app_register(ESP_APP_ID);
if (ret){
ESP_LOGE(GATTS_TAG, "gatts app register error, error code = %x", ret);
return;
}
esp_err_t local_mtu_ret = esp_ble_gatt_set_local_mtu(500);
if (local_mtu_ret){
ESP_LOGE(GATTS_TAG, "set local MTU failed, error code = %x", local_mtu_ret);
}
ret = esp_ble_gatts_create_attr_tab(gatt_db, gatts_if, HRS_IDX_NB, ESP_APP_ID);
if (ret){
ESP_LOGE(GATTS_TAG, "create attr table failed, error code = %x", ret);
}
}
```
在这个示例中,我们使用了ESP-IDF提供的蓝牙协议栈和GATT Server框架,实现了一个简单的GATT Server,并且开启了蓝牙广播和可见性,使得其他蓝牙设备可以扫描到并连接我们的设备。在连接建立后,我们可以向GATT Server中的特定Characteristic写入数据,也可以从特定Characteristic读取数据。
相关推荐
![pdf](https://img-home.csdnimg.cn/images/20210720083512.png)
![rar](https://img-home.csdnimg.cn/images/20210720083606.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)