blackbeard420/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf synced 2025-03-10 01:29:21 -04:00
Code Issues Projects Releases Wiki Activity

feat(openthread): support trel feature

Browse Source
This commit is contained in:
Xu Si Yu 2024-07-17 12:27:56 +08:00 committed by BOT
parent d697fda6a1
commit 88077e0b16
19 changed files with 883 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
components/openthread/CMakeLists.txt
View File

@ -15,7 +15,6 @@ if(CONFIG_OPENTHREAD_ENABLED)
set(private_include_dirs
"openthread/examples/platforms"
"openthread/include/openthread"
"openthread/src"
"openthread/src/core"
"openthread/src/lib"
@ -140,6 +139,19 @@ if(CONFIG_OPENTHREAD_ENABLED)
list(APPEND exclude_srcs
"src/port/esp_openthread_radio.c"
"src/port/esp_openthread_sleep.c")
elseif(CONFIG_OPENTHREAD_RADIO_154_NONE)
list(APPEND exclude_srcs
"src/port/esp_openthread_radio_spinel.cpp"
"src/port/esp_spi_spinel_interface.cpp"
"src/port/esp_uart_spinel_interface.cpp"
"src/port/esp_openthread_radio.c"
"src/port/esp_openthread_sleep.c"
)
endif()
if(NOT CONFIG_OPENTHREAD_RADIO_TREL)
list(APPEND exclude_srcs
"src/port/esp_openthread_trel.c")
endif()
if(CONFIG_OPENTHREAD_BORDER_ROUTER)
@ -252,6 +264,10 @@ idf_component_register(SRC_DIRS "${src_dirs}"
PRIV_REQUIRES console esp_event esp_partition esp_timer
ieee802154 mbedtls nvs_flash)
if(CONFIG_OPENTHREAD_RADIO_TREL)
idf_component_optional_requires(PRIVATE espressif__mdns)
endif()
if(CONFIG_OPENTHREAD_ENABLED OR CONFIG_OPENTHREAD_SPINEL_ONLY)
if(CONFIG_OPENTHREAD_RADIO)
set(CONFIG_FILE_TYPE "radio")

20
components/openthread/Kconfig
View File

@ -101,7 +101,7 @@ menu "OpenThread"
default 5 if OPENTHREAD_LOG_LEVEL_DEBG
choice OPENTHREAD_RADIO_TYPE
prompt "Config the Thread radio type"
prompt "Config the Thread radio type with 15.4 link"
depends on OPENTHREAD_ENABLED
default OPENTHREAD_RADIO_NATIVE if SOC_IEEE802154_SUPPORTED
default OPENTHREAD_RADIO_SPINEL_UART
@ -124,8 +124,26 @@ menu "OpenThread"
help
Select this to connect to a Radio Co-Processor via SPI.
config OPENTHREAD_RADIO_154_NONE
bool "Disable the Thread radio based on 15.4 link"
help
Select this to disable the Thread radio based on 15.4 link.
endchoice
config OPENTHREAD_RADIO_TREL
bool "Enable Thread Radio Encapsulation Link (TREL)"
depends on SOC_WIFI_SUPPORTED
default n
help
Select this option to enable Thread Radio Encapsulation Link.
config OPENTHREAD_TREL_PORT
int "The port of openthread trel service"
depends on OPENTHREAD_RADIO_TREL
default 12390
help
Configure the port number of TREL service.
choice OPENTHREAD_DEVICE_TYPE
prompt "Config the Thread device type"
depends on OPENTHREAD_ENABLED

38
components/openthread/include/esp_openthread_trel.h Normal file
View File

@ -0,0 +1,38 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include "sdkconfig.h"
#include "esp_netif.h"
#include "esp_netif_types.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Sets the interface used for trel feature.
*
* @note This function must be called after connect to wifi/ethernet
*
* @param[in] trel_netif The network interface (WiFi or ethernet)
*
*/
void esp_openthread_set_trel_netif(esp_netif_t *trel_netif);
/**
* @brief Gets the trel interface of OpenThread device.
*
* @return
* The trel interface or NULL if trel not initialized.
*
*/
esp_netif_t *esp_openthread_get_trel_netif(void);
#ifdef __cplusplus
}
#endif

1
components/openthread/include/esp_openthread_types.h
View File

