Un Arduino par module....ou pas.

[petitrain]

Suite de mon projet et plein de problème que je ne sais pas comment résoudre, si une bonne âme pouvait me venir en aide...
Je rappelle brièvement mon projet, toujours le même: je voudrais commander l'éclairage de mon réseau par des bandeaux de ledsRGB et blanc chaud commandés eux-mêmes par un arduino+ des MOSFETS.
J'aimerai avoir plusieurs programmes ( chaude journée d'été, dans le froid de l'hiver, jour et nuit , maintenance, etc..)
Je compte utiliser les ScheduleTable et aussi une machine à état qui, dans le principe me parait simple...
J'ai testé un premier programme et rien ne marche comme je l'avais imaginer.
Je n'arrive pas à démarrer les Tables dans la machine.
La machine à états marche très mal:
La commande d'extinction des leds (for(byte i;i<7;i++){digitalWrite(leds,LOW);}) est inopérante
Je ne peux pas passer d'un programme à un autre...
Je pense avoir fait pas mal d'erreurs, si vous pouviez me mettre sur la voie

Code: [Sélectionner]

/********************************BIBLIOTHEQUE UTILE POUR GERER LES BOUTONS**********************/
#include <RBD_Timer.h> 
#include <RBD_Button.h>
/********************************BIBLIOTHEQUE POUR LE CHENILLARD*******************************/
 #include <ScheduleTable.h>
  ScheduleTable Chenillard(12,12,200);// création de la table : 12 actions, 12 périodes de 200ms.
/********************************DECLARATION DES ETATS DE LA MACHINE***************************/

enum{INITIAL, ATTENTEPROG1, PROG1, ATTENTEPROG2, PROG2, ATTENTEPROG3, PROG3, ATTENTEPROG4, PROG4,
 ATTENTEPROG5, PROG5, ATTENTEPROG6, PROG6, ATTENTEPROG7, PROG7,};
 int etat = INITIAL;
/******************************DECLARATION DES BROCHES POUR LES LEDS TEST**********************/

byte leds[] = {2,4,7,8,11,12,13};
/*******************************CONSTRUCTEUR POUR LES BOUTONS**********************************/

RBD::Button boutonIncrementation(17, false);
RBD::Button boutonValidation(16, false);
RBD::Button boutonDecrementation(15, false);
RBD::Button boutonReset(14, false);
boolean etatVal = 0;                          // Variable pour la validation
boolean ancienEtatVal = 0;                    // Précédent état de la validation
byte compteur=0;                              // Compteur des différents programmes
const byte valeurMin=0;                       // Valeur minimum du compteur
const byte valeurMax=7;                       // Valeur maximum du compteur
/******************************INITIALISATION**************************************************/

void setup() {
    Serial.begin(9600);
    for(int i=0;i<7;i++){
    pinMode(leds[i],OUTPUT);
    }
    Chenillard.at(1,Chenillard1);
    Chenillard.at(2,Chenillard2);
    Chenillard.at(3,Chenillard3);
    Chenillard.at(4,Chenillard4);
    Chenillard.at(5,Chenillard5);
    Chenillard.at(6,Chenillard6);
    Chenillard.at(7,Chenillard7);
    Chenillard.at(8,Chenillard8);
    Chenillard.at(9,Chenillard9);
    Chenillard.at(10,Chenillard10);
    Chenillard.at(11,Chenillard11);
    Chenillard.at(12,Chenillard12);
   

}
/*****************************LOOP*************************************************************/

