添加智能灯固件代码

firmware/esp-idf/wumei-smart-firmware/examples/common_components/protocol_examples_common/CMakeLists.txt

@@ -0,0 +1,4 @@
+idf_component_register(SRCS "connect.c" "stdin_out.c" "addr_from_stdin.c"
+                    INCLUDE_DIRS "include"
+                    PRIV_REQUIRES esp_netif
+                    )

firmware/esp-idf/wumei-smart-firmware/examples/common_components/protocol_examples_common/Kconfig.projbuild

@@ -0,0 +1,218 @@
+menu "Example Connection Configuration"
+
+    config EXAMPLE_CONNECT_WIFI
+        bool "connect using WiFi interface"
+        default y
+        help
+            Protocol examples can use Wi-Fi and/or Ethernet to connect to the network.
+            Choose this option to connect with WiFi
+
+    if EXAMPLE_CONNECT_WIFI
+        config EXAMPLE_WIFI_SSID
+            string "WiFi SSID"
+            default "myssid"
+            help
+                SSID (network name) for the example to connect to.
+
+        config EXAMPLE_WIFI_PASSWORD
+            string "WiFi Password"
+            default "mypassword"
+            help
+                WiFi password (WPA or WPA2) for the example to use.
+                Can be left blank if the network has no security set.
+    endif
+
+    config EXAMPLE_CONNECT_ETHERNET
+        bool "connect using Ethernet interface"
+        default n
+        help
+            Protocol examples can use Wi-Fi and/or Ethernet to connect to the network.
+            Choose this option to connect with Ethernet
+
+    if EXAMPLE_CONNECT_ETHERNET
+        choice EXAMPLE_USE_ETHERNET
+            prompt "Ethernet Type"
+            default EXAMPLE_USE_INTERNAL_ETHERNET if IDF_TARGET_ESP32
+            default EXAMPLE_USE_DM9051 if !IDF_TARGET_ESP32
+            help
+                Select which kind of Ethernet will be used in the example.
+
+            config EXAMPLE_USE_INTERNAL_ETHERNET
+                depends on IDF_TARGET_ESP32
+                select ETH_USE_ESP32_EMAC
+                bool "Internal EMAC"
+                help
+                    Select internal Ethernet MAC controller.
+
+            config EXAMPLE_USE_DM9051
+                bool "DM9051 Module"
+                select ETH_USE_SPI_ETHERNET
+                select ETH_SPI_ETHERNET_DM9051
+                help
+                    Select external SPI-Ethernet module.
+
+            config EXAMPLE_USE_OPENETH
+                bool "OpenCores Ethernet MAC (EXPERIMENTAL)"
+                select ETH_USE_OPENETH
+                help
+                    When this option is enabled, the example is built with support for
+                    OpenCores Ethernet MAC, which allows testing the example in QEMU.
+                    Note that this option is used for internal testing purposes, and
+                    not officially supported. Examples built with this option enabled
+                    will not run on a real ESP32 chip.
+
+        endchoice
+
+        if EXAMPLE_USE_INTERNAL_ETHERNET
+            choice EXAMPLE_ETH_PHY_MODEL
+                prompt "Ethernet PHY Device"
+                default EXAMPLE_ETH_PHY_IP101
+                help
+                    Select the Ethernet PHY device to use in the example.
+
+                config EXAMPLE_ETH_PHY_IP101
+                    bool "IP101"
+                    help
+                        IP101 is a single port 10/100 MII/RMII/TP/Fiber Fast Ethernet Transceiver.
+                        Goto http://www.icplus.com.tw/pp-IP101G.html for more information about it.
+
+                config EXAMPLE_ETH_PHY_RTL8201
+                    bool "RTL8201/SR8201"
+                    help
+                        RTL8201F/SR8201F is a single port 10/100Mb Ethernet Transceiver with auto MDIX.
+                        Goto http://www.corechip-sz.com/productsview.asp?id=22 for more information about it.
+
+                config EXAMPLE_ETH_PHY_LAN8720
+                    bool "LAN8720"
+                    help
+                        LAN8720A is a small footprint RMII 10/100 Ethernet Transceiver with HP Auto-MDIX Support.
+                        Goto https://www.microchip.com/LAN8720A for more information about it.
+
+                config EXAMPLE_ETH_PHY_DP83848
+                    bool "DP83848"
+                    help
+                        DP83848 is a single port 10/100Mb/s Ethernet Physical Layer Transceiver.
+                        Goto http://www.ti.com/product/DP83848J for more information about it.
+            endchoice
+
+            config EXAMPLE_ETH_MDC_GPIO
+                int "SMI MDC GPIO number"
+                default 23
+                help
+                    Set the GPIO number used by SMI MDC.
+
+            config EXAMPLE_ETH_MDIO_GPIO
+                int "SMI MDIO GPIO number"
+                default 18
+                help
+                    Set the GPIO number used by SMI MDIO.
+        endif
+
+        if EXAMPLE_USE_DM9051
+            config EXAMPLE_DM9051_SPI_HOST
+                int "SPI Host Number"
+                range 0 2
+                default 1
+                help
+                    Set the SPI host used to communicate with DM9051.
+
+            config EXAMPLE_DM9051_SCLK_GPIO
+                int "SPI SCLK GPIO number"
+                range 0 33
+                default 19
+                help
+                    Set the GPIO number used by SPI SCLK.
+
+            config EXAMPLE_DM9051_MOSI_GPIO
+                int "SPI MOSI GPIO number"
+                range 0 33
+                default 23
+                help
+                    Set the GPIO number used by SPI MOSI.
+
+            config EXAMPLE_DM9051_MISO_GPIO
+                int "SPI MISO GPIO number"
+                range 0 33
+                default 25
+                help
+                    Set the GPIO number used by SPI MISO.
+
+            config EXAMPLE_DM9051_CS_GPIO
+                int "SPI CS GPIO number"
+                range 0 33
+                default 22
+                help
+                    Set the GPIO number used by SPI CS.
+
+            config EXAMPLE_DM9051_SPI_CLOCK_MHZ
+                int "SPI clock speed (MHz)"
+                range 20 80
+                default 20
+                help
+                    Set the clock speed (MHz) of SPI interface.
+
+            config EXAMPLE_DM9051_INT_GPIO
+                int "Interrupt GPIO number"
+                default 4
+                help
+                    Set the GPIO number used by DM9051 interrupt.
+        endif
+
+        config EXAMPLE_ETH_PHY_RST_GPIO
+            int "PHY Reset GPIO number"
+            default 5
+            help
+                Set the GPIO number used to reset PHY chip.
+                Set to -1 to disable PHY chip hardware reset.
+
+        config EXAMPLE_ETH_PHY_ADDR
+            int "PHY Address"
+            range 0 31 if EXAMPLE_USE_INTERNAL_ETHERNET
+            range 1 1 if !EXAMPLE_USE_INTERNAL_ETHERNET
+            default 1
+            help
+                Set PHY address according your board schematic.
+    endif
+
+    config EXAMPLE_CONNECT_IPV6
+        bool "Obtain IPv6 address"
+        default y
+        help
+            By default, examples will wait until IPv4 and IPv6 local link addresses are obtained.
+            Disable this option if the network does not support IPv6.
+            Choose the preferred IPv6 address type if the connection code should wait until other than
+            the local link address gets assigned.
+
+    if EXAMPLE_CONNECT_IPV6
+        choice EXAMPLE_CONNECT_PREFERRED_IPV6
+            prompt "Preferred IPv6 Type"
+            default EXAMPLE_CONNECT_IPV6_PREF_LOCAL_LINK
+            help
+                Select which kind of IPv6 address the connect logic waits for.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_LOCAL_LINK
+                bool "Local Link Address"
+                help
+                    Blocks until Local link address assigned.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_GLOBAL
+                bool "Global Address"
+                help
+                    Blocks until Global address assigned.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_SITE_LOCAL
+                bool "Site Local Address"
+                help
+                    Blocks until Site link address assigned.
+
+            config EXAMPLE_CONNECT_IPV6_PREF_UNIQUE_LOCAL
+                bool "Unique Local Link Address"
+                help
+                    Blocks until Unique local address assigned.
+
+        endchoice
+
+    endif
+
+
+endmenu

