diff --git a/components/esp_hw_support/include/esp_private/esp_regdma.h b/components/esp_hw_support/include/esp_private/esp_regdma.h index 846665c5b4..24d4bd24f6 100644 --- a/components/esp_hw_support/include/esp_private/esp_regdma.h +++ b/components/esp_hw_support/include/esp_private/esp_regdma.h @@ -40,8 +40,8 @@ extern "C" { #define REGDMA_IOMUX_LINK(_pri) ((0x12 << 8) | _pri) #define REGDMA_SPIMEM_LINK(_pri) ((0x13 << 8) | _pri) #define REGDMA_SYSTIMER_LINK(_pri) ((0x14 << 8) | _pri) -#define REGDMA_BLE_MAC_LINK(_pri) ((0x15 << 8) | _pri) -#define REGDMA_MODEM_BT_BB_LINK(_pri) ((0x16 << 8) | _pri) +#define REGDMA_MODEM_BTBB_LINK(_pri) ((0x15 << 8) | _pri) +#define REGDMA_MODEM_IEEE802154_LINK(_pri) ((0x16 << 8) | _pri) #define REGDMA_MODEM_FE_LINK(_pri) ((0xFF << 8) | _pri) typedef enum { diff --git a/components/esp_hw_support/include/esp_private/sleep_retention.h b/components/esp_hw_support/include/esp_private/sleep_retention.h index 2c1bb7fecf..007f973f42 100644 --- a/components/esp_hw_support/include/esp_private/sleep_retention.h +++ b/components/esp_hw_support/include/esp_private/sleep_retention.h @@ -32,9 +32,8 @@ typedef enum sleep_retention_module_bitmap { SLEEP_RETENTION_MODULE_WIFI_MAC = BIT(10), SLEEP_RETENTION_MODULE_WIFI_BB = BIT(11), SLEEP_RETENTION_MODULE_BLE_MAC = BIT(12), - SLEEP_RETENTION_MODULE_BLE_BB = BIT(13), + SLEEP_RETENTION_MODULE_BT_BB = BIT(13), SLEEP_RETENTION_MODULE_802154_MAC = BIT(14), - SLEEP_RETENTION_MODULE_802154_BB = BIT(15), /* digital peripheral module, which includes Interrupt Matrix, HP_SYSTEM, * TEE, APM, UART, Timer Group, IOMUX, SPIMEM, SysTimer, etc.. */ diff --git a/components/esp_hw_support/sleep_clock.c b/components/esp_hw_support/sleep_clock.c index 3617868d0e..86e2b15ff4 100644 --- a/components/esp_hw_support/sleep_clock.c +++ b/components/esp_hw_support/sleep_clock.c @@ -81,21 +81,21 @@ bool IRAM_ATTR clock_domain_pd_allowed(void) const uint32_t modules = sleep_retention_get_modules(); const uint32_t mask = (const uint32_t) ( SLEEP_RETENTION_MODULE_CLOCK_SYSTEM -#if CONFIG_MAC_BB_PD || CONFIG_BT_LE_SLEEP_ENABLE +#if CONFIG_MAC_BB_PD || CONFIG_BT_LE_SLEEP_ENABLE || CONFIG_IEEE802154_SLEEP_ENABLE | SLEEP_RETENTION_MODULE_CLOCK_MODEM #endif ); return ((modules & mask) == mask); } -#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP || CONFIG_MAC_BB_PD || CONFIG_BT_LE_SLEEP_ENABLE +#if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP || CONFIG_MAC_BB_PD || CONFIG_BT_LE_SLEEP_ENABLE || CONFIG_IEEE802154_SLEEP_ENABLE ESP_SYSTEM_INIT_FN(sleep_clock_startup_init, BIT(0), 106) { #if CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP sleep_clock_system_retention_init(); #endif -#if CONFIG_MAC_BB_PD || CONFIG_BT_LE_SLEEP_ENABLE +#if CONFIG_MAC_BB_PD || CONFIG_BT_LE_SLEEP_ENABLE || CONFIG_IEEE802154_SLEEP_ENABLE sleep_clock_modem_retention_init(); #endif return ESP_OK; diff --git a/components/esp_hw_support/sleep_retention.c b/components/esp_hw_support/sleep_retention.c index af357efb3b..562fd3158a 100644 --- a/components/esp_hw_support/sleep_retention.c +++ b/components/esp_hw_support/sleep_retention.c @@ -21,7 +21,6 @@ #include "sdkconfig.h" #include "esp_pmu.h" - static __attribute__((unused)) const char *TAG = "sleep"; /** diff --git a/components/ieee802154/Kconfig b/components/ieee802154/Kconfig index 4ca8ab64c2..6b01de4e72 100644 --- a/components/ieee802154/Kconfig +++ b/components/ieee802154/Kconfig @@ -74,4 +74,12 @@ menu "IEEE 802.15.4" Enabling this option increases throughput by ~5% at the expense of ~2.1k IRAM code size increase. + + config IEEE802154_SLEEP_ENABLE + bool "Enable IEEE802154 light sleep" + depends on PM_ENABLE && PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP + default n + help + Enabling this option allows the IEEE802.15.4 module to be powered down during automatic light sleep, + which reduces current consumption. endmenu # IEEE 802.15.4 diff --git a/components/ieee802154/driver/esp_ieee802154_dev.c b/components/ieee802154/driver/esp_ieee802154_dev.c index 1552856101..243228829d 100644 --- a/components/ieee802154/driver/esp_ieee802154_dev.c +++ b/components/ieee802154/driver/esp_ieee802154_dev.c @@ -24,6 +24,13 @@ #include "esp_ieee802154_timer.h" #include "hal/ieee802154_ll.h" #include "esp_attr.h" +#include "esp_phy_init.h" + +#if CONFIG_IEEE802154_SLEEP_ENABLE +#include "esp_pm.h" +#include "esp_private/esp_clk.h" +#include "esp_private/sleep_retention.h" +#endif #define CCA_DETECTION_TIME 8 @@ -38,6 +45,8 @@ static uint8_t s_enh_ack_frame[128]; static uint8_t s_recent_rx_frame_info_index; static portMUX_TYPE s_ieee802154_spinlock = portMUX_INITIALIZER_UNLOCKED; +static esp_err_t ieee802154_sleep_init(void); + static IRAM_ATTR void event_end_process(void) { ieee802154_etm_channel_clear(IEEE802154_ETM_CHANNEL0); @@ -193,7 +202,7 @@ IEEE802154_STATIC bool stop_current_operation(void) break; case IEEE802154_STATE_IDLE: - // do nothing + ieee802154_ll_set_cmd(IEEE802154_CMD_STOP); break; case IEEE802154_STATE_RX: @@ -580,10 +589,12 @@ IEEE802154_STATIC IRAM_ATTR void ieee802154_exit_critical(void) void ieee802154_enable(void) { modem_clock_module_enable(ieee802154_periph.module); + s_ieee802154_state = IEEE802154_STATE_IDLE; } void ieee802154_disable(void) { + modem_clock_module_disable(ieee802154_periph.module); s_ieee802154_state = IEEE802154_STATE_DISABLE; } @@ -616,12 +627,13 @@ esp_err_t ieee802154_mac_init(void) #endif memset(s_rx_frame, 0, sizeof(s_rx_frame)); - s_ieee802154_state = IEEE802154_STATE_IDLE; // TODO: Add flags for IEEE802154 ISR allocating. TZ-102 ret = esp_intr_alloc(ieee802154_periph.irq_id, 0, ieee802154_isr, NULL, NULL); ESP_RETURN_ON_FALSE(ret == ESP_OK, ESP_FAIL, IEEE802154_TAG, "IEEE802154 MAC init failed"); + ret = ieee802154_sleep_init(); + return ret; } @@ -743,6 +755,44 @@ esp_err_t ieee802154_receive_at(uint32_t time) return ESP_OK; } +static esp_err_t ieee802154_sleep_init(void) +{ + esp_err_t err = ESP_OK; +#if CONFIG_IEEE802154_SLEEP_ENABLE + #define N_REGS_IEEE802154() (((IEEE802154_MAC_DATE_REG - IEEE802154_REG_BASE) / 4) + 1) + const static sleep_retention_entries_config_t ieee802154_mac_regs_retention[] = { + [0] = { .config = REGDMA_LINK_CONTINUOUS_INIT(REGDMA_MODEM_IEEE802154_LINK(0x00), IEEE802154_REG_BASE, IEEE802154_REG_BASE, N_REGS_IEEE802154(), 0, 0), .owner = ENTRY(3) }, + }; + + err = sleep_retention_entries_create(ieee802154_mac_regs_retention, ARRAY_SIZE(ieee802154_mac_regs_retention), REGDMA_LINK_PRI_7, SLEEP_RETENTION_MODULE_802154_MAC); + ESP_RETURN_ON_ERROR(err, IEEE802154_TAG, "failed to allocate memory for ieee802154 mac retention"); + ESP_LOGI(IEEE802154_TAG, "ieee802154 mac sleep retention initialization"); +#endif + return err; +} + +IRAM_ATTR void ieee802154_sleep_cb(void) +{ +#if CONFIG_IEEE802154_SLEEP_ENABLE + esp_phy_disable(); +#if SOC_PM_RETENTION_HAS_CLOCK_BUG + sleep_retention_do_extra_retention(true);// backup +#endif + ieee802154_disable(); // IEEE802154 CLOCK Disable +#endif // CONFIG_IEEE802154_SLEEP_ENABLE +} + +IRAM_ATTR void ieee802154_wakeup_cb(void) +{ +#if CONFIG_IEEE802154_SLEEP_ENABLE + ieee802154_enable(); // IEEE802154 CLOCK Enable +#if SOC_PM_RETENTION_HAS_CLOCK_BUG + sleep_retention_do_extra_retention(false);// restore +#endif + esp_phy_enable(); +#endif //CONFIG_IEEE802154_SLEEP_ENABLE +} + esp_err_t ieee802154_sleep(void) { ieee802154_enter_critical(); diff --git a/components/ieee802154/esp_ieee802154.c b/components/ieee802154/esp_ieee802154.c index cadbabaacf..42c0d2065c 100644 --- a/components/ieee802154/esp_ieee802154.c +++ b/components/ieee802154/esp_ieee802154.c @@ -331,6 +331,16 @@ uint8_t esp_ieee802154_get_recent_lqi(void) return ieee802154_get_recent_lqi(); } +void esp_ieee802154_sleep_cb(void) +{ + ieee802154_sleep_cb(); +} + +void esp_ieee802154_wakeup_cb(void) +{ + ieee802154_wakeup_cb(); +} + __attribute__((weak)) void esp_ieee802154_receive_done(uint8_t *data, esp_ieee802154_frame_info_t *frame_info) { diff --git a/components/ieee802154/include/esp_ieee802154.h b/components/ieee802154/include/esp_ieee802154.h index 96de1a0775..63ac0b5178 100644 --- a/components/ieee802154/include/esp_ieee802154.h +++ b/components/ieee802154/include/esp_ieee802154.h @@ -111,6 +111,17 @@ esp_ieee802154_state_t esp_ieee802154_get_state(void); */ esp_err_t esp_ieee802154_sleep(void); +/** + * @brief The IEEE 802.15.4 sleep callback. + */ + +void esp_ieee802154_sleep_cb(void); + +/** + * @brief The IEEE 802.15.4 wakeup callback. + */ +void esp_ieee802154_wakeup_cb(void); + /** * @brief Set the IEEE 802.15.4 Radio to receive state. * diff --git a/components/ieee802154/private_include/esp_ieee802154_dev.h b/components/ieee802154/private_include/esp_ieee802154_dev.h index b22443cad9..ef13f45445 100644 --- a/components/ieee802154/private_include/esp_ieee802154_dev.h +++ b/components/ieee802154/private_include/esp_ieee802154_dev.h @@ -177,6 +177,18 @@ uint8_t ieee802154_get_recent_lqi(void); */ ieee802154_state_t ieee802154_get_state(void); +/** + * @brief The callback of IEEE 802.15.4 sleep. + * + */ +void ieee802154_sleep_cb(void); + +/** + * @brief The callback of IEEE 802.15.4 wakeup. + * + */ +void ieee802154_wakeup_cb(void); + /** The following three functions are only used for internal test. **/ /** * @brief The clear channel assessment done. diff --git a/components/openthread/port/esp_openthread.cpp b/components/openthread/port/esp_openthread.cpp new file mode 100644 index 0000000000..8b1cc2ae2b --- /dev/null +++ b/components/openthread/port/esp_openthread.cpp @@ -0,0 +1,107 @@ +/* + * SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "esp_openthread.h" +#include "esp_check.h" +#include "esp_openthread_border_router.h" +#include "esp_openthread_common_macro.h" +#include "esp_openthread_dns64.h" +#include "esp_openthread_lock.h" +#include "esp_openthread_platform.h" +#include "esp_openthread_task_queue.h" +#include "esp_openthread_types.h" +#include "freertos/FreeRTOS.h" +#include "lwip/dns.h" +#include "openthread/instance.h" +#include "openthread/netdata.h" +#include "openthread/tasklet.h" +#include "esp_openthread_sleep.h" + +esp_err_t esp_openthread_init(const esp_openthread_platform_config_t *config) +{ +#if CONFIG_IEEE802154_SLEEP_ENABLE + ESP_RETURN_ON_ERROR(esp_openthread_sleep_init(), OT_PLAT_LOG_TAG, + "Failed to initialize OpenThread esp pm_lock"); +#endif + ESP_RETURN_ON_ERROR(esp_openthread_platform_init(config), OT_PLAT_LOG_TAG, + "Failed to initialize OpenThread platform driver"); + esp_openthread_lock_acquire(portMAX_DELAY); + ESP_RETURN_ON_FALSE(otInstanceInitSingle() != NULL, ESP_FAIL, OT_PLAT_LOG_TAG, + "Failed to initialize OpenThread instance"); +#if CONFIG_OPENTHREAD_DNS64_CLIENT + ESP_RETURN_ON_ERROR(esp_openthread_dns64_client_init(), OT_PLAT_LOG_TAG, + "Failed to initialize OpenThread dns64 client"); +#endif + esp_openthread_lock_release(); + + return ESP_OK; +} + +esp_err_t esp_openthread_launch_mainloop(void) +{ + esp_openthread_mainloop_context_t mainloop; + otInstance *instance = esp_openthread_get_instance(); + esp_err_t error = ESP_OK; + + while (true) { + FD_ZERO(&mainloop.read_fds); + FD_ZERO(&mainloop.write_fds); + FD_ZERO(&mainloop.error_fds); + + mainloop.max_fd = -1; + mainloop.timeout.tv_sec = 10; + mainloop.timeout.tv_usec = 0; + + esp_openthread_lock_acquire(portMAX_DELAY); + esp_openthread_platform_update(&mainloop); + if (otTaskletsArePending(instance)) { + mainloop.timeout.tv_sec = 0; + mainloop.timeout.tv_usec = 0; + } +#if CONFIG_IEEE802154_SLEEP_ENABLE + esp_openthread_sleep_process(); +#endif + esp_openthread_lock_release(); + + if (select(mainloop.max_fd + 1, &mainloop.read_fds, &mainloop.write_fds, &mainloop.error_fds, + &mainloop.timeout) >= 0) { + esp_openthread_lock_acquire(portMAX_DELAY); +#if CONFIG_IEEE802154_SLEEP_ENABLE + esp_openthread_wakeup_process(); +#endif + error = esp_openthread_platform_process(instance, &mainloop); + while (otTaskletsArePending(instance)) { + otTaskletsProcess(instance); + } + esp_openthread_lock_release(); + if (error != ESP_OK) { + ESP_LOGE(OT_PLAT_LOG_TAG, "esp_openthread_platform_process failed"); + break; + } + } else { + error = ESP_FAIL; + ESP_LOGE(OT_PLAT_LOG_TAG, "OpenThread system polling failed"); + break; + } + } + return error; +} + +esp_err_t esp_openthread_deinit(void) +{ + otInstanceFinalize(esp_openthread_get_instance()); + return esp_openthread_platform_deinit(); +} + +static void stub_task(void *context) +{ + // this is a empty function used for ot-task signal pending +} + +void otTaskletsSignalPending(otInstance *aInstance) +{ + esp_openthread_task_queue_post(stub_task, NULL); +} diff --git a/components/openthread/port/esp_openthread_sleep.c b/components/openthread/port/esp_openthread_sleep.c new file mode 100644 index 0000000000..f8794e13c0 --- /dev/null +++ b/components/openthread/port/esp_openthread_sleep.c @@ -0,0 +1,68 @@ +/* + * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#include "esp_log.h" +#include "esp_check.h" +#include "openthread/instance.h" +#include "openthread/thread.h" +#include "esp_openthread.h" +#include "esp_ieee802154.h" + +#if CONFIG_IEEE802154_SLEEP_ENABLE +#include "esp_pm.h" +static esp_pm_lock_handle_t s_pm_lock = NULL; +static const char* TAG = "esp openthread sleep"; +static bool s_ot_sleep = false; + +esp_err_t esp_openthread_sleep_init(void) +{ + esp_err_t err = ESP_OK; + + err = esp_pm_lock_create(ESP_PM_CPU_FREQ_MAX, 0, "ieee802154", &s_pm_lock); + if (err != ESP_OK) { + goto error; + } + esp_pm_lock_acquire(s_pm_lock); + + ESP_LOGI(TAG, "Enable ieee802154 light sleep, the wake up source is ESP timer"); + + return err; + +error: + /*lock should release first and then delete*/ + if (s_pm_lock != NULL) { + esp_pm_lock_release(s_pm_lock); + esp_pm_lock_delete(s_pm_lock); + s_pm_lock = NULL; + } + return err; +} + +void esp_openthread_sleep_process(void) +{ + otInstance *instance = esp_openthread_get_instance(); + otLinkModeConfig linkMode = otThreadGetLinkMode(instance); + bool s_ot_sed_ssed = false; + if (linkMode.mRxOnWhenIdle == false && linkMode.mDeviceType == false && linkMode.mNetworkData == false) { + s_ot_sed_ssed = true; + } + + if (esp_ieee802154_get_state() == ESP_IEEE802154_RADIO_SLEEP && s_ot_sed_ssed) { + esp_ieee802154_sleep_cb(); + esp_pm_lock_release(s_pm_lock); + s_ot_sleep = true; + } +} + +void esp_openthread_wakeup_process(void) +{ + if (s_ot_sleep) { + esp_pm_lock_acquire(s_pm_lock); + esp_ieee802154_wakeup_cb(); + s_ot_sleep = false; + } +} +#endif // CONFIG_IEEE802154_SLEEP_ENABLE diff --git a/components/openthread/private_include/esp_openthread_sleep.h b/components/openthread/private_include/esp_openthread_sleep.h new file mode 100644 index 0000000000..bae2913d4f --- /dev/null +++ b/components/openthread/private_include/esp_openthread_sleep.h @@ -0,0 +1,41 @@ +/* + * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD + * + * SPDX-License-Identifier: Apache-2.0 + */ + +#pragma once + +#include "esp_err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef CONFIG_IEEE802154_SLEEP_ENABLE +/** + * @brief This function initializes the OpenThread sleep. + * + * @return + * - ESP_OK on success + * - ESP_FAIL on failure + * + */ +esp_err_t esp_openthread_sleep_init(void); + +/** + * @brief This function performs the OpenThread sleep process. + * + */ +void esp_openthread_sleep_process(void); + +/** + * @brief This function performs the OpenThread wakeup process. + * + */ +void esp_openthread_wakeup_process(void); +#endif + +#ifdef __cplusplus +} +#endif diff --git a/components/openthread/src/port/esp_openthread_radio.c b/components/openthread/src/port/esp_openthread_radio.c index fa4dcfbe12..6ad310fd03 100644 --- a/components/openthread/src/port/esp_openthread_radio.c +++ b/components/openthread/src/port/esp_openthread_radio.c @@ -273,7 +273,7 @@ otError otPlatRadioEnable(otInstance *aInstance) otError otPlatRadioDisable(otInstance *aInstance) { - esp_ieee802154_disable(); + // radio will be disabled in esp_openthread_radio_deinit() return OT_ERROR_NONE; } diff --git a/examples/openthread/.build-test-rules.yml b/examples/openthread/.build-test-rules.yml index 75acba2f4d..bab61b6116 100644 --- a/examples/openthread/.build-test-rules.yml +++ b/examples/openthread/.build-test-rules.yml @@ -18,6 +18,14 @@ examples/openthread/ot_cli: temporary: true reason: only test on esp32h2 +examples/openthread/ot_power_save: + enable: + - if: IDF_TARGET == "esp32c6" + disable_test: + - if: IDF_TARGET in ["esp32h2", "esp32c6"] + temporary: true + reason: No support # TO-DO: TZ-134 + examples/openthread/ot_rcp: enable: - if: IDF_TARGET in ["esp32h2", "esp32c6"] diff --git a/examples/openthread/README.md b/examples/openthread/README.md index 1c7728835e..f7de43d3c7 100644 --- a/examples/openthread/README.md +++ b/examples/openthread/README.md @@ -11,3 +11,5 @@ In this folder, it contains following OpenThread examples: * [ot_rcp](ot_rcp) is an [OpenThread RCP](https://openthread.io/platforms/co-processor) example. It runs on an 802.15.4 SoC like ESP32-H2, to extend 802.15.4 radio. * [ot_br](ot_br) is an [OpenThread Border Router](https://openthread.io/guides/border-router) example. It runs on a Wi-Fi SoC such as ESP32, ESP32-C3 and ESP32-S3. It needs an 802.15.4 SoC like ESP32-H2 running [ot_rcp](ot_rcp) example to provide 802.15.4 radio. + +* [ot_power_save](ot_power_save) is an OpenThread Power save example, it supports 802.15.4 radio light sleep. It runs on an 802.15.4 SoC like ESP32-C6. \ No newline at end of file diff --git a/examples/openthread/ot_power_save/CMakeLists.txt b/examples/openthread/ot_power_save/CMakeLists.txt new file mode 100644 index 0000000000..a975ba7e48 --- /dev/null +++ b/examples/openthread/ot_power_save/CMakeLists.txt @@ -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(ot_power_save) diff --git a/examples/openthread/ot_power_save/README.md b/examples/openthread/ot_power_save/README.md new file mode 100644 index 0000000000..adafceb053 --- /dev/null +++ b/examples/openthread/ot_power_save/README.md @@ -0,0 +1,46 @@ +| Supported Targets | ESP32-C6 | +| ----------------- | -------- | + +# OpenThread Power Save Example + +The example demonstrates the OpenThread Power Save based on light sleep, which reduces power consumption by turning off RF, PHY, BB, and IEEE802154 MAC during the sleep state. +## How to use example + +### Hardware Required + +* Prepare an ESP32-C6 development board as an OpenThread Sleepy End Device (SED). +* Connect the board using a USB cable for power supply and programming. +* Choose another ESP32-C6 as the OpenThread Leader. + + +## Configure the Openthread Dataset + +* Run [ot_cli](../ot_cli/) on another ESP32-C6 device to create openthread dataset configuration and start an openthread network as the leader. +* Configure the Openthread dataset (`CONFIG_OPENTHREAD_NETWORK_DATASET`) in [ot_power_save](../ot_power_save/main/esp_ot_power_save_config.h), ensuring that the device's dataset matches the dataset of the leader. + +## Erase the ot_storage + +If desired, erase the ot_storage by running `idf.py -p erase-flash` before flashing the board to remove previous examples or other project data. + +### Build and Flash + + Build the project and flash it to the board. Use the following command: `idf.py -p build flash monitor`. + + +### Example Output + +As the example runs, you will see the log output indicating the initialization and operation of OpenThread, including the device joining the OpenThread network as a Sleepy End Device (SED) and periodic polling of the leader. + +``` +I (769) btbb_init: btbb sleep retention initialization +I (769) ieee802154: ieee802154 mac sleep retention initialization +I(769) OPENTHREAD:[I] ChildSupervsn-: Timeout: 0 -> 190 +I (699) main_task: Returned from app_main() +I (799) OPENTHREAD: OpenThread attached to netif +I(799) OPENTHREAD:[N] Mle-----------: Mode 0x0f -> 0x04 [rx-on:no ftd:no full-net:no] +I(809) OPENTHREAD:[N] Mle-----------: Role disabled -> detached +I (819) OPENTHREAD: netif up +I(1519) OPENTHREAD:[N] Mle-----------: Attach attempt 1, AnyPartition reattaching with Active Dataset +I(2479) OPENTHREAD:[N] Mle-----------: RLOC16 fffe -> 5023 +I(2529) OPENTHREAD:[N] Mle-----------: Role detached -> child +``` \ No newline at end of file diff --git a/examples/openthread/ot_power_save/main/CMakeLists.txt b/examples/openthread/ot_power_save/main/CMakeLists.txt new file mode 100644 index 0000000000..832a7f9bed --- /dev/null +++ b/examples/openthread/ot_power_save/main/CMakeLists.txt @@ -0,0 +1,2 @@ +idf_component_register(SRCS "esp_ot_power_save.c" + INCLUDE_DIRS ".") diff --git a/examples/openthread/ot_power_save/main/esp_ot_power_save.c b/examples/openthread/ot_power_save/main/esp_ot_power_save.c new file mode 100644 index 0000000000..9d6205d83b --- /dev/null +++ b/examples/openthread/ot_power_save/main/esp_ot_power_save.c @@ -0,0 +1,206 @@ +/* + * SPDX-FileCopyrightText: 2023 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 +#include +#include +#include + +#include "esp_err.h" +#include "esp_event.h" +#include "esp_log.h" +#include "esp_openthread.h" +#include "esp_openthread_netif_glue.h" +#include "esp_ot_power_save_config.h" +#include "esp_vfs_eventfd.h" +#include "driver/uart.h" +#include "nvs_flash.h" +#include "openthread/logging.h" +#include "openthread/thread.h" + +#ifdef CONFIG_PM_ENABLE +#include "esp_pm.h" +#endif + +#if !SOC_IEEE802154_SUPPORTED +#error "Power save is only supported for the SoCs which have IEEE 802.15.4 module" +#endif + +#define TAG "ot_esp_power_save" + +static int hex_digit_to_int(char hex) +{ + if ('A' <= hex && hex <= 'F') { + return 10 + hex - 'A'; + } + if ('a' <= hex && hex <= 'f') { + return 10 + hex - 'a'; + } + if ('0' <= hex && hex <= '9') { + return hex - '0'; + } + return -1; +} + +static size_t hex_string_to_binary(const char *hex_string, uint8_t *buf) +{ + int num_char = strlen(hex_string); + + if (num_char % 2 == true) { + return 0; + } + + for (size_t i = 0; i < num_char; i += 2) { + int digit0 = hex_digit_to_int(hex_string[i]); + int digit1 = hex_digit_to_int(hex_string[i + 1]); + + if (digit0 < 0 || digit1 < 0) { + return 0; + } + buf[i / 2] = (digit0 << 4) + digit1; + } + + return num_char/2; +} + +static void create_config_network(otInstance *instance) +{ + otLinkModeConfig linkMode; + uint16_t dataset_str_len = strlen(CONFIG_OPENTHREAD_NETWORK_DATASET); + otOperationalDatasetTlvs datasetTlvs; + memset(&linkMode, 0, sizeof(otLinkModeConfig)); + + linkMode.mRxOnWhenIdle = false; + linkMode.mDeviceType = false; + linkMode.mNetworkData = false; + + if (otLinkSetPollPeriod(instance, CONFIG_OPENTHREAD_NETWORK_POLLPERIOD_TIME) != OT_ERROR_NONE) { + ESP_LOGE(TAG, "Failed to set OpenThread pollperiod."); + abort(); + } + + if (otThreadSetLinkMode(instance, linkMode) != OT_ERROR_NONE) { + ESP_LOGE(TAG, "Failed to set OpenThread linkmode."); + abort(); + } + + if (dataset_str_len > (OT_OPERATIONAL_DATASET_MAX_LENGTH * 2)) { + ESP_LOGE(TAG, "dataset length error."); + abort(); + } + + datasetTlvs.mLength = hex_string_to_binary(CONFIG_OPENTHREAD_NETWORK_DATASET, datasetTlvs.mTlvs); + + if (!datasetTlvs.mLength) { + ESP_LOGE(TAG, "Failed convert configured dataset"); + abort(); + } + + if (otDatasetSetActiveTlvs(instance, &datasetTlvs) != OT_ERROR_NONE) { + ESP_LOGE(TAG, "Failed to set OpenThread otDatasetSetActiveTlvs."); + abort(); + } + + if(otIp6SetEnabled(instance, true) != OT_ERROR_NONE) { + ESP_LOGE(TAG, "Failed to enable OpenThread IP6 link"); + abort(); + } + + if(otThreadSetEnabled(instance, true) != OT_ERROR_NONE) { + ESP_LOGE(TAG, "Failed to enable OpenThread"); + abort(); + } +} + +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(), + }; + + // Initialize the OpenThread stack + ESP_ERROR_CHECK(esp_openthread_init(&config)); + +#if CONFIG_OPENTHREAD_LOG_LEVEL_DYNAMIC + // The OpenThread log level directly matches ESP log level + (void)otLoggingSetLevel(CONFIG_LOG_DEFAULT_LEVEL); +#endif + esp_netif_t *openthread_netif; + // Initialize the esp_netif bindings + openthread_netif = init_openthread_netif(&config); + esp_netif_set_default_netif(openthread_netif); + + create_config_network(esp_openthread_get_instance()); + + // Run the main loop + esp_openthread_launch_mainloop(); + + // Clean up + esp_netif_destroy(openthread_netif); + esp_openthread_netif_glue_deinit(); + + esp_vfs_eventfd_unregister(); + vTaskDelete(NULL); +} + +static esp_err_t ot_power_save_init(void) +{ + esp_err_t rc = ESP_OK; +#ifdef CONFIG_PM_ENABLE + int cur_cpu_freq_mhz = CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ; + + esp_pm_config_t pm_config = { + .max_freq_mhz = cur_cpu_freq_mhz, + .min_freq_mhz = cur_cpu_freq_mhz, +#if CONFIG_FREERTOS_USE_TICKLESS_IDLE + .light_sleep_enable = true +#endif + }; + + rc = esp_pm_configure(&pm_config); +#endif + return rc; +} + +void app_main(void) +{ + // Used eventfds: + // * netif + // * ot task queue + // * radio driver + esp_vfs_eventfd_config_t eventfd_config = { + .max_fds = 3, + }; + + 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(ot_power_save_init()); + + xTaskCreate(ot_task_worker, "ot_power_save_main", 4096, NULL, 5, NULL); +} diff --git a/examples/openthread/ot_power_save/main/esp_ot_power_save_config.h b/examples/openthread/ot_power_save/main/esp_ot_power_save_config.h new file mode 100644 index 0000000000..217c83370d --- /dev/null +++ b/examples/openthread/ot_power_save/main/esp_ot_power_save_config.h @@ -0,0 +1,54 @@ +/* + * SPDX-FileCopyrightText: 2023 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 "esp_openthread_types.h" + +# define CONFIG_OPENTHREAD_NETWORK_DATASET "0e080000000000010000000300000b35060004001fffe002084c14b4d26855fcd00708fdf7e918eb62e2a905107ca0e75a6ead4b960cfe073386943605030f4f70656e5468726561642d616631360102af1604102b9084b26c9a7d10a1a729bfc2e84ea00c0402a0f7f8" +# define CONFIG_OPENTHREAD_NETWORK_POLLPERIOD_TIME 3000 + +#if SOC_IEEE802154_SUPPORTED +#define ESP_OPENTHREAD_DEFAULT_RADIO_CONFIG() \ + { \ + .radio_mode = RADIO_MODE_NATIVE, \ + } +#endif + +#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, \ + }, \ + } + +#define ESP_OPENTHREAD_DEFAULT_PORT_CONFIG() \ + { \ + .storage_partition_name = "ot_storage", \ + .netif_queue_size = 10, \ + .task_queue_size = 10, \ + } diff --git a/examples/openthread/ot_power_save/partitions.csv b/examples/openthread/ot_power_save/partitions.csv new file mode 100644 index 0000000000..1874ddc89f --- /dev/null +++ b/examples/openthread/ot_power_save/partitions.csv @@ -0,0 +1,6 @@ +# 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, 0x120000, +ot_storage, data, 0x3a, , 0x2000, diff --git a/examples/openthread/ot_power_save/sdkconfig.defaults b/examples/openthread/ot_power_save/sdkconfig.defaults new file mode 100644 index 0000000000..5f64593d30 --- /dev/null +++ b/examples/openthread/ot_power_save/sdkconfig.defaults @@ -0,0 +1,53 @@ +CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=2048 + +# +# Partition Table +# +CONFIG_PARTITION_TABLE_CUSTOM=y +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_FILENAME="partitions.csv" +# end of Partition Table + +# +# mbedTLS +# +# ESP32H2-TODO: JIRA TZ-127, enable HW acceleration. +CONFIG_MBEDTLS_HARDWARE_AES=n +CONFIG_MBEDTLS_HARDWARE_MPI=n +CONFIG_MBEDTLS_HARDWARE_SHA=n +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 +# end of OpenThread + +# +# lwIP +# +CONFIG_LWIP_TCPIP_TASK_STACK_SIZE=4096 +CONFIG_LWIP_IPV6_NUM_ADDRESSES=8 +CONFIG_LWIP_MULTICAST_PING=y +# end of lwIP + +# +# IEEE 802.15.4 +# +CONFIG_IEEE802154_ENABLED=y +# end of IEEE 802.15.4 + +# +# light sleep +# +CONFIG_PM_ENABLE=y +CONFIG_FREERTOS_USE_TICKLESS_IDLE=y +CONFIG_PM_POWER_DOWN_PERIPHERAL_IN_LIGHT_SLEEP=y +CONFIG_IEEE802154_SLEEP_ENABLE=y +# end of light sleep