feat(esp_event): add esp_event components from esp-idf

Commit ID: 463a9d8b

components/esp_event/CMakeLists.txt

@@ -0,0 +1,15 @@
+idf_component_register(SRCS "default_event_loop.c"
+                            "esp_event.c"
+                            "esp_event_private.c"
+                            "event_loop_legacy.c"
+                            "event_send.c"
+                    INCLUDE_DIRS "include"
+                    PRIV_INCLUDE_DIRS "private_include"
+                    REQUIRES log tcpip_adapter
+                    PRIV_REQUIRES esp_eth
+                    LDFRAGMENTS linker.lf)
+
+if(GCC_NOT_5_2_0 AND CONFIG_ESP_EVENT_LOOP_PROFILING)
+    # uses C11 atomic feature
+    set_source_files_properties(esp_event.c PROPERTIES COMPILE_FLAGS -std=gnu11)
+endif()

components/esp_event/Kconfig

@@ -0,0 +1,25 @@
+menu "Event Loop Library"
+
+    config ESP_EVENT_LOOP_PROFILING
+        bool "Enable event loop profiling"
+        default n
+        help
+            Enables collections of statistics in the event loop library such as the number of events posted
+            to/recieved by an event loop, number of callbacks involved, number of events dropped to to a full event
+            loop queue, run time of event handlers, and number of times/run time of each event handler.
+
+    config ESP_EVENT_POST_FROM_ISR
+        bool "Support posting events from ISRs"
+        default y
+        help
+            Enable posting events from interrupt handlers.
+
+    config ESP_EVENT_POST_FROM_IRAM_ISR
+        bool "Support posting events from ISRs placed in IRAM"
+        default y
+        depends on ESP_EVENT_POST_FROM_ISR
+        help
+            Enable posting events from interrupt handlers placed in IRAM. Enabling this option places API functions
+            esp_event_post and esp_event_post_to in IRAM.
+
+endmenu

components/esp_event/component.mk

@@ -0,0 +1,18 @@
+#
+# Component Makefile
+#
+COMPONENT_ADD_INCLUDEDIRS := include
+COMPONENT_PRIV_INCLUDEDIRS := private_include
+COMPONENT_SRCDIRS := .
+COMPONENT_ADD_LDFRAGMENTS := linker.lf
+
+ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+	PROFILING_ENABLED := 1
+else
+	PROFILING_ENABLED := 0
+endif
+
+ifeq ($(and $(GCC_NOT_5_2_0),$(PROFILING_ENABLED)), 1)
+# uses C11 atomic feature
+esp_event.o: CFLAGS += -std=gnu11
+endif

components/esp_event/default_event_loop.c

