[ARDUINO] Faire un bouton de marche Servo-Moteur

[A3C4]

Bonjour,

Je cherche à réaliser un bouton de marche d'un servomoteur, mais le problème étant que durant l'état HIGH du bouton en réalité le servomoteur change l'angle que j'ai changé avec un potentiomètre en état LOW, c'est à dire :
*Position LOW du bouton = Potentiomètre qui modifie la valeur de l'angle du servomoteur
*Position HIGH du bouton = Le servomoteur rejoint l'angle choisi précédemment(à l'aveugle du coup)
Alors que moi je voudrais que l'appui sur ce bouton me permette de modifier l'angle de ce servomoteur, et d'ailleurs je comprend pas pourquoi mon code ne fonctionne pas pourtant il est clairement dit que si l'état est en HIGH je modifie l'angle du moteur, voici mon code :

#include <Servo.h>

Servo myservo;

int pot= 0;
int val;
const int tableau = 320;
float pos[tableau];
const int bouton = 13;  // la broche 13 devient bouton
const int led = 2;
byte etat;
boolean boutonRelache;


void setup(){
myservo.attach(9);
pinMode(bouton, INPUT_PULLUP); // Initialise la broche 4 comme entrée
pinMode(led, OUTPUT);   // Initialise la broche 12 comme sortie
boutonRelache=(digitalRead(bouton)==HIGH);
etat = boutonRelache ? LOW : HIGH;
Serial.begin(9600);  
}

void loop(){
 
if (digitalRead(bouton) == HIGH){
  if (!boutonRelache){
    delay(20);
    boutonRelache = true;
  }
}
  else{
    if(boutonRelache){
      boutonRelache = false;
      etat = (etat == HIGH) ? LOW : HIGH;
      delay(20);
      digitalWrite(led,etat);
    }
    
       if(etat == HIGH)
      {
    val = analogRead(pot);
    val=map(val,0,1023,0,180);
    delay(10);
    myservo.write(val);
  
           // allume la LED
      }
     
  }
   
  }

Je vous remercie pour vos réponse
-----

[Forhorse]

Problème classique de rebond qui n'est pas / mal géré
J'ai pas tout regardé, mais ton delay(20) à la suite de la lecture de l'entrée du bouton, tel quel il ne sert à rien.
Pour faire un anti-rebond, il faut tester l'état de l'entrée, attendre un peu, et tester à nouveau l'état pour voir si c'est toujours le même que celui qui à été testé précédemment et agir en conséquence, je n'ai pas l'impression que c'est ce que fait ton code ici.

[A3C4]

Le debounce est ici :

