alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-10-05 20:47:46 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

esp_netif: Migrate SLIP interface to user-space

Browse Source
This commit is contained in:
David Cermak 2022-07-22 17:37:47 +02:00 committed by David Čermák
parent 985f44c158
commit 83b8556f10
21 changed files with 368 additions and 628 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
components/esp_netif/CMakeLists.txt
View File

@ -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")

2
components/esp_netif/esp_netif_defaults.c
View File

@ -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();

32
components/esp_netif/include/esp_netif_defaults.h
View File

@ -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;

82
components/esp_netif/include/esp_netif_slip.h
View File

@ -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_

3
components/esp_netif/include/esp_netif_types.h
View File

@ -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 {

7
components/esp_netif/include/lwip/esp_netif_net_stack.h
View File

@ -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 {

1
components/esp_netif/loopback/esp_netif_loopback.c
View File

@ -6,7 +6,6 @@
#include <string.h>
#include "esp_netif_lwip_internal.h"
#include "esp_netif.h"
#include "esp_netif_private.h"

49
components/esp_netif/lwip/esp_netif_lwip.c
View File

@ -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);

10
components/esp_netif/lwip/esp_netif_lwip_internal.h
View File

@ -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;

2
components/esp_netif/lwip/esp_netif_lwip_ppp.c
View File

@ -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

307
components/esp_netif/lwip/esp_netif_lwip_slip.c
View File

@ -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 <string.h>
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 */

58
components/esp_netif/lwip/esp_netif_lwip_slip.h
View File

@ -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_

6
examples/protocols/slip/slip_udp/README.md
View File

@ -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 |

2
examples/protocols/slip/slip_udp/components/slip_modem/CMakeLists.txt
View File

@ -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
)

70
examples/protocols/slip/slip_udp/components/slip_modem/include/slip_modem.h
View File

@ -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 <stdint.h>
#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);

78
examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem.c
View File

@ -4,17 +4,18 @@
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#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);
}

192
examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.c Normal file
View File

@ -0,0 +1,192 @@
/*
* SPDX-FileCopyrightText: 2019-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#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);
}
}

42
examples/protocols/slip/slip_udp/components/slip_modem/library/slip_modem_netif.h Normal file
View File

@ -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);

4
examples/protocols/slip/slip_udp/main/Kconfig.projbuild
View File

@ -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.

41
examples/protocols/slip/slip_udp/main/slip_client_main.c
View File

@ -7,20 +7,18 @@
CONDITIONS OF ANY KIND, either express or implied.
*/
#include <string.h>
#include <sys/socket.h>
#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");

3
tools/ci/check_copyright_ignore.txt
View File

@ -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