@@ -0,0 +1,120 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp_event.h"
+#include "esp_event_internal.h"
+#include "esp_task.h"
+
+/* ------------------------- Static Variables ------------------------------- */
+
+static esp_event_loop_handle_t s_default_loop = NULL;
+
+/* ---------------------------- Public API ---------------------------------- */
+
+esp_err_t esp_event_handler_register(esp_event_base_t event_base, int32_t event_id,
+        esp_event_handler_t event_handler, void* event_handler_arg)
+{
+    if (s_default_loop == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    return esp_event_handler_register_with(s_default_loop, event_base, event_id,
+            event_handler, event_handler_arg);
+}
+
+esp_err_t esp_event_handler_unregister(esp_event_base_t event_base, int32_t event_id,
+        esp_event_handler_t event_handler)
+{
+    if (s_default_loop == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    return esp_event_handler_unregister_with(s_default_loop, event_base, event_id,
+            event_handler);
+}
+
+esp_err_t esp_event_post(esp_event_base_t event_base, int32_t event_id,
+        void* event_data, size_t event_data_size, TickType_t ticks_to_wait)
+{
+    if (s_default_loop == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    return esp_event_post_to(s_default_loop, event_base, event_id,
+            event_data, event_data_size, ticks_to_wait);
+}
+
+
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+esp_err_t esp_event_isr_post(esp_event_base_t event_base, int32_t event_id,
+        void* event_data, size_t event_data_size, BaseType_t* task_unblocked)
+{
+    if (s_default_loop == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    return esp_event_isr_post_to(s_default_loop, event_base, event_id,
+            event_data, event_data_size, task_unblocked);
+}
+#endif
+
+
+esp_err_t esp_event_loop_create_default()
+{
+    if (s_default_loop) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_event_loop_args_t loop_args = {
+        .queue_size = CONFIG_ESP_SYSTEM_EVENT_QUEUE_SIZE,
+        .task_name = "sys_evt",
+        .task_stack_size = ESP_TASKD_EVENT_STACK,
+        .task_priority = ESP_TASKD_EVENT_PRIO,
+        .task_core_id = 0
+    };
+
+    esp_err_t err;
+
+    err = esp_event_loop_create(&loop_args, &s_default_loop);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_event_loop_delete_default()
+{
+    if (!s_default_loop) {
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t err;
+
+    err = esp_event_loop_delete(s_default_loop);
+
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    s_default_loop = NULL;
+
+    return ESP_OK;
+}
+
+
+/* Include the code to forward legacy system_event_t events to the this default
+ * event loop.
+ */
+#include "event_send_compat.inc"

components/esp_event/esp_event.c

@@ -0,0 +1,944 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#include "esp_log.h"
+
+#include "esp_event.h"
+#include "esp_event_internal.h"
+#include "esp_event_private.h"
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+#include "esp_timer.h"
+#endif
+
+/* ---------------------------- Definitions --------------------------------- */
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+// LOOP @<address, name> rx:<recieved events no.> dr:<dropped events no.>
+#define LOOP_DUMP_FORMAT              "LOOP @%p,%s rx:%u dr:%u\n"
+ // handler @<address> ev:<base, id> inv:<times invoked> time:<runtime>
+#define HANDLER_DUMP_FORMAT           "  HANDLER @%p ev:%s,%s inv:%u time:%lld us\n"
+
+#define PRINT_DUMP_INFO(dst, sz, ...)  do { \
+                                            int cb = snprintf(dst, sz, __VA_ARGS__); \
+                                            dst += cb; \
+                                            sz -= cb; \
+                                        } while(0);
+#endif
+
+/* ------------------------- Static Variables ------------------------------- */
+
+static const char* TAG = "event";
+static const char* esp_event_any_base = "any";
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+static SLIST_HEAD(esp_event_loop_instance_list_t, esp_event_loop_instance) s_event_loops =
+        SLIST_HEAD_INITIALIZER(s_event_loops);
+
+static portMUX_TYPE s_event_loops_spinlock = portMUX_INITIALIZER_UNLOCKED;
+#endif
+
+
+/* ------------------------- Static Functions ------------------------------- */
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+
+
+static int esp_event_dump_prepare()
+{
+    esp_event_loop_instance_t* loop_it;
+    esp_event_loop_node_t *loop_node_it;
+    esp_event_base_node_t* base_node_it;
+    esp_event_id_node_t* id_node_it;
+    esp_event_handler_instance_t* handler_it;
+
+    // Count the number of items to be printed. This is needed to compute how much memory to reserve.
+    int loops = 0, handlers = 0;
+
+    portENTER_CRITICAL(&s_event_loops_spinlock);
+
+    SLIST_FOREACH(loop_it, &s_event_loops, next) {
+        SLIST_FOREACH(loop_node_it, &(loop_it->loop_nodes), next) {
+            SLIST_FOREACH(handler_it, &(loop_node_it->handlers), next) {
+                handlers++;
+            }
+
+            SLIST_FOREACH(base_node_it, &(loop_node_it->base_nodes), next) {
+                SLIST_FOREACH(handler_it, &(base_node_it->handlers), next) {
+                    handlers++;
+                }
+                SLIST_FOREACH(id_node_it, &(base_node_it->id_nodes), next) {
+                    SLIST_FOREACH(handler_it, &(id_node_it->handlers), next) {
+                        handlers++;
+                    }
+                }
+            }
+        }
+        loops++;
+    }
+
+    portEXIT_CRITICAL(&s_event_loops_spinlock);
+
+    // Reserve slightly more memory than computed
+    int allowance = 3;
+    int size = (((loops + allowance) * (sizeof(LOOP_DUMP_FORMAT) + 10 + 20 + 2 * 11)) +
+                        ((handlers + allowance) * (sizeof(HANDLER_DUMP_FORMAT) + 10 + 2 * 20 + 11 + 20)));
+
+    return size;
+}
+#endif
+
+static void esp_event_loop_run_task(void* args)
+{
+    esp_err_t err;
+    esp_event_loop_handle_t event_loop = (esp_event_loop_handle_t) args;
+
+    ESP_LOGD(TAG, "running task for loop %p", event_loop);
+
+    while(1) {
+        err = esp_event_loop_run(event_loop, portMAX_DELAY);
+        if (err != ESP_OK) {
+            break;
+        }
+    }
+
+    ESP_LOGE(TAG, "suspended task for loop %p", event_loop);
+    vTaskSuspend(NULL);
+}
+
+static void handler_execute(esp_event_loop_instance_t* loop, esp_event_handler_instance_t *handler, esp_event_post_instance_t post)
+{
+    ESP_LOGD(TAG, "running post %s:%d with handler %p on loop %p", post.base, post.id, handler->handler, loop);
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    int64_t start, diff;
+    start = esp_timer_get_time();
+#endif
+    // Execute the handler
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+    void* data_ptr = NULL;
+
+    if (post.data_set) {
+        if (post.data_allocated) {
+            data_ptr = post.data.ptr;
+        } else {
+            data_ptr = &post.data.val;
+        }
+    }
+
+    (*(handler->handler))(handler->arg, post.base, post.id, data_ptr);
+#else
+    (*(handler->handler))(handler->arg, post.base, post.id, post.data);
+#endif
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    diff = esp_timer_get_time() - start;
+
+    xSemaphoreTake(loop->profiling_mutex, portMAX_DELAY);
+
+    handler->invoked++;
+    handler->time += diff;
+
+    xSemaphoreGive(loop->profiling_mutex);
+#endif
+}
+
+static esp_err_t handler_instances_add(esp_event_handler_instances_t* handlers, esp_event_handler_t handler, void* handler_arg)
+{
+    esp_event_handler_instance_t* handler_instance = calloc(1, sizeof(*handler_instance));
+
+    if (!handler_instance) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    handler_instance->handler = handler;
+    handler_instance->arg = handler_arg;
+
+    if (SLIST_EMPTY(handlers)) {
+        SLIST_INSERT_HEAD(handlers, handler_instance, next);
+    }
+    else {
+        esp_event_handler_instance_t *it = NULL, *last = NULL;
+
+        SLIST_FOREACH(it, handlers, next) {
+            if (handler == it->handler) {
+                it->arg = handler_arg;
+                ESP_LOGW(TAG, "handler already registered, overwriting");
+                free(handler_instance);
+                return ESP_OK;
+            }
+            last = it;
+        }
+
+        SLIST_INSERT_AFTER(last, handler_instance, next);
+    }
+
+    return ESP_OK;
+}
+
+static esp_err_t base_node_add_handler(esp_event_base_node_t* base_node, int32_t id, esp_event_handler_t handler, void* handler_arg)
+{
+    if (id == ESP_EVENT_ANY_ID) {
+        return handler_instances_add(&(base_node->handlers), handler, handler_arg);
+    }
+    else {
+        esp_err_t err = ESP_OK;
+        esp_event_id_node_t *it = NULL, *id_node = NULL, *last_id_node = NULL;
+
+        SLIST_FOREACH(it, &(base_node->id_nodes), next) {
+            if (it->id == id) {
+                id_node = it;
+            }
+            last_id_node = it;
+        }
+
+        if (!last_id_node || !id_node) {
+            id_node = (esp_event_id_node_t*) calloc(1, sizeof(*id_node));
+
+            if (!id_node) {
+                ESP_LOGE(TAG, "alloc for new id node failed");
+                return ESP_ERR_NO_MEM;
+            }
+
+            id_node->id = id;
+
+            SLIST_INIT(&(id_node->handlers));
+
+            err = handler_instances_add(&(id_node->handlers), handler, handler_arg);
+
+            if (err == ESP_OK) {
+                if (!last_id_node) {
+                    SLIST_INSERT_HEAD(&(base_node->id_nodes), id_node, next);
+                }
+                else {
+                    SLIST_INSERT_AFTER(last_id_node, id_node, next);
+                }
+            } else {
+                free(id_node);
+            }
+
+            return err;
+        }
+        else {
+            return handler_instances_add(&(id_node->handlers), handler, handler_arg);
+        }
+    }
+}
+
+static esp_err_t loop_node_add_handler(esp_event_loop_node_t* loop_node, esp_event_base_t base, int32_t id, esp_event_handler_t handler, void* handler_arg)
+{
+    if (base == esp_event_any_base && id == ESP_EVENT_ANY_ID) {
+        return handler_instances_add(&(loop_node->handlers), handler, handler_arg);
+    }
+    else {
+        esp_err_t err = ESP_OK;
+        esp_event_base_node_t *it = NULL, *base_node = NULL, *last_base_node = NULL;
+
+        SLIST_FOREACH(it, &(loop_node->base_nodes), next) {
+            if (it->base == base) {
+                base_node = it;
+            }
+            last_base_node = it;
+        }
+
+        if (!last_base_node ||
+        	!base_node ||
+            (base_node && !SLIST_EMPTY(&(base_node->id_nodes)) && id == ESP_EVENT_ANY_ID) ||
+            (last_base_node && last_base_node->base != base && !SLIST_EMPTY(&(last_base_node->id_nodes)) && id == ESP_EVENT_ANY_ID)) {
+            base_node = (esp_event_base_node_t*) calloc(1, sizeof(*base_node));
+
+            if (!base_node) {
+                ESP_LOGE(TAG, "alloc mem for new base node failed");
+                return ESP_ERR_NO_MEM;
+            }
+
+            base_node->base = base;
+
+            SLIST_INIT(&(base_node->handlers));
+            SLIST_INIT(&(base_node->id_nodes));
+
+            err = base_node_add_handler(base_node, id, handler, handler_arg);
+
+            if (err == ESP_OK) {
+                if (!last_base_node) {
+                    SLIST_INSERT_HEAD(&(loop_node->base_nodes), base_node, next);
+                }
+                else {
+                    SLIST_INSERT_AFTER(last_base_node, base_node, next);
+                }
+            } else {
+                free(base_node);
+            }
+
+            return err;
+        } else {
+            return base_node_add_handler(base_node, id, handler, handler_arg);
+        }
+    }
+}
+
+static esp_err_t handler_instances_remove(esp_event_handler_instances_t* handlers, esp_event_handler_t handler)
+{
+    esp_event_handler_instance_t *it, *temp;
+
+    SLIST_FOREACH_SAFE(it, handlers, next, temp) {
+        if (it->handler == handler) {
+            SLIST_REMOVE(handlers, it, esp_event_handler_instance, next);
+            free(it);
+            return ESP_OK;
+        }
+    }
+
+    return ESP_ERR_NOT_FOUND;
+}
+
+
+static esp_err_t base_node_remove_handler(esp_event_base_node_t* base_node, int32_t id, esp_event_handler_t handler)
+{
+    if (id == ESP_EVENT_ANY_ID) {
+        return handler_instances_remove(&(base_node->handlers), handler);
+    }
+    else {
+        esp_event_id_node_t *it, *temp;
+        SLIST_FOREACH_SAFE(it, &(base_node->id_nodes), next, temp) {
+            if (it->id == id) {
+                esp_err_t res = handler_instances_remove(&(it->handlers), handler);
+
+                if (res == ESP_OK) {
+                    if (SLIST_EMPTY(&(it->handlers))) {
+                        SLIST_REMOVE(&(base_node->id_nodes), it, esp_event_id_node, next);
+                        free(it);
+                        return ESP_OK;
+                    }
+                }
+            }
+        }
+    }
+
+    return ESP_ERR_NOT_FOUND;
+}
+
+static esp_err_t loop_node_remove_handler(esp_event_loop_node_t* loop_node, esp_event_base_t base, int32_t id, esp_event_handler_t handler)
+{
+    if (base == esp_event_any_base && id == ESP_EVENT_ANY_ID) {
+        return handler_instances_remove(&(loop_node->handlers), handler);
+    }
+    else {
+        esp_event_base_node_t *it, *temp;
+        SLIST_FOREACH_SAFE(it, &(loop_node->base_nodes), next, temp) {
+            if (it->base == base) {
+                esp_err_t res = base_node_remove_handler(it, id, handler);
+
+                if (res == ESP_OK) {
+                    if (SLIST_EMPTY(&(it->handlers)) && SLIST_EMPTY(&(it->id_nodes))) {
+                        SLIST_REMOVE(&(loop_node->base_nodes), it, esp_event_base_node, next);
+                        free(it);
+                        return ESP_OK;
+                    }
+                }
+            }
+        }
+    }
+
+    return ESP_ERR_NOT_FOUND;
+}
+
+static void handler_instances_remove_all(esp_event_handler_instances_t* handlers)
+{
+    esp_event_handler_instance_t *it, *temp;
+    SLIST_FOREACH_SAFE(it, handlers, next, temp) {
+        SLIST_REMOVE(handlers, it, esp_event_handler_instance, next);
+        free(it);
+    }
+}
+
+static void base_node_remove_all_handler(esp_event_base_node_t* base_node)
+{
+    handler_instances_remove_all(&(base_node->handlers));
+
+    esp_event_id_node_t *it, *temp;
+    SLIST_FOREACH_SAFE(it, &(base_node->id_nodes), next, temp) {
+        handler_instances_remove_all(&(it->handlers));
+        SLIST_REMOVE(&(base_node->id_nodes), it, esp_event_id_node, next);
+        free(it);
+    }
+}
+
+static void loop_node_remove_all_handler(esp_event_loop_node_t* loop_node)
+{
+    handler_instances_remove_all(&(loop_node->handlers));
+
+    esp_event_base_node_t *it, *temp;
+    SLIST_FOREACH_SAFE(it, &(loop_node->base_nodes), next, temp) {
+        base_node_remove_all_handler(it);
+        SLIST_REMOVE(&(loop_node->base_nodes), it, esp_event_base_node, next);
+        free(it);
+    }
+}
+
+static void inline __attribute__((always_inline)) post_instance_delete(esp_event_post_instance_t* post)
+{
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+    if (post->data_allocated && post->data.ptr) {
+        free(post->data.ptr);
+    }
+#else
+    if (post->data) {
+        free(post->data);
+    }
+#endif
+    memset(post, 0, sizeof(*post));
+}
+
+/* ---------------------------- Public API --------------------------------- */
+
+esp_err_t esp_event_loop_create(const esp_event_loop_args_t* event_loop_args, esp_event_loop_handle_t* event_loop)
+{
+    assert(event_loop_args);
+
+    esp_event_loop_instance_t* loop;
+    esp_err_t err = ESP_ERR_NO_MEM; // most likely error
+
+    loop = calloc(1, sizeof(*loop));
+    if (loop == NULL) {
+        ESP_LOGE(TAG, "alloc for event loop failed");
+        return err;
+    }
+
+    loop->queue = xQueueCreate(event_loop_args->queue_size , sizeof(esp_event_post_instance_t));
+    if (loop->queue == NULL) {
+        ESP_LOGE(TAG, "create event loop queue failed");
+        goto on_err;
+    }
+
+    loop->mutex = xSemaphoreCreateRecursiveMutex();
+    if (loop->mutex == NULL) {
+        ESP_LOGE(TAG, "create event loop mutex failed");
+        goto on_err;
+    }
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    loop->profiling_mutex = xSemaphoreCreateMutex();
+    if (loop->profiling_mutex == NULL) {
+        ESP_LOGE(TAG, "create event loop profiling mutex failed");
+        goto on_err;
+    }
+#endif
+
+    SLIST_INIT(&(loop->loop_nodes));
+
+    // Create the loop task if requested
+    if (event_loop_args->task_name != NULL) {
+        BaseType_t task_created = xTaskCreatePinnedToCore(esp_event_loop_run_task, event_loop_args->task_name,
+                    event_loop_args->task_stack_size, (void*) loop,
+                    event_loop_args->task_priority, &(loop->task), event_loop_args->task_core_id);
+
+        if (task_created != pdPASS) {
+            ESP_LOGE(TAG, "create task for loop failed");
+            err = ESP_FAIL;
+            goto on_err;
+        }
+
+        loop->name = event_loop_args->task_name;
+
+        ESP_LOGD(TAG, "created task for loop %p", loop);
+    } else {
+        loop->name = "";
+        loop->task = NULL;
+    }
+
+    loop->running_task = NULL;
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    portENTER_CRITICAL(&s_event_loops_spinlock);
+    SLIST_INSERT_HEAD(&s_event_loops, loop, next);
+    portEXIT_CRITICAL(&s_event_loops_spinlock);
+#endif
+
+    *event_loop = (esp_event_loop_handle_t) loop;
+
+    ESP_LOGD(TAG, "created event loop %p", loop);
+
+    return ESP_OK;
+
+on_err:
+    if (loop->queue != NULL) {
+        vQueueDelete(loop->queue);
+    }
+
+    if (loop->mutex != NULL) {
+        vSemaphoreDelete(loop->mutex);
+    }
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    if (loop->profiling_mutex != NULL) {
+        vSemaphoreDelete(loop->profiling_mutex);
+    }
+#endif
+
+    free(loop);
+
+    return err;
+}
+
+// On event lookup performance: The library implements the event list as a linked list, which results to O(n)
+// lookup time. The test comparing this implementation to the O(lg n) performance of rbtrees
+// (https://github.com/freebsd/freebsd/blob/master/sys/sys/tree.h)
+// indicate that the difference is not that substantial, especially considering the additional
+// pointers per node of rbtrees. Code for the rbtree implementation of the event loop library is archived
+// in feature/esp_event_loop_library_rbtrees if needed.
+esp_err_t esp_event_loop_run(esp_event_loop_handle_t event_loop, TickType_t ticks_to_run)
+{
+    assert(event_loop);
+
+    esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
+    esp_event_post_instance_t post;
+    TickType_t marker = xTaskGetTickCount();
+    TickType_t end = 0;
+
+#if (configUSE_16_BIT_TICKS == 1)
+    int32_t remaining_ticks = ticks_to_run;
+#else
+    int64_t remaining_ticks = ticks_to_run;
+#endif
+
+    while(xQueueReceive(loop->queue, &post, ticks_to_run) == pdTRUE) {
+        // The event has already been unqueued, so ensure it gets executed.
+        xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY);
+
+        loop->running_task = xTaskGetCurrentTaskHandle();
+
+        bool exec = false;
+
+        esp_event_handler_instance_t *handler;
+        esp_event_loop_node_t *loop_node;
+        esp_event_base_node_t *base_node;
+        esp_event_id_node_t *id_node;
+
+        SLIST_FOREACH(loop_node, &(loop->loop_nodes), next) {
+            // Execute loop level handlers
+            SLIST_FOREACH(handler, &(loop_node->handlers), next) {
+                handler_execute(loop, handler, post);
+                exec |= true;
+            }
+
+            SLIST_FOREACH(base_node, &(loop_node->base_nodes), next) {
+                if (base_node->base == post.base) {
+                    // Execute base level handlers
+                    SLIST_FOREACH(handler, &(base_node->handlers), next) {
+                        handler_execute(loop, handler, post);
+                        exec |= true;
+                    }
+
+                    SLIST_FOREACH(id_node, &(base_node->id_nodes), next) {
+                        if (id_node->id == post.id) {
+                            // Execute id level handlers
+                            SLIST_FOREACH(handler, &(id_node->handlers), next) {
+                                handler_execute(loop, handler, post);
+                                exec |= true;
+                            }
+                            // Skip to next base node
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        esp_event_base_t base = post.base;
+        int32_t id = post.id;
+
+        post_instance_delete(&post);
+
+        if (ticks_to_run != portMAX_DELAY) {
+            end = xTaskGetTickCount();
+            remaining_ticks -= end - marker;
+            // If the ticks to run expired, return to the caller
+            if (remaining_ticks <= 0) {
+                xSemaphoreGiveRecursive(loop->mutex);
+                break;
+            } else {
+                marker = end;
+            }
+        }
+
+        loop->running_task = NULL;
+
+        xSemaphoreGiveRecursive(loop->mutex);
+
+        if (!exec) {
+            // No handlers were registered, not even loop/base level handlers
+            ESP_LOGD(TAG, "no handlers have been registered for event %s:%d posted to loop %p", base, id, event_loop);
+        }
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t esp_event_loop_delete(esp_event_loop_handle_t event_loop)
+{
+    assert(event_loop);
+
+    esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
+    SemaphoreHandle_t loop_mutex = loop->mutex;
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    SemaphoreHandle_t loop_profiling_mutex = loop->profiling_mutex;
+#endif
+
+    xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY);
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    xSemaphoreTakeRecursive(loop->profiling_mutex, portMAX_DELAY);
+    portENTER_CRITICAL(&s_event_loops_spinlock);
+    SLIST_REMOVE(&s_event_loops, loop, esp_event_loop_instance, next);
+    portEXIT_CRITICAL(&s_event_loops_spinlock);
+#endif
+
+    // Delete the task if it was created
+    if (loop->task != NULL) {
+        vTaskDelete(loop->task);
+    }
+
+    // Remove all registered events and handlers in the loop
+    esp_event_loop_node_t *it, *temp;
+    SLIST_FOREACH_SAFE(it, &(loop->loop_nodes), next, temp) {
+        loop_node_remove_all_handler(it);
+        SLIST_REMOVE(&(loop->loop_nodes), it, esp_event_loop_node, next);
+        free(it);
+    }
+
+    // Drop existing posts on the queue
+    esp_event_post_instance_t post;
+    while(xQueueReceive(loop->queue, &post, 0) == pdTRUE) {
+        post_instance_delete(&post);
+    }
+
+    // Cleanup loop
+    vQueueDelete(loop->queue);
+    free(loop);
+    // Free loop mutex before deleting
+    xSemaphoreGiveRecursive(loop_mutex);
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    xSemaphoreGiveRecursive(loop_profiling_mutex);
+    vSemaphoreDelete(loop_profiling_mutex);
+#endif
+    vSemaphoreDelete(loop_mutex);
+
+    ESP_LOGD(TAG, "deleted loop %p", (void*) event_loop);
+
+    return ESP_OK;
+}
+
+esp_err_t esp_event_handler_register_with(esp_event_loop_handle_t event_loop, esp_event_base_t event_base,
+                                        int32_t event_id, esp_event_handler_t event_handler, void* event_handler_arg)
+{
+    assert(event_loop);
+    assert(event_handler);
+
+    if (event_base == ESP_EVENT_ANY_BASE && event_id != ESP_EVENT_ANY_ID) {
+        ESP_LOGE(TAG, "registering to any event base with specific id unsupported");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
+
+    if (event_base == ESP_EVENT_ANY_BASE) {
+        event_base = esp_event_any_base;
+    }
+
+    esp_err_t err = ESP_OK;
+
+    xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY);
+
+    esp_event_loop_node_t *loop_node = NULL, *last_loop_node = NULL;
+
+    SLIST_FOREACH(loop_node, &(loop->loop_nodes), next) {
+        last_loop_node = loop_node;
+    }
+
+    bool is_loop_level_handler = (event_base == esp_event_any_base) && (event_id == ESP_EVENT_ANY_ID);
+
+    if (!last_loop_node ||
+       (last_loop_node && !SLIST_EMPTY(&(last_loop_node->base_nodes)) && is_loop_level_handler)) {
+        loop_node = (esp_event_loop_node_t*) calloc(1, sizeof(*loop_node));
+
+        SLIST_INIT(&(loop_node->handlers));
+        SLIST_INIT(&(loop_node->base_nodes));
+
+        if (!loop_node) {
+            ESP_LOGE(TAG, "alloc for new loop node failed");
+            err = ESP_ERR_NO_MEM;
+            goto on_err;
+        }
+
+        err = loop_node_add_handler(loop_node, event_base, event_id, event_handler, event_handler_arg);
+
+        if (err == ESP_OK) {
+            if (!last_loop_node) {
+                SLIST_INSERT_HEAD(&(loop->loop_nodes), loop_node, next);
+            }
+            else {
+                SLIST_INSERT_AFTER(last_loop_node, loop_node, next);
+            }
+        } else {
+            free(loop_node);
+        }
+    }
+    else {
+        err = loop_node_add_handler(last_loop_node, event_base, event_id, event_handler, event_handler_arg);
+    }
+
+on_err:
+    xSemaphoreGiveRecursive(loop->mutex);
+    return err;
+}
+
+esp_err_t esp_event_handler_unregister_with(esp_event_loop_handle_t event_loop, esp_event_base_t event_base,
+                                            int32_t event_id, esp_event_handler_t event_handler)
+{
+    assert(event_loop);
+    assert(event_handler);
+
+    if (event_base == ESP_EVENT_ANY_BASE && event_id != ESP_EVENT_ANY_ID) {
+        ESP_LOGE(TAG, "unregistering to any event base with specific id unsupported");
+        return ESP_FAIL;
+    }
+
+    if (event_base == ESP_EVENT_ANY_BASE) {
+        event_base = esp_event_any_base;
+    }
+
+    esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
+
+    xSemaphoreTakeRecursive(loop->mutex, portMAX_DELAY);
+
+    esp_event_loop_node_t *it, *temp;
+
+    SLIST_FOREACH_SAFE(it, &(loop->loop_nodes), next, temp) {
+        esp_err_t res = loop_node_remove_handler(it, event_base, event_id, event_handler);
+
+        if (res == ESP_OK && SLIST_EMPTY(&(it->base_nodes)) && SLIST_EMPTY(&(it->handlers))) {
+            SLIST_REMOVE(&(loop->loop_nodes), it, esp_event_loop_node, next);
+            free(it);
+            break;
+        }
+    }
+
+    xSemaphoreGiveRecursive(loop->mutex);
+
+    return ESP_OK;
+}
+
+esp_err_t esp_event_post_to(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, int32_t event_id,
+                            void* event_data, size_t event_data_size, TickType_t ticks_to_wait)
+{
+    assert(event_loop);
+
+    if (event_base == ESP_EVENT_ANY_BASE || event_id == ESP_EVENT_ANY_ID) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
+
+    esp_event_post_instance_t post;
+    memset((void*)(&post), 0, sizeof(post));
+
+    if (event_data != NULL && event_data_size != 0) {
+        // Make persistent copy of event data on heap.
+        void* event_data_copy = calloc(1, event_data_size);
+
+        if (event_data_copy == NULL) {
+            return ESP_ERR_NO_MEM;
+        }
+
+        memcpy(event_data_copy, event_data, event_data_size);
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+        post.data.ptr = event_data_copy;
+        post.data_allocated = true;
+        post.data_set = true;
+#else
+        post.data = event_data_copy;
+#endif
+    }
+    post.base = event_base;
+    post.id = event_id;
+
+    BaseType_t result = pdFALSE;
+
+    // Find the task that currently executes the loop. It is safe to query loop->task since it is
+    // not mutated since loop creation. ENSURE THIS REMAINS TRUE.
+    if (loop->task == NULL) {
+        // The loop has no dedicated task. Find out what task is currently running it.
+        result = xSemaphoreTakeRecursive(loop->mutex, ticks_to_wait);
+
+        if (result == pdTRUE) {
+            if (loop->running_task != xTaskGetCurrentTaskHandle()) {
+                xSemaphoreGiveRecursive(loop->mutex);
+                result = xQueueSendToBack(loop->queue, &post, ticks_to_wait);
+            } else {
+                xSemaphoreGiveRecursive(loop->mutex);
+                result = xQueueSendToBack(loop->queue, &post, 0);
+            }
+        }
+    } else {
+        // The loop has a dedicated task.
+        if (loop->task != xTaskGetCurrentTaskHandle()) {
+            result = xQueueSendToBack(loop->queue, &post, ticks_to_wait);
+        } else {
+            result = xQueueSendToBack(loop->queue, &post, 0);
+        }
+    }
+
+    if (result != pdTRUE) {
+        post_instance_delete(&post);
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+        atomic_fetch_add(&loop->events_dropped, 1);
+#endif
+        return ESP_ERR_TIMEOUT;
+    }
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    atomic_fetch_add(&loop->events_recieved, 1);
+#endif
+
+    return ESP_OK;
+}
+
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+esp_err_t esp_event_isr_post_to(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, int32_t event_id,
+                            void* event_data, size_t event_data_size, BaseType_t* task_unblocked)
+{
+    assert(event_loop);
+
+    if (event_base == ESP_EVENT_ANY_BASE || event_id == ESP_EVENT_ANY_ID) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
+
+    esp_event_post_instance_t post;
+    memset((void*)(&post), 0, sizeof(post));
+
+    if (event_data_size > sizeof(post.data.val)) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (event_data != NULL && event_data_size != 0) {
+        memcpy((void*)(&(post.data.val)), event_data, event_data_size);
+        post.data_allocated = false;
+        post.data_set = true;
+    }
+    post.base = event_base;
+    post.id = event_id;
+
+    BaseType_t result = pdFALSE;
+
+    // Post the event from an ISR,
+    result = xQueueSendToBackFromISR(loop->queue, &post, task_unblocked);
+
+    if (result != pdTRUE) {
+        post_instance_delete(&post);
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+        atomic_fetch_add(&loop->events_dropped, 1);
+#endif
+        return ESP_FAIL;
+    }
+
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    atomic_fetch_add(&loop->events_recieved, 1);
+#endif
+
+    return ESP_OK;
+}
+#endif
+
+esp_err_t esp_event_dump(FILE* file)
+{
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    assert(file);
+
+    esp_event_loop_instance_t* loop_it;
+    esp_event_loop_node_t *loop_node_it;
+    esp_event_base_node_t* base_node_it;
+    esp_event_id_node_t* id_node_it;
+    esp_event_handler_instance_t* handler_it;
+
+    // Allocate memory for printing
+    int sz = esp_event_dump_prepare();
+    char* buf = calloc(sz, sizeof(char));
+    char* dst = buf;
+
+    char id_str_buf[20];
+
+    // Print info to buffer
+    portENTER_CRITICAL(&s_event_loops_spinlock);
+
+    SLIST_FOREACH(loop_it, &s_event_loops, next) {
+        uint32_t events_recieved, events_dropped;
+
+        events_recieved = atomic_load(&loop_it->events_recieved);
+        events_dropped = atomic_load(&loop_it->events_dropped);
+
+        PRINT_DUMP_INFO(dst, sz, LOOP_DUMP_FORMAT, loop_it, loop_it->task != NULL ? loop_it->name : "none" ,
+                        events_recieved, events_dropped);
+
+        int sz_bak = sz;
+
+        SLIST_FOREACH(loop_node_it, &(loop_it->loop_nodes), next) {
+            SLIST_FOREACH(handler_it, &(loop_node_it->handlers), next) {
+                PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler, "ESP_EVENT_ANY_BASE",
+                                "ESP_EVENT_ANY_ID", handler_it->invoked, handler_it->time);
+            }
+
+            SLIST_FOREACH(base_node_it, &(loop_node_it->base_nodes), next) {
+                SLIST_FOREACH(handler_it, &(base_node_it->handlers), next) {
+                    PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler, base_node_it->base ,
+                                    "ESP_EVENT_ANY_ID", handler_it->invoked, handler_it->time);
+                }
+
+                SLIST_FOREACH(id_node_it, &(base_node_it->id_nodes), next) {
+                    SLIST_FOREACH(handler_it, &(id_node_it->handlers), next) {
+                        memset(id_str_buf, 0, sizeof(id_str_buf));
+                        snprintf(id_str_buf, sizeof(id_str_buf), "%d", id_node_it->id);
+
+                        PRINT_DUMP_INFO(dst, sz, HANDLER_DUMP_FORMAT, handler_it->handler, base_node_it->base ,
+                                        id_str_buf, handler_it->invoked, handler_it->time);
+                    }
+                }
+            }
+        }
+
+        // No handlers registered for this loop
+        if (sz == sz_bak) {
+            PRINT_DUMP_INFO(dst, sz, "  NO HANDLERS REGISTERED\n");
+        }
+    }
+
+    portEXIT_CRITICAL(&s_event_loops_spinlock);
+
+    // Print the contents of the buffer to the file
+    fprintf(file, buf);
+
+    // Free the allocated buffer
+    free(buf);
+#endif
+    return ESP_OK;
+}

components/esp_event/esp_event_private.c

@@ -0,0 +1,68 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp_event_private.h"
+#include "esp_event_internal.h"
+
+#include "esp_log.h"
+
+bool esp_event_is_handler_registered(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler)
+{
+    esp_event_loop_instance_t* loop = (esp_event_loop_instance_t*) event_loop;
+
+    bool result = false;
+
+    esp_event_loop_node_t* loop_node;
+    esp_event_base_node_t* base_node;
+    esp_event_id_node_t* id_node;
+    esp_event_handler_instance_t* handler;
+
+    SLIST_FOREACH(loop_node, &(loop->loop_nodes), next) {
+        SLIST_FOREACH(handler, &(loop_node->handlers), next) {
+            if(event_base == ESP_EVENT_ANY_BASE && event_id == ESP_EVENT_ANY_ID && handler->handler == event_handler)
+            {
+                result = true;
+                goto out;
+            }
+        }
+
+        SLIST_FOREACH(base_node, &(loop_node->base_nodes), next) {
+            if (base_node->base == event_base) {
+                SLIST_FOREACH(handler, &(base_node->handlers), next) {
+                    if(event_id == ESP_EVENT_ANY_ID && handler->handler == event_handler)
+                    {
+                        result = true;
+                        goto out;
+                    }
+                }
+
+                SLIST_FOREACH(id_node, &(base_node->id_nodes), next) {
+                    if(id_node->id == event_id) {
+                        SLIST_FOREACH(handler, &(id_node->handlers), next) {
+                            if(handler->handler == event_handler)
+                            {
+                                result = true;
+                                goto out;
+                            }
+                        }       
+                    }
+                }
+            }
+        }
+    }
+
+out:
+    xSemaphoreGive(loop->mutex);
+    return result;
+}

components/esp_event/event_loop_legacy.c

@@ -0,0 +1,101 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp_err.h"
+#include "esp_log.h"
+#include "esp_event_legacy.h"
+#include "esp_event.h"
+
+#include "sdkconfig.h"
+
+static const char* TAG = "event";
+
+static system_event_cb_t s_event_handler_cb;
+static void *s_event_ctx;
+static bool s_initialized;
+
+ESP_EVENT_DEFINE_BASE(SYSTEM_EVENT);
+
+static void esp_event_post_to_user(void* arg, esp_event_base_t base, int32_t id, void* data)
+{
+    if (s_event_handler_cb) {
+        system_event_t* event = (system_event_t*) data;
+        (*s_event_handler_cb)(s_event_ctx, event);
+    }
+}
+
+system_event_cb_t esp_event_loop_set_cb(system_event_cb_t cb, void *ctx)
+{
+    system_event_cb_t old_cb = s_event_handler_cb;
+    s_event_handler_cb = cb;
+    s_event_ctx = ctx;
+    return old_cb;
+}
+
+esp_err_t esp_event_send_legacy(system_event_t *event)
+{
+    if (!s_initialized) {
+        ESP_LOGE(TAG, "system event loop not initialized via esp_event_loop_init");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    return esp_event_post(SYSTEM_EVENT, event->event_id, event, sizeof(*event), portMAX_DELAY);
+}
+
+esp_err_t esp_event_loop_init(system_event_cb_t cb, void *ctx)
+{
+    if (s_initialized) {
+        ESP_LOGE(TAG, "system event loop already initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t err = esp_event_loop_create_default();
+    if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
+        return err;
+    }
+
+    err = esp_event_handler_register(SYSTEM_EVENT, ESP_EVENT_ANY_ID, esp_event_post_to_user, NULL);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    s_initialized = true;
+    s_event_handler_cb = cb;
+    s_event_ctx = ctx;
+    return ESP_OK;
+}
+
+esp_err_t esp_event_loop_deinit() 
+{
+    if (!s_initialized) {
+        ESP_LOGE(TAG, "system event loop not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t err = esp_event_handler_unregister(SYSTEM_EVENT, ESP_EVENT_ANY_ID, esp_event_post_to_user);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    err = esp_event_loop_delete_default();
+    if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
+        return err;
+    }
+
+    s_initialized = false;
+    s_event_handler_cb = NULL;
+    s_event_ctx = NULL;
+    return ESP_OK;
+}
+

components/esp_event/event_send.c

@@ -0,0 +1,45 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+#include "esp_event.h"
+#include "esp_event_legacy.h"
+
+esp_err_t esp_event_send_noop(system_event_t *event);
+
+extern esp_err_t esp_event_send_legacy(system_event_t *event) __attribute__((weak, alias("esp_event_send_noop")));
+extern esp_err_t esp_event_send_to_default_loop(system_event_t *event) __attribute((weak, alias("esp_event_send_noop")));
+
+
+esp_err_t esp_event_send_noop(system_event_t *event)
+{
+    return ESP_OK;
+}
+
+esp_err_t esp_event_send(system_event_t *event)
+{
+    // send the event to the new style event loop
+    esp_err_t err = esp_event_send_to_default_loop(event);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    // send the event to the legacy event loop
+    err = esp_event_send_legacy(event);
+    if (err != ESP_OK) {
+        return err;
+    }
+
+    return ESP_OK;
+}

components/esp_event/event_send_compat.inc

@@ -0,0 +1,316 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "esp_event.h"
+#include "esp_log.h"
+#include "esp_event_legacy.h"
+#include "esp_wifi_types.h"
+#include "tcpip_adapter.h"
+#include "esp_eth.h"
+
+/**
+ * The purpose of this file is to provide an "esp_event_send_to_default_loop"
+ * function, which is used to forward legacy events (system_event_t) sent using
+ * esp_event_send, to the new default event loop (esp_event_post).
+ *
+ * For each of the events in system_event_id_t, we extract the event data from
+ * the corresponding system_event_info_t member, and forward that to
+ * esp_event_post function.
+ *
+ * Some macros are used to reduce the amount of boilerplate.
+ *
+ * Note that this function only needs to be included into the output file if
+ * the new default event loop is used. This function is in a separate file for
+ * readability reasons. In order to be linked if the contents of
+ * default_event_loop.c is linked, this file is #include-ed into default_event_loop.c.
+ */
+
+//#if LOG_LOCAL_LEVEL >= 4 /* ESP_LOG_DEBUG */
+#if 1
+#define WITH_EVENT_DEBUG
+#endif
+
+#ifdef WITH_EVENT_DEBUG
+static void esp_system_event_debug(const system_event_t* event);
+#endif
+
+#define HANDLE_SYS_EVENT(base_, name_) \
+        case SYSTEM_EVENT_ ## name_: \
+            return esp_event_post(base_ ## _EVENT, base_ ## _EVENT_ ## name_, \
+                    NULL, 0, send_timeout)
+
+#define HANDLE_SYS_EVENT_ARG(base_, name_, member_) \
+        case SYSTEM_EVENT_ ## name_: \
+            return esp_event_post(base_ ## _EVENT, base_ ## _EVENT_ ## name_, \
+                    &event->event_info.member_, sizeof(event->event_info.member_), \
+                    send_timeout)
+
+esp_err_t esp_event_send_to_default_loop(system_event_t *event)
+{
+#ifdef WITH_EVENT_DEBUG
+    esp_system_event_debug(event);
+#endif // WITH_EVENT_DEBUG
+
+    const TickType_t send_timeout = 0;
+    switch (event->event_id) {
+        /* Wi-Fi common events */
+        HANDLE_SYS_EVENT(WIFI, WIFI_READY);
+        HANDLE_SYS_EVENT_ARG(WIFI, SCAN_DONE, scan_done);
+        HANDLE_SYS_EVENT(WIFI, STA_START);
+        HANDLE_SYS_EVENT(WIFI, STA_STOP);
+
+        /* STA events */
+        HANDLE_SYS_EVENT_ARG(WIFI, STA_CONNECTED, connected);
+        HANDLE_SYS_EVENT_ARG(WIFI, STA_DISCONNECTED, disconnected);
+        HANDLE_SYS_EVENT_ARG(WIFI, STA_AUTHMODE_CHANGE, auth_change);
+
+        /* WPS events */
+        HANDLE_SYS_EVENT(WIFI, STA_WPS_ER_SUCCESS);
+        HANDLE_SYS_EVENT(WIFI, STA_WPS_ER_TIMEOUT);
+        HANDLE_SYS_EVENT_ARG(WIFI, STA_WPS_ER_FAILED, sta_er_fail_reason);
+        HANDLE_SYS_EVENT_ARG(WIFI, STA_WPS_ER_PIN, sta_er_pin);
+        HANDLE_SYS_EVENT(WIFI, STA_WPS_ER_PBC_OVERLAP);
+
+        /* AP events */
+        HANDLE_SYS_EVENT(WIFI, AP_START);
+        HANDLE_SYS_EVENT(WIFI, AP_STOP);
+        HANDLE_SYS_EVENT_ARG(WIFI, AP_STACONNECTED, sta_connected);
+        HANDLE_SYS_EVENT_ARG(WIFI, AP_STADISCONNECTED, sta_disconnected);
+        HANDLE_SYS_EVENT_ARG(WIFI, AP_PROBEREQRECVED, ap_probereqrecved);
+
+        /* Ethernet events */
+        /* Some extra defines to fit the old naming scheme... */
+#define ETH_EVENT_ETH_START ETHERNET_EVENT_START
+#define ETH_EVENT_ETH_STOP ETHERNET_EVENT_STOP
+#define ETH_EVENT_ETH_CONNECTED ETHERNET_EVENT_CONNECTED
+#define ETH_EVENT_ETH_DISCONNECTED ETHERNET_EVENT_DISCONNECTED
+
+        HANDLE_SYS_EVENT(ETH, ETH_START);
+        HANDLE_SYS_EVENT(ETH, ETH_STOP);
+        HANDLE_SYS_EVENT(ETH, ETH_CONNECTED);
+        HANDLE_SYS_EVENT(ETH, ETH_DISCONNECTED);
+
+        /* IP events */
+        HANDLE_SYS_EVENT_ARG(IP, STA_GOT_IP, got_ip);
+        HANDLE_SYS_EVENT_ARG(IP, ETH_GOT_IP, got_ip);
+        HANDLE_SYS_EVENT(IP, STA_LOST_IP);
+        HANDLE_SYS_EVENT_ARG(IP, GOT_IP6, got_ip6);
+        HANDLE_SYS_EVENT(IP, AP_STAIPASSIGNED);
+        default:
+            return ESP_ERR_NOT_SUPPORTED;
+    }
+}
+
+#ifdef WITH_EVENT_DEBUG
+
+static const char* TAG = "system_event";
+
+typedef struct {
+    int err;
+    const char *reason;
+} wifi_reason_t;
+  
+static const wifi_reason_t wifi_reason[] =
+{   
+    {0,                                    "other reason"},
+    {WIFI_REASON_UNSPECIFIED,              "unspecified"},
+    {WIFI_REASON_AUTH_EXPIRE,              "auth expire"},
+    {WIFI_REASON_AUTH_LEAVE,               "auth leave"},
+    {WIFI_REASON_ASSOC_EXPIRE,             "assoc expire"},
+    {WIFI_REASON_ASSOC_TOOMANY,            "assoc too many"},
+    {WIFI_REASON_NOT_AUTHED,               "not authed"},
+    {WIFI_REASON_NOT_ASSOCED,              "not assoced"},
+    {WIFI_REASON_ASSOC_LEAVE,              "assoc leave"},
+    {WIFI_REASON_ASSOC_NOT_AUTHED,         "assoc not authed"},
+    {WIFI_REASON_BEACON_TIMEOUT,           "beacon timeout"},
+    {WIFI_REASON_NO_AP_FOUND,              "no ap found"},
+    {WIFI_REASON_AUTH_FAIL,                "auth fail"},
+    {WIFI_REASON_ASSOC_FAIL,               "assoc fail"},
+    {WIFI_REASON_HANDSHAKE_TIMEOUT,        "hanshake timeout"},
+    {WIFI_REASON_DISASSOC_PWRCAP_BAD,      "bad Power Capability, disassoc"},
+    {WIFI_REASON_DISASSOC_SUPCHAN_BAD,     "bad Supported Channels, disassoc"},
+    {WIFI_REASON_IE_INVALID,               "invalid IE"},
+    {WIFI_REASON_MIC_FAILURE,              "MIC failure"},
+    {WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT,   "4-way keying handshake timeout"},
+    {WIFI_REASON_GROUP_KEY_UPDATE_TIMEOUT, "Group key handshake"},
+    {WIFI_REASON_IE_IN_4WAY_DIFFERS,       "IE in 4-way differs"},
+    {WIFI_REASON_GROUP_CIPHER_INVALID,     "invalid group cipher"},
+    {WIFI_REASON_PAIRWISE_CIPHER_INVALID,  "invalid pairwise cipher"},
+    {WIFI_REASON_AKMP_INVALID,             "invalid AKMP"},
+    {WIFI_REASON_UNSUPP_RSN_IE_VERSION,    "unsupported RSN IE version"},
+    {WIFI_REASON_INVALID_RSN_IE_CAP,       "invalid RSN IE capability"},
+    {WIFI_REASON_802_1X_AUTH_FAILED,       "802.1x auth failed"},
+    {WIFI_REASON_CIPHER_SUITE_REJECTED,    "cipher suite rejected"}                                                                                                              
+};
+  
+static const char* wifi_disconnect_reason_to_str(int err)
+{
+    for (int i=0; i< sizeof(wifi_reason)/sizeof(wifi_reason[0]); i++){
+        if (err == wifi_reason[i].err){
+            return wifi_reason[i].reason;
+        }
+    }
+    return wifi_reason[0].reason;
+}
+
+static void esp_system_event_debug(const system_event_t* event)
+{
+    if (event == NULL) {
+        return;
+    }
+
+    switch (event->event_id) {
+        case SYSTEM_EVENT_WIFI_READY: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_WIFI_READY");
+            break;
+        }
+        case SYSTEM_EVENT_SCAN_DONE: {
+            const system_event_sta_scan_done_t *scan_done = &event->event_info.scan_done;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_SCAN_DONE, status:%d, number:%d",  scan_done->status, scan_done->number);
+            break;
+        }
+        case SYSTEM_EVENT_STA_START: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_START");
+            break;
+        }
+        case SYSTEM_EVENT_STA_STOP: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_STOP");
+            break;
+        }
+        case SYSTEM_EVENT_STA_CONNECTED: {
+            const system_event_sta_connected_t *connected = &event->event_info.connected;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_CONNECTED, ssid:%s, ssid_len:%d, bssid:" MACSTR ", channel:%d, authmode:%d", \
+                       connected->ssid, connected->ssid_len, MAC2STR(connected->bssid), connected->channel, connected->authmode);
+            break;
+        }
+        case SYSTEM_EVENT_STA_DISCONNECTED: {
+            const system_event_sta_disconnected_t *disconnected = &event->event_info.disconnected;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_DISCONNECTED, ssid:%s, ssid_len:%d, bssid:" MACSTR ", reason:%d (%s)", \
+                       disconnected->ssid, disconnected->ssid_len, MAC2STR(disconnected->bssid), disconnected->reason,
+                       wifi_disconnect_reason_to_str(disconnected->reason));
+            break;
+        }
+        case SYSTEM_EVENT_STA_AUTHMODE_CHANGE: {
+            const system_event_sta_authmode_change_t *auth_change = &event->event_info.auth_change;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_AUTHMODE_CHNAGE, old_mode:%d, new_mode:%d", auth_change->old_mode, auth_change->new_mode);
+            break;
+        }
+        case SYSTEM_EVENT_STA_GOT_IP: {
+            const system_event_sta_got_ip_t *got_ip = &event->event_info.got_ip;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_GOT_IP, ip:" IPSTR ", mask:" IPSTR ", gw:" IPSTR,
+                IP2STR(&got_ip->ip_info.ip),
+                IP2STR(&got_ip->ip_info.netmask),
+                IP2STR(&got_ip->ip_info.gw));
+            break;
+        }
+        case SYSTEM_EVENT_STA_LOST_IP: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_LOST_IP");
+            break;
+        }
+        case SYSTEM_EVENT_STA_WPS_ER_SUCCESS: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_WPS_ER_SUCCESS");
+            break;
+        }
+        case SYSTEM_EVENT_STA_WPS_ER_FAILED: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_WPS_ER_FAILED");
+            break;
+        }
+        case SYSTEM_EVENT_STA_WPS_ER_TIMEOUT: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_WPS_ER_TIMEOUT");
+            break;
+        }
+        case SYSTEM_EVENT_STA_WPS_ER_PIN: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_WPS_ER_PIN");
+            break;
+        }
+        case SYSTEM_EVENT_STA_WPS_ER_PBC_OVERLAP: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_STA_WPS_ER_PBC_OVERLAP");
+            break;
+        }
+        case SYSTEM_EVENT_AP_START: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_AP_START");
+            break;
+        }
+        case SYSTEM_EVENT_AP_STOP: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_AP_STOP");
+            break;
+        }
+        case SYSTEM_EVENT_AP_STACONNECTED: {
+            const system_event_ap_staconnected_t *staconnected = &event->event_info.sta_connected;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_AP_STACONNECTED, mac:" MACSTR ", aid:%d", \
+                       MAC2STR(staconnected->mac), staconnected->aid);
+            break;
+        }
+        case SYSTEM_EVENT_AP_STADISCONNECTED: {
+            const system_event_ap_stadisconnected_t *stadisconnected = &event->event_info.sta_disconnected;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_AP_STADISCONNECTED, mac:" MACSTR ", aid:%d", \
+                       MAC2STR(stadisconnected->mac), stadisconnected->aid);
+            break;
+        }
+        case SYSTEM_EVENT_AP_STAIPASSIGNED: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_AP_STAIPASSIGNED");
+            break;
+        }
+        case SYSTEM_EVENT_AP_PROBEREQRECVED: {
+            const system_event_ap_probe_req_rx_t *ap_probereqrecved = &event->event_info.ap_probereqrecved;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_AP_PROBEREQRECVED, rssi:%d, mac:" MACSTR, \
+                       ap_probereqrecved->rssi, \
+                       MAC2STR(ap_probereqrecved->mac));
+            break;
+        }
+        case SYSTEM_EVENT_GOT_IP6: {
+            const ip6_addr_t *addr = &event->event_info.got_ip6.ip6_info.ip;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_AP_STA_GOT_IP6 address %04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
+                     IP6_ADDR_BLOCK1(addr),
+                     IP6_ADDR_BLOCK2(addr),
+                     IP6_ADDR_BLOCK3(addr),
+                     IP6_ADDR_BLOCK4(addr),
+                     IP6_ADDR_BLOCK5(addr),
+                     IP6_ADDR_BLOCK6(addr),
+                     IP6_ADDR_BLOCK7(addr),
+                     IP6_ADDR_BLOCK8(addr));
+            break;
+        }
+        case SYSTEM_EVENT_ETH_START: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_ETH_START");
+            break;
+        }
+        case SYSTEM_EVENT_ETH_STOP: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_ETH_STOP");
+            break;
+        }
+        case SYSTEM_EVENT_ETH_CONNECTED: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_ETH_CONNECETED");
+            break;
+        }
+        case SYSTEM_EVENT_ETH_DISCONNECTED: {
+            ESP_LOGD(TAG, "SYSTEM_EVENT_ETH_DISCONNECETED");
+            break;
+        }
+        case SYSTEM_EVENT_ETH_GOT_IP: {
+            const system_event_sta_got_ip_t *got_ip = &event->event_info.got_ip;
+            ESP_LOGD(TAG, "SYSTEM_EVENT_ETH_GOT_IP, ip:" IPSTR ", mask:" IPSTR ", gw:" IPSTR,
+                IP2STR(&got_ip->ip_info.ip),
+                IP2STR(&got_ip->ip_info.netmask),
+                IP2STR(&got_ip->ip_info.gw));
+            break;
+        }
+        default: {
+            ESP_LOGW(TAG, "unexpected system event %d!", event->event_id);
+            break;
+        }
+    }
+}
+
+#endif // WITH_EVENT_DEBUG

