Serial Print soucis boucle

Bonjour ! Voilà, j'ai un petit soucis. J'ai trouver sur internet un code, où lorsque j'appui sur un bouton, la led s'allume. Là j'ai aucun soucis, j'ai voulus m'amuser avec ce que j'ai appris et j'ai utilisé la fonction Serial.print pour afficher des messages dans le "Moniteur serie". Le seul soucis, c'est que je pense que mon code utilise un boucle, qui cherche à savoir tout le temps si j'appui ou non sur le bouton, du coup mon serial print se répète et la console devient ilisible ! Voici mon code :

// --- Programme Arduino --- // par X. HINAULT - 01/2010

// --- Que fait ce programme ? --- /* Une LED reste allumée tant qu'un bouton poussoir est appuyé et s'éteint lorsqu'il n'est pas appuyé */

// --- Fonctionnalités utilisées ---

// --- Circuit à réaliser --- // Connecter BP à la masse sur la broche 2 (configurée en entrée) // Connecter LED et sa résistance en série sur la broche 3 (configurée en sortie)

//**************** Entête déclarative ******* // A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

// --- Déclaration des constantes ---

const int APPUI=0; // constante état du BP - appui sur niveau bas const int PAS_APPUI=1; // constante état du BP - relâché sur niveau haut

// --- constantes des broches ---

const int BP=2; //declaration constante de broche const int LED=3; //declaration constante de broche

// --- Déclaration des variables globales ---

int ETAT_BP; // variable d'état du bouton poussoir

// --- Initialisation des fonctionnalités utilisées ---

//**************** FONCTION SETUP = Code d'initialisation ***** // La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup() { // debut de la fonction setup()

// --- ici instructions à exécuter au démarrage --- Serial.begin(9600); pinMode(LED, OUTPUT); //met la broche en sortie

pinMode(BP, INPUT); //met la broche en entree

digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée

} // fin de la fonction setup() // ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme ************* // la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal ---

ETAT_BP=digitalRead(BP); // lit l'état du BP et met la valeur 0/1 dans la variable

if (ETAT_BP==APPUI){ // si l'état du BP est appuyé (càd si variable état BP = 0) // Attention à bien utiliser == et non =

digitalWrite(LED,1); // allume la LED Serial.print("La LED a etait allume.");

}

else { // sinon (càd si variable état bp=1)

digitalWrite(LED,0); // éteint la LED Serial.print("La LED a etait eteinte."); }

// remarque : on aurait pu écrire ceci sur une seule ligne selon : // if (ETAT_BP==APPUI)digitalWrite(LED,1); else digitalWrite(LED,0);

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin // ********************************************************************************

// --- Fin programme ---

Que faire pour l'améliorer ? Merci beaucoup, au passage, si vous avez des idée d'amélioration ;). Cordialement, Maxime.

Hello,

une proposition serait de ne faire des actions (et afficher) que lors du changement d'état. Il faut dans ce cas garder en mémoire l'état précédent du bouton, et si l'état change, effectuer l'action, et mémoriser ce dernier état.

Salut, Merci pour ta réponse, comme je l'est indiqué je suis debutant :/. Comment je pourrait procéder ? Cordialement, Maxime.

Regardes également du côté de Fichier\Exemple\02-digital\Blink without delay ;)

Merci, Je vais essayer de comprendre le code, et je vous donne de mes nouvelles :p Encore merci. Cordialement, Maxime.

Coucou,

Je ferais ceci

int lastButton;
setup() {
  lastButton = -1;
}

loop()
{
  int currentButton = digitalRead(BUTTON);
  if (lastButton != currentButton)
  {
    if (currentButton == ON)
    {
    }
    else
    {
    }
  lastButton = currentButton;
  }
}

Coucou les copains,
Voici un petit programme qui fonctionne sans problème :

/* petit programme pour tester un bouton poussoir */
/* Une résistance de 10 kohm va du +5Vcc jusqu'à l'entrée 10 ici
   choisie sans critère particulier. Entre l'entrée testée et la 
   masse se branche le bouton poussoir. */

const byte MonBouton = 10;  // Broche 10 pour brancher le bouton poussoir.

void setup() {
  Serial.begin(115200);
  pinMode(MonBouton, INPUT);}
  
void loop() { 
 while(digitalRead(MonBouton)==HIGH) {} // Attendre que le BP soit activé.
 Action_sur_Enfoncement(); // BP activé on fait un traitement.
 // Si la ligne ci-dessus est enlevée, seul le relâcher aura un effet.
 while(digitalRead(MonBouton)==LOW); // Attente du relâcher.
 Action_sur_Liberation();} // En général c'est le relâcher qui déclenche une action.
 
void Action_sur_Enfoncement() {
 delay(50); // Parer les faux rebonds
 Serial.print("Mon bouton poussoir vient d'");
 Serial.print(char(234));   // Caractère spécial "ê".
 Serial.print("tre activ");
 Serial.println(char(233)); } //Caractère spécial "é".
 
void Action_sur_Liberation() {
 delay(50); // Parer les faux rebonds
 Serial.print("Mon bouton poussoir vient d'");
 Serial.print(char(234)); // Caractère spécial "ê".
 Serial.print("tre lib"); // Suite du texte.
 Serial.print(char(233)); // Caractère spécial "é".
 Serial.print('r');       // Caractère ordinaire.
 Serial.println(char(233)); }

COMMENTAIRES sur ce programme :

  • Il ne fonctionne que sur un bouton poussoir. Si tu veux travailler avec un ou des inverseurs, il faut tester un front descendant, la programmation est légèrement plus complexe.
  • Personnellement je déteste les boucles de base avec une liste sans fin d’instructions incompréhensibles, le programme est illisible. Je préfère construire une procédure pour chaque action élémentaire. Dans les procédures elles-mêmes je procède ainsi. Avec ce type de programmation on consomme 3 octets de plus pour chaque appel et retour à procédure, mais le programme est « facile » à comprendre et à déverminer.
  • Par exemple ici, les procédures pour afficher sont « lourdes », car je déteste les textes sans accents. Donc j’utilise les caractères spéciaux pour la ligne série. Du coup, si j’avais logé tout ce code dans loop() mon programme serait bien abscond.

Le créateur du langage PASCAL, mon préféré de tous les langages informatiques que j’ai pratiqué au cours de ma vie disait : l’important pour un logiciel n’est pas qu’il fonctionne correctement, mais qu’il SOIT LISIBLE. Je partage totalement ce point de vue.