Pushbutton event based approach - managing two events failed

[javbru01]

The below code is not working correctly since the push button after the interrupt still bounce in certain cases and increases the counter, e.g. under then the mechanical switch releases. (I will describe later the application)

import utime
import framebuf
from machine import Pin, SoftI2C
from time import sleep_ms, sleep
import ssd1306
import neopixel
import sys
import freesans20
import writer

import config

print("main igen")
DEBOUNCING = 500
# this function gets called every time the button is pressed
def button_pressed_handler(pin):
    global button_presses, last_time, color, DEBOUNCING
    new_time = utime.ticks_ms()
    print("i am inside function "+ str(new_time)+ " - " + str(last_time) + " = " + str(new_time - last_time))
    # if it has been more that 1/5 of a second since the last event, we have a new event
    if (new_time - last_time) > DEBOUNCING: 
        print("i am inside the if in the function " + str(new_time)+ " - " + str(last_time) + " = " + str(new_time - last_time))
        button_presses +=1
        color.reverse()
        new_time = utime.ticks_ms()
        last_time = new_time

button_presses = 0 # the count of times the button has been pressed
last_time = 0 # the last time we pressed the button

builtin_led = Pin(config.LED_PIN, Pin.OUT)
n = neopixel.NeoPixel(builtin_led, 1)

# using default address 0x3C for the display
i2c = SoftI2C(sda=Pin(config.DISPLAY_SDA_PIN), 
            scl=Pin(config.DISPLAY_SCL_PIN))

display = ssd1306.SSD1306_I2C(128, 64, i2c)

# the inbuilt button of the M5stampC3 (button gpio 3)
# button_pin = Pin(3,Pin.IN, Pin.PULL_UP)
button_pin = Pin(4,Pin.IN, Pin.PULL_UP)

color = [0, 0, 255]


# now we register the handler function when the button is pressed
button_pin.irq(trigger=Pin.IRQ_FALLING, handler = button_pressed_handler)


# Display section: it is to small and fonts are small so we want to generate left-rigth numbers

# Use fontwriter from the writer instance to create a custom fonts
# https://blog.miguelgrinberg.com/post/micropython-and-the-internet-of-things-part-vi-working-with-a-screen

font_writer = writer.Writer(display, freesans20)

#


# display Initialize
        
display.fill(0)
display.rect(0, 0, 128, 64, 1)
# display.line(64, 0, 64, 64, 1)

# textlen = font_writer.stringlen('0')
# font_writer.set_textpos(64 + (64 - textlen), 30)
# font_writer.printstring('0')

# textlen = font_writer.stringlen('0')
# font_writer.set_textpos(64 + (64 - textlen) // 2, 30)
# font_writer.printstring('0')

display.show()
sleep_ms(50)

# This is for only printing when a new button press count value happens
old_presses = 0
while True:
    #print("I am looping")
# only print on change in the button_presses value
    if  button_presses != old_presses:

        # To display the counters
        print(str(button_presses))
    
        text = (str(button_presses))
        textlen = font_writer.stringlen(text)
        font_writer.set_textpos((96 - textlen), 30)
        font_writer.printstring(text)
        
        display.show()
        #sleep_ms(50)

        n[0] = (color[0], color[1], color[2])
        n.write()
        old_presses = button_presses
    sleep_ms(100)
    # else:                       # if push_button not pressed
    #     n[0] = (0, 0, 255)
    #     n.write()
    #     sleep_ms(100) 

I have tried several debouncing techniques but still get some odd results when testing the app. Some times the bouncing when releasing the pushbutton increases the value of the counter (means entering the definition on the irq handler).

Anyway, I decided to test the uasyncio script for the switch driver. This works like a charm.
However, I am not sure if my code is efficient or not. Here is a sample:

import utime
import framebuf
from machine import Pin, SoftI2C
from time import sleep_ms, sleep
import ssd1306
import neopixel
import sys
import freesans20
import writer
import uasyncio as asyncio
from primitives import Switch
import json

import config

# function save on a JSON file for backup data
def save_counter_state(state_Count,state_LED):
    jsonData["stateCounter"]=state_Count
    jsonData["stateLED"]=state_LED
    try:
        with open('savedata.json', 'w') as f:
            json.dump(jsonData, f)
    except:
        print("Could not save the counter state variable.")

# Reset function to clear data and start again
def button_reset_handler(pin):
    global button_reset, button_presses, color
    print("we are reseting")
    button_presses = 0
    color = [0, 0, 255]
    # Initialize display

    display.fill(0)
    display.rect(0, 0, 128, 64, 1)
    display.show()
    sleep_ms(50)

#open JSON file and load Counter state state
try:
    with open('savedata.json', 'r') as f:
        data = json.load(f)
        button_presses = data["stateCounter"]
        # led_state= data["stateCounter"]
        color = data["stateLED"]