components/esp_event/include/esp_event.h

@@ -0,0 +1,382 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//         http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ESP_EVENT_H_
+#define ESP_EVENT_H_
+
+#include "esp_err.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+
+#include "esp_event_base.h"
+#include "esp_event_legacy.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// Configuration for creating event loops
+typedef struct {
+    int32_t queue_size;                         /**< size of the event loop queue */
+    const char* task_name;                      /**< name of the event loop task; if NULL,
+                                                        a dedicated task is not created for event loop*/
+    UBaseType_t task_priority;                  /**< priority of the event loop task, ignored if task name is NULL */
+    uint32_t task_stack_size;                   /**< stack size of the event loop task, ignored if task name is NULL */
+    BaseType_t task_core_id;                    /**< core to which the event loop task is pinned to,
+                                                        ignored if task name is NULL */
+} esp_event_loop_args_t;
+
+/**
+ * @brief Create a new event loop.
+ *
+ * @param[in] event_loop_args configuration structure for the event loop to create
+ * @param[out] event_loop handle to the created event loop
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_NO_MEM: Cannot allocate memory for event loops list
+ *  - ESP_FAIL: Failed to create task loop
+ *  - Others: Fail
+ */
+esp_err_t esp_event_loop_create(const esp_event_loop_args_t* event_loop_args, esp_event_loop_handle_t* event_loop);
+
+/**
+ * @brief Delete an existing event loop.
+ *
+ * @param[in] event_loop event loop to delete
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - Others: Fail
+ */
+esp_err_t esp_event_loop_delete(esp_event_loop_handle_t event_loop);
+
+/**
+ * @brief Create default event loop
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_NO_MEM: Cannot allocate memory for event loops list
+ *  - ESP_FAIL: Failed to create task loop
+ *  - Others: Fail
+ */
+esp_err_t esp_event_loop_create_default();
+
+/**
+ * @brief Delete the default event loop
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - Others: Fail
+ */
+esp_err_t esp_event_loop_delete_default();
+
+/**
+ * @brief Dispatch events posted to an event loop.
+ *
+ * This function is used to dispatch events posted to a loop with no dedicated task, i.e task name was set to NULL
+ * in event_loop_args argument during loop creation. This function includes an argument to limit the amount of time
+ * it runs, returning control to the caller when that time expires (or some time afterwards). There is no guarantee
+ * that a call to this function will exit at exactly the time of expiry. There is also no guarantee that events have
+ * been dispatched during the call, as the function might have spent all of the alloted time waiting on the event queue.
+ * Once an event has been unqueued, however, it is guaranteed to be dispatched. This guarantee contributes to not being
+ * able to exit exactly at time of expiry as (1) blocking on internal mutexes is necessary for dispatching the unqueued
+ * event, and (2) during  dispatch of the unqueued event there is no way to control the time occupied by handler code
+ * execution. The guaranteed time of exit is therefore the alloted time + amount of time required to dispatch
+ * the last unqueued event.
+ *
+ * In cases where waiting on the queue times out, ESP_OK is returned and not ESP_ERR_TIMEOUT, since it is
+ * normal behavior.
+ *
+ * @param[in] event_loop event loop to dispatch posted events from
+ * @param[in] ticks_to_run number of ticks to run the loop
+ *
+ * @note encountering an unknown event that has been posted to the loop will only generate a warning, not an error.
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - Others: Fail
+ */
+esp_err_t esp_event_loop_run(esp_event_loop_handle_t event_loop, TickType_t ticks_to_run);
+
+/**
+ * @brief Register an event handler to the system event loop.
+ *
+ * This function can be used to register a handler for either: (1) specific events,
+ * (2) all events of a certain event base, or (3) all events known by the system event loop.
+ *
+ *  - specific events: specify exact event_base and event_id
+ *  - all events of a certain base: specify exact event_base and use ESP_EVENT_ANY_ID as the event_id
+ *  - all events known by the loop: use ESP_EVENT_ANY_BASE for event_base and ESP_EVENT_ANY_ID as the event_id
+ *
+ * Registering multiple handlers to events is possible. Registering a single handler to multiple events is
+ * also possible. However, registering the same handler to the same event multiple times would cause the
+ * previous registrations to be overwritten.
+ *
+ * @param[in] event_base the base id of the event to register the handler for
+ * @param[in] event_id the id of the event to register the handler for
+ * @param[in] event_handler the handler function which gets called when the event is dispatched
+ * @param[in] event_handler_arg data, aside from event data, that is passed to the handler when it is called
+ *
+ * @note the event loop library does not maintain a copy of event_handler_arg, therefore the user should
+ * ensure that event_handler_arg still points to a valid location by the time the handler gets called
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_NO_MEM: Cannot allocate memory for the handler
+ *  - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
+ *  - Others: Fail
+ */
+esp_err_t esp_event_handler_register(esp_event_base_t event_base,
+                                        int32_t event_id,
+                                        esp_event_handler_t event_handler,
+                                        void* event_handler_arg);
+
+/**
+ * @brief Register an event handler to a specific loop.
+ *
+ * This function behaves in the same manner as esp_event_handler_register, except the additional
+ * specification of the event loop to register the handler to.
+ *
+ * @param[in] event_loop the event loop to register this handler function to
+ * @param[in] event_base the base id of the event to register the handler for
+ * @param[in] event_id the id of the event to register the handler for
+ * @param[in] event_handler the handler function which gets called when the event is dispatched
+ * @param[in] event_handler_arg data, aside from event data, that is passed to the handler when it is called
+ *
+ * @note the event loop library does not maintain a copy of event_handler_arg, therefore the user should
+ * ensure that event_handler_arg still points to a valid location by the time the handler gets called
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_NO_MEM: Cannot allocate memory for the handler
+ *  - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
+ *  - Others: Fail
+ */
+esp_err_t esp_event_handler_register_with(esp_event_loop_handle_t event_loop,
+                                            esp_event_base_t event_base,
+                                            int32_t event_id,
+                                            esp_event_handler_t event_handler,
+                                            void* event_handler_arg);
+
+/**
+ * @brief Unregister a handler with the system event loop.
+ *
+ * This function can be used to unregister a handler so that it no longer gets called during dispatch.
+ * Handlers can be unregistered for either: (1) specific events, (2) all events of a certain event base,
+ * or (3) all events known by the system event loop
+ *
+ *  - specific events: specify exact event_base and event_id
+ *  - all events of a certain base: specify exact event_base and use ESP_EVENT_ANY_ID as the event_id
+ *  - all events known by the loop: use ESP_EVENT_ANY_BASE for event_base and ESP_EVENT_ANY_ID as the event_id
+ *
+ * This function ignores unregistration of handlers that has not been previously registered.
+ *
+ * @param[in] event_base the base of the event with which to unregister the handler
+ * @param[in] event_id the id of the event with which to unregister the handler
+ * @param[in] event_handler the handler to unregister
+ *
+ * @return ESP_OK success
+ * @return ESP_ERR_INVALID_ARG invalid combination of event base and event id
+ * @return others fail
+ */
+esp_err_t esp_event_handler_unregister(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler);
+
+/**
+ * @brief Unregister a handler with the system event loop.
+ *
+ * This function behaves in the same manner as esp_event_handler_unregister, except the additional specification of
+ * the event loop to unregister the handler with.
+ *
+ * @param[in] event_loop the event loop with which to unregister this handler function
+ * @param[in] event_base the base of the event with which to unregister the handler
+ * @param[in] event_id the id of the event with which to unregister the handler
+ * @param[in] event_handler the handler to unregister
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
+ *  - Others: Fail
+ */
+esp_err_t esp_event_handler_unregister_with(esp_event_loop_handle_t event_loop,
+                                            esp_event_base_t event_base,
+                                            int32_t event_id,
+                                            esp_event_handler_t event_handler);
+
+/**
+ * @brief Posts an event to the system default event loop. The event loop library keeps a copy of event_data and manages
+ * the copy's lifetime automatically (allocation + deletion); this ensures that the data the
+ * handler recieves is always valid.
+ *
+ * @param[in] event_base the event base that identifies the event
+ * @param[in] event_id the event id that identifies the event
+ * @param[in] event_data the data, specific to the event occurence, that gets passed to the handler
+ * @param[in] event_data_size the size of the event data
+ * @param[in] ticks_to_wait number of ticks to block on a full event queue
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_TIMEOUT: Time to wait for event queue to unblock expired, 
+ *                      queue full when posting from ISR
+ *  - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
+ *  - Others: Fail
+ */
+esp_err_t esp_event_post(esp_event_base_t event_base,
+                            int32_t event_id,
+                            void* event_data,
+                            size_t event_data_size,
+                            TickType_t ticks_to_wait);
+
+/**
+ * @brief Posts an event to the specified event loop. The event loop library keeps a copy of event_data and manages
+ * the copy's lifetime automatically (allocation + deletion); this ensures that the data the
+ * handler recieves is always valid.
+ *
+ * This function behaves in the same manner as esp_event_post_to, except the additional specification of the event loop
+ * to post the event to.
+ *
+ * @param[in] event_loop the event loop to post to
+ * @param[in] event_base the event base that identifies the event
+ * @param[in] event_id the event id that identifies the event
+ * @param[in] event_data the data, specific to the event occurence, that gets passed to the handler
+ * @param[in] event_data_size the size of the event data
+ * @param[in] ticks_to_wait number of ticks to block on a full event queue
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_TIMEOUT: Time to wait for event queue to unblock expired, 
+ *                      queue full when posting from ISR
+ *  - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id
+ *  - Others: Fail
+ */
+esp_err_t esp_event_post_to(esp_event_loop_handle_t event_loop,
+                            esp_event_base_t event_base,
+                            int32_t event_id,
+                            void* event_data,
+                            size_t event_data_size,
+                            TickType_t ticks_to_wait);
+
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+/**
+ * @brief Special variant of esp_event_post for posting events from interrupt handlers.
+ * 
+ * @param[in] event_base the event base that identifies the event
+ * @param[in] event_id the event id that identifies the event
+ * @param[in] event_data the data, specific to the event occurence, that gets passed to the handler
+ * @param[in] event_data_size the size of the event data; max is 4 bytes
+ * @param[out] task_unblocked an optional parameter (can be NULL) which indicates that an event task with 
+ *                            higher priority than currently running task has been unblocked by the posted event;
+ *                            a context switch should be requested before the interrupt is existed.
+ *
+ * @note this function is only available when CONFIG_ESP_EVENT_POST_FROM_ISR is enabled
+ * @note when this function is called from an interrupt handler placed in IRAM, this function should
+ *       be placed in IRAM as well by enabling CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_FAIL: Event queue for the default event loop full
+ *  - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id,
+ *                          data size of more than 4 bytes 
+ *  - Others: Fail
+ */
+esp_err_t esp_event_isr_post(esp_event_base_t event_base,
+                            int32_t event_id,
+                            void* event_data,
+                            size_t event_data_size,
+                            BaseType_t* task_unblocked);
+
+/**
+ * @brief Special variant of esp_event_post_to for posting events from interrupt handlers
+ *
+ * @param[in] event_base the event base that identifies the event
+ * @param[in] event_id the event id that identifies the event
+ * @param[in] event_data the data, specific to the event occurence, that gets passed to the handler
+ * @param[in] event_data_size the size of the event data
+ * @param[out] task_unblocked an optional parameter (can be NULL) which indicates that an event task with 
+ *                            higher priority than currently running task has been unblocked by the posted event;
+ *                            a context switch should be requested before the interrupt is existed.
+ *
+ * @note this function is only available when CONFIG_ESP_EVENT_POST_FROM_ISR is enabled
+ * @note when this function is called from an interrupt handler placed in IRAM, this function should
+ *       be placed in IRAM as well by enabling CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_FAIL: Event queue for the loop full
+ *  - ESP_ERR_INVALID_ARG: Invalid combination of event base and event id,
+ *                          data size of more than 4 bytes 
+ *  - Others: Fail
+ */
+esp_err_t esp_event_isr_post_to(esp_event_loop_handle_t event_loop,
+                            esp_event_base_t event_base,
+                            int32_t event_id,
+                            void* event_data,
+                            size_t event_data_size,
+                            BaseType_t* task_unblocked);
+#endif
+
+/**
+ * @brief Dumps statistics of all event loops.
+ *
+ * Dumps event loop info in the format:
+ *
+ @verbatim
+       event loop
+           handler
+           handler
+           ...
+       event loop
+           handler
+           handler
+           ...
+
+  where:
+
+   event loop
+       format: address,name rx:total_recieved dr:total_dropped
+       where:
+           address - memory address of the event loop
+           name - name of the event loop, 'none' if no dedicated task
+           total_recieved - number of successfully posted events
+           total_dropped - number of events unsucessfully posted due to queue being full
+
+   handler
+       format: address ev:base,id inv:total_invoked run:total_runtime
+       where:
+           address - address of the handler function
+           base,id - the event specified by event base and id this handler executes
+           total_invoked - number of times this handler has been invoked
+           total_runtime - total amount of time used for invoking this handler
+
+ @endverbatim
+ *
+ * @param[in] file the file stream to output to
+ *
+ * @note this function is a noop when CONFIG_ESP_EVENT_LOOP_PROFILING is disabled
+ *
+ * @return
+ *  - ESP_OK: Success
+ *  - ESP_ERR_NO_MEM: Cannot allocate memory for event loops list
+ *  - Others: Fail
+ */
+esp_err_t esp_event_dump(FILE* file);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // #ifndef ESP_EVENT_H_

