[Partage] Boutons Poussoirs

Bonjour Je suis en train de tester simpleBouton.h et un tutoriel sur la machien à état qui répond à mes attentes: action quand le bouton est appuyé (et non relâché) Merci à son auteur !

Peux-ton faire un callback avec cette librairie pour faire fonctionner ce code ?

void simpleclick()//http://forum.arduino.cc/index.php?topic=470879.0
{
... // le code à exécuter quand on fait un click sur le bouton
}

void setup() {
  button.attachClick(simpleclick); // on associe le fonction callBack à l'appui sur le bouton
}


void loop() {
  button.tick();  // On vérifie l'état des boutons, ce qui déclenche les appels aux fonctions
}

A priori non car j'ai ce message

'class simpleBouton' has no member named 'attachClick'

Idem avec bouton_aller.attacher(clic);

Comment faire?

//essai state machine du 26/04
#include "simpleBouton.h"
#include 

#define FULLSTEP 4
#define HALFSTEP 8

#define motorPin1  8     // Blue   - 28BYJ48 pin 1
#define motorPin2  9     // Pink   - 28BYJ48 pin 2
#define motorPin3  10    // Yellow - 28BYJ48 pin 3
#define motorPin4  11    // Orange - 28BYJ48 pin 4

#define motorPin5  4     // Blue   - 28BYJ48 pin 1
#define motorPin6  5     // Pink   - 28BYJ48 pin 2
#define motorPin7  6     // Yellow - 28BYJ48 pin 3
#define motorPin8  7     // Orange - 28BYJ48 pin 4