firmware/esp-idf/wumei-smart-firmware/examples/common_components/protocol_examples_common/addr_from_stdin.c

@@ -0,0 +1,65 @@
+#include <string.h>
+#include "esp_system.h"
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "protocol_examples_common.h"
+
+#include "lwip/sockets.h"
+#include <lwip/netdb.h>
+#include <arpa/inet.h>
+
+#define HOST_IP_SIZE 128
+
+esp_err_t get_addr_from_stdin(int port, int sock_type, int *ip_protocol, int *addr_family, struct sockaddr_in6 *dest_addr)
+{
+    char host_ip[HOST_IP_SIZE];
+    int len;
+    static bool already_init = false;
+
+    // this function could be called multiple times -> make sure UART init runs only once
+    if (!already_init) {
+        example_configure_stdin_stdout();
+        already_init = true;
+    }
+
+    // ignore empty or LF only string (could receive from DUT class)
+    do {
+        fgets(host_ip, HOST_IP_SIZE, stdin);
+        len = strlen(host_ip);
+    } while (len<=1 && host_ip[0] == '\n');
+    host_ip[len - 1] = '\0';
+
+    struct addrinfo hints, *addr_list, *cur;
+    memset( &hints, 0, sizeof( hints ) );
+
+    // run getaddrinfo() to decide on the IP protocol
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = sock_type;
+    hints.ai_protocol = IPPROTO_TCP;
+    if( getaddrinfo( host_ip, NULL, &hints, &addr_list ) != 0 ) {
+        return ESP_FAIL;
+    }
+    for( cur = addr_list; cur != NULL; cur = cur->ai_next ) {
+        memcpy(dest_addr, cur->ai_addr, sizeof(*dest_addr));
+        if (cur->ai_family == AF_INET) {
+            *ip_protocol = IPPROTO_IP;
+            *addr_family = AF_INET;
+            // add port number and return on first IPv4 match
+            ((struct sockaddr_in*)dest_addr)->sin_port = htons(port);
+            freeaddrinfo( addr_list );
+            return ESP_OK;
+
+        } else if (cur->ai_family == AF_INET6) {
+            *ip_protocol = IPPROTO_IPV6;
+            *addr_family = AF_INET6;
+            // add port and interface number and return on first IPv6 match
+            dest_addr->sin6_port = htons(port);
+            dest_addr->sin6_scope_id = esp_netif_get_netif_impl_index(EXAMPLE_INTERFACE);
+            freeaddrinfo( addr_list );
+            return ESP_OK;
+        }
+    }
+    // no match found
+    freeaddrinfo( addr_list );
+    return ESP_FAIL;
+}