components/esp_event/include/esp_event_base.h

@@ -0,0 +1,43 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//         http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ESP_EVENT_BASE_H_
+#define ESP_EVENT_BASE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Defines for declaring and defining event base
+#define ESP_EVENT_DECLARE_BASE(id) extern esp_event_base_t id
+#define ESP_EVENT_DEFINE_BASE(id) esp_event_base_t id = #id
+
+// Event loop library types
+typedef const char*  esp_event_base_t; /**< unique pointer to a subsystem that exposes events */
+typedef void*        esp_event_loop_handle_t; /**< a number that identifies an event with respect to a base */
+typedef void         (*esp_event_handler_t)(void* event_handler_arg, 
+                                        esp_event_base_t event_base, 
+                                        int32_t event_id, 
+                                        void* event_data); /**< function called when an event is posted to the queue */
+
+
+// Defines for registering/unregistering event handlers
+#define ESP_EVENT_ANY_BASE     NULL             /**< register handler for any event base */
+#define ESP_EVENT_ANY_ID       -1               /**< register handler for any event id */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // #ifndef ESP_EVENT_BASE_H_

components/esp_event/include/esp_event_legacy.h

@@ -0,0 +1,222 @@
+// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "esp_err.h"
+#include "esp_wifi_types.h"
+#include "tcpip_adapter.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** System event types enumeration */
+typedef enum {
+    SYSTEM_EVENT_WIFI_READY = 0,           /*!< ESP32 WiFi ready */
+    SYSTEM_EVENT_SCAN_DONE,                /*!< ESP32 finish scanning AP */
+    SYSTEM_EVENT_STA_START,                /*!< ESP32 station start */
+    SYSTEM_EVENT_STA_STOP,                 /*!< ESP32 station stop */
+    SYSTEM_EVENT_STA_CONNECTED,            /*!< ESP32 station connected to AP */
+    SYSTEM_EVENT_STA_DISCONNECTED,         /*!< ESP32 station disconnected from AP */
+    SYSTEM_EVENT_STA_AUTHMODE_CHANGE,      /*!< the auth mode of AP connected by ESP32 station changed */
+    SYSTEM_EVENT_STA_GOT_IP,               /*!< ESP32 station got IP from connected AP */
+    SYSTEM_EVENT_STA_LOST_IP,              /*!< ESP32 station lost IP and the IP is reset to 0 */
+    SYSTEM_EVENT_STA_WPS_ER_SUCCESS,       /*!< ESP32 station wps succeeds in enrollee mode */
+    SYSTEM_EVENT_STA_WPS_ER_FAILED,        /*!< ESP32 station wps fails in enrollee mode */
+    SYSTEM_EVENT_STA_WPS_ER_TIMEOUT,       /*!< ESP32 station wps timeout in enrollee mode */
+    SYSTEM_EVENT_STA_WPS_ER_PIN,           /*!< ESP32 station wps pin code in enrollee mode */
+    SYSTEM_EVENT_STA_WPS_ER_PBC_OVERLAP,   /*!< ESP32 station wps overlap in enrollee mode */
+    SYSTEM_EVENT_AP_START,                 /*!< ESP32 soft-AP start */
+    SYSTEM_EVENT_AP_STOP,                  /*!< ESP32 soft-AP stop */
+    SYSTEM_EVENT_AP_STACONNECTED,          /*!< a station connected to ESP32 soft-AP */
+    SYSTEM_EVENT_AP_STADISCONNECTED,       /*!< a station disconnected from ESP32 soft-AP */
+    SYSTEM_EVENT_AP_STAIPASSIGNED,         /*!< ESP32 soft-AP assign an IP to a connected station */
+    SYSTEM_EVENT_AP_PROBEREQRECVED,        /*!< Receive probe request packet in soft-AP interface */
+    SYSTEM_EVENT_GOT_IP6,                  /*!< ESP32 station or ap or ethernet interface v6IP addr is preferred */
+    SYSTEM_EVENT_ETH_START,                /*!< ESP32 ethernet start */
+    SYSTEM_EVENT_ETH_STOP,                 /*!< ESP32 ethernet stop */
+    SYSTEM_EVENT_ETH_CONNECTED,            /*!< ESP32 ethernet phy link up */
+    SYSTEM_EVENT_ETH_DISCONNECTED,         /*!< ESP32 ethernet phy link down */
+    SYSTEM_EVENT_ETH_GOT_IP,               /*!< ESP32 ethernet got IP from connected AP */
+    SYSTEM_EVENT_MAX                       /*!< Number of members in this enum */
+} system_event_id_t;
+
+/* add this macro define for compatible with old IDF version */
+#ifndef SYSTEM_EVENT_AP_STA_GOT_IP6
+#define SYSTEM_EVENT_AP_STA_GOT_IP6 SYSTEM_EVENT_GOT_IP6
+#endif
+
+
+/** Argument structure of SYSTEM_EVENT_STA_WPS_ER_FAILED event */
+typedef wifi_event_sta_wps_fail_reason_t system_event_sta_wps_fail_reason_t;
+
+/** Argument structure of SYSTEM_EVENT_SCAN_DONE event */
+typedef wifi_event_sta_scan_done_t system_event_sta_scan_done_t;
+
+/** Argument structure of SYSTEM_EVENT_STA_CONNECTED event */
+typedef wifi_event_sta_connected_t system_event_sta_connected_t;
+
+/** Argument structure of SYSTEM_EVENT_STA_DISCONNECTED event */
+typedef wifi_event_sta_disconnected_t system_event_sta_disconnected_t;
+
+/** Argument structure of SYSTEM_EVENT_STA_AUTHMODE_CHANGE event */
+typedef wifi_event_sta_authmode_change_t system_event_sta_authmode_change_t;
+
+/** Argument structure of SYSTEM_EVENT_STA_WPS_ER_PIN event */
+typedef wifi_event_sta_wps_er_pin_t system_event_sta_wps_er_pin_t;
+
+/** Argument structure of  event */
+typedef wifi_event_ap_staconnected_t system_event_ap_staconnected_t;
+
+/** Argument structure of  event */
+typedef wifi_event_ap_stadisconnected_t system_event_ap_stadisconnected_t;
+
+/** Argument structure of  event */
+typedef wifi_event_ap_probe_req_rx_t system_event_ap_probe_req_rx_t;
+
+/** Argument structure of  event */
+typedef ip_event_ap_staipassigned_t system_event_ap_staipassigned_t;
+
+/** Argument structure of  event */
+typedef ip_event_got_ip_t system_event_sta_got_ip_t;
+
+/** Argument structure of  event */
+typedef ip_event_got_ip6_t system_event_got_ip6_t;
+
+/** Union of all possible system_event argument structures */
+typedef union {
+    system_event_sta_connected_t               connected;          /*!< ESP32 station connected to AP */
+    system_event_sta_disconnected_t            disconnected;       /*!< ESP32 station disconnected to AP */
+    system_event_sta_scan_done_t               scan_done;          /*!< ESP32 station scan (APs) done */
+    system_event_sta_authmode_change_t         auth_change;        /*!< the auth mode of AP ESP32 station connected to changed */
+    system_event_sta_got_ip_t                  got_ip;             /*!< ESP32 station got IP, first time got IP or when IP is changed */
+    system_event_sta_wps_er_pin_t              sta_er_pin;         /*!< ESP32 station WPS enrollee mode PIN code received */
+    system_event_sta_wps_fail_reason_t         sta_er_fail_reason; /*!< ESP32 station WPS enrollee mode failed reason code received */
+    system_event_ap_staconnected_t             sta_connected;      /*!< a station connected to ESP32 soft-AP */
+    system_event_ap_stadisconnected_t          sta_disconnected;   /*!< a station disconnected to ESP32 soft-AP */
+    system_event_ap_probe_req_rx_t             ap_probereqrecved;  /*!< ESP32 soft-AP receive probe request packet */
+    system_event_ap_staipassigned_t            ap_staipassigned;   /**< ESP32 soft-AP assign an IP to the station*/
+    system_event_got_ip6_t                     got_ip6;            /*!< ESP32 station　or ap or ethernet ipv6 addr state change to preferred */
+} system_event_info_t;
+
+/** Event, as a tagged enum */
+typedef struct {
+    system_event_id_t     event_id;      /*!< event ID */
+    system_event_info_t   event_info;    /*!< event information */
+} system_event_t;
+
+/** Event handler function type */
+typedef esp_err_t (*system_event_handler_t)(system_event_t *event);
+
+/**
+  * @brief  Send a event to event task
+  *
+  * @note This API is part of the legacy event system. New code should use event library API in esp_event.h
+  *
+  * Other task/modules, such as the tcpip_adapter, can call this API to send an event to event task
+  *
+  * @param event Event to send
+  *
+  * @return ESP_OK : succeed
+  * @return others : fail
+  */
+esp_err_t esp_event_send(system_event_t *event);
+
+/**
+ * @brief  Default event handler for system events
+ *
+ * @note This API is part of the legacy event system. New code should use event library API in esp_event.h
+ *
+ * This function performs default handling of system events.
+ * When using esp_event_loop APIs, it is called automatically before invoking the user-provided
+ * callback function.
+ *
+ * Applications which implement a custom event loop must call this function
+ * as part of event processing.
+ *
+ * @param  event   pointer to event to be handled
+ * @return ESP_OK if an event was handled successfully
+ */
+esp_err_t esp_event_process_default(system_event_t *event);
+
+/**
+  * @brief  Install default event handlers for Ethernet interface
+  *
+  * @note This API is part of the legacy event system. New code should use event library API in esp_event.h
+  *
+  */
+void esp_event_set_default_eth_handlers();
+
+/**
+  * @brief  Install default event handlers for Wi-Fi interfaces (station and AP)
+  *
+  * @note This API is part of the legacy event system. New code should use event library API in esp_event.h
+  */
+void esp_event_set_default_wifi_handlers();
+
+/**
+ * @brief  Application specified event callback function
+ *
+ * @note This API is part of the legacy event system. New code should use event library API in esp_event.h
+ *
+ *
+ * @param  ctx    reserved for user
+ * @param  event  event type defined in this file
+ *
+ * @return
+ *    - ESP_OK: succeed
+ *    - others: fail
+ */
+typedef esp_err_t (*system_event_cb_t)(void *ctx, system_event_t *event);
+
+/**
+ * @brief  Initialize event loop
+ *
+ * @note This API is part of the legacy event system. New code should use event library API in esp_event.h
+ *
+ * Create the event handler and task
+ *
+ * @param  cb   application specified event callback, it can be modified by call esp_event_set_cb
+ * @param  ctx  reserved for user
+ *
+ * @return
+ *    - ESP_OK: succeed
+ *    - others: fail
+ */
+esp_err_t esp_event_loop_init(system_event_cb_t cb, void *ctx);
+
+/**
+ * @brief  Set application specified event callback function
+ *
+ * @note This API is part of the legacy event system. New code should use event library API in esp_event.h
+ *
+ * @attention 1. If cb is NULL, means application don't need to handle
+ *               If cb is not NULL, it will be call when an event is received, after the default event callback is completed
+ *
+ * @param  cb   application callback function
+ * @param  ctx  argument to be passed to callback
+ *
+ *
+ * @return old callback
+ */
+system_event_cb_t esp_event_loop_set_cb(system_event_cb_t cb, void *ctx);
+
+#ifdef __cplusplus
+}
+#endif
+

