[Partage] Boutons Poussoirs

Bonjour

Dans la série “petites librairies en français et simples d’usage à destination des débutants”, voici la nouvelle version de ma librairie pour gérer facilement des boutons poussoirs.

Après téléchargement et installation, les exemples d’utilisation sont disponibles directement depuis l’IDE Arduino

Header :

//Librairie Arduino pour la gestion de boutons poussoirs
//Version 4.1
//
//Cablage : pin---BP---GND
//
//6 octets alloués en RAM pour un simpleBouton
//Les fonctions non utilisées sont dégagées à la compilation
//
//Bricoleau 2018

#ifndef simpleBouton_h
#define simpleBouton_h

#include <Arduino.h>

class simpleBouton
{
  public :
    //Constructeur
    simpleBouton(uint8_t pin, uint8_t delai_debounce_ms = 20);

    //Lecture hardware et mise à jour des variables internes
    //Idéalement, doit être appelée à chaque début de loop()
    bool actualiser(); //retourne true si l'état du bouton a changé

    //Informations de statut
    bool estEnfonce() const;
    bool estRelache() const;
    bool estStable() const;
    uint8_t pin() const;

    bool vientDEtreEnfonceOuRelache() const               {return !estStable();}
    bool vientDEtreEnfonce() const                        {return vientDEtreEnfonceOuRelache() && estEnfonce();}
    bool vientDEtreRelache() const                        {return vientDEtreEnfonceOuRelache() && estRelache();}

    //Informations de durée
    uint32_t dureeEtatActuel() const                      {return millis() - this->_millis_etat_actuel;}
    uint32_t dureeEnfonce() const                         {return estEnfonce() ? dureeEtatActuel() : 0;}
    uint32_t dureeRelache() const                         {return estRelache() ? dureeEtatActuel() : 0;}

    bool estStableDepuisAuMoins(uint32_t delai_ms) const  {return dureeEtatActuel() >= delai_ms;}
    bool estEnfonceDepuisAuMoins(uint32_t delai_ms) const {return estStableDepuisAuMoins(delai_ms) && estEnfonce();}
    bool estRelacheDepuisAuMoins(uint32_t delai_ms) const {return estStableDepuisAuMoins(delai_ms) && estRelache();}

    bool estStableDepuisPlusDe(uint32_t delai_ms) const   {return dureeEtatActuel() > delai_ms;}
    bool estEnfonceDepuisPlusDe(uint32_t delai_ms) const  {return estStableDepuisPlusDe(delai_ms) && estEnfonce();}
    bool estRelacheDepuisPlusDe(uint32_t delai_ms) const  {return estStableDepuisPlusDe(delai_ms) && estRelache();}

    uint8_t delaiDebounceMs() const                       {return this->_delai_debounce_ms;}

    //Et pour un usage minimaliste :
    operator bool() {return actualiser() && estEnfonce();}

  private :
    uint8_t  _statut, _delai_debounce_ms;
    uint32_t _millis_etat_actuel;
};

class boutonAction
{
  public :
    boutonAction(uint8_t pin, uint8_t delai_debounce_ms = 20);

    void attacher(void (*clic)(), void (*clicClic)() = NULL, void (*clicClicClic)() = NULL);

    static uint16_t delai_max_interclic_ms;

    void activerRepetition(uint32_t (*delaiRepetitionPersonnalise)(uint32_t) = NULL);
    void desactiverRepetition();

    void actualiser();

  private :
    simpleBouton bouton;
    void (*_simpleClic)();
    void (*_doubleClic)();
    void (*_tripleClic)();
    uint8_t _statut;
    uint32_t _millis_dernier_clic, _millis_derniere_action;
    uint32_t (*_delaiRepetition)(uint32_t);
    //Prendre exemple sur la fonction ci-dessous dans le cpp pour définir une fonction personnalisée
    static uint32_t _delaiRepetitionParDefaut(uint32_t duree_enfonce);
};

#endif

V3 du 16/03/2018

