ESP32 Forum

Code: Select all

/* ULP assembly files are passed through C preprocessor first, so include directives
   and C macros may be used in these files
 */
#include "soc/rtc_cntl_reg.h"
#include "soc/soc_ulp.h"
#include "example_config.h"

	.set adc_channel, EXAMPLE_ADC_CHANNEL

	/* Configure the number of ADC samples to average on each measurement.
	   For convenience, make it a power of 2. */
	.set adc_oversampling_factor_log, 2
	.set adc_oversampling_factor, (1 << adc_oversampling_factor_log)

	/* list of variables in .bss section (zero-initialized data) */
	.bss

	/* Low threshold of ADC reading. Set by the main program. */
	.global low_thr
low_thr:
	.long 0

	/* High threshold of ADC reading. Set by the main program. */
	.global high_thr
high_thr:
	.long 0

	/* Counter of measurements done */
	.global sample_counter
sample_counter:
	.long 0

	.global last_result
last_result:
	.long 0

	 .global is_main_cpu_wake  
is_main_cpu_wake:
     .long 0

	/* Code goes into .text section */
	.text
	.global entry
entry:
	/* increment sample counter */
	move r3, sample_counter
	ld r2, r3, 0
	add r2, r2, 1
	st r2, r3, 0

	/* do measurements using ADC */
	/* r0 will be used as accumulator */
	move r0, 0
	/* initialize the loop counter */
	stage_rst
measure:
	/* measure and add value to accumulator */
	adc r1, 0, adc_channel + 1
	add r0, r0, r1
	/* increment loop counter and check exit condition */
	stage_inc 1
	jumps measure, adc_oversampling_factor, lt

	/* divide accumulator by adc_oversampling_factor.
	   Since it is chosen as a power of two, use right shift */
	rsh r0, r0, adc_oversampling_factor_log
	/* averaged value is now in r0; store it into last_result */
	move r3, last_result
	st r0, r3, 0
    
	// test if main CPU is already in wake state
	// and just jump to halt if it is
    move r3, is_main_cpu_wake
	ld r3, r3, 0
	sub r3, r3, 1
    jump loop_end, eq

	//if it is not waken then
	// compare with high_thr; wake up if value > high_thr 

	move r3, high_thr
	ld r3, r3, 0
	sub r3, r3, r0
	jump wake_up, ov

	/* still below upper treshold */
	/* just continue measurement and do nothing else */
	.global loop_end
loop_end:
    // stop ULP program and wait until its timer restarts program at entry point
     halt

	.global wake_up
wake_up:
	// Check if the system can be woken up 
	READ_RTC_FIELD(RTC_CNTL_LOW_POWER_ST_REG, RTC_CNTL_RDY_FOR_WAKEUP)
	and r0, r0, 1
	jump wake_up, eq

	// Wake up the SoC
	wake
// next line is under comment because we need ULP running all the time
// allowing re-entering into sleep if voltage again drops below lower treshold level
// we also involwed new variable is_main_cpu_wake which allows us to skip
// re-entering into wake process if main cores are already waken

//    WRITE_RTC_FIELD(RTC_CNTL_STATE0_REG, RTC_CNTL_ULP_CP_SLP_TIMER_EN, 0)

    // here we know main cores are waken up by ULP
	// so we can set up that state in is_maincpu_wake variable
	// stored in RTC memory

	move r3, is_main_cpu_wake
	move r0, 1
	st r0, r3, 0
    // stop ULP program and wait until its timer restart program at entry point
    halt

Code: Select all

#pragma once

/* Ints are used here to be able to include the file in assembly as well */
#define EXAMPLE_ADC_CHANNEL     6 // ADC_CHANNEL_6, GPIO34 on ESP32, GPIO7 on ESP32-S3
#define EXAMPLE_ADC_UNIT        0 // ADC_UNIT_1
#define EXAMPLE_ADC_ATTEN       3 // we want half of power voltage (got by two identical 10K resistors) is measurable
                                  // so we need strongest attenuation approx 12dB which should give values approx 1860 on AD converter 
#define EXAMPLE_ADC_WIDTH       0 // ADC_BITWIDTH_DEFAULT means 12 bits AD

/* Set low and high thresholds */
#define EXAMPLE_ADC_LOW_TRESHOLD    1300
#define EXAMPLE_ADC_HIGH_TRESHOLD   1860 

Code: Select all

#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "esp_sleep.h"
#include "soc/rtc_cntl_reg.h"
#include "soc/sens_reg.h"
#include "driver/gpio.h"
#include "driver/rtc_io.h"
#include "ulp.h"
#include "ulp_main.h"
#include "esp_adc/adc_oneshot.h"
#include "ulp/example_config.h"
#include "ulp_adc.h"
#include "esp_timer.h"

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

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 start_ulp_program(void);

static void periodic_timer_callback(void* arg)
{
    // monitoring routine which will activate deep sleep state
    // in the case the measured value is below lower treshold limit
    uint16_t cur_val = ulp_last_result & 0xFFFF;
    printf("current value at ULP AD %"PRIu16"\n", cur_val);
    if(cur_val<ulp_low_thr){
        printf("Entering to deep sleep\n");
        ESP_ERROR_CHECK( esp_sleep_enable_ulp_wakeup() );
        #if !CONFIG_IDF_TARGET_ESP32
         /* RTC peripheral power domain needs to be kept on to keep SAR ADC related configs during sleep */
         esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
        #endif
        // here we reset varibla which keeps track are the main CORES in sleep or not
        // that variable is set to value 1 in the case ULP has waken the main cores
        // however if ESP is regulary powered or powered from real reset that variable
        // has to be set at 1 in proper part of main routine before ULP program is started
        ulp_is_main_cpu_wake = 0;
        esp_deep_sleep_start();
    }
}