@ -136,6 +136,7 @@ typedef enum {
RADIO_MODE_NATIVE = 0x0, /*!< Use the native 15.4 radio */
RADIO_MODE_UART_RCP, /*!< UART connection to a 15.4 capable radio co-processor (RCP) */
RADIO_MODE_SPI_RCP, /*!< SPI connection to a 15.4 capable radio co-processor (RCP) */
RADIO_MODE_TREL, /*!< Use the Thread Radio Encapsulation Link (TREL) */
RADIO_MODE_MAX, /*!< Using for parameter check */
} esp_openthread_radio_mode_t;

32
components/openthread/private_include/openthread-core-esp32x-ftd-config.h
View File

@ -203,16 +203,6 @@
#define OPENTHREAD_CONFIG_DNSSD_SERVER_ENABLE 1
#endif
/**
* @def OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
*
* Set to 1 to enable support for Thread Radio Encapsulation Link (TREL).
*
*/
#ifndef OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
#define OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE 0
#endif
/**
* @def OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE
*
@ -225,6 +215,28 @@
#endif // CONFIG_OPENTHREAD_BORDER_ROUTER
/**
* @def OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
*
* Set to 1 to enable support for Thread Radio Encapsulation Link (TREL).
*
*/
#if CONFIG_OPENTHREAD_RADIO_TREL
#define OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE 1
#endif // CONFIG_OPENTHREAD_RADIO_TREL
/**
* @def OPENTHREAD_CONFIG_RADIO_LINK_IEEE_802_15_4_ENABLE
*
* Set to 1 to enable support for IEEE802.15.4 radio link.
*
*/
#if CONFIG_OPENTHREAD_RADIO_NATIVE || CONFIG_OPENTHREAD_RADIO_SPINEL_UART || CONFIG_OPENTHREAD_RADIO_SPINEL_SPI
#define OPENTHREAD_CONFIG_RADIO_LINK_IEEE_802_15_4_ENABLE 1
#else
#define OPENTHREAD_CONFIG_RADIO_LINK_IEEE_802_15_4_ENABLE 0
#endif
#if !CONFIG_OPENTHREAD_RADIO_NATIVE
/**
* @def OPENTHREAD_SPINEL_CONFIG_RCP_RESTORATION_MAX_COUNT

2
components/openthread/src/port/esp_openthread_radio.c
View File

@ -7,7 +7,7 @@
#include <stdatomic.h>
#include "esp_openthread_radio.h"
#include "error.h"
#include "openthread/error.h"
#include "esp_err.h"
#include "sdkconfig.h"
#include "esp_check.h"

1
components/openthread/src/port/esp_openthread_radio_spinel.cpp
View File

@ -6,7 +6,6 @@
#include "esp_openthread_radio.h"
#include "link_raw.h"
#include "sdkconfig.h"
#include "esp_check.h"
#include "esp_err.h"

374
components/openthread/src/port/esp_openthread_trel.c Normal file
View File

@ -0,0 +1,374 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "esp_err.h"
#include "esp_netif_types.h"
#include "lwip/ip6_addr.h"
#include "sdkconfig.h"
#include "common/code_utils.hpp"
#include "openthread/error.h"
#include "esp_check.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "mdns.h"
#include "esp_netif_ip_addr.h"
#include "esp_openthread.h"
#include "esp_openthread_common_macro.h"
#include "esp_openthread_lock.h"
#include "esp_openthread_radio.h"
#include "esp_openthread_task_queue.h"
#include "esp_openthread_trel.h"
#include "lwip/pbuf.h"
#include "lwip/tcpip.h"
#include "lwip/udp.h"
#include "openthread/trel.h"
#include "openthread/platform/diag.h"
#if CONFIG_OPENTHREAD_BORDER_ROUTER
#include "esp_openthread_border_router.h"
#endif
static esp_netif_t *s_trel_netif = NULL;
static otPlatTrelCounters s_trel_counters;
#define TREL_MDNS_TYPE "_trel"
#define TREL_MDNS_PROTO "_udp"
typedef struct {
uint16_t port;
struct udp_pcb *trel_pcb;
} ot_trel_t;
typedef struct {
struct pbuf *p;
} ot_trel_recv_task_t;
typedef struct {
struct udp_pcb *pcb;
const uint8_t *payload;
uint16_t length;
ip_addr_t peer_addr;
uint16_t peer_port;
} ot_trel_send_task_t;
static ot_trel_t s_ot_trel = {CONFIG_OPENTHREAD_TREL_PORT, NULL};
static bool s_is_service_registered = false;
static void trel_browse_notifier(mdns_result_t *result)
{
while (result) {
if (result->addr->addr.type == IPADDR_TYPE_V6) {
otPlatTrelPeerInfo info;
uint8_t trel_txt[1024] = {0};
uint16_t trel_txt_len = 0;
size_t index = 0;
while (index < result->txt_count) {
trel_txt[trel_txt_len++] = strlen(result->txt[index].key) + result->txt_value_len[index] + 1;
memcpy((trel_txt + trel_txt_len), (void *)result->txt[index].key, strlen(result->txt[index].key));
trel_txt_len += (strlen(result->txt[index].key));
trel_txt[trel_txt_len++] = '=';
memcpy((trel_txt + trel_txt_len), (void *)result->txt[index].value, result->txt_value_len[index]);
trel_txt_len += result->txt_value_len[index];
index++;
}
info.mTxtData = trel_txt;
info.mTxtLength = trel_txt_len;
info.mSockAddr.mPort = result->port;
memcpy(info.mSockAddr.mAddress.mFields.m32, result->addr->addr.u_addr.ip6.addr, OT_IP6_ADDRESS_SIZE);
info.mRemoved = (result->ttl == 0);
ESP_LOGI(OT_PLAT_LOG_TAG, "Found TREL peer: address: %s, port:%d", ip6addr_ntoa(((ip6_addr_t*)(&result->addr->addr.u_addr.ip6))), info.mSockAddr.mPort);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
otPlatTrelHandleDiscoveredPeerInfo(esp_openthread_get_instance(), &info);
esp_openthread_task_switching_lock_release();
}
result = result->next;
}
}
static void trel_recv_task(void *ctx)
{
struct pbuf *recv_buf = (struct pbuf *)ctx;
uint8_t *data_buf = (uint8_t *)recv_buf->payload;
uint8_t *data_buf_to_free = NULL;
uint16_t length = recv_buf->len;
if (recv_buf->next != NULL) {
data_buf = (uint8_t *)malloc(recv_buf->tot_len);
if (data_buf != NULL) {
length = recv_buf->tot_len;
data_buf_to_free = data_buf;
pbuf_copy_partial(recv_buf, data_buf, recv_buf->tot_len, 0);
} else {
ESP_LOGE(OT_PLAT_LOG_TAG, "Failed to allocate data buf when receiving Thread TREL message");
ExitNow();
}
}
otPlatTrelHandleReceived(esp_openthread_get_instance(), data_buf, length);
exit:
if (data_buf_to_free) {
free(data_buf_to_free);
}
pbuf_free(recv_buf);
}
static void handle_trel_udp_recv(void *ctx, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, uint16_t port)
{
ESP_LOGD(OT_PLAT_LOG_TAG, "Receive from %s:%d", ip6addr_ntoa(&(addr->u_addr.ip6)), port);
if (esp_openthread_task_queue_post(trel_recv_task, p) != ESP_OK) {
ESP_LOGE(OT_PLAT_LOG_TAG, "Failed to receive OpenThread TREL message");
}
}
static esp_err_t ot_new_trel(void *ctx)
{
ot_trel_t *task = (ot_trel_t *)ctx;
task->trel_pcb = udp_new();
ESP_RETURN_ON_FALSE(task->trel_pcb != NULL, ESP_ERR_NO_MEM, OT_PLAT_LOG_TAG, "Failed to create a new UDP pcb");
udp_bind(task->trel_pcb, IP6_ADDR_ANY, task->port);
udp_bind_netif(task->trel_pcb, netif_get_by_index(esp_netif_get_netif_impl_index(s_trel_netif)));
udp_recv(task->trel_pcb, handle_trel_udp_recv, NULL);
return ESP_OK;
}
void otPlatTrelEnable(otInstance *aInstance, uint16_t *aUdpPort)
{
*aUdpPort = s_ot_trel.port;
if (s_trel_netif == NULL) {
ESP_LOGE(OT_PLAT_LOG_TAG, "netif for trel is not set");
assert(false);
}
esp_openthread_task_switching_lock_release();
esp_err_t err = esp_netif_tcpip_exec(ot_new_trel, &s_ot_trel);
if (err != ESP_OK) {
ESP_LOGE(OT_PLAT_LOG_TAG, "Fail to create trel udp");
}
mdns_browse_new(TREL_MDNS_TYPE, TREL_MDNS_PROTO, trel_browse_notifier);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
}
static void trel_send_task(void *ctx)
{
err_t err = ERR_OK;
struct pbuf *send_buf = NULL;
ot_trel_send_task_t *task = (ot_trel_send_task_t *)ctx;
task->pcb = s_ot_trel.trel_pcb;
task->pcb->ttl = UDP_TTL;
task->pcb->netif_idx = esp_netif_get_netif_impl_index(s_trel_netif);
task->peer_addr.u_addr.ip6.zone = 0;
task->peer_addr.type = IPADDR_TYPE_V6;
task->pcb->flags = (task->pcb->flags & (~UDP_FLAGS_MULTICAST_LOOP));
task->pcb->local_port = s_ot_trel.port;
send_buf = pbuf_alloc(PBUF_TRANSPORT, task->length, PBUF_RAM);
if (send_buf == NULL) {
ESP_LOGE(OT_PLAT_LOG_TAG, "Failed to allocate data buf when sending Thread TREL message");
ExitNow();
}
memcpy(send_buf->payload, task->payload, task->length);
err = udp_sendto_if(task->pcb, send_buf, &task->peer_addr, task->peer_port, netif_get_by_index(task->pcb->netif_idx));
if(err != ERR_OK) {
ESP_LOGE(OT_PLAT_LOG_TAG, "Fail to send trel msg to %s:%d %d (%d)", ip6addr_ntoa(&(task->peer_addr.u_addr.ip6)), task->peer_port, task->pcb->netif_idx, err);
}
exit:
pbuf_free(send_buf);
free(task);
}
void otPlatTrelSend(otInstance *aInstance,
const uint8_t *aUdpPayload,
uint16_t aUdpPayloadLen,
const otSockAddr *aDestSockAddr)
{
ot_trel_send_task_t *task = (ot_trel_send_task_t *)malloc(sizeof(ot_trel_send_task_t));
if (task == NULL) {
ESP_LOGE(OT_PLAT_LOG_TAG, "Failed to allocate buf for Thread TREL");
return;
}
memcpy(task->peer_addr.u_addr.ip6.addr, aDestSockAddr->mAddress.mFields.m32, OT_IP6_ADDRESS_SIZE);
task->peer_port = aDestSockAddr->mPort;
ESP_LOGD(OT_PLAT_LOG_TAG, "send trel msg to %s:%d", ip6addr_ntoa(&(task->peer_addr.u_addr.ip6)), task->peer_port);
task->payload = aUdpPayload;
task->length = aUdpPayloadLen;
esp_openthread_task_switching_lock_release();
tcpip_callback(trel_send_task, task);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
}
void otPlatTrelRegisterService(otInstance *aInstance, uint16_t aPort, const uint8_t *aTxtData, uint8_t aTxtLength)
{
esp_err_t ret = ESP_OK;
esp_openthread_task_switching_lock_release();
if (s_is_service_registered) {
mdns_service_remove(TREL_MDNS_TYPE, TREL_MDNS_PROTO);
}
mdns_service_add(NULL, TREL_MDNS_TYPE, TREL_MDNS_PROTO, aPort, NULL, 0);
s_is_service_registered = true;
uint16_t index = 0;
while (index < aTxtLength) {
const uint8_t *item_header = aTxtData + index + 1;
uint8_t item_len = aTxtData[index];
char key[UINT8_MAX + 1];
for (uint16_t i = 0; i < item_len; i++) {
if (item_header[i] == '=') {
ESP_GOTO_ON_FALSE(i != 0, ESP_FAIL, exit, OT_PLAT_LOG_TAG, "Wrong format of _trel._udp txt key");
key[i] = '\0';
uint16_t value_len = item_len - i - 1;
ESP_GOTO_ON_FALSE(value_len != 0, ESP_FAIL, exit, OT_PLAT_LOG_TAG, "Wrong format of _trel._udp txt value");
mdns_service_txt_item_set_with_explicit_value_len(TREL_MDNS_TYPE, TREL_MDNS_PROTO, key, (const char *)item_header + i + 1, value_len);
break;
}
key[i] = item_header[i];
}
index += item_len + 1;
}
exit:
if (ret != ESP_OK) {
ESP_LOGE(OT_PLAT_LOG_TAG, "Registered TREL service with some errors");
}
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
}
void otPlatTrelResetCounters(otInstance *aInstance)
{
memset(&s_trel_counters, 0, sizeof(otPlatTrelCounters));
}
static void trel_disable_task(void *ctx)
{
struct udp_pcb *pcb = (struct udp_pcb *)ctx;
udp_remove(pcb);
}
void otPlatTrelDisable(otInstance *aInstance)
{
esp_openthread_task_switching_lock_release();
if (s_ot_trel.trel_pcb) {
tcpip_callback(trel_disable_task, s_ot_trel.trel_pcb);
}
mdns_service_remove(TREL_MDNS_TYPE, TREL_MDNS_PROTO);
s_is_service_registered = false;
mdns_browse_delete(TREL_MDNS_TYPE, TREL_MDNS_PROTO);
esp_openthread_task_switching_lock_acquire(portMAX_DELAY);
s_ot_trel.trel_pcb = NULL;
}
const otPlatTrelCounters *otPlatTrelGetCounters(otInstance *aInstance)
{
return &s_trel_counters;
}
void esp_openthread_set_trel_netif(esp_netif_t *trel_netif)
{
s_trel_netif = trel_netif;
}
esp_netif_t *esp_openthread_get_trel_netif(void)
{
return s_trel_netif;
}
OT_TOOL_WEAK otError otPlatRadioSetTransmitPower(otInstance *aInstance, int8_t aPower)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatRadioSetTransmitPower`");
return OT_ERROR_NONE;
}
OT_TOOL_WEAK otError otPlatRadioGetTransmitPower(otInstance *aInstance, int8_t *aPower)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatRadioGetTransmitPower`");
return OT_ERROR_NONE;
}
OT_TOOL_WEAK bool otPlatRadioGetPromiscuous(otInstance *aInstance)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatRadioGetPromiscuous`");
return false;
}
OT_TOOL_WEAK otError otPlatRadioSetCcaEnergyDetectThreshold(otInstance *aInstance, int8_t aThreshold)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatRadioSetCcaEnergyDetectThreshold`");
return OT_ERROR_NONE;
}
OT_TOOL_WEAK otError otPlatRadioGetCcaEnergyDetectThreshold(otInstance *aInstance, int8_t *aThreshold)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatRadioGetCcaEnergyDetectThreshold`");
return OT_ERROR_NONE;
}
OT_TOOL_WEAK void otPlatRadioGetIeeeEui64(otInstance *aInstance, uint8_t *aIeeeEui64)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatRadioGetIeeeEui64`");
}
OT_TOOL_WEAK otRadioFrame *otPlatRadioGetTransmitBuffer(otInstance *aInstance)
{
return NULL;
}
#if CONFIG_OPENTHREAD_DIAG
OT_TOOL_WEAK void otPlatDiagSetOutputCallback(otInstance *aInstance, otPlatDiagOutputCallback aCallback, void *aContext)
{
OT_UNUSED_VARIABLE(aInstance);
OT_UNUSED_VARIABLE(aCallback);
OT_UNUSED_VARIABLE(aContext);
}
OT_TOOL_WEAK void otPlatDiagModeSet(bool mode)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatDiagModeSet`");
}
OT_TOOL_WEAK bool otPlatDiagModeGet(void)
{
return false;
}
OT_TOOL_WEAK void otPlatDiagTxPowerSet(int8_t tx_power)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatDiagTxPowerSet`");
}
OT_TOOL_WEAK void otPlatDiagChannelSet(uint8_t channel)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatDiagChannelSet`");
}
OT_TOOL_WEAK void otPlatDiagAlarmCallback(otInstance *aInstance)
{
ESP_LOGW(OT_PLAT_LOG_TAG, "Running in TREL mode and not support `otPlatDiagAlarmCallback`");
}
#endif // CONFIG_OPENTHREAD_DIAG
OT_TOOL_WEAK esp_err_t esp_openthread_radio_init(const esp_openthread_platform_config_t *config)
{
ESP_LOGI(OT_PLAT_LOG_TAG, "Running in TREL mode");
return ESP_OK;
}
OT_TOOL_WEAK void esp_openthread_radio_deinit(void)
{
ESP_LOGI(OT_PLAT_LOG_TAG, "Running in TREL mode");
}

2
components/openthread/src/port/esp_spi_spinel_interface.cpp
View File

@ -6,7 +6,7 @@
#include "esp_spi_spinel_interface.hpp"
#include "error.h"
#include "openthread/error.h"
#include "esp_check.h"
#include "esp_openthread_common_macro.h"
#include "esp_rom_sys.h"

4
examples/openthread/.build-test-rules.yml
View File

@ -33,3 +33,7 @@ examples/openthread/ot_sleepy_device/deep_sleep:
examples/openthread/ot_sleepy_device/light_sleep:
enable:
- if: SOC_IEEE802154_SUPPORTED == 1
examples/openthread/ot_trel:
enable:
- if: SOC_WIFI_SUPPORTED == 1

6
examples/openthread/ot_trel/CMakeLists.txt Normal file
View File

@ -0,0 +1,6 @@
# 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(esp_ot_cli)

132
examples/openthread/ot_trel/README.md Normal file
View File

@ -0,0 +1,132 @@
| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C6 | ESP32-S2 | ESP32-S3 |
| ----------------- | ----- | -------- | -------- | -------- | -------- | -------- |
# Thread Radio Encapsulation Link Example
This example demonstrates a Thread Radio Encapsulation Link (TREL) Example.
## How to use example
### Hardware Required
To run this example, a board with Wi-Fi module (for example ESP32-S3) is required.
### Configure the project
```
idf.py menuconfig
```
The Wi-Fi ssid and password should be set through the menuconfig:
```
Component config → → Example Connection Configuration → → WiFi SSID
Component config → → Example Connection Configuration → → WiFi Password
```
The example can run with the default configuration. OpenThread Command Line is enabled with UART as the default interface. Additionally, USB JTAG is also supported and can be activated through the menuconfig:
```
Component config → ESP System Settings → Channel for console output → USB Serial/JTAG Controller
```
### Build, Flash, and Run
Build the project and flash it to the board, then run monitor tool to view serial output:
```
idf.py -p PORT build flash monitor
```
Now you'll get an OpenThread command line shell.
### Example Output
The `help` command will print all of the supported commands.
```bash
> help
I(7058) OPENTHREAD:[INFO]-CLI-----: execute command: help
bbr
bufferinfo
ccathreshold
channel
child
childip
childmax
childsupervision
childtimeout
coap
contextreusedelay
counters
dataset
delaytimermin
diag
discover
dns
domainname
eidcache
eui64
extaddr
extpanid
factoryreset
...
```
## Set Up Network
To run this example, at least two ESP32-S3 boards flashed with this ot_trel example are required. And they must connect to the same wifi AP.
On the first device, run the following commands:
```bash
> factoryreset
... # the device will reboot
> dataset init new
Done
> dataset commit active
Done
> ifconfig up
Done
> thread start
Done
# After some seconds
> state
leader
Done
```
Now the first device has formed a Thread network as a leader. Get some information which will be used in next steps:
```bash
> ipaddr
fdde:ad00:beef:0:0:ff:fe00:fc00
fdde:ad00:beef:0:0:ff:fe00:8000
fdde:ad00:beef:0:a7c6:6311:9c8c:271b
fe80:0:0:0:5c27:a723:7115:c8f8
# Get the Active Dataset
> dataset active -x
0e080000000000010000000300001835060004001fffe00208fe7bb701f5f1125d0708fd75cbde7c6647bd0510b3914792d44f45b6c7d76eb9306eec94030f4f70656e5468726561642d35383332010258320410e35c581af5029b054fc904a24c2b27700c0402a0fff8
```
On the second device, set the active dataset from leader, and start Thread interface:
```bash
> factoryreset
... # the device will reboot
> dataset set active 0e080000000000010000000300001835060004001fffe00208fe7bb701f5f1125d0708fd75cbde7c6647bd0510b3914792d44f45b6c7d76eb9306eec94030f4f70656e5468726561642d35383332010258320410e35c581af5029b054fc904a24c2b27700c0402a0fff8
> ifconfig up
Done
> thread start
Done
# After some seconds
> state
router # child is also a valid state
Done
```
The second device has joined the Thread network as a router (or a child).
## Extension commands
You can refer to the [extension command](https://github.com/espressif/esp-thread-br/blob/main/components/esp_ot_cli_extension/README.md) about the extension commands.

2
examples/openthread/ot_trel/main/CMakeLists.txt Normal file
View File

@ -0,0 +1,2 @@
idf_component_register(SRCS "esp_ot_trel.c"
INCLUDE_DIRS ".")

9
examples/openthread/ot_trel/main/Kconfig.projbuild Normal file
View File

@ -0,0 +1,9 @@
menu "OpenThread CLI Example"
config OPENTHREAD_AUTO_START
bool 'Enable the automatic start mode.'
default False
help
If enabled, the Openthread Device will create or connect to thread network with pre-configured
network parameters automatically. Otherwise, user need to configure Thread via CLI command manually.
endmenu

58
examples/openthread/ot_trel/main/esp_ot_config.h Normal file
View File

@ -0,0 +1,58 @@
/*
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: CC0-1.0
*
* OpenThread Command Line 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.
*/
#pragma once
#include "sdkconfig.h"
#include "esp_openthread_types.h"
#define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG() \
{ \
.radio_mode = RADIO_MODE_TREL, \
}
#if CONFIG_OPENTHREAD_CONSOLE_TYPE_UART
#define ESP_OPENTHREAD_DEFAULT_HOST_CONFIG() \
{ \
.host_connection_mode = HOST_CONNECTION_MODE_CLI_UART, \
.host_uart_config = { \
.port = 0, \
.uart_config = \
{ \
.baud_rate = 115200, \
.data_bits = UART_DATA_8_BITS, \
.parity = UART_PARITY_DISABLE, \
.stop_bits = UART_STOP_BITS_1, \
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE, \
.rx_flow_ctrl_thresh = 0, \
.source_clk = UART_SCLK_DEFAULT, \
}, \
.rx_pin = UART_PIN_NO_CHANGE, \
.tx_pin = UART_PIN_NO_CHANGE, \
}, \
}
#elif CONFIG_OPENTHREAD_CONSOLE_TYPE_USB_SERIAL_JTAG
#define ESP_OPENTHREAD_DEFAULT_HOST_CONFIG() \
{ \
.host_connection_mode = HOST_CONNECTION_MODE_CLI_USB, \
.host_usb_config = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT(), \
}
#endif
#define ESP_OPENTHREAD_DEFAULT_PORT_CONFIG() \
{ \
.storage_partition_name = "nvs", \
.netif_queue_size = 10, \
.task_queue_size = 10, \
}

