commande led par IR

Bonjour a tous,

J’ai besoin d’un petit coup de mains pour mener à bien mon projet

je vous explique, je veux allumer et éteindre des led avec ma télécommande mais ça c’est bon j’y arrive sans problème en revanche j’ai un souci pour faire clignoter une des led je dois mal m’y prendre je tres mais tres debutant

pour arriver à mes fin j’utilise ce code glané sur le net et modifier pour mes besoins

#include <IRremote.h>
int RECV_PIN = 11; 
int led1 = 2;
int led2 = 4;
int led3 = 7;
int itsONled[] = {0, 0, 0, 0};

#define code1  0xFF30CF // bouton 1
#define code2  0xFF18E7 // bouton 2
#define code3  0xFF7A85 // bouton 3
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);   
  irrecv.enableIRIn();  
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
}
void loop() {
  if (irrecv.decode(&results)) {
    unsigned int value = results.value;
    switch (value) {
      case code1:
        if (itsONled[1] == 1) {       
          digitalWrite(led1, LOW);  
          itsONled[1] = 0;           
        } else {                      
          digitalWrite(led1, HIGH); 
          itsONled[1] = 1;         
        }
        break;
      case code2:
        if (itsONled[2] == 1) {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        } else {
          digitalWrite(led2, HIGH);
          itsONled[2] = 1;
        }
        break;
      case code3:
        if (itsONled[3] == 1) {
          digitalWrite(led3, LOW);
          itsONled[3] = 0;
        } else {
          digitalWrite(led3, HIGH);
          itsONled[3] = 1;
        }
        break;
    }
    Serial.println(value); 
    irrecv.resume();
  }
}

Merci d’avance pour votre aide

Est-ce pour l'école ?

results.value n'est pas un unsigned int - jetez un œil dans la librairie

Où est votre code de clignotant ?Bien entendu il ne doit pas se trouver dans le "si j'ai reçu une commande IR" puisqu'il faut que la LED clignote même si vous n'appuyer sur aucun bouton

-> regardez l'exemple "Blink without delay" et le tuto d'eskimon sur Introduire le temps

bonjour un grand merci pour votre retour

non ce n'est pas pour l'école je suis modéliste et je souhaite animer les voiture que je monte (feux avant, clignotant, feux stop etc)

Maintenant je vais profiter du dimanche pour insérer un "blink without delay" dans mon code

Merci Stéphan

bon j’ai tenté de faire évoluer mon code mais j’arrive à faire le “blink without delay” seul mais quand je l’intègre dans mon bout de code cela ne clignote pas. si vous avez 5 min merci de me donner votre avis

#include <IRremote.h>
int RECV_PIN = 11;
int led1 = 2;
const int led2 = 4;
int led3 = 7;
int itsONled[] = {0, 0, 0, 0};
int ledState=LOW;
unsigned long previousMillis=0;
const long interval=500;

#define code1  0xFF30CF // bouton 1
#define code2  0xFF18E7 // bouton 2
#define code3  0xFF7A85 // bouton 3
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn();
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
}
void loop()
{
  if (irrecv.decode(&results)) {
    unsigned int value = results.value;
    switch (value) {
      case code1:
        if (itsONled[1] == 1) {
          digitalWrite(led1, LOW);
          itsONled[1] = 0;
        } else {
          digitalWrite(led1, HIGH);
          itsONled[1] = 1;
        }
        break;
      case code2:     
ledclignote (); //je lance ma fonction mais cela ne clignote pas, mais allume et et coupe bien avec la telecommande 
   break;
      case code3:
        if (itsONled[3] == 1) {
          digitalWrite(led3, LOW);
          itsONled[3] = 0;
        } else {
          digitalWrite(led3, HIGH);
          itsONled[3] = 1;
        }
        break;
    }
    Serial.println(value);
    irrecv.resume();
  }
}
void ledclignote ()//ma fonction clignote question faut il un void ou in int 

    {
unsigned long currentMillis=millis();

if(currentMillis-previousMillis>=interval){
previousMillis=currentMillis;

if(ledState==LOW){
ledState=HIGH;
}else{
ledState=LOW;
}

digitalWrite(led2,ledState);
}
}