firmware/esp-idf/wumei-smart-firmware/examples/common_components/protocol_examples_common/connect.c

@@ -0,0 +1,430 @@
+/* Common functions for protocol examples, to establish Wi-Fi or Ethernet connection.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#include <string.h>
+#include "protocol_examples_common.h"
+#include "sdkconfig.h"
+#include "esp_event.h"
+#include "esp_wifi.h"
+#include "esp_wifi_default.h"
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+#include "esp_eth.h"
+#endif
+#include "esp_log.h"
+#include "esp_netif.h"
+#include "driver/gpio.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "lwip/err.h"
+#include "lwip/sys.h"
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+#define MAX_IP6_ADDRS_PER_NETIF (5)
+#define NR_OF_IP_ADDRESSES_TO_WAIT_FOR (s_active_interfaces*2)
+
+#if defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_LOCAL_LINK)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_LINK_LOCAL
+#elif defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_GLOBAL)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_GLOBAL
+#elif defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_SITE_LOCAL)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_SITE_LOCAL
+#elif defined(CONFIG_EXAMPLE_CONNECT_IPV6_PREF_UNIQUE_LOCAL)
+#define EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE ESP_IP6_ADDR_IS_UNIQUE_LOCAL
+#endif // if-elif CONFIG_EXAMPLE_CONNECT_IPV6_PREF_...
+
+#else
+#define NR_OF_IP_ADDRESSES_TO_WAIT_FOR (s_active_interfaces)
+#endif
+
+static int s_active_interfaces = 0;
+static xSemaphoreHandle s_semph_get_ip_addrs;
+static esp_ip4_addr_t s_ip_addr;
+static esp_netif_t *s_example_esp_netif = NULL;
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+static esp_ip6_addr_t s_ipv6_addr;
+
+/* types of ipv6 addresses to be displayed on ipv6 events */
+static const char *s_ipv6_addr_types[] = {
+    "ESP_IP6_ADDR_IS_UNKNOWN",
+    "ESP_IP6_ADDR_IS_GLOBAL",
+    "ESP_IP6_ADDR_IS_LINK_LOCAL",
+    "ESP_IP6_ADDR_IS_SITE_LOCAL",
+    "ESP_IP6_ADDR_IS_UNIQUE_LOCAL",
+    "ESP_IP6_ADDR_IS_IPV4_MAPPED_IPV6"
+    };
+#endif
+
+static const char *TAG = "example_connect";
+
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+static esp_netif_t* wifi_start(void);
+static void wifi_stop(void);
+#endif
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+static esp_netif_t* eth_start(void);
+static void eth_stop(void);
+#endif
+
+/**
+ * @brief Checks the netif description if it contains specified prefix.
+ * All netifs created withing common connect component are prefixed with the module TAG,
+ * so it returns true if the specified netif is owned by this module
+ */
+static bool is_our_netif(const char *prefix, esp_netif_t *netif)
+{
+    return strncmp(prefix, esp_netif_get_desc(netif), strlen(prefix)-1) == 0;
+}
+
+/* set up connection, Wi-Fi and/or Ethernet */
+static void start(void)
+{
+
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+    s_example_esp_netif = wifi_start();
+    s_active_interfaces++;
+#endif
+
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+    s_example_esp_netif = eth_start();
+    s_active_interfaces++;
+#endif
+
+#if CONFIG_EXAMPLE_CONNECT_WIFI && CONFIG_EXAMPLE_CONNECT_ETHERNET
+    /* if both intefaces at once, clear out to indicate that multiple netifs are active */
+    s_example_esp_netif = NULL;
+#endif
+
+    s_semph_get_ip_addrs = xSemaphoreCreateCounting(NR_OF_IP_ADDRESSES_TO_WAIT_FOR, 0);
+}
+
+/* tear down connection, release resources */
+static void stop(void)
+{
+#if CONFIG_EXAMPLE_CONNECT_WIFI
+    wifi_stop();
+    s_active_interfaces--;
+#endif
+
+#if CONFIG_EXAMPLE_CONNECT_ETHERNET
+    eth_stop();
+    s_active_interfaces--;
+#endif
+}
+
+static void on_got_ip(void *arg, esp_event_base_t event_base,
+                      int32_t event_id, void *event_data)
+{
+    ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
+    if (!is_our_netif(TAG, event->esp_netif)) {
+        ESP_LOGW(TAG, "Got IPv4 from another interface \"%s\": ignored", esp_netif_get_desc(event->esp_netif));
+        return;
+    }
+    ESP_LOGI(TAG, "Got IPv4 event: Interface \"%s\" address: " IPSTR, esp_netif_get_desc(event->esp_netif), IP2STR(&event->ip_info.ip));
+    memcpy(&s_ip_addr, &event->ip_info.ip, sizeof(s_ip_addr));
+    xSemaphoreGive(s_semph_get_ip_addrs);
+}
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+
+static void on_got_ipv6(void *arg, esp_event_base_t event_base,
+                        int32_t event_id, void *event_data)
+{
+    ip_event_got_ip6_t *event = (ip_event_got_ip6_t *)event_data;
+    if (!is_our_netif(TAG, event->esp_netif)) {
+        ESP_LOGW(TAG, "Got IPv6 from another netif: ignored");
+        return;
+    }
+    esp_ip6_addr_type_t ipv6_type = esp_netif_ip6_get_addr_type(&event->ip6_info.ip);
+    ESP_LOGI(TAG, "Got IPv6 event: Interface \"%s\" address: " IPV6STR ", type: %s", esp_netif_get_desc(event->esp_netif),
+            IPV62STR(event->ip6_info.ip), s_ipv6_addr_types[ipv6_type]);
+    if (ipv6_type == EXAMPLE_CONNECT_PREFERRED_IPV6_TYPE) {
+        memcpy(&s_ipv6_addr, &event->ip6_info.ip, sizeof(s_ipv6_addr));
+        xSemaphoreGive(s_semph_get_ip_addrs);
+    }
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_IPV6
+
+esp_err_t example_connect(void)
+{
+    if (s_semph_get_ip_addrs != NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    start();
+    ESP_ERROR_CHECK(esp_register_shutdown_handler(&stop));
+    ESP_LOGI(TAG, "Waiting for IP(s)");
+    for (int i=0; i<NR_OF_IP_ADDRESSES_TO_WAIT_FOR; ++i) {
+        xSemaphoreTake(s_semph_get_ip_addrs, portMAX_DELAY);
+    }
+    // iterate over active interfaces, and print out IPs of "our" netifs
+    esp_netif_t *netif = NULL;
+    esp_netif_ip_info_t ip;
+    for (int i=0; i<esp_netif_get_nr_of_ifs(); ++i) {
+        netif = esp_netif_next(netif);
+        if (is_our_netif(TAG, netif)) {
+            ESP_LOGI(TAG, "Connected to %s", esp_netif_get_desc(netif));
+            ESP_ERROR_CHECK(esp_netif_get_ip_info(netif, &ip));
+
+            ESP_LOGI(TAG, "- IPv4 address: " IPSTR, IP2STR(&ip.ip));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+            esp_ip6_addr_t ip6[MAX_IP6_ADDRS_PER_NETIF];
+            int ip6_addrs = esp_netif_get_all_ip6(netif, ip6);
+            for (int j=0; j< ip6_addrs; ++j) {
+                esp_ip6_addr_type_t ipv6_type = esp_netif_ip6_get_addr_type(&(ip6[j]));
+                ESP_LOGI(TAG, "- IPv6 address: " IPV6STR ", type: %s", IPV62STR(ip6[j]), s_ipv6_addr_types[ipv6_type]);
+            }
+#endif
+
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t example_disconnect(void)
+{
+    if (s_semph_get_ip_addrs == NULL) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    vSemaphoreDelete(s_semph_get_ip_addrs);
+    s_semph_get_ip_addrs = NULL;
+    stop();
+    return ESP_OK;
+}
+
+#ifdef CONFIG_EXAMPLE_CONNECT_WIFI
+
+static void on_wifi_disconnect(void *arg, esp_event_base_t event_base,
+                               int32_t event_id, void *event_data)
+{
+    ESP_LOGI(TAG, "Wi-Fi disconnected, trying to reconnect...");
+    esp_err_t err = esp_wifi_connect();
+    if (err == ESP_ERR_WIFI_NOT_STARTED) {
+        return;
+    }
+    ESP_ERROR_CHECK(err);
+}
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+
+static void on_wifi_connect(void *esp_netif, esp_event_base_t event_base,
+                            int32_t event_id, void *event_data)
+{
+    esp_netif_create_ip6_linklocal(esp_netif);
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_IPV6
+
+static esp_netif_t* wifi_start(void)
+{
+    char *desc;
+    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
+
+    esp_netif_inherent_config_t esp_netif_config = ESP_NETIF_INHERENT_DEFAULT_WIFI_STA();
+    // Prefix the interface description with the module TAG
+    // Warning: the interface desc is used in tests to capture actual connection details (IP, gw, mask)
+    asprintf(&desc, "%s: %s", TAG, esp_netif_config.if_desc);
+    esp_netif_config.if_desc = desc;
+    esp_netif_config.route_prio = 128;
+    esp_netif_t *netif = esp_netif_create_wifi(WIFI_IF_STA, &esp_netif_config);
+    free(desc);
+    esp_wifi_set_default_wifi_sta_handlers();
+
+    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &on_wifi_disconnect, NULL));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &on_got_ip, NULL));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, &on_wifi_connect, netif));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6, NULL));
+#endif
+
+    ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
+    wifi_config_t wifi_config = {
+        .sta = {
+            .ssid = CONFIG_EXAMPLE_WIFI_SSID,
+            .password = CONFIG_EXAMPLE_WIFI_PASSWORD,
+        },
+    };
+    ESP_LOGI(TAG, "Connecting to %s...", wifi_config.sta.ssid);
+    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
+    ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config));
+    ESP_ERROR_CHECK(esp_wifi_start());
+    ESP_ERROR_CHECK(esp_wifi_connect());
+    return netif;
+}
+
+static void wifi_stop(void)
+{
+    esp_netif_t *wifi_netif = get_example_netif_from_desc("sta");
+    ESP_ERROR_CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_DISCONNECTED, &on_wifi_disconnect));
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, &on_got_ip));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6));
+    ESP_ERROR_CHECK(esp_event_handler_unregister(WIFI_EVENT, WIFI_EVENT_STA_CONNECTED, &on_wifi_connect));
+#endif
+    esp_err_t err = esp_wifi_stop();
+    if (err == ESP_ERR_WIFI_NOT_INIT) {
+        return;
+    }
+    ESP_ERROR_CHECK(err);
+    ESP_ERROR_CHECK(esp_wifi_deinit());
+    ESP_ERROR_CHECK(esp_wifi_clear_default_wifi_driver_and_handlers(wifi_netif));
+    esp_netif_destroy(wifi_netif);
+    s_example_esp_netif = NULL;
+}
+#endif // CONFIG_EXAMPLE_CONNECT_WIFI
+
+#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET
+
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+
+/** Event handler for Ethernet events */
+static void on_eth_event(void *esp_netif, esp_event_base_t event_base,
+                         int32_t event_id, void *event_data)
+{
+    switch (event_id) {
+    case ETHERNET_EVENT_CONNECTED:
+        ESP_LOGI(TAG, "Ethernet Link Up");
+        esp_netif_create_ip6_linklocal(esp_netif);
+        break;
+    default:
+        break;
+    }
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_IPV6
+
+static esp_eth_handle_t s_eth_handle = NULL;
+static esp_eth_mac_t *s_mac = NULL;
+static esp_eth_phy_t *s_phy = NULL;
+static void *s_eth_glue = NULL;
+
+static esp_netif_t* eth_start(void)
+{
+    char *desc;
+    esp_netif_inherent_config_t esp_netif_config = ESP_NETIF_INHERENT_DEFAULT_ETH();
+    // Prefix the interface description with the module TAG
+    // Warning: the interface desc is used in tests to capture actual connection details (IP, gw, mask)
+    asprintf(&desc, "%s: %s", TAG, esp_netif_config.if_desc);
+    esp_netif_config.if_desc = desc;
+    esp_netif_config.route_prio = 64;
+    esp_netif_config_t netif_config = {
+            .base = &esp_netif_config,
+            .stack = ESP_NETIF_NETSTACK_DEFAULT_ETH
+    };
+    esp_netif_t *netif = esp_netif_new(&netif_config);
+    assert(netif);
+    free(desc);
+    // Set default handlers to process TCP/IP stuffs
+    ESP_ERROR_CHECK(esp_eth_set_default_handlers(netif));
+    // Register user defined event handers
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_ETH_GOT_IP, &on_got_ip, NULL));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_register(ETH_EVENT, ETHERNET_EVENT_CONNECTED, &on_eth_event, netif));
+    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6, NULL));
+#endif
+    eth_mac_config_t mac_config = ETH_MAC_DEFAULT_CONFIG();
+    eth_phy_config_t phy_config = ETH_PHY_DEFAULT_CONFIG();
+    phy_config.phy_addr = CONFIG_EXAMPLE_ETH_PHY_ADDR;
+    phy_config.reset_gpio_num = CONFIG_EXAMPLE_ETH_PHY_RST_GPIO;
+#if CONFIG_EXAMPLE_USE_INTERNAL_ETHERNET
+    mac_config.smi_mdc_gpio_num = CONFIG_EXAMPLE_ETH_MDC_GPIO;
+    mac_config.smi_mdio_gpio_num = CONFIG_EXAMPLE_ETH_MDIO_GPIO;
+    s_mac = esp_eth_mac_new_esp32(&mac_config);
+#if CONFIG_EXAMPLE_ETH_PHY_IP101
+    s_phy = esp_eth_phy_new_ip101(&phy_config);
+#elif CONFIG_EXAMPLE_ETH_PHY_RTL8201
+    s_phy = esp_eth_phy_new_rtl8201(&phy_config);
+#elif CONFIG_EXAMPLE_ETH_PHY_LAN8720
+    s_phy = esp_eth_phy_new_lan8720(&phy_config);
+#elif CONFIG_EXAMPLE_ETH_PHY_DP83848
+    s_phy = esp_eth_phy_new_dp83848(&phy_config);
+#endif
+#elif CONFIG_EXAMPLE_USE_DM9051
+    gpio_install_isr_service(0);
+    spi_device_handle_t spi_handle = NULL;
+    spi_bus_config_t buscfg = {
+        .miso_io_num = CONFIG_EXAMPLE_DM9051_MISO_GPIO,
+        .mosi_io_num = CONFIG_EXAMPLE_DM9051_MOSI_GPIO,
+        .sclk_io_num = CONFIG_EXAMPLE_DM9051_SCLK_GPIO,
+        .quadwp_io_num = -1,
+        .quadhd_io_num = -1,
+    };
+    ESP_ERROR_CHECK(spi_bus_initialize(CONFIG_EXAMPLE_DM9051_SPI_HOST, &buscfg, 1));
+    spi_device_interface_config_t devcfg = {
+        .command_bits = 1,
+        .address_bits = 7,
+        .mode = 0,
+        .clock_speed_hz = CONFIG_EXAMPLE_DM9051_SPI_CLOCK_MHZ * 1000 * 1000,
+        .spics_io_num = CONFIG_EXAMPLE_DM9051_CS_GPIO,
+        .queue_size = 20
+    };
+    ESP_ERROR_CHECK(spi_bus_add_device(CONFIG_EXAMPLE_DM9051_SPI_HOST, &devcfg, &spi_handle));
+    /* dm9051 ethernet driver is based on spi driver */
+    eth_dm9051_config_t dm9051_config = ETH_DM9051_DEFAULT_CONFIG(spi_handle);
+    dm9051_config.int_gpio_num = CONFIG_EXAMPLE_DM9051_INT_GPIO;
+    s_mac = esp_eth_mac_new_dm9051(&dm9051_config, &mac_config);
+    s_phy = esp_eth_phy_new_dm9051(&phy_config);
+#elif CONFIG_EXAMPLE_USE_OPENETH
+    phy_config.autonego_timeout_ms = 100;
+    s_mac = esp_eth_mac_new_openeth(&mac_config);
+    s_phy = esp_eth_phy_new_dp83848(&phy_config);
+#endif
+
+    // Install Ethernet driver
+    esp_eth_config_t config = ETH_DEFAULT_CONFIG(s_mac, s_phy);
+    ESP_ERROR_CHECK(esp_eth_driver_install(&config, &s_eth_handle));
+    // combine driver with netif
+    s_eth_glue = esp_eth_new_netif_glue(s_eth_handle);
+    esp_netif_attach(netif, s_eth_glue);
+    esp_eth_start(s_eth_handle);
+    return netif;
+}
+
+static void eth_stop(void)
+{
+    esp_netif_t *eth_netif = get_example_netif_from_desc("eth");
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_ETH_GOT_IP, &on_got_ip));
+#ifdef CONFIG_EXAMPLE_CONNECT_IPV6
+    ESP_ERROR_CHECK(esp_event_handler_unregister(IP_EVENT, IP_EVENT_GOT_IP6, &on_got_ipv6));
+    ESP_ERROR_CHECK(esp_event_handler_unregister(ETH_EVENT, ETHERNET_EVENT_CONNECTED, &on_eth_event));
+#endif
+    ESP_ERROR_CHECK(esp_eth_stop(s_eth_handle));
+    ESP_ERROR_CHECK(esp_eth_del_netif_glue(s_eth_glue));
+    ESP_ERROR_CHECK(esp_eth_clear_default_handlers(eth_netif));
+    ESP_ERROR_CHECK(esp_eth_driver_uninstall(s_eth_handle));
+    ESP_ERROR_CHECK(s_phy->del(s_phy));
+    ESP_ERROR_CHECK(s_mac->del(s_mac));
+
+    esp_netif_destroy(eth_netif);
+    s_example_esp_netif = NULL;
+}
+
+#endif // CONFIG_EXAMPLE_CONNECT_ETHERNET
+
+esp_netif_t *get_example_netif(void)
+{
+    return s_example_esp_netif;
+}
+
+esp_netif_t *get_example_netif_from_desc(const char *desc)
+{
+    esp_netif_t *netif = NULL;
+    char *expected_desc;
+    asprintf(&expected_desc, "%s: %s", TAG, desc);
+    while ((netif = esp_netif_next(netif)) != NULL) {
+        if (strcmp(esp_netif_get_desc(netif), expected_desc) == 0) {
+            free(expected_desc);
+            return netif;
+        }
+    }
+    free(expected_desc);
+    return netif;
+}

