From 83b8556f107fc3d5fd411eb7a2bba185f988cc0f Mon Sep 17 00:00:00 2001 From: David Cermak Date: Fri, 22 Jul 2022 17:37:47 +0200 Subject: [PATCH 1/3] esp_netif: Migrate SLIP interface to user-space --- components/esp_netif/CMakeLists.txt | 5 - components/esp_netif/esp_netif_defaults.c | 2 - .../esp_netif/include/esp_netif_defaults.h | 32 +- components/esp_netif/include/esp_netif_slip.h | 82 ----- .../esp_netif/include/esp_netif_types.h | 3 +- .../include/lwip/esp_netif_net_stack.h | 7 - .../esp_netif/loopback/esp_netif_loopback.c | 1 - components/esp_netif/lwip/esp_netif_lwip.c | 49 +-- .../esp_netif/lwip/esp_netif_lwip_internal.h | 10 +- .../esp_netif/lwip/esp_netif_lwip_ppp.c | 2 +- .../esp_netif/lwip/esp_netif_lwip_slip.c | 307 ------------------ .../esp_netif/lwip/esp_netif_lwip_slip.h | 58 ---- examples/protocols/slip/slip_udp/README.md | 6 +- .../components/slip_modem/CMakeLists.txt | 2 +- .../slip_modem/include/slip_modem.h | 70 ++-- .../slip_modem/library/slip_modem.c | 78 +++-- .../slip_modem/library/slip_modem_netif.c | 192 +++++++++++ .../slip_modem/library/slip_modem_netif.h | 42 +++ .../slip/slip_udp/main/Kconfig.projbuild | 4 +- .../slip/slip_udp/main/slip_client_main.c | 41 +-- tools/ci/check_copyright_ignore.txt | 3 - 21 files changed, 368 insertions(+), 628 deletions(-) delete mode 100644 components/esp_netif/include/esp_netif_slip.h delete mode 100644 components/esp_netif/lwip/esp_netif_lwip_slip.c delete mode 100644 components/esp_netif/lwip/esp_netif_lwip_slip.h create mode 100644 examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c create mode 100644 examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h diff --git a/components/esp_netif/CMakeLists.txt b/components/esp_netif/CMakeLists.txt index 663a41648a..6eb4d85911 100644 --- a/components/esp_netif/CMakeLists.txt +++ b/components/esp_netif/CMakeLists.txt @@ -19,11 +19,6 @@ set(srcs set(include_dirs "include") set(priv_include_dirs "lwip" "private_include") -if(CONFIG_LWIP_SLIP_SUPPORT) -list(APPEND srcs - "lwip/esp_netif_lwip_slip.c") -endif() - if(CONFIG_PPP_SUPPORT) list(APPEND srcs "lwip/esp_netif_lwip_ppp.c") diff --git a/components/esp_netif/esp_netif_defaults.c b/components/esp_netif/esp_netif_defaults.c index 950772a720..a49c69d85b 100644 --- a/components/esp_netif/esp_netif_defaults.c +++ b/components/esp_netif/esp_netif_defaults.c @@ -32,5 +32,3 @@ const esp_netif_inherent_config_t _g_esp_netif_inherent_ap_config = ESP_NETIF_IN const esp_netif_inherent_config_t _g_esp_netif_inherent_eth_config = ESP_NETIF_INHERENT_DEFAULT_ETH(); const esp_netif_inherent_config_t _g_esp_netif_inherent_ppp_config = ESP_NETIF_INHERENT_DEFAULT_PPP(); - -const esp_netif_inherent_config_t _g_esp_netif_inherent_slip_config = ESP_NETIF_INHERENT_DEFAULT_SLIP(); diff --git a/components/esp_netif/include/esp_netif_defaults.h b/components/esp_netif/include/esp_netif_defaults.h index fdf7f32a76..90fbca16dd 100644 --- a/components/esp_netif/include/esp_netif_defaults.h +++ b/components/esp_netif/include/esp_netif_defaults.h @@ -72,18 +72,7 @@ extern "C" { }; -#define ESP_NETIF_INHERENT_DEFAULT_SLIP() \ - { \ - .flags = ESP_NETIF_FLAG_IS_SLIP, \ - ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(mac) \ - ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(ip_info) \ - .get_ip_event = 0, \ - .lost_ip_event = 0, \ - .if_key = "SLP_DEF", \ - .if_desc = "slip", \ - .route_prio = 16, \ - .bridge_info = NULL \ -}; + #define ESP_NETIF_INHERENT_DEFAULT_BR() \ { \ @@ -140,17 +129,6 @@ extern "C" { .stack = ESP_NETIF_NETSTACK_DEFAULT_PPP, \ } -/** -* @brief Default configuration reference of SLIP client -*/ -#define ESP_NETIF_DEFAULT_SLIP() \ - { \ - .base = ESP_NETIF_BASE_DEFAULT_SLIP, \ - .driver = NULL, \ - .stack = ESP_NETIF_NETSTACK_DEFAULT_SLIP, \ - } - - /** * @brief Default base config (esp-netif inherent) of WIFI STA */ @@ -173,11 +151,6 @@ extern "C" { */ #define ESP_NETIF_BASE_DEFAULT_PPP &_g_esp_netif_inherent_ppp_config -/** - * @brief Default base config (esp-netif inherent) of slip interface - */ -#define ESP_NETIF_BASE_DEFAULT_SLIP &_g_esp_netif_inherent_slip_config - #define ESP_NETIF_NETSTACK_DEFAULT_ETH _g_esp_netif_netstack_default_eth #define ESP_NETIF_NETSTACK_DEFAULT_BR _g_esp_netif_netstack_default_br @@ -186,7 +159,6 @@ extern "C" { #define ESP_NETIF_NETSTACK_DEFAULT_WIFI_AP _g_esp_netif_netstack_default_wifi_ap #endif #define ESP_NETIF_NETSTACK_DEFAULT_PPP _g_esp_netif_netstack_default_ppp -#define ESP_NETIF_NETSTACK_DEFAULT_SLIP _g_esp_netif_netstack_default_slip // // Include default network stacks configs @@ -201,7 +173,6 @@ extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_wifi_sta extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_wifi_ap; #endif extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_ppp; -extern const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_slip; // // Include default common configs inherent to esp-netif @@ -214,7 +185,6 @@ extern const esp_netif_inherent_config_t _g_esp_netif_inherent_ap_config; #endif extern const esp_netif_inherent_config_t _g_esp_netif_inherent_eth_config; extern const esp_netif_inherent_config_t _g_esp_netif_inherent_ppp_config; -extern const esp_netif_inherent_config_t _g_esp_netif_inherent_slip_config; #ifdef CONFIG_ESP_WIFI_SOFTAP_SUPPORT extern const esp_netif_ip_info_t _g_esp_netif_soft_ap_ip; diff --git a/components/esp_netif/include/esp_netif_slip.h b/components/esp_netif/include/esp_netif_slip.h deleted file mode 100644 index 5cad14ea28..0000000000 --- a/components/esp_netif/include/esp_netif_slip.h +++ /dev/null @@ -1,82 +0,0 @@ -// Copyright 2019 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_NETIF_SLIP_H_ -#define _ESP_NETIF_SLIP_H_ - -#include "esp_netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** @brief Configuration structure for SLIP network interface - * - */ -typedef struct esp_netif_slip_config { - esp_ip6_addr_t ip6_addr; /* Local IP6 address */ - -} esp_netif_slip_config_t; - - -/** @brief Sets common parameters for the supplied esp-netif. - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] config Pointer to SLIP netif configuration structure - * - * @return ESP_OK on success, ESP_ERR_ESP_NETIF_INVALID_PARAMS if netif null or not SLIP - */ -esp_err_t esp_netif_slip_set_params(esp_netif_t *netif, const esp_netif_slip_config_t *config); - -#if CONFIG_LWIP_IPV6 -/** @brief Sets IPV6 address for the supplied esp-netif. - * - * @param[in] netif handle to slip esp-netif instance - * @param[in] ipv6 IPv6 address of the SLIP interface - * - * @return ESP_OK on success, ESP_ERR_ESP_NETIF_INVALID_PARAMS if netif null or not SLIP - */ -esp_err_t esp_netif_slip_set_ipv6(esp_netif_t *netif, const esp_ip6_addr_t *ipv6); -#endif - -/** - * @brief Data path API to write raw packet ous the SLIP interface - * - * This API is typically used when implementing user defined methods - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] buffer pointer to the outgoing data - * @param[in] len length of the data - * - * @return - * - ESP_OK on success - */ -void esp_netif_lwip_slip_raw_output(esp_netif_t *netif, void *buffer, size_t len); - -/** - * @brief Fetch IP6 address attached to the SLIP interface - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] address index (unused) - * - * @return - * - pointer to the internal ip6 address object - */ -const esp_ip6_addr_t *esp_slip_get_ip6(esp_netif_t *slip_netif); - -#ifdef __cplusplus -} -#endif -#endif //_ESP_NETIF_SLIP_H_ diff --git a/components/esp_netif/include/esp_netif_types.h b/components/esp_netif/include/esp_netif_types.h index 3268f4732b..de7f7579fc 100644 --- a/components/esp_netif/include/esp_netif_types.h +++ b/components/esp_netif/include/esp_netif_types.h @@ -159,8 +159,7 @@ typedef enum esp_netif_flags { ESP_NETIF_FLAG_GARP = 1 << 3, ESP_NETIF_FLAG_EVENT_IP_MODIFIED = 1 << 4, ESP_NETIF_FLAG_IS_PPP = 1 << 5, - ESP_NETIF_FLAG_IS_SLIP = 1 << 6, - ESP_NETIF_FLAG_IS_BRIDGE = 1 << 7, + ESP_NETIF_FLAG_IS_BRIDGE = 1 << 6, } esp_netif_flags_t; typedef enum esp_netif_ip_event_type { diff --git a/components/esp_netif/include/lwip/esp_netif_net_stack.h b/components/esp_netif/include/lwip/esp_netif_net_stack.h index e908b96a60..52790d72ac 100644 --- a/components/esp_netif/include/lwip/esp_netif_net_stack.h +++ b/components/esp_netif/include/lwip/esp_netif_net_stack.h @@ -9,7 +9,6 @@ #include "esp_netif.h" #include "lwip/netif.h" #include "esp_netif_ppp.h" -#include "esp_netif_slip.h" #if defined(CONFIG_ESP_NETIF_TCPIP_LWIP) @@ -26,12 +25,6 @@ struct esp_netif_netstack_lwip_ppp_config { esp_netif_ppp_config_t ppp_events; }; -struct esp_netif_netstack_lwip_slip_config { - init_fn_t init_fn; - input_fn_t input_fn; - esp_netif_slip_config_t slip_config; -}; - // LWIP netif specific network stack configuration struct esp_netif_netstack_config { union { diff --git a/components/esp_netif/loopback/esp_netif_loopback.c b/components/esp_netif/loopback/esp_netif_loopback.c index 8418e9d28b..c328a37e5e 100644 --- a/components/esp_netif/loopback/esp_netif_loopback.c +++ b/components/esp_netif/loopback/esp_netif_loopback.c @@ -6,7 +6,6 @@ #include -#include "esp_netif_lwip_internal.h" #include "esp_netif.h" #include "esp_netif_private.h" diff --git a/components/esp_netif/lwip/esp_netif_lwip.c b/components/esp_netif/lwip/esp_netif_lwip.c index 049fd55e69..22f770869e 100644 --- a/components/esp_netif/lwip/esp_netif_lwip.c +++ b/components/esp_netif/lwip/esp_netif_lwip.c @@ -41,7 +41,6 @@ #endif // CONFIG_LWIP_HOOK_TCP_ISN_DEFAULT #include "esp_netif_lwip_ppp.h" -#include "esp_netif_lwip_slip.h" #include "dhcpserver/dhcpserver.h" #include "dhcpserver/dhcpserver_options.h" #include "netif/dhcp_state.h" @@ -64,7 +63,7 @@ /** * @brief macros to check netif related data to evaluate interface type */ -#if CONFIG_PPP_SUPPORT || CONFIG_LWIP_SLIP_SUPPORT +#if CONFIG_PPP_SUPPORT #define _IS_NETIF_ANY_POINT2POINT_TYPE(netif) (netif->related_data && netif->related_data->is_point2point) #else #define _IS_NETIF_ANY_POINT2POINT_TYPE(netif) false @@ -255,7 +254,7 @@ static esp_netif_t* esp_netif_is_active(esp_netif_t *arg) */ static void esp_netif_set_default_netif_internal(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT esp_netif_ppp_set_default_netif(esp_netif->netif_handle); #endif @@ -450,7 +449,7 @@ esp_netif_t* esp_netif_get_handle_from_netif_impl(void *dev) void* esp_netif_get_netif_impl(esp_netif_t *esp_netif) { // get impl ptr only for vanilla lwip impl (ppp_pcb not supported) - if (esp_netif && !_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (esp_netif && !ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { return esp_netif->lwip_netif; } return NULL; @@ -577,23 +576,6 @@ static esp_err_t esp_netif_init_configuration(esp_netif_t *esp_netif, const esp_ esp_netif->netif_handle = esp_netif->related_data; #else LOG_NETIF_DISABLED_AND_DO("PPP", return ESP_ERR_NOT_SUPPORTED); -#endif - } else if (cfg->base->flags & ESP_NETIF_FLAG_IS_SLIP) { -#if CONFIG_LWIP_SLIP_SUPPORT - esp_netif->related_data = esp_netif_new_slip(esp_netif, esp_netif_stack_config); - if (esp_netif->related_data == NULL) { - return ESP_ERR_ESP_NETIF_INIT_FAILED; - } - if (esp_netif_stack_config->lwip.init_fn) { - esp_netif->lwip_init_fn = esp_netif_stack_config->lwip.init_fn; - } - if (esp_netif_stack_config->lwip.input_fn) { - esp_netif->lwip_input_fn = esp_netif_stack_config->lwip.input_fn; - } - // Make the netif handle (used for tcpip input function) the esp_netif itself - esp_netif->netif_handle = esp_netif; -#else - LOG_NETIF_DISABLED_AND_DO("SLIP", return ESP_ERR_NOT_SUPPORTED); #endif } else { if (esp_netif_stack_config-> lwip.init_fn) { @@ -786,13 +768,9 @@ static esp_err_t esp_netif_lwip_add(esp_netif_t *esp_netif) static void esp_netif_destroy_related(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT esp_netif_destroy_ppp(esp_netif->related_data); -#endif - } else if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, SLIP_LWIP_NETIF)) { -#if CONFIG_LWIP_SLIP_SUPPORT - esp_netif_destroy_slip(esp_netif->related_data); #endif } } @@ -945,11 +923,7 @@ static esp_err_t esp_netif_start_api(esp_netif_api_msg_t *msg) #endif } struct netif *p_netif = esp_netif->lwip_netif; - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, SLIP_LWIP_NETIF)) { -#if CONFIG_LWIP_SLIP_SUPPORT - esp_netif_start_slip(esp_netif); -#endif - } + if (esp_netif->flags&ESP_NETIF_FLAG_AUTOUP) { ESP_LOGD(TAG, "%s Setting the lwip netif%p UP", __func__, p_netif); netif_set_up(p_netif); @@ -1011,7 +985,7 @@ static esp_err_t esp_netif_start_api(esp_netif_api_msg_t *msg) esp_err_t esp_netif_start(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT // No need to start PPP interface in lwip thread esp_err_t ret = esp_netif_start_ppp(esp_netif); @@ -1066,7 +1040,7 @@ static esp_err_t esp_netif_stop_api(esp_netif_api_msg_t *msg) esp_err_t esp_netif_stop(esp_netif_t *esp_netif) { - if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { + if (ESP_NETIF_IS_POINT2POINT_TYPE(esp_netif, PPP_LWIP_NETIF)) { #if CONFIG_PPP_SUPPORT // No need to stop PPP interface in lwip thread esp_err_t ret = esp_netif_stop_ppp(esp_netif->related_data); @@ -1074,15 +1048,6 @@ esp_err_t esp_netif_stop(esp_netif_t *esp_netif) esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED); } return ret; -#endif - } else if (_IS_NETIF_POINT2POINT_TYPE(esp_netif, SLIP_LWIP_NETIF)) { -#if CONFIG_LWIP_SLIP_SUPPORT - // No need to stop SLIP interface in lwip thread - esp_err_t ret = esp_netif_stop_slip(esp_netif); - if (ret == ESP_OK) { - esp_netif_update_default_netif(esp_netif, ESP_NETIF_STOPPED); - } - return ret; #endif } return esp_netif_lwip_ipc_call(esp_netif_stop_api, esp_netif, NULL); diff --git a/components/esp_netif/lwip/esp_netif_lwip_internal.h b/components/esp_netif/lwip/esp_netif_lwip_internal.h index 0737f79c3c..332a4f822d 100644 --- a/components/esp_netif/lwip/esp_netif_lwip_internal.h +++ b/components/esp_netif/lwip/esp_netif_lwip_internal.h @@ -8,7 +8,6 @@ #include "esp_netif.h" #include "esp_netif_ppp.h" -#include "esp_netif_slip.h" #include "lwip/netif.h" #include "dhcpserver/dhcpserver.h" @@ -39,10 +38,10 @@ typedef struct esp_netif_ip_lost_timer_s { /** * @brief Check the netif if of a specific P2P type */ -#if CONFIG_PPP_SUPPORT || CONFIG_LWIP_SLIP_SUPPORT -#define _IS_NETIF_POINT2POINT_TYPE(netif, type) (netif->related_data && netif->related_data->is_point2point && netif->related_data->netif_type == type) +#if CONFIG_PPP_SUPPORT +#define ESP_NETIF_IS_POINT2POINT_TYPE(netif, type) (netif->related_data && netif->related_data->is_point2point && netif->related_data->netif_type == type) #else -#define _IS_NETIF_POINT2POINT_TYPE(netif, type) false +#define ESP_NETIF_IS_POINT2POINT_TYPE(netif, type) false #endif /** @@ -51,12 +50,11 @@ typedef struct esp_netif_ip_lost_timer_s { enum netif_types { COMMON_LWIP_NETIF, PPP_LWIP_NETIF, - SLIP_LWIP_NETIF }; /** * @brief Related data to esp-netif (additional data for some special types of netif - * (typically for point-point network types, such as PPP or SLIP) + * (typically for point-point network types, such as PPP) */ typedef struct netif_related_data { bool is_point2point; diff --git a/components/esp_netif/lwip/esp_netif_lwip_ppp.c b/components/esp_netif/lwip/esp_netif_lwip_ppp.c index 2c6c1c1248..67175df4d9 100644 --- a/components/esp_netif/lwip/esp_netif_lwip_ppp.c +++ b/components/esp_netif/lwip/esp_netif_lwip_ppp.c @@ -203,7 +203,7 @@ static uint32_t pppos_low_level_output(ppp_pcb *pcb, uint8_t *data, uint32_t len esp_err_t esp_netif_ppp_set_auth(esp_netif_t *netif, esp_netif_auth_type_t authtype, const char *user, const char *passwd) { - if (!_IS_NETIF_POINT2POINT_TYPE(netif, PPP_LWIP_NETIF)) { + if (!ESP_NETIF_IS_POINT2POINT_TYPE(netif, PPP_LWIP_NETIF)) { return ESP_ERR_ESP_NETIF_INVALID_PARAMS; } #if PPP_AUTH_SUPPORT diff --git a/components/esp_netif/lwip/esp_netif_lwip_slip.c b/components/esp_netif/lwip/esp_netif_lwip_slip.c deleted file mode 100644 index 6d59370f4e..0000000000 --- a/components/esp_netif/lwip/esp_netif_lwip_slip.c +++ /dev/null @@ -1,307 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD - * - * SPDX-License-Identifier: Apache-2.0 - */ - - - -#include "esp_netif.h" -#include "esp_log.h" -#include "esp_netif_slip.h" -#include "esp_netif_lwip_internal.h" -#include "esp_netif_net_stack.h" -#include "lwip/esp_netif_net_stack.h" - -#ifdef CONFIG_ESP_NETIF_TCPIP_LWIP - -#include "lwip/dns.h" -#include "lwip/opt.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" -#include "netif/slipif.h" -#include "lwip/sio.h" - -#include - -static const char *TAG = "esp-netif_lwip-slip"; - -/** - * @brief LWIP SLIP context object extends esp-netif related data - */ -typedef struct lwip_slip_ctx { - //! Generic esp-netif related data - netif_related_data_t base; - - //! SLIP interface IP6 address - esp_ip6_addr_t addr; - -} lwip_slip_ctx_t; - -/** - * @brief Create a new lwip slip interface - */ -netif_related_data_t * esp_netif_new_slip(esp_netif_t *esp_netif, const esp_netif_netstack_config_t *esp_netif_stack_config) -{ - ESP_LOGD(TAG, "%s", __func__); - - // Fetch netif and create context - struct netif *netif_impl = esp_netif->lwip_netif; - - lwip_slip_ctx_t *slip_ctx = calloc(1, sizeof(lwip_slip_ctx_t)); - if (slip_ctx == NULL) { - ESP_LOGE(TAG, "%s: cannot allocate lwip_slip_ctx_t", __func__); - return NULL; - } - // Setup the generic esp-netif fields - slip_ctx->base.is_point2point = true; - slip_ctx->base.netif_type = SLIP_LWIP_NETIF; - - ESP_LOGD(TAG, "%s: Initialising SLIP (esp_netif %p, lwip_netif %p)", __func__, esp_netif, netif_impl); - - ESP_LOGI(TAG, "%s: Created SLIP interface (netif %p, slip_ctx: %p)", __func__, esp_netif, slip_ctx); - - return (netif_related_data_t *)slip_ctx; -} - -/** - * @brief Stops the SLIP interface - */ -esp_err_t esp_netif_stop_slip(esp_netif_t *esp_netif) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)esp_netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGI(TAG, "%s: Stopped SLIP connection: %p", __func__, slip_ctx); - - // Stop interface - netif_set_link_down(esp_netif->lwip_netif); - - return ESP_OK; -} - -/** - * @brief Starts the SLIP interface - */ -esp_err_t esp_netif_start_slip(esp_netif_t *esp_netif) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)esp_netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGI(TAG, "%s: Starting SLIP interface: %p", __func__, slip_ctx); - - // Set the netif up - netif_set_up(esp_netif->lwip_netif); - netif_set_link_up(esp_netif->lwip_netif); -#if CONFIG_LWIP_IPV6 - int8_t addr_index = 0; - - netif_ip6_addr_set(esp_netif->lwip_netif, addr_index, (ip6_addr_t *)&slip_ctx->addr); - netif_ip6_addr_set_state(esp_netif->lwip_netif, addr_index, IP6_ADDR_VALID); -#endif - return ESP_OK; -} - - -/** - * @brief Sets paramaters for the supplied netif - */ -esp_err_t esp_netif_slip_set_params(esp_netif_t *netif, const esp_netif_slip_config_t *slip_config) -{ - - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGD(TAG, "%s (slip_ctx: %p)", __func__, slip_ctx); - - if (netif_is_link_up(netif->lwip_netif)) { - ESP_LOGE(TAG, "Cannot set parameters while SLIP interface is running"); - return ESP_ERR_INVALID_STATE; - } - - memcpy(&slip_ctx->addr, &slip_config->ip6_addr, sizeof(esp_ip6_addr_t)); - - - return ESP_OK; -} - -#if CONFIG_LWIP_IPV6 -esp_err_t esp_netif_slip_set_ipv6(esp_netif_t *netif, const esp_ip6_addr_t *ipv6) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGV(TAG, "%s (slip_ctx: %p)", __func__, slip_ctx); - - if (netif_is_link_up(netif->lwip_netif)) { - ESP_LOGE(TAG, "Cannot set parameters while SLIP interface is running"); - return ESP_ERR_INVALID_STATE; - } - memcpy(&slip_ctx->addr, ipv6, sizeof(ip6_addr_t)); - int8_t addr_index = 0; - - netif_ip6_addr_set(netif->lwip_netif, addr_index, (ip6_addr_t *)&slip_ctx->addr); - netif_ip6_addr_set_state(netif->lwip_netif, addr_index, IP6_ADDR_VALID); - - return ESP_OK; -} -#endif - -/** - * @brief Write incoming serial data to the SLIP interface - */ -void esp_netif_lwip_slip_input(void *h, void *buffer, unsigned int len, void *eb) -{ - esp_netif_t *netif = h; - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - - ESP_LOGD(TAG, "%s", __func__); - ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); - - // Update slip netif with data - const int max_batch = 255; - int sent = 0; - while(sent < len) { - int batch = (len - sent) > max_batch ? max_batch : (len - sent); - slipif_received_bytes(netif->lwip_netif, buffer+sent, batch); - sent += batch; - } - - // Process incoming bytes - for (int i = 0; i < len; i++) { - slipif_process_rxqueue(netif->lwip_netif); - } -} - -/** - * @brief Write raw data out the SLIP interface - */ -void esp_netif_lwip_slip_raw_output(esp_netif_t *slip_netif, void *buffer, size_t len) -{ - struct netif *lwip_netif = slip_netif->lwip_netif; - - ESP_LOGD(TAG, "%s", __func__); - - struct pbuf p = { - .next = NULL, - .payload = buffer, - .tot_len = len, - .len = len, - }; - - // Call slip if output function to feed data out slip interface -#if CONFIG_LWIP_IPV6 - lwip_netif->output_ip6(lwip_netif, &p, NULL); -#else - lwip_netif->output(lwip_netif, &p, NULL); -#endif -} - -/** - * @brief Destroys the SLIP context object - */ -void esp_netif_destroy_slip(netif_related_data_t *slip) -{ - ESP_LOGD(TAG, "%s", __func__); - - // Free base object - free(slip); -} - -const esp_ip6_addr_t *esp_slip_get_ip6(esp_netif_t *slip_netif) -{ - lwip_slip_ctx_t *slip_ctx = (lwip_slip_ctx_t *)slip_netif->related_data; - assert(slip_ctx->base.netif_type == SLIP_LWIP_NETIF); - return &slip_ctx->addr; -} - -/** @brief Get esp-netif object corresponding to registration index - */ -static esp_netif_t * get_netif_with_esp_index(int index) -{ - esp_netif_t *netif = NULL; - int counter = 0; - while ((netif = esp_netif_next(netif)) != NULL) { - if (counter == index) { - return netif; - } - counter++; - } - return NULL; -} - -/** @brief Return list registration index of the supplied netif ptr - */ -static int get_esp_netif_index(esp_netif_t * esp_netif) -{ - esp_netif_t *netif = NULL; - int counter = 0; - while ((netif = esp_netif_next(netif)) != NULL) { - if (esp_netif == netif) { - return counter; - } - counter++; - } - return -1; -} - -err_t esp_slipif_init(struct netif *netif) -{ - esp_netif_t *esp_netif = netif->state; - int esp_index = get_esp_netif_index(esp_netif); - if (esp_index < 0) { - return ERR_IF; - } - - // Store netif index in net interface for SIO open command to abstract the dev - netif->state = (void *)esp_index; - - return slipif_init(netif); -} - -static const struct esp_netif_netstack_config s_netif_config_slip = { - .lwip = { - .init_fn = esp_slipif_init, - .input_fn = esp_netif_lwip_slip_input, - } -}; - -const esp_netif_netstack_config_t *_g_esp_netif_netstack_default_slip = &s_netif_config_slip; - - -/*** - * @brief Open a serial device for communication - */ -sio_fd_t sio_open(uint8_t devnum) -{ - ESP_LOGD(TAG, "Opening device: %d\r\n", devnum); - - esp_netif_t *esp_netif = get_netif_with_esp_index(devnum); - if (!esp_netif) { - ESP_LOGE(TAG, "didn't find esp-netif with index=%d\n", devnum); - return NULL; - } - - // Return SIO handle - return esp_netif; -} - -/*** - * @brief Send a single character to the serial device (blocking) - */ -void sio_send(uint8_t c, sio_fd_t fd) -{ - esp_netif_t *esp_netif = fd; - - ESP_LOGD(TAG, "%s", __func__); - ESP_LOG_BUFFER_HEX_LEVEL(TAG, &c, 1, ESP_LOG_DEBUG); - - esp_err_t ret = esp_netif_transmit(esp_netif, &c, 1); - if (ret != ESP_OK) { - // Handle errors - ESP_LOGD(TAG, "%s: uart_write_bytes error %i", __func__, ret); - } -} - -#endif /* CONFIG_ESP_NETIF_TCPIP_LWIP */ diff --git a/components/esp_netif/lwip/esp_netif_lwip_slip.h b/components/esp_netif/lwip/esp_netif_lwip_slip.h deleted file mode 100644 index e8f9ae3264..0000000000 --- a/components/esp_netif/lwip/esp_netif_lwip_slip.h +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright 2019 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_NETIF_LWIP_SLIP_H_ -#define _ESP_NETIF_LWIP_SLIP_H_ - -/** - * @brief Creates new SLIP related structure - * - * @param[in] esp_netif pointer esp-netif instance - * @param[in] stack_config TCP/IP stack configuration structure - * - * @return - * - pointer to slip-netif object on success - * - NULL otherwise - */ -netif_related_data_t * esp_netif_new_slip(esp_netif_t *esp_netif, const esp_netif_netstack_config_t *esp_netif_stack_config); - -/** - * @brief Destroys the slip netif object - * - * @param[in] slip pointer to internal slip context instance - */ -void esp_netif_destroy_slip(netif_related_data_t *slip); - -/** - * @brief Stop the esp slip netif - * - * @param[in] esp_netif handle to slip esp-netif instance - * - * @return - * - ESP_OK on success - */ -esp_err_t esp_netif_stop_slip(esp_netif_t *esp_netif); - -/** - * @brief Start the esp slip netif - * - * @param[in] esp_netif handle to slip esp-netif instance - * - * @return - * - ESP_OK on success - */ -esp_err_t esp_netif_start_slip(esp_netif_t *esp_netif); - - -#endif // _ESP_NETIF_LWIP_SLIP_H_ diff --git a/examples/protocols/slip/slip_udp/README.md b/examples/protocols/slip/slip_udp/README.md index e83944da84..f8c50d9c35 100644 --- a/examples/protocols/slip/slip_udp/README.md +++ b/examples/protocols/slip/slip_udp/README.md @@ -9,6 +9,8 @@ This provides SLIP support for connection to Contiki gateway devices, allowing the ESP platform board to be used to bridge between low-power networks and IP (Wifi / Ethernet). +This example also demonstrates creating custom network interfaces, including UART drivers and lwIP netif layers, and attaching them to the standard `esp_netif` component, so the generic system interfaces can still use the common approach of listing all interfaces, updating states, posting events and handling routing priorities. Please refer to the implementation of [slip_modem](components/slip_modem) component for more details. + ## How to use example ### Hardware Required @@ -49,8 +51,8 @@ nc -u 10.0.0.2 5678 | ESP32 | Gateway | | ------ | -------------- | -| GPIO4 | RX | -| GPIO36 | TX | +| GPIO25 | RX | +| GPIO26 | TX | | GND | GND | | 3v3 | VCC | diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt b/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt index 838d5a975a..6837386287 100644 --- a/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt +++ b/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt @@ -1,7 +1,7 @@ # SLIP Modem Component idf_component_register( - SRCS "library/slip_modem.c" + SRCS "library/slip_modem.c" "library/slip_modem_netif.c" INCLUDE_DIRS "include" REQUIRES esp_netif driver ) diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h b/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h index 2cbd4be519..53b8eba5bb 100644 --- a/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h +++ b/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h @@ -1,16 +1,8 @@ -// Copyright 2020 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. +/* + * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ #pragma once @@ -18,15 +10,30 @@ #include #include "esp_netif.h" -#include "esp_netif_slip.h" - #include "driver/uart.h" +/** @brief Configuration of SLIP network interface + * + */ +#define ESP_NETIF_INHERENT_DEFAULT_SLIP() \ + { \ + ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(mac) \ + ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(ip_info) \ + .get_ip_event = 0, \ + .lost_ip_event = 0, \ + .if_key = "SLP_DEF", \ + .if_desc = "slip", \ + .route_prio = 16, \ + .bridge_info = NULL \ +}; + +extern esp_netif_netstack_config_t *netstack_default_slip; + // Forward declare modem object -typedef struct esp_slip_modem esp_slip_modem_t; +typedef struct slip_modem slip_modem_t; // Filter callbacks for handling application specific slip messages -typedef bool slip_rx_filter_cb_t(void *ctx, uint8_t *data, uint32_t len); +typedef bool slip_rx_filter_cb_t(slip_modem_t *slip, uint8_t *data, uint32_t len); /** @brief Configuration structure for SLIP modem interface @@ -43,9 +50,10 @@ typedef struct { uint32_t rx_buffer_len; /* Length of buffer for RX messages */ slip_rx_filter_cb_t *rx_filter; /* Filter for parsing out non-SLIP messages from incoming SLIP stream */ - void *rx_filter_ctx; /* Context to be passed to SLIP filter function */ + esp_ip6_addr_t *ipv6_addr; + +} slip_modem_config_t; -} esp_slip_modem_config_t; /** @brief Create a slip modem @@ -56,7 +64,7 @@ typedef struct { * @returns * - slip modem driver glue object */ -void *esp_slip_modem_create(esp_netif_t *slip_netif, esp_slip_modem_config_t *modem_config); +slip_modem_t *slip_modem_create(esp_netif_t *slip_netif, slip_modem_config_t *modem_config); /** @brief Destroy a slip modem * @@ -65,4 +73,24 @@ void *esp_slip_modem_create(esp_netif_t *slip_netif, esp_slip_modem_config_t *mo * @return * - ESP_OK on success */ -esp_err_t esp_slip_modem_destroy(esp_slip_modem_t *slip_modem); +esp_err_t slip_modem_destroy(slip_modem_t *slip); + +/** + * @brief Getter for the internally configured IPv6 address + * + * @param[in] slip modem object + * + * @returns + * - ipv6 address + */ +const esp_ip6_addr_t *slip_modem_get_ipv6_address(slip_modem_t *slip); + +/** + * @brief Data path API that forward the supplied data to the attached network interface + * + * @param[in] slip modem object + * @param[in] buffer pointer to the outgoing data + * @param[in] len length of the data + * + */ +void slip_modem_raw_output(slip_modem_t *slip, void *buffer, size_t len); diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c index 816ffdded9..907270a611 100644 --- a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c +++ b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c @@ -4,17 +4,18 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include #include "slip_modem.h" #include "esp_netif.h" -#include "esp_netif_slip.h" +#include "slip_modem_netif.h" #include "esp_event.h" #include "esp_log.h" #define SLIP_RX_TASK_PRIORITY 10 #define SLIP_RX_TASK_STACK_SIZE (4 * 1024) -static const char *TAG = "esp-slip_modem"; +static const char *TAG = "slip-modem"; // UART container object @@ -40,7 +41,7 @@ typedef struct { // Modem object, implements glue logic for slip_driver and esp_netif -struct esp_slip_modem { +struct slip_modem { // ESP base netif driver esp_netif_driver_base_t base; @@ -53,50 +54,54 @@ struct esp_slip_modem { // Filter callbacks for application-specific slip message handling slip_rx_filter_cb_t *rx_filter; - void *rx_filter_ctx; // Running flag bool running; + + // esp_netif related: SLIP interface IP6 address + esp_ip6_addr_t addr; + }; // Forward function declaration -static void esp_slip_modem_uart_rx_task(void *arg); -static esp_err_t esp_slip_modem_post_attach(esp_netif_t *esp_netif, void *args); +static void slip_modem_uart_rx_task(void *arg); +static esp_err_t slip_modem_post_attach(esp_netif_t *esp_netif, void *args); -// Create a new slip netif -void *esp_slip_modem_create(esp_netif_t *slip_netif, esp_slip_modem_config_t *modem_config) +// Create a new slip modem +slip_modem_t *slip_modem_create(esp_netif_t *slip_netif, slip_modem_config_t *modem_config) { ESP_LOGI(TAG, "%s: Creating slip modem (netif: %p)", __func__, slip_netif); ESP_LOGD(TAG, "%s (netif: %p)", __func__, slip_netif); - esp_slip_modem_t *slip_modem = calloc(1, sizeof(esp_slip_modem_t)); + slip_modem_t *slip_modem = calloc(1, sizeof(slip_modem_t)); if (!slip_modem) { ESP_LOGE(TAG, "create netif glue failed"); return NULL; } // Attach driver and post_attach callbacks - slip_modem->base.post_attach = esp_slip_modem_post_attach; + slip_modem->base.post_attach = slip_modem_post_attach; + slip_modem->base.netif = slip_netif; // Attach config slip_modem->buffer_len = modem_config->rx_buffer_len; slip_modem->rx_filter = modem_config->rx_filter; - slip_modem->rx_filter_ctx = modem_config->rx_filter_ctx; slip_modem->uart.uart_dev = modem_config->uart_dev; slip_modem->uart.uart_baud = modem_config->uart_baud; slip_modem->uart.uart_rx_pin = modem_config->uart_rx_pin; slip_modem->uart.uart_tx_pin = modem_config->uart_tx_pin; + memcpy(&slip_modem->addr, modem_config->ipv6_addr, sizeof(esp_ip6_addr_t)); - // Return new modem, with a cast to the first item - return &slip_modem->base; + // Return the new modem + return slip_modem; } // Internal handler called on driver start -static esp_err_t esp_slip_driver_start(esp_slip_modem_t *slip_modem) +static esp_err_t esp_slip_driver_start(slip_modem_t *slip_modem) { ESP_LOGD(TAG, "%s: Starting SLIP modem (modem %p)", __func__, slip_modem); @@ -129,38 +134,39 @@ static esp_err_t esp_slip_driver_start(esp_slip_modem_t *slip_modem) // Start slip RX task slip_modem->running = true; - xTaskCreate(esp_slip_modem_uart_rx_task, "slip_modem_uart_rx_task", SLIP_RX_TASK_STACK_SIZE, slip_modem, SLIP_RX_TASK_PRIORITY, &slip_modem->uart.uart_rx_task); + xTaskCreate(slip_modem_uart_rx_task, "slip_modem_uart_rx_task", SLIP_RX_TASK_STACK_SIZE, slip_modem, SLIP_RX_TASK_PRIORITY, &slip_modem->uart.uart_rx_task); // Finally, initialise slip network interface esp_netif_action_start(slip_modem->base.netif, 0, 0, 0); - + ESP_ERROR_CHECK(slip_modem_netif_start(slip_modem->base.netif, &slip_modem->addr)); return ESP_OK; } -esp_err_t esp_slip_modem_destroy(esp_slip_modem_t *slip_modem) +esp_err_t slip_modem_destroy(slip_modem_t *slip) { // Stop slip driver - esp_netif_action_stop(slip_modem->base.netif, 0, 0, 0); + esp_netif_action_stop(slip->base.netif, 0, 0, 0); + ESP_ERROR_CHECK(slip_modem_netif_stop(slip->base.netif)); // Stop uart rx task - vTaskDelete(slip_modem->uart.uart_rx_task); + vTaskDelete(slip->uart.uart_rx_task); // Delete driver - uart_driver_delete(slip_modem->uart.uart_dev); + uart_driver_delete(slip->uart.uart_dev); // Free slip interface - free(slip_modem); + free(slip); return ESP_OK; } // Modem transmit for glue logic -static esp_err_t esp_slip_modem_transmit(void *slip_driver, void *buffer, size_t len) +static esp_err_t slip_modem_transmit(void *slip_driver, void *buffer, size_t len) { ESP_LOGD(TAG, "%s", __func__); ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); - esp_slip_modem_t *slip_modem = (esp_slip_modem_t *) slip_driver; + slip_modem_t *slip_modem = (slip_modem_t *) slip_driver; int32_t res = uart_write_bytes(slip_modem->uart.uart_dev, (char *)buffer, len); if (res < 0) { @@ -172,15 +178,15 @@ static esp_err_t esp_slip_modem_transmit(void *slip_driver, void *buffer, size_t } // Post-attach handler for netif -static esp_err_t esp_slip_modem_post_attach(esp_netif_t *esp_netif, void *args) +static esp_err_t slip_modem_post_attach(esp_netif_t *esp_netif, void *args) { - esp_slip_modem_t *slip_modem = (esp_slip_modem_t *) args; + slip_modem_t *slip_modem = (slip_modem_t *) args; ESP_LOGD(TAG, "%s (netif: %p args: %p)", __func__, esp_netif, args); const esp_netif_driver_ifconfig_t driver_ifconfig = { .driver_free_rx_buffer = NULL, - .transmit = esp_slip_modem_transmit, + .transmit = slip_modem_transmit, .handle = slip_modem, }; @@ -192,9 +198,9 @@ static esp_err_t esp_slip_modem_post_attach(esp_netif_t *esp_netif, void *args) return ESP_OK; } -static void esp_slip_modem_uart_rx_task(void *arg) +static void slip_modem_uart_rx_task(void *arg) { - esp_slip_modem_t *slip_modem = (esp_slip_modem_t *) arg; + slip_modem_t *slip_modem = (slip_modem_t *) arg; ESP_LOGD(TAG, "Start SLIP modem RX task (slip_modem %p filter: %p)", slip_modem, slip_modem->rx_filter); ESP_LOGD(TAG, "Uart: %d, buffer: %p (%d bytes)", slip_modem->uart.uart_dev, slip_modem->buffer, slip_modem->buffer_len); @@ -213,11 +219,12 @@ static void esp_slip_modem_uart_rx_task(void *arg) slip_modem->buffer[len] = '\0'; // Filter if provided - if ((slip_modem->rx_filter != NULL) && slip_modem->rx_filter(slip_modem->rx_filter_ctx, slip_modem->buffer, len)) { + if ((slip_modem->rx_filter != NULL) && slip_modem->rx_filter(slip_modem, slip_modem->buffer, len)) { continue; } // Pass received bytes in to slip interface + ESP_LOGI(TAG, "esp_netif %p", slip_modem->base.netif); esp_netif_receive(slip_modem->base.netif, slip_modem->buffer, len, NULL); } @@ -225,3 +232,16 @@ static void esp_slip_modem_uart_rx_task(void *arg) vTaskDelay(1 * portTICK_PERIOD_MS); } } + +/** + * @brief Gets the internally configured ipv6 address + */ +const esp_ip6_addr_t *slip_modem_get_ipv6_address(slip_modem_t *slip) +{ + return &slip->addr; +} + +void slip_modem_raw_output(slip_modem_t *slip, void *buffer, size_t len) +{ + slip_modem_netif_raw_output(slip->base.netif, buffer, len); +} diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c new file mode 100644 index 0000000000..ee90bb6e0f --- /dev/null +++ b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c @@ -0,0 +1,192 @@ +/* + * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include +#include "esp_netif.h" +#include "esp_log.h" +#include "esp_netif_net_stack.h" +#include "lwip/esp_netif_net_stack.h" +#include "lwip/dns.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" +#include "netif/slipif.h" +#include "lwip/sio.h" + +static const char *TAG = "slip-modem-netif"; + +/** + * @brief Stops the SLIP interface + */ +esp_err_t slip_modem_netif_stop(esp_netif_t *esp_netif) +{ + struct netif *netif = esp_netif_get_netif_impl(esp_netif); + + ESP_LOGI(TAG, "%s: Stopped SLIP connection: lwip netif:%p", __func__, netif); + + // Stop interface + netif_set_link_down(netif); + + return ESP_OK; +} + +/** + * @brief Starts the SLIP interface + */ +esp_err_t slip_modem_netif_start(esp_netif_t *esp_netif, esp_ip6_addr_t *addr) +{ + struct netif *netif = esp_netif_get_netif_impl(esp_netif); + + ESP_LOGI(TAG, "%s: Starting SLIP interface: lwip netif:%p", __func__, netif); + + // Set the netif up + netif_set_up(netif); + netif_set_link_up(netif); +#if CONFIG_LWIP_IPV6 + int8_t addr_index = 0; + + netif_ip6_addr_set(netif, addr_index, (ip6_addr_t *)addr); + netif_ip6_addr_set_state(netif, addr_index, IP6_ADDR_VALID); +#endif + return ESP_OK; +} + +/** + * @brief Write incoming serial data to the SLIP interface + */ +void esp_netif_lwip_slip_input(void *h, void *buffer, unsigned int len, void *eb) +{ + struct netif *netif = h; + + ESP_LOGD(TAG, "%s", __func__); + ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); + + // Update slip netif with data + const int max_batch = 255; + int sent = 0; + while(sent < len) { + int batch = (len - sent) > max_batch ? max_batch : (len - sent); + slipif_received_bytes(netif, buffer+sent, batch); + sent += batch; + } + + // Process incoming bytes + for (int i = 0; i < len; i++) { + slipif_process_rxqueue(netif); + } +} + +/** + * @brief Write raw data out the SLIP interface + */ +void slip_modem_netif_raw_output(esp_netif_t *netif, void *buffer, size_t len) +{ + struct netif *lwip_netif = esp_netif_get_netif_impl(netif); + + ESP_LOGD(TAG, "%s", __func__); + + struct pbuf p = { + .next = NULL, + .payload = buffer, + .tot_len = len, + .len = len, + }; + + // Call slip if output function to feed data out slip interface +#if CONFIG_LWIP_IPV6 + lwip_netif->output_ip6(lwip_netif, &p, NULL); +#else + lwip_netif->output(lwip_netif, &p, NULL); +#endif +} + + +/** @brief Get esp-netif object corresponding to registration index + */ +static esp_netif_t * get_netif_with_esp_index(int index) +{ + esp_netif_t *netif = NULL; + int counter = 0; + while ((netif = esp_netif_next(netif)) != NULL) { + if (counter == index) { + return netif; + } + counter++; + } + return NULL; +} + +/** @brief Return list registration index of the supplied netif ptr + */ +static int get_esp_netif_index(esp_netif_t * esp_netif) +{ + esp_netif_t *netif = NULL; + int counter = 0; + while ((netif = esp_netif_next(netif)) != NULL) { + if (esp_netif == netif) { + return counter; + } + counter++; + } + return -1; +} + +err_t esp_slipif_init(struct netif *netif) +{ + esp_netif_t *esp_netif = netif->state; + int esp_index = get_esp_netif_index(esp_netif); + if (esp_index < 0) { + return ERR_IF; + } + + // Store netif index in net interface for SIO open command to abstract the dev + netif->state = (void *)esp_index; + + return slipif_init(netif); +} + +const struct esp_netif_netstack_config s_netif_config_slip = { + .lwip = { + .init_fn = esp_slipif_init, + .input_fn = esp_netif_lwip_slip_input, + } +}; + +const esp_netif_netstack_config_t *netstack_default_slip = &s_netif_config_slip; + + +/*** + * @brief Open a serial device for communication + */ +sio_fd_t sio_open(uint8_t devnum) +{ + ESP_LOGD(TAG, "Opening device: %d\r\n", devnum); + + esp_netif_t *esp_netif = get_netif_with_esp_index(devnum); + if (!esp_netif) { + ESP_LOGE(TAG, "didn't find esp-netif with index=%d\n", devnum); + return NULL; + } + + // Return SIO handle + return esp_netif; +} + +/*** + * @brief Send a single character to the serial device (blocking) + */ +void sio_send(uint8_t c, sio_fd_t fd) +{ + esp_netif_t *esp_netif = fd; + + ESP_LOGD(TAG, "%s", __func__); + ESP_LOG_BUFFER_HEX_LEVEL(TAG, &c, 1, ESP_LOG_DEBUG); + + esp_err_t ret = esp_netif_transmit(esp_netif, &c, 1); + if (ret != ESP_OK) { + // Handle errors + ESP_LOGD(TAG, "%s: uart_write_bytes error %i", __func__, ret); + } +} diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h new file mode 100644 index 0000000000..339ee675bf --- /dev/null +++ b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h @@ -0,0 +1,42 @@ +/* + * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +/** + * @brief Stop the esp slip netif + * + * @param[in] esp_netif handle to slip esp-netif instance + * + * @return + * - ESP_OK on success + */ +esp_err_t slip_modem_netif_stop(esp_netif_t *esp_netif); + +/** + * @brief Start the esp slip netif + * + * @param[in] esp_netif handle to slip esp-netif instance + * @param[in] addr IPv6 address associated with this SLIP interface + * + * @return + * - ESP_OK on success + */ +esp_err_t slip_modem_netif_start(esp_netif_t *esp_netif, esp_ip6_addr_t *addr); + +/** + * @brief Data path API to write raw packet ous the SLIP interface + * + * This API is typically used when implementing user defined methods + * + * @param[in] esp_netif handle to slip esp-netif instance + * @param[in] buffer pointer to the outgoing data + * @param[in] len length of the data + * + * @return + * - ESP_OK on success + */ +void slip_modem_netif_raw_output(esp_netif_t *netif, void *buffer, size_t len); diff --git a/examples/protocols/slip/slip_udp/main/Kconfig.projbuild b/examples/protocols/slip/slip_udp/main/Kconfig.projbuild index e23abfa081..047ba12e2f 100644 --- a/examples/protocols/slip/slip_udp/main/Kconfig.projbuild +++ b/examples/protocols/slip/slip_udp/main/Kconfig.projbuild @@ -3,14 +3,14 @@ menu "Example Configuration" menu "UART Configuration" config EXAMPLE_UART_TX_PIN int "TXD Pin Number" - default 4 + default 25 range 0 36 help Pin number of UART TX. config EXAMPLE_UART_RX_PIN int "RXD Pin Number" - default 36 + default 26 range 0 36 help Pin number of UART RX. diff --git a/examples/protocols/slip/slip_udp/main/slip_client_main.c b/examples/protocols/slip/slip_udp/main/slip_client_main.c index 8bb131f986..72a364a4f6 100644 --- a/examples/protocols/slip/slip_udp/main/slip_client_main.c +++ b/examples/protocols/slip/slip_udp/main/slip_client_main.c @@ -7,20 +7,18 @@ CONDITIONS OF ANY KIND, either express or implied. */ #include +#include + #include "freertos/FreeRTOS.h" #include "freertos/task.h" - #include "esp_system.h" #include "esp_log.h" #include "esp_event.h" #include "esp_netif.h" -#include "esp_netif_slip.h" - -#include "lwip/sockets.h" #include "slip_modem.h" -static const char *TAG = "SLIP_EXAMPLE"; +static const char *TAG = "slip-example"; #define STACK_SIZE (10 * 1024) #define PRIORITY 10 @@ -118,13 +116,10 @@ esp_err_t udp_rx_tx_init(void) } // Write a prefix to the contiki slip device -static void slip_set_prefix(esp_netif_t *slip_netif) +static void slip_set_prefix(slip_modem_t *slip) { uint8_t buff[10] = {0}; - - // Fetch the slip interface IP - const esp_ip6_addr_t *addr = esp_slip_get_ip6(slip_netif); - + const esp_ip6_addr_t *addr = slip_modem_get_ipv6_address(slip); ESP_LOGI(TAG, "%s: prefix set (%08x:%08x)", __func__, lwip_ntohl(addr->addr[0]), lwip_ntohl(addr->addr[1])); @@ -138,21 +133,18 @@ static void slip_set_prefix(esp_netif_t *slip_netif) } // Write raw data out the slip interface - esp_netif_lwip_slip_raw_output(slip_netif, buff, 2 + 8); + slip_modem_raw_output(slip, buff, 2 + 8); } // slip_rx_filter filters incoming commands from the slip interface // this implementation is designed for use with contiki slip devices -bool slip_rx_filter(void *ctx, uint8_t *data, uint32_t len) +static bool slip_rx_filter(slip_modem_t *slip, uint8_t *data, uint32_t len) { - - esp_netif_t *slip_netif = (esp_netif_t *)ctx; - if (data[1] == '?') { switch (data[2]) { case 'P': ESP_LOGI(TAG, "Prefix request"); - slip_set_prefix(slip_netif); + slip_set_prefix(slip); return true; @@ -191,24 +183,21 @@ esp_netif_t *slip_if_init(void) #endif esp_netif_config_t cfg = { .base = &base_cfg, .driver = NULL, - .stack = ESP_NETIF_NETSTACK_DEFAULT_SLIP }; + .stack = netstack_default_slip }; esp_netif_t *slip_netif = esp_netif_new(&cfg); - esp_netif_slip_config_t slip_config; - - IP6_ADDR(&slip_config.ip6_addr, + esp_ip6_addr_t local_addr; /* Local IP6 address */ + IP6_ADDR(&local_addr, lwip_htonl(0xfd0000), lwip_htonl(0x00000000), lwip_htonl(0x00000000), lwip_htonl(0x00000001) ); - esp_netif_slip_set_params(slip_netif, &slip_config); - ESP_LOGI(TAG, "Initialising SLIP modem"); - esp_slip_modem_config_t modem_cfg = { + slip_modem_config_t modem_cfg = { .uart_dev = UART_NUM_1, .uart_tx_pin = CONFIG_EXAMPLE_UART_TX_PIN, @@ -216,12 +205,12 @@ esp_netif_t *slip_if_init(void) .uart_baud = CONFIG_EXAMPLE_UART_BAUD, .rx_buffer_len = 1024, - .rx_filter = slip_rx_filter, - .rx_filter_ctx = slip_netif, + .ipv6_addr = &local_addr }; - void *slip_modem = esp_slip_modem_create(slip_netif, &modem_cfg); + void *slip_modem = slip_modem_create(slip_netif, &modem_cfg); + assert(slip_modem); ESP_ERROR_CHECK(esp_netif_attach(slip_netif, slip_modem)); ESP_LOGI(TAG, "SLIP init complete"); diff --git a/tools/ci/check_copyright_ignore.txt b/tools/ci/check_copyright_ignore.txt index d0f5a7c197..24987b71e0 100644 --- a/tools/ci/check_copyright_ignore.txt +++ b/tools/ci/check_copyright_ignore.txt @@ -460,8 +460,6 @@ components/esp_local_ctrl/src/esp_local_ctrl_handler.c components/esp_local_ctrl/src/esp_local_ctrl_priv.h components/esp_local_ctrl/src/esp_local_ctrl_transport_ble.c components/esp_netif/include/esp_netif_ppp.h -components/esp_netif/include/esp_netif_slip.h -components/esp_netif/lwip/esp_netif_lwip_slip.h components/esp_netif/private_include/esp_netif_private.h components/esp_netif/test/test_esp_netif.c components/esp_netif/test_apps/component_ut_test.py @@ -1800,7 +1798,6 @@ examples/protocols/mqtt/ws/main/app_main.c examples/protocols/mqtt/ws/mqtt_ws_example_test.py examples/protocols/mqtt/wss/main/app_main.c examples/protocols/mqtt/wss/mqtt_wss_example_test.py -examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h examples/protocols/slip/slip_udp/main/slip_client_main.c examples/protocols/sntp/example_test.py examples/protocols/sntp/main/sntp_example_main.c From b439319409d9f9cf87c9b64ec04808e1ca23eb33 Mon Sep 17 00:00:00 2001 From: David Cermak Date: Tue, 26 Jul 2022 12:16:58 +0200 Subject: [PATCH 2/3] esp_netif: Add docs on creating custom network stack connection layer --- docs/en/api-reference/network/esp_netif_driver.rst | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/docs/en/api-reference/network/esp_netif_driver.rst b/docs/en/api-reference/network/esp_netif_driver.rst index 000d5eb37d..6ea1b5104b 100644 --- a/docs/en/api-reference/network/esp_netif_driver.rst +++ b/docs/en/api-reference/network/esp_netif_driver.rst @@ -91,7 +91,12 @@ Network stack connection ------------------------ The packet data path functions for transmitting and freeing the rx buffer (defined in the I/O driver) are called from -the esp-netif, specifically from its TCP/IP stack connecting layer. The following API reference outlines these network stack -interaction with the esp-netif. +the esp-netif, specifically from its TCP/IP stack connecting layer. + +Note, that IDF provides several network stack configurations for the most common network interfaces, such as for the WiFi station or Ethernet. +These configurations are defined in :component_file:`esp_netif/include/esp_netif_defaults.h` and should be sufficient for most network drivers. +(In rare cases, expert users might want to define custom lwIP based interface layers; it is possible, but an explicit dependency to lwIP needs to be set) + +The following API reference outlines these network stack interaction with the esp-netif: .. include-build-file:: inc/esp_netif_net_stack.inc From 1f7b2d4860bb2c7fe7b5e71cee5310d73f12cbc6 Mon Sep 17 00:00:00 2001 From: David Cermak Date: Tue, 16 Aug 2022 16:07:45 +0200 Subject: [PATCH 3/3] Examples: Remove SLIP protocol example --- .../protocols/slip/slip_udp/CMakeLists.txt | 6 - examples/protocols/slip/slip_udp/README.md | 88 ------- .../components/slip_modem/CMakeLists.txt | 8 - .../slip_modem/include/slip_modem.h | 96 ------- .../slip_modem/library/slip_modem.c | 247 ------------------ .../slip_modem/library/slip_modem_netif.c | 192 -------------- .../slip_modem/library/slip_modem_netif.h | 42 --- .../slip/slip_udp/main/CMakeLists.txt | 8 - .../slip/slip_udp/main/Kconfig.projbuild | 38 --- .../slip/slip_udp/main/slip_client_main.c | 236 ----------------- .../slip/slip_udp/sdkconfig.defaults | 2 - 11 files changed, 963 deletions(-) delete mode 100644 examples/protocols/slip/slip_udp/CMakeLists.txt delete mode 100644 examples/protocols/slip/slip_udp/README.md delete mode 100644 examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt delete mode 100644 examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h delete mode 100644 examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c delete mode 100644 examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c delete mode 100644 examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h delete mode 100644 examples/protocols/slip/slip_udp/main/CMakeLists.txt delete mode 100644 examples/protocols/slip/slip_udp/main/Kconfig.projbuild delete mode 100644 examples/protocols/slip/slip_udp/main/slip_client_main.c delete mode 100644 examples/protocols/slip/slip_udp/sdkconfig.defaults diff --git a/examples/protocols/slip/slip_udp/CMakeLists.txt b/examples/protocols/slip/slip_udp/CMakeLists.txt deleted file mode 100644 index 0a8c2f9ccd..0000000000 --- a/examples/protocols/slip/slip_udp/CMakeLists.txt +++ /dev/null @@ -1,6 +0,0 @@ -# The following lines of boilerplate have to be in your project's CMakeLists -# in this exact order for cmake to work correctly -cmake_minimum_required(VERSION 3.16) - -include($ENV{IDF_PATH}/tools/cmake/project.cmake) -project(slip_client) diff --git a/examples/protocols/slip/slip_udp/README.md b/examples/protocols/slip/slip_udp/README.md deleted file mode 100644 index f8c50d9c35..0000000000 --- a/examples/protocols/slip/slip_udp/README.md +++ /dev/null @@ -1,88 +0,0 @@ -| Supported Targets | ESP32 | ESP32-C3 | ESP32-S2 | ESP32-S3 | -| ----------------- | ----- | -------- | -------- | -------- | - -# SLIP device client - -(See the README.md file in the upper level 'examples' directory for more information about examples.) - -## Overview - -This provides SLIP support for connection to Contiki gateway devices, allowing the ESP platform board to be used to bridge between low-power networks and IP (Wifi / Ethernet). - -This example also demonstrates creating custom network interfaces, including UART drivers and lwIP netif layers, and attaching them to the standard `esp_netif` component, so the generic system interfaces can still use the common approach of listing all interfaces, updating states, posting events and handling routing priorities. Please refer to the implementation of [slip_modem](components/slip_modem) component for more details. - -## How to use example - -### Hardware Required - -To run this example, you need an ESP32 dev board (e.g. ESP32-WROVER Kit) or ESP32 core board (e.g. ESP32-DevKitC). -For test purpose, you also need a SLIP capable gateway device, such as anything running [Contiki](https://github.com/contiki-os/contiki) gateway firmware. -You can also try other modules as long as they implement the SLIP protocol (e.g. linux device with slip module loaded) - -#### Setup a test SLIP device - -It is possible to configure any device with linux and a serial interface -(e.g. raspberry PI or a PC with USB to serial bridge) to enable SLIP interface. - -To test this example with such device, please follow these steps: - -- Configure IPv4 mode in the example configuration menu - -- Setup SLIP interface -``` -slattach -v -L -s 115200 -p slip /dev/ttyAMA0 -``` -where the `/dev/ttyAMA0` is the device's serial port - -- Configure IP addresses -``` -ifconfig sl0 10.0.0.1 dstaddr 10.0.0.2 -``` -where the `10.0.0.2` is IPv4 address of the ESP platform board - -- Send and receive back UDP packets, as the example implements UDP echo server -``` -nc -u 10.0.0.2 5678 -``` - -#### Pin Assignment - -**Note:** The following pin assignments are used by default which can be changed in menuconfig. - -| ESP32 | Gateway | -| ------ | -------------- | -| GPIO25 | RX | -| GPIO26 | TX | -| GND | GND | -| 3v3 | VCC | - -### Configure the project - -Open the project configuration menu (`idf.py menuconfig`). Then go into `Example Configuration` menu. - -- Choose the RX and TX pins -- Choose port number and IP protocol for socket udp server -For use in external projects `SLIP support` must be enabled under the `components/lwip` menu. - - -### Build and Flash - -Run `idf.py -p PORT flash monitor` to build and flash the project.. - -(To exit the serial monitor, type ``Ctrl-]``.) - -See the [Getting Started Guide](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html) for full steps to configure and use ESP-IDF to build projects. - - - -## Troubleshooting - -1. Invalid slip packets - -Many slip devices use additional messages for things like ipv6 prefix configuration (or sending log messages over the SLIP serial port). This is supported in the driver through the use of an `rx_filter` function that is called on receipt of all packets and can be used to filter packets prior to passing them to the stack. - -2. No packets received - -The first layer to check is the serial port, you can enable debugging of the SLIP component by setting the global log level to `DEBUG`, or changing the slip component log levbel with `esp_log_level_set("esp-netif_lwip-slip", ESP_LOG_DEBUG);` - -(For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you as soon as possible.) diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt b/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt deleted file mode 100644 index 6837386287..0000000000 --- a/examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -# SLIP Modem Component - -idf_component_register( - SRCS "library/slip_modem.c" "library/slip_modem_netif.c" - INCLUDE_DIRS "include" - REQUIRES esp_netif driver -) -target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format") diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h b/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h deleted file mode 100644 index 53b8eba5bb..0000000000 --- a/examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h +++ /dev/null @@ -1,96 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD - * - * SPDX-License-Identifier: Apache-2.0 - */ - -#pragma once - -#include -#include - -#include "esp_netif.h" -#include "driver/uart.h" - -/** @brief Configuration of SLIP network interface - * - */ -#define ESP_NETIF_INHERENT_DEFAULT_SLIP() \ - { \ - ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(mac) \ - ESP_COMPILER_DESIGNATED_INIT_AGGREGATE_TYPE_EMPTY(ip_info) \ - .get_ip_event = 0, \ - .lost_ip_event = 0, \ - .if_key = "SLP_DEF", \ - .if_desc = "slip", \ - .route_prio = 16, \ - .bridge_info = NULL \ -}; - -extern esp_netif_netstack_config_t *netstack_default_slip; - -// Forward declare modem object -typedef struct slip_modem slip_modem_t; - -// Filter callbacks for handling application specific slip messages -typedef bool slip_rx_filter_cb_t(slip_modem_t *slip, uint8_t *data, uint32_t len); - - -/** @brief Configuration structure for SLIP modem interface - * - */ -typedef struct { - uart_port_t uart_dev; /* UART device for reading and writing SLIP information, this must be initialised externally */ - - int uart_tx_pin; /* UART TX pin number */ - int uart_rx_pin; /* UART TX pin number */ - - uint32_t uart_baud; /* UART baud rate */ - - uint32_t rx_buffer_len; /* Length of buffer for RX messages */ - - slip_rx_filter_cb_t *rx_filter; /* Filter for parsing out non-SLIP messages from incoming SLIP stream */ - esp_ip6_addr_t *ipv6_addr; - -} slip_modem_config_t; - - - -/** @brief Create a slip modem - * - * @param[in] slip configured esp netif - * @param[in] configuration for the slip modem - * - * @returns - * - slip modem driver glue object - */ -slip_modem_t *slip_modem_create(esp_netif_t *slip_netif, slip_modem_config_t *modem_config); - -/** @brief Destroy a slip modem - * - * @param[in] slip modem object for destruction - * - * @return - * - ESP_OK on success - */ -esp_err_t slip_modem_destroy(slip_modem_t *slip); - -/** - * @brief Getter for the internally configured IPv6 address - * - * @param[in] slip modem object - * - * @returns - * - ipv6 address - */ -const esp_ip6_addr_t *slip_modem_get_ipv6_address(slip_modem_t *slip); - -/** - * @brief Data path API that forward the supplied data to the attached network interface - * - * @param[in] slip modem object - * @param[in] buffer pointer to the outgoing data - * @param[in] len length of the data - * - */ -void slip_modem_raw_output(slip_modem_t *slip, void *buffer, size_t len); diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c deleted file mode 100644 index 907270a611..0000000000 --- a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c +++ /dev/null @@ -1,247 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2020-2022 Espressif Systems (Shanghai) CO LTD - * - * SPDX-License-Identifier: Apache-2.0 - */ - -#include -#include "slip_modem.h" - -#include "esp_netif.h" -#include "slip_modem_netif.h" -#include "esp_event.h" -#include "esp_log.h" - -#define SLIP_RX_TASK_PRIORITY 10 -#define SLIP_RX_TASK_STACK_SIZE (4 * 1024) - -static const char *TAG = "slip-modem"; - - -// UART container object -typedef struct { - // UART device number for SIO use - uart_port_t uart_dev; - - // UART baud rate for configuration - uint32_t uart_baud; - - // UART TX pin for configuration - int uart_tx_pin; - - // UART RX pin for configuration - int uart_rx_pin; - - // QueueHandle for uart driver - QueueHandle_t uart_queue; - - // TaskHandle for receive task - TaskHandle_t uart_rx_task; -} esp_slip_uart_t; - - -// Modem object, implements glue logic for slip_driver and esp_netif -struct slip_modem { - // ESP base netif driver - esp_netif_driver_base_t base; - - // Uart for use with slip - esp_slip_uart_t uart; - - // Buffer for incoming messages - uint8_t *buffer; - uint32_t buffer_len; - - // Filter callbacks for application-specific slip message handling - slip_rx_filter_cb_t *rx_filter; - - // Running flag - bool running; - - // esp_netif related: SLIP interface IP6 address - esp_ip6_addr_t addr; - -}; - - -// Forward function declaration -static void slip_modem_uart_rx_task(void *arg); -static esp_err_t slip_modem_post_attach(esp_netif_t *esp_netif, void *args); - -// Create a new slip modem -slip_modem_t *slip_modem_create(esp_netif_t *slip_netif, slip_modem_config_t *modem_config) -{ - ESP_LOGI(TAG, "%s: Creating slip modem (netif: %p)", __func__, slip_netif); - - ESP_LOGD(TAG, "%s (netif: %p)", __func__, slip_netif); - - slip_modem_t *slip_modem = calloc(1, sizeof(slip_modem_t)); - if (!slip_modem) { - ESP_LOGE(TAG, "create netif glue failed"); - return NULL; - } - - // Attach driver and post_attach callbacks - slip_modem->base.post_attach = slip_modem_post_attach; - slip_modem->base.netif = slip_netif; - - // Attach config - slip_modem->buffer_len = modem_config->rx_buffer_len; - - slip_modem->rx_filter = modem_config->rx_filter; - - slip_modem->uart.uart_dev = modem_config->uart_dev; - slip_modem->uart.uart_baud = modem_config->uart_baud; - slip_modem->uart.uart_rx_pin = modem_config->uart_rx_pin; - slip_modem->uart.uart_tx_pin = modem_config->uart_tx_pin; - memcpy(&slip_modem->addr, modem_config->ipv6_addr, sizeof(esp_ip6_addr_t)); - - // Return the new modem - return slip_modem; -} - -// Internal handler called on driver start -static esp_err_t esp_slip_driver_start(slip_modem_t *slip_modem) -{ - ESP_LOGD(TAG, "%s: Starting SLIP modem (modem %p)", __func__, slip_modem); - - // Allocate RX buffer if one does not exist - if (slip_modem->buffer == NULL) { - slip_modem->buffer = malloc(slip_modem->buffer_len); - } - if (slip_modem->buffer == NULL) { - ESP_LOGE(TAG, "error allocating rx buffer"); - return ESP_ERR_NO_MEM; - } - - // Build configuration - uart_config_t uart_config = { - .baud_rate = slip_modem->uart.uart_baud, - .data_bits = UART_DATA_8_BITS, - .parity = UART_PARITY_DISABLE, - .stop_bits = UART_STOP_BITS_1, - .flow_ctrl = UART_HW_FLOWCTRL_DISABLE, - }; - - // Initialise uart - ESP_ERROR_CHECK(uart_param_config(slip_modem->uart.uart_dev, &uart_config)); - - // Set UART pins - ESP_ERROR_CHECK(uart_set_pin(slip_modem->uart.uart_dev, slip_modem->uart.uart_tx_pin, slip_modem->uart.uart_rx_pin, 0, 0)); - - // Install UART driver - ESP_ERROR_CHECK(uart_driver_install(slip_modem->uart.uart_dev, slip_modem->buffer_len, slip_modem->buffer_len, 10, &slip_modem->uart.uart_queue, 0)); - - // Start slip RX task - slip_modem->running = true; - xTaskCreate(slip_modem_uart_rx_task, "slip_modem_uart_rx_task", SLIP_RX_TASK_STACK_SIZE, slip_modem, SLIP_RX_TASK_PRIORITY, &slip_modem->uart.uart_rx_task); - - // Finally, initialise slip network interface - esp_netif_action_start(slip_modem->base.netif, 0, 0, 0); - ESP_ERROR_CHECK(slip_modem_netif_start(slip_modem->base.netif, &slip_modem->addr)); - return ESP_OK; -} - - -esp_err_t slip_modem_destroy(slip_modem_t *slip) -{ - // Stop slip driver - esp_netif_action_stop(slip->base.netif, 0, 0, 0); - ESP_ERROR_CHECK(slip_modem_netif_stop(slip->base.netif)); - - // Stop uart rx task - vTaskDelete(slip->uart.uart_rx_task); - - // Delete driver - uart_driver_delete(slip->uart.uart_dev); - - // Free slip interface - free(slip); - - return ESP_OK; -} - -// Modem transmit for glue logic -static esp_err_t slip_modem_transmit(void *slip_driver, void *buffer, size_t len) -{ - ESP_LOGD(TAG, "%s", __func__); - ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); - slip_modem_t *slip_modem = (slip_modem_t *) slip_driver; - - int32_t res = uart_write_bytes(slip_modem->uart.uart_dev, (char *)buffer, len); - if (res < 0) { - // Handle errors - ESP_LOGE(TAG, "%s: uart_write_bytes error %i", __func__, res); - return ESP_FAIL; - } - return ESP_OK; -} - -// Post-attach handler for netif -static esp_err_t slip_modem_post_attach(esp_netif_t *esp_netif, void *args) -{ - slip_modem_t *slip_modem = (slip_modem_t *) args; - - ESP_LOGD(TAG, "%s (netif: %p args: %p)", __func__, esp_netif, args); - - const esp_netif_driver_ifconfig_t driver_ifconfig = { - .driver_free_rx_buffer = NULL, - .transmit = slip_modem_transmit, - .handle = slip_modem, - }; - - slip_modem->base.netif = esp_netif; - ESP_ERROR_CHECK(esp_netif_set_driver_config(esp_netif, &driver_ifconfig)); - - esp_slip_driver_start(slip_modem); - - return ESP_OK; -} - -static void slip_modem_uart_rx_task(void *arg) -{ - slip_modem_t *slip_modem = (slip_modem_t *) arg; - - ESP_LOGD(TAG, "Start SLIP modem RX task (slip_modem %p filter: %p)", slip_modem, slip_modem->rx_filter); - ESP_LOGD(TAG, "Uart: %d, buffer: %p (%d bytes)", slip_modem->uart.uart_dev, slip_modem->buffer, slip_modem->buffer_len); - - while (slip_modem->running == true) { - // Read data from the UART - int len = uart_read_bytes(slip_modem->uart.uart_dev, slip_modem->buffer, slip_modem->buffer_len, 1 / portTICK_PERIOD_MS); - - if (len > 0) { - - // Log slip RX data - ESP_LOGD(TAG, "rx %d bytes", len); - ESP_LOG_BUFFER_HEX_LEVEL(TAG, slip_modem->buffer, len, ESP_LOG_DEBUG); - - // Ensure null termination - slip_modem->buffer[len] = '\0'; - - // Filter if provided - if ((slip_modem->rx_filter != NULL) && slip_modem->rx_filter(slip_modem, slip_modem->buffer, len)) { - continue; - } - - // Pass received bytes in to slip interface - ESP_LOGI(TAG, "esp_netif %p", slip_modem->base.netif); - esp_netif_receive(slip_modem->base.netif, slip_modem->buffer, len, NULL); - } - - // Yeild to allow other tasks to progress - vTaskDelay(1 * portTICK_PERIOD_MS); - } -} - -/** - * @brief Gets the internally configured ipv6 address - */ -const esp_ip6_addr_t *slip_modem_get_ipv6_address(slip_modem_t *slip) -{ - return &slip->addr; -} - -void slip_modem_raw_output(slip_modem_t *slip, void *buffer, size_t len) -{ - slip_modem_netif_raw_output(slip->base.netif, buffer, len); -} diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c deleted file mode 100644 index ee90bb6e0f..0000000000 --- a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c +++ /dev/null @@ -1,192 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD - * - * SPDX-License-Identifier: Apache-2.0 - */ - -#include -#include "esp_netif.h" -#include "esp_log.h" -#include "esp_netif_net_stack.h" -#include "lwip/esp_netif_net_stack.h" -#include "lwip/dns.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" -#include "netif/slipif.h" -#include "lwip/sio.h" - -static const char *TAG = "slip-modem-netif"; - -/** - * @brief Stops the SLIP interface - */ -esp_err_t slip_modem_netif_stop(esp_netif_t *esp_netif) -{ - struct netif *netif = esp_netif_get_netif_impl(esp_netif); - - ESP_LOGI(TAG, "%s: Stopped SLIP connection: lwip netif:%p", __func__, netif); - - // Stop interface - netif_set_link_down(netif); - - return ESP_OK; -} - -/** - * @brief Starts the SLIP interface - */ -esp_err_t slip_modem_netif_start(esp_netif_t *esp_netif, esp_ip6_addr_t *addr) -{ - struct netif *netif = esp_netif_get_netif_impl(esp_netif); - - ESP_LOGI(TAG, "%s: Starting SLIP interface: lwip netif:%p", __func__, netif); - - // Set the netif up - netif_set_up(netif); - netif_set_link_up(netif); -#if CONFIG_LWIP_IPV6 - int8_t addr_index = 0; - - netif_ip6_addr_set(netif, addr_index, (ip6_addr_t *)addr); - netif_ip6_addr_set_state(netif, addr_index, IP6_ADDR_VALID); -#endif - return ESP_OK; -} - -/** - * @brief Write incoming serial data to the SLIP interface - */ -void esp_netif_lwip_slip_input(void *h, void *buffer, unsigned int len, void *eb) -{ - struct netif *netif = h; - - ESP_LOGD(TAG, "%s", __func__); - ESP_LOG_BUFFER_HEXDUMP(TAG, buffer, len, ESP_LOG_DEBUG); - - // Update slip netif with data - const int max_batch = 255; - int sent = 0; - while(sent < len) { - int batch = (len - sent) > max_batch ? max_batch : (len - sent); - slipif_received_bytes(netif, buffer+sent, batch); - sent += batch; - } - - // Process incoming bytes - for (int i = 0; i < len; i++) { - slipif_process_rxqueue(netif); - } -} - -/** - * @brief Write raw data out the SLIP interface - */ -void slip_modem_netif_raw_output(esp_netif_t *netif, void *buffer, size_t len) -{ - struct netif *lwip_netif = esp_netif_get_netif_impl(netif); - - ESP_LOGD(TAG, "%s", __func__); - - struct pbuf p = { - .next = NULL, - .payload = buffer, - .tot_len = len, - .len = len, - }; - - // Call slip if output function to feed data out slip interface -#if CONFIG_LWIP_IPV6 - lwip_netif->output_ip6(lwip_netif, &p, NULL); -#else - lwip_netif->output(lwip_netif, &p, NULL); -#endif -} - - -/** @brief Get esp-netif object corresponding to registration index - */ -static esp_netif_t * get_netif_with_esp_index(int index) -{ - esp_netif_t *netif = NULL; - int counter = 0; - while ((netif = esp_netif_next(netif)) != NULL) { - if (counter == index) { - return netif; - } - counter++; - } - return NULL; -} - -/** @brief Return list registration index of the supplied netif ptr - */ -static int get_esp_netif_index(esp_netif_t * esp_netif) -{ - esp_netif_t *netif = NULL; - int counter = 0; - while ((netif = esp_netif_next(netif)) != NULL) { - if (esp_netif == netif) { - return counter; - } - counter++; - } - return -1; -} - -err_t esp_slipif_init(struct netif *netif) -{ - esp_netif_t *esp_netif = netif->state; - int esp_index = get_esp_netif_index(esp_netif); - if (esp_index < 0) { - return ERR_IF; - } - - // Store netif index in net interface for SIO open command to abstract the dev - netif->state = (void *)esp_index; - - return slipif_init(netif); -} - -const struct esp_netif_netstack_config s_netif_config_slip = { - .lwip = { - .init_fn = esp_slipif_init, - .input_fn = esp_netif_lwip_slip_input, - } -}; - -const esp_netif_netstack_config_t *netstack_default_slip = &s_netif_config_slip; - - -/*** - * @brief Open a serial device for communication - */ -sio_fd_t sio_open(uint8_t devnum) -{ - ESP_LOGD(TAG, "Opening device: %d\r\n", devnum); - - esp_netif_t *esp_netif = get_netif_with_esp_index(devnum); - if (!esp_netif) { - ESP_LOGE(TAG, "didn't find esp-netif with index=%d\n", devnum); - return NULL; - } - - // Return SIO handle - return esp_netif; -} - -/*** - * @brief Send a single character to the serial device (blocking) - */ -void sio_send(uint8_t c, sio_fd_t fd) -{ - esp_netif_t *esp_netif = fd; - - ESP_LOGD(TAG, "%s", __func__); - ESP_LOG_BUFFER_HEX_LEVEL(TAG, &c, 1, ESP_LOG_DEBUG); - - esp_err_t ret = esp_netif_transmit(esp_netif, &c, 1); - if (ret != ESP_OK) { - // Handle errors - ESP_LOGD(TAG, "%s: uart_write_bytes error %i", __func__, ret); - } -} diff --git a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h b/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h deleted file mode 100644 index 339ee675bf..0000000000 --- a/examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD - * - * SPDX-License-Identifier: Apache-2.0 - */ - -#pragma once - -/** - * @brief Stop the esp slip netif - * - * @param[in] esp_netif handle to slip esp-netif instance - * - * @return - * - ESP_OK on success - */ -esp_err_t slip_modem_netif_stop(esp_netif_t *esp_netif); - -/** - * @brief Start the esp slip netif - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] addr IPv6 address associated with this SLIP interface - * - * @return - * - ESP_OK on success - */ -esp_err_t slip_modem_netif_start(esp_netif_t *esp_netif, esp_ip6_addr_t *addr); - -/** - * @brief Data path API to write raw packet ous the SLIP interface - * - * This API is typically used when implementing user defined methods - * - * @param[in] esp_netif handle to slip esp-netif instance - * @param[in] buffer pointer to the outgoing data - * @param[in] len length of the data - * - * @return - * - ESP_OK on success - */ -void slip_modem_netif_raw_output(esp_netif_t *netif, void *buffer, size_t len); diff --git a/examples/protocols/slip/slip_udp/main/CMakeLists.txt b/examples/protocols/slip/slip_udp/main/CMakeLists.txt deleted file mode 100644 index eace917e55..0000000000 --- a/examples/protocols/slip/slip_udp/main/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -# Slip client example - -idf_component_register( - SRCS "slip_client_main.c" - INCLUDE_DIRS "." - REQUIRES esp_netif slip_modem driver -) -target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format") diff --git a/examples/protocols/slip/slip_udp/main/Kconfig.projbuild b/examples/protocols/slip/slip_udp/main/Kconfig.projbuild deleted file mode 100644 index 047ba12e2f..0000000000 --- a/examples/protocols/slip/slip_udp/main/Kconfig.projbuild +++ /dev/null @@ -1,38 +0,0 @@ -menu "Example Configuration" - - menu "UART Configuration" - config EXAMPLE_UART_TX_PIN - int "TXD Pin Number" - default 25 - range 0 36 - help - Pin number of UART TX. - - config EXAMPLE_UART_RX_PIN - int "RXD Pin Number" - default 26 - range 0 36 - help - Pin number of UART RX. - - config EXAMPLE_UART_BAUD - int "UART baud rate" - default 115200 - help - Baud rate for UART communication - - endmenu - - config EXAMPLE_UDP_PORT - int "Port for UDP echo server" - default 5678 - help - Port for UDP echo server in example - - config EXAMPLE_IPV4 - bool "Test with IPv4 address" - default n - help - Test interface using IPv4 - -endmenu diff --git a/examples/protocols/slip/slip_udp/main/slip_client_main.c b/examples/protocols/slip/slip_udp/main/slip_client_main.c deleted file mode 100644 index 72a364a4f6..0000000000 --- a/examples/protocols/slip/slip_udp/main/slip_client_main.c +++ /dev/null @@ -1,236 +0,0 @@ -/* SLIP Client Example - - 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 -#include - -#include "freertos/FreeRTOS.h" -#include "freertos/task.h" -#include "esp_system.h" -#include "esp_log.h" -#include "esp_event.h" -#include "esp_netif.h" - -#include "slip_modem.h" - -static const char *TAG = "slip-example"; - -#define STACK_SIZE (10 * 1024) -#define PRIORITY 10 - -static void udp_rx_tx_task(void *arg) -{ - char addr_str[128]; - uint8_t rx_buff[1024]; - - int sock = (int)arg; - - struct sockaddr_storage source_addr; - socklen_t socklen = sizeof(source_addr); - - - ESP_LOGI(TAG, "Starting node manager UDP task"); - - while (1) { - // Receive data - int len = recvfrom(sock, rx_buff, sizeof(rx_buff) - 1, 0, (struct sockaddr *)&source_addr, &socklen); - if (len < 0) { - ESP_LOGE(TAG, "recvfrom failed: errno %d", errno); - break; - } - - // Parse out address to string - if (source_addr.ss_family == PF_INET) { - inet_ntoa_r(((struct sockaddr_in *)&source_addr)->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1); - } else if (source_addr.ss_family == PF_INET6) { - inet6_ntoa_r(((struct sockaddr_in6 *)&source_addr)->sin6_addr, addr_str, sizeof(addr_str) - 1); - } - - // Force null termination of received data and print - rx_buff[len] = 0; - ESP_LOGI(TAG, "Received '%s' from '%s'", rx_buff, addr_str); - - // Send data back - int err = sendto(sock, rx_buff, len, 0, (struct sockaddr *)&source_addr, socklen); - if (err < 0) { - ESP_LOGE(TAG, "sendto failed: errno %d", errno); - break; - } - } - - vTaskDelete(NULL); -} - -esp_err_t udp_rx_tx_init(void) -{ - // Setup bind address - struct sockaddr_in6 dest_addr; -#if CONFIG_EXAMPLE_IPV4 - sa_family_t family = AF_INET; - int ip_protocol = IPPROTO_IP; - struct sockaddr_in *dest_addr_ip4 = (struct sockaddr_in *)&dest_addr; - dest_addr_ip4->sin_addr.s_addr = htonl(INADDR_ANY); - dest_addr_ip4->sin_family = AF_INET; - dest_addr_ip4->sin_port = htons(CONFIG_EXAMPLE_UDP_PORT); - ip_protocol = IPPROTO_IP; -#else - sa_family_t family = AF_INET6; - int ip_protocol = IPPROTO_IPV6; - bzero(&dest_addr.sin6_addr.un, sizeof(dest_addr.sin6_addr.un)); - dest_addr.sin6_family = family; - dest_addr.sin6_port = htons(CONFIG_EXAMPLE_UDP_PORT); -#endif - - // Create socket - int sock = socket(family, SOCK_DGRAM, ip_protocol); - if (sock < 0) { - ESP_LOGE(TAG, "Unable to create socket: errno %d", errno); - return ESP_FAIL; - } - - // Disable IPv4 and reuse address - int opt = 1; - setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); -#if !CONFIG_EXAMPLE_IPV4 - setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt)); -#endif - - // Bind socket - int err = bind(sock, (struct sockaddr *)&dest_addr, sizeof(dest_addr)); - if (err < 0) { - ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno); - return ESP_FAIL; - } - ESP_LOGI(TAG, "Socket bound, port %d", CONFIG_EXAMPLE_UDP_PORT); - - - // Start UDP rx thread - xTaskCreate(udp_rx_tx_task, "udp_rx_tx", STACK_SIZE, (void *)sock, PRIORITY, NULL); - - return ESP_OK; -} - -// Write a prefix to the contiki slip device -static void slip_set_prefix(slip_modem_t *slip) -{ - uint8_t buff[10] = {0}; - const esp_ip6_addr_t *addr = slip_modem_get_ipv6_address(slip); - ESP_LOGI(TAG, "%s: prefix set (%08x:%08x)", __func__, - lwip_ntohl(addr->addr[0]), lwip_ntohl(addr->addr[1])); - - // Build slip set message - buff[0] = '!'; - buff[1] = 'P'; - for (int i = 0; i < 2; i++) { - for (int j = 0; j < 4; j++) { - buff[2 + i * 4 + j] = addr->addr[i] >> (j * 8); - } - } - - // Write raw data out the slip interface - slip_modem_raw_output(slip, buff, 2 + 8); -} - -// slip_rx_filter filters incoming commands from the slip interface -// this implementation is designed for use with contiki slip devices -static bool slip_rx_filter(slip_modem_t *slip, uint8_t *data, uint32_t len) -{ - if (data[1] == '?') { - switch (data[2]) { - case 'P': - ESP_LOGI(TAG, "Prefix request"); - slip_set_prefix(slip); - - return true; - - default: - ESP_LOGI(TAG, "Unhandled request '%c'", data[2]); - break; - } - - return true; - - } else if (data[1] == '!') { - switch (data[2]) { - default: - ESP_LOGI(TAG, "Unhandled command '%c'", data[2]); - break; - } - } - - return false; -} - -#if CONFIG_EXAMPLE_IPV4 -static const esp_netif_ip_info_t s_slip_ip4 = { - .ip = { .addr = ESP_IP4TOADDR( 10, 0, 0, 2) }, -}; -#endif - -// Initialise the SLIP interface -esp_netif_t *slip_if_init(void) -{ - ESP_LOGI(TAG, "Initialising SLIP interface"); - - esp_netif_inherent_config_t base_cfg = ESP_NETIF_INHERENT_DEFAULT_SLIP() -#if CONFIG_EXAMPLE_IPV4 - base_cfg.ip_info = &s_slip_ip4; -#endif - esp_netif_config_t cfg = { .base = &base_cfg, - .driver = NULL, - .stack = netstack_default_slip }; - - esp_netif_t *slip_netif = esp_netif_new(&cfg); - - esp_ip6_addr_t local_addr; /* Local IP6 address */ - IP6_ADDR(&local_addr, - lwip_htonl(0xfd0000), - lwip_htonl(0x00000000), - lwip_htonl(0x00000000), - lwip_htonl(0x00000001) - ); - - ESP_LOGI(TAG, "Initialising SLIP modem"); - - slip_modem_config_t modem_cfg = { - .uart_dev = UART_NUM_1, - - .uart_tx_pin = CONFIG_EXAMPLE_UART_TX_PIN, - .uart_rx_pin = CONFIG_EXAMPLE_UART_RX_PIN, - .uart_baud = CONFIG_EXAMPLE_UART_BAUD, - - .rx_buffer_len = 1024, - .rx_filter = slip_rx_filter, - .ipv6_addr = &local_addr - }; - - void *slip_modem = slip_modem_create(slip_netif, &modem_cfg); - assert(slip_modem); - ESP_ERROR_CHECK(esp_netif_attach(slip_netif, slip_modem)); - - ESP_LOGI(TAG, "SLIP init complete"); - - return slip_netif; -} - -void app_main(void) -{ - // Setup networking - esp_netif_init(); - - esp_log_level_set("*", ESP_LOG_DEBUG); - - // Create event loop - ESP_ERROR_CHECK(esp_event_loop_create_default()); - - // Setup slip interface - slip_if_init(); - - // Setup UDP loopback service - udp_rx_tx_init(); -} diff --git a/examples/protocols/slip/slip_udp/sdkconfig.defaults b/examples/protocols/slip/slip_udp/sdkconfig.defaults deleted file mode 100644 index a0f094bcdd..0000000000 --- a/examples/protocols/slip/slip_udp/sdkconfig.defaults +++ /dev/null @@ -1,2 +0,0 @@ -# Override some defaults to enable SLIP -CONFIG_LWIP_SLIP_SUPPORT=y