Bonjour,

Pour faire clignoter ta fonction ledclignote() doit être appelée périodiquement dans loop().
Il faut donc que tu positionne un flag dans le cas code2 et si ce flag est positionné tu appelles ta fonction dans loop().

qu'est ce que tu appelle un flag ultra novice désolé

merci encore

un flag, c'est un indicateur. Généralement c'est un booleen mais on peut utiliser in int comme tu l'as fait pour itsONled qui sont des indicateurs de marche des leds.
Tu peux utiliser itsONled[2] comme indicateur de clignotement.

Merci pour votre réponse mais j'avoue qu'un exemple sur mon code m'aiderai grandement

Merci d'avance

Criaillement Stéphan

voilà

#include <IRremote.h>
int RECV_PIN = 11;
int led1 = 2;
const int led2 = 4;
int led3 = 7;
int itsONled[] = {0, 0, 0, 0};
int ledState = LOW;
unsigned long previousMillis = 0;
const long interval = 500;

#define code1  0xFF30CF // bouton 1
#define code2  0xFF18E7 // bouton 2
#define code3  0xFF7A85 // bouton 3
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn();
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
}
void loop()
{
  if (irrecv.decode(&results)) {
    unsigned int value = results.value;
    switch (value) {
      case code1:
        if (itsONled[1] == 1) {
          digitalWrite(led1, LOW);
          itsONled[1] = 0;
        } else {
          digitalWrite(led1, HIGH);
          itsONled[1] = 1;
        }
        break;
      case code2:
        itsONled[2]=!itsONled[2];   // inverse l'état de lindicateur
        break;
      case code3:
        if (itsONled[3] == 1) {
          digitalWrite(led3, LOW);
          itsONled[3] = 0;
        } else {
          digitalWrite(led3, HIGH);
          itsONled[3] = 1;
        }
        break;
    }
    Serial.println(value);
    irrecv.resume();
  }
  if (itsONled[2])
    ledclignote ();
}
void ledclignote ()//ma fonction clignote question faut il un void ou in int

{
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }

    digitalWrite(led2, ledState);
  }
}

merci je cours tenter ça merci je vous tiens au jus du retour

bon j’ai du faire une bourde en recopiant car j’ai seulement la led sur le bouton 1 qui marche

mais les deux autre nada je sais j’abuse merci d’avance

#include<IRremote.h>
int RECV_PIN=11;
int led1=2;
int led2=4;
int led3=7;
int itsONled[]={0,0,0,0};
int ledState=LOW;
unsigned long previousMillis=0;
const long interval=500;

#define code1 0xFF30CF//bouton1
#define code2 0xFF18E7//bouton2
#define code3 0xFF7A85//bouton3
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn();
pinMode(led1,OUTPUT);
pinMode(led2,OUTPUT);
pinMode(led3,OUTPUT);
}
void loop()
{
if(irrecv.decode(&results)){
unsigned int value = results.value;
switch(value){
case code1:
if(itsONled[1]==1){
digitalWrite(led1,LOW);
itsONled[1]=0;
}else{
digitalWrite(led1,HIGH);
itsONled[1]=1;
}
break;
casecode2:
itsONled[2]=!itsONled[2];//inversel'étatdelindicateur
break;
casecode3:
if(itsONled[3]==1){
digitalWrite(led3,LOW);
itsONled[3]=0;
}else{
digitalWrite(led3,HIGH);
itsONled[3]=1;
}
break;
}
Serial.println(value);
irrecv.resume();
}
if(itsONled[2])
ledclignote();
}
void ledclignote()//mafonctionclignotequestionfautilunvoidouinint

