espressif/esp-protocols
1
0
Fork 1
mirror of https://github.com/espressif/esp-protocols.git synced 2025-07-29 10:17:30 +02:00
Code Issues Packages Projects Releases Wiki Activity

feat(eppp): Added support for SPI transport

Browse Source
This commit is contained in:
David Cermak
2023-12-22 20:03:01 +01:00
parent ad27414a64
commit 18f845275f
19 changed files with 1192 additions and 431 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
components/eppp_link/test/test_app/CMakeLists.txt Normal file
View File

@ -0,0 +1,7 @@
# The following four 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)
set(EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/tools/unit-test-app/components)
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
project(test_app)

73
components/eppp_link/test/test_app/README.md Normal file
View File

@ -0,0 +1,73 @@
# Test application running both server and client on the same device
Need to connect client's Tx to server's Rx and vice versa:
GPIO25 - GPIO4
GPIO26 - GPIO5
We wait for the connection and then we start pinging the client's address on server's netif.
## Example of output:
```
I (393) eppp_test_app: [APP] Startup..
I (393) eppp_test_app: [APP] Free memory: 296332 bytes
I (393) eppp_test_app: [APP] IDF version: v5.3-dev-1154-gf14d9e7431-dirty
I (423) uart: ESP_INTR_FLAG_IRAM flag not set while CONFIG_UART_ISR_IN_IRAM is enabled, flag updated
I (423) uart: queue free spaces: 16
I (433) eppp_link: Waiting for IP address
I (433) uart: ESP_INTR_FLAG_IRAM flag not set while CONFIG_UART_ISR_IN_IRAM is enabled, flag updated
I (443) uart: queue free spaces: 16
I (443) eppp_link: Waiting for IP address
I (6473) esp-netif_lwip-ppp: Connected
I (6513) eppp_link: Got IPv4 event: Interface "pppos_client" address: 192.168.11.2
I (6523) esp-netif_lwip-ppp: Connected
I (6513) eppp_link: Connected!
I (6523) eppp_link: Got IPv4 event: Interface "pppos_server" address: 192.168.11.1
I (6553) main_task: Returned from app_main()
64bytes from 192.168.11.2 icmp_seq=1 ttl=255 time=18 ms
64bytes from 192.168.11.2 icmp_seq=2 ttl=255 time=19 ms
64bytes from 192.168.11.2 icmp_seq=3 ttl=255 time=19 ms
64bytes from 192.168.11.2 icmp_seq=4 ttl=255 time=20 ms
64bytes from 192.168.11.2 icmp_seq=5 ttl=255 time=19 ms
64bytes from 192.168.11.2 icmp_seq=6 ttl=255 time=19 ms
64bytes from 192.168.11.2 icmp_seq=7 ttl=255 time=19 ms
From 192.168.11.2 icmp_seq=8 timeout // <-- Disconnected Tx-Rx wires
From 192.168.11.2 icmp_seq=9 timeout
```
## Test cases
This test app exercises these methods of setting up server-client connection:
* simple blocking API (eppp_listen() <--> eppp_connect()): Uses network events internally and waits for connection
* simplified non-blocking API (eppp_open(EPPP_SERVER, ...) <--> eppp_open(EPPP_SERVER, ...) ): Uses events internally, optionally waits for connecting
* manual API (eppp_init(), eppp_netif_start(), eppp_perform()): User to manually drive Rx task
- Note that the ping test for this test case takes longer, since we call perform for both server and client from one task, for example:
```
TEST(eppp_test, open_close_taskless)I (28562) uart: ESP_INTR_FLAG_IRAM flag not set while CONFIG_UART_ISR_IN_IRAM is enabled, flag updated
I (28572) uart: ESP_INTR_FLAG_IRAM flag not set while CONFIG_UART_ISR_IN_IRAM is enabled, flag updated
Note: esp_netif_init() has been called. Until next reset, TCP/IP task will periodicially allocate memory and consume CPU time.
I (28602) uart: ESP_INTR_FLAG_IRAM flag not set while CONFIG_UART_ISR_IN_IRAM is enabled, flag updated
I (28612) uart: queue free spaces: 16
I (28612) uart: ESP_INTR_FLAG_IRAM flag not set while CONFIG_UART_ISR_IN_IRAM is enabled, flag updated
I (28622) uart: queue free spaces: 16
I (28642) esp-netif_lwip-ppp: Connected
I (28642) esp-netif_lwip-ppp: Connected
I (28642) test: Got IPv4 event: Interface "pppos_server(EPPP0)" address: 192.168.11.1
I (28642) esp-netif_lwip-ppp: Connected
I (28652) test: Got IPv4 event: Interface "pppos_client(EPPP1)" address: 192.168.11.2
I (28662) esp-netif_lwip-ppp: Connected
64bytes from 192.168.11.2 icmp_seq=1 ttl=255 time=93 ms
64bytes from 192.168.11.2 icmp_seq=2 ttl=255 time=98 ms
64bytes from 192.168.11.2 icmp_seq=3 ttl=255 time=99 ms
64bytes from 192.168.11.2 icmp_seq=4 ttl=255 time=99 ms
64bytes from 192.168.11.2 icmp_seq=5 ttl=255 time=99 ms
5 packets transmitted, 5 received, time 488ms
I (29162) esp-netif_lwip-ppp: User interrupt
I (29162) test: Disconnected interface "pppos_client(EPPP1)"
I (29172) esp-netif_lwip-ppp: User interrupt
I (29172) test: Disconnected interface "pppos_server(EPPP0)"
MALLOC_CAP_8BIT usage: Free memory delta: 0 Leak threshold: -64
MALLOC_CAP_32BIT usage: Free memory delta: 0 Leak threshold: -64
PASS
```

