[SOLVED]ULP count example with Arduino IDE
Posted: Tue Sep 24, 2019 6:55 pm
Hello to all,
I need a counter while ESP is in deep sleep. I've found the ULP count example, which seems to work with ESP-IDF (not tested by me).
I tried to convert this example to Arduino IDE, because I'm more familiar with that. Thanks to duff2013, we can upload ULP code with Arduino IDE. I've tested it with the examples he provides and it worked.
However, I'm unable to get it work. To simplify things, I've dropped deep sleep for first tests and also no storage to NVS. Because I've heared that sometimes GPIO0 doesn't work correctly with button on board, I've switched over to GPIO2 (RTC_IO_12).
Everything compiles and uploads without errors but for some reason, ULP simple doesn't count anything. Because I've took this example from official ESP32 examples at git, I assume assembler code should work.
Does anyone know what I've missing here?
ESP Code
Assembler code for ULP
ulp_main.h
I need a counter while ESP is in deep sleep. I've found the ULP count example, which seems to work with ESP-IDF (not tested by me).
I tried to convert this example to Arduino IDE, because I'm more familiar with that. Thanks to duff2013, we can upload ULP code with Arduino IDE. I've tested it with the examples he provides and it worked.
However, I'm unable to get it work. To simplify things, I've dropped deep sleep for first tests and also no storage to NVS. Because I've heared that sometimes GPIO0 doesn't work correctly with button on board, I've switched over to GPIO2 (RTC_IO_12).
Everything compiles and uploads without errors but for some reason, ULP simple doesn't count anything. Because I've took this example from official ESP32 examples at git, I assume assembler code should work.
Does anyone know what I've missing here?
ESP Code
Code: Select all
#include <stdio.h>
#include "esp_sleep.h"
#include "nvs.h"
#include "nvs_flash.h"
#include "soc/rtc_cntl_reg.h"
#include "soc/sens_reg.h"
#include "soc/rtc_periph.h"
#include "driver/gpio.h"
#include "driver/rtc_io.h"
#include "esp32/ulp.h"// Must have this!!!
// include ulp header you will create
#include "ulp_main.h"// Must have this!!!
// Custom binary loader
#include "ulptool.h"// Must have this!!!
// Unlike the esp-idf always use these binary blob names
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_run_ulp(uint32_t usec);
static void update_pulse_count(void);
void setup() {
Serial.begin(115200);
delay(1000);
esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
if (cause != ESP_SLEEP_WAKEUP_ULP) {
printf("Not ULP wakeup, initializing ULP\n");
init_run_ulp(20 * 1000); // 20 msec
} else {
printf("ULP wakeup, saving pulse count\n");
update_pulse_count();
}
printf("Entering deep sleep\n\n");
// ESP_ERROR_CHECK( esp_sleep_enable_ulp_wakeup() );
// esp_deep_sleep_start();
}
void loop() {
delay(1000);
update_pulse_count();
}
static void init_run_ulp(uint32_t usec) {
gpio_num_t gpio_num = GPIO_NUM_2;
// initialize ulp variable
ulp_set_wakeup_period(0, usec);
ulp_debounce_counter = 3;
ulp_debounce_max_count = 3;
ulp_next_edge = 0;
ulp_io_number = rtc_gpio_desc[gpio_num].rtc_num; /* map from GPIO# to RTC_IO# */
printf("PIN %5d\n", ulp_io_number);
ulp_edge_count_to_wake_up = 10;
/* Initialize selected GPIO as RTC IO, enable input, disable pullup and pulldown */
rtc_gpio_init(gpio_num);
rtc_gpio_set_direction(gpio_num, RTC_GPIO_MODE_INPUT_ONLY);
rtc_gpio_pulldown_dis(gpio_num);
rtc_gpio_pullup_dis(gpio_num);
rtc_gpio_hold_en(gpio_num);
/* Disconnect GPIO12 and GPIO15 to remove current drain through
* pullup/pulldown resistors.
* GPIO12 may be pulled high to select flash voltage.
*/
rtc_gpio_isolate(GPIO_NUM_12);
rtc_gpio_isolate(GPIO_NUM_15);
// use this binary loader instead
esp_err_t err = ulptool_load_binary(0, ulp_main_bin_start, (ulp_main_bin_end - ulp_main_bin_start) / sizeof(uint32_t));
// ulp coprocessor will run on its own now
err = ulp_run((&ulp_entry - RTC_SLOW_MEM) / sizeof(uint32_t));
}
static void update_pulse_count(void)
{
/* ULP program counts signal edges, convert that to the number of pulses */
uint32_t pulse_count_from_ulp = (ulp_edge_count & UINT16_MAX) / 2;
/* In case of an odd number of edges, keep one until next time */
ulp_edge_count = ulp_edge_count % 2;
printf("Pulse count from ULP: %5d\n", pulse_count_from_ulp);
}
Code: Select all
/* ULP Example: pulse counting
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.
This file contains assembly code which runs on the ULP.
ULP wakes up to run this code at a certain period, determined by the values
in SENS_ULP_CP_SLEEP_CYCx_REG registers. On each wake up, the program checks
the input on GPIO0. If the value is different from the previous one, the
program "debounces" the input: on the next debounce_max_count wake ups,
it expects to see the same value of input.
If this condition holds true, the program increments edge_count and starts
waiting for input signal polarity to change again.
When the edge counter reaches certain value (set by the main program),
this program running triggers a wake up from deep sleep.
*/
/* 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/rtc_io_reg.h"
#include "soc/soc_ulp.h"
/* Define variables, which go into .bss section (zero-initialized data) */
.bss
/* Next input signal edge expected: 0 (negative) or 1 (positive) */
.global next_edge
next_edge:
.long 0
/* Counter started when signal value changes.
Edge is "debounced" when the counter reaches zero. */
.global debounce_counter
debounce_counter:
.long 0
/* Value to which debounce_counter gets reset.
Set by the main program. */
.global debounce_max_count
debounce_max_count:
.long 0
/* Total number of signal edges acquired */
.global edge_count
edge_count:
.long 0
/* Number of edges to acquire before waking up the SoC.
Set by the main program. */
.global edge_count_to_wake_up
edge_count_to_wake_up:
.long 0
/* RTC IO number used to sample the input signal.
Set by main program. */
.global io_number
io_number:
.long 0
/* Code goes into .text section */
.text
.global entry
entry:
/* Load io_number */
move r3, io_number
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
/* State of input changed? */
move r3, next_edge
ld r3, r3, 0
add r3, r0, r3
and r3, r3, 1
jump changed, eq
/* Not changed */
/* Reset debounce_counter to debounce_max_count */
move r3, debounce_max_count
move r2, debounce_counter
ld r3, r3, 0
st r3, r2, 0
/* End program */
halt
.global changed
changed:
/* Input state changed */
/* Has debounce_counter reached zero? */
move r3, debounce_counter
ld r2, r3, 0
add r2, r2, 0 /* dummy ADD to use "jump if ALU result is zero" */
jump edge_detected, eq
/* Not yet. Decrement debounce_counter */
sub r2, r2, 1
st r2, r3, 0
/* End program */
halt
.global edge_detected
edge_detected:
/* Reset debounce_counter to debounce_max_count */
move r3, debounce_max_count
move r2, debounce_counter
ld r3, r3, 0
st r3, r2, 0
/* Flip next_edge */
move r3, next_edge
ld r2, r3, 0
add r2, r2, 1
and r2, r2, 1
st r2, r3, 0
/* Increment edge_count */
move r3, edge_count
ld r2, r3, 0
add r2, r2, 1
st r2, r3, 0
/* Compare edge_count to edge_count_to_wake_up */
move r3, edge_count_to_wake_up
ld r3, r3, 0
sub r3, r3, r2
/* jump wake_up, eq */
/* Not yet. End program */
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, end program */
wake
halt
Code: Select all
/*
Put your ULP globals here you want visibility
for your sketch. Add "ulp_" to the beginning
of the variable name and must be size 'uint32_t'
*/
#include "Arduino.h"
extern uint32_t ulp_entry;
extern uint32_t ulp_changed;
extern uint32_t ulp_edge_detected;
extern uint32_t ulp_wake_up;
extern uint32_t ulp_next_edge;
extern uint32_t ulp_debounce_counter;
extern uint32_t ulp_debounce_max_count;
extern uint32_t ulp_edge_count;
extern uint32_t ulp_edge_count_to_wake_up;
extern uint32_t ulp_io_number;
) - but I would like to know for future projects what is wrong (or what am I doing wrong).