espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-08-02 20:24:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'bugfix/aligenie_demo_timer' into 'master'

Browse Source 
bugfix: update genie timer in aligenie example

See merge request espressif/esp-idf!11411
This commit is contained in:
Island
2020-12-02 12:04:32 +08:00
parent 0f8afff021 76c279bee1
commit 66416d1a8b
5 changed files with 112 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
examples/bluetooth/esp_ble_mesh/aligenie_demo/components/vendor_model/genie_mesh.c
View File

@@ -42,6 +42,7 @@ static util_timer_t g_pbadv_timer;
static util_timer_t g_prov_timer; static util_timer_t g_prov_timer;
#ifdef CONFIG_MESH_MODEL_VENDOR_SRV #ifdef CONFIG_MESH_MODEL_VENDOR_SRV
static util_timer_t g_indc_timer; static util_timer_t g_indc_timer;
static util_timer_t g_time_sync_timer;
#endif #endif
#ifdef CONFIG_MESH_MODEL_TRANS #ifdef CONFIG_MESH_MODEL_TRANS
@@ -51,12 +52,12 @@ void mesh_timer_stop(elem_state_t *p_elem)
util_timer_stop(&p_elem->state.trans_timer); util_timer_stop(&p_elem->state.trans_timer);
} }
static void mesh_delay_timer_cb(void *p_timer, void *p_arg) static void mesh_delay_timer_cb(void *p_timer)
{ {
elem_state_t *p_elem = (elem_state_t *)p_arg; elem_state_t *p_elem = (elem_state_t *)p_timer;
mesh_timer_stop(p_elem); mesh_timer_stop(p_elem);
genie_event(GENIE_EVT_SDK_DELAY_END, p_arg); genie_event(GENIE_EVT_SDK_DELAY_END, p_timer);
} }
void clear_trans_para(elem_state_t *p_elem) void clear_trans_para(elem_state_t *p_elem)
@@ -66,19 +67,19 @@ void clear_trans_para(elem_state_t *p_elem)
p_elem->state.trans_end_time = 0; p_elem->state.trans_end_time = 0;
} }
static void mesh_trans_timer_cycle(void *p_timer, void *p_arg) static void mesh_trans_timer_cycle(void *p_timer)
{ {
elem_state_t *p_elem = (elem_state_t *)p_arg; elem_state_t *p_elem = (elem_state_t *)p_timer;
model_state_t *p_state = &p_elem->state; model_state_t *p_state = &p_elem->state;
mesh_timer_stop(p_elem); mesh_timer_stop(p_elem);
// do cycle // do cycle
genie_event(GENIE_EVT_SDK_TRANS_CYCLE, p_arg); genie_event(GENIE_EVT_SDK_TRANS_CYCLE, p_timer);
// ESP_LOGI(TAG, ">>>>>%d %d", (uint32_t)cur_time, (uint32_t)p_elem->state.trans_end_time); // ESP_LOGI(TAG, ">>>>>%d %d", (uint32_t)cur_time, (uint32_t)p_elem->state.trans_end_time);
if (p_state->trans == 0) { if (p_state->trans == 0) {
genie_event(GENIE_EVT_SDK_TRANS_END, p_arg); genie_event(GENIE_EVT_SDK_TRANS_END, p_timer);
} else { } else {
util_timer_start(&p_state->trans_timer, GENIE_MESH_TRNSATION_CYCLE); util_timer_start(&p_state->trans_timer, GENIE_MESH_TRNSATION_CYCLE);
} }
@@ -240,7 +241,7 @@ void poweron_indicate_start(void)
util_timer_init(&g_indc_timer, poweron_indicate_cb, NULL); util_timer_init(&g_indc_timer, poweron_indicate_cb, NULL);
inited = 1; inited = 1;
} }
bt_mesh_rand(&random_time, 1); esp_fill_random(&random_time, 1);
#ifdef CONFIG_MESH_MODEL_TRANS #ifdef CONFIG_MESH_MODEL_TRANS
random_time = 2000 + 8000 * random_time / 255; random_time = 2000 + 8000 * random_time / 255;
#else #else
@@ -777,6 +778,34 @@ uint8_t get_seg_count(uint16_t msg_len)
} }
#ifdef CONFIG_MESH_MODEL_VENDOR_SRV #ifdef CONFIG_MESH_MODEL_VENDOR_SRV
static int genie_timer_event(uint8_t event, uint8_t index, genie_timer_attr_data_t *data);
static void time_sync_request_cb(void *p_timer)
{
ENTER_FUNC();
genie_timer_event(GENIE_TIME_EVT_TIMING_SYNC, 0, NULL);
}
void time_sync_request_start(void)
{
ENTER_FUNC();
static uint8_t inited = 0;
uint16_t random_time = 0;
if (!inited) {
util_timer_init(&g_time_sync_timer, time_sync_request_cb, NULL);
inited = 1;
}
esp_fill_random(&random_time, 1);
#ifdef CONFIG_MESH_MODEL_TRANS
random_time = 10000 + 5000 * random_time / 255;
#else
random_time = 5000 + 10000 * random_time / 255;
#endif
ESP_LOGD(TAG, "time sync indicate random: %d ms", random_time);
util_timer_start(&g_time_sync_timer, random_time);
}
void genie_standart_indication(elem_state_t *p_elem) void genie_standart_indication(elem_state_t *p_elem)
{ {
ENTER_FUNC(); ENTER_FUNC();
@@ -866,6 +895,8 @@ void genie_standart_indication(elem_state_t *p_elem)
buff[i++] = (GENIE_MODEL_ATTR_DEVICE_EVENT >> 8) & 0xff; buff[i++] = (GENIE_MODEL_ATTR_DEVICE_EVENT >> 8) & 0xff;
buff[i++] = EVENT_DEV_UP; buff[i++] = EVENT_DEV_UP;
cur_indication_flag &= ~INDICATION_FLAG_POWERON; cur_indication_flag &= ~INDICATION_FLAG_POWERON;
// 1. request to sync time with random delay
time_sync_request_start();
} }
ESP_LOGD(TAG, "end flag %02x", g_indication_flag); ESP_LOGD(TAG, "end flag %02x", g_indication_flag);

