comment faire une fonction "ET/OU" avec une condition ?

bonjour, je suis un gros gros noob avec arduino et la programmation.
je m’aide du site du zéro et leur tuto et l’énorme base de donnée du site officiel d’arduino et des tuto du site pjrc qui vend les teensy que j’ai acheté.

mon but est de faire un escalier avec des trips leds rgb et de controler l’allumage des marches au fur et à mesure ainsi que le changement des couleurs des leds de façon progressive avec deux boutons Couleur + et - (et plus tard, deux boutons luminosité +/-)

pour passer par toutes les couleurs de façon progressive, je voulais utiliser la méthode des tables codées en GRAY sur 3 bits ici.
j’ai donc fait ce code:

//déclaration des pins
int redPin =  24;
int greenPin =  26;
int bluePin =  25;
int Cmoinspin = 18;
int Cpluspin = 19;
//initialisation du mode de connection des pins

void setup()   {                

  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  pinMode(Cpluspin, INPUT_PULLUP);
  pinMode(Cmoinspin, INPUT_PULLUP);
  Serial.begin(38400);
  
}
// mise à zéro des variables
int ColorR = 0;
int ColorG = 0;
int ColorB = 0;

//programme
void loop()                     
{
  //écriture du code rgb vers les sorties
  analogWrite(redPin, ColorR);
  analogWrite(greenPin, ColorG);
  analogWrite(bluePin, ColorB);
  Serial.println(ColorR);
  Serial.println(ColorG);
  Serial.println(ColorB);
  
  //conditions augmentation couleur.
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 0) && (ColorG = 0) && (ColorB = 0))  {
    ColorR = ColorR + 1;
    delay(100);
    }
     
    if ((digitalRead (Cpluspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG = 0) && (ColorB = 0))  {
    ColorR = ColorR + 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 255) && (ColorG = 0) && (ColorB = 0))  {
    ColorG = ColorG + 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 255) && (ColorG > 0 && ColorG < 255) && (ColorB = 0))  {
    ColorG = ColorG + 1;
    delay(100);
    }
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 255) && (ColorG = 255) && (ColorB = 0))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG = 255) && (ColorB = 0))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 0) && (ColorG = 255) && (ColorB = 0))  {
    ColorB = ColorB + 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 0) && (ColorG = 255) && (ColorB > 0 && ColorB < 255))  {
    ColorB = ColorB + 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 0) && (ColorG = 255) && (ColorB = 255))  {
    ColorR = ColorR + 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG = 255) && (ColorB = 255))  {
    ColorR = ColorR + 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 255) && (ColorG = 255) && (ColorB = 255))  {
    ColorG = ColorG - 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 255) && (ColorG > 0 && ColorG < 255) && (ColorB = 255))  {
    ColorG = ColorG - 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR = 255) && (ColorG =0) && (ColorB = 255))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG =0) && (ColorB = 255))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR =0) && (ColorG =0) && (ColorB = 255))  {
    ColorB = ColorB - 1;
    delay(100);
    }
      
    if ((digitalRead (Cpluspin) == LOW) && (ColorR =0) && (ColorG =0) && (ColorB > 0 && ColorB < 255))  {
    ColorB = ColorB - 1;
    delay(100);
    }
      
  
  //conditions diminution couleur.
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 0) && (ColorG = 0) && (ColorB = 0))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG = 0) && (ColorB = 0))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 255) && (ColorG = 0) && (ColorB = 0))  {
    ColorG = ColorG - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 255) && (ColorG > 0 && ColorG < 255) && (ColorB = 0))  {
    ColorG = ColorG - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 255) && (ColorG = 255) && (ColorB = 0))  {
    ColorR = ColorR + 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG = 255) && (ColorB = 0))  {
    ColorR = ColorR + 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 0) && (ColorG = 255) && (ColorB = 0))  {
    ColorB = ColorB - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 0) && (ColorG = 255) && (ColorB > 0 && ColorB < 255))  {
    ColorB = ColorB - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 0) && (ColorG = 255) && (ColorB = 255))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG = 255) && (ColorB = 255))  {
    ColorR = ColorR - 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 255) && (ColorG = 255) && (ColorB = 255))  {
    ColorG = ColorG + 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 255) && (ColorG > 0 && ColorG < 255) && (ColorB = 255))  {
    ColorG = ColorG + 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR = 255) && (ColorG =0) && (ColorB = 255))  {
    ColorR = ColorR + 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR > 0 && ColorR < 255) && (ColorG =0) && (ColorB = 255))  {
    ColorR = ColorR + 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR =0) && (ColorG =0) && (ColorB = 255))  {
    ColorB = ColorB + 1;
    delay(100);
    }
      
    if ((digitalRead (Cmoinspin) == LOW) && (ColorR =0) && (ColorG =0) && (ColorB > 0 && ColorB < 255))  {
    ColorB = ColorB + 1;
    delay(100);
    }
       
  
  
}

