sorry for bringing up this old thread, but it fits best to my question. Thanks to you guys to provide ULP pulse count example. I tried it out and it worked like expected. However, I need to count two GPIOs instead of just one meaning I need to count two distinct inputs while ESP32 sleeps. It should wake up based on timer and read out the counting of ULP.
ESP32 code is not that hard to me but I'm struggling with ULP assembler code. I tried to understand what happens in the example but there are a few things I don't understand. I commented the example with // and capital letters.
Especially the part where you read GPIO (read_done) and check the edge (changed) I don't understand completely.
May I ask you guys to enlight me. One way for me is just to copy & paste the jump targets to something like read_done_a, read_done_b but this might not be the best solution. Last time I had to develop assembler was before decades, so it would be great if someone has a better solution.
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 // LOAD ADDRESS OF VARIABLE IO_NUMBER INTO R3
ld r3, r3, 0 // READ LOWER BYTES OF R3 INTO R3, MEANS READ VALUE OF VARIABLE IO_NUMBER INTO R3
/* 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 // MOVE VALUE OF IO_NUMBER TO R0
jumpr read_io_high, 16, ge // IF IO_NUMBER(R0) > 16 JUMP TO READ FURTHER
/* Read the value of lower 16 RTC IOs into R0 */
READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16) // READ GPIO PINS 0-15 INTO R0
rsh r0, r0, r3 // RIGHT SHIFT WHAT? R3 STILL CONTAINS NUMBER OF IO PIN
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 // R0 CONTAINS PIN STATUS OF ALL PINS, AFTER AND, IT CONTAINS ONLY STATUS OF ONE PIN?
/* State of input changed? */
move r3, next_edge // LOAD ADDRESS OF VARIABLE NEXT_EDGE
ld r3, r3, 0 // LOAD VALUE OF NEXT_EDGE TO R3
add r3, r0, r3 // WHY/WHAT HAPPENS HERE?
and r3, r3, 1 // WHY/WHAT HAPPENS HERE?
jump changed, eq // JUMP TO CHANGED, IF PREVIOUS AND RETURNS TRUE
/* 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