firmware/esp-idf/wumei-smart-firmware/examples/common_components/protocol_examples_common/include/addr_from_stdin.h

@@ -0,0 +1,44 @@
+/*  Common utilities for socket address input interface:
+    The API get_addr_from_stdin() is mainly used by socket client examples which read IP address from stdin (if configured).
+    This option is typically used in the CI, but could be enabled in the project configuration.
+    In that case this component is used to receive a string that is evaluated and processed to output
+    socket structures to open a connectio
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "lwip/sys.h"
+#include <lwip/netdb.h>
+#include <arpa/inet.h>
+
+/**
+ * @brief Read and evaluate IP address from stdin
+ *
+ * This API reads stdin and parses the input address using getaddrinfo()
+ * to fill in struct sockaddr_in6 (for both IPv4 and IPv6) used to open
+ * a socket. IP protocol is guessed from the IP address string.
+ *
+ * @param[in] port port number of expected connection
+ * @param[in] sock_type expected protocol: SOCK_STREAM or SOCK_DGRAM
+ * @param[out] ip_protocol resultant IP protocol: IPPROTO_IP or IPPROTO_IP6
+ * @param[out] addr_family resultant address family: AF_INET or AF_INET6
+ * @param[out] dest_addr sockaddr_in6 structure (for both IPv4 and IPv6)
+ * @return ESP_OK on success, ESP_FAIL otherwise
+ */
+esp_err_t get_addr_from_stdin(int port, int sock_type,
+                              int *ip_protocol,
+                              int *addr_family,
+                              struct sockaddr_in6 *dest_addr);
+
+#ifdef __cplusplus
+}
+#endif

