Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-10-02 03:00:34 +03:00
Code Issues Packages Projects Releases Wiki Activity

feat(openthread): support trel feature

Browse Source
This commit is contained in:
Xu Si Yu
2024-10-12 17:52:41 +08:00
parent 8711b55bec
commit a0ae573357
19 changed files with 884 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/openthread/CMakeLists.txt
+17 -1
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)
@@ -259,6 +271,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")
components/openthread/Kconfig
+19 -1
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
components/openthread/include/esp_openthread_trel.h
+38
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
components/openthread/include/esp_openthread_types.h
+1
View File
@@ -117,6 +117,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;
components/openthread/private_include/openthread-core-esp32x-ftd-config.h
+22 -10
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
components/openthread/src/port/esp_openthread_radio.c
+1 -1
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"
components/openthread/src/port/esp_openthread_radio_spinel.cpp
-1
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"
components/openthread/src/port/esp_openthread_trel.c
+374
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");
}
components/openthread/src/port/esp_spi_spinel_interface.cpp
+1 -1
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"