{
unsigned long currentMillis=millis();

if(currentMillis-previousMillis>=interval){
previousMillis=currentMillis;

if(ledState==LOW){
ledState=HIGH;
}else{
ledState=LOW;
}

digitalWrite(led2,ledState);
}
}

voici mon montage au cas ou

Formates ton code (avec CTRL T dans l’IDE) et tu verras immédiatement le problème
Tu as ecrit casecode2: au lieu de case code2:, idem pour casecode3:

bon ça marche un grand merci pour ton aide juste une dernière question il faut que je clique plusieurs fois pour éteindre la led qui clignote y a t'il une astuce ?

oui, le programme n’éteint pas la led.
Tu peux faire ceci;

      case code2:
        itsONled[2] = !itsONled[2]; //inversel'étatdelindicateur
        if (!itsONled[2])
          digitalWrite(led2, LOW);  // éteint la led
        break;

je fait la MAJ et je test merci vraiment

super ça marche

et la cerise sur le gâteau si je veux tout éteindre en une seule touche mais c'est deja super pour tout le reste

merci merci

Vous devriez pouvoir trouver en vous inspirant des autres actions... essayez et postez votre code

bonjour,

donc comme vous me l’avez demandé voici mon code corrigé et fonctionnel. Il y a certainement plus simple mais ça marche, si vous pensez qu’il est possible de l’améliorer je suis preneur. Merci encore pour votre aide

#include<IRremote.h>
int RECV_PIN = 11;
int led1 = 2;
int led2 = 4;
int led3 = 7;
int led4 = 6;
int itsONled[] = {0, 0, 0, 0, 0};
int ledState = LOW;
int ledStatew = LOW;
unsigned long previousMillis1 = 0;
unsigned long previousMillis2 = 0;
const long interval = 500;

#define code1 0xFF30CF//bouton1 Phare
#define code2 0xFF18E7//bouton2 Clignotant gauche
#define code3 0xFF7A85//bouton3 Feux stop 
#define code4 0xFF10EF//bouton4 Clignotants droite
#define code5 0xFF38C7//bouton5 switch off
#define code6 0xFF5AA5//bouton6 warning
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn();
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}
void loop()
{
  if (irrecv.decode(&results)) {
    unsigned int value = results.value;
    switch (value) {
      case code1:// ************** Allume les phares ************** //
        Serial.println("Phare");
        if (itsONled[1] == 1) {
          digitalWrite(led1, LOW);
          itsONled[1] = 0;
        } else {
          digitalWrite(led1, HIGH);
          itsONled[1] = 1;
        }
        break;
      case code2:// ************** Allume le clignotant gauche ************** //
        Serial.println("Clignotant gauche");
        if (itsONled[4] == 1) {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        } else {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        }
        itsONled[2] = !itsONled[2]; //inversel'étatdelindicateur
        if (!itsONled[2])
          digitalWrite(led2, LOW);

        break;
      case code3:// ************** Allume les stop ************** //
        Serial.println("Feux stop");
        if (itsONled[3] == 1) {
          digitalWrite(led3, LOW);
          itsONled[3] = 0;
        } else {
          digitalWrite(led3, HIGH);
          itsONled[3] = 1;
        }
        break;
      case code4:// ************** Allume le clignotant droit ************** //
        Serial.println("Clignotant droite");
        if (itsONled[2] == 1) {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        } else {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        }
        itsONled[4] = !itsONled[4]; //inversel'étatdelindicateur
        if (!itsONled[4])
          digitalWrite(led4, LOW);

        break;

      case code5:// ************** Tout eteindre  ************** //
        Serial.println("switch off");
        if (itsONled[2] == 1) {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        } else {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        }
        if (itsONled[4] == 1) {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        } else {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        }
        if (itsONled[1] == 1) {
          digitalWrite(led1, LOW);
          itsONled[1] = 0;
        } else {
          digitalWrite(led1, LOW);
          itsONled[1] = 0;
        }
        if (itsONled[3] == 1) {
          digitalWrite(led3, LOW);
          itsONled[3] = 0;
        } else {
          digitalWrite(led3, LOW);
          itsONled[3] = 0;
        }
        break;
        break;
      case code6:// ************** warning ************** //
        Serial.println("Warning");
        if (itsONled[2] == 1) {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        } else {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        }
        if (itsONled[4] == 1) {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        } else {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        }
        itsONled[4] = !itsONled[4];
        itsONled[2] = !itsONled[2];//inversel'étatdelindicateur
        if (!itsONled[2])
          digitalWrite(led2, LOW);
        if (!itsONled[4])
          digitalWrite(led4, LOW);

        break;


    }
    Serial.println(value);
    irrecv.resume();
  }
  if (itsONled[2])
    ledclignote();
  if (itsONled[4])
    ledwarning();

}
void ledclignote()//ma fonction clignote

