How to measure IR pulse timings in Deep Sleep Wake Stub?

[probonopd]

How to resume from deep sleep upon receiving "POWER ON" IR code?

I have set up the ESP32 to wake up whenever the IR receiver pin is pulled low (as happens at the start of every IR code).

It then wakes up, but on any IR code (and also on random noise on the IR receiver pin).

How can I get it to check for the correct "POWER ON" IR code, and only then run the rest of the sketch and go back to deep sleep otherwise?

Possibly I need to use a Deep Sleep Wake Stub.

#include <Arduino.h>

#define GPIO_PIN_NUM (gpio_num_t)14
#define MAX_TIMINGS 5

RTC_DATA_ATTR uint32_t timings[MAX_TIMINGS];
RTC_DATA_ATTR int timing_index;

void RTC_IRAM_ATTR esp_wake_deep_sleep(void) { 
    // Run default deep sleep wake stub
    esp_default_wake_deep_sleep(); 

  // ***** HELP NEEDED HERE *****
  // Measure the time in milliseconds between state changes
  // on the GPIO the IR receiver is connected to,
  // and put them into the timings array
}

void setup() {
    Serial.begin(115200);

    Serial.printf("Timings: %d", timings[1]);
    for (int i = 0; i < MAX_TIMINGS; i++) {
        Serial.printf("Timing %d: %d", i, timings[i]);
        Serial.println();
    }

    // Minimize current consumption
    // https://github.com/espressif/esp-idf/blob/master/examples/system/deep_sleep_wake_stub/main/wake_stub_example_main.c
    rtc_gpio_isolate(GPIO_NUM_12);

    // Go to deep sleep but wake up on GPIO 14
    esp_sleep_enable_ext0_wakeup(GPIO_PIN_NUM, 0);

    // Go to deep sleep
    esp_deep_sleep_start();
}

void loop() {
}   

But it is unclear to me how to write put the timings of pin changes into the array in esp_wake_deep_sleep(void).

https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/deep-sleep-stub.html mentions Rules for Wake Stubs, but it doesn't show how to measure time between pin changes.

Normally one could do something using micros(); and digitalRead() but these are Arduino functions unavailable to a Deep Sleep Wake Stub. The Rules for Wake Stubs say what you can't do, but they don't explain how to do it. It is unclear to me how to do it without violating those rules. The example linked there doesn't show how to read pin states and timings either.

Any help appreciated.

[gm-jiang]

@probonopd Sorry, I am not familiar with the programming under Arduino, but under the esp-idf framework, you can use rtc_cntl_ll_get_rtc_time() to measure the time or use esp_cpu_get_cycle_count() to get the CPU cycle counts then convert it into time. For reading a gpio status in wake stub, it is recommended to refer to this example https://gist.github.com/igrr/54f7fbe0513ac14e1aea3fd7fbecfeab.

[probonopd]

Thank you. Since on cannot use Arduino code in Deep Sleep Wake Stubs, programming should be roughly the same as in the esp-idf framework.

A typical NEC IR remote control signal has a 9ms leading pulse burst followed by a 4.5ms space.
So the interesting part of the signal starts after 13.5ms. By that time, the ESP32 should have woken up from deep sleep and we should be able to catch all the pulses following the leading pulse burst and space.

It seems like I am able to measure time now, but I am probably doing something wrong since I can't seem to wait for pin state changes.

This is what I have:

#include <Arduino.h>

#include <esp_sleep.h>
#include <driver/gpio.h>
#include <driver/rtc_io.h>
#include <esp_log.h>
#include <stdio.h>
#include <esp_timer.h>
#include <esp32/rom/rtc.h>
#include <esp32/rom/ets_sys.h>
#include "esp_system.h"

// WDT
#include "soc/timer_group_reg.h"

// Timer
#include <hal/rtc_cntl_ll.h>

// https://gist.github.com/igrr/54f7fbe0513ac14e1aea3fd7fbecfeab
// GPIO14 is RTC_GPIO16 (see esp32_chip_pin_list_en.pdf)
#define PULSE_CNT_GPIO_NUM 14
#define PULSE_CNT_RTC_GPIO_NUM 16

// https://gist.github.com/igrr/54f7fbe0513ac14e1aea3fd7fbecfeab
#define PULSE_CNT_IS_HIGH() \
    ((REG_GET_FIELD(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT) \
            & BIT(PULSE_CNT_RTC_GPIO_NUM)) == 1)

