temporary fix for OpenOCD until complete refactoring of tl-install for all components (#159)

Author: Jason2866

boards/esp32-c5-devkitc-1.json

@@ -0,0 +1,31 @@
+{
+  "build": {
+    "core": "esp32",
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "mcu": "esp32c5",
+    "variant": "esp32c5"
+  },
+  "connectivity": [
+    "bluetooth",
+    "wifi"
+  ],
+  "debug": {
+    "openocd_target": "esp32c5.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "Espressif ESP32-C5-DevKitC-1 4MB no PSRAM",
+  "upload": {
+    "flash_size": "4MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 4194304,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://docs.espressif.com/projects/esp-dev-kits/en/latest/esp32c5/esp32-c5-devkitc-1/user_guide.html",
+  "vendor": "Espressif"
+}

builder/frameworks/_embed_files.py

@@ -110,14 +110,14 @@ def transform_to_asm(target, source, env):
                 " ".join(
                     [
                         "riscv32-esp-elf-objcopy"
-                        if mcu in ("esp32c2","esp32c3","esp32c6","esp32h2","esp32p4")
+                        if mcu in ("esp32c2","esp32c3","esp32c5","esp32c6","esp32h2","esp32p4")
                         else "xtensa-%s-elf-objcopy" % mcu,
                         "--input-target",
                         "binary",
                         "--output-target",
-                        "elf32-littleriscv" if mcu in ("esp32c2","esp32c3","esp32c6","esp32h2","esp32p4") else "elf32-xtensa-le",
+                        "elf32-littleriscv" if mcu in ("esp32c2","esp32c3","esp32c5","esp32c6","esp32h2","esp32p4") else "elf32-xtensa-le",
                         "--binary-architecture",
-                        "riscv" if mcu in ("esp32c2","esp32c3","esp32c6","esp32h2","esp32p4") else "xtensa",
+                        "riscv" if mcu in ("esp32c2","esp32c3","esp32c5","esp32c6","esp32h2","esp32p4") else "xtensa",
                         "--rename-section",
                         ".data=.rodata.embedded",
                         "$SOURCE",

builder/main.py

@@ -235,7 +235,7 @@ def __fetch_fs_size(target, source, env):
 mcu = board.get("build.mcu", "esp32")
 toolchain_arch = "xtensa-%s" % mcu
 filesystem = board.get("build.filesystem", "spiffs")
-if mcu in ("esp32c2", "esp32c3", "esp32c6", "esp32h2", "esp32p4"):
+if mcu in ("esp32c2", "esp32c3", "esp32c5", "esp32c6", "esp32h2", "esp32p4"):
     toolchain_arch = "riscv32-esp"
 
 if "INTEGRATION_EXTRA_DATA" not in env:
@@ -256,7 +256,7 @@ def __fetch_fs_size(target, source, env):
     GDB=join(
         platform.get_package_dir(
             "riscv32-esp-elf-gdb"
-            if mcu in ("esp32c2", "esp32c3", "esp32c6", "esp32h2", "esp32p4")
+            if mcu in ("esp32c2", "esp32c3", "esp32c5", "esp32c6", "esp32h2", "esp32p4")
             else "xtensa-esp-elf-gdb"
         )
         or "",
@@ -547,7 +547,7 @@ def check_lib_archive_exists():
         f.replace(
             "$PACKAGE_DIR",
             _to_unix_slashes(
-                platform.get_package_dir("tool-openocd") or ""))
+                platform.get_package_dir("tool-openocd-esp32") or ""))
         for f in openocd_args
     ]
     env.Replace(

examples/espidf-ulp-lp/CMakeLists.txt

@@ -1,4 +1,4 @@
 cmake_minimum_required(VERSION 3.16)
 
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(lp_core_pulse_counter)
+project(lp_core_gpio_wake_up_example)

examples/espidf-ulp-lp/README.md

@@ -1,51 +1,26 @@
-| Supported Targets | ESP32-C6 |
-| ----------------- | -------- |
+| Supported Targets | ESP32-C5 | ESP32-C6 | ESP32-P4 |
+| ----------------- | -------- | -------- | -------- |
+# ULP-LP-Core simple example with GPIO Interrupt:
 
-This example demonstrates how to program the ULP Core coprocessor to count pulses on an IO while the main CPUs are either running some other code or are in deep sleep. See the README.md file in the upper level 'examples' directory for more information about examples.
+This example demonstrates how to program the LP-Core coprocessor to wake up from a RTC IO interrupt, instead of waking periodically from the ULP timer.
 
-At runtime, the main code running on the ESP (found in lp_core_pulse_counter_example_main.c) loads ULP program into the `RTC_SLOW_MEM` memory region using `ulp_lp_core_load_binary` function. Main code configures the ULP program by setting up values of some variables and then starts it using `ulp_lp_core_run`. Once the ULP program is started, it monitors the IO pin for pulses.
+ULP program written in C can be found across `ulp/main.c`. The build system compiles and links this program, converts it into binary format, and embeds it into the .rodata section of the ESP-IDF application.
 
-When the ULP program finds an edge in the input signal, it performs debouncing and increments the variable maintaining the total edge count. Once the edge count reaches certain value, ULP triggers wake up from deep sleep. Note that the ULP program keeps running and monitoring the input signal even when the SoC is woken up.
+At runtime, the main code running on the ESP (found in lp_core_gpio_wake_up_example_main.c) loads ULP program into the `RTC_SLOW_MEM` memory region using `ulp_lp_core_load_binary` function. The main code then configures the ULP GPIO wakeup source and starts the coprocessor by using `ulp_lp_core_run` followed by putting the chip into deep sleep mode.
 
-### Hardware Required
+When the wakeup source pin is pulled low the LP-Core coprocessor is woken up, sends a wakeup signal to the main CPU and goes back to sleep again.
 
-To run this example, you should have a development board based on any of the chips listed in the supported targets table at the top and a host machine with a serial input connection.
+In this example the input signal is connected to GPIO2. To change the pin number, check the Chip Pin List document and adjust `WAKEUP_PIN` variable in main.c.
 
-#### Pin Assignment:
 
-**Note:** The following pin assignments are used by default.
+## Example output
 
-
-|                         | Uart Tx | Pulse Count Input |
-| ----------------------- | ------- | ----------------- |
-| ESP32-C6                | GPIO5   | GPIO6             |
-| Host machine            | Rx      | N/A               |
-
-
-## Example Output
-
-The log output from the serial monitor connected to the main core should indicate that the LP core and the LP UART peripheral have been successfully initialized. The main CPU would then enter deep sleep mode.
-
-```bash
-Using pin 6 as pulse counter input
-ULP will wake up processor after every 10 pulses
-Not a ULP wakeup, initializing it!
-Entering in deep sleep
-...
-rst:0x5 (SLEEP_WAKEUP),boot:0xc (SPI_FAST_FLASH_BOOT)
-...
-ULP woke up the main CPU!
-Pulse count: 11
-Entering in deep sleep
 ```
+Not a LP-Core wakeup, initializing it!
+Entering deep sleep
 
-The log output from the serial monitor connected to the LP core should display output as below -
+...
 
-```bash
-LP Core pulse counter started
-Pulse count: 10, wake-up main CPU
+LP-Core woke up the main CPU!
+Entering deep sleep
 ```
-
-## Troubleshooting
-
-(For any technical queries, please open an [issue](https://github.com/espressif/esp-idf/issues) on GitHub. We will get back to you as soon as possible.)

examples/espidf-ulp-lp/pytest_lp_core_pcnt.py

@@ -1,4 +1,4 @@
-idf_component_register(SRCS "lp_core_pulse_counter_example_main.c"
+idf_component_register(SRCS "lp_core_gpio_wake_up_example_main.c"
                     INCLUDE_DIRS ".")
 
 #
@@ -15,7 +15,7 @@ set(ulp_sources "../ulp/main.c")
 #
 # 3. List all the component source files which include automatically
 #    generated ULP export file, ${ulp_app_name}.h:
-set(ulp_exp_dep_srcs "lp_core_pulse_counter_example_main.c")
+set(ulp_exp_dep_srcs "lp_core_gpio_wake_up_example_main.c")
 
 #
 # 4. Call function to build ULP binary and embed in project using the argument

examples/espidf-ulp-lp/src/CMakeLists.txt

@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: Unlicense OR CC0-1.0
  */
-/* LP core gpio example
+/* ULP LP-Core GPIO wake-up example
 
    This example code is in the Public Domain (or CC0 licensed, at your option.)
 
@@ -13,22 +13,30 @@
 */
 
 #include <stdio.h>
-#include <inttypes.h>
 #include "esp_sleep.h"
-#include "driver/gpio.h"
 #include "driver/rtc_io.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
 #include "ulp_lp_core.h"
 #include "ulp_main.h"
-#include "lp_core_uart.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+#define WAKEUP_PIN 2
 
 extern const uint8_t ulp_main_bin_start[] asm("_binary_ulp_main_bin_start");
 extern const uint8_t ulp_main_bin_end[]   asm("_binary_ulp_main_bin_end");
 
-
 static void init_ulp_program(void);
 
+static void wakeup_gpio_init(void)
+{
+    /* Configure the button GPIO as input, enable wakeup */
+    rtc_gpio_init(WAKEUP_PIN);
+    rtc_gpio_set_direction(WAKEUP_PIN, RTC_GPIO_MODE_INPUT_ONLY);
+    rtc_gpio_pulldown_dis(WAKEUP_PIN);
+    rtc_gpio_pullup_en(WAKEUP_PIN);
+    rtc_gpio_wakeup_enable(WAKEUP_PIN, GPIO_INTR_NEGEDGE);
+}
+
 void app_main(void)
 {
     /* If user is using USB-serial-jtag then idf monitor needs some time to
@@ -38,46 +46,39 @@ void app_main(void)
     */
     vTaskDelay(pdMS_TO_TICKS(1000));
 
-    /* Initialize selected GPIO as RTC IO, enable input/output, disable pullup and pulldown */
-    printf("Using pin %d as pulse counter input\n", CONFIG_EXAMPLE_PULSE_COUNT_PIN);
-    rtc_gpio_init(CONFIG_EXAMPLE_PULSE_COUNT_PIN);
-    rtc_gpio_set_direction(CONFIG_EXAMPLE_PULSE_COUNT_PIN, RTC_GPIO_MODE_INPUT_OUTPUT);
-    rtc_gpio_pulldown_dis(CONFIG_EXAMPLE_PULSE_COUNT_PIN);
-    rtc_gpio_pullup_dis(CONFIG_EXAMPLE_PULSE_COUNT_PIN);
-
-    printf("ULP will wake up processor after every %d pulses\n", CONFIG_EXAMPLE_PULSE_COUNT_WAKEUP_LIMIT);
+    wakeup_gpio_init();
 
     esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
     /* not a wakeup from ULP, load the firmware */
     if (cause != ESP_SLEEP_WAKEUP_ULP) {
         printf("Not a ULP wakeup, initializing it! \n");
         init_ulp_program();
-    } else {
-        printf("ULP woke up the main CPU!\n");
-        printf("Pulse count: %"PRIu32"\n", ulp_pulse_count);
+    }
+
+    /* ULP read and detected a change in WAKEUP_PIN, prints */
+    if (cause == ESP_SLEEP_WAKEUP_ULP) {
+        printf("ULP woke up the main CPU! \n");
     }
 
     /* Go back to sleep, only the ULP will run */
-    printf("Entering in deep sleep\n\n");
+    printf("Entering deep sleep\n\n");
 
     /* Small delay to ensure the messages are printed */
+    vTaskDelay(100 / portTICK_PERIOD_MS);
+
     ESP_ERROR_CHECK( esp_sleep_enable_ulp_wakeup());
 
     esp_deep_sleep_start();
 }
 
 static void init_ulp_program(void)
 {
-    lp_core_uart_cfg_t uart_cfg = LP_CORE_UART_DEFAULT_CONFIG();
-
-    ESP_ERROR_CHECK(lp_core_uart_init(&uart_cfg));
-
     esp_err_t err = ulp_lp_core_load_binary(ulp_main_bin_start, (ulp_main_bin_end - ulp_main_bin_start));
     ESP_ERROR_CHECK(err);
 
     /* Start the program */
     ulp_lp_core_cfg_t cfg = {
-        .wakeup_source = ULP_LP_CORE_WAKEUP_SOURCE_HP_CPU,
+        .wakeup_source = ULP_LP_CORE_WAKEUP_SOURCE_LP_IO,
     };
 
     err = ulp_lp_core_run(&cfg);

examples/espidf-ulp-lp/src/Kconfig.projbuild

@@ -5,60 +5,16 @@
  */
 #include <stdint.h>
 #include <stdbool.h>
-#include "sdkconfig.h"
 #include "ulp_lp_core.h"
 #include "ulp_lp_core_utils.h"
 #include "ulp_lp_core_gpio.h"
-#include "ulp_lp_core_interrupts.h"
-#include "ulp_lp_core_print.h"
-#include "riscv/csr.h"
-
-#define DEBOUNCE_INTERVAL_CYCLES 10 // 10 cycles is about 0.625 us at 16 MHz
-
-#define SIMULATED_PULSE_FREQUENCY_HZ 2
-#define SIMULATED_PULSE_DELAY_US (1000000 / SIMULATED_PULSE_FREQUENCY_HZ) / 2
-
-uint32_t pulse_count;
-static uint32_t last_trigger_time_cycles;
-
-void LP_CORE_ISR_ATTR ulp_lp_core_lp_io_intr_handler(void)
-{
-    ulp_lp_core_gpio_clear_intr_status();
-    uint32_t trigger_time_cycles = RV_READ_CSR(mcycle);
-    /* Do some simple debouncing, do not count spurious pulses */
-    if (trigger_time_cycles - last_trigger_time_cycles > DEBOUNCE_INTERVAL_CYCLES) {
-        pulse_count++;
-        last_trigger_time_cycles = trigger_time_cycles;
-    }
-
-    if (pulse_count % CONFIG_EXAMPLE_PULSE_COUNT_WAKEUP_LIMIT == 0) {
-        lp_core_printf("Pulse count: %d, wake-up main CPU\n", pulse_count);
-        ulp_lp_core_wakeup_main_processor();
-    }
-
-}
-
 
 
 int main (void)
 {
-    lp_core_printf("LP Core pulse counter started\n");
-    ulp_lp_core_intr_enable();
-    ulp_lp_core_gpio_intr_enable(CONFIG_EXAMPLE_PULSE_COUNT_PIN, LP_IO_INTR_POSEDGE);
-
-    while(1) {
+    ulp_lp_core_wakeup_main_processor();
 
-#if CONFIG_EXAMPLE_PULSE_COUNT_SIMULATE
-        /* No external device connected to generate pulses, we simulate them ourselves instead */
-        ulp_lp_core_delay_us(SIMULATED_PULSE_DELAY_US);
-        ulp_lp_core_gpio_set_level(CONFIG_EXAMPLE_PULSE_COUNT_PIN, 1);
-        ulp_lp_core_delay_us(SIMULATED_PULSE_DELAY_US);
-        ulp_lp_core_gpio_set_level(CONFIG_EXAMPLE_PULSE_COUNT_PIN, 0);
-#else
-        /* Put CPU into a wait state to reduce power consumption while waiting for pulses */
-        ulp_lp_core_wait_for_intr();
-#endif //CONFIG_EXAMPLE_PULSE_COUNT_SIMULATE
-    }
+    ulp_lp_core_gpio_clear_intr_status();
 
     return 0;
 }