components/esp_event/include/esp_event_loop.h

@@ -0,0 +1 @@
+#include "esp_event_legacy.h"

components/esp_event/linker.lf

@@ -0,0 +1,6 @@
+if ESP_EVENT_POST_FROM_IRAM_ISR = y:
+    [mapping:esp_event]
+    archive: libesp_event.a
+    entries:
+        esp_event:esp_event_isr_post_to (noflash)
+        default_event_loop:esp_event_isr_post (noflash)

components/esp_event/private_include/esp_event_internal.h

@@ -0,0 +1,112 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ESP_EVENT_INTERNAL_H_
+#define ESP_EVENT_INTERNAL_H_
+
+#include "esp_event.h"
+#include "stdatomic.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef SLIST_HEAD(base_nodes, base_node) base_nodes_t;
+
+/// Event handler
+typedef struct esp_event_handler_instance {
+    esp_event_handler_t handler;                                    /**< event handler function*/
+    void* arg;                                                      /**< event handler argument */
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    uint32_t invoked;                                               /**< number of times this handler has been invoked */
+    int64_t time;                                                   /**< total runtime of this handler across all calls */
+#endif
+    SLIST_ENTRY(esp_event_handler_instance) next;                   /**< next event handler in the list */
+} esp_event_handler_instance_t;
+
+typedef SLIST_HEAD(esp_event_handler_instances, esp_event_handler_instance) esp_event_handler_instances_t;
+
+/// Event
+typedef struct esp_event_id_node {
+    int32_t id;                                                     /**< id number of the event */
+    esp_event_handler_instances_t handlers;                         /**< list of handlers to be executed when
+                                                                            this event is raised */
+    SLIST_ENTRY(esp_event_id_node) next;                            /**< pointer to the next event node on the linked list */
+} esp_event_id_node_t;
+
+typedef SLIST_HEAD(esp_event_id_nodes, esp_event_id_node) esp_event_id_nodes_t;
+
+typedef struct esp_event_base_node {
+    esp_event_base_t base;                                          /**< base identifier of the event */
+    esp_event_handler_instances_t handlers;                         /**< event base level handlers, handlers for
+                                                                            all events with this base */
+    esp_event_id_nodes_t id_nodes;                                  /**< list of event ids with this base */
+    SLIST_ENTRY(esp_event_base_node) next;                          /**< pointer to the next base node on the linked list */
+} esp_event_base_node_t;
+
+typedef SLIST_HEAD(esp_event_base_nodes, esp_event_base_node) esp_event_base_nodes_t;
+
+typedef struct esp_event_loop_node {
+    esp_event_handler_instances_t handlers;                         /** event loop level handlers */
+    esp_event_base_nodes_t base_nodes;                              /** list of event bases registered to the loop */
+    SLIST_ENTRY(esp_event_loop_node) next;                          /** pointer to the next loop node containing
+                                                                            event loop level handlers and the rest of
+                                                                            event bases registered to the loop */
+} esp_event_loop_node_t;
+
+typedef SLIST_HEAD(esp_event_loop_nodes, esp_event_loop_node) esp_event_loop_nodes_t;
+
+/// Event loop
+typedef struct esp_event_loop_instance {
+    const char* name;                                               /**< name of this event loop */
+    QueueHandle_t queue;                                            /**< event queue */
+    TaskHandle_t task;                                              /**< task that consumes the event queue */
+    TaskHandle_t running_task;                                      /**< for loops with no dedicated task, the
+                                                                            task that consumes the queue */
+    SemaphoreHandle_t mutex;                                        /**< mutex for updating the events linked list */
+    esp_event_loop_nodes_t loop_nodes;                              /**< set of linked lists containing the
+                                                                            registered handlers for the loop */
+#ifdef CONFIG_ESP_EVENT_LOOP_PROFILING
+    atomic_uint_least32_t events_recieved;                          /**< number of events successfully posted to the loop */
+    atomic_uint_least32_t events_dropped;                           /**< number of events dropped due to queue being full */
+    SemaphoreHandle_t profiling_mutex;                              /**< mutex used for profiliing */
+    SLIST_ENTRY(esp_event_loop_instance) next;                      /**< next event loop in the list */
+#endif
+} esp_event_loop_instance_t;
+
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+typedef union esp_event_post_data {
+    uint32_t val;
+    void *ptr;
+} esp_event_post_data_t;
+#else
+typedef void* esp_event_post_data_t;
+#endif
+
+/// Event posted to the event queue
+typedef struct esp_event_post_instance {
+#if CONFIG_ESP_EVENT_POST_FROM_ISR
+    bool data_allocated;                                             /**< indicates whether data is allocated from heap */
+    bool data_set;                                                   /**< indicates if data is null */
+#endif
+    esp_event_base_t base;                                           /**< the event base */
+    int32_t id;                                                      /**< the event id */
+    esp_event_post_data_t data;                                      /**< data associated with the event */
+} esp_event_post_instance_t;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // #ifndef ESP_EVENT_INTERNAL_H_