{
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis1 >= interval) {
    previousMillis1 = currentMillis;

    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }

    digitalWrite(led2, ledState);
  }
}
void ledwarning()//ma fonction clignote

{
  unsigned long currentMillis2 = millis();

  if (currentMillis2 - previousMillis2 >= interval) {
    previousMillis2 = currentMillis2;

    if (ledStatew == LOW) {
      ledStatew = HIGH;
    } else {
      ledStatew = LOW;
    }

    digitalWrite(led4, ledStatew);
  }
}

Merci - quelques remarques constructives


ce serait mieux d'utiliser des const byte pour les N° de pins et de ne pas utiliser 1 ou 0 pour les états mais HIGH et LOW partout dans les test et les affectations

ce serait mieux de donner des noms parlants à vos codes IR et aux pins const byte led1 = 2; --> en fait c'est pas top, vaudrait mieux appeler votre constante pharePin par exemple pour la lisibilité. idem pour les autres bien sûr

const byte RECV_PIN = 11;
const byte led1 = 2; // en fait c'est pas top, vaudrait mieux appeler ça pharePin
const byte led2 = 4; // etc...
const byte led3 = 7;
const byte led4 = 6;
const byte itsONled[] = {0, 0, 0, 0, 0};
byte ledState = LOW;
byte ledStatew = LOW;
unsigned long previousMillis1 = 0;
unsigned long previousMillis2 = 0;
const unsigned long interval = 500;

#define Phare 0xFF30CF//bouton1 Phare
#define ClignotantGauche 0xFF18E7//bouton2 Clignotant gauche
#define FeuxStop 0xFF7A85//bouton3 Feux stop 
#define ClignotantDroite 0xFF10EF//bouton4 Clignotant droite
#define ToutEteindre 0xFF38C7//bouton5 switch off
#define Warning 0xFF5AA5//bouton6 warning

et au lieu de faire itsONled[1] = [color=red]0[/color]; faire itsONled[1] = [color=green]LOW[/color]; et au lieu de faire if (itsONled[1] == [color=red]1[/color]) faire if (itsONled[1] == [color=green]HIGH[/color]) (idem bien sûr partout, remplacer les 0 et 1 par LOW et HIGH pour la cohérence).


Vous utilisez un tableau pour mémoriser l'état des LEDs ou le mode du système. const byte itsONled[] = {0, 0, 0, 0, 0}; l'idée en soit n'est pas mauvaise mais comme vous n'utilisez pas un tableau pour les N° de pin ça ne sert pas à grand chose et alourdit la lisibilité du code autant utiliser les variables d'états par pin ou alors mettre les pins dans un tableau correspondant.

Notez que vous utilisez des indices de 1 à 4 et vous avez bien déclaré 5 valeurs, mais l'index 0 n'est pas utilisé. En informatique on compte depuis 0. vous devrez appeller vos LED led0, led1, led2 et led3 plutôt que led1...led4 comme ça leur N° correspondrait à l'indice du tableau.

