kopia lustrzana https://github.com/espressif/esp-idf
248 wiersze
6.6 KiB
C
248 wiersze
6.6 KiB
C
/* 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 <string.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";
|
|
|
|
#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(esp_netif_t *slip_netif)
|
|
{
|
|
uint8_t buff[10] = {0};
|
|
|
|
// Fetch the slip interface IP
|
|
const esp_ip6_addr_t *addr = esp_slip_get_ip6(slip_netif);
|
|
|
|
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
|
|
esp_netif_lwip_slip_raw_output(slip_netif, 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)
|
|
{
|
|
|
|
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);
|
|
|
|
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 = ESP_NETIF_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,
|
|
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 = {
|
|
.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,
|
|
.rx_filter_ctx = slip_netif,
|
|
};
|
|
|
|
void *slip_modem = esp_slip_modem_create(slip_netif, &modem_cfg);
|
|
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();
|
|
}
|