4
components/eppp_link/test/test_app/main/CMakeLists.txt Normal file
View File

@ -0,0 +1,4 @@
idf_component_register(SRCS app_main.c
INCLUDE_DIRS "."
REQUIRES test_utils
PRIV_REQUIRES unity nvs_flash esp_netif driver esp_event)

344
components/eppp_link/test/test_app/main/app_main.c Normal file
View File

@ -0,0 +1,344 @@
/*
* SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include "esp_system.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_netif_ppp.h"
#include "eppp_link.h"
#include "lwip/sockets.h"
#include "esp_log.h"
#include "ping/ping_sock.h"
#include "driver/uart.h"
#include "test_utils.h"
#include "unity.h"
#include "test_utils.h"
#include "unity_fixture.h"
#include "memory_checks.h"
#include "lwip/sys.h"
#define CLIENT_INFO_CONNECTED BIT0
#define CLIENT_INFO_DISCONNECT BIT1
#define CLIENT_INFO_CLOSED BIT2
#define PING_SUCCEEDED BIT3
#define PING_FAILED BIT4
#define STOP_WORKER_TASK BIT5
#define WORKER_TASK_STOPPED BIT6
TEST_GROUP(eppp_test);
TEST_SETUP(eppp_test)
{
// Perform some open/close operations to disregard lazy init one-time allocations
// LWIP: core protection mutex
sys_arch_protect();
sys_arch_unprotect(0);
// UART: install and delete both drivers to disregard potential leak in allocated interrupt slot
TEST_ESP_OK(uart_driver_install(UART_NUM_1, 256, 0, 0, NULL, 0));
TEST_ESP_OK(uart_driver_delete(UART_NUM_1));
TEST_ESP_OK(uart_driver_install(UART_NUM_2, 256, 0, 0, NULL, 0));
TEST_ESP_OK(uart_driver_delete(UART_NUM_2));
// PING: used for timestamps
struct timeval time;
gettimeofday(&time, NULL);
test_utils_record_free_mem();
TEST_ESP_OK(test_utils_set_leak_level(0, ESP_LEAK_TYPE_CRITICAL, ESP_COMP_LEAK_GENERAL));
}
TEST_TEAR_DOWN(eppp_test)
{
test_utils_finish_and_evaluate_leaks(32, 64);
}
static void test_on_ping_end(esp_ping_handle_t hdl, void *args)
{
EventGroupHandle_t event = args;
uint32_t transmitted;
uint32_t received;
uint32_t total_time_ms;
esp_ping_get_profile(hdl, ESP_PING_PROF_REQUEST, &transmitted, sizeof(transmitted));
esp_ping_get_profile(hdl, ESP_PING_PROF_REPLY, &received, sizeof(received));
esp_ping_get_profile(hdl, ESP_PING_PROF_DURATION, &total_time_ms, sizeof(total_time_ms));
printf("%" PRId32 " packets transmitted, %" PRId32 " received, time %" PRId32 "ms\n", transmitted, received, total_time_ms);
if (transmitted == received) {
xEventGroupSetBits(event, PING_SUCCEEDED);
} else {
xEventGroupSetBits(event, PING_FAILED);
}
}
static void test_on_ping_success(esp_ping_handle_t hdl, void *args)
{
uint8_t ttl;
uint16_t seqno;
uint32_t elapsed_time, recv_len;
ip_addr_t target_addr;
esp_ping_get_profile(hdl, ESP_PING_PROF_SEQNO, &seqno, sizeof(seqno));
esp_ping_get_profile(hdl, ESP_PING_PROF_TTL, &ttl, sizeof(ttl));
esp_ping_get_profile(hdl, ESP_PING_PROF_IPADDR, &target_addr, sizeof(target_addr));
esp_ping_get_profile(hdl, ESP_PING_PROF_SIZE, &recv_len, sizeof(recv_len));
esp_ping_get_profile(hdl, ESP_PING_PROF_TIMEGAP, &elapsed_time, sizeof(elapsed_time));
printf("%" PRId32 "bytes from %s icmp_seq=%d ttl=%d time=%" PRId32 " ms\n",
recv_len, inet_ntoa(target_addr.u_addr.ip4), seqno, ttl, elapsed_time);
}
struct client_info {
esp_netif_t *netif;
EventGroupHandle_t event;
};
static void open_client_task(void *ctx)
{
struct client_info *info = ctx;
eppp_config_t config = EPPP_DEFAULT_CLIENT_CONFIG();
config.uart.port = UART_NUM_2;
config.uart.tx_io = 4;
config.uart.rx_io = 5;
info->netif = eppp_connect(&config);
xEventGroupSetBits(info->event, CLIENT_INFO_CONNECTED);
// wait for disconnection trigger
EventBits_t bits = xEventGroupWaitBits(info->event, CLIENT_INFO_DISCONNECT, pdFALSE, pdFALSE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & CLIENT_INFO_DISCONNECT, CLIENT_INFO_DISCONNECT);
eppp_close(info->netif);
xEventGroupSetBits(info->event, CLIENT_INFO_CLOSED);
vTaskDelete(NULL);
}
TEST(eppp_test, init_deinit)
{
// Init and deinit server size
eppp_config_t config = EPPP_DEFAULT_CONFIG(0, 0);
esp_netif_t *netif = eppp_init(EPPP_SERVER, &config);
TEST_ASSERT_NOT_NULL(netif);
eppp_deinit(netif);
netif = NULL;
// Init and deinit client size
netif = eppp_init(EPPP_CLIENT, &config);
TEST_ASSERT_NOT_NULL(netif);
eppp_deinit(netif);
}
static EventBits_t ping_test(uint32_t addr, esp_netif_t *netif, EventGroupHandle_t event)
{
ip_addr_t target_addr = { .type = IPADDR_TYPE_V4, .u_addr.ip4.addr = addr };
esp_ping_config_t ping_config = ESP_PING_DEFAULT_CONFIG();
ping_config.interval_ms = 100;
ping_config.target_addr = target_addr;
ping_config.interface = esp_netif_get_netif_impl_index(netif);
esp_ping_callbacks_t cbs = { .cb_args = event, .on_ping_end = test_on_ping_end, .on_ping_success = test_on_ping_success };
esp_ping_handle_t ping;
esp_ping_new_session(&ping_config, &cbs, &ping);
esp_ping_start(ping);
// Wait for the client thread closure and delete locally created objects
EventBits_t bits = xEventGroupWaitBits(event, PING_SUCCEEDED | PING_FAILED, pdFALSE, pdFALSE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & (PING_SUCCEEDED | PING_FAILED), PING_SUCCEEDED);
esp_ping_stop(ping);
esp_ping_delete_session(ping);
return bits;
}
TEST(eppp_test, open_close)
{
test_case_uses_tcpip();
eppp_config_t config = EPPP_DEFAULT_SERVER_CONFIG();
struct client_info client = { .netif = NULL, .event = xEventGroupCreate()};
TEST_ESP_OK(esp_event_loop_create_default());
TEST_ASSERT_NOT_NULL(client.event);
// Need to connect the client in a separate thread, as the simplified API blocks until connection
xTaskCreate(open_client_task, "client_task", 4096, &client, 5, NULL);
// Now start the server
esp_netif_t *eppp_server = eppp_listen(&config);
// Wait for the client to connect
EventBits_t bits = xEventGroupWaitBits(client.event, CLIENT_INFO_CONNECTED, pdFALSE, pdFALSE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & CLIENT_INFO_CONNECTED, CLIENT_INFO_CONNECTED);
// Check that both server and client are valid netif pointers
TEST_ASSERT_NOT_NULL(eppp_server);
TEST_ASSERT_NOT_NULL(client.netif);
// Now that we're connected, let's try to ping clients address
bits = ping_test(config.ppp.their_ip4_addr, eppp_server, client.event);
TEST_ASSERT_EQUAL(bits & (PING_SUCCEEDED | PING_FAILED), PING_SUCCEEDED);
// Trigger client disconnection and close the server
xEventGroupSetBits(client.event, CLIENT_INFO_DISCONNECT);
eppp_close(eppp_server);
// Wait for the client thread closure and delete locally created objects
bits = xEventGroupWaitBits(client.event, CLIENT_INFO_CLOSED, pdFALSE, pdFALSE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & CLIENT_INFO_CLOSED, CLIENT_INFO_CLOSED);
TEST_ESP_OK(esp_event_loop_delete_default());
vEventGroupDelete(client.event);
// wait for the lwip sockets to close cleanly
vTaskDelay(pdMS_TO_TICKS(1000));
}
static void on_event(void *arg, esp_event_base_t base, int32_t event_id, void *data)
{
EventGroupHandle_t event = arg;
if (base == IP_EVENT && event_id == IP_EVENT_PPP_GOT_IP) {
ip_event_got_ip_t *e = (ip_event_got_ip_t *)data;
esp_netif_t *netif = e->esp_netif;
ESP_LOGI("test", "Got IPv4 event: Interface \"%s(%s)\" address: " IPSTR, esp_netif_get_desc(netif),
esp_netif_get_ifkey(netif), IP2STR(&e->ip_info.ip));
if (strcmp("pppos_server", esp_netif_get_desc(netif)) == 0) {
xEventGroupSetBits(event, 1 << EPPP_SERVER);
} else if (strcmp("pppos_client", esp_netif_get_desc(netif)) == 0) {
xEventGroupSetBits(event, 1 << EPPP_CLIENT);
}
} else if (base == NETIF_PPP_STATUS && event_id == NETIF_PPP_ERRORUSER) {
esp_netif_t **netif = data;
ESP_LOGI("test", "Disconnected interface \"%s(%s)\"", esp_netif_get_desc(*netif), esp_netif_get_ifkey(*netif));
if (strcmp("pppos_server", esp_netif_get_desc(*netif)) == 0) {
xEventGroupSetBits(event, 1 << EPPP_SERVER);
} else if (strcmp("pppos_client", esp_netif_get_desc(*netif)) == 0) {
xEventGroupSetBits(event, 1 << EPPP_CLIENT);
}
}
}
TEST(eppp_test, open_close_nonblocking)
{
test_case_uses_tcpip();
EventGroupHandle_t event = xEventGroupCreate();
eppp_config_t server_config = EPPP_DEFAULT_SERVER_CONFIG();
TEST_ESP_OK(esp_event_loop_create_default());
// Open the server size
TEST_ESP_OK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_event, event));
esp_netif_t *eppp_server = eppp_open(EPPP_SERVER, &server_config, 0);
TEST_ASSERT_NOT_NULL(eppp_server);
// Open the client size
eppp_config_t client_config = EPPP_DEFAULT_SERVER_CONFIG();
client_config.uart.port = UART_NUM_2;
client_config.uart.tx_io = 4;
client_config.uart.rx_io = 5;
esp_netif_t *eppp_client = eppp_open(EPPP_CLIENT, &client_config, 0);
TEST_ASSERT_NOT_NULL(eppp_client);
const EventBits_t wait_bits = (1 << EPPP_SERVER) | (1 << EPPP_CLIENT);
EventBits_t bits = xEventGroupWaitBits(event, wait_bits, pdTRUE, pdTRUE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & wait_bits, wait_bits);
// Now that we're connected, let's try to ping clients address
bits = ping_test(server_config.ppp.their_ip4_addr, eppp_server, event);
TEST_ASSERT_EQUAL(bits & (PING_SUCCEEDED | PING_FAILED), PING_SUCCEEDED);
// stop network for both client and server
eppp_netif_stop(eppp_client, 0); // ignore result, since we're not waiting for clean close
eppp_close(eppp_server);
eppp_close(eppp_client); // finish client close
TEST_ESP_OK(esp_event_loop_delete_default());
vEventGroupDelete(event);
// wait for the lwip sockets to close cleanly
vTaskDelay(pdMS_TO_TICKS(1000));
}
struct worker {
esp_netif_t *eppp_server;
esp_netif_t *eppp_client;
EventGroupHandle_t event;
};
static void worker_task(void *ctx)
{
struct worker *info = ctx;
while (1) {
eppp_perform(info->eppp_server);
eppp_perform(info->eppp_client);
if (xEventGroupGetBits(info->event) & STOP_WORKER_TASK) {
break;
}
}
xEventGroupSetBits(info->event, WORKER_TASK_STOPPED);
vTaskDelete(NULL);
}
TEST(eppp_test, open_close_taskless)
{
test_case_uses_tcpip();
struct worker info = { .event = xEventGroupCreate() };
TEST_ESP_OK(esp_event_loop_create_default());
TEST_ESP_OK(esp_event_handler_register(IP_EVENT, ESP_EVENT_ANY_ID, on_event, info.event));
TEST_ESP_OK(esp_event_handler_register(NETIF_PPP_STATUS, ESP_EVENT_ANY_ID, on_event, info.event));
// Create server
eppp_config_t server_config = EPPP_DEFAULT_SERVER_CONFIG();
info.eppp_server = eppp_init(EPPP_SERVER, &server_config);
TEST_ASSERT_NOT_NULL(info.eppp_server);
// Create client
eppp_config_t client_config = EPPP_DEFAULT_CLIENT_CONFIG();
client_config.uart.port = UART_NUM_2;
client_config.uart.tx_io = 4;
client_config.uart.rx_io = 5;
info.eppp_client = eppp_init(EPPP_CLIENT, &client_config);
TEST_ASSERT_NOT_NULL(info.eppp_client);
// Start workers
xTaskCreate(worker_task, "worker", 4096, &info, 5, NULL);
// Start network
TEST_ESP_OK(eppp_netif_start(info.eppp_server));
TEST_ESP_OK(eppp_netif_start(info.eppp_client));
const EventBits_t wait_bits = (1 << EPPP_SERVER) | (1 << EPPP_CLIENT);
EventBits_t bits = xEventGroupWaitBits(info.event, wait_bits, pdTRUE, pdTRUE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & wait_bits, wait_bits);
xEventGroupClearBits(info.event, wait_bits);
// Now that we're connected, let's try to ping clients address
bits = ping_test(server_config.ppp.their_ip4_addr, info.eppp_server, info.event);
TEST_ASSERT_EQUAL(bits & (PING_SUCCEEDED | PING_FAILED), PING_SUCCEEDED);
// stop network for both client and server, we won't wait for completion so expecting ESP_FAIL
TEST_ASSERT_EQUAL(eppp_netif_stop(info.eppp_client, 0), ESP_FAIL);
TEST_ASSERT_EQUAL(eppp_netif_stop(info.eppp_server, 0), ESP_FAIL);
// and wait for completion
bits = xEventGroupWaitBits(info.event, wait_bits, pdTRUE, pdTRUE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & wait_bits, wait_bits);
// now stop the worker
xEventGroupSetBits(info.event, STOP_WORKER_TASK);
bits = xEventGroupWaitBits(info.event, WORKER_TASK_STOPPED, pdTRUE, pdTRUE, pdMS_TO_TICKS(50000));
TEST_ASSERT_EQUAL(bits & WORKER_TASK_STOPPED, WORKER_TASK_STOPPED);
// and destroy objects
eppp_deinit(info.eppp_server);
eppp_deinit(info.eppp_client);
TEST_ESP_OK(esp_event_loop_delete_default());
vEventGroupDelete(info.event);
// wait for the lwip sockets to close cleanly
vTaskDelay(pdMS_TO_TICKS(1000));
}
TEST_GROUP_RUNNER(eppp_test)
{
RUN_TEST_CASE(eppp_test, init_deinit)
RUN_TEST_CASE(eppp_test, open_close)
RUN_TEST_CASE(eppp_test, open_close_nonblocking)
RUN_TEST_CASE(eppp_test, open_close_taskless)
}
void app_main(void)
{
UNITY_MAIN(eppp_test);
}

4
components/eppp_link/test/test_app/main/idf_component.yml Normal file
View File

@ -0,0 +1,4 @@
dependencies:
espressif/eppp_link:
version: "*"
override_path: "../../.."

12
components/eppp_link/test/test_app/sdkconfig.defaults Normal file
View File

@ -0,0 +1,12 @@
# This file was generated using idf.py save-defconfig. It can be edited manually.
# Espressif IoT Development Framework (ESP-IDF) 5.3.0 Project Minimal Configuration
#
CONFIG_UART_ISR_IN_IRAM=y
CONFIG_ESP_NETIF_IP_LOST_TIMER_INTERVAL=0
CONFIG_FREERTOS_UNICORE=y
CONFIG_HEAP_TRACING_STANDALONE=y
CONFIG_HEAP_TRACING_STACK_DEPTH=6
CONFIG_LWIP_PPP_SUPPORT=y
CONFIG_LWIP_PPP_VJ_HEADER_COMPRESSION=n
CONFIG_LWIP_PPP_DEBUG_ON=y
CONFIG_UNITY_ENABLE_FIXTURE=y