hexianglong/snapclient
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove wifi logger component

Browse Source
This commit is contained in:
Carlos
2021-11-12 07:19:39 +01:00
Unverified
parent f52b8da28e
commit bafbc1e2bf
13 changed files with 1 additions and 972 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
components/ota_server/CMakeLists.txt
View File

@@ -1,3 +1,3 @@
idf_component_register(SRCS "ota_server.c"
INCLUDE_DIRS "include"
REQUIRES app_update dsp_processor wifi_interface lightsnapcast wifi_logger)
REQUIRES app_update dsp_processor wifi_interface lightsnapcast)

3
components/ota_server/ota_server.c
View File

@@ -22,8 +22,6 @@
#include "ota_server.h"
#include "wifi_logger.h"
extern xTaskHandle t_http_get_task;
const int OTA_CONNECTED_BIT = BIT0;
@@ -196,7 +194,6 @@ ota_server_start_my (void)
// dsp_i2s_task_deinit();
vTaskDelete (t_http_get_task);
deinit_player (); // ensure this is called after http_task was killed
stop_wifi_logger ();
int recv_len;
char ota_buff[OTA_BUFF_SIZE] = { 0 };

4
components/protocol_examples_common/CMakeLists.txt
View File

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

218
components/protocol_examples_common/Kconfig.projbuild
View File

@@ -1,218 +0,0 @@
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

75
components/protocol_examples_common/addr_from_stdin.c
View File

@@ -1,75 +0,0 @@
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_system.h"
#include "protocol_examples_common.h"
#include <string.h>
#include "lwip/sockets.h"
#include <arpa/inet.h>
#include <lwip/netdb.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;
}

0
components/protocol_examples_common/component.mk
View File

488
components/protocol_examples_common/connect.c
View File

@@ -1,488 +0,0 @@
/* 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 "esp_event.h"
#include "esp_wifi.h"
#include "esp_wifi_default.h"
#include "protocol_examples_common.h"
#include "sdkconfig.h"
#include <string.h>
#if CONFIG_EXAMPLE_CONNECT_ETHERNET
#include "esp_eth.h"
#endif
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "freertos/FreeRTOS.h"
#include "freertos/event_groups.h"
#include "freertos/task.h"
#include "lwip/err.h"
#include "lwip/sys.h"
#include "wifi_interface.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;
// extern esp_netif_t *esp_wifi_netif;
#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
esp_wifi_netif = wifi_start ();
s_active_interfaces++;
#endif
#if CONFIG_EXAMPLE_CONNECT_ETHERNET
esp_wifi_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 */
esp_wifi_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);
esp_wifi_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);
esp_wifi_netif = NULL;
}
#endif // CONFIG_EXAMPLE_CONNECT_ETHERNET
esp_netif_t *
get_example_netif (void)
{
return get_current_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;
}

45
components/protocol_examples_common/include/addr_from_stdin.h
View File

@@ -1,45 +0,0 @@
/* 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 <arpa/inet.h>
#include <lwip/netdb.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

80
components/protocol_examples_common/include/protocol_examples_common.h
View File

@@ -1,80 +0,0 @@
/* 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

32
components/protocol_examples_common/stdin_out.c
View File

@@ -1,32 +0,0 @@
/* 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 "driver/uart.h"
#include "esp_err.h"
#include "esp_vfs_dev.h"
#include "protocol_examples_common.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;
}

1
components/wifi_logger

Submodule components/wifi_logger deleted from 23bf246c86

4
main/main.c
View File

@@ -31,8 +31,6 @@
#include "mdns.h"
#include "net_functions.h"
#include "wifi_logger.h"
// Web socket server
#include "websocket_if.h"
//#include "websocket_server.h"
@@ -3885,8 +3883,6 @@ app_main (void)
HTTP_TASK_PRIORITY, &t_http_get_task,
HTTP_TASK_CORE_ID);
// start_wifi_logger(); // Start wifi logger
while (1)
{
// audio_event_iface_msg_t msg;

21
sdkconfig
View File

@@ -152,14 +152,6 @@ CONFIG_SNTP_TIMEZONE="UTC"
CONFIG_SNTP_SERVER="pool.ntp.org"
# end of SNTP Configuration
#
# Example Connection Configuration
#
# CONFIG_EXAMPLE_CONNECT_WIFI is not set
# CONFIG_EXAMPLE_CONNECT_ETHERNET is not set
# CONFIG_EXAMPLE_CONNECT_IPV6 is not set
# end of Example Connection Configuration
#
# Wifi Configuration
#
@@ -1189,19 +1181,6 @@ CONFIG_WEBSOCKET_SERVER_TASK_STACK_DEPTH=3000
CONFIG_WEBSOCKET_SERVER_TASK_PRIORITY=5
# CONFIG_WEBSOCKET_SERVER_PINNED is not set
# end of WebSocket Server
#
# WiFi Logger configuration
#
CONFIG_TRANSPORT_PROTOCOL_UDP=y
# CONFIG_TRANSPORT_PROTOCOL_TCP is not set
# CONFIG_TRANSPORT_PROTOCOL_WEBSOCKET is not set
CONFIG_ROUTE_ESP_IDF_API_LOGS_TO_WIFI=y
CONFIG_SERVER_IP_ADDRESS="192.168.0.10"
CONFIG_SERVER_PORT=9999
CONFIG_MESSAGE_QUEUE_SIZE=1000
CONFIG_BUFFER_SIZE=512
# end of WiFi Logger configuration
# end of Component config
#