if (digitalRead(bouton) == HIGH){
  if (!boutonRelache){
    delay(20);
    boutonRelache = true;
  }

et de toute façon ça prend réellement compte l'état high et low, c'est juste que le servomoteur ne s'active pas quand il y a l'état HIGH, je pense que j'ai bien expliqué mon problème au début, enfin dites moi si vous comprenez pas ^^'(ps : je n'ai toujours pas trouvé ou est le problème)

[Forhorse]

Le debounce est ici :

if (digitalRead(bouton) == HIGH){
  if (!boutonRelache){
    delay(20);
    boutonRelache = true;
  }

T'es sûr de ton coup là ?

[A voir en vidéo sur Futura]

[A3C4]

Oui vous pouvez constater ici que que l'état précédent est bien sauvegarder et donc me donne à chaque fois l'état 2 fois :

pas de rebond.pdf

Donc maintenant que j'ai constaté cela, je me dis qu'en réalité c'est parce qu'à travers le temps le bouton est enregistré tel donc ne vérifie pas à chaque fois l'état du bouton donc ce qui me semble logique mon servomoteur ne bouge pas à travers le temps. Donc je me demande comment maintenant je peux réaliser cette vérification toutes les secondes par exemple, corrigé moi si je me trompe s.v.p .

[A3C4]

Bon, j'ai pensé à mettre finalement un while, mais le problème c'est que ce while me bloque le bouton dans l'état LOW :

  else{
    if(boutonRelache){
      delay(10);
      boutonRelache = false;
      etat = (etat == HIGH) ? LOW : HIGH;
      digitalWrite(led,etat);
      Serial.println(etat);
      do
      {
    val = analogRead(pot);
    val=map(val,0,1023,0,180);
    myservo.write(val);
      }
      while(etat == HIGH);
  }
  }

Je comprends pas très bien pourquoi ça me bloque à cet état là ...

[Murayama]

Bonjour!

je pense que j'ai bien expliqué mon problème au début, enfin dites moi si vous comprenez pas

Condescendance, quand tu nous tiens...

Oui vous pouvez constater ici que que l'état précédent est bien sauvegarder et donc me
donne à chaque fois l'état 2 fois :

Ce qui prouve quoi?
En regardant le code, il y a des trucs chelous:

La variable "etat" est au départ l'état opposé à boutonRelache, tantôt l'opposé
d'elle-même. Dans ce dernier cas, le changement n'intervient pas par quelque chose
de physique, mais par quelque chose de purement logique, son état passé.

Votre test est foireux.

    if (digitalRead(bouton) == HIGH){    //    Si le bouton est maintenant relâché
    if (!boutonRelache){                 //    Et si il était appuyé au dernier test
        delay(20);                       //    Délai
        boutonRelache = true;            //    Alors on déclare le bouton relâché.
    }

Comme il n'y a aucun autre test pendant ou après le délai, ce délai ne sert
à rien et par conséquent l'anti-rebond aussi.

Je serais vous, je commencerais par simplifier un peu, et n'avoir qu'une seule
variable pour appuyé et relâché.
Et puis ça ne ferait pas de mal de raisonner en logique positive, du point de vue
de l'humain. Par exemple, appeler l'état du bouton "boutonAppuye" correspond
à l'action, alors que boutonRelache correspond à la non-action. De ce fait, !boutonRelache
correspond à la non-(non-action), ce qui veut dire bouton appuyé. Ce n'est pas ce qui
se fait de plus simple.

Ensuite:

while(etat == HIGH);

Je comprends pas très bien pourquoi ça me bloque à cet état là ...

Vous attendez, il me semble, que la variable "etat" change ... d'état.
À votre avis, dans cette boucle, qu'est-ce qui pourrait bien faire changer
"état" de haut à bas et causer la sortie de boucle?

À part ça, il faudrait prendre l'habitude de choisir des noms variables qui ont un sens.
Le nom de variable "etat" par lui-même n'a pas de sens. Vu qu'il n'est utilisé que
pour la LED, pourquoi pas etat_led? On se demande aussi pourquoi boutonRelache est
boolean alors que l'etat est un byte.
Tiens, à propos de LED, il y a un commentaire "allume la LED" qui semble être isolé
après une fonction qui n'a pas de rapport.
Ensuite, la variable tableau, je m'attendais a ce que ce soit un tableau, mais
non, c'est une longueur. Donc tab_len, ou autre, qui permettrait de l'identifier.
À part ça, pos ne sert à rien, je ne le trouve pas dans le code. Quand on pose
une question, il est préférable de ne pas inclure ce qui ne sert à rien.

Pascal

[A3C4]

Bonjour,

Oui la condescendance c'est mon dada , plus sérieusement, après avoir regardé des tutos sur YouTube et sur le web, j'ai enfin trouvé comment faire un anti-rebond logiciel :

#include <Servo.h>

Servo myservo;

int pot= 0;
int val;

const int bouton = 13;
const int led = 2;
int etatprecedent = HIGH; //nous initialison l'état précedent comme l'état non appuyer
long delai = 1000; //nous definission le délai voulu

bool tempo = LOW;

void setup(){
  pinMode(bouton,INPUT_PULLUP);
  pinMode(led, OUTPUT);
  Serial.begin(9600);
  myservo.attach(9);
}

void loop(){
  const int etatbouton = digitalRead(bouton); // nous définissons la variable etatbouton comme la lecture d'état du bouton
  static long derniereTrans = 0; // nous définissons la derniere transition
  long temps;
  if(digitalRead(led) ==1){
  val = analogRead(pot);
  val=map(val,0,1023,0,180);
  myservo.write(val);
  Serial.println(val);
  }
  if (etatbouton != etatprecedent){ //si l'état bouton est different de l'état précedent
    temps = micros(); //on utilise la fonction micros
    if ((temps - derniereTrans) >= delai){ //si la différence entre la fonction temps et le dernier front est suppérieur ou égale au délai prédéfini
      if (etatbouton == LOW){ //si l'état du bouton est appuyé
      digitalWrite(led, !digitalRead(led));
        Serial.println(digitalRead(led));//on allume la led en inversant son état 
    }
    derniereTrans = temps; //la dernière transistion est à présent le temps écoulé depuis le démarage
    }
  }

etatprecedent = etatbouton; //nous disons que l'étatprecedent est à présent l'étatbouton soit LOW soit HIGH
      if (digitalRead(led) == 1){  // ce code fonctionne tjr pas
}
}

En tout cas c'est le seul qui a fonctionné correctement d'ailleurs j'ai bien l'impression voici le lien https://www.youtube.com/watch?v=ftdqUflYG3Y&t=1286s (ps: j'ai aussi ajouté une résistance de 10k pour être plus safe), ensuite c'est tout bon, j'ai réussi à modifier l'angle de mon servomoteur et cela que quand j'appuie sur mon bouton, pour les variables tableau et pos c'était pour la mémorisation des positions de mon servomoteur pour ensuite l'utilisé quand j'appuie sur un autre bouton poussoir, pour en quelque sorte une automatisation, et donc désolé de pas les avoir effacé. Merci de vos aiguillages dans tous les cas ! (hésitez pas à me corriger sur mes commentaires si j'ai faux s.v.p je suis très preneurs des explications !)

[Forhorse]

ça c'est un anti-rebond... et sans utiliser la fonction "delay" en plus, ce qui est beaucoup mieux. (perso j'utilise plus la fonction millis() que micros() parce qu'en général les boutons actionnés par les humains n'ont pas besoin d'une réactivité extrême et que les rebonds peuvent parfois être "long")