sauf que ça ne marche pas, la led de test reste en bleu quand je reste appuyé sur le bouton.
le bouton couleur + met la led en blanc et l’autre la met en violet.

je n’arrive pas à voir dans la fenetre monitor ce qu’il devrait être marqué.

je pense que le soucis viens de la fonction if qui intègre des conditions ET …
mais j’arrive pas à trouver un tuto expliquant comment l’utiliser ou si c’est bien ça mon soucis.

merci pour votre aide ! c’est vraiment pas évident de débuter en programmation !

Bonjour,

En ce qui concerne la visualisation sur le terminal de tes valeurs est ce que tu règles bien ton terminal à 38400 bauds ?

En suite pour tes tests, certain sont mal conçus et d’autre inutile.
D’abord tu as plein de tests du style (ColorG = 0) c’est une affectation et non un test, il faut les remplacer par des (ColorG == 0)
Si tu regardes le 2 1er tu augmentes ColorR de 1 si colorR <>255 uniquement donc pourquoi faire un test avec colorR=0 ?
plutôt que de multiplier les tests avec des && il est à mon avis plus facile et plus clair de faire des tests sur plusieurs niveaux

if (digitalRead (Cpluspin) == LOW){
   if  ((colorR !=0) && (ColorG == 0) && (ColorB == 0))
             {
               colorR++;  //identique à ColorR=coloR+1
               }
   if ....

} //fin du if digitalRead

Et pour finir, mais ça ça n’engage que moi, la plupart de tes niveaux de couleur ne vont pas être décelable à l’œil, il serait à mon avis plus facile de faire un tableau à 2 dimensions (par exemple 32 niveaux de couleurs par 3 composantes RGB. On trouve plein de table de couleur sur internet) définis comme constante et parcourir ton tableau en fonction du bouton activé.

Serge

oui je suis bien à la bonne vitesse dans ma console. j'ai même essayé à d'autres vitesses.

merci pour la == ! j'ai loupé cette finesse là ! pour la possibilité de simplifier avec les deux lignes qui ont le même effet, c'était prévu mais je voulais d'abord solutionner le problème d'exécution du code pour ne pas cumuler les problèmes.

je vais étudier ton bout de code et essayer de m'en inspirer au mieux !

vraiment un grand merci pour ton aide !

pour l'histoire du tableau, je ne sais pas faire ça. et puis bon les variations même si imperceptibles se font quand même au mieux de ce que permet le controleur, et c'est pas tous les jours que je vais changer la couleur.

ptain chui rop content ça marche :stuck_out_tongue:

//déclaration des pins
int redPin =  24;
int greenPin =  26;
int bluePin =  25;
int Cmoinspin = 18;
int Cpluspin = 19;
//initialisation du mode de connection des pins

void setup()   {                

  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  pinMode(Cpluspin, INPUT_PULLUP);
  pinMode(Cmoinspin, INPUT_PULLUP);
  Serial.begin(38400);
  
}
// mise à zéro des variables
int ColorR = 0;
int ColorG = 0;
int ColorB = 0;

//programme
void loop()                     
{
  //écriture du code rgb vers les sorties
  analogWrite(redPin, ColorR);
  analogWrite(greenPin, ColorG);
  analogWrite(bluePin, ColorB);
  Serial.println(ColorR);
  Serial.println(ColorG);
  Serial.println(ColorB);
  
  //conditions augmentation couleur.
    if (digitalRead (Cpluspin) == LOW) {
      if ((ColorR <=254) && (ColorG == 0) && (ColorB == 0))  {
      ColorR++;
      delay(20);
      }
      if ((ColorR == 255) && (ColorG <= 254) && (ColorB == 0))  {
      ColorG++;
      delay(20);
      }
      if ((ColorR >= 0) && (ColorG == 255) && (ColorB == 0))  {
      ColorR--;
      delay(20);
      }
      if ((ColorR == 0) && (ColorG == 255) && (ColorB <= 254))  {
      ColorB++;
      delay(20);
      }
      if ((ColorR <=254) && (ColorG == 255) && (ColorB == 255))  {
      ColorR++;
      delay(20);
      }
      if ((ColorR ==255) && (ColorG >= 0) && (ColorB == 255))  {
      ColorG--;
      delay(20);
      }
      if ((ColorR >= 0) && (ColorG == 0) && (ColorB == 255))  {
      ColorR--;
      delay(20);
      }
      if ((ColorR == 0) && (ColorG == 0) && (ColorB >= 0))  {
      ColorB--;
      delay(20);
      }
    }

}