141
examples/openthread/ot_trel/main/esp_ot_trel.c Normal file
View File

@ -0,0 +1,141 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: CC0-1.0
*
* OpenThread Command Line 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 <stdio.h>
#include <unistd.h>
#include <string.h>
#include "sdkconfig.h"
#include "esp_err.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_netif_types.h"
#include "esp_openthread.h"
#include "esp_openthread_cli.h"
#include "esp_openthread_lock.h"
#include "esp_openthread_netif_glue.h"
#include "esp_openthread_types.h"
#include "esp_ot_config.h"
#include "esp_vfs_eventfd.h"
#include "driver/uart.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "hal/uart_types.h"
#include "nvs_flash.h"
#include "openthread/cli.h"
#include "openthread/instance.h"
#include "openthread/logging.h"
#include "openthread/tasklet.h"
#include "esp_openthread_trel.h"
#include "protocol_examples_common.h"
#include "mdns.h"
#if CONFIG_OPENTHREAD_STATE_INDICATOR_ENABLE
#include "ot_led_strip.h"
#endif
#if CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
#include "esp_ot_cli_extension.h"
#endif // CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
#define TAG "ot_esp_trel"
static esp_netif_t *init_openthread_netif(const esp_openthread_platform_config_t *config)
{
esp_netif_config_t cfg = ESP_NETIF_DEFAULT_OPENTHREAD();
esp_netif_t *netif = esp_netif_new(&cfg);
assert(netif != NULL);
ESP_ERROR_CHECK(esp_netif_attach(netif, esp_openthread_netif_glue_init(config)));
return netif;
}
static void ot_task_worker(void *aContext)
{
esp_openthread_platform_config_t config = {
.radio_config = ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG(),
.host_config = ESP_OPENTHREAD_DEFAULT_HOST_CONFIG(),
.port_config = ESP_OPENTHREAD_DEFAULT_PORT_CONFIG(),
};
#if !CONFIG_EXAMPLE_CONNECT_WIFI && !CONFIG_EXAMPLE_CONNECT_ETHERNET
#error No netif for TREL!
#endif
ESP_ERROR_CHECK(example_connect());
assert(esp_openthread_get_trel_netif() == NULL);
esp_openthread_set_trel_netif(get_example_netif());
// Initialize the OpenThread stack
ESP_ERROR_CHECK(esp_openthread_init(&config));
#if CONFIG_OPENTHREAD_STATE_INDICATOR_ENABLE
ESP_ERROR_CHECK(esp_openthread_state_indicator_init(esp_openthread_get_instance()));
#endif
#if CONFIG_OPENTHREAD_LOG_LEVEL_DYNAMIC
// The OpenThread log level directly matches ESP log level
(void)otLoggingSetLevel(CONFIG_LOG_DEFAULT_LEVEL);
#endif
// Initialize the OpenThread cli
#if CONFIG_OPENTHREAD_CLI
esp_openthread_cli_init();
#endif
esp_netif_t *openthread_netif;
// Initialize the esp_netif bindings
openthread_netif = init_openthread_netif(&config);
esp_netif_set_default_netif(openthread_netif);
#if CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
esp_cli_custom_command_init();
#endif // CONFIG_OPENTHREAD_CLI_ESP_EXTENSION
// Run the main loop
#if CONFIG_OPENTHREAD_CLI
esp_openthread_cli_create_task();
#endif
#if CONFIG_OPENTHREAD_AUTO_START
otOperationalDatasetTlvs dataset;
otError error = otDatasetGetActiveTlvs(esp_openthread_get_instance(), &dataset);
ESP_ERROR_CHECK(esp_openthread_auto_start((error == OT_ERROR_NONE) ? &dataset : NULL));
#endif
esp_openthread_launch_mainloop();
// Clean up
esp_openthread_netif_glue_deinit();
esp_netif_destroy(openthread_netif);
esp_vfs_eventfd_unregister();
vTaskDelete(NULL);
}
void app_main(void)
{
// Used eventfds:
// * netif
// * ot task queue
esp_vfs_eventfd_config_t eventfd_config = {
.max_fds = 2,
};
ESP_ERROR_CHECK(nvs_flash_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_vfs_eventfd_register(&eventfd_config));
ESP_ERROR_CHECK(mdns_init());
ESP_ERROR_CHECK(mdns_hostname_set("esp-ot-trel"));
xTaskCreate(ot_task_worker, "ot_trel_main", 8192, xTaskGetCurrentTaskHandle(), 5, NULL);
}

