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

callback: add a void* pointer with each callback

Browse Source 
also format event.c/wifi.c/esp_event.h/esp_wifi.h
This commit is contained in:
Wu Jian Gang 2016-09-13 15:57:11 +08:00
parent c56a790f64
commit bf5e83a6ed
5 changed files with 155 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
components/esp32/cpu_start.c
View File

@ -198,7 +198,7 @@ static void do_global_ctors(void) {
(*p)(); (*p)();
} }
extern esp_err_t app_main(void *param); extern esp_err_t app_main(void *ctx);
void user_start_cpu0(void) { void user_start_cpu0(void) {
ets_setup_syscalls(); ets_setup_syscalls();
@ -214,14 +214,14 @@ void user_start_cpu0(void) {
system_init(); system_init();
esp_event_init(NULL); esp_event_init(NULL, NULL);
tcpip_adapter_init(); tcpip_adapter_init();
#endif #endif
#if CONFIG_WIFI_ENABLED && CONFIG_WIFI_AUTO_STARTUP #if CONFIG_WIFI_ENABLED && CONFIG_WIFI_AUTO_STARTUP
#include "esp_wifi.h" #include "esp_wifi.h"
esp_wifi_startup(app_main); esp_wifi_startup(app_main, NULL);
#else #else
app_main(NULL); app_main(NULL);
#endif #endif

242
components/esp32/event.c
View File

@ -11,6 +11,7 @@
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -29,10 +30,13 @@
#define ESP32_WORKAROUND 1 #define ESP32_WORKAROUND 1
#if CONFIG_WIFI_ENABLED #if CONFIG_WIFI_ENABLED
static bool event_init_flag = false;
static xQueueHandle g_event_handler = NULL; static xQueueHandle g_event_handler = NULL;
static system_event_cb_t g_event_handler_cb;
#define WIFI_DEBUG(...) static system_event_cb_t g_event_handler_cb;
static void *g_event_ctx;
#define WIFI_DEBUG(...)
#define WIFI_API_CALL_CHECK(info, api_call, ret) \ #define WIFI_API_CALL_CHECK(info, api_call, ret) \
do{\ do{\
esp_err_t __err = (api_call);\ esp_err_t __err = (api_call);\
@ -43,6 +47,7 @@ do{\
} while(0) } while(0)
typedef esp_err_t (*system_event_handle_fn_t)(system_event_t *e); typedef esp_err_t (*system_event_handle_fn_t)(system_event_t *e);
typedef struct { typedef struct {
system_event_id_t event_id; system_event_id_t event_id;
system_event_handle_fn_t event_handle; system_event_handle_fn_t event_handle;
@ -55,7 +60,7 @@ static esp_err_t system_event_sta_start_handle_default(system_event_t *event);
static esp_err_t system_event_sta_stop_handle_default(system_event_t *event); static esp_err_t system_event_sta_stop_handle_default(system_event_t *event);
static esp_err_t system_event_sta_connected_handle_default(system_event_t *event); static esp_err_t system_event_sta_connected_handle_default(system_event_t *event);
static esp_err_t system_event_sta_disconnected_handle_default(system_event_t *event); static esp_err_t system_event_sta_disconnected_handle_default(system_event_t *event);
static esp_err_t system_event_sta_gotip_default(system_event_t *event); static esp_err_t system_event_sta_got_ip_default(system_event_t *event);
static system_event_handle_t g_system_event_handle_table[] = { static system_event_handle_t g_system_event_handle_table[] = {
{SYSTEM_EVENT_WIFI_READY, NULL}, {SYSTEM_EVENT_WIFI_READY, NULL},
@ -65,7 +70,7 @@ static system_event_handle_t g_system_event_handle_table[] = {
{SYSTEM_EVENT_STA_CONNECTED, system_event_sta_connected_handle_default}, {SYSTEM_EVENT_STA_CONNECTED, system_event_sta_connected_handle_default},
{SYSTEM_EVENT_STA_DISCONNECTED, system_event_sta_disconnected_handle_default}, {SYSTEM_EVENT_STA_DISCONNECTED, system_event_sta_disconnected_handle_default},
{SYSTEM_EVENT_STA_AUTHMODE_CHANGE, NULL}, {SYSTEM_EVENT_STA_AUTHMODE_CHANGE, NULL},
{SYSTEM_EVENT_STA_GOT_IP, system_event_sta_gotip_default}, {SYSTEM_EVENT_STA_GOT_IP, system_event_sta_got_ip_default},
{SYSTEM_EVENT_AP_START, system_event_ap_start_handle_default}, {SYSTEM_EVENT_AP_START, system_event_ap_start_handle_default},
{SYSTEM_EVENT_AP_STOP, system_event_ap_stop_handle_default}, {SYSTEM_EVENT_AP_STOP, system_event_ap_stop_handle_default},
{SYSTEM_EVENT_AP_STACONNECTED, NULL}, {SYSTEM_EVENT_AP_STACONNECTED, NULL},
@ -74,15 +79,15 @@ static system_event_handle_t g_system_event_handle_table[] = {
{SYSTEM_EVENT_MAX, NULL}, {SYSTEM_EVENT_MAX, NULL},
}; };
static esp_err_t system_event_sta_gotip_default(system_event_t *event) static esp_err_t system_event_sta_got_ip_default(system_event_t *event)
{ {
extern esp_err_t esp_wifi_set_sta_ip(void); extern esp_err_t esp_wifi_set_sta_ip(void);
WIFI_API_CALL_CHECK("esp_wifi_set_sta_ip", esp_wifi_set_sta_ip(), ESP_OK); WIFI_API_CALL_CHECK("esp_wifi_set_sta_ip", esp_wifi_set_sta_ip(), ESP_OK);
printf("ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR "\n", printf("ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR "\n",
IP2STR(&event->event_info.got_ip.ip_info.ip), IP2STR(&event->event_info.got_ip.ip_info.ip),
IP2STR(&event->event_info.got_ip.ip_info.netmask), IP2STR(&event->event_info.got_ip.ip_info.netmask),
IP2STR(&event->event_info.got_ip.ip_info.gw)); IP2STR(&event->event_info.got_ip.ip_info.gw));
return ESP_OK; return ESP_OK;
} }
@ -132,7 +137,7 @@ esp_err_t system_event_sta_stop_handle_default(system_event_t *event)
esp_err_t system_event_sta_connected_handle_default(system_event_t *event) esp_err_t system_event_sta_connected_handle_default(system_event_t *event)
{ {
tcpip_adapter_dhcp_status_t status; tcpip_adapter_dhcp_status_t status;
WIFI_API_CALL_CHECK("esp_wifi_reg_rxcb", esp_wifi_reg_rxcb(WIFI_IF_STA, (wifi_rxcb_t)tcpip_adapter_sta_input), ESP_OK); WIFI_API_CALL_CHECK("esp_wifi_reg_rxcb", esp_wifi_reg_rxcb(WIFI_IF_STA, (wifi_rxcb_t)tcpip_adapter_sta_input), ESP_OK);
tcpip_adapter_up(TCPIP_ADAPTER_IF_STA); tcpip_adapter_up(TCPIP_ADAPTER_IF_STA);
@ -172,7 +177,7 @@ esp_err_t system_event_sta_disconnected_handle_default(system_event_t *event)
static esp_err_t esp_wifi_post_event_to_user(system_event_t *event) static esp_err_t esp_wifi_post_event_to_user(system_event_t *event)
{ {
if (g_event_handler_cb) { if (g_event_handler_cb) {
return (*g_event_handler_cb)(event); return (*g_event_handler_cb)(g_event_ctx, event);
} }
return ESP_OK; return ESP_OK;
@ -187,102 +192,88 @@ static esp_err_t esp_system_event_debug(system_event_t *event)
WIFI_DEBUG("received event: "); WIFI_DEBUG("received event: ");
switch (event->event_id) { switch (event->event_id) {
case SYSTEM_EVENT_WIFI_READY: case SYSTEM_EVENT_WIFI_READY: {
{ WIFI_DEBUG("SYSTEM_EVENT_WIFI_READY\n");
WIFI_DEBUG("SYSTEM_EVENT_WIFI_READY\n"); break;
break; }
} case SYSTEM_EVENT_SCAN_DONE: {
case SYSTEM_EVENT_SCAN_DONE: system_event_sta_scan_done_t *scan_done;
{ scan_done = &event->event_info.scan_done;
system_event_sta_scan_done_t *scan_done; WIFI_DEBUG("SYSTEM_EVENT_SCAN_DONE\nstatus:%d, number:%d\n", scan_done->status, scan_done->number);
scan_done = &event->event_info.scan_done; break;
WIFI_DEBUG("SYSTEM_EVENT_SCAN_DONE\nstatus:%d, number:%d\n", scan_done->status, scan_done->number); }
break; case SYSTEM_EVENT_STA_START: {
} WIFI_DEBUG("SYSTEM_EVENT_STA_START\n");
case SYSTEM_EVENT_STA_START: break;
{ }
WIFI_DEBUG("SYSTEM_EVENT_STA_START\n"); case SYSTEM_EVENT_STA_STOP: {
break; WIFI_DEBUG("SYSTEM_EVENT_STA_STOP\n");
} break;
case SYSTEM_EVENT_STA_STOP: }
{ case SYSTEM_EVENT_STA_CONNECTED: {
WIFI_DEBUG("SYSTEM_EVENT_STA_STOP\n"); system_event_sta_connected_t *connected;
break; connected = &event->event_info.connected;
} WIFI_DEBUG("SYSTEM_EVENT_STA_CONNECTED\nssid:%s, ssid_len:%d, bssid:%02x:%02x:%02x:%02x:%02x:%02x, channel:%d, authmode:%d\n", \
case SYSTEM_EVENT_STA_CONNECTED: connected->ssid, connected->ssid_len, connected->bssid[0], connected->bssid[0], connected->bssid[1], \
{ connected->bssid[3], connected->bssid[4], connected->bssid[5], connected->channel, connected->authmode);
system_event_sta_connected_t *connected; break;
connected = &event->event_info.connected; }
WIFI_DEBUG("SYSTEM_EVENT_STA_CONNECTED\nssid:%s, ssid_len:%d, bssid:%02x:%02x:%02x:%02x:%02x:%02x, channel:%d, authmode:%d\n", \ case SYSTEM_EVENT_STA_DISCONNECTED: {
connected->ssid, connected->ssid_len, connected->bssid[0], connected->bssid[0], connected->bssid[1], \ system_event_sta_disconnected_t *disconnected;
connected->bssid[3], connected->bssid[4], connected->bssid[5], connected->channel, connected->authmode); disconnected = &event->event_info.disconnected;
break; WIFI_DEBUG("SYSTEM_EVENT_STA_DISCONNECTED\nssid:%s, ssid_len:%d, bssid:%02x:%02x:%02x:%02x:%02x:%02x, reason:%d\n", \
} disconnected->ssid, disconnected->ssid_len, disconnected->bssid[0], disconnected->bssid[0], disconnected->bssid[1], \
case SYSTEM_EVENT_STA_DISCONNECTED: disconnected->bssid[3], disconnected->bssid[4], disconnected->bssid[5], disconnected->reason);
{ break;
system_event_sta_disconnected_t *disconnected; }
disconnected = &event->event_info.disconnected; case SYSTEM_EVENT_STA_AUTHMODE_CHANGE: {
WIFI_DEBUG("SYSTEM_EVENT_STA_DISCONNECTED\nssid:%s, ssid_len:%d, bssid:%02x:%02x:%02x:%02x:%02x:%02x, reason:%d\n", \ system_event_sta_authmode_change_t *auth_change;
disconnected->ssid, disconnected->ssid_len, disconnected->bssid[0], disconnected->bssid[0], disconnected->bssid[1], \ auth_change = &event->event_info.auth_change;
disconnected->bssid[3], disconnected->bssid[4], disconnected->bssid[5], disconnected->reason); WIFI_DEBUG("SYSTEM_EVENT_STA_AUTHMODE_CHNAGE\nold_mode:%d, new_mode:%d\n", auth_change->old_mode, auth_change->new_mode);
break; break;
} }
case SYSTEM_EVENT_STA_AUTHMODE_CHANGE: case SYSTEM_EVENT_STA_GOT_IP: {
{ system_event_sta_got_ip_t *got_ip;
system_event_sta_authmode_change_t *auth_change; got_ip = &event->event_info.got_ip;
auth_change = &event->event_info.auth_change; WIFI_DEBUG("SYSTEM_EVENT_STA_GOTIP\n");
WIFI_DEBUG("SYSTEM_EVENT_STA_AUTHMODE_CHNAGE\nold_mode:%d, new_mode:%d\n", auth_change->old_mode, auth_change->new_mode); break;
break; }
} case SYSTEM_EVENT_AP_START: {
case SYSTEM_EVENT_STA_GOT_IP: WIFI_DEBUG("SYSTEM_EVENT_AP_START\n");
{ break;
system_event_sta_got_ip_t *got_ip; }
got_ip = &event->event_info.got_ip; case SYSTEM_EVENT_AP_STOP: {
WIFI_DEBUG("SYSTEM_EVENT_STA_GOTIP\n"); WIFI_DEBUG("SYSTEM_EVENT_AP_STOP\n");
break; break;
} }
case SYSTEM_EVENT_AP_START: case SYSTEM_EVENT_AP_STACONNECTED: {
{ system_event_ap_staconnected_t *staconnected;
WIFI_DEBUG("SYSTEM_EVENT_AP_START\n"); staconnected = &event->event_info.sta_connected;
break; WIFI_DEBUG("SYSTEM_EVENT_AP_STACONNECTED\nmac:%02x:%02x:%02x:%02x:%02x:%02x, aid:%d\n", \
} staconnected->mac[0], staconnected->mac[0], staconnected->mac[1], \
case SYSTEM_EVENT_AP_STOP: staconnected->mac[3], staconnected->mac[4], staconnected->mac[5], staconnected->aid);
{ break;
WIFI_DEBUG("SYSTEM_EVENT_AP_STOP\n"); }
break; case SYSTEM_EVENT_AP_STADISCONNECTED: {
} system_event_ap_stadisconnected_t *stadisconnected;
case SYSTEM_EVENT_AP_STACONNECTED: stadisconnected = &event->event_info.sta_disconnected;
{ WIFI_DEBUG("SYSTEM_EVENT_AP_STADISCONNECTED\nmac:%02x:%02x:%02x:%02x:%02x:%02x, aid:%d\n", \
system_event_ap_staconnected_t *staconnected; stadisconnected->mac[0], stadisconnected->mac[0], stadisconnected->mac[1], \
staconnected = &event->event_info.sta_connected; stadisconnected->mac[3], stadisconnected->mac[4], stadisconnected->mac[5], stadisconnected->aid);
WIFI_DEBUG("SYSTEM_EVENT_AP_STACONNECTED\nmac:%02x:%02x:%02x:%02x:%02x:%02x, aid:%d\n", \ break;
staconnected->mac[0], staconnected->mac[0], staconnected->mac[1], \ }
staconnected->mac[3], staconnected->mac[4], staconnected->mac[5], staconnected->aid); case SYSTEM_EVENT_AP_PROBEREQRECVED: {
break; system_event_ap_probe_req_rx_t *ap_probereqrecved;
} ap_probereqrecved = &event->event_info.ap_probereqrecved;
case SYSTEM_EVENT_AP_STADISCONNECTED: WIFI_DEBUG("SYSTEM_EVENT_AP_PROBEREQRECVED\nrssi:%d, mac:%02x:%02x:%02x:%02x:%02x:%02x\n", \
{ ap_probereqrecved->rssi, ap_probereqrecved->mac[0], ap_probereqrecved->mac[0], ap_probereqrecved->mac[1], \
system_event_ap_stadisconnected_t *stadisconnected; ap_probereqrecved->mac[3], ap_probereqrecved->mac[4], ap_probereqrecved->mac[5]);
stadisconnected = &event->event_info.sta_disconnected; break;
WIFI_DEBUG("SYSTEM_EVENT_AP_STADISCONNECTED\nmac:%02x:%02x:%02x:%02x:%02x:%02x, aid:%d\n", \ }
stadisconnected->mac[0], stadisconnected->mac[0], stadisconnected->mac[1], \ default: {
stadisconnected->mac[3], stadisconnected->mac[4], stadisconnected->mac[5], stadisconnected->aid); printf("Error: no such kind of event!\n");
break; break;
} }
case SYSTEM_EVENT_AP_PROBEREQRECVED:
{
system_event_ap_probe_req_rx_t *ap_probereqrecved;
ap_probereqrecved = &event->event_info.ap_probereqrecved;
WIFI_DEBUG("SYSTEM_EVENT_AP_PROBEREQRECVED\nrssi:%d, mac:%02x:%02x:%02x:%02x:%02x:%02x\n", \
ap_probereqrecved->rssi, ap_probereqrecved->mac[0], ap_probereqrecved->mac[0], ap_probereqrecved->mac[1], \
ap_probereqrecved->mac[3], ap_probereqrecved->mac[4], ap_probereqrecved->mac[5]);
break;
}
default:
{
printf("Error: no such kind of event!\n");
break;
}
} }
return ESP_OK; return ESP_OK;
@ -296,8 +287,8 @@ static esp_err_t esp_system_event_handler(system_event_t *event)
} }
esp_system_event_debug(event); esp_system_event_debug(event);
if ((event->event_id < SYSTEM_EVENT_MAX) && (event->event_id == g_system_event_handle_table[event->event_id].event_id)){ if ((event->event_id < SYSTEM_EVENT_MAX) && (event->event_id == g_system_event_handle_table[event->event_id].event_id)) {
if (g_system_event_handle_table[event->event_id].event_handle){ if (g_system_event_handle_table[event->event_id].event_handle) {
WIFI_DEBUG("enter default callback\n"); WIFI_DEBUG("enter default callback\n");
g_system_event_handle_table[event->event_id].event_handle(event); g_system_event_handle_table[event->event_id].event_handle(event);
WIFI_DEBUG("exit default callback\n"); WIFI_DEBUG("exit default callback\n");
@ -317,42 +308,57 @@ static void esp_system_event_task(void *pvParameters)
while (1) { while (1) {
if (xQueueReceive(g_event_handler, &evt, portMAX_DELAY) == pdPASS) { if (xQueueReceive(g_event_handler, &evt, portMAX_DELAY) == pdPASS) {
ret = esp_system_event_handler(&evt); ret = esp_system_event_handler(&evt);
if (ret == ESP_FAIL) if (ret == ESP_FAIL) {
printf("esp wifi post event to user fail!\n"); printf("esp wifi post event to user fail!\n");
}
} }
} }
} }
system_event_cb_t esp_event_set_cb(system_event_cb_t cb) system_event_cb_t esp_event_set_cb(system_event_cb_t cb, void *ctx)
{ {
system_event_cb_t old_cb = g_event_handler_cb; system_event_cb_t old_cb = g_event_handler_cb;
g_event_handler_cb = cb; g_event_handler_cb = cb;
g_event_ctx = ctx;
return old_cb; return old_cb;
} }
esp_err_t esp_event_send(system_event_t *event) esp_err_t esp_event_send(system_event_t *event)
{ {
portBASE_TYPE ret; portBASE_TYPE ret;
ret = xQueueSendToBack((xQueueHandle)g_event_handler, event, 0); ret = xQueueSendToBack((xQueueHandle)g_event_handler, event, 0);
if (pdPASS != ret){
if (event) printf("e=%d f\n", event->event_id); if (pdPASS != ret) {
else printf("e null\n"); if (event) {
printf("e=%d f\n", event->event_id);
} else {
printf("e null\n");
}
return ESP_FAIL; return ESP_FAIL;
} }
return ESP_OK; return ESP_OK;
} }
void* esp_event_get_handler(void) void *esp_event_get_handler(void)
{ {
return (void*)g_event_handler; return (void *)g_event_handler;
} }
esp_err_t esp_event_init(system_event_cb_t cb) esp_err_t esp_event_init(system_event_cb_t cb, void *ctx)
{ {
g_event_handler_cb = (system_event_cb_t)cb; if (event_init_flag) {
return ESP_FAIL;
}
g_event_handler_cb = cb;
g_event_ctx = ctx;
g_event_handler = xQueueCreate(CONFIG_WIFI_ENENT_QUEUE_SIZE, sizeof(system_event_t)); g_event_handler = xQueueCreate(CONFIG_WIFI_ENENT_QUEUE_SIZE, sizeof(system_event_t));
xTaskCreatePinnedToCore(esp_system_event_task, "eventTask", CONFIG_WIFI_EVENT_TASK_STACK_SIZE, NULL, 5, NULL, 0); // TODO: rearrange task priority xTaskCreatePinnedToCore(esp_system_event_task, "eventTask", CONFIG_WIFI_EVENT_TASK_STACK_SIZE, NULL, 5, NULL, 0); // TODO: rearrange task priority
return ESP_OK; return ESP_OK;
} }

13
components/esp32/include/esp_event.h
View File

@ -108,12 +108,13 @@ typedef struct {
/** /**
* @brief Application specified event callback function * @brief Application specified event callback function
* *
* @param void *param : parameter passed to callback function * @param void *ctx : reversed for user
* @param system_event_t *event : event type defined in this file
* *
* @return ESP_OK : succeed * @return ESP_OK : succeed
* @return others : fail * @return others : fail
*/ */
typedef esp_err_t (*system_event_cb_t)(void *param); typedef esp_err_t (*system_event_cb_t)(void *ctx, system_event_t *event);
/** /**
* @brief Set application specified event callback function * @brief Set application specified event callback function
@ -122,17 +123,17 @@ typedef esp_err_t (*system_event_cb_t)(void *param);
* If cb is not NULL, it will be call when an event is received, after the default event callback is completed * If cb is not NULL, it will be call when an event is received, after the default event callback is completed
* *
* @param system_event_cb_t cb : callback * @param system_event_cb_t cb : callback
* @param void *ctx : reversed for user
* *
* @return system_event_cb_t : old callback * @return system_event_cb_t : old callback
*/ */
system_event_cb_t esp_event_set_cb(system_event_cb_t cb); system_event_cb_t esp_event_set_cb(system_event_cb_t cb, void *ctx);
/** /**
* @brief Send a event to event task * @brief Send a event to event task
* *
* @attention 1. Other task/modules, such as the TCPIP module, can call this API to send an event to event task * @attention 1. Other task/modules, such as the TCPIP module, can call this API to send an event to event task
* *
*
* @param system_event_t * event : event * @param system_event_t * event : event
* *
* @return ESP_OK : succeed * @return ESP_OK : succeed
@ -145,7 +146,6 @@ esp_err_t esp_event_send(system_event_t *event);
* *
* @attention : currently this API returns event queue handler, generally this handler is used to * @attention : currently this API returns event queue handler, generally this handler is used to
* *
*
* @param null * @param null
* *
* @return void* : event queue pointer * @return void* : event queue pointer
@ -157,11 +157,12 @@ void *esp_event_get_handler(void);
* Create the event handler and task * Create the event handler and task
* *
* @param system_event_cb_t cb : application specified event callback, it can be modified by call esp_event_set_cb * @param system_event_cb_t cb : application specified event callback, it can be modified by call esp_event_set_cb
* @param void *ctx : reversed for user
* *
* @return ESP_OK : succeed * @return ESP_OK : succeed
* @return others : fail * @return others : fail
*/ */
esp_err_t esp_event_init(system_event_cb_t cb); esp_err_t esp_event_init(system_event_cb_t cb, void *ctx);
#ifdef __cplusplus #ifdef __cplusplus
} }

6
components/esp32/include/esp_wifi.h
View File

@ -149,12 +149,14 @@ typedef enum {
* be called firstly * be called firstly
* *
* @param wifi_startup_cb_t cb : application specific callback function * @param wifi_startup_cb_t cb : application specific callback function
* @param void *ctx : reversed for user
* *
* @return ESP_OK : succeed * @return ESP_OK : succeed
* @return others : fail * @return others : fail
*/ */
typedef esp_err_t (* wifi_startup_cb_t)(void *param); typedef esp_err_t (* wifi_startup_cb_t)(void *ctx);
void esp_wifi_startup(wifi_startup_cb_t cb);
esp_err_t esp_wifi_startup(wifi_startup_cb_t cb, void *ctx);
typedef struct { typedef struct {
void *event_q; /**< WiFi event q handler, it's a freeRTOS queue */ void *event_q; /**< WiFi event q handler, it's a freeRTOS queue */

22
components/esp32/wifi.c
View File

@ -11,6 +11,7 @@
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
@ -26,9 +27,12 @@
#if CONFIG_WIFI_ENABLED #if CONFIG_WIFI_ENABLED
static wifi_startup_cb_t startup_cb; static bool wifi_startup_flag = false;
#define WIFI_DEBUG(...) static wifi_startup_cb_t startup_cb;
static void *startup_ctx;
#define WIFI_DEBUG(...)
#define WIFI_API_CALL_CHECK(info, api_call, ret) \ #define WIFI_API_CALL_CHECK(info, api_call, ret) \
do{\ do{\
esp_err_t __err = (api_call);\ esp_err_t __err = (api_call);\
@ -54,7 +58,7 @@ static void esp_wifi_task(void *pvParameters)
} }
if (startup_cb) { if (startup_cb) {
err = (*startup_cb)(NULL); err = (*startup_cb)(startup_ctx);
if (err != ESP_OK) { if (err != ESP_OK) {
WIFI_DEBUG("startup_cb fail, ret=%d\n", err); WIFI_DEBUG("startup_cb fail, ret=%d\n", err);
break; break;
@ -71,7 +75,7 @@ static void esp_wifi_task(void *pvParameters)
wifi_mode_t mode; wifi_mode_t mode;
bool auto_connect; bool auto_connect;
err = esp_wifi_get_mode(&mode); err = esp_wifi_get_mode(&mode);
if (err != ESP_OK){ if (err != ESP_OK) {
WIFI_DEBUG("esp_wifi_get_mode fail, ret=%d\n", err); WIFI_DEBUG("esp_wifi_get_mode fail, ret=%d\n", err);
} }
@ -94,9 +98,17 @@ static void esp_wifi_task(void *pvParameters)
vTaskDelete(NULL); vTaskDelete(NULL);
} }
void esp_wifi_startup(wifi_startup_cb_t cb) esp_err_t esp_wifi_startup(wifi_startup_cb_t cb, void *ctx)
{ {
if (wifi_startup_flag) {
return ESP_FAIL;
}
startup_cb = cb; startup_cb = cb;
startup_ctx = ctx;
xTaskCreatePinnedToCore(esp_wifi_task, "wifiTask", 4096, NULL, 5, NULL, 0);// TODO: rearrange task priority xTaskCreatePinnedToCore(esp_wifi_task, "wifiTask", 4096, NULL, 5, NULL, 0);// TODO: rearrange task priority
return ESP_OK;
} }
#endif #endif