Pour les cas d’utilisation les plus simples, vous pouvez à présent utiliser le bouton comme un simple booléen !
Impossible de faire plus facile à utiliser :slight_smile:

Par exemple :

#include "simpleBouton.h"
simpleBouton boutonTest(7);

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (boutonTest) Serial.println("Detection appui bouton");
}

V4 du 03/11/2018

Ajout d’une classe boutonAction, qui permet d’associer une fonction à exécuter au clic sur un bouton.

Cette classe permet aussi de gérer le double ou le triple clic avec une fonction associée à chacun.
Le délai maximum entre deux clics est par défaut à 500 ms.

La répétition est activable sur un appui long (comme une touche d’un clavier d’ordi).
Par défaut, la cadence de répétition est progressive, mais il est possible de faire prendre en compte une fonction de cadencement personnalisée.

Et bien sûr, la répétition fonctionne aussi avec les clics multiples :slight_smile:

Les exemples 11 à 15 illustrent les nouvelles possibilités.
Je recommande particulièrement l’exemple 14 : réglage d’une valeur via un seul bouton.

V4.1 du 16/11/2018

Compatibilité ESP8266 (testé sur wemos)

Attention : les exemples fournis sont basés sur les numéros de pin d’une arduino uno, à modifier pour fonctionner sur un wemos. Par exemple :

const uint8_t pin_bouton = 3;//cablage pin---BP---GND

doit être modifié en

const uint8_t pin_bouton = D3;//cablage pin---BP---GND

V4.2 du 07/08/2020

Suppression du warning parasite lors de la compilation

simpleBouton.zip (15.8 KB)

Conseil :

Prenez une carte arduino uno, cablez deux boutons poussoirs : pin7-----BP1-----GND pin8-----BP2-----GND

Et parcourez les 11 exemples fournis.

Un grand merci pour cette librairie... super pratique et efficace !

Par contre j'ai parfois un message d'erreur... mais ça finit par passer quand même...

const uint8_t masque_pin_simpleBouton = ~(masque_etat_simpleBouton | masque_chgt_simpleBouton);

Quel message d'erreur ?

Si celui-ci n'est pas systématique, cela fait plutôt penser à un bug de l'IDE Arduino, dont les dernières versions sont truffées. Quelle version de l'IDE ?

Ce message :

const uint8_t masque_pin_simpleBouton = ~(masque_etat_simpleBouton | masque_chgt_simpleBouton);

Version 1.6.8

Ça ce n'est pas un message d'erreur mais juste une ligne de code de la bibliothèque

Publication de la version V3

Voir le descriptif en haut de ce topic

Ta librairie fonctionne merveilleusement bien ! Incroyable de simplicité et avec des exemples très complets.

C'est du super boulot je te remercie du partage !

Merci ça fait plaisir d'avoir un avis en retour

Ce qui reste malheureusement assez rare quand je relis ce qui est écrit ci-dessus, surtout au regard des plus de 400 téléchargements de la version précédente. Mais bon pas grave :)

Tu trouveras peut-être aussi d'autres partages intéressants dans le lien que j'ai mis en signature.

Effectivement j'ai été surpris du manque de réaction face à la simplicité de ce que tu proposes. Dommage.

Merci pour les autres partages, toujours la même philosophie c'est top !

Merci beaucoup pour le partage. J'ai un prototypage qui bloquait jusqu'à l'intégration du SimpleRTC. Du coup je viens de récupérer SimpleBouton. Avec le transfert des certaines routines en librairies, la prog est beaucoup plus simple. Encore merci.

bravo pour le boulot et le partage

je proposerais éventuellement de changer

  //Initialisation hardware
  pinMode(pin, INPUT);
  digitalWrite(pin, HIGH);

en

  //Initialisation hardware PULLUP
  pinMode(pin, INPUT_PULLUP);

pour être plus à la page avec les dernières versions de l'IDE?