11
examples/openthread/ot_trel/main/idf_component.yml Normal file
View File

@ -0,0 +1,11 @@
## IDF Component Manager Manifest File
dependencies:
espressif/esp_ot_cli_extension:
version: "~1.1.0"
espressif/mdns: "^1.0.3"
idf:
version: ">=4.1.0"
protocol_examples_common:
path: ${IDF_PATH}/examples/common_components/protocol_examples_common
ot_led:
path: ${IDF_PATH}/examples/openthread/ot_common_components/ot_led

5
examples/openthread/ot_trel/partitions.csv Normal file
View File

@ -0,0 +1,5 @@
# Name, Type, SubType, Offset, Size, Flags
# Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
nvs, data, nvs, 0x9000, 0x6000,
phy_init, data, phy, 0xf000, 0x1000,
factory, app, factory, 0x10000, 0x170000,
1 # Name, Type, SubType, Offset, Size, Flags
2 # Note: if you have increased the bootloader size, make sure to update the offsets to avoid overlap
3 nvs, data, nvs, 0x9000, 0x6000,
4 phy_init, data, phy, 0xf000, 0x1000,
5 factory, app, factory, 0x10000, 0x170000,

42
examples/openthread/ot_trel/sdkconfig.defaults Normal file
View File

@ -0,0 +1,42 @@
#
# Partition Table
#
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
CONFIG_PARTITION_TABLE_FILENAME="partitions.csv"
CONFIG_PARTITION_TABLE_OFFSET=0x8000
CONFIG_PARTITION_TABLE_MD5=y
# end of Partition Table
#
# mbedTLS
#
CONFIG_MBEDTLS_CMAC_C=y
CONFIG_MBEDTLS_SSL_PROTO_DTLS=y
CONFIG_MBEDTLS_KEY_EXCHANGE_ECJPAKE=y
CONFIG_MBEDTLS_ECJPAKE_C=y
# end of mbedTLS
#
# OpenThread
#
CONFIG_OPENTHREAD_ENABLED=y
CONFIG_OPENTHREAD_BORDER_ROUTER=n
CONFIG_OPENTHREAD_DNS64_CLIENT=y
CONFIG_OPENTHREAD_RADIO_154_NONE=y
CONFIG_OPENTHREAD_RADIO_TREL=y
# end of OpenThread
#
# lwIP
#
CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=4096
CONFIG_LWIP_IPV6_NUM_ADDRESSES=8
CONFIG_LWIP_MULTICAST_PING=y
CONFIG_LWIP_HOOK_IP6_SELECT_SRC_ADDR_CUSTOM=y
# end of lwIP
#
# Configurations for optimizing the size of firmware
#
CONFIG_COMPILER_OPTIMIZATION_SIZE=y