#define MAX_TIMINGS 10

RTC_DATA_ATTR int wake_count;
RTC_DATA_ATTR uint64_t timings[MAX_TIMINGS];
RTC_DATA_ATTR bool pin_states[MAX_TIMINGS];

static const char RTC_RODATA_ATTR wake_fmt_str[] = "Boot count: %d\n";
static const char RTC_RODATA_ATTR pin_state_str[] = "Pin state: %d\n";


FORCE_INLINE_ATTR uint64_t rtc_cntl_ll_get_rtc_time(void)
{
    SET_PERI_REG_MASK(RTC_CNTL_TIME_UPDATE_REG, RTC_CNTL_TIME_UPDATE);
    uint64_t t = READ_PERI_REG(RTC_CNTL_TIME0_REG);
    t |= ((uint64_t) READ_PERI_REG(RTC_CNTL_TIME1_REG)) << 32;
    return t;
}

void RTC_IRAM_ATTR esp_wake_deep_sleep(void) {   

    // Run default deep sleep wake stub
    esp_default_wake_deep_sleep();

    // Increment the wake count
    ets_printf(wake_fmt_str, wake_count);
    wake_count++;

    int timing_index = 0;
    bool pin_state = 1;
    uint64_t timing;

    pin_state = PULSE_CNT_IS_HIGH();
    pin_state = GPIO.in1.data & (1 << PULSE_CNT_RTC_GPIO_NUM); // What is the difference between this and the line above?
    pin_states[timing_index] = pin_state;

    timing = rtc_cntl_ll_get_rtc_time();
    timings[timing_index] = timing;

    timing_index++;

    // A typical NEC IR remote control signal has a 9ms leading pulse burst
    // followed by a 4.5ms space.
    // So the interesting part of the signal starts after 13.5ms.
    // By that time, the ESP32 should have woken up from deep sleep
    // and we should be able to catch all the pulses following the leading pulse burst and space.
    // https://github.com/Arduino-IRremote/Arduino-IRremote/discussions/1088#discussioncomment-5163382

    // // Wait for pin state to change
    // // This never continues, because the pin state never changes???

    // if(pin_state == 0) {
    //     while (PULSE_CNT_IS_HIGH() == 0) {
    //     REG_WRITE(TIMG_WDTFEED_REG(0), 1); // Feed the watchdog; defined in soc/timer_group_reg.h
    //     // ets_delay_us(1000); // 1ms
    //     }
    // } else {
    //     while (PULSE_CNT_IS_HIGH() != 0) {
    //     REG_WRITE(TIMG_WDTFEED_REG(0), 1); // Feed the watchdog; defined in soc/timer_group_reg.h
    //     // ets_delay_us(1000); // 1ms
    //     }
    // }

    // This just waits forever. Why?
}


void setup() {
    Serial.begin(115200);

    // Wait for serial to be ready
    while (!Serial) {
        delay(1);
    }

    Serial.println("Hello world!");

    for (int i = 0; i < MAX_TIMINGS; i++) {
        Serial.printf("%d: Pin state %d, ", i, pin_states[i]);
        Serial.printf("Timing %d",timings[i]);
        Serial.println();
    }

    Serial.printf("Wake count: %d", wake_count);
    Serial.println();
    Serial.printf("Boot reason: %d", rtc_get_reset_reason(0));
    Serial.println();

    // Isolate GPIO12 pin from external circuits. This is needed for modules
    // which have an external pull-up resistor on GPIO12 (such as ESP32-WROVER)
    // to minimize current consumption.
    // https://github.com/espressif/esp-idf/blob/master/examples/system/deep_sleep_wake_stub/main/wake_stub_example_main.c
    rtc_gpio_isolate((gpio_num_t) PULSE_CNT_GPIO_NUM);

    // Go to deep sleep but wake up on GPIO 14
    esp_sleep_enable_ext0_wakeup((gpio_num_t) PULSE_CNT_GPIO_NUM, 0);

    // Go to deep sleep
    esp_deep_sleep_start();

}

void loop() {
}

I think the Arduino part of the code setup(), loop() is working, but I think I am not doing something correctly in void RTC_IRAM_ATTR esp_wake_deep_sleep(void).