uint8 config_data_table
时间: 2023-12-28 21:02:40 浏览: 22
uint8 config_data_table是一个包含8位无符号整数的数据表。通常情况下,这种数据表用于存储配置信息,例如传感器的采样频率、设备的通信协议、系统的配置参数等。
这种数据表可以用在嵌入式系统中,通过读取和更新config_data_table中的数值,可以动态地调整系统的配置,从而实现各种功能的定制化。
在编程中,uint8 config_data_table可以通过数组或者结构体的形式来定义和使用。开发人员可以通过读取和修改数组中的元素,或者结构体中的成员,来实现对系统配置信息的访问和修改。
由于uint8数据类型的范围为0-255,因此可以使用config_data_table来存储大部分的配置信息。如果有需要存储更大范围的数值,也可以选择其他数据类型来定义相应的数据表。
总之,uint8 config_data_table是一种用于存储配置信息的数据表,可以在嵌入式系统中灵活地应用,可以方便地实现系统功能的定制化和配置的动态调整。
相关问题
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读取数据。
esp32 在ulp模式下定期读取sht30的温湿度参数的完整代码
以下是 ESP32 在 ULP 模式下定期读取 SHT30 温湿度参数的完整代码:
```
#include "esp_sleep.h"
#include "driver/rtc_io.h"
#include "soc/rtc_cntl_reg.h"
#include "soc/sens_reg.h"
#include "soc/soc_ulp.h"
RTC_DATA_ATTR static struct {
uint16_t humi;
uint16_t temp;
} sht30_data;
static RTC_DATA_ATTR const uint16_t sht30_cmd = 0x2400; // SHT30读取命令
static const uint16_t sht30_crc_table[] = { //CRC校验表
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef
};
// 计算 SHT30 数据的 CRC 校验值
static uint16_t sht30_crc(uint8_t *data, int len)
{
uint16_t crc = 0xffff;
for (int i = 0; i < len; i++) {
crc = (crc << 8) ^ sht30_crc_table[(crc >> 8) ^ data[i]];
}
return crc;
}
// ULP 程序
static const ulp_insn_t ulp_prog[] = {
I_MOVI(R2, sht30_cmd),
I_WR_REG(R2, SENS_SHT3XD_ADDR, SENS_SHT3XD_CMD, 0),
I_DELAY(1000), // 等待 1000us
I_RD_REG(R2, SENS_SHT3XD_ADDR, SENS_SHT3XD_DATA_H, 0),
I_WR_REG(R3, SENS_SHT3XD_ADDR, SENS_SHT3XD_CMD, 1),
I_DELAY(1000), // 等待 1000us
I_RD_REG(R3, SENS_SHT3XD_ADDR, SENS_SHT3XD_DATA_L, 0),
I_HALT()
};
void setup()
{
rtc_gpio_init(GPIO_NUM_4); // SHT30 的 SDA 引脚连接到 GPIO4
rtc_gpio_set_direction(GPIO_NUM_4, RTC_GPIO_MODE_INPUT_OUTPUT); // 设置为输入输出模式
rtc_gpio_set_level(GPIO_NUM_4, 1); // 默认拉高
// 配置 ULP 程序
ulp_process_macros_and_load(0, ulp_prog, sizeof(ulp_prog) / sizeof(ulp_insn_t));
ulp_set_wakeup_period(0, 1000000); // 设置 ULP 睡眠时间为 1s
ulp_run(0); // 启动 ULP 程序
}
void loop()
{
esp_sleep_enable_ulp_wakeup(); // 允许 ULP 唤醒主CPU
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON); // 打开 RTC 性能域
esp_light_sleep_start(); // 进入浅度睡眠
if (sht30_data.humi != 0 && sht30_data.temp != 0) {
// 发送温湿度数据到服务器等
}
}
// 中断处理函数,当 ULP 程序执行完毕后会调用此函数
void IRAM_ATTR ulp_isr(void *arg)
{
uint8_t data[2];
data[0] = ulp_reg_read(SENS_SHT3XD_DATA_H_REG);
data[1] = ulp_reg_read(SENS_SHT3XD_DATA_L_REG);
if (sht30_crc(data, 2) == ((data[0] << 8) | data[1])) { // 验证 CRC 校验值
sht30_data.humi = ((data[0] << 8) | data[1]) * 100 / 65535;
data[0] = ulp_reg_read(SENS_SHT3XD_DATA_H_REG + 1);
data[1] = ulp_reg_read(SENS_SHT3XD_DATA_L_REG + 1);
if (sht30_crc(data, 2) == ((data[0] << 8) | data[1])) {
sht30_data.temp = ((data[0] << 8) | data[1]) * 175 / 65535 - 45;
}
}
ulp_set_wakeup_period(0, 1000000); // 设置 ULP 睡眠时间为 1s
ulp_run(0); // 启动 ULP 程序
}
// 主函数
void app_main()
{
setup();
// 注册 ULP 中断处理函数
esp_err_t ret = esp_sleep_enable_timer_wakeup(1000000); // 设置主CPU睡眠时间为 1s
ret = esp_sleep_isr_register(&ulp_isr, NULL, ESP_SLEEP_ISR_FLAG_DEFAULT);
while (1) {
loop();
}
}
```
需要注意的是,上述代码涉及到 SHT30 的读取、CRC 校验等细节,具体可以参考 SHT30 的数据手册。同时,为了防止 ULP 程序占用主CPU资源,需要在 ULP 程序执行完毕后立即进入浅度睡眠,并在 ULP 中断处理函数中重新启动 ULP 程序。