j’ai plus qu’à faire la même chose pour la décrémentation !

autre question:

je voudrais allumer les led en mode configuration et les éteindre 1s après l’arrêt de l’appuis d’un des boutons de configuration.
voici mon code :

//déclaration des pins
int redPin =  24; //sortie analogique rouge
int greenPin =  26; //sortie analogique verte
int bluePin =  25; //sortie analogique bleue
int Cmoinspin = 18; //changement de couleur décroissant
int Cpluspin = 19; //changement de couleur croissant
int Bpluspin = 2; //changement de luminosité décroissant
int Bmoinspin = 3; //changement de luminosité croissant
int activity = 6; //led interne permettant de vérifier l'activité du teensy 2.0 ++
int marche1 = 4; //sortie d'activation de la marche 1 de l'escalier
int marche2 = 5;
int marche3 = 6;
int marche4 = 7;
int marche5 = 8;
int marche6 = 9;
int marche7 = 10;
int marche8 = 11;
int marche9 = 12;
int marche10 = 13;
int marche11 = 17;
int marche12 = 23;
int marche13 = 22; //jusqu'à la 13ème marche...
int capteurbas = 0; //capteur de présence en bas de l'escalier
int capteurhaut = 1; //capteur de présence en haut de l'escalier

//initialisation du mode de connection des pins

void setup()   {                

  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  pinMode(activity, OUTPUT);
  pinMode(marche1, OUTPUT);
  pinMode(marche2, OUTPUT);
  pinMode(marche3, OUTPUT);
  pinMode(marche4, OUTPUT);
  pinMode(marche5, OUTPUT);
  pinMode(marche6, OUTPUT);
  pinMode(marche7, OUTPUT);
  pinMode(marche8, OUTPUT);
  pinMode(marche9, OUTPUT);
  pinMode(marche10, OUTPUT);
  pinMode(marche11, OUTPUT);
  pinMode(marche12, OUTPUT);
  pinMode(marche13, OUTPUT);
  pinMode(Cmoinspin, INPUT_PULLUP);
  pinMode(Cpluspin, INPUT_PULLUP);
  pinMode(Bmoinspin, INPUT_PULLUP);
  pinMode(Bpluspin, INPUT_PULLUP);
  pinMode(capteurbas, INPUT_PULLUP);
  pinMode(capteurhaut, INPUT_PULLUP);
}

// mise à zéro des variables
int ColorR = 0;
int ColorG = 0;
int ColorB = 0;
int BrightR = 0;
int BrightG = 0;
int BrightB = 0;
int CodeR = 0;
int CodeG = 0;
int CodeB = 0;


//programme
void loop() {                
  codergb();

  if ((digitalRead (Cmoinspin) == LOW) || (digitalRead (Cpluspin) == LOW) || (digitalRead (Bmoinspin) == LOW) || (digitalRead (Bpluspin) == LOW)) {
    AllumageGeneral();
  }
}

//écriture du code rgb vers les sorties en mode configuration
void AllumageGeneral() {
  codergb();
  analogWrite(redPin, CodeR);
  analogWrite(greenPin, CodeG);
  analogWrite(bluePin, CodeB);
}

//effacement du code rgb vers les sorties en sortie de mode configuration avec 1s de temporisation à l'extinction
void ExtinctionGenerale() {
  delay(1000);
  analogWrite(redPin, 0);
  analogWrite(greenPin, 0);
  analogWrite(bluePin, 0);    
}