firmware/esp-idf/wumei-smart-firmware/examples/common_components/protocol_examples_common/include/protocol_examples_common.h

@@ -0,0 +1,78 @@
+/* Common functions for protocol examples, to establish Wi-Fi or Ethernet connection.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp_err.h"
+#include "esp_netif.h"
+
+#ifdef CONFIG_EXAMPLE_CONNECT_ETHERNET
+#define EXAMPLE_INTERFACE get_example_netif()
+#endif
+
+#ifdef CONFIG_EXAMPLE_CONNECT_WIFI
+#define EXAMPLE_INTERFACE get_example_netif()
+#endif
+
+/**
+ * @brief Configure Wi-Fi or Ethernet, connect, wait for IP
+ *
+ * This all-in-one helper function is used in protocols examples to
+ * reduce the amount of boilerplate in the example.
+ *
+ * It is not intended to be used in real world applications.
+ * See examples under examples/wifi/getting_started/ and examples/ethernet/
+ * for more complete Wi-Fi or Ethernet initialization code.
+ *
+ * Read "Establishing Wi-Fi or Ethernet Connection" section in
+ * examples/protocols/README.md for more information about this function.
+ *
+ * @return ESP_OK on successful connection
+ */
+esp_err_t example_connect(void);
+
+/**
+ * Counterpart to example_connect, de-initializes Wi-Fi or Ethernet
+ */
+esp_err_t example_disconnect(void);
+
+/**
+ * @brief Configure stdin and stdout to use blocking I/O
+ *
+ * This helper function is used in ASIO examples. It wraps installing the
+ * UART driver and configuring VFS layer to use UART driver for console I/O.
+ */
+esp_err_t example_configure_stdin_stdout(void);
+
+/**
+ * @brief Returns esp-netif pointer created by example_connect()
+ *
+ * @note If multiple interfaces active at once, this API return NULL
+ * In that case the get_example_netif_from_desc() should be used
+ * to get esp-netif pointer based on interface description
+ */
+esp_netif_t *get_example_netif(void);
+
+/**
+ * @brief Returns esp-netif pointer created by example_connect() described by
+ * the supplied desc field
+ *
+ * @param desc Textual interface of created network interface, for example "sta"
+ * indicate default WiFi station, "eth" default Ethernet interface.
+ *
+ */
+esp_netif_t *get_example_netif_from_desc(const char *desc);
+
+#ifdef __cplusplus
+}
+#endif