En fait ce tableau ne sert à rien, vous savez que vous pouvez faire directement un digitalRead() sur la valeur de la pin pour savoir si elle est HIGH ou LOW et vous pourriez juste avoir 2 booléens pour mémoriser s'il faut clignoter ou pas (droite, gauche ou les 2 pour les warnings)

Dans l'absolu comme vous avez 2 modes (un pour les phares (deux états ON ou OFF), un pour les clignotants (5 états ON, OFF, DROITE, GAUCHE, WARNING) il vaudrait mieux traiter cela par 2 variables indiquant l'état du système, ce serait plus lisible.


vous avez 2 break à la suite dans code5


tous vos tests du genre

        if (itsONled[4] == 1) {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        } else {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        }

sont bizarres, non? is la LED4 est allumée vous l'éteignez sinon vous l'éteignez aussi... à quoi sert le test?


si vous regardez bien ce cas:

case code6:// ************** warning ************** //
        Serial.println("Warning");
        if (itsONled[2] == 1) {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        } else {
          digitalWrite(led2, LOW);
          itsONled[2] = 0;
        }
        if (itsONled[4] == 1) {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        } else {
          digitalWrite(led4, LOW);
          itsONled[4] = 0;
        }
        itsONled[4] = !itsONled[4];
        itsONled[2] = !itsONled[2];//inversel'étatdelindicateur
        if (!itsONled[2])
          digitalWrite(led2, LOW);
        if (!itsONled[4])
          digitalWrite(led4, LOW);

        break;

on retrouve ce que je dis plus haut, vos 2 premiers if éteignent dans tous les cas led2 et led4 puis donc vous savez que itsONled[4] et itsONled[2] valent donc 0, vous les inversez (avec de la logique booléenne ce qui n'est pas très propre) et donc passez à HIGH et testez s'ils sont à 0 ce qui n'est donc pas le cas, donc les 2 if ne servent à rien et pire encore votre LED est OFF mais votre tableau isONled est maintenant faux mais que vous utilisez pour déclencher le clignotement . vaut mieux donc écrire juste

      case code6:// ************** warning ************** //
        Serial.println("Warning");

        digitalWrite(led2, LOW);
        digitalWrite(led4, LOW);
        itsONled[2] = 1; // ce qui est abusif 
        itsONled[4] = 1;
        break;

Dans le code pour tout éteindre, ce n'est pas la peine de vérifier l'état des pins puisque vous voulez éteindre, autant tout forcer à LOW directement

      case ToutEteindre:// ************** Tout eteindre  ************** //
        Serial.println("switch off");
        digitalWrite(led1, LOW);
        digitalWrite(led2, LOW);
        digitalWrite(led3, LOW);
        digitalWrite(led4, LOW);
        itsONled[1] = 0;
        itsONled[2] = 0;
        itsONled[3] = 0;
        itsONled[4] = 0;
        break;

ce code là

    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }

est tout à fait fonctionnel et lisible, on peut utiliser l'opérateur ternaire pour écrire la même chose:
ledState = (ledState == HIGH) ? LOW : HIGH; ça fait plus pro :slight_smile: et bien sûr si vous voulez faire le hacker sauvage qui se fiche d'avoir un code conceptuellement intègre faire comme vous avez fait plus haut ledState = ! ledState;


la façon dont vous appelez le clignotement est un peu tirée par les cheveux - vous devriez conceptuellement décider si c'est le clignotant gauche ou droit ou alors les 2. là vous avez une fonction pour led2 et utilisez la fonction warning pour led4 qui sert aussi pour le clignotant droit. Même si c'est fonctionnel (je n'ai pas vérifié si vous pouvez vous trouver dans un cas où le clignotement ne serait pas synchronisé des 2 côtés) c'est plus compliqué à lire.


voilà, j'espère que ces commentaires vont vous aider