Arduino commande IR

[Lycaon]

bonjour,
je voudrais commander des moteurs CC de jouets par infra-rouge en utilisant Arduino.

Comme je débute ,j'essaie déjà de commander une LED.....

J'ai récupéré une télécommande pour décodeur TNT et la diode démodulatrice du récepteur.(donc appariés)

J'ai identifié les codes qui correspondent aux touches de la télécommande..
exemple :touche "OK"=Ox391
le problème est que si j'appuie de nouveau sur cette touche ,le code est OxB91.
A chaque appui j'ai donc une alternance de code. (391 B91 391....)
Même choses pour les touches P+ et P-
pour P+ ,c'est soit Ox3B2 ou OxBB2
pour P- c'est soit Ox3B3 ou OxBB3

J'ai chargé un programme qui permet d'allumer et d'éteindre une LED avec 2 touches de télécommande.
Dans le programme ,ces touches sont définies ainsi
#define ON_CODE 0xFF02FD // +
#define OFF_CODE 0xFF9867 // -
j'ai modifié les codes en choisissant Ox3B2 et Ox3B3
Comme on peut le prévoir ,la commande fonctionne une fois sur 2 selon que c'est 3B2 ou BB2 (ou 3B3 ou BB3) qui est envoyé.
Comment faire pour que ON_CODE ou OFF_CODE correspondent à 2 valeurs?
Merci pour les conseils (si mes explications sont suffisantes)
-----

[Lycaon]

voici le programme que j'ai chargé (Avant modification des codes)
/*
* IR TEST LED & REMOTE
* Copyleft Snootlab 2012
*/

#include <IRremote.h>

#define RECV_PIN 11
#define LED_PIN 4

#define ON_CODE 0xFF02FD // +
#define OFF_CODE 0xFF9867 // -


IRrecv irrecv(RECV_PIN);
decode_results results;

boolean led = false;

void setup()
{
pinMode(LED_PIN, OUTPUT);
irrecv.enableIRIn(); // Start receiver
Serial.begin(9600);
}


void loop() {
digitalWrite(LED_PIN, led);
// If IR message is received
if (irrecv.decode(&results)) {
if (results.value == OFF_CODE) {
Serial.println("-");
led=false;
}
else if (results.value == ON_CODE) {
Serial.println("+");
led=true;
}

else {
Serial.print("unexpected value: ");
Serial.println(results.value, HEX);
}
irrecv.resume(); // Resume (needed)
}
}

[Lycaon]

Je viens de m'apercevoir que le programme fonctionne à condition d'appuyer suffisamment longtemps pour qu'au moins 2 codes soient décryptés .
Néanmoins,je maintiens ma question.

[Lycaon]

