Bouton et "debouncing"

L'implémentation du debouncing (anti-rebond) pour un bouton dans un projet MicroPython avec une Raspberry Pi Pico est essentielle pour éviter les lectures multiples dues aux rebonds mécaniques du bouton. Voici une version améliorée du code précédent avec une logique de debouncing.

Le debouncing

Le "debouncing" (anti-rebond) est une technique utilisée pour gérer les signaux instables provenant de dispositifs comme les boutons poussoirs et les interrupteurs dans les systèmes électroniques, particulièrement les microcontrôleurs. Lorsque vous appuyez sur un bouton ou basculez un interrupteur, vous pourriez vous attendre à une transition nette d'un état à un autre (par exemple, de OFF à ON), mais en réalité, cela ne se passe pas toujours ainsi.

Pourquoi est-il nécessaire ?

• Rebonds Mécaniques : Les boutons et les interrupteurs mécaniques sont sujets à des "rebonds" lorsqu'ils sont pressés ou relâchés. Au lieu de changer d'état une seule fois, le contact physique à l'intérieur du bouton "rebondit" contre l'autre contact quelques fois très rapidement (en millisecondes) avant de s'arrêter. Cela peut entraîner de multiples lectures de changement d'état pour une seule action physique sur le bouton.

• Signaux Bruités : En plus des rebonds mécaniques, les signaux électriques peuvent être bruités, ce qui peut aussi causer des lectures fausses ou multiples.

Comment fonctionne le Debouncing ?

Il existe deux approches principales pour le debouncing : matérielle et logicielle.

1. Debouncing Matériel :

   • Utilise des composants électroniques (comme des condensateurs et des résistances) pour filtrer le bruit et lisser la transition de signal.
   • Le condensateur peut absorber les changements rapides de tension (rebonds), permettant seulement aux changements d'état plus lents et stables de passer.

2. Debouncing Logiciel :

   • Implique l'utilisation de techniques de programmation pour filtrer les rebonds.
   • L'idée est de ne pas accepter immédiatement un changement d'état comme valide, mais d'attendre un court délai (le "temps de debouncing") pour s'assurer que l'état reste constant.
   • Si le signal change de nouveau pendant ce délai, le compteur est réinitialisé. Seuls les changements d'état qui perdurent au-delà du délai sont considérés comme valides.

Exemple en MicroPython :

Dans l'exemple suivant avec le Raspberry Pi Pico, le debouncing logiciel a été utilisé. Lorsqu'un changement d'état du bouton est détecté, le programme attend un court délai avant de vérifier à nouveau l'état du bouton. Si l'état a changé pendant ce délai, le changement est ignoré (considéré comme un rebond). Si l'état reste constant, le changement est considéré comme valide.

Le debouncing est essentiel pour obtenir des lectures fiables des boutons et des interrupteurs dans les projets électroniques et de microcontrôleurs.

Code MicroPython avec Debouncing :

from machine import Pin
import utime

# Configuration de la broche pour la LED et le bouton
led = Pin(2, Pin.OUT)
button = Pin(3, Pin.IN, Pin.PULL_DOWN)

led_state = False
last_button_state = 0
last_debounce_time = 0
debounce_delay = 50  # Millisecondes

def toggle_led():
    global led_state
    led_state = not led_state
    led.value(led_state)

# Boucle principale
while True:
    reading = button.value()
    
    if reading != last_button_state:
        last_debounce_time = utime.ticks_ms()

    if (utime.ticks_ms() - last_debounce_time) > debounce_delay:
        if reading != button.value():
            continue

        if reading == 1:
            toggle_led()

    last_button_state = reading
    utime.sleep_ms(10)

Explication du Debouncing :

• last_button_state garde en mémoire l'état précédent du bouton.
• last_debounce_time enregistre la dernière fois que l'état du bouton a changé.
• debounce_delay définit le temps d'attente (en millisecondes) avant de considérer un changement d'état du bouton comme valide.
• Dans la boucle principale, si l'état du bouton change, le temps actuel est enregistré (last_debounce_time).
• On attend que le temps dépasse debounce_delay pour s'assurer que l'état du bouton est stable (pas de rebond).
• Si l'état du bouton est stable et qu'il est appuyé, la fonction toggle_led est appelée pour changer l'état de la LED.
• Un utime.sleep_ms(10) est ajouté à la fin de la boucle pour réduire la charge du processeur.

Ce code gère efficacement les rebonds mécaniques du bouton et assure une interaction fiable avec le bouton. C'est un bon exemple pour enseigner la gestion des entrées numériques et le concept de debouncing dans les projets microcontrôleur.