et aussi de mettre une valeur par défaut (15ms ou 20ms) pour delai_debounce_ms dans le constructeur ce qui permettrait d'instancier le bouton juste avec son N° de pin pour les débutants qui n'auraient pas d'idée de ce qu'est une valeur raisonnable pour les boutons qu'on trouve couramment sur le marché

A mon avis la "cuisine interne"

const uint8_t bit_etat_simpleBouton = 7;
const uint8_t bit_chgt_simpleBouton = bit_etat_simpleBouton - 1;
const uint8_t masque_etat_simpleBouton = 1 << bit_etat_simpleBouton;
const uint8_t masque_chgt_simpleBouton = 1 << bit_chgt_simpleBouton;
const uint8_t masque_pin_simpleBouton = ~(masque_etat_simpleBouton | masque_chgt_simpleBouton)

n'a pas trop lieu d'être car vous ne pouvez pas dire tiens je prends maintenant les bits 2 et 3 pour les états et les autres bits pour le N° de pin.. le code a besoin des bits de poids faible dédiés au N° de pin, donc autant mettre

const uint8_t masque_etat_simpleBouton = B10000000;
const uint8_t masque_chgt_simpleBouton = B01000000;
const uint8_t masque_pin_simpleBouton  = B00111111;

ce serait directement plus lisible non? (même si ça ne change rien effectivement à la mémoire utilisée)

Hello

Merci pour la revue

Oui pour le INPUT_PULLUP, effectivement c'était resté en "vieux code". Je le modifierai lorsque je mettrai en ligne une nouvelle version.

Valeur par défaut pour le debounce dans le constructeur => elle y est déjà (dans le header)

"Cuisine interne" du .cpp : y a pas grande différence. J'aime bien ma recette, qui ne change de toute manière rien au résultat compilé. C'est vrai que c'est moins lisible, mais voyons-y le caprice de l'auteur :)

bricoleau: "Cuisine interne" du .cpp : y a pas grande différence. J'aime bien ma recette, qui ne change de toute manière rien au résultat compilé. C'est vrai que c'est moins lisible, mais voyons-y le caprice de l'auteur :)

J'aime bien les caprices de l'auteur - ça fait un peu artiste :)

Valeur par défaut pour le debounce dans le constructeur => elle y est déjà (dans le header)

ah oui j'avoue ne pas avoir lu le header en détail! (et c'est le bon endroit pour la déclaration)

Merci beaucoup pour ce partage! Un membre du forum m'a renvoyé vers ce lien et son utilisation m'a totalement facilité la tâche. Débutante d'arduino, je ne suis pas à l'aise avec les boutons et je suis ravie d'avoir pu utiliser cette alternative! :)

merci pour le partage, en tant que débutant tomber là dessus c'est bonheur !

Merci pour cette librairie francophone. Est-il possible de gérer simplement un double click voir un triple click sur un bouton ?

Bonjour

En l'état cette bib ne gère pas les actions associées aux appuis bouton. Mais elle dispose de toutes les primitives permettant d'ajouter une surcouche dans ce sens.

J'avais déjà commencé à écrire cette surcouche. Je peux la mettre en ligne d'ici demain.

Oui je veux bien, rien d'urgent ...

Et voilà

V4 du 03/11/2018

Ajout d'une classe boutonAction, qui permet d'associer une fonction à exécuter au clic sur un bouton.

Cette classe permet aussi de gérer le double ou le triple clic avec une fonction associée à chacun. Le délai maximum entre deux clics est par défaut à 500 ms.

La répétition est activable sur un appui long (comme une touche d'un clavier d'ordi). Par défaut, la cadence de répétition est progressive, mais il est possible de faire prendre en compte une fonction de cadencement personnalisée.

Et bien sûr, la répétition fonctionne aussi avec les clics multiples :)

Les exemples 11 à 15 illustrent les nouvelles possibilités. Je recommande particulièrement l'exemple 14 : réglage d'une valeur via un seul bouton.

Retourner en début de topic pour accéder au téléchargement