void codergb() {

  //gestion de la luminosité et du code RGB avant la sortie
  if ( CodeR >= 0 ) {
    CodeR = ColorR - BrightR;
  } 
  else {
    CodeR = 0;
  }
  if ( CodeG >= 0 ) {
    CodeG = ColorG - BrightG;
  } 
  else {
    CodeG = 0;
  }
  if ( CodeB >= 0 ) {
    CodeB = ColorB - BrightB;
  } 
  else {
    CodeB = 0;
  }

  //conditions augmentation de couleur selon un code GRAY.
  if (digitalRead (Cpluspin) == LOW) {
    if ((ColorR <=254) && (ColorG == 0) && (ColorB == 0))  {
      ColorR++;
      delay(20);
    }
    if ((ColorR == 255) && (ColorG <= 254) && (ColorB == 0))  {
      ColorG++;
      delay(20);
    }
    if ((ColorR >= 0) && (ColorG == 255) && (ColorB == 0))  {
      ColorR--;
      delay(20);
    }
    if ((ColorR == 0) && (ColorG == 255) && (ColorB <= 254))  {
      ColorB++;
      delay(20);
    }
    if ((ColorR <=254) && (ColorG == 255) && (ColorB == 255))  {
      ColorR++;
      delay(20);
    }
    if ((ColorR ==255) && (ColorG >= 0) && (ColorB == 255))  {
      ColorG--;
      delay(20);
    }
    if ((ColorR >= 0) && (ColorG == 0) && (ColorB == 255))  {
      ColorR--;
      delay(20);
    }
    if ((ColorR == 0) && (ColorG == 0) && (ColorB >= 0))  {
      ColorB--;
      delay(20);
    }
  }

  //conditions diminution de couleur selon un code GRAY.
  if (digitalRead (Cmoinspin) == LOW) {
    if ((ColorR <=254) && (ColorG == 0) && (ColorB == 0))  {
      ColorR--;
      delay(20);
    }
    if ((ColorR == 255) && (ColorG <= 254) && (ColorB == 0))  {
      ColorG--;
      delay(20);
    }
    if ((ColorR >= 0) && (ColorG == 255) && (ColorB == 0))  {
      ColorR++;
      delay(20);
    }
    if ((ColorR == 0) && (ColorG == 255) && (ColorB <= 254))  {
      ColorB--;
      delay(20);
    }
    if ((ColorR <=254) && (ColorG == 255) && (ColorB == 255))  {
      ColorR--;
      delay(20);
    }
    if ((ColorR ==255) && (ColorG >= 0) && (ColorB == 255))  {
      ColorG++;
      delay(20);
    }
    if ((ColorR >= 0) && (ColorG == 0) && (ColorB == 255))  {
      ColorR++;
      delay(20);
    }
    if ((ColorR == 0) && (ColorG == 0) && (ColorB >= 0))  {
      ColorB++;
      delay(20);
    }
  }
}

attention il est fait mention de variables de luminosité qui ne sont pas utilisées pour le moment, pareil pour la led activity.

j’ai donc créé une fonction "void ExtinctionGenerale() " mais si je la met dans un “else” après le if qui déclenche “AllumageGeneral()”, ça me retarde l’allumage de 1s lors de la pression d’un bouton. c’est pas très génant mais ça risque de l’être lorsque je vais intégrer d’autres fonctions qui elles devront utiliser des tempos plus courtes et dont j’ai pas envie qu’elles soient ralenties par une tempo inutile et qui pourtant s’exécutera.

je voulais donc utiliser un état “RISING”, mais ça n’est possible qu’avec des entrées déclarées en interrupt.
c’est pas un soucis sauf que j’ai l’impression que quand je fais ça, seule la fonction associée (allumage entre autre) est exécutée, du coup le code rgb ne doit pas s’incrémenter (je suppose car la console marche pas, et du coup j’ai viré le code associé).
j’ai essayé en mettant “codergb()” dans “AllumageGeneral()” pour forcer le calcul pendant l’interrupt mais ça marche pas.
y’a une histoire de variables qui doivent être déclarées volatiles mais l’exemple que j’ai trouvé ne fonctionnais qu’avec une variable en LOW/HIGH alors que moi c’est des nombres.

bref, je sais pas comment faire pour activer une seule fois cette fonction d’extinction uniquement à la disparition d’un des boutons qui lance “AllumageGeneral()”.


autre soucis. je voulais faire une fonction blink en utilisant la led interne pour vérifier plus tard quand le bidule sera installé , qu’il est pas planté.
un clignotement toutes les sec.
sauf que ça ralentit tout le programme…

y’a moyen de faire autrement ?


j’ai oublié ma question suivante.

bonjour,

juste une petite remarque sur ton code.Tu as mis un delay dans tous tes tests. Ils peuvent être remplacé par un seul delay avant la fin de la boucle.
Pour ce qui est de la question sur la gestion du temps tu peux aller jeter un œil sur http://arduino.cc/forum/index.php/topic,52996.0.html et particulièrement sur la réponse de fdufnews

Serge