firmware/esp-idf/wumei-smart-firmware/examples/common_components/protocol_examples_common/stdin_out.c

@@ -0,0 +1,29 @@
+/* Common functions for protocol examples, to configure stdin and stdout.
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+ */
+
+#include "protocol_examples_common.h"
+#include "esp_err.h"
+#include "esp_vfs_dev.h"
+#include "driver/uart.h"
+#include "sdkconfig.h"
+
+esp_err_t example_configure_stdin_stdout(void)
+{
+    // Initialize VFS & UART so we can use std::cout/cin
+    setvbuf(stdin, NULL, _IONBF, 0);
+    /* Install UART driver for interrupt-driven reads and writes */
+    ESP_ERROR_CHECK( uart_driver_install( (uart_port_t)CONFIG_ESP_CONSOLE_UART_NUM,
+            256, 0, 0, NULL, 0) );
+    /* Tell VFS to use UART driver */
+    esp_vfs_dev_uart_use_driver(CONFIG_ESP_CONSOLE_UART_NUM);
+    esp_vfs_dev_uart_port_set_rx_line_endings(CONFIG_ESP_CONSOLE_UART_NUM, ESP_LINE_ENDINGS_CR);
+    /* Move the caret to the beginning of the next line on '\n' */
+    esp_vfs_dev_uart_port_set_tx_line_endings(CONFIG_ESP_CONSOLE_UART_NUM, ESP_LINE_ENDINGS_CRLF);
+    return ESP_OK;
+}