void loop() {
/**************************TEST DES BOUTONS****************************************************/

  if(boutonIncrementation.onPressed()){if(compteur< valeurMax)compteur++;}
  if(boutonDecrementation.onPressed()){if(compteur>valeurMin)compteur--;}
  if(boutonValidation.onPressed()){etatVal=!etatVal;}
  Serial.print("compteur :   ");
  Serial.println(compteur);
  Serial.print("Validation :      ");
  Serial.println(etatVal);
/****************************MACHINE A ETAT****************************************************/
  switch (etat){
    case INITIAL:                                        // Dans cet état, il n'y a qu'un motif
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);} // qui défile sur la rangée de leds
         Chenillard.start();               // En attente du compteur pour choisir
         if(compteur==1){etat=ATTENTEPROG1;}             // le programme à jouer.
    break;
    case ATTENTEPROG1:                                   // Le programme 1 est en attente de
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);} // validation.La led 1 clignote.
         Clignote(0);
         if(etatVal!=ancienEtatVal){etat=PROG1;}
    break;
    case PROG1:                                          // Le programme est validé. la led 1
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);} // est allumée. La validation est
         digitalWrite(leds[0],HIGH);                     // remise à zéro et le programme 1 se
         etatVal=ancienEtatVal;                          // déroule.
         //programme1
         if(compteur==2){etat=ATTENTEPROG2;}
    break;
    case ATTENTEPROG2:                                   // idem pour le programme2...
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         Clignote(1);
         if(etatVal!=ancienEtatVal){etat=PROG2;}
    break;
    case PROG2:
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         digitalWrite(leds[1],HIGH);
         etatVal=ancienEtatVal;
         //programme2
         if(compteur==3){etat=ATTENTEPROG3;}
    break;
    case ATTENTEPROG3:                                   // idem pour le programme3...
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         Clignote(2);
         if(etatVal!=ancienEtatVal){etat=PROG3;}
    break;
    case PROG3:
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         digitalWrite(leds[2],HIGH);
         etatVal=ancienEtatVal;
         //programme3
         if(compteur==4){etat=ATTENTEPROG4;}
    break;
    case ATTENTEPROG4:                                   // idem pour le programme4...
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         Clignote(3);
         if(etatVal!=ancienEtatVal){etat=PROG4;}
    break;
    case PROG4:
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         digitalWrite(leds[3],HIGH);
         etatVal=ancienEtatVal;
         //programme4
         if(compteur==5){etat=ATTENTEPROG5;}
    break;
    case ATTENTEPROG5:                                   // idem pour le programme5...
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         Clignote(4);
         if(etatVal!=ancienEtatVal){etat=PROG5;}
    break;
    case PROG5:
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         digitalWrite(leds[4],HIGH);
         etatVal=ancienEtatVal;
         //programme5
         if(compteur==6){etat=ATTENTEPROG6;}
    break;
    case ATTENTEPROG6:                                   // idem pour le programme6...
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         Clignote(5);
         if(etatVal!=ancienEtatVal){etat=PROG6;}
    break;
    case PROG6:
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         digitalWrite(leds[5],HIGH);
         etatVal=ancienEtatVal;
         //programme6
         if(compteur==7){etat=ATTENTEPROG7;}
    break;
    case ATTENTEPROG7:                                   // idem pour le programme7...
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         Clignote(6);
         if(etatVal!=ancienEtatVal){etat=PROG1;}
    break;
    case PROG7:
         for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
         digitalWrite(leds[6],HIGH);
         etatVal=ancienEtatVal;
         //programme7
         if(compteur==6){etat=ATTENTEPROG6;}
    break;
   
   
  }


}
void Clignote(byte numLed){
  //for(byte i;i<7;i++){digitalWrite(leds[i],LOW);}
  digitalWrite(leds[numLed],millis()/200%2);
}
/*                         Quand aucun programme est appelé, les leds clignotent suivant le mode chenillard:
 * allumé=x    eteint=-                               ORDRE D'ALLUMAGE DES LEDS
 *                   
 *        actions  :  0(led2)  :  1(led4)  :  2(led7)  :  3(led8)  :  4(led11)  :  5(led12)  :  6(led13)  :  périodes
 *        -----------------------------------------------------------------------------------------------------------
 *           1     :     x     :     -     :     -     :     -     :      -     :      -     :     -      :     1
 *           1     :     -     :     x     :     -     :     -     :      -     :      -     :     -      :     2
 *           1     :     -     :     -     :     x     :     -     :      -     :      -     :     -      :     3
 *           1     :     -     :     -     :     -     :     x     :      -     :      -     :     -      :     4
 *           1     :     -     :     -     :     -     :     -     :      x     :      -     :     -      :     5
 *           1     :     -     :     -     :     -     :     -     :      -     :      x     :     -      :     6
 *           1     :     -     :     -     :     -     :     -     :      -     :      -     :     x      :     7
 *           1     :     -     :     -     :     -     :     -     :      -     :      x     :     -      :     8
 *           1     :     -     :     -     :     -     :     -     :      x     :      -     :     -      :     9
 *           1     :     -     :     -     :     -     :     x     :      -     :      -     :     -      :     10
 *           1     :     -     :     -     :     x     :     -     :      -     :      -     :     -      :     11
 *           1     :     -     :     x     :     -     :     -     :      -     :      -     :     -      :     12
 */




 void Chenillard1(){digitalWrite(leds[0],HIGH);digitalWrite(leds[1],LOW);}  //Les fonctions qui définissent les actions
 void Chenillard2(){digitalWrite(leds[1],HIGH);digitalWrite(leds[0],LOW);}  //de la Table.
 void Chenillard3(){digitalWrite(leds[2],HIGH);digitalWrite(leds[1],LOW);}
 void Chenillard4(){digitalWrite(leds[3],HIGH);digitalWrite(leds[2],LOW);}
 void Chenillard5(){digitalWrite(leds[4],HIGH);digitalWrite(leds[3],LOW);}
 void Chenillard6(){digitalWrite(leds[5],HIGH);digitalWrite(leds[4],LOW);}
 void Chenillard7(){digitalWrite(leds[6],HIGH);digitalWrite(leds[5],LOW);}
 void Chenillard8(){digitalWrite(leds[5],HIGH);digitalWrite(leds[6],LOW);}
 void Chenillard9(){digitalWrite(leds[4],HIGH);digitalWrite(leds[5],LOW);}
 void Chenillard10(){digitalWrite(leds[3],HIGH);digitalWrite(leds[4],LOW);}
 void Chenillard11(){digitalWrite(leds[2],HIGH);digitalWrite(leds[3],LOW);}
 void Chenillard12(){digitalWrite(leds[1],HIGH);digitalWrite(leds[2],LOW);}