static void timer_config_and_install(void)
{
    const esp_timer_create_args_t periodic_timer_args = {
            .callback = &periodic_timer_callback,
            .name = "periodic"
    };
    esp_timer_handle_t periodic_timer;
    ESP_ERROR_CHECK(esp_timer_create(&periodic_timer_args, &periodic_timer));
    ESP_ERROR_CHECK(esp_timer_start_periodic(periodic_timer, 1000000));
}

void app_main(void)
{
    esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
    if (cause != ESP_SLEEP_WAKEUP_ULP) {
       // at this point, chip is powered by regular reset or real power up
       // so we need to initialize ulp program
       // also at this point RTC RAM is empty 
        printf("Not ULP wakeup\n");
        init_ulp_program();
        ESP_ERROR_CHECK( esp_sleep_enable_ulp_wakeup() );
        #if !CONFIG_IDF_TARGET_ESP32
         /* RTC peripheral power domain needs to be kept on to keep SAR ADC related configs during sleep */
         esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
        #endif
        ulp_is_main_cpu_wake = 1;
        start_ulp_program();
    } else {
       // at this point, we know the powering up is actually wake up from deep sleep
       // so do nothing about ULP program
       // it works all the time and variable stored in RTC memory are here all the time

        printf("Wakeup from deep sleep\n");
        printf("ULP did %"PRIu32" measurements since last reset\n", ulp_sample_counter & UINT16_MAX);
        printf("Thresholds:  low=%"PRIu32"  high=%"PRIu32"\n", ulp_low_thr, ulp_high_thr);
        ulp_last_result &= UINT16_MAX;
        printf("Value=%"PRIu32" was %s threshold\n", ulp_last_result,ulp_last_result < ulp_low_thr ? "below" : "above");
    }

    // here we initialize and start periodic timer
    // which will monitor results from ULP AD converter
   
    timer_config_and_install();

    while(1){
      // here is your main loop
    } 
}

static void init_ulp_program(void)
{
    esp_err_t err = ulp_load_binary(0, ulp_main_bin_start,
            (ulp_main_bin_end - ulp_main_bin_start) / sizeof(uint32_t));
    ESP_ERROR_CHECK(err);

    ulp_adc_cfg_t cfg = {
        .adc_n    = EXAMPLE_ADC_UNIT,
        .channel  = EXAMPLE_ADC_CHANNEL,
        .width    = EXAMPLE_ADC_WIDTH,
        .atten    = EXAMPLE_ADC_ATTEN,
        .ulp_mode = ADC_ULP_MODE_FSM,
    };

    ESP_ERROR_CHECK(ulp_adc_init(&cfg));

    ulp_low_thr = EXAMPLE_ADC_LOW_TRESHOLD;
    ulp_high_thr = EXAMPLE_ADC_HIGH_TRESHOLD;

    /* Set ULP wake up period to 1000000us = 1s */
    ulp_set_wakeup_period(0, 1000000);

#if CONFIG_IDF_TARGET_ESP32
    /* Disconnect GPIO12 and GPIO15 to remove current drain through
     * pullup/pulldown resistors on modules which have these (e.g. ESP32-WROVER)
     * GPIO12 may be pulled high to select flash voltage.
     */
    rtc_gpio_isolate(GPIO_NUM_12);
    rtc_gpio_isolate(GPIO_NUM_15);
#endif // CONFIG_IDF_TARGET_ESP32

    esp_deep_sleep_disable_rom_logging(); // suppress boot messages
}

static void start_ulp_program(void)
{
    /* Reset sample counter */
    ulp_sample_counter = 0;

    // program in ULP is modified such way
    // that once started it works in infinity loop all the time
    // regrdles the MAIN CORES are in deep sleep or not.
    // Since ULP consumes exrtremaly low current idea is too keep
    // it works all the time until real reset or real powering up happens
    esp_err_t err = ulp_run(&ulp_entry - RTC_SLOW_MEM);
    ESP_ERROR_CHECK(err);
}

Code: Select all

idf_component_register(SRCS "ulp_adc_example_main.c"
                    INCLUDE_DIRS ""
                    REQUIRES soc nvs_flash ulp driver esp_adc esp_timer)
#
# ULP support additions to component CMakeLists.txt.
#
# 1. The ULP app name must be unique (if multiple components use ULP).
set(ulp_app_name ulp_${COMPONENT_NAME})
#
# 2. Specify all assembly source files.
#    Files should be placed into a separate directory (in this case, ulp/),
#    which should not be added to COMPONENT_SRCS.
set(ulp_s_sources "ulp/adc.S")
#
# 3. List all the component source files which include automatically
#    generated ULP export file, ${ulp_app_name}.h:
set(ulp_exp_dep_srcs "ulp_adc_example_main.c")
#
# 4. Call function to build ULP binary and embed in project using the argument
#    values above.
ulp_embed_binary(${ulp_app_name} "${ulp_s_sources}" "${ulp_exp_dep_srcs}")