(je n'ai pas pu modifier le message précédent...)
En fait ,le problème venait de la mauvaise directivité de ma télécommande.
Néanmoins ,je maintiens ma question:
Comment modifier le programme pour que le code 3B2 OU BB2 allume la led ,et que le code 3B3 OU BB3 éteigne la led.

[A voir en vidéo sur Futura]

[invite1d577638]

Salut,

J'ai pas lu en détails, mais pourquoi ne pas analyser la fin de la string et allumer et éteindre ta led en fonction de la valeur du dernier caractère ? (3 ou 2 ?) Tu as une fonction CharAt() qui peut sans doute t'aider !

[biloux911]

Bonjour,

+1 pour la solution de Yoruk, mais si il y a deux codes différents j'imagine que ça sert à quelque chose (facilite les nombres avec des chiffres en doublon peut-être ?) dans ce cas tu as juste à ajouter un OU logique : code recu == (code1 || code2). Mais si tu fais la même opération peut importe le code reçu en fait ça ne sert à rien à ce niveau là ^^

[Lycaon]

merci pour les avis.
Je vais cogiter cela!

[invite936c567e]

Bonjour

Je pense qu'il y a un problème de compréhension du principe de fonctionnement des télécommandes IR.

Les commandes ne sont pas transmises par une simple valeur, mais par un protocole un peu plus complexe. Et c'est ce protocole qu'il faut mettre en œuvre pour que la transmission se fasse correctement.

Une commande transmise contient normalement plusieurs éléments :
• Des bits délimitant la trame transmise (start/stop), lesquels ne sont pas à considérer dans l'information délivrée. Les bits de start servent à ajuster le niveau de la commande automatique du gain (circuit AGC).
• Des bits de basculement, qui permettent de distinguer les appuis continus des appuis successifs sur les touches de la télécommande.
• Une adresse de destination désignant l'appareil à commander. En effet, plusieurs appareils pouvant recevoir l'ordre donné (une TV, un décodeur, un lecteur de DVD, un magnétoscope, etc.), il faut bien déterminer lequel est censé l'exécuter. Certaines télécommandes peuvent envoyer des commandes à plusieurs appareils, soit indépendamment (télécommande combo), soit simultanément (télécommande universelle).
• Un numéro d'instruction, indiquant quel ordre doit être exécuté.

La présence d'un bit de basculement explique la succession de codes différents dans ton cas.

J'étais tenté de te donner l'explication des commandes que tu as cités pour le code RC5, mais de toute évidence il ne s'agit pas de ce protocole, du moins pas en ce qui concerne la signification standard des numéros d'instruction qu'on pourrait en tirer.



Pour bien faire, il faudrait extraire les différents éléments de l'information reçue, afin de les traiter séparément comme il se doit.

Toutefois, ta situation particulière autorise qu'on confonde l'adresse de destination et le numéro d'instruction qui occupent les 11 bits de poids faible, et qu'on traite juste séparément le 12^ème bit, qui semble être le seul bit de basculement.

Pour connaitre l'adresse et l'instruction afin de les tester, tu peux faire :

  int code = results.value & 0x7FF;
  switch (code)
  {
  case CODE_ON:
    ...
    break;
  case CODE_OFF:
    ...
    break;
  ...
  default:
    ...
  }

Et pour tester le bit de basculement :

  if (results.value & 0x800)
  {
    ... // quand le bit de basculement est à 1
  }
  else
  {
    ... // quand le bit de basculement est à 0
  }

[Lycaon]

bonsoir,
merci d'avoir pris le temps pour ces explications.
J'ai utilisé le programme IRrecvDump de la librairie IRremote d'Arduino.
à chaque appui de touche j'obtiens un message du type
"Decoded RC5 (12 bits)" suivi d'une valeur comme 3B3 (par exemple)
"Raw(20) "avec 9 groupes de nombres dont j'ignore la signification.

J'ai retrouvé un document simple concernant le code RC5 et j'ai pu vérifier que le premier bit changeait à chaque impulsion.
J'ai compris pourquoi la même touche donnait comme code soit 3B3 ou BB3
en binaire 3B3 c'est 0011 1011 0011
BB3 1011 1011 0011
donc seul le bit de gauche change .
D'après Les 5 bits suivant seraient les bits d'adresse 011 10
Les 6 derniers seraient les bits de commande 11 0011
Ceci m'a permis de mieux comprendre la réponse de PASCAL
Le code 110011 ne correspond pas P- d'après le code RC5.

Par contre ,je n'ai pas compris comment utiliser les bouts de code fournis par PASCAL,en particulier les pointillés et le nombres Ox7FF .


Pour le moment,ce qui me parait le plus à mon niveau (car j'ai encore beaucoup à apprendre!) c'est de placer dans le programme " code recu == (code1 || code2)".
Mais il faut que je réfléchisse aux modification que je dois apporter au programme que j'ai joint.

Cordialement

[invite037b2da2]

Bonsoir Lycaon,

Je n'y connais rien aux protocoles de com infrarouge, en bref il y à une astuce qui devrait marcher

Tu décale les bits qui changent ou tu les annules avec une opération logique genre OFF_CODE & 0xFFFF Avec ça ta constante passe à 2 octets et fais pareil pour ta valeur lue et tu comaprepas les mêmes valeurs dans ce cas.
Bonne chance.

Réda.

[invite037b2da2]

Pardon je viens de voir PA5CAL à ta solution à toi de jouer maintenant.

Réda.

[Lycaon]

merci pour ton avis reda.
Je viens de découvrir la signification du bitwise & que j'avais évidemment pris pour &&.....
C'est pourquoi je ne comprenais rien.
maintenant que j'ai réalisé ce que représentent 0x800 et 0x7FF en binaire je vais voir de plus près l'effet de ce &.


Indépendamment de cela ,est-ce que je pose mes questions dans la bonne section,car ce sont plus de questions qui concernent l'informatique que l'électronique ?

[invite936c567e]

je n'ai pas compris comment utiliser les bouts de code fournis par PASCAL,en particulier les pointillés et le nombres Ox7FF

Les pointillés sont à remplacer par les instructions à exécuter dans les différents cas de figure quand ils surviennent.

Voici quelques explications sur le code que j'ai fourni :

 int code = results.value & 0x7FF;

La valeur hexadécimale 0x7FF correspond à 0111 1111 1111 en binaire. L'opérateur & (ET arithmétique) permet de ne garder de results.value que les bits de cette valeur qui sont à 1, forçant à 0 les autres bits. Cette ligne de code permet donc de prendre les douze bits de droite de results.value et de les enregistrer dans code.

Par exemple, si results.value contient 0xB91 (1011 1001 0001), c'est la valeur 0x391 (0011 1001 0001) qu'on enregistre dans code.

  switch (code)
  {
  case CODE_ON:
    ... // ici les instructions si code=CODE_ON
    break;
  case CODE_OFF:
    ... // ici les instructions si code=CODE_OFF
    break;
  ... // ici d'autres case...break pour d'autres valeurs de code
  default:
    ... // ici les instructions si code ne prend aucune des autres valeurs
  }

L'instruction « switch » permet d'exécuter certaines séquences d'instructions en fonction de la valeur de code.

Si la valeur de code est égale à CODE_ON, alors on exécute les instructions comprises entre « case CODE_ON: » et le « break; » qui suit (et pas les autres) ; si la valeur de code est égale à CODE_OFF, alors on exécute les instructions comprises entre « case CODE_OFF: » et le « break; » qui suit (et pas les autres) ; et ainsi de suite. Si la valeur de code ne correspond à aucune des valeurs prévues dans les case, alors on exécute ce qui suit le « default: » (cette partie est optionnelle).

Ensuite, on passe à ce qui suit l'accolade fermante « } ».

[invite936c567e]

Pour le moment,ce qui me parait le plus à mon niveau (car j'ai encore beaucoup à apprendre!) c'est de placer dans le programme " code recu == (code1 || code2)".

Je comprends ce que tu cherches à faire, mais cette façon de coder est erronée.

En effet, l'opérateur || est un OU logique. Il considère les valeurs de code1 et code2 comme des valeurs booléennes, c'est-à-dire qui valent FAUX lorsqu'il s'agit de valeurs numériques nulles, ou VRAI dans le cas contraire.

Quand code1 et code2 sont non-nuls, « (code1 || code2) » vaut VRAI OU VRAI, qui est égal à VRAI.

Le calcul de l'expression « code_recu == (code1 || code2) » revient alors à tester si code_recu contient la valeur VRAI, c'est-à-dire une valeur différente de zéro.

Et comme code_recu est en principe non-nul, l'expression donne toujours le résultat VRAI.

Bref, en l'état, cette expression ne correspond pas à ce qu'on cherche à faire.


Pour tester si code_recu est égal à code1 ou bien à code2, l'expression correcte est :

(code_recu == code1) || (code_recu == code2)

Dans ce cas, ce sont bien les valeurs numériques qui sont comparées, et le résultat est VRAI si l'une ou l'autre des égalités est vraie.

[Lycaon]

Bonjour,
Merci Pascal pour ces utiles développements.
J'ai bien pigé l'utilisation du & BFF.
Il me reste à modifier le programme initial .
Je reporte à plus tard cette modification car je veux d'abord résoudre deux problèmes qui touchent le portable sur lequel j'ai installé le soft Arduino.(2 touches clavier inactives et restauration impossible )Mais cela n'a rien à voir avec arduino.
Dès que j'aurais mis en pratique les explications concernant le programme arduino ,je donnerai signe .
cordialement

[Lycaon]

bonjour,
J'ai testé avec succès la méthode avec switch(code).
J'étudierai plus tard la seconde méthode
Merci PA5CAL