alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

ble_mesh: example: fix the structure init order to meet C++ requirements

Browse Source 
Closes https://github.com/espressif/esp-idf/issues/8110
This commit is contained in:
InfiniteYuan 2022-08-16 17:50:16 +08:00 committed by BOT
parent d5f11597e6
commit 5f11da04b0
26 changed files with 330 additions and 670 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
examples/bluetooth/esp_ble_mesh/aligenie_demo/main/aligenie_demo.c
View File

@ -73,23 +73,23 @@ static uint8_t dev_uuid[16] = {
};
static esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_ENABLED,
/* 3 transmissions with 20ms interval */
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_ENABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
/* 3 transmissions with 20ms interval */
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
uint8_t test_ids[1] = {0x00};
@ -97,15 +97,19 @@ uint8_t test_ids[1] = {0x00};
/** ESP BLE Mesh Health Server Model Context */
ESP_BLE_MESH_MODEL_PUB_DEFINE(health_pub, 2 + 11, ROLE_NODE);
static esp_ble_mesh_health_srv_t health_server = {
.health_test.id_count = 1,
.health_test.test_ids = test_ids,
.health_test = {
.id_count = 1,
.test_ids = test_ids,
},
};
#ifdef CONFIG_MESH_MODEL_GEN_ONOFF_SRV
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_pub_0, 2 + 3, ROLE_NODE);
static esp_ble_mesh_gen_onoff_srv_t onoff_server_0 = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
};
#endif
@ -116,16 +120,20 @@ static esp_ble_mesh_light_lightness_state_t lightness_state;
/* Light Lightness Server related context */
ESP_BLE_MESH_MODEL_PUB_DEFINE(lightness_pub, 2 + 5, ROLE_NODE);
static esp_ble_mesh_light_lightness_srv_t lightness_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
.state = &lightness_state,
};
/* Light Lightness Setup Server related context */
ESP_BLE_MESH_MODEL_PUB_DEFINE(lightness_setup_pub, 2 + 5, ROLE_NODE);
static esp_ble_mesh_light_lightness_setup_srv_t lightness_setup_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
.state = &lightness_state,
};
#endif
@ -137,16 +145,20 @@ static esp_ble_mesh_light_ctl_state_t ctl_state;
/* Light CTL Server related context */
ESP_BLE_MESH_MODEL_PUB_DEFINE(ctl_pub, 2 + 9, ROLE_NODE);
static esp_ble_mesh_light_ctl_srv_t ctl_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
.state = &ctl_state,
};
/* Light CTL Setup Server related context */
ESP_BLE_MESH_MODEL_PUB_DEFINE(ctl_setup_pub, 2 + 6, ROLE_NODE);
static esp_ble_mesh_light_ctl_setup_srv_t ctl_setup_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
.state = &ctl_state,
};
#endif
@ -158,16 +170,20 @@ static esp_ble_mesh_light_hsl_state_t hsl_state;
/* Light HSL Server related context */
ESP_BLE_MESH_MODEL_PUB_DEFINE(hsl_pub, 2 + 9, ROLE_NODE);
static esp_ble_mesh_light_hsl_srv_t hsl_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
.state = &hsl_state,
};
/* Light HSL Setup Server related context */
ESP_BLE_MESH_MODEL_PUB_DEFINE(hsl_setup_pub, 2 + 9, ROLE_NODE);
static esp_ble_mesh_light_hsl_setup_srv_t hsl_setup_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
.state = &hsl_state,
};
#endif
@ -214,14 +230,18 @@ static esp_ble_mesh_model_t ali_vnd_models[] = {
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_pub_1, 2 + 3, ROLE_NODE);
static esp_ble_mesh_gen_onoff_srv_t onoff_server_1 = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
},
};
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_pub_2, 2 + 3, ROLE_NODE);
static esp_ble_mesh_gen_onoff_srv_t onoff_server_2 = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
},
};
static esp_ble_mesh_model_t extend_model_0[] = {
@ -240,8 +260,8 @@ esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ALIBABA,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
/* Disable OOB security for SILabs Android app */
@ -497,7 +517,7 @@ void user_genie_event_handle(genie_event_t event, void *p_arg)
case GENIE_EVT_SDK_COLOR_ACTION: {
ESP_LOGI(TAG, "GENIE_EVT_SDK_COLOR_ACTION");
#ifdef CONFIG_MESH_MODEL_HSL_SRV
uint8_t *p_data = p_arg;
uint8_t *p_data = (uint8_t *)p_arg;
uint16_t lightness = *p_data++;
lightness += (*p_data++ << 8);
@ -1064,7 +1084,7 @@ static void example_ble_mesh_generic_server_cb(esp_ble_mesh_generic_server_cb_ev
case ESP_BLE_MESH_GENERIC_SERVER_RECV_GET_MSG_EVT:
ESP_LOGI(TAG, "ESP_BLE_MESH_GENERIC_SERVER_RECV_GET_MSG_EVT");
if (param->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_GET) {
esp_ble_mesh_gen_onoff_srv_t *srv = param->model->user_data;
esp_ble_mesh_gen_onoff_srv_t *srv = (esp_ble_mesh_gen_onoff_srv_t *)param->model->user_data;
ESP_LOGI(TAG, "onoff: 0x%02x", srv->state.onoff);
esp_ble_mesh_server_model_send_msg(param->model, &param->ctx,
ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_STATUS, sizeof(srv->state.onoff), &srv->state.onoff);
@ -1080,7 +1100,7 @@ static void example_ble_mesh_generic_server_cb(esp_ble_mesh_generic_server_cb_ev
param->value.set.onoff.trans_time, param->value.set.onoff.delay);
}
esp_ble_mesh_gen_onoff_srv_t *srv = param->model->user_data;
esp_ble_mesh_gen_onoff_srv_t *srv = (esp_ble_mesh_gen_onoff_srv_t *)param->model->user_data;
if (param->value.set.onoff.op_en == false) {
srv->state.onoff = param->value.set.onoff.onoff;
} else {
@ -1287,7 +1307,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
ESP_ERROR_CHECK(esp_ble_mesh_node_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
ESP_ERROR_CHECK(esp_ble_mesh_node_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT)));
if (esp_ble_mesh_node_is_provisioned()) {
ESP_LOGW(TAG, "node already provisioned");

9
examples/bluetooth/esp_ble_mesh/aligenie_demo/main/include/board.h
View File

@ -9,14 +9,13 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#include "driver/gpio.h"
#include "lightbulb.h"
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include "driver/gpio.h"
#include "lightbulb.h"
#define LED_ON 1
#define LED_OFF 0
@ -81,4 +80,4 @@ uint8_t *mac_str2hex(const char *mac_str, uint8_t *mac_hex);
}
#endif /**< __cplusplus */
#endif
#endif /* _BOARD_H_ */

24
examples/bluetooth/esp_ble_mesh/ble_mesh_fast_provision/fast_prov_client/main/main.c
View File

@ -41,22 +41,22 @@ static const esp_ble_mesh_client_op_pair_t fast_prov_cli_op_pair[] = {
};
static esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with a 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_DISABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_ENABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with a 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
esp_ble_mesh_client_t config_client;
esp_ble_mesh_client_t gen_onoff_client;
@ -89,8 +89,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t comp = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
static esp_ble_mesh_prov_t prov = {
@ -211,10 +211,10 @@ static void example_recv_unprov_adv_pkt(uint8_t dev_uuid[16], uint8_t addr[BLE_M
add:
memcpy(add_dev.addr, addr, 6);
add_dev.addr_type = (uint8_t)addr_type;
add_dev.addr_type = (esp_ble_mesh_addr_type_t)addr_type;
memcpy(add_dev.uuid, dev_uuid, 16);
add_dev.oob_info = oob_info;
add_dev.bearer = (uint8_t)bearer;
add_dev.bearer = (esp_ble_mesh_prov_bearer_t)bearer;
flag = ADD_DEV_RM_AFTER_PROV_FLAG | ADD_DEV_START_PROV_NOW_FLAG | ADD_DEV_FLUSHABLE_DEV_FLAG;
err = esp_ble_mesh_provisioner_add_unprov_dev(&add_dev, flag);
if (err != ESP_OK) {
@ -551,7 +551,7 @@ static esp_err_t ble_mesh_init(void)
return ESP_FAIL;
}
err = esp_ble_mesh_provisioner_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_provisioner_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "%s: Failed to enable provisioning", __func__);
return ESP_FAIL;

8
examples/bluetooth/esp_ble_mesh/ble_mesh_fast_provision/fast_prov_server/main/board.h
View File

@ -8,6 +8,10 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include "sdkconfig.h"
#include "driver/gpio.h"
#include "esp_ble_mesh_defs.h"
@ -45,4 +49,8 @@ void board_led_operation(uint8_t pin, uint8_t onoff);
esp_err_t board_init(void);
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif

34
examples/bluetooth/esp_ble_mesh/ble_mesh_fast_provision/fast_prov_server/main/main.c
View File

@ -48,22 +48,22 @@ esp_ble_mesh_client_t config_client;
/* Configuration Server Model user_data */
esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_ENABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_DISABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
/* Fast Prov Client Model user_data */
@ -77,6 +77,7 @@ example_fast_prov_server_t fast_prov_server = {
.primary_role = false,
.max_node_num = 6,
.prov_node_cnt = 0x0,
.app_idx = ESP_BLE_MESH_KEY_UNUSED,
.unicast_min = ESP_BLE_MESH_ADDR_UNASSIGNED,
.unicast_max = ESP_BLE_MESH_ADDR_UNASSIGNED,
.unicast_cur = ESP_BLE_MESH_ADDR_UNASSIGNED,
@ -84,7 +85,6 @@ example_fast_prov_server_t fast_prov_server = {
.flags = 0x0,
.iv_index = 0x0,
.net_idx = ESP_BLE_MESH_KEY_UNUSED,
.app_idx = ESP_BLE_MESH_KEY_UNUSED,
.group_addr = ESP_BLE_MESH_ADDR_UNASSIGNED,
.prim_prov_addr = ESP_BLE_MESH_ADDR_UNASSIGNED,
.match_len = 0x0,
@ -94,8 +94,10 @@ example_fast_prov_server_t fast_prov_server = {
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_pub, 2 + 3, ROLE_FAST_PROV);
static esp_ble_mesh_gen_onoff_srv_t onoff_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
}
};
static esp_ble_mesh_model_op_t fast_prov_srv_op[] = {
@ -134,8 +136,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t comp = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
static esp_ble_mesh_prov_t prov = {
@ -309,9 +311,9 @@ static void example_recv_unprov_adv_pkt(uint8_t dev_uuid[16], uint8_t addr[BLE_M
}
}
add_dev.addr_type = (uint8_t)addr_type;
add_dev.addr_type = (esp_ble_mesh_addr_type_t)addr_type;
add_dev.oob_info = oob_info;
add_dev.bearer = (uint8_t)bearer;
add_dev.bearer = (esp_ble_mesh_prov_bearer_t)bearer;
memcpy(add_dev.uuid, dev_uuid, 16);
memcpy(add_dev.addr, addr, BLE_MESH_ADDR_LEN);
flag = ADD_DEV_RM_AFTER_PROV_FLAG | ADD_DEV_START_PROV_NOW_FLAG | ADD_DEV_FLUSHABLE_DEV_FLAG;
@ -452,8 +454,8 @@ static void example_ble_mesh_custom_model_cb(esp_ble_mesh_model_cb_event_t event
case ESP_BLE_MESH_VND_MODEL_OP_FAST_PROV_NODE_GROUP_DELETE: {
ESP_LOGI(TAG, "%s: Fast prov server receives msg, opcode 0x%04" PRIx32, __func__, opcode);
struct net_buf_simple buf = {
.len = param->model_operation.length,
.data = param->model_operation.msg,
.len = param->model_operation.length,
};
err = example_fast_prov_server_recv_msg(param->model_operation.model,
param->model_operation.ctx, &buf);
@ -727,7 +729,7 @@ static esp_err_t ble_mesh_init(void)
k_delayed_work_init(&send_self_prov_node_addr_timer, example_send_self_prov_node_addr);
err = esp_ble_mesh_node_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_node_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "%s: Failed to enable node provisioning", __func__);
return err;

10
examples/bluetooth/esp_ble_mesh/ble_mesh_node/onoff_client/main/board.h
View File

@ -10,6 +10,10 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include "driver/gpio.h"
#include "esp_ble_mesh_defs.h"
@ -45,4 +49,8 @@ void board_led_operation(uint8_t pin, uint8_t onoff);
void board_init(void);
#endif
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BOARD_H_ */

24
examples/bluetooth/esp_ble_mesh/ble_mesh_node/onoff_client/main/main.c
View File

@ -48,22 +48,22 @@ static const char * NVS_KEY = "onoff_client";
static esp_ble_mesh_client_t onoff_client;
static esp_ble_mesh_cfg_srv_t config_server = {
.relay = ESP_BLE_MESH_RELAY_ENABLED,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_DISABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_ENABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_cli_pub, 2 + 1, ROLE_NODE);
@ -79,8 +79,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
/* Disable OOB security for SILabs Android app */
@ -89,8 +89,8 @@ static esp_ble_mesh_prov_t provision = {
#if 0
.output_size = 4,
.output_actions = ESP_BLE_MESH_DISPLAY_NUMBER,
.input_actions = ESP_BLE_MESH_PUSH,
.input_size = 4,
.input_actions = ESP_BLE_MESH_PUSH,
#else
.output_size = 0,
.output_actions = 0,
@ -278,7 +278,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
err = esp_ble_mesh_node_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_node_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enable mesh node (err %d)", err);
return err;

10
examples/bluetooth/esp_ble_mesh/ble_mesh_node/onoff_server/main/board.h
View File

@ -10,6 +10,10 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include "driver/gpio.h"
#if defined(CONFIG_BLE_MESH_ESP_WROOM_32)
@ -44,4 +48,8 @@ void board_led_operation(uint8_t pin, uint8_t onoff);
void board_init(void);
#endif
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BOARD_H_ */

46
examples/bluetooth/esp_ble_mesh/ble_mesh_node/onoff_server/main/main.c
View File

@ -34,40 +34,46 @@ extern struct _led_state led_state[3];
static uint8_t dev_uuid[16] = { 0xdd, 0xdd };
static esp_ble_mesh_cfg_srv_t config_server = {
.relay = ESP_BLE_MESH_RELAY_ENABLED,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_DISABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_ENABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_pub_0, 2 + 3, ROLE_NODE);
static esp_ble_mesh_gen_onoff_srv_t onoff_server_0 = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
},
};
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_pub_1, 2 + 3, ROLE_NODE);
static esp_ble_mesh_gen_onoff_srv_t onoff_server_1 = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
},
};
ESP_BLE_MESH_MODEL_PUB_DEFINE(onoff_pub_2, 2 + 3, ROLE_NODE);
static esp_ble_mesh_gen_onoff_srv_t onoff_server_2 = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_AUTO_RSP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
},
};
static esp_ble_mesh_model_t root_models[] = {
@ -91,8 +97,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
/* Disable OOB security for SILabs Android app */
@ -101,8 +107,8 @@ static esp_ble_mesh_prov_t provision = {
#if 0
.output_size = 4,
.output_actions = ESP_BLE_MESH_DISPLAY_NUMBER,
.input_actions = ESP_BLE_MESH_PUSH,
.input_size = 4,
.input_actions = ESP_BLE_MESH_PUSH,
#else
.output_size = 0,
.output_actions = 0,
@ -146,7 +152,7 @@ static void example_handle_gen_onoff_msg(esp_ble_mesh_model_t *model,
esp_ble_mesh_msg_ctx_t *ctx,
esp_ble_mesh_server_recv_gen_onoff_set_t *set)
{
esp_ble_mesh_gen_onoff_srv_t *srv = model->user_data;
esp_ble_mesh_gen_onoff_srv_t *srv = (esp_ble_mesh_gen_onoff_srv_t *)model->user_data;
switch (ctx->recv_op) {
case ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_GET:
@ -227,7 +233,7 @@ static void example_ble_mesh_generic_server_cb(esp_ble_mesh_generic_server_cb_ev
case ESP_BLE_MESH_GENERIC_SERVER_RECV_GET_MSG_EVT:
ESP_LOGI(TAG, "ESP_BLE_MESH_GENERIC_SERVER_RECV_GET_MSG_EVT");
if (param->ctx.recv_op == ESP_BLE_MESH_MODEL_OP_GEN_ONOFF_GET) {
srv = param->model->user_data;
srv = (esp_ble_mesh_gen_onoff_srv_t *)param->model->user_data;
ESP_LOGI(TAG, "onoff 0x%02x", srv->state.onoff);
example_handle_gen_onoff_msg(param->model, &param->ctx, NULL);
}
@ -298,7 +304,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
err = esp_ble_mesh_node_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_node_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enable mesh node (err %d)", err);
return err;

34
examples/bluetooth/esp_ble_mesh/ble_mesh_provisioner/main/main.c
View File

@ -51,13 +51,7 @@ typedef struct {
uint8_t onoff;
} esp_ble_mesh_node_info_t;
static esp_ble_mesh_node_info_t nodes[CONFIG_BLE_MESH_MAX_PROV_NODES] = {
[0 ... (CONFIG_BLE_MESH_MAX_PROV_NODES - 1)] = {
.unicast = ESP_BLE_MESH_ADDR_UNASSIGNED,
.elem_num = 0,
.onoff = LED_OFF,
}
};
static esp_ble_mesh_node_info_t nodes[CONFIG_BLE_MESH_MAX_PROV_NODES] = {0};
static struct esp_ble_mesh_key {
uint16_t net_idx;
@ -69,22 +63,22 @@ static esp_ble_mesh_client_t config_client;
static esp_ble_mesh_client_t onoff_client;
static esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_DISABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_ENABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
static esp_ble_mesh_model_t root_models[] = {
@ -99,8 +93,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
static esp_ble_mesh_prov_t provision = {
@ -259,14 +253,14 @@ static void recv_unprov_adv_pkt(uint8_t dev_uuid[16], uint8_t addr[BD_ADDR_LEN],
ESP_LOGI(TAG, "oob info: %d, bearer: %s", oob_info, (bearer & ESP_BLE_MESH_PROV_ADV) ? "PB-ADV" : "PB-GATT");
memcpy(add_dev.addr, addr, BD_ADDR_LEN);
add_dev.addr_type = (uint8_t)addr_type;
add_dev.addr_type = (esp_ble_mesh_addr_type_t)addr_type;
memcpy(add_dev.uuid, dev_uuid, 16);
add_dev.oob_info = oob_info;
add_dev.bearer = (uint8_t)bearer;
add_dev.bearer = (esp_ble_mesh_prov_bearer_t)bearer;
/* Note: If unprovisioned device adv packets have not been received, we should not add
device with ADD_DEV_START_PROV_NOW_FLAG set. */
err = esp_ble_mesh_provisioner_add_unprov_dev(&add_dev,
ADD_DEV_RM_AFTER_PROV_FLAG | ADD_DEV_START_PROV_NOW_FLAG | ADD_DEV_FLUSHABLE_DEV_FLAG);
(esp_ble_mesh_dev_add_flag_t)(ADD_DEV_RM_AFTER_PROV_FLAG | ADD_DEV_START_PROV_NOW_FLAG | ADD_DEV_FLUSHABLE_DEV_FLAG));
if (err) {
ESP_LOGE(TAG, "%s: Add unprovisioned device into queue failed", __func__);
}
@ -608,7 +602,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
err = esp_ble_mesh_provisioner_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_provisioner_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enable mesh provisioner (err %d)", err);
return err;

8
examples/bluetooth/esp_ble_mesh/ble_mesh_sensor_model/sensor_client/main/board.h
View File

@ -10,6 +10,14 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
void board_init(void);
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BOARD_H_ */

14
examples/bluetooth/esp_ble_mesh/ble_mesh_sensor_model/sensor_client/main/main.c
View File

@ -54,7 +54,10 @@ static struct esp_ble_mesh_key {
} prov_key;
static esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_DISABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_DISABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
@ -62,9 +65,6 @@ static esp_ble_mesh_cfg_srv_t config_server = {
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
static esp_ble_mesh_client_t config_client;
@ -82,8 +82,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
static esp_ble_mesh_prov_t provision = {
@ -164,10 +164,10 @@ static void recv_unprov_adv_pkt(uint8_t dev_uuid[ESP_BLE_MESH_OCTET16_LEN], uint
ESP_LOGI(TAG, "oob info 0x%04x, bearer %s", oob_info, (bearer & ESP_BLE_MESH_PROV_ADV) ? "PB-ADV" : "PB-GATT");
memcpy(add_dev.addr, addr, BD_ADDR_LEN);
add_dev.addr_type = (uint8_t)addr_type;
add_dev.addr_type = (esp_ble_mesh_addr_type_t)addr_type;
memcpy(add_dev.uuid, dev_uuid, ESP_BLE_MESH_OCTET16_LEN);
add_dev.oob_info = oob_info;
add_dev.bearer = (uint8_t)bearer;
add_dev.bearer = (esp_ble_mesh_prov_bearer_t)bearer;
/* Note: If unprovisioned device adv packets have not been received, we should not add
device with ADD_DEV_START_PROV_NOW_FLAG set. */
err = esp_ble_mesh_provisioner_add_unprov_dev(&add_dev,
@ -648,7 +648,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
err = esp_ble_mesh_provisioner_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_provisioner_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enable mesh provisioner");
return err;

10
examples/bluetooth/esp_ble_mesh/ble_mesh_sensor_model/sensor_server/main/board.h
View File

@ -10,6 +10,10 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include "driver/gpio.h"
#if defined(CONFIG_BLE_MESH_ESP_WROOM_32)
@ -44,4 +48,8 @@ void board_led_operation(uint8_t pin, uint8_t onoff);
void board_init(void);
#endif
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BOARD_H_ */

78
examples/bluetooth/esp_ble_mesh/ble_mesh_sensor_model/sensor_server/main/main.c
View File

@ -49,22 +49,22 @@ static int8_t outdoor_temp = 60; /* Outdoor temperature is 30 Degrees Celsius
static uint8_t dev_uuid[ESP_BLE_MESH_OCTET16_LEN] = { 0x32, 0x10 };
static esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_ENABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_ENABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
NET_BUF_SIMPLE_DEFINE_STATIC(sensor_data_0, 1);
@ -89,41 +89,53 @@ static esp_ble_mesh_sensor_state_t sensor_states[2] = {
* Sensor Descriptor state represents the attributes describing the sensor
* data. This state does not change throughout the lifetime of an element.
*/
.descriptor.positive_tolerance = SENSOR_POSITIVE_TOLERANCE,
.descriptor.negative_tolerance = SENSOR_NEGATIVE_TOLERANCE,
.descriptor.sampling_function = SENSOR_SAMPLE_FUNCTION,
.descriptor.measure_period = SENSOR_MEASURE_PERIOD,
.descriptor.update_interval = SENSOR_UPDATE_INTERVAL,
.sensor_data.format = ESP_BLE_MESH_SENSOR_DATA_FORMAT_A,
.sensor_data.length = 0, /* 0 represents the length is 1 */
.sensor_data.raw_value = &sensor_data_0,
.descriptor = {
.positive_tolerance = SENSOR_POSITIVE_TOLERANCE,
.negative_tolerance = SENSOR_NEGATIVE_TOLERANCE,
.sampling_function = SENSOR_SAMPLE_FUNCTION,
.measure_period = SENSOR_MEASURE_PERIOD,
.update_interval = SENSOR_UPDATE_INTERVAL,
},
.sensor_data = {
.format = ESP_BLE_MESH_SENSOR_DATA_FORMAT_A,
.length = 0, /* 0 represents the length is 1 */
.raw_value = &sensor_data_0,
},
},
[1] = {
.sensor_property_id = SENSOR_PROPERTY_ID_1,
.descriptor.positive_tolerance = SENSOR_POSITIVE_TOLERANCE,
.descriptor.negative_tolerance = SENSOR_NEGATIVE_TOLERANCE,
.descriptor.sampling_function = SENSOR_SAMPLE_FUNCTION,
.descriptor.measure_period = SENSOR_MEASURE_PERIOD,
.descriptor.update_interval = SENSOR_UPDATE_INTERVAL,
.sensor_data.format = ESP_BLE_MESH_SENSOR_DATA_FORMAT_A,
.sensor_data.length = 0, /* 0 represents the length is 1 */
.sensor_data.raw_value = &sensor_data_1,
.descriptor = {
.positive_tolerance = SENSOR_POSITIVE_TOLERANCE,
.negative_tolerance = SENSOR_NEGATIVE_TOLERANCE,
.sampling_function = SENSOR_SAMPLE_FUNCTION,
.measure_period = SENSOR_MEASURE_PERIOD,
.update_interval = SENSOR_UPDATE_INTERVAL,
},
.sensor_data = {
.format = ESP_BLE_MESH_SENSOR_DATA_FORMAT_A,
.length = 0, /* 0 represents the length is 1 */
.raw_value = &sensor_data_1,
},
},
};
/* 20 octets is large enough to hold two Sensor Descriptor state values. */
ESP_BLE_MESH_MODEL_PUB_DEFINE(sensor_pub, 20, ROLE_NODE);
static esp_ble_mesh_sensor_srv_t sensor_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
},
.state_count = ARRAY_SIZE(sensor_states),
.states = sensor_states,
};
ESP_BLE_MESH_MODEL_PUB_DEFINE(sensor_setup_pub, 20, ROLE_NODE);
static esp_ble_mesh_sensor_setup_srv_t sensor_setup_server = {
.rsp_ctrl.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.rsp_ctrl = {
.get_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
.set_auto_rsp = ESP_BLE_MESH_SERVER_RSP_BY_APP,
},
.state_count = ARRAY_SIZE(sensor_states),
.states = sensor_states,
};
@ -140,8 +152,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
static esp_ble_mesh_prov_t provision = {
@ -244,7 +256,7 @@ static void example_ble_mesh_send_sensor_descriptor_status(esp_ble_mesh_sensor_s
esp_err_t err;
int i;
status = calloc(1, ARRAY_SIZE(sensor_states) * ESP_BLE_MESH_SENSOR_DESCRIPTOR_LEN);
status = (uint8_t *)calloc(1, ARRAY_SIZE(sensor_states) * ESP_BLE_MESH_SENSOR_DESCRIPTOR_LEN);
if (!status) {
ESP_LOGE(TAG, "No memory for sensor descriptor status!");
return;
@ -427,7 +439,7 @@ static void example_ble_mesh_send_sensor_status(esp_ble_mesh_sensor_server_cb_pa
}
}
status = calloc(1, buf_size);
status = (uint8_t *)calloc(1, buf_size);
if (!status) {
ESP_LOGE(TAG, "No memory for sensor status!");
return;
@ -485,7 +497,7 @@ static void example_ble_mesh_send_sensor_column_status(esp_ble_mesh_sensor_serve
length = ESP_BLE_MESH_SENSOR_PROPERTY_ID_LEN +param->value.get.sensor_column.raw_value_x->len;
status = calloc(1, length);
status = (uint8_t *)calloc(1, length);
if (!status) {
ESP_LOGE(TAG, "No memory for sensor column status!");
return;
@ -599,7 +611,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
err = esp_ble_mesh_node_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_node_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enable mesh node");
return err;

8
examples/bluetooth/esp_ble_mesh/ble_mesh_vendor_model/vendor_client/main/board.h
View File

@ -10,6 +10,14 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
void board_init(void);
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BOARD_H_ */

14
examples/bluetooth/esp_ble_mesh/ble_mesh_vendor_model/vendor_client/main/main.c
View File

@ -71,7 +71,10 @@ static struct esp_ble_mesh_key {
} prov_key;
static esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_DISABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_DISABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
@ -79,9 +82,6 @@ static esp_ble_mesh_cfg_srv_t config_server = {
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
static esp_ble_mesh_client_t config_client;
@ -116,8 +116,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
static esp_ble_mesh_prov_t provision = {
@ -219,10 +219,10 @@ static void recv_unprov_adv_pkt(uint8_t dev_uuid[ESP_BLE_MESH_OCTET16_LEN], uint
ESP_LOGI(TAG, "oob info 0x%04x, bearer %s", oob_info, (bearer & ESP_BLE_MESH_PROV_ADV) ? "PB-ADV" : "PB-GATT");
memcpy(add_dev.addr, addr, BD_ADDR_LEN);
add_dev.addr_type = (uint8_t)addr_type;
add_dev.addr_type = (esp_ble_mesh_addr_type_t)addr_type;
memcpy(add_dev.uuid, dev_uuid, ESP_BLE_MESH_OCTET16_LEN);
add_dev.oob_info = oob_info;
add_dev.bearer = (uint8_t)bearer;
add_dev.bearer = (esp_ble_mesh_prov_bearer_t)bearer;
/* Note: If unprovisioned device adv packets have not been received, we should not add
device with ADD_DEV_START_PROV_NOW_FLAG set. */
err = esp_ble_mesh_provisioner_add_unprov_dev(&add_dev,
@ -542,7 +542,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
err = esp_ble_mesh_provisioner_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_provisioner_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enable mesh provisioner");
return err;

10
examples/bluetooth/esp_ble_mesh/ble_mesh_vendor_model/vendor_server/main/board.h
View File

@ -10,6 +10,10 @@
#ifndef _BOARD_H_
#define _BOARD_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include "driver/gpio.h"
#if defined(CONFIG_BLE_MESH_ESP_WROOM_32)
@ -44,4 +48,8 @@ void board_led_operation(uint8_t pin, uint8_t onoff);
void board_init(void);
#endif
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BOARD_H_ */

22
examples/bluetooth/esp_ble_mesh/ble_mesh_vendor_model/vendor_server/main/main.c
View File

@ -38,22 +38,22 @@
static uint8_t dev_uuid[ESP_BLE_MESH_OCTET16_LEN] = { 0x32, 0x10 };
static esp_ble_mesh_cfg_srv_t config_server = {
.relay = ESP_BLE_MESH_RELAY_ENABLED,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_DISABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_ENABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
static esp_ble_mesh_model_t root_models[] = {
@ -76,8 +76,8 @@ static esp_ble_mesh_elem_t elements[] = {
static esp_ble_mesh_comp_t composition = {
.cid = CID_ESP,
.elements = elements,
.element_count = ARRAY_SIZE(elements),
.elements = elements,
};
static esp_ble_mesh_prov_t provision = {
@ -193,7 +193,7 @@ static esp_err_t ble_mesh_init(void)
return err;
}
err = esp_ble_mesh_node_prov_enable(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT);
err = esp_ble_mesh_node_prov_enable((esp_ble_mesh_prov_bearer_t)(ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT));
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to enable mesh node");
return err;

24
examples/bluetooth/esp_ble_mesh/ble_mesh_wifi_coexist/main/main.c
View File

@ -61,22 +61,22 @@ esp_ble_mesh_client_t config_client;
/* Configuration Server Model user_data */
esp_ble_mesh_cfg_srv_t config_server = {
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay = ESP_BLE_MESH_RELAY_ENABLED,
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.beacon = ESP_BLE_MESH_BEACON_DISABLED,
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_GATT_PROXY_SERVER)
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_ENABLED,
#else
.gatt_proxy = ESP_BLE_MESH_GATT_PROXY_NOT_SUPPORTED,
#endif
#if defined(CONFIG_BLE_MESH_FRIEND)
.friend_state = ESP_BLE_MESH_FRIEND_ENABLED,
#else
.friend_state = ESP_BLE_MESH_FRIEND_NOT_SUPPORTED,
#endif
.default_ttl = 7,
/* 3 transmissions with 20ms interval */
.net_transmit = ESP_BLE_MESH_TRANSMIT(2, 20),
.relay_retransmit = ESP_BLE_MESH_TRANSMIT(2, 20),
};
/* Fast Prov Client Model user_data */
@ -90,6 +90,7 @@ example_fast_prov_server_t fast_prov_server = {
.primary_role = false,
.max_node_num = 6,
.prov_node_cnt = 0x0,
.app_idx = ESP_BLE_MESH_KEY_UNUSED,
.unicast_min = ESP_BLE_MESH_ADDR_UNASSIGNED,
.unicast_max = ESP_BLE_MESH_ADDR_UNASSIGNED,
.unicast_cur = ESP_BLE_MESH_ADDR_UNASSIGNED,
@ -97,7 +98,6 @@ example_fast_prov_server_t fast_prov_server = {
.flags = 0x0,
.iv_index = 0x0,
.net_idx = ESP_BLE_MESH_KEY_UNUSED,
.app_idx = ESP_BLE_MESH_KEY_UNUSED,
.group_addr = ESP_BLE_MESH_ADDR_UNASSIGNED,
.prim_prov_addr = ESP_BLE_MESH_ADDR_UNASSIGNED,
.match_len = 0x0,
@ -321,9 +321,9 @@ static void example_recv_unprov_adv_pkt(uint8_t dev_uuid[16], uint8_t addr[BLE_M
}
}
add_dev.addr_type = (uint8_t)addr_type;
add_dev.addr_type = (esp_ble_mesh_addr_type_t)addr_type;
add_dev.oob_info = oob_info;
add_dev.bearer = (uint8_t)bearer;
add_dev.bearer = (esp_ble_mesh_prov_bearer_t)bearer;
memcpy(add_dev.uuid, dev_uuid, 16);
memcpy(add_dev.addr, addr, BLE_MESH_ADDR_LEN);
flag = ADD_DEV_RM_AFTER_PROV_FLAG | ADD_DEV_START_PROV_NOW_FLAG | ADD_DEV_FLUSHABLE_DEV_FLAG;
@ -464,8 +464,8 @@ static void example_ble_mesh_custom_model_cb(esp_ble_mesh_model_cb_event_t event
case ESP_BLE_MESH_VND_MODEL_OP_FAST_PROV_NODE_GROUP_DELETE: {
ESP_LOGI(TAG, "%s: Fast prov server receives msg, opcode 0x%04" PRIx32, __func__, opcode);
struct net_buf_simple buf = {
.len = param->model_operation.length,
.data = param->model_operation.msg,
.len = param->model_operation.length,
};
err = example_fast_prov_server_recv_msg(param->model_operation.model,
param->model_operation.ctx, &buf);

8
examples/bluetooth/esp_ble_mesh/common_components/example_init/ble_mesh_example_init.h
View File

@ -7,10 +7,18 @@
#ifndef _BLE_MESH_EXAMPLE_INIT_H_
#define _BLE_MESH_EXAMPLE_INIT_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include "esp_err.h"
void ble_mesh_get_dev_uuid(uint8_t *dev_uuid);
esp_err_t bluetooth_init(void);
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BLE_MESH_EXAMPLE_INIT_H_ */

8
examples/bluetooth/esp_ble_mesh/common_components/example_nvs/ble_mesh_example_nvs.h
View File

@ -7,6 +7,10 @@
#ifndef _BLE_MESH_EXAMPLE_NVS_H_
#define _BLE_MESH_EXAMPLE_NVS_H_
#ifdef __cplusplus
extern "C" {
#endif /**< __cplusplus */
#include <stdint.h>
#include "esp_err.h"
#include "nvs_flash.h"
@ -21,4 +25,8 @@ esp_err_t ble_mesh_nvs_restore(nvs_handle_t handle, const char *key, void *data,
esp_err_t ble_mesh_nvs_erase(nvs_handle_t handle, const char *key);
#ifdef __cplusplus
}
#endif /**< __cplusplus */
#endif /* _BLE_MESH_EXAMPLE_NVS_H_ */

8
examples/bluetooth/esp_ble_mesh/common_components/fast_provisioning/ble_mesh_fast_prov_client_model.h
View File

@ -7,6 +7,10 @@
#ifndef _BLE_MESH_FAST_PROV_CLIENT_MODEL_H_
#define _BLE_MESH_FAST_PROV_CLIENT_MODEL_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "esp_ble_mesh_defs.h"
enum {
@ -25,4 +29,8 @@ esp_err_t example_fast_prov_client_recv_status(esp_ble_mesh_model_t *model,
esp_ble_mesh_msg_ctx_t *ctx,
uint16_t len, const uint8_t *data);
#ifdef __cplusplus
}
#endif
#endif /* _BLE_MESH_FAST_PROV_CLIENT_MODEL_H_ */

8
examples/bluetooth/esp_ble_mesh/common_components/fast_provisioning/ble_mesh_fast_prov_common.h
View File

@ -7,6 +7,10 @@
#ifndef _BLE_MESH_FAST_PROV_COMMON_H_
#define _BLE_MESH_FAST_PROV_COMMON_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "esp_ble_mesh_defs.h"
#include "esp_ble_mesh_config_model_api.h"
@ -109,4 +113,8 @@ typedef struct {
uint8_t status_act; /* Indicate the result of action */
} example_fast_prov_net_key_status_t;
#ifdef __cplusplus
}
#endif
#endif /* _BLE_MESH_FAST_PROV_COMMON_H_ */

8
examples/bluetooth/esp_ble_mesh/common_components/fast_provisioning/ble_mesh_fast_prov_operation.h
View File

@ -7,6 +7,10 @@
#ifndef _BLE_MESH_FAST_PROV_OPERATION_H_
#define _BLE_MESH_FAST_PROV_OPERATION_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "ble_mesh_fast_prov_common.h"
esp_err_t example_store_node_info(const uint8_t uuid[16], uint16_t node_addr,
@ -58,4 +62,8 @@ esp_err_t example_send_fast_prov_status_msg(esp_ble_mesh_model_t *model,
esp_ble_mesh_msg_ctx_t *ctx,
uint32_t opcode, struct net_buf_simple *msg);
#ifdef __cplusplus
}
#endif
#endif /* _BLE_MESH_FAST_PROV_OPERATION_H_ */

8
examples/bluetooth/esp_ble_mesh/common_components/fast_provisioning/ble_mesh_fast_prov_server_model.h
View File

@ -7,6 +7,10 @@
#ifndef _BLE_MESH_FAST_PROV_SERVER_MODEL_H_
#define _BLE_MESH_FAST_PROV_SERVER_MODEL_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "ble_mesh_fast_prov_common.h"
#define DISABLE_FAST_PROV_TIMEOUT K_SECONDS(10)
@ -91,4 +95,8 @@ esp_err_t example_handle_fast_prov_status_send_comp_evt(int err_code, uint32_t o
esp_err_t example_fast_prov_server_init(esp_ble_mesh_model_t *model);
#ifdef __cplusplus
}
#endif
#endif /* _BLE_MESH_FAST_PROV_SERVER_MODEL_H_ */

477
examples/bluetooth/esp_ble_mesh/common_components/light_driver/iot_led.c
View File

@ -1,477 +0,0 @@
/*
* SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <math.h>
#include "soc/ledc_reg.h"
#include "soc/timer_group_struct.h"
#include "soc/ledc_struct.h"
#include "driver/gptimer.h"
#include "driver/ledc.h"
#include "esp_attr.h"
#include "iot_led.h"
#include "esp_log.h"
#define LEDC_FADE_MARGIN (10)
#define LEDC_VALUE_TO_DUTY(value) (value * ((1 << LEDC_TIMER_13_BIT) - 1) / UINT16_MAX)
#define LEDC_DUTY_TO_VALUE(value) (value * UINT16_MAX / ((1 << LEDC_TIMER_13_BIT) - 1) )
#define LEDC_FIXED_Q (8)
#define FLOATINT_2_FIXED(X, Q) ((int)((X)*(0x1U << Q)))
#define FIXED_2_FLOATING(X, Q) ((int)((X)/(0x1U << Q)))
#define GET_FIXED_INTEGER_PART(X, Q) (X >> Q)
#define GET_FIXED_DECIMAL_PART(X, Q) (X & ((0x1U << Q) - 1))
#define GPTIMER_RESOLUTION_HZ 1000000 // 1MHz, 1 tick=1us
typedef struct {
int cur;
int final;
int step;
int cycle;
size_t num;
} ledc_fade_data_t;
typedef struct {
ledc_fade_data_t fade_data[LEDC_CHANNEL_MAX];
ledc_mode_t speed_mode;
ledc_timer_t timer_num;
gptimer_handle_t gptimer;
} iot_light_t;
static const char *TAG = "iot_light";
static DRAM_ATTR iot_light_t *g_light_config = NULL;
static DRAM_ATTR uint16_t *g_gamma_table = NULL;
static DRAM_ATTR bool g_hw_timer_started = false;
static bool fade_timercb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_ctx);
static void iot_timer_start(gptimer_handle_t gptimer)
{
gptimer_alarm_config_t alarm_config = {
.reload_count = 0,
.alarm_count = DUTY_SET_CYCLE / 1000 * GPTIMER_RESOLUTION_HZ,
.flags.auto_reload_on_alarm = true,
};
gptimer_set_alarm_action(gptimer, &alarm_config);
gptimer_start(gptimer);
g_hw_timer_started = true;
}
static IRAM_ATTR void iot_timer_stop(gptimer_handle_t gptimer)
{
gptimer_stop(gptimer);
g_hw_timer_started = false;
}
static IRAM_ATTR esp_err_t iot_ledc_duty_config(ledc_mode_t speed_mode, ledc_channel_t channel, int hpoint_val, int duty_val,
uint32_t duty_direction, uint32_t duty_num, uint32_t duty_cycle, uint32_t duty_scale)
{
if (hpoint_val >= 0) {
#if CONFIG_IDF_TARGET_ESP32C3
LEDC.channel_group[speed_mode].channel[channel].hpoint.hpoint = hpoint_val & LEDC_HPOINT_LSCH1_V;
#elif CONFIG_IDF_TARGET_ESP32
LEDC.channel_group[speed_mode].channel[channel].hpoint.hpoint = hpoint_val & LEDC_HPOINT_HSCH1_V;
#endif
}
if (duty_val >= 0) {
LEDC.channel_group[speed_mode].channel[channel].duty.duty = duty_val;
}
#if CONFIG_IDF_TARGET_ESP32C3
LEDC.channel_group[speed_mode].channel[channel].conf1.val = ((duty_direction & LEDC_DUTY_INC_LSCH0_V) << LEDC_DUTY_INC_LSCH0_S) |
((duty_num & LEDC_DUTY_NUM_LSCH0_V) << LEDC_DUTY_NUM_LSCH0_S) |
((duty_cycle & LEDC_DUTY_CYCLE_LSCH0_V) << LEDC_DUTY_CYCLE_LSCH0_S) |
((duty_scale & LEDC_DUTY_SCALE_LSCH0_V) << LEDC_DUTY_SCALE_LSCH0_S);
#elif CONFIG_IDF_TARGET_ESP32
LEDC.channel_group[speed_mode].channel[channel].conf1.val = ((duty_direction & LEDC_DUTY_INC_HSCH0_V) << LEDC_DUTY_INC_HSCH0_S) |
((duty_num & LEDC_DUTY_NUM_HSCH0_V) << LEDC_DUTY_NUM_HSCH0_S) |
((duty_cycle & LEDC_DUTY_CYCLE_HSCH0_V) << LEDC_DUTY_CYCLE_HSCH0_S) |
((duty_scale & LEDC_DUTY_SCALE_HSCH0_V) << LEDC_DUTY_SCALE_HSCH0_S);
#endif
LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 1;
LEDC.channel_group[speed_mode].channel[channel].conf1.duty_start = 1;
if (speed_mode == LEDC_LOW_SPEED_MODE) {
LEDC.channel_group[speed_mode].channel[channel].conf0.low_speed_update = 1;
}
return ESP_OK;
}
static IRAM_ATTR esp_err_t _iot_set_fade_with_step(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t target_duty, int scale, int cycle_num)
{
uint32_t duty_cur = LEDC.channel_group[speed_mode].channel[channel].duty_rd.duty_read >> 4;
int step_num = 0;
int dir = LEDC_DUTY_DIR_DECREASE;
if (scale > 0) {
if (duty_cur > target_duty) {
step_num = (duty_cur - target_duty) / scale;
step_num = step_num > 1023 ? 1023 : step_num;
scale = (step_num == 1023) ? (duty_cur - target_duty) / step_num : scale;
} else {
dir = LEDC_DUTY_DIR_INCREASE;
step_num = (target_duty - duty_cur) / scale;
step_num = step_num > 1023 ? 1023 : step_num;
scale = (step_num == 1023) ? (target_duty - duty_cur) / step_num : scale;
}
}
if (scale > 0 && step_num > 0) {
iot_ledc_duty_config(speed_mode, channel, -1, duty_cur << 4, dir, step_num, cycle_num, scale);
} else {
iot_ledc_duty_config(speed_mode, channel, -1, target_duty << 4, dir, 0, 1, 0);
}
return ESP_OK;
}
static IRAM_ATTR esp_err_t _iot_set_fade_with_time(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t target_duty, int max_fade_time_ms)
{
uint32_t freq = 0;
uint32_t duty_cur = LEDC.channel_group[speed_mode].channel[channel].duty_rd.duty_read >> 4;
uint32_t duty_delta = target_duty > duty_cur ? target_duty - duty_cur : duty_cur - target_duty;
uint32_t timer_source_clk = LEDC.timer_group[speed_mode].timer[g_light_config->timer_num].conf.tick_sel;
uint32_t duty_resolution = LEDC.timer_group[speed_mode].timer[g_light_config->timer_num].conf.duty_resolution;
uint32_t clock_divider = LEDC.timer_group[speed_mode].timer[g_light_config->timer_num].conf.clock_divider;
uint32_t precision = (0x1U << duty_resolution);
if (timer_source_clk == LEDC_APB_CLK) {
freq = ((uint64_t)APB_CLK_FREQ << 8) / precision / clock_divider;
} else {
freq = ((uint64_t)REF_CLK_FREQ << 8) / precision / clock_divider;
}
if (duty_delta == 0) {
return _iot_set_fade_with_step(speed_mode, channel, target_duty, 0, 0);
}
int total_cycles = max_fade_time_ms * freq / 1000;
if (total_cycles == 0) {
return _iot_set_fade_with_step(speed_mode, channel, target_duty, 0, 0);
}
int scale, cycle_num;
if (total_cycles > duty_delta) {
scale = 1;
cycle_num = total_cycles / duty_delta;
#if CONFIG_IDF_TARGET_ESP32C3
if (cycle_num > LEDC_DUTY_NUM_LSCH0_V) {
cycle_num = LEDC_DUTY_NUM_LSCH0_V;
}
#elif CONFIG_IDF_TARGET_ESP32
if (cycle_num > LEDC_DUTY_NUM_HSCH0_V) {
cycle_num = LEDC_DUTY_NUM_HSCH0_V;
}
#endif
} else {
cycle_num = 1;
scale = duty_delta / total_cycles;
#if CONFIG_IDF_TARGET_ESP32C3
if (scale > LEDC_DUTY_SCALE_LSCH0_V) {
scale = LEDC_DUTY_SCALE_LSCH0_V;
}
#elif CONFIG_IDF_TARGET_ESP32
if (scale > LEDC_DUTY_SCALE_HSCH0_V) {
scale = LEDC_DUTY_SCALE_HSCH0_V;
}
#endif
}
return _iot_set_fade_with_step(speed_mode, channel, target_duty, scale, cycle_num);
}
static IRAM_ATTR esp_err_t _iot_update_duty(ledc_mode_t speed_mode, ledc_channel_t channel)
{
LEDC.channel_group[speed_mode].channel[channel].conf0.sig_out_en = 1;
LEDC.channel_group[speed_mode].channel[channel].conf1.duty_start = 1;
if (speed_mode == LEDC_LOW_SPEED_MODE) {
LEDC.channel_group[speed_mode].channel[channel].conf0.low_speed_update = 1;
}
return ESP_OK;
}
static IRAM_ATTR esp_err_t iot_ledc_set_duty(ledc_mode_t speed_mode, ledc_channel_t channel, uint32_t duty)
{
return iot_ledc_duty_config(speed_mode,
channel, // uint32_t chan_num,
-1,
duty << 4, // uint32_t duty_val,the least 4 bits are decimal part
1, // uint32_t increase,
1, // uint32_t duty_num,
1, // uint32_t duty_cycle,
0 // uint32_t duty_scale
);
}
static void gamma_table_create(uint16_t *gamma_table, float correction)
{
float value_tmp = 0;
/**
* @brief gamma curve formula: y=a*x^(1/gm)
* x ∈ (0,(GAMMA_TABLE_SIZE-1)/GAMMA_TABLE_SIZE)
* a = GAMMA_TABLE_SIZE
*/
for (int i = 0; i < GAMMA_TABLE_SIZE; i++) {
value_tmp = (float)(i) / GAMMA_TABLE_SIZE;
value_tmp = powf(value_tmp, 1.0f / correction);
gamma_table[i] = (uint16_t)FLOATINT_2_FIXED((value_tmp * GAMMA_TABLE_SIZE), LEDC_FIXED_Q);
}
}
static IRAM_ATTR uint32_t gamma_value_to_duty(int value)
{
uint32_t tmp_q = GET_FIXED_INTEGER_PART(value, LEDC_FIXED_Q);
uint32_t tmp_r = GET_FIXED_DECIMAL_PART(value, LEDC_FIXED_Q);
uint16_t cur = LEDC_VALUE_TO_DUTY(g_gamma_table[tmp_q]);
uint16_t next = LEDC_VALUE_TO_DUTY(g_gamma_table[tmp_q + 1]);
return (cur + (next - cur) * tmp_r / (0x1U << LEDC_FIXED_Q));
}
static IRAM_ATTR bool fade_timercb(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void *user_ctx)
{
int idle_channel_num = 0;
for (int channel = 0; channel < LEDC_CHANNEL_MAX; channel++) {
ledc_fade_data_t *fade_data = g_light_config->fade_data + channel;
if (fade_data->num > 0) {
fade_data->num--;
if (fade_data->step) {
fade_data->cur += fade_data->step;
if (fade_data->num != 0) {
_iot_set_fade_with_time(g_light_config->speed_mode, channel,
gamma_value_to_duty(fade_data->cur),
DUTY_SET_CYCLE - LEDC_FADE_MARGIN);
} else {
iot_ledc_set_duty(g_light_config->speed_mode, channel, gamma_value_to_duty(fade_data->cur));
}
_iot_update_duty(g_light_config->speed_mode, channel);
} else {
iot_ledc_set_duty(g_light_config->speed_mode, channel, gamma_value_to_duty(fade_data->cur));
_iot_update_duty(g_light_config->speed_mode, channel);
}
} else if (fade_data->cycle) {
fade_data->num = fade_data->cycle - 1;
if (fade_data->step) {
fade_data->step *= -1;
fade_data->cur += fade_data->step;
} else {
fade_data->cur = (fade_data->cur == fade_data->final) ? 0 : fade_data->final;
}
_iot_set_fade_with_time(g_light_config->speed_mode, channel,
gamma_value_to_duty(fade_data->cur),
DUTY_SET_CYCLE - LEDC_FADE_MARGIN);
_iot_update_duty(g_light_config->speed_mode, channel);
} else {
idle_channel_num++;
}
}
if (idle_channel_num >= LEDC_CHANNEL_MAX) {
iot_timer_stop(timer);
}
return false;
}
esp_err_t iot_led_init(ledc_timer_t timer_num, ledc_mode_t speed_mode, uint32_t freq_hz)
{
esp_err_t ret = ESP_OK;
const ledc_timer_config_t ledc_time_config = {
.speed_mode = speed_mode,
.timer_num = timer_num,
.freq_hz = freq_hz,
.duty_resolution = LEDC_TIMER_13_BIT,
};
ret = ledc_timer_config(&ledc_time_config);
if (ret != ESP_OK) {
ESP_LOGW(TAG, "LEDC timer configuration");
return ret;
}
if (g_gamma_table == NULL) {
g_gamma_table = calloc(GAMMA_TABLE_SIZE, sizeof(uint16_t));
gamma_table_create(g_gamma_table, GAMMA_CORRECTION);
} else {
ESP_LOGE(TAG, "gamma_table has been initialized");
}
if (g_light_config == NULL) {
g_light_config = calloc(1, sizeof(iot_light_t));
g_light_config->timer_num = timer_num;
g_light_config->speed_mode = speed_mode;
gptimer_config_t timer_config = {
.clk_src = GPTIMER_CLK_SRC_DEFAULT,
.direction = GPTIMER_COUNT_UP,
.resolution_hz = GPTIMER_RESOLUTION_HZ,
};
ESP_ERROR_CHECK(gptimer_new_timer(&timer_config, &g_light_config->gptimer));
gptimer_event_callbacks_t cbs = {
.on_alarm = fade_timercb,
};
ESP_ERROR_CHECK(gptimer_register_event_callbacks(g_light_config->gptimer, &cbs, NULL));
ESP_ERROR_CHECK(gptimer_enable(g_light_config->gptimer));
} else {
ESP_LOGE(TAG, "g_light_config has been initialized");
}
return ESP_OK;
}
esp_err_t iot_led_deinit(void)
{
if (g_gamma_table) {
free(g_gamma_table);
}
if (g_light_config) {
gptimer_disable(g_light_config->gptimer);
gptimer_del_timer(g_light_config->gptimer);
free(g_light_config);
}
return ESP_OK;
}
esp_err_t iot_led_regist_channel(ledc_channel_t channel, gpio_num_t gpio_num)
{
esp_err_t ret = ESP_OK;
if (g_light_config == NULL) {
ESP_LOGW(TAG, "iot_led_init() must be called first");
return ESP_ERR_NOT_FOUND;
}
#ifdef CONFIG_SPIRAM_SUPPORT
if (gpio_num != GPIO_NUM_16 || gpio_num != GPIO_NUM_17) {
ESP_LOGW(TAG, "gpio_num must not conflict to PSRAM(IO16 && IO17)");
return ESP_ERR_INVALID_ARG;
}
#endif
const ledc_channel_config_t ledc_ch_config = {
.gpio_num = gpio_num,
.channel = channel,
.intr_type = LEDC_INTR_DISABLE,
.speed_mode = g_light_config->speed_mode,
.timer_sel = g_light_config->timer_num,
};
ret = ledc_channel_config(&ledc_ch_config);
if (ret != ESP_OK) {
ESP_LOGW(TAG, "LEDC channel configuration");
return ret;
}
return ESP_OK;
}
esp_err_t iot_led_get_channel(ledc_channel_t channel, uint8_t *dst)
{
if (g_light_config == NULL || dst == NULL) {
ESP_LOGW(TAG, "iot_led_init() must be called first or dst should not be NULL");
return ESP_ERR_INVALID_ARG;
}
int cur = g_light_config->fade_data[channel].cur;
*dst = FIXED_2_FLOATING(cur, LEDC_FIXED_Q);
return ESP_OK;
}
esp_err_t iot_led_set_channel(ledc_channel_t channel, uint8_t value, uint32_t fade_ms)
{
if (g_light_config == NULL) {
ESP_LOGW(TAG, "iot_led_init() must be called first");
return ESP_ERR_INVALID_ARG;
}
ledc_fade_data_t *fade_data = g_light_config->fade_data + channel;
fade_data->final = FLOATINT_2_FIXED(value, LEDC_FIXED_Q);
if (fade_ms < DUTY_SET_CYCLE) {
fade_data->num = 1;
} else {
fade_data->num = fade_ms / DUTY_SET_CYCLE;
}
fade_data->step = abs(fade_data->cur - fade_data->final) / fade_data->num;
if (fade_data->cur > fade_data->final) {
fade_data->step *= -1;
}
if (fade_data->cycle != 0) {
fade_data->cycle = 0;
}
if (g_hw_timer_started != true) {
iot_timer_start(g_light_config->gptimer);
}
return ESP_OK;
}
esp_err_t iot_led_start_blink(ledc_channel_t channel, uint8_t value, uint32_t period_ms, bool fade_flag)
{
if (g_light_config == NULL) {
ESP_LOGW(TAG, "iot_led_init() must be called first");
return ESP_ERR_INVALID_ARG;
}
ledc_fade_data_t *fade_data = g_light_config->fade_data + channel;
fade_data->final = fade_data->cur = FLOATINT_2_FIXED(value, LEDC_FIXED_Q);
fade_data->cycle = period_ms / 2 / DUTY_SET_CYCLE;
fade_data->num = (fade_flag) ? period_ms / 2 / DUTY_SET_CYCLE : 0;
fade_data->step = (fade_flag) ? fade_data->cur / fade_data->num * -1 : 0;
if (g_hw_timer_started != true) {
iot_timer_start(g_light_config->gptimer);
}
return ESP_OK;
}
esp_err_t iot_led_stop_blink(ledc_channel_t channel)
{
if (g_light_config == NULL) {
ESP_LOGW(TAG, "iot_led_init() must be called first");
return ESP_ERR_INVALID_ARG;
}
ledc_fade_data_t *fade_data = g_light_config->fade_data + channel;
fade_data->cycle = fade_data->num = 0;
return ESP_OK;
}
esp_err_t iot_led_set_gamma_table(const uint16_t gamma_table[GAMMA_TABLE_SIZE])
{
if (g_gamma_table == NULL) {
ESP_LOGW(TAG, "iot_led_init() must be called first");
return ESP_ERR_INVALID_ARG;
}
memcpy(g_gamma_table, gamma_table, GAMMA_TABLE_SIZE * sizeof(uint16_t));
return ESP_OK;
}