[Jean-Luc]

Bonsoir,

Rapidement (trop fatigué pour étudier en détails) il manque l'appel

Code: [Sélectionner]

ScheduleTable::update();

Dans loop()

C'est pour ça que la Schedule table ne fonctionne pas.

Je regarde le reste demain.

[Jean-Luc]

2 autres choses :

La variable ancienEtatVal n'est jamais affectée (sauf à l'initialisation). Par conséquent, une pression de bouton sur 2 sera vue

Dans tous les case, les leds sont éteintes. Par conséquent elles sont éteintes en permanence car leur allumage est très fugace.

[petitrain]

merci pour cette réponse rapide. Je m'y recolle mais c'est pas gagné....
Que c'est dur la programation....

[Jean-Luc]

Une simplification consisterait à utiliser une variable booléenne à la place des variables etatVal et ancienEtatVal. Car en fait la bibliothèque RBD_button intégre déjà cette mémorisation de son état précédent. Appelons cette variable 'ok'. Au lieu d'inverser etatVal et de retenir sa valeur précédente, il suffit d'écrire dans loop :

Code: [Sélectionner]

bool ok = boutonValidation.onPressed();

Puis à chaque fois que vous testiez la différence entre etatVal et ancienEtatVal :

Code: [Sélectionner]

if (ok) { ... }


[petitrain]

Merci pour l'aide, surtout le if(OK){.....} je n'aurai jamais pensé l'écrire comme ça. Ça marche très bien. Par contre j'ai abandonné la machine à état, je ne m'en sortais pas. Je pensai avoir absorbé la théorie, mais, dans la pratique, ça s'avère plus difficile à mettre en œuvre . J'ai fait un switch(compteur)....avec des case:1,2,3,....et dans chaque case un clignote() de la led concernée et un if(OK){on change la valeur d'une variable programme=1,2,3... } puis un autre switch(programme) avec des case: programme1, programme2...
Il  me reste a mettre tous les programmes à écrire pour que mon éclairage du réseau voie enfin le jour.
Par contre, je n'arrive pas  à faire démarrer les ScheduleTables depuis mon switch. Je suis obligé de mettre .....start() dans le setup, et quand le programme arrive sur ScheduleTable::uptade (), là, elle se met en route. Donc, si j'en aie plusieurs, elles vont toutes se mettre en route ....