components/esp_event/private_include/esp_event_private.h

@@ -0,0 +1,54 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ESP_EVENT_PRIVATE_H_
+#define ESP_EVENT_PRIVATE_H_
+
+#include "esp_event.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Searches handlers registered with an event loop to see if it has been registered.
+ *
+ * @param[in] event_loop the loop to search
+ * @param[in] event_base the event base to search
+ * @param[in] event_id the event id to search
+ * @param[in] event_handler the event handler to look for
+ *
+ * @return true handler registered
+ * @return false handler not registered
+ * 
+ * @return 
+ *  - true: Handler registered
+ *  - false:  Handler not registered
+ */
+bool esp_event_is_handler_registered(esp_event_loop_handle_t event_loop, esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler);
+
+/**
+ * @brief Deinitializes the event loop library
+ *
+ * @return 
+ *  - ESP_OK: Success
+ *  - Others: Fail
+ */
+esp_err_t esp_event_loop_deinit();
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // #ifndef ESP_EVENT_PRIVATE_H_

components/esp_event/sdkconfig.rename

@@ -0,0 +1,6 @@
+# sdkconfig replacement configurations for deprecated options formatted as
+# CONFIG_DEPRECATED_OPTION CONFIG_NEW_OPTION
+
+CONFIG_EVENT_LOOP_PROFILING         CONFIG_ESP_EVENT_LOOP_PROFILING
+CONFIG_POST_EVENTS_FROM_ISR         CONFIG_ESP_EVENT_POST_FROM_ISR
+CONFIG_POST_EVENTS_FROM_IRAM_ISR    CONFIG_ESP_EVENT_POST_FROM_IRAM_ISR