113
examples/bluetooth/esp_ble_mesh/aligenie_demo/components/vendor_model/genie_model_srv.c
View File

@@ -80,10 +80,10 @@ static uint16_t bt_mesh_model_get_netkey_id(esp_ble_mesh_elem_t *elem)
static uint8_t genie_model_msg_gen_tid(void) static uint8_t genie_model_msg_gen_tid(void)
{ {
ENTER_FUNC(); ENTER_FUNC();
static uint8_t tid = 0x80; static uint8_t tid = 0xFF;
if (tid == 0xFF) { if (tid == 0xFF) {
bt_mesh_rand(&tid, 1); esp_fill_random(&tid, 1);
tid &= 0x3F; tid &= 0x3F;
} else { } else {
tid = (tid + 1) & 0x3F; tid = (tid + 1) & 0x3F;
@@ -123,13 +123,13 @@ static uint16_t genie_model_init(void)
* *
* @return 0 for success; negative for failure * @return 0 for success; negative for failure
*/ */
static int16_t genie_model_msg_node_free(genie_model_msg_node_t *p_node) static esp_err_t genie_model_msg_node_free(genie_model_msg_node_t *p_node)
{ {
ENTER_FUNC(); ENTER_FUNC();
free(p_node); free(p_node);
return 0; return ESP_OK;
} }
/** @def genie_model_msg_node_generate /** @def genie_model_msg_node_generate
@@ -161,7 +161,7 @@ static genie_model_msg_node_t *genie_model_msg_node_generate(genie_model_msg_t *
ESP_LOGD(TAG, "p_node->msg: %p, data: %p, %p", &p_node->msg, &p_node->msg.data, &p_node->msg.data + 1); ESP_LOGD(TAG, "p_node->msg: %p, data: %p, %p", &p_node->msg, &p_node->msg.data, &p_node->msg.data + 1);
p_node->msg.data = (uint8_t *)(&p_node->msg.data + 1); p_node->msg.data = (uint8_t *)(&p_node->msg.data + 1);
memcpy(p_node->msg.data, p_model_msg->data, p_model_msg->len); memcpy(p_node->msg.data, p_model_msg->data, p_model_msg->len);
ESP_LOGD(TAG, "p_model_msg->data: %p, data: %s, p_node->msg.data: %p, data: %s", ESP_LOGD(TAG, "p_model_msg->data: %p, data: 0x%s, p_node->msg.data: %p, data: 0x%s",
p_model_msg->data, util_hex2str(p_model_msg->data, p_model_msg->len), p_model_msg->data, util_hex2str(p_model_msg->data, p_model_msg->len),
p_node->msg.data, util_hex2str(p_node->msg.data, p_node->msg.len)); p_node->msg.data, util_hex2str(p_node->msg.data, p_node->msg.len));
p_node->timeout = esp_timer_get_time() + p_model_msg->retry_period; p_node->timeout = esp_timer_get_time() + p_model_msg->retry_period;
@@ -179,7 +179,7 @@ static genie_model_msg_node_t *genie_model_msg_node_generate(genie_model_msg_t *
* *
* @return 0 for success; negative for failure * @return 0 for success; negative for failure
*/ */
static int16_t genie_model_msg_list_append(genie_model_msg_t *p_model_msg) static esp_err_t genie_model_msg_list_append(genie_model_msg_t *p_model_msg)
{ {
ENTER_FUNC(); ENTER_FUNC();
genie_model_msg_node_t *p_msg_node = NULL; genie_model_msg_node_t *p_msg_node = NULL;
@@ -187,13 +187,13 @@ static int16_t genie_model_msg_list_append(genie_model_msg_t *p_model_msg)
p_msg_node = genie_model_msg_node_generate(p_model_msg); p_msg_node = genie_model_msg_node_generate(p_model_msg);
if (!p_msg_node) { if (!p_msg_node) {
return -2; return ESP_ERR_INVALID_ARG;
} }
ESP_LOGD(TAG, "append msg: %p, opid: %x, retry: %d, head: %p, node: %p", p_model_msg, p_model_msg->opid, p_model_msg->retry, &g_vnd_msg_list, &p_msg_node->node); ESP_LOGD(TAG, "append msg: %p, opid: 0x%02x, retry: %d, head: %p, node: %p", p_model_msg, p_model_msg->opid, p_model_msg->retry, &g_vnd_msg_list, &p_msg_node->node);
if (genie_dlist_node_number(&g_vnd_msg_list) >= GENIE_VENDOR_MSG_LIST_MAXSIZE) { if (genie_dlist_node_number(&g_vnd_msg_list) >= GENIE_VENDOR_MSG_LIST_MAXSIZE) {
ESP_LOGW(TAG, "List Full, discard!!!"); ESP_LOGW(TAG, "List Full, discard!!!");
return 0; return ESP_OK;
} }
genie_dlist_append(&g_vnd_msg_list, &p_msg_node->node); genie_dlist_append(&g_vnd_msg_list, &p_msg_node->node);
@@ -203,7 +203,7 @@ static int16_t genie_model_msg_list_append(genie_model_msg_t *p_model_msg)
util_timer_start(&g_vnd_msg_timer, p_model_msg->retry_period); util_timer_start(&g_vnd_msg_timer, p_model_msg->retry_period);
} }
return 0; return ESP_OK;
} }
/** @def genie_model_retry_timer_cb /** @def genie_model_retry_timer_cb
@@ -233,10 +233,10 @@ static void genie_model_retry_timer_cb(void *args)
p_msg_node = CONTAINER_OF(p_node, genie_model_msg_node_t, node); p_msg_node = CONTAINER_OF(p_node, genie_model_msg_node_t, node);
nearest = p_msg_node->msg.retry_period; nearest = p_msg_node->msg.retry_period;
p_msg = &p_msg_node->msg; p_msg = &p_msg_node->msg;
ESP_LOGD(TAG, "msg: %p, opid: %d, left: %d", p_msg, p_msg->opid, p_msg_node->left_retry); ESP_LOGD(TAG, "msg: %p, opid: 0x%02x, left: %d", p_msg, p_msg->opid, p_msg_node->left_retry);
if (p_msg_node->timeout <= esp_timer_get_time()) { if (p_msg_node->timeout <= esp_timer_get_time()) {
ESP_LOGD(TAG, "timeout - msg: %p, opid: %x, left: %d", p_msg, p_msg->opid, p_msg_node->left_retry); ESP_LOGD(TAG, "timeout - msg: %p, opid: 0x%02x, left: %d", p_msg, p_msg->opid, p_msg_node->left_retry);
genie_model_msg_send(p_msg); genie_model_msg_send(p_msg);
if (--p_msg_node->left_retry <= 0) { if (--p_msg_node->left_retry <= 0) {
genie_dlist_remove(p_node); genie_dlist_remove(p_node);
@@ -259,6 +259,7 @@ static void genie_model_retry_timer_cb(void *args)
util_timer_stop(&g_vnd_msg_timer); util_timer_stop(&g_vnd_msg_timer);
ESP_LOGD(TAG, "list empty, stop timer"); ESP_LOGD(TAG, "list empty, stop timer");
} }
return; return;
} }
@@ -270,17 +271,17 @@ static void genie_model_retry_timer_cb(void *args)
* *
* @return 0 for success; negative for failure * @return 0 for success; negative for failure
*/ */
static int16_t genie_model_msg_check_tid(genie_dlist_t *p_head, uint8_t tid) static esp_err_t genie_model_msg_check_tid(genie_dlist_t *p_head, uint8_t tid)
{ {
ENTER_FUNC(); ENTER_FUNC();
genie_dnode_t *p_node = NULL; genie_dnode_t *p_node = NULL;
if (!p_head) { if (!p_head) {
return -1; return ESP_FAIL;
} }
if (genie_dlist_is_empty(p_head)) { if (genie_dlist_is_empty(p_head)) {
return 0; return ESP_OK;
} }
/** /**
@@ -295,14 +296,14 @@ static int16_t genie_model_msg_check_tid(genie_dlist_t *p_head, uint8_t tid)
p_msg = &p_msg_node->msg; p_msg = &p_msg_node->msg;
if (p_msg->tid == tid) { if (p_msg->tid == tid) {
ESP_LOGD(TAG, "dequeue msg: %p, opid: %x, retry: %2d", p_msg, p_msg->opid, p_msg->retry); ESP_LOGD(TAG, "dequeue msg: %p, opid: 0x%02x, retry: %2d", p_msg, p_msg->opid, p_msg->retry);
genie_dlist_remove(p_node); genie_dlist_remove(p_node);
genie_model_msg_node_free((genie_model_msg_node_t *)p_node); genie_model_msg_node_free((genie_model_msg_node_t *)p_node);
break; break;
} }
} }
return 0; return ESP_OK;
} }
@@ -314,10 +315,10 @@ static int16_t genie_model_msg_check_tid(genie_dlist_t *p_head, uint8_t tid)
* *
* @return 0 for success; negative for failure * @return 0 for success; negative for failure
*/ */
int16_t genie_model_msg_send(genie_model_msg_t *p_model_msg) esp_err_t genie_model_msg_send(genie_model_msg_t *p_model_msg)
{ {
ENTER_FUNC(); ENTER_FUNC();
int16_t err = -1; esp_err_t err = ESP_FAIL;
bool resend_flag = false; bool resend_flag = false;
esp_ble_mesh_msg_ctx_t ctx = {0}; esp_ble_mesh_msg_ctx_t ctx = {0};
esp_ble_mesh_model_t *p_model = esp_ble_mesh_find_vendor_model(p_model_msg->p_elem, CID_ALIBABA, GENIE_VENDOR_MODEL_SRV_ID); esp_ble_mesh_model_t *p_model = esp_ble_mesh_find_vendor_model(p_model_msg->p_elem, CID_ALIBABA, GENIE_VENDOR_MODEL_SRV_ID);
@@ -329,7 +330,13 @@ int16_t genie_model_msg_send(genie_model_msg_t *p_model_msg)
return err; return err;
} }
ESP_LOGD(TAG, "p_model: 0x%p, cid: 0x%04x, id: 0x%04x, retry: %d", p_model, p_model->vnd.company_id, p_model->vnd.model_id, p_model_msg->retry); ESP_LOGD(TAG, "p_model: %p, cid: 0x%04x, id: 0x%04x, opcode: 0x%02x, retry: %d", p_model, p_model->vnd.company_id, p_model->vnd.model_id, p_model_msg->opid, p_model_msg->retry);
if(p_model_msg->tid == 0) {
p_model_msg->tid = genie_model_msg_gen_tid();
ESP_LOGD(TAG, "genie_model_msg_gen_tid: 0x%02x", p_model_msg->tid);
}
/** /**
* no need to duplicate the following messages * no need to duplicate the following messages
* 1. retry <= 0 - the message won't want to be resent * 1. retry <= 0 - the message won't want to be resent
@@ -338,35 +345,42 @@ int16_t genie_model_msg_send(genie_model_msg_t *p_model_msg)
* 4. already duplicated or CONFIME/CONFIME_TG * 4. already duplicated or CONFIME/CONFIME_TG
* */ * */
if ((p_model_msg->retry > 1) && if ((p_model_msg->retry > 1) &&
(p_model_msg->tid >= 0x7F && p_model_msg->tid < 0xC0) && (p_model_msg->tid >= 0x7F && p_model_msg->tid < 0xC0) &&
(p_model_msg->opid != GENIE_OP_ATTR_SET_UNACK) && ((p_model_msg->opid == GENIE_OP_ATTR_INDICATE) ||
(p_model_msg->opid != GENIE_OP_ATTR_CONFIME) && (p_model_msg->opid == GENIE_OP_ATTR_INDICATE_TG) ||
(p_model_msg->opid != GENIE_OP_ATTR_CONFIME_TG) && (p_model_msg->opid == GENIE_OP_ATTR_TRANS_INDICATE))) {
(p_model_msg->opid != GENIE_OP_ATTR_TRANS_MSG) &&
(p_model_msg->opid != GENIE_OP_ATTR_TRANS_ACK) ) {
resend_flag = true; resend_flag = true;
ESP_LOGD(TAG, "resend_flag"); ESP_LOGD(TAG, "set resend flag");
}
/** genie_dnode_t *p_node = NULL;
* only when opid is one of GENIE_OP_ATTR_CONFIME, GENIE_OP_ATTR_CONFIME_TG and GENIE_OP_ATTR_TRANS_ACK, shall we keep tid as it is GENIE_DLIST_FOR_EACH_NODE(&g_vnd_msg_list, p_node) {
* */ genie_model_msg_t *p_msg = NULL;
if (!(p_model_msg->tid) && genie_model_msg_node_t *p_msg_node = NULL;
(p_model_msg->opid != GENIE_OP_ATTR_CONFIME) &&
(p_model_msg->opid != GENIE_OP_ATTR_CONFIME_TG) && p_msg_node = CONTAINER_OF(p_node, genie_model_msg_node_t, node);
(p_model_msg->opid != GENIE_OP_ATTR_TRANS_MSG) && p_msg = &p_msg_node->msg;
(p_model_msg->opid != GENIE_OP_ATTR_TRANS_ACK)) {
p_model_msg->tid = genie_model_msg_gen_tid(); if (p_msg->tid == p_model_msg->tid) {
ESP_LOGD(TAG, "genie_model_msg_gen_tid"); ESP_LOGI(TAG, "no resend");
resend_flag = false;
break;
}
}
} }
// prepare buffer // prepare buffer
uint8_t *data = malloc(p_model_msg->len + 1); uint8_t *data = NULL;
data = malloc(p_model_msg->len + 1);
if (!data) {
ESP_LOGE(TAG, "malloc failed");
return ESP_FAIL;
}
data[0] = p_model_msg->tid; data[0] = p_model_msg->tid;
memcpy(data + 1, p_model_msg->data, p_model_msg->len); memcpy(data + 1, p_model_msg->data, p_model_msg->len);
p_model_msg->retry--; p_model_msg->retry--;
ESP_LOGD(TAG, "p_model_msg->opid: 0x%04x, p_model_msg->data: 0x%p, len: %d, data: %s", ESP_LOGD(TAG, "p_model_msg->opid: 0x%02x, p_model_msg->data: %p, len: %d, data: 0x%s",
p_model_msg->opid, p_model_msg, p_model_msg->len, util_hex2str(p_model_msg->data, p_model_msg->len)); p_model_msg->opid, p_model_msg, p_model_msg->len, util_hex2str(p_model_msg->data, p_model_msg->len));
if (resend_flag) { if (resend_flag) {
@@ -379,10 +393,9 @@ int16_t genie_model_msg_send(genie_model_msg_t *p_model_msg)
ctx.addr = GENIE_RECV_ADDR; ctx.addr = GENIE_RECV_ADDR;
ctx.send_ttl = BLE_MESH_TTL_DEFAULT; ctx.send_ttl = BLE_MESH_TTL_DEFAULT;
ctx.send_rel = 0; ctx.send_rel = 0;
ctx.srv_send = true;
ESP_LOGI(TAG, "vendor message send: tid: 0x%02x, retry: %02d, len: %02d, opcode: 0x%x, data: 0x%s", p_model_msg->tid, p_model_msg->retry, p_model_msg->len, p_model_msg->opid, util_hex2str(p_model_msg->data, p_model_msg->len)); ESP_LOGI(TAG, "vendor message send: tid: 0x%02x, retry: %02d, len: %02d, opcode: 0x%02x, data: 0x%s", p_model_msg->tid, p_model_msg->retry, p_model_msg->len, p_model_msg->opid, util_hex2str(p_model_msg->data, p_model_msg->len));
ESP_LOGD(TAG, "vendor message send: element: 0x%p, app_idx: %d, net_idx: %d, tid: 0x%02x, retry: %02d, len: %02d, opcode: 0x%x, data: 0x%s", ESP_LOGD(TAG, "vendor message send: element: %p, app_idx: %d, net_idx: %d, tid: 0x%02x, retry: %02d, len: %02d, opcode: 0x%02x, data: 0x%s",
p_model_msg->p_elem, ctx.app_idx, ctx.net_idx, p_model_msg->tid, p_model_msg->retry, p_model_msg->len, p_model_msg->opid, util_hex2str(p_model_msg->data, p_model_msg->len)); p_model_msg->p_elem, ctx.app_idx, ctx.net_idx, p_model_msg->tid, p_model_msg->retry, p_model_msg->len, p_model_msg->opid, util_hex2str(p_model_msg->data, p_model_msg->len));
err = esp_ble_mesh_server_model_send_msg(p_model, &ctx, ESP_BLE_MESH_MODEL_OP_3(p_model_msg->opid, CID_ALIBABA), p_model_msg->len + 1, data); err = esp_ble_mesh_server_model_send_msg(p_model, &ctx, ESP_BLE_MESH_MODEL_OP_3(p_model_msg->opid, CID_ALIBABA), p_model_msg->len + 1, data);
@@ -394,7 +407,7 @@ int16_t genie_model_msg_send(genie_model_msg_t *p_model_msg)
} }
if (p_model_msg->retry == 0) { if (p_model_msg->retry == 0) {
ESP_LOGW(TAG, "The message has been retried 9 times and may be lost. This is the last retry. tid: %02x", p_model_msg->tid); ESP_LOGW(TAG, "The message has been retried 9 times and may be lost. This is the last retry. tid: 0x%02x", p_model_msg->tid);
} }
free(data); free(data);
@@ -410,7 +423,7 @@ int16_t genie_model_msg_send(genie_model_msg_t *p_model_msg)
* *
* @return if success return 0; if fails return error no. * @return if success return 0; if fails return error no.
*/ */
static int16_t genie_model_analyze(esp_ble_mesh_model_t *p_model, static esp_err_t genie_model_analyze(esp_ble_mesh_model_t *p_model,
esp_ble_mesh_msg_ctx_t *p_ctx, esp_ble_mesh_msg_ctx_t *p_ctx,
struct net_buf_simple *p_buf, struct net_buf_simple *p_buf,
uint8_t opid) uint8_t opid)
@@ -438,7 +451,7 @@ static int16_t genie_model_analyze(esp_ble_mesh_model_t *p_model,
} }
msg.len = p_buf->len; msg.len = p_buf->len;
ESP_LOGD(TAG, "opcode: 0x%x, tid: %02x, len: %d", msg.opid, msg.tid, msg.len); ESP_LOGD(TAG, "opcode: 0x%02x, tid: 0x%02x, len: %d", msg.opid, msg.tid, msg.len);
if (msg.len) { if (msg.len) {
msg.data = (uint8_t *)p_buf->data; msg.data = (uint8_t *)p_buf->data;
@@ -450,7 +463,7 @@ static int16_t genie_model_analyze(esp_ble_mesh_model_t *p_model,
genie_event(GENIE_EVT_SDK_VENDOR_MSG, (void *)&msg); genie_event(GENIE_EVT_SDK_VENDOR_MSG, (void *)&msg);
return 0; return ESP_OK;
} }
/** @def genie_model_get_status /** @def genie_model_get_status
@@ -522,7 +535,7 @@ static void genie_model_confirm(esp_ble_mesh_model_t *model,
} }
tid = net_buf_simple_pull_u8(buf); tid = net_buf_simple_pull_u8(buf);
ESP_LOGI(TAG, "confirm tid: %02x", tid); ESP_LOGI(TAG, "confirm tid: 0x%02x", tid);
genie_model_msg_check_tid(&g_vnd_msg_list, tid); genie_model_msg_check_tid(&g_vnd_msg_list, tid);
} }
@@ -547,7 +560,7 @@ static void genie_model_confirm_tg(esp_ble_mesh_model_t *model,
} }
tid = net_buf_simple_pull_u8(buf); tid = net_buf_simple_pull_u8(buf);
ESP_LOGI(TAG, "confirm_tg tid: %02x", tid); ESP_LOGI(TAG, "confirm_tg tid: 0x%02x", tid);
genie_model_msg_check_tid(&g_vnd_msg_list, tid); genie_model_msg_check_tid(&g_vnd_msg_list, tid);
} }
@@ -625,5 +638,5 @@ void genie_model_dispatch(uint32_t opcode, esp_ble_mesh_model_t *model,
return; return;
} }
} }
ESP_LOGW(TAG, "not find callback function for opcode: 0x%04x", opcode); ESP_LOGW(TAG, "not find callback function for opcode: 0x%02x", opcode);
} }

4
examples/bluetooth/esp_ble_mesh/aligenie_demo/components/vendor_model/genie_timer.c
View File

@@ -323,7 +323,7 @@ static inline void seconds_update(void)
static void genie_timer_update(void *args) static void genie_timer_update(void *args)
{ {
if (!g_genie_timer.update) { if (!g_genie_timer.update) {
ESP_LOGE(TAG, "g_genie_timer.update %d", g_genie_timer.update); ESP_LOGD(TAG, "g_genie_timer.update %d", g_genie_timer.update);
return; return;
} }
@@ -839,7 +839,7 @@ int genie_timer_init(genie_timer_event_func_t cb)
} }
/* sync timing */ /* sync timing */
g_genie_timer.cb(GENIE_TIME_EVT_TIMING_SYNC, 0, NULL); // g_genie_timer.cb(GENIE_TIME_EVT_TIMING_SYNC, 0, NULL);
return 0; return 0;
} }

2
examples/bluetooth/esp_ble_mesh/aligenie_demo/components/vendor_model/include/genie_model_srv.h
View File

@@ -47,7 +47,7 @@ typedef struct genie_opcode_cb_t {
* *
* @return 0 for success; negative for failure * @return 0 for success; negative for failure
*/ */
int16_t genie_model_msg_send(genie_model_msg_t *p_model_msg); esp_err_t genie_model_msg_send(genie_model_msg_t *p_model_msg);
/** /**
* @brief * @brief

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

@@ -1317,6 +1317,13 @@ void app_main(void)
} }
ESP_ERROR_CHECK(err); ESP_ERROR_CHECK(err);
/* Open nvs namespace for storing/restoring mesh example info */
err = ble_mesh_nvs_open(&NVS_HANDLE);
if (err) {
ESP_LOGE(TAG, "ble_mesh_nvs_open failed (err %d)", err);
return;
}
#ifdef CONFIG_GENIE_RESET_BY_REPEAT #ifdef CONFIG_GENIE_RESET_BY_REPEAT
genie_reset_by_repeat_init(); genie_reset_by_repeat_init();
#endif #endif
@@ -1329,13 +1336,6 @@ void app_main(void)
return; return;
} }
/* Open nvs namespace for storing/restoring mesh example info */
err = ble_mesh_nvs_open(&NVS_HANDLE);
if (err) {
ESP_LOGE(TAG, "ble_mesh_nvs_open failed (err %d)", err);
return;
}
/* Initialize the Bluetooth Mesh Subsystem */ /* Initialize the Bluetooth Mesh Subsystem */
err = ble_mesh_init(); err = ble_mesh_init();
if (err) { if (err) {