except:
    button_presses = 0
    color = [0, 0, 255]
    print("Counter state variable not found. Starting with counter on 0 and Blue LED color.")

# color = [0, 0, 255] # Intialize color to the program

jsonData = {"stateCounter": button_presses,
            "stateLED": color}
# In M5Stanp an RRGB LED is build in with numpy addressing
builtin_led = Pin(config.LED_PIN, Pin.OUT)
n = neopixel.NeoPixel(builtin_led, 1)

button_presses = 0 # the count of times the button has been pressed
last_time = 0 # the last time we pressed the button

builtin_led = Pin(config.LED_PIN, Pin.OUT)
n = neopixel.NeoPixel(builtin_led, 1)

# using default address 0x3C for the display In am using in this project an SSD1315 from Groove
i2c = SoftI2C(sda=Pin(config.DISPLAY_SDA_PIN), 
              scl=Pin(config.DISPLAY_SCL_PIN))
 
display = ssd1306.SSD1306_I2C(128, 64, i2c)

# the inbuilt button of the M5stampC3 (button gpio 3)
# button_pin = Pin(3,Pin.IN, Pin.PULL_UP)
# button_pin = Pin(4,Pin.IN, Pin.PULL_UP)

color = [0, 0, 255]
# Use writer from some web source and created I think by peterhinch
font_writer = writer.Writer(display, freesans20)

# display Initialize
        
display.fill(0)
display.rect(0, 0, 128, 64, 1)

display.show()
sleep_ms(50)

button_reset = Pin(config.RESET, Pin.IN, Pin.PULL_UP)
print("button reset: ")
print(button_reset.value())

button_reset.irq(trigger=Pin.IRQ_RISING, handler = button_reset_handler)

# This is for only printing when a new button press count value happens
old_presses = 0

async def close_switch():
    await asyncio.sleep(0.04)

async def open_switch():
    global button_presses, old_presses
    button_presses += 1
    await asyncio.sleep(0.04)


async def main():
    global old_presses, stop_flag, button_presses
    
    pin = Pin(4, Pin.IN, Pin.PULL_UP)                    # 
    sw = Switch(pin)

    print(button_presses)
    while True:
        sw.open_func(open_switch)
        await asyncio.sleep(0.01)
        if  button_presses != old_presses:

            # To display the counters
            print(str(button_presses))
        
            text = (str(button_presses))
            textlen = font_writer.stringlen(text)
            font_writer.set_textpos((96 - textlen), 30)
            font_writer.printstring(text)
            
            display.show()

            # Save in the JSON file
            save_counter_state(button_presses, color)


            n[0] = (color[0], color[1], color[2])
            n.write()
            old_presses = button_presses

    asyncio.run(main())

I am using an M5stamp-c3 based on an esp32-c3 microcontroller. The inbuilt functions are explained on the code.
While are different implemented functions (to save an JSON script to check some values in case of power off the device, or the change of LED color), my main purpouse is to make a stable counter.

Using the coros can be helpful in next step, that is to add a new switch and to time events between switches. In this case I am having issues adding a second switch and my timers are never updating (I think becuse the trigger event for the second switch is not getting activated.)

I would love some help and maybe giving me some help to achieve the code.

PD: I was to rushy when say that the code is working fine. The JSON is not being saving the values in the data dump. I need to check tomorrow (time reason). But will appreciate any help on it.

[peterhinch]

Congratulations on using asyncio: it is the best approach. You might like to look at the tutorial where you will see that MicroPython has a sleep_ms method. Calling sleep_ms(40) is more efficient than sleep(0.04) because floats involve RAM allocation.

Some comments on your code. The open_switch method need not be asynchronous. The following will work equally well:

def open_switch():
    global button_presses
    button_presses += 1

Secondly there is no need to repeatedly set the callback

    print(button_presses)
    sw.open_func(open_switch)  # Assign the callback outside the loop
    while True:
        await asyncio.sleep(0)  # A sleep of 0 is an entirely valid way to let other tasks be scheduled
        # Rest of code

[javbru01]

Thank you @peterhinch . Certainly I need to read and learn more about it. I found the tutorials really helpful to start this project.
I implemented now the changes and can notify that it works with two switches as with one. No bouncing and I avoided to use a capacitor. Great implementation.

I know that the final solution has not been designed neither thought to be using asynchronous implementation. Actually I am just learning by doing but now I think a sketch and better general description can help to create a more efficient code. However, reality strikes and I am sitting on deadlines. Good news I achieve the goal using the switches and displaying on a screen (all what my colleague/user required).

Now (and this is outside the scope of my delivery, but I think equally valuable in the project) I would like to implement timers that can run and count the timestamp between events, e.g., the time between a pushing and releasing the button. Or even better,the mean value of that sequence updated every time the event happen.