components/esp_event/test/CMakeLists.txt

@@ -0,0 +1,3 @@
+idf_component_register(SRC_DIRS "."
+                    PRIV_INCLUDE_DIRS "../private_include" "."
+                    REQUIRES unity test_utils esp_event driver)

components/esp_event/test/component.mk

@@ -0,0 +1,5 @@
+#
+#Component Makefile
+#
+COMPONENT_PRIV_INCLUDEDIRS := ../private_include .
+COMPONENT_ADD_LDFLAGS = -Wl,--whole-archive -l$(COMPONENT_NAME) -Wl,--no-whole-archive

components/tcpip_adapter/event_handlers.c

@@ -0,0 +1,308 @@
+// Copyright 2018 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include "tcpip_adapter.h"
+#include "esp_event.h"
+#include "esp_wifi.h"
+#include "esp_private/wifi.h"
+#include "esp_eth.h"
+#include "esp_err.h"
+#include "esp_log.h"
+
+static const char *TAG = "tcpip_adapter";
+
+#define API_CALL_CHECK(info, api_call, ret) \
+do{\
+    esp_err_t __err = (api_call);\
+    if ((ret) != __err) {\
+        ESP_LOGE(TAG, "%s %d %s ret=0x%X", __FUNCTION__, __LINE__, (info), __err);\
+        return;\
+    }\
+} while(0)
+
+typedef esp_err_t (*system_event_handler_t)(system_event_t *e);
+
+static void handle_ap_start(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_ap_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_sta_start(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_sta_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_sta_connected(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_sta_disconnected(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_sta_got_ip(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+
+static void handle_eth_start(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_eth_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_eth_connected(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_eth_disconnected(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+static void handle_eth_got_ip(void *arg, esp_event_base_t base, int32_t event_id, void *data);
+
+static void handle_eth_start(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_ip_info_t eth_ip;
+    uint8_t eth_mac[6];
+    esp_eth_handle_t eth_handle = *(esp_eth_handle_t*)data;
+    esp_eth_ioctl(eth_handle, ETH_CMD_G_MAC_ADDR, eth_mac);
+    tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_ETH, &eth_ip);
+    tcpip_adapter_eth_start(eth_mac, &eth_ip, eth_handle);
+}
+
+static void handle_eth_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_stop(TCPIP_ADAPTER_IF_ETH);
+}
+
+static void handle_eth_connected(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_dhcp_status_t status;
+
+    tcpip_adapter_up(TCPIP_ADAPTER_IF_ETH);
+
+    tcpip_adapter_dhcpc_get_status(TCPIP_ADAPTER_IF_ETH, &status);
+
+    if (status == TCPIP_ADAPTER_DHCP_INIT) {
+        tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_ETH);
+    } else if (status == TCPIP_ADAPTER_DHCP_STOPPED) {
+        tcpip_adapter_ip_info_t eth_ip;
+
+        tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_ETH, &eth_ip);
+
+        if (!(ip4_addr_isany_val(eth_ip.ip) || ip4_addr_isany_val(eth_ip.netmask))) {
+            system_event_t evt;
+
+            //notify event
+            evt.event_id = SYSTEM_EVENT_ETH_GOT_IP;
+            memcpy(&evt.event_info.got_ip.ip_info, &eth_ip, sizeof(tcpip_adapter_ip_info_t));
+
+            esp_event_send(&evt);
+        } else {
+            ESP_LOGE(TAG, "invalid static ip");
+        }
+    }
+}
+
+static void handle_eth_disconnected(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_down(TCPIP_ADAPTER_IF_ETH);
+}
+
+static void handle_sta_got_ip(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    API_CALL_CHECK("esp_wifi_internal_set_sta_ip", esp_wifi_internal_set_sta_ip(), ESP_OK);
+
+    const ip_event_got_ip_t *event = (const ip_event_got_ip_t *) data;
+    ESP_LOGI(TAG, "sta ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR,
+             IP2STR(&event->ip_info.ip),
+             IP2STR(&event->ip_info.netmask),
+             IP2STR(&event->ip_info.gw));
+}
+
+static void handle_eth_got_ip(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    const ip_event_got_ip_t *event = (const ip_event_got_ip_t *) data;
+    ESP_LOGI(TAG, "eth ip: " IPSTR ", mask: " IPSTR ", gw: " IPSTR,
+             IP2STR(&event->ip_info.ip),
+             IP2STR(&event->ip_info.netmask),
+             IP2STR(&event->ip_info.gw));
+}
+
+static void handle_ap_start(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_ip_info_t ap_ip;
+    uint8_t ap_mac[6];
+
+    API_CALL_CHECK("esp_wifi_internal_reg_rxcb", esp_wifi_internal_reg_rxcb(ESP_IF_WIFI_AP, (wifi_rxcb_t)tcpip_adapter_ap_input), ESP_OK);
+    API_CALL_CHECK("esp_wifi_mac_get",  esp_wifi_get_mac(ESP_IF_WIFI_AP, ap_mac), ESP_OK);
+
+    tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_AP, &ap_ip);
+    tcpip_adapter_ap_start(ap_mac, &ap_ip);
+}
+
+static void handle_ap_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    API_CALL_CHECK("esp_wifi_internal_reg_rxcb", esp_wifi_internal_reg_rxcb(ESP_IF_WIFI_AP, NULL), ESP_OK);
+
+    tcpip_adapter_stop(TCPIP_ADAPTER_IF_AP);
+}
+
+static void handle_sta_start(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_ip_info_t sta_ip;
+    uint8_t sta_mac[6];
+
+    API_CALL_CHECK("esp_wifi_mac_get",  esp_wifi_get_mac(ESP_IF_WIFI_STA, sta_mac), ESP_OK);
+    tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &sta_ip);
+    tcpip_adapter_sta_start(sta_mac, &sta_ip);
+}
+
+static void handle_sta_stop(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_stop(TCPIP_ADAPTER_IF_STA);
+}
+
+static void handle_sta_connected(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_dhcp_status_t status;
+
+    API_CALL_CHECK("esp_wifi_internal_reg_rxcb", esp_wifi_internal_reg_rxcb(ESP_IF_WIFI_STA, (wifi_rxcb_t)tcpip_adapter_sta_input), ESP_OK);
+
+    tcpip_adapter_up(TCPIP_ADAPTER_IF_STA);
+
+    tcpip_adapter_dhcpc_get_status(TCPIP_ADAPTER_IF_STA, &status);
+
+    if (status == TCPIP_ADAPTER_DHCP_INIT) {
+        tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
+    } else if (status == TCPIP_ADAPTER_DHCP_STOPPED) {
+        tcpip_adapter_ip_info_t sta_ip;
+        tcpip_adapter_ip_info_t sta_old_ip;
+
+        tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &sta_ip);
+        tcpip_adapter_get_old_ip_info(TCPIP_ADAPTER_IF_STA, &sta_old_ip);
+
+        if (!(ip4_addr_isany_val(sta_ip.ip) || ip4_addr_isany_val(sta_ip.netmask))) {
+            system_event_t evt;
+
+            evt.event_id = SYSTEM_EVENT_STA_GOT_IP;
+            evt.event_info.got_ip.ip_changed = false;
+
+            if (memcmp(&sta_ip, &sta_old_ip, sizeof(sta_ip))) {
+                evt.event_info.got_ip.ip_changed = true;
+            }
+
+            memcpy(&evt.event_info.got_ip.ip_info, &sta_ip, sizeof(tcpip_adapter_ip_info_t));
+            tcpip_adapter_set_old_ip_info(TCPIP_ADAPTER_IF_STA, &sta_ip);
+
+            esp_event_send(&evt);
+            ESP_LOGD(TAG, "static ip: ip changed=%d", evt.event_info.got_ip.ip_changed);
+        } else {
+            ESP_LOGE(TAG, "invalid static ip");
+        }
+    }
+}
+
+static void handle_sta_disconnected(void *arg, esp_event_base_t base, int32_t event_id, void *data)
+{
+    tcpip_adapter_down(TCPIP_ADAPTER_IF_STA);
+    API_CALL_CHECK("esp_wifi_internal_reg_rxcb", esp_wifi_internal_reg_rxcb(ESP_IF_WIFI_STA, NULL), ESP_OK);
+}
+
+
+esp_err_t tcpip_adapter_set_default_wifi_handlers()
+{
+    esp_err_t err;
+    err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_START, handle_sta_start, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_STOP, handle_sta_stop, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, handle_sta_connected, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, handle_sta_disconnected, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_AP_START, handle_ap_start, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_AP_STOP, handle_ap_stop, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, handle_sta_got_ip, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_register_shutdown_handler((shutdown_handler_t)esp_wifi_stop);
+    if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
+        goto fail;
+    }
+
+    return ESP_OK;
+
+fail:
+    tcpip_adapter_clear_default_wifi_handlers();
+    return err;
+}
+
+esp_err_t tcpip_adapter_clear_default_wifi_handlers()
+{
+    esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_START, handle_sta_start);
+    esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_STOP, handle_sta_stop);
+    esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, handle_sta_connected);
+    esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, handle_sta_disconnected);
+    esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_START, handle_ap_start);
+    esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_AP_STOP, handle_ap_stop);
+    esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, handle_sta_got_ip);
+    esp_unregister_shutdown_handler((shutdown_handler_t)esp_wifi_stop);
+
+    return ESP_OK;
+}
+
+esp_err_t tcpip_adapter_set_default_eth_handlers()
+{
+    esp_err_t err;
+    err = esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_START, handle_eth_start, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_STOP, handle_eth_stop, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_CONNECTED, handle_eth_connected, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_DISCONNECTED, handle_eth_disconnected, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    err = esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, handle_eth_got_ip, NULL);
+    if (err != ESP_OK) {
+        goto fail;
+    }
+
+    return ESP_OK;
+
+fail:
+    tcpip_adapter_clear_default_eth_handlers();
+    return err;
+}
+
+esp_err_t tcpip_adapter_clear_default_eth_handlers()
+{
+    esp_event_handler_unregister(ETH_EVENT, ETHERNET_EVENT_START, handle_eth_start);
+    esp_event_handler_unregister(ETH_EVENT, ETHERNET_EVENT_STOP, handle_eth_stop);
+    esp_event_handler_unregister(ETH_EVENT, ETHERNET_EVENT_CONNECTED, handle_eth_connected);
+    esp_event_handler_unregister(ETH_EVENT, ETHERNET_EVENT_DISCONNECTED, handle_eth_disconnected);
+    esp_event_handler_unregister(IP_EVENT, IP_EVENT_ETH_GOT_IP, handle_eth_got_ip);
+    return ESP_OK;
+}