请解释 NRF5中nrf_sdh_enable_request
时间: 2023-09-16 19:12:37 浏览: 57
nrf_sdh_enable_request是一个函数,用于启用SoftDevice Handler Library(SDH)的功能。SDH是一个库,用于管理Nordic Semiconductor的SoftDevice,即蓝牙协议栈。当使用Nordic Semiconductor的SDK时,SDH通常被用来初始化和配置SoftDevice,并处理SoftDevice的事件和回调。nrf_sdh_enable_request函数会请求启用SDH,它将初始化SoftDevice并启动SoftDevice的事件处理。如果SDH已经被启用,该函数将什么都不做。
相关问题
nrf52832 2.4g获取设备rssi
要获取nrf52832设备的2.4G信号强度指示(RSSI),您需要在nrf52832上运行适当的代码并使用BLE协议栈 API。以下是一个示例代码片段,可以在nrf52832上获取连接设备的RSSI值:
```c
#include <stdbool.h>
#include <stdint.h>
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_sdh.h"
#include "nrf_sdh_ble.h"
#include "ble.h"
#include "ble_gap.h"
// 定义一个 ble_gap_evt_handler_t 类型的函数,
// 用于处理 GAP (Generic Access Profile) 事件
void ble_gap_evt_handler(ble_gap_evt_t const * p_gap_evt, void * p_context)
{
switch (p_gap_evt->params.rssi_changed.rssi)
{
case BLE_GAP_RSSI_INVALID: // RSSI无效
NRF_LOG_INFO("RSSI无效");
break;
default: // RSSI有效
NRF_LOG_INFO("RSSI = %d dBm", p_gap_evt->params.rssi_changed.rssi);
break;
}
}
// 初始化 BLE Stack
static void ble_stack_init(void)
{
ret_code_t err_code;
err_code = nrf_sdh_enable_request();
APP_ERROR_CHECK(err_code);
// 等待 SoftDevice 启动
while (nrf_sdh_is_enabled() == false)
{
// Empty.
}
// 初始化 BLE Stack
err_code = nrf_sdh_ble_default_cfg_set(APP_BLE_CONN_CFG_TAG, &cfg);
APP_ERROR_CHECK(err_code);
err_code = nrf_sdh_ble_enable(&ram_start);
APP_ERROR_CHECK(err_code);
}
// 初始化 GAP (Generic Access Profile)
static void gap_params_init(void)
{
ret_code_t err_code;
ble_gap_conn_params_t gap_conn_params = {0};
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);
err_code = sd_ble_gap_appearance_set(BLE_APPEARANCE_GENERIC_TAG);
APP_ERROR_CHECK(err_code);
memset(&gap_conn_params, 0, sizeof(gap_conn_params));
gap_conn_params.min_conn_interval = MIN_CONN_INTERVAL;
gap_conn_params.max_conn_interval = MAX_CONN_INTERVAL;
gap_conn_params.slave_latency = SLAVE_LATENCY;
gap_conn_params.conn_sup_timeout = CONN_SUP_TIMEOUT;
err_code = sd_ble_gap_ppcp_set(&gap_conn_params);
APP_ERROR_CHECK(err_code);
}
// 初始化连接参数
static void conn_params_init(void)
{
ret_code_t err_code;
ble_conn_params_init_t conn_params_init;
memset(&conn_params_init, 0, sizeof(conn_params_init));
conn_params_init.p_conn_params = NULL;
conn_params_init.first_conn_params_update_delay = FIRST_CONN_PARAMS_UPDATE_DELAY;
conn_params_init.next_conn_params_update_delay = NEXT_CONN_PARAMS_UPDATE_DELAY;
conn_params_init.max_conn_params_update_count = MAX_CONN_PARAMS_UPDATE_COUNT;
conn_params_init.start_on_notify_cccd_handle = BLE_GATT_HANDLE_INVALID;
conn_params_init.disconnect_on_fail = true;
conn_params_init.evt_handler = NULL;
conn_params_init.error_handler = NULL;
err_code = ble_conn_params_init(&conn_params_init);
APP_ERROR_CHECK(err_code);
}
// 初始化服务
static void services_init(void)
{
ret_code_t err_code;
// 添加服务代码...
}
// 初始化广播
static void advertising_init(void)
{
ret_code_t err_code;
ble_advertising_init_t init;
memset(&init, 0, sizeof(init));
init.advdata.name_type = BLE_ADVDATA_FULL_NAME;
init.advdata.include_appearance = true;
init.advdata.flags = BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE;
init.advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids) / sizeof(m_adv_uuids[0]);
init.advdata.uuids_complete.p_uuids = m_adv_uuids;
init.config.ble_adv_fast_enabled = true;
init.config.ble_adv_fast_interval = APP_ADV_INTERVAL;
init.config.ble_adv_fast_timeout = APP_ADV_DURATION;
init.evt_handler = NULL;
err_code = ble_advertising_init(&advdata, NULL);
APP_ERROR_CHECK(err_code);
}
int main(void)
{
// 初始化日志模块
ret_code_t err_code = NRF_LOG_INIT(NULL);
APP_ERROR_CHECK(err_code);
// 初始化 BLE Stack
ble_stack_init();
// 初始化 GAP (Generic Access Profile)
gap_params_init();
// 初始化连接参数
conn_params_init();
// 初始化服务
services_init();
// 初始化广播
advertising_init();
// 开始广播
err_code = ble_advertising_start(&m_advertising, BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
// 连接设备并获取 RSSI 值
err_code = sd_ble_gap_rssi_start(m_conn_handle, 5, 0);
APP_ERROR_CHECK(err_code);
// 进入主循环
while (true)
{
// 处理 BLE 事件
nrf_ble_qwr_on_ble_evt(&m_qwr, p_ble_evt);
ble_conn_params_on_ble_evt(p_ble_evt);
ble_advertising_on_ble_evt(p_ble_evt);
ble_nus_on_ble_evt(&m_nus, p_ble_evt);
on_ble_evt(p_ble_evt);
}
}
```
在上面的示例代码中,我们使用 `sd_ble_gap_rssi_start()` 函数来启动 RSSI 读取过程。该函数的第一个参数为连接句柄,第二个参数为 RSSI 读取周期,单位为 100 毫秒。在上面的示例代码中,我们设置周期为 5,即每 500 毫秒读取一次 RSSI。
当 RSSI 值发生变化时,`ble_gap_evt_handler()` 函数将被调用,从而可以获取 RSSI 值。注意,要在应用程序初始化期间注册 `ble_gap_evt_handler()` 以处理 GAP 事件。
希望这可以回答您的问题!
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 函数来进行加密连接,从而实现了蓝牙加密功能。