// Define two motor objects
// The sequence 1-3-2-4 is required for proper sequencing of 28BYJ48
AccelStepper stepper_ar(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
AccelStepper stepper_camera(HALFSTEP, motorPin5, motorPin7, motorPin6, motorPin8); 


simpleBouton bouton_aller(2);
simpleBouton bouton_retour(3);

enum {DEMARRE, ALLER, RETOUR} etatCourant;

// ------------------------------------------------------
// Cette fonction installe l'état initial
// ------------------------------------------------------
void demarre()
{
stepper_ar.moveTo(500);//4096 = 2 tours
 stepper_ar.setSpeed(400);
 etatCourant = DEMARRE;
}


// ------------------------------------------------------
// La fonction de call back, appellée automatiquement quand on clique
// ------------------------------------------------------
void clic()
{
  switch (etatCourant) {
    case ARRET: // on était au repos et on a un appui, on allume la verte
      stepper_ar.moveTo(2000);//4096 = 2 tours
      stepper_ar.setSpeed(400);
      etatCourant = ALLER; // on note le nouvel état de notre système
      break;

    case ALLER: // on était led verte allumée et on a un appui, on allume la jaune
      stepper_ar.moveTo(-2000);//4096 = 2 tours
      stepper_ar.setSpeed(-400);
      etatCourant = RETOUR;// on note le nouvel état de notre système
      break;
  }
}


void setup() {

  bouton_aller.attachClick(clic); // on associe le fonction callBack à l'appui sur le bouton
    bouton_retour.attachClick(clic); // on associe le fonction callBack à l'appui sur le bouton
    
  arret();

stepper_ar.setMaxSpeed(700.0);
stepper_ar.setAcceleration(400.0);
stepper_camera.setMaxSpeed(700.0);
stepper_camera.setAcceleration(400.0); 
}



void loop() {
  bouton_aller.actualiser();
  bouton_retour.actualiser();

  stepper_ar.run();
stepper_camera.run();
}

Merci beaucoup !

Regardez la classe boutonAction de la librairie ou mon post #35 pour des évolutions

Bonjour Bricoleau,

tout d'abord je tiens à te remercier de créer des bibliothèques pour simplifier la vie des débutants :)

J'ai testé différents exemples avec deux boutons poussoirs et je remarque que chez moi il se passe l'inverse entre le code et l'action. Je m'explique, si je prend l'exemple numéro 1 : état bouton. Au moment de l'appuie sur mon BP j'ai le message Relache sur le moniteur série et quand je le relache j'ai le message Enfonce.

J'ai ce soucis sur tout les exemples, une idée de ce que je fais de mal ?

J'utilise le Grove Button v1.2 de seedstudio

Merci

Si j'en crois les informations sur le site seeedstudio

This new version of button twig contains one independent button, which are configured with pull-down resistor

le bouton est câblé au plus avec une résistance de tirage à la masse. Donc le branchement est l'inverse de ce que préconise bricoleau dans ses explications. Donc c'est normal que tu trouves un comportement inverse.

J-M-L: Regardez la classe boutonAction de la librairie ou mon post #35 pour des évolutions

Merci ça marche nickel

Je remercie Bricoleau pour sa libraire : je suis cependant étonné qu'elle fonctionne sans utiliser de debounce et resistance J'ai teste de nombreux codes/library de boutons et je devais créer un debounce (hardware c'est plus facile pour moi) pour que les boutons fonctionnent à 100% Avec la librairie de Bricoleau et un circuit ultra basique, nul besoin de quoique ce soit : les boutons lancent les actions à coup certain ! Bizarre...J'ai quand même envie de faire un debounce au cas où...

Qu'en pensez-vous?

Kanter: Je suis cependant étonné qu'elle fonctionne sans utiliser de debounce et resistance J'ai teste de nombreux codes/library de boutons et je devais créer un debounce (hardware c'est plus facile pour moi) pour que les boutons fonctionnent à 100% Avec la librairie de Bricoleau et un circuit ultra basique, nul besoin de quoique ce soit : les boutons lancent les actions à coup certain ! Bizarre...J'ai quand même envie de faire un debounce au cas où...

Qu'en pensez-vous?

Lisez le code en détail :)

Hello

Oui d'où le nom de simpleBouton.h :)

La bibliothèque intègre un debounce logiciel de 20 ms par défaut, valeur que l'on peut changer lors de la déclaration du bouton.

Pour les mordus du fer à souder, il est toujours possible d'ajouter un debounce physique avec une capa en parallèle du bouton. Et dans ce cas, réduire le délai de debounce logiciel, qui ne sert plus à rien.

Bonjour

J'ai regardé le code en question histoire d'être moins bête et je pense avoir trouvé :

  //Filtrage temporel
  uint32_t maintenant = millis();
  if (etat_courant != etat_precedent)
  {
    uint32_t delai = maintenant - this->_millis_etat_actuel;
    if (delai < this->_delai_debounce_ms)
    {
      etat_courant = etat_precedent;
    }
  }

La bibliothèque intègre un debounce logiciel de 20 ms par défaut, valeur que l'on peut changer lors de la déclaration du bouton.

Merci beaucoup ! Je vous donne un karma à tous les deux !

Bonjour Bricoleau, Je viens de m'inscrire sur le forum juste pour te féliciter pour cette bibliothèque ! Moi qui galérais avec un programme avec l'habituelle "Bounce2", en 2 minute grâce a ton travail, mon programme est opérationnel !

Encore Bravo et Merci !

SijoreSSuS

salut

quel exemple dois-je prendre dans l'IDE pour piloter 4 leds à l'aide de 3 boutons ? Chaque bouton allumant sa led correspondante et éteignant les autres, la 4ème led s'allumant ( et éteignant les autres) en pressant deux fois consécutives sur n'importe quel des trois boutons.

Merci pour le partage. Salutations.

Il n’ya Pas d’exemple identique - à vous de le programmer.

Un bouton c’est soit au repos soit appuyé (parfois avec des rebonds entre les 2 positions quand on appuie ou relâche) - à vous de voir quand vous voulez déclenchez l’action - lors de la transition d’appui ou lorsqu’on relâche

Bonjour Bricoleau,

Nouveau venu sur le forum et débutant en montages Arduino, je tenais à vous remercier pour le partage de cette librairie et des exemples fournis. C'est clair et cela fonctionne !

Bonjour, Je remercie aussi Bricoleau pour cette librairie vraiment simple d'utilisation, surtout avec la class boutonAction.

A force de tâtonner, j'ai même découvert qu'on pouvait utiliser cette classe avec plusieurs boutons.

J'ai juste un peu modifié l'exemple 14.

  bouton.attacher(simpleClic, doubleClic, tripleClic);
 // peut être modifié, l'essentiel est que le mot "Clic" soit présent
 bouton1.attacher(Clic1, Clic2, Clic3);

code complet :

#include "simpleBouton.h"

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

boutonAction bouton(pin_bouton);
boutonAction bouton1(pin_bouton1);

void simpleClic() {Serial.println("simple clic");}
void doubleClic() {Serial.println("double clic");}
void tripleClic() {Serial.println("triple clic");}
void Clic1() {Serial.println("bouton1 simple clic");}
void Clic2() {Serial.println("bouton1 double clic");}
void Clic3() {Serial.println("bouton1 triple clic");}

void setup()
{
  Serial.begin(115200);
// le nom de fonction peut changer, c'est l'ordre qui compte
  bouton.attacher(simpleClic, doubleClic, tripleClic);
  bouton1.attacher(Clic1, Clic2, Clic3);

}

void loop()
{
  bouton.actualiser();
  bouton1.actualiser();
}

Super librairie, merci Bricolo ! J'en ai utilisé plusieurs solutions, et gros gain de temps et de fiabilité, lisibilité et tout et tout ! J'ai apporté une petite modif sur l'exemple 10: Gestion d'un compteur avec un bouton + et un bouton - et répétition progressive en cas d'appui long.

j'ai ajouté une possiblité d'incrément par 1, ou 5 ou 10 pour augmenter encore la vitesse. l'incrémenteur, boostCompteur à déclarer en byte en public. le lignes que j'ai ajoutées sont marquées par "//************************" pour plus de visibilité.

//Exemple librairie simpleBouton.h
//Gestion d'un compteur avec un bouton + et un bouton -
//et répétition progressive en cas d'appui long

#include "simpleBouton.h"

simpleBouton bouton_plus(7);
simpleBouton bouton_moins(8);
//Cablage : pin---BP---GND

int compteur = 0;

void setup()
{
  Serial.begin(115200);
  Serial.println(compteur);
}

uint32_t delai;
bool blocage = false;

void loop()
{
  bouton_plus.actualiser();
  bouton_moins.actualiser();
  
  if (bouton_plus.vientDEtreEnfonce() || bouton_moins.vientDEtreEnfonce()) delai = 0;

  //Gestion du petit malin qui appuie sur les deux boutons en même temps
  if (bouton_plus.estEnfonce() && bouton_moins.estEnfonce()) blocage = true;
  if (bouton_plus.estRelache() && bouton_moins.estRelache()) blocage = false;
  if (blocage) return;
   
  if (bouton_plus.estEnfonceDepuisAuMoins(delai))  {
    Compteur += boostCompteur ; //************************
    //Serial.println(Compteur);
    delai = delai + delaiRepetition(bouton_plus.dureeEtatActuel());
  }

  if (bouton_moins.estEnfonceDepuisAuMoins(delai))  {
    Compteur -= boostCompteur ; //************************
    //Serial.println(Compteur);
    delai = delai + delaiRepetition(bouton_moins.dureeEtatActuel());
  }
}

uint32_t delaiRepetition(uint32_t duree){ //Exemple de cadence progressive
  if (duree <  500) {
    boostCompteur =1; //************************
    return 300;
  }
  if (duree <  2000) {
    boostCompteur =5; //************************
    return 150;
  }
  if (duree <  3000){
    boostCompteur =10;  //************************
    return 100;}
  return 10;  // 10ms de cadence
}

achess: // peut être modifié, l'essentiel est que le mot "Clic" soit présent

Le mot clic ??? Mais non...

Le nom de fonction n’a aucun impact, ces noms disparaissent à la compilation

Bonjour moi c'est Thomas je suis un "nul" d'arduino je ne sais pas si je poste ma question au bon endroit mais bon...

J'essaie d'occuper le garçon de ma compagne avec Arduino nous essayons de créer un feu tricolore avec feu piéton et bouton poussoir "piéton" cela fonctionne bien avec ce code trouvé sur le net un peu modifié mais il faut rester appuyer sur le BP jusqu'à ce que la boucle soit terminée pour quelle prenne en compte l'appui. Nous souhaiterions pouvoir faire une simple impulsion sur ce dernier et qu le programme passe directement au "feu orange" puis "feu rouge" et ensuite reprenne le fonctionnement normal.

merci pour votre aide.

// Constantes et variables pour le feu tricolore
const int ledRouge = 12;
const int ledOrange = 11;
const int ledVerte = 10;

// Constantes et variables pour le feu piéton
const int ledRouge_pieton = 9;
const int ledVerte_pieton = 8;

// Constante et variables pour le bouton poussoir
const int bouton = 2;
int etatBouton = 0;

void setup() {
pinMode (ledRouge, OUTPUT);
pinMode (ledOrange, OUTPUT);
pinMode (ledVerte, OUTPUT);

pinMode (ledRouge_pieton, OUTPUT);
pinMode (ledVerte_pieton, OUTPUT);

pinMode (bouton, INPUT);

}

void loop() {

etatBouton = digitalRead (bouton);
delay(100);

if (etatBouton == HIGH) {
  digitalWrite (ledRouge, LOW);
  digitalWrite (ledOrange, HIGH);
  digitalWrite (ledVerte, LOW);
  delay(3000);

  digitalWrite (ledRouge, HIGH);
  digitalWrite (ledOrange, LOW);

  digitalWrite (ledRouge_pieton, LOW);
  digitalWrite (ledVerte_pieton, HIGH);
  delay(15000);

  digitalWrite (ledRouge_pieton, HIGH);
  digitalWrite (ledVerte_pieton, LOW);

  digitalWrite (ledRouge, LOW);
  digitalWrite (ledVerte, HIGH);
  delay(10000);
  digitalWrite (ledVerte, LOW);  
}
else {
  digitalWrite (ledRouge_pieton, HIGH);
  digitalWrite (ledVerte_pieton, LOW);

  digitalWrite (ledOrange, HIGH);
  delay(3000);
  
  digitalWrite (ledOrange, LOW);
  digitalWrite (ledRouge, HIGH);
  digitalWrite (ledRouge_pieton, LOW);
  digitalWrite (ledVerte_pieton, HIGH);
  delay(10000);
  digitalWrite (ledRouge_pieton, HIGH);
  digitalWrite (ledVerte_pieton, LOW);
  delay(5000);

  digitalWrite (ledRouge, LOW);
  digitalWrite (ledVerte, HIGH);
  delay(10000);
  digitalWrite (ledVerte, LOW);
}
  
}

Auriez-vous une solution ?

Thomas et Mylan

Bonjour Thomas et Mylan

Ton post est mal placé, demande a un modérateur de déplacer ton message en cliquant sur "Report to moderator" en bas de ton msg

Le problème vient de tes "delay" qui bloquent la boucle,

La solution serait d'utiliser la fonction millis() : voir ici exemple utilisation de millis()

Et de le coupler avec la machine a état de J-M-L

Mise en ligne aujourd'hui d'une nouvelle version mineure

V4.2 du 07/08/2020

Suppression du warning parasite lors de la compilation

Vous voulez pas la publier dans github et la déclarer dans les bibliothèques? Ça permettrait les màj automatiques

ok je vais voir ça :)