ESP32 Forum

Code: Select all

#include "soc/rtc_cntl_reg.h"
#include "soc/rtc_io_reg.h"
#include "soc/soc_ulp.h"

        /* ------ Define variables, which go into .bss section (zero-initialized data) ------ */
        .bss

        /* Number of logical '1's read so far. Wake up when we pass num_thres */
        .global num_high
num_high:
        .long 0

        /* Number of successive highs before wake.  Set by main program. */
        .global num_thres
num_thres:
        .long 0

        /* RTC IO number used to sample the input signal.  Set by main program. */
        .global io_psdown
io_psdown:
        .long 0

        .global helloworld
helloworld:
        .long 0

        /* ------ Code goes into .text section ------ */
        .text
        .global entry
entry:
        /* Say hello */
        move r3, helloworld
        move r2, 0xC0DE;
        st r2, r3, 0                 // helloworld = 0xC0DE;

        /* Load io_number */         // R0:1 = gpio_rtc[io_number]
        move r3, io_psdown
        ld r3, r3, 0

        /* Lower 16 IOs and higher need to be handled separately,
         * because r0-r3 registers are 16 bit wide.
         * Check which IO this is.
         */
        move r0, r3
        jumpr read_io_high, 16, ge

        /* Read the value of lower 16 RTC IOs into R0 */
        READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16)
        rsh r0, r0, r3
        jump read_done

        /* Read the value of RTC IOs 16-17, into R0 */
read_io_high:
        READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + 16, 2)
        sub r3, r3, 16
        rsh r0, r0, r3

read_done:
        and r0, r0, 1                // if (R0:1) goto is_low else:
        jump is_low, eq
        /* Load counter */
        move r3, num_high            // num_high = num_high + 1 (part 1)
        ld r3, r3, 0
        add r0, r3, 1
        /* Save counter */
        move r3, num_high            // num_high = num_high + 1 (part 2)
        st r0, r3, 0
        /* Load threshold */
        move r3, num_thres
        ld r3, r3, 0
        sub r0, r3, r0
        jump wake_up, ov             // if (R0 > num_thres) goto wake_up else:

        /* End program */
        halt

is_low:
        /* Reset counter */
        move r0, 0                   // num_high = 0
        move r3, num_high
        st r0, r3, 0
exit:
        /* End program */
        halt

wake_up:
        move r3, helloworld          // helloworld = 0xBEEF
        move r2, 0xBEEF;
        st r2, r3, 0

        /* Loop until the system can be woken up */
loop_rdy:
        READ_RTC_FIELD(RTC_CNTL_LOW_POWER_ST_REG, RTC_CNTL_RDY_FOR_WAKEUP)
        and r0, r0, 1
        jump loop_rdy, eq
        //jump exit, eq

        move r3, helloworld          // helloworld = 0xACED
        move r2, 0xACED;
        st r2, r3, 0

        /* Wake up the SoC, end program */
        wake
        WRITE_RTC_FIELD(RTC_CNTL_STATE0_REG, RTC_CNTL_ULP_CP_SLP_TIMER_EN, 0)
        halt

Code: Select all

    ulp_set_wakeup_period(0, 200000); // Set ULP wake up period to 200ms
    ESP_ERROR_CHECK(ulp_load_binary(0, ulp_main_bin_start, (ulp_main_bin_end - ulp_main_bin_start) / sizeof(uint32_t)));
    ulp_num_thres = 100;  //5;               // Wakeup when PS_DOWN was high for 1 sec
    ulp_num_high  = 42; // Reset counter
    ulp_io_psdown = esp32_gpioMux[LG_GPIO_PSDOWN].rtc; // Evaluates to: 1
    log_info("ULP INIT: TH:%d,%p NH:%d,%p IO:%d,%p HL:%d,%p", ulp_num_thres,&ulp_num_thres, ulp_num_high,&ulp_num_high, ulp_io_psdown,&ulp_io_psdown, ulp_helloworld,&ulp_helloworld);

    ulp_run(&ulp_entry - RTC_SLOW_MEM); // For testing
 

Code: Select all

    ulp_num_high  = 0; // Reset counter
    ulp_num_thres = 5; // Wakeup when PS_DOWN was high for 1 sec
    pinMode(LG_GPIO_PSDOWN, INPUT); // ULP reads it as a GPIO (Not an ADC) (pinMode() is an arduino API)
    //delay(5);
    esp_sleep_enable_ulp_wakeup();
    ulp_run(&ulp_entry - RTC_SLOW_MEM);
    log_warn("ULP: NH:%x TH:%x", ulp_num_high, ulp_num_thres);
    esp_deep_sleep_start();