I could imaging that open_func and open_close could be combine to achieve it, but is it a better way to do so? to collect such statistics?

Thanks!
/J

[javbru01]

@peterhinch I have another question to seek better understanding. In your previous comment you explained that there is no need set the callback inside the while loop in the main. Reading carefully I understand that:

1. The Switch method inside the asynchronous main will yield the cpu time to the next coroutine. Will this mean that only during the time the await function execution other coroutines will have a chance to yield?

2. What will happens if I create a second switch but just one await in the loop? for example:

        pin1 = Pin(4, Pin.IN, Pin.PULL_UP)
        pin2 = Pin(7, Pin.IN, Pin.PULL_UP)
        sw2 = Switch(pin2)
        sw2.open_func(open_switch2)
        
        sw1 = Switch(pin1)
        sw1.open_func(open_switch1)
        
   
        # print("This is button 1 pressed ntimes: ",button_presses1) # button_presses1 is the counter for the switch 1
        # print("This is button 2 pressed ntimes: ",button_presses2) # button_presses2 is the counter for the switch 2
        while True:
            await asyncio.sleep_ms(10)
   

   Because I can see that it works to count both switches and the rest of the code works as expected (save data in the dump file, reset when requires, led switches state to red or blue when need it), so just wondering how this is implemented at the machine level.

[peterhinch]

The above code fragment is fine.

The way asyncio works is that when a task issues await asyncio.sleep(t) the scheduler passes control to another task. The Switch driver has a task which periodically checks the state of the Pin. When a change takes place the callback runs. Between each check of the Pin the task issues await asyncio.sleep(t) which allows another task to run. This means that both switches and your main loop appear to run concurrently. This is known as yielding to the scheduler.

It is therefore important that any coroutine you write must periodically issue await asyncio.sleep(t) otherwise the other tasks won't get to run.

You might like to look at the relevant Switch code where you will see the periodic yield to the scheduler.

There are various ways to time the press duration. One way is to use events. Create a coro like this

async def time_switch(sw):
    while True:
        await sw.close.wait()  # These await statements yield to the scheduler
        ts = time.ticks_ms()
        sw.close.clear()
        await sw.open.wait()
        tclosed = ticks_diff(ticks_ms(), ts)
        sw.open.clear()
        # Do something with tclosed

You'll find the methods in the time module. The passed Switch needs to be set up in event mode.

[javbru01]

Hi again,

I am seeking once more for some help.

I am now struggling with implementing a function that read an event and wait for the same event execution under a time window. If execution happens outside the time window, the event should not be registered in the main.

More explicit:
I have a switch (similar to those implemented before) but now any other event should pause between 2,5 seconds and 5 seconds, while waiting for the same switch to be trigger once more. In this case all other switches should not be listened, no matter if trigger or not. Within this time windows, only should happen the same initial switch that trigger the event Switch.

Since the default of the Switch driver is working as expected I have not modify anything from my original code and I have use the open_func that has as an argument the call of a function. Inside the function the incremental counter is the only return that happens.

button_presses2 = 0 #Call the definition, increase the counter
def open_switch2():
    global button_presses2
    button_presses2 +=1
    #...
async def main():
    global old_presses2, button_presses2

    pin2 = Pin(7, Pin.IN, Pin.PULL_UP)
    sw2 = Switch(pin2)
    sw2.open_func(open_switch2)
    # Execute the main while waiting for a signal from swtiches
    while True:
        await asyncio.sleep_ms(10)
    
        if  button_presses1 != old_presses1:

            # To display the counters
        print(button_presses1)

        old_presses1 = button_presses1

asyncio.run(main())

In this above example I would like to implement a new function, where the counter only returns if the switch 2 presses twice within the time window (2,5 seconds and 5 seconds) otherwise counter should be the same.

I was reading the part on Delay_ms and wait_for but I am not sure how to implement such in my code.

Do you have any suggestion? Thanks in advance.

[peterhinch]

I'm not 100% sure I understand your requirement but here is my attempt:

from primitives import Delay_ms
d25 = Delay_ms(duration=2500)
d5 = Delay_ms(duration=5000)
def open_switch2():
    global button_presses2
    if not d5.running():  # First press
        d5.trigger()
        d25.trigger()
    else:  # Second press
        if not d25.running():  # In the time window
            # Do whatever
        d25.stop()   # After 2nd press it may be wise to stop the timers in case another press occurs
        d5.stop()

[javbru01]

Thanks once more. That is exactly what I was looking for.

I first solve it using utime inside the function, but I was wondering how to use it with Delay_ms or Event primitives.

I also attempted with Delay, but never got to work the window function and it is because I uses some part of the example in the documentation with out taking out the loop inside the example.

This is working as expected. Thanks again.

/J