utiliser deux chiffres d'une télécommande arduino

[invite56ce0df1]

Bonjour,

Je voulais savoir comment récupérer deux chiffres d'une télécommande, en effet lorsque j'appuie sur le chiffre 2 et après le chiffre 4 je voudrais stocker cette variable afin que cela donne: 24.

CODE chiffres de 0 à 9

#define C0     0x15EA00FF
#define C1     0x15EA807F
#define C2     0x15EA40BF
#define C3     0x15EAC03F
#define C4     0x15EA20DF
#define C5     0x15EAA05F
#define C6     0x15EA609F
#define C7     0x15EAE01F
#define C8     0x15EA10EF
#define C9     0x15EA906F

je compare les résultats, et je sais stocker les chiffres de 0 à 9 DANS UNE VARIABLES " commande_voulue "

if (irrecv.decode(&results)) {
     
     
      Serial.println(results.value, HEX);
      fonctionVolplus();
   switch (results.value) {
     
   case C0 :
     fonction_recherche_titre();
     commande_voulue = 0;
     delay(10);
     break;
     
   case C1 :
     fonction_recherche_titre();
     commande_voulue = 1;
     
     delay(10);
     break;
     
   case C2 :
     fonction_recherche_titre();
     commande_voulue = 2;
     delay(10);
     break;
   case C3 :
     fonction_recherche_titre();
     commande_voulue = 3;
     delay(10);
     break;
   case C4 :
     fonction_recherche_titre();
     commande_voulue = 4;
     delay(10);
     break;
     
   case C5 :
     fonction_recherche_titre();
     commande_voulue = 5;
     delay(10);
     break;
     
   case C6 :
     fonction_recherche_titre();
     commande_voulue = 6;
     delay(10);
     break;
     
   case C7 :
     fonction_recherche_titre();
     commande_voulue = 7;
     delay(10);
     break;
     
   case C8 :
     fonction_recherche_titre();
     commande_voulue = 8;
     delay(10);
     break;
     
   case C9 :
     fonction_recherche_titre();
     commande_voulue = 9;
     delay(10);
     break;E]

comment stoker le chiffre 12 OU 13 ect... dans cette variable ?

merci pour votre aide .
-----

[invitef86a6203]

unsigned char Rcv[2];
int MyNum;

  Rcv[1] =  Rcv[0]; 
  Rcv[0] = commande_voulue;

  Mynum = Rcv[0] + (Rcv[1] * 10) // ABC binaire 
// ou
// Mynum = Rcv[0] + (Rcv[1] * 16) // chiffre binaire en hexa

[invite56ce0df1]

merci pour la réponse,

donc quand je tape deux chiffres il se place dans la variable MyNum; ?

mais pour que les deux chiffres soit pris en compte pas besoin de délay ? en gros on tape deux chiffres par exemple 2 et 3, ma variable stocke le chiffre 23, ma variable commande_voulue contient le 3 donc la dernière touche appuyé ?

si je retape le chiffre 4, alors MyNum contient le chiffre 34 ?

Mon projet consiste à driver un lecteur cd, quand je tape les chiffres de 0 à 9 il va à la piste voulue. donc si je reprend ton exemple cela marchera pour deux chiffres, mais si je tape que le chiffre 5 ma variable MyNum contient 5 ?

merci beaucoup

[Murayama]

Bonjour!

Vous devriez simplifier votre code et procéder sans même utiliser de tableau.
1. La fonction fonction_recherche_titre(); et la fonction delay
sont dans tous les cas du switch. Ces commandes ne varient pas suivant le
"case", alors on peut donc factoriser tout ça et écrire la fonction une seule fois
avant ou après le switch.
2. Quand on entre un chiffre dans une calculatrice, c'est toujours d'abord par
le digit le plus gros. Si vous voulez entrer "24", alors ce sera un 2, puis un 4.
Donc vous pouvez utiliser une variable et à chaque chiffre, vous multipliez
d'abord cette variable par 10, puis vous ajoutez la dernière touche. Cette méthode
est très pratique justement pour faire un mode d'entrée similaire à une calculette.
À chaque chiffre entré, vous affichez le nombre justifié à droite. Alors qu'avec un
tableau, il faudrait attendre de tout avoir pour afficher.
3. Je ne sais pas comment la librairie de télécommande est faite, mais a priori
le delai ne sert à rien. Mais bon si vous ne faites que ça, laissons le.

Exemple: Je veux entrer 2508 dans une variable "my_variable"
my_variable = 0;
// Je presse sur 2:
my_variable *= 10; // Toujours 0
my_variable += 2; // On obtient 2
// Je presse sur 5
my_variable *= 10; // On obtient 20
my_variable += 5; // On obtient 25
// Je presse sur 0
my_variable *= 10; // On obtient 250
my_variable += 0; // On obtient 250
// Je presse sur 0
my_variable *= 10; // On obtient 2500
my_variable += 8; // On obtient 2508

Le code serait alors:

if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    fonctionVolplus();
    switch(results.value) {
    case C0:
        key = 0;
        break;
    case C1:
        key = 1;
        break;
//    Bref, on ne va pas tous les écrire, mais
//    c'est juste pour montrer le principe
    case C9:
        key = 9;
        break;
    }
    fonction_recherche_titre();
    commande_voulue *= 10;
    commande_voulue += key;
    delay(10);
}

Maintenant, je ne sais pas si Arduino fonctionne comme le C standard, mais
dans le cas où les macros fonctionneraient de la même façon, vous pouvez
encore simplifier. Dans tous les "case", la seule chose qui change est un chiffre.
Case 0, commande voulue = 0, case i, commane voulue = i...
Vous pouvez donc remplacer le case somplet par:

#define MAKE_CASE(id)   \
case C##id:                \
   key = id;            \
   break

Votre code devient alors (cette fois ci il est complet parce que bien plus facile à écrire):

if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    fonctionVolplus();
    switch(results.value) {
    MAKE_CASE(0);
    MAKE_CASE(1);
    MAKE_CASE(2);
    MAKE_CASE(3);
    MAKE_CASE(4);
    MAKE_CASE(5);
    MAKE_CASE(6);
    MAKE_CASE(7);
    MAKE_CASE(8);
    MAKE_CASE(9);
    }
    fonction_recherche_titre();
    commande_voulue *= 10;
    commande_voulue += key;
    delay(10);
}

Pascal

[A voir en vidéo sur Futura]

[invite56ce0df1]

Merci beaucoup pour ces explications :

j'ai tester mais cela ne fonctionne pas,

voici le code de fonction_recherche_titre

void fonction_recherche_titre(){
          
          parameter = 0;
          opcode = 0x01;
          parameter =commande_voulue;                // on met les parametres DSA 0
          myDSA.sendMessage(opcode, parameter);

ce qui se passe, lorsque j'appuie sur un boutton, le programme me renvoie directement sur la fonction "fonction_recherche_titre" , finalement je ne peux pas utiliser les deux chiffres. mais seulement de 0 à 9.

Quel galère .......

[Murayama]

Bonjour!

Quel galère .....

Ben pas forcément: le programme ne fait que faire ce que vous lui dites.
Essayez de suivre par la pensée ce qui est fait dans le programme d'origine.
Vous partez de commande_voulue = 0. Vous recevez par exemple C3.
Vous allez entrer dans le case C3 du switch. Vous appelez la commande
de recherche alors que commande_voulue est encore à 0 (est-ce bien ce
que vous voulez??). Ensuite vous avez un délai qui ne sert à rien et vous
sortez. Si vous appuyez sur une autre touche, alors la commande_voulue
est toujours à 3 de par la touche précédente, vous recherchez le titre de 3,
puis vous mettez la commande à la nouvelle valeur. Il me semble que c'est
un peu "fishy" comme méthode. C'est pourquoi j'ai mis la fonction à la fin.
Bref, vous ne prenez en compte qu'un seul chiffre.

Je n'ai (presque) rien changé à votre code. La fonction recherche_titre est appelée
à chaque itération dans votre code comme dans le mien.
Si vous voulez utiliser 2 chiffres, alors il faut détecter qu'il y en a bien 2.
Mais il faut faire attention de savoir si c'est bien ce que vous voulez.
Parce que si vous imposez 2 chiffres, alors pour envoyer un seul chiffre,
vous devrez envoyer par exemple 01.
Exercice: trouvez une combine pour pouvoir envoyer 2 chiffres. Ce sera un
bon début.
Ou alors si vous voulez avoir un nombre arbitraire de chiffres, il va falloir
décider d'une autre touche pour faire l'envoi.
Exemple pour envoyer 1: <1> <send>
Pour envoyer 28: <2> <8> <send>

D'autre part, les variables parameter et opcode ne servent à rien.
Sauf peut-être à debugger, je ne ne me souviens plus du debugger Arduino.
Et peut-être par extension, la fonction entière ne sert à rien puisqu'elle ne
fait que myDSA.sendMessage(0x01, commande_voulue);

Une remarque: vous appelez cette fonction fonction_recherche_titre alors
qu'il est évident que c'est une fonction. Pourquoi pas tout simplement
recherche_titre();

Pascal

[invite56ce0df1]

Bonjour,

merci pour les explications, j'ai essayé d'utiliser des conditions boolean :
si j'appuie sur une touche dédier alors validation = true;

avec une condition if (validation) j'attend un nouvel appuie, la touche appuyé sera dans la variable key, lui même multiplié par 10, et en fin de test je lui dit que validation2 = true;

on rentre dans la condition if(validation2) j'attend un nouvel appuie, la touche sera dans la variable key2, et je l'envoie dans la fonction "recherche_titre99()" a ce moment j'additionne key1 + key2 et j'envoie au leteur.

voici le programme qui ne fonctionne pas évidement:

// VARIABLE CDPRO
  paused = false;  
  arret = true;
  validation = false;
  validation2=false;

}


void loop() {


  // *************************Controle bouton et stockage de la variable**********************************

  boutonLecture = digitalRead(Lecture);
  boutonStop = digitalRead(Stop);
  boutonNext = digitalRead(Next);
  boutonPreview = digitalRead(Preview);

  if (boutonLecture == LOW) { 
    fonctionLecture();  
  }                
  if (boutonStop == LOW)    { 
    fonctionStop();     
  } 
  if (boutonNext == LOW)    { 
    fonctionNext();     
  } 
  if (boutonPreview == LOW) { 
    fonctionPreview();  
  } 

  // ***************************Gestion des entré infrarouges ****************************************** 
  if (! validation){
    if (irrecv.decode(&results)) {
      Serial.println(results.value, HEX);

      switch (results.value) {

      case C1 :
        key1 = 1;
        recherche_titre();
        delay(10);
        break;

      case C2 :
        key1 = 2;
        recherche_titre();
        delay(10);
        break;

      case C3 :
        key1 = 3;
        recherche_titre();
        delay(10);
        break;

      case C4 :
        key1 = 4;
        recherche_titre();
        delay(10);
        break;

      case C5 :
        key1 = 5;
        recherche_titre();
        delay(10);
        break;

      case C6 :
        key1 = 6;
        recherche_titre();
        delay(10);
        break;

      case C7 :
        key1 = 7;
        recherche_titre();
        delay(10);
        break;

      case C8 :
        key1 = 8;
        recherche_titre();
        delay(10);
        break;

      case C9 :
        key1 = 9;
        recherche_titre();
        delay(10);
        break;

      case C99 :
        validation = true;
        delay(10);
        break;


      case VOL_PLUS : 
        delay(10);
        break;

      case VOL_MOIN : 
        fonctionVolmoin();
        delay(10);
        break;

      case NEXT : 
        fonctionNext();
        delay(10);
        break;

      case PREVIEW :
        fonctionPreview();
        delay(10);
        break;

      case LECTURE : 
        fonctionLecture();
        delay(10);
        break;

      case PAUSE : 
        fonctionPause();
        delay(10);
        break;

      case STOP : 
        fonctionStop();
        delay(10);
        break;

      }

      irrecv.resume(); // Receive the next valuE

    }

  }

  if (validation ){

    if (irrecv.decode(&results)&& !validation2) {
      Serial.println(results.value, HEX);

      switch (results.value) {

      case C0 :
        key = 0;
        delay(10);
        break;

      case C1 :
        key = 1;
        delay(10);
        break;

      case C2 :
        key = 2;
        delay(10);
        break;

      case C3 :
        key = 3;
        delay(10);
        break;

      case C4 :
        key = 4;
        delay(10);
        break;

      case C5 :
        key = 5;
        delay(10);
        break;

      case C6 :
        key = 6;
        delay(10);
        break;

      case C7 :
        key = 7;
        delay(10);
        break;

      case C8 :
        key = 8;
        delay(10);
        break;

      case C9 :
        key = 9;
        delay(10);
        break;
      }
      key*=10;
      validation2=true;
      irrecv.resume(); // Receive the next valuE 
    }
  } 

  if (validation2){               
    if (irrecv.decode(&results)) {

      switch (results.value) {

      case C0 :
        key2 = 0;
        delay(10);
        break;

      case C1 :
        key2 = 1;
        delay(10);
        break;

      case C2 :
        key2 = 2;
        delay(10);
        break;

      case C3 :
        key2 = 3;
        delay(10);
        break;

      case C4 :
        key2 = 4;
        delay(10);
        break;

      case C5 :
        key2 = 5;
        delay(10);
        break;

      case C6 :
        key2 = 6;
        delay(10);
        break;

      case C7 :
        key2 = 7;
        delay(10);
        break;

      case C8 :
        key2 = 8;
        delay(10);
        break;

      case C9 :
        key2 = 9;
        delay(10);
        break;
      }

      recherche_titre99();
      irrecv.resume();

    }

  }     



  // ***************************Gestion de la CDPRO ******************************************   



  if(myDSA.transmitRequested()) {                               // si la transmition est demandé
    if(myDSA.receiveMessage(&opcode, &parameter)) {   // si on recetptionne les opcodes et parametre

      switch (opcode) {                             // alors on compare avec les opcodes correspondant
      case 0x01:	//Found
        switch (parameter) {
        case 0x41:	//Paused
          paused = true;
          break;
        case 0x42:	//Pause release
          paused = false;
          break;
        }
        break;
      case 0x02:	//Stopped
        paused = false;
        break;
      case 0x10:	//Actual title
        actualTitle = parameter;
        break;
      case 0x12:	//Actual minutes
        actualMinutes = parameter;
        break;
      case 0x13:	//Actual seconds
        actualSeconds = parameter;
        break;				
      case 0x21:	//Title maximum
        numberOfTracks = parameter;
        break;
      default:

        break;
      }			


      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, LSBFIRST, charTable[actualTitle]);
      digitalWrite(latchPin, HIGH);




    }


  }




}

voici les fonctions :

void recherche_titre(){             
          myDSA.sendMessage(0x01, key1);  
}

void recherche_titre99(){   
          myDSA.sendMessage(0x01, (key + key2));
         
}

[Murayama]

Bonjour!

Le gros problème de votre programme, c'est que vous ne procédez pas méthodiquement.

1. Vous avez 3 switches. Il y en a clairement 2 de trop. Les variables validation
ne servent à rien. Que feriez-vous pour implémenter une calculatrice avec une
télécommande, par exemple? Vous mettriez autant de switches qu'il y a de digits à
l'affichage? Je vous ai expliqué comment faire, vous ne le faites pas.
Il vous faut une variable. À chaque chiffre entré, vous multipliez par 10 et vous
ajoutez le chiffre. Et ceci fonctionne quel que soit le nombre de chiffres, et avec
un seul switch.


2. Je vous l'ai déjà dit et vous n'en tenez pas compte, mais: Dans les switches, vous
avez à chaque "case" le même délai de 10. Cela ne sert à rien puisque vous passerez une
seule fois par itération dans un seul des "case". Donc vous ajoutez des lignes de code qui ne
servent qu'à rendre le code plus confus. S'il faut un délai (ce dont je ne suis pas
certain), alors il ne faut l'écrire qu'une fois dans la boucle.

3. Je vous l'ai déjà dit aussi, maias vous appelez vos fonctions "fonction***" alors que
c'est évident que ce sont des fonctions. Pourquoi fonction_Stop() et pas Stop() tout court.
Si vous avez 2 appareils, alors diversifiez en CD1Stop et CD2Stop mais avec un seul
c'est inutile parce qu'il n'y a rien d'autre à arrêter.
Vous ne pensez pas que ce serait plus simple? Le nom des fonctions est arbitraire,
je sais, mais ça prend du temps à écrire. Bon, ceci dit, cette remarque n'empêchera pas
le code de fonctionner.

4. Une chose que je n'ai pas compris: vous semblez avoir des boutons (enfin votre
montage), puisque vous appelez boutonLecture = digitalRead(); Par contre, Il semble
y avoir des touches de télécommande avec le même effet (case VOL_PLUS, etc...)
Vous commandez à la fois avec la télécommande et avec des boutons sur Arduino?

5. Comme je vous l'ai dit aussi, vos fonctions ne servent à rien. Pourquoi ne pas
grouper vos fonctions en une seule:

void recherche_titre(uint8 cmd) {
    myDSA.sendMessage(0x01, cmd);
}

À la place de recherche_titre, vous appelez recherche_titre(key1);
et à la place de recherche_titre99, vous appelez recherche_titre(key1+key2);


En bref: vous devriez considérer ce que vous faites comme une machine d'état qui
reçoit des messages, un à la fois.

La boucle devrait être (en pseudo code) :

Loop() {
    code = GetITCode();
    switch(code) {
    case number:
        update current value (c'est à deire current_value *= 10; current_value += nombre)
        beak
    case validation:
        send current value, then set it to 0 for next numbers
        break
    case command:
        process command
        break;
    }
    delay(10); (s'il est absolument nécessaire uniquement)
}

Pascal

[invite56ce0df1]

Bonsoir,

Merci d'avoir commenté ce message avec attention, effectivement je débute.
Il est vrai que ce programme est imbuvable...mais c'est un début non ?

Mon projet consiste à faire fonctionner un lecteur cd, pour cela j'utilise une télécommande et 4 boutons en façade.

Dans la boucle Loop, le programme récupère des infos du lecteur cd, notamment les numéros de titre et je les affiches avec deux tubes nixie.
Lorsque je veux passer à la chanson suivante, je fais une commande qui est envoyé au lecteur mais ce n'est pas la même commande que la fonction recherche.

Si je souhaite utiliser la télécommande afin d'aller directement au titre voulu, je suis obligé de récupérer les informations (soit je tape 01 ou 1) et de les envoyées au lecteur par une autre fonction.

j'ai un peu de mal à comprendre le fonctionnement d'un programme, ou du moins les possibilités que l'ont peux faire. j'ai l'habitude de programmé sur des automates industrielles mais ce n'est pas pareil.
j'ai regardé plein de cour, mais la pratique reste quand même plus didacticiel.

je vais essayé de faire ce que vous m'avez énoncé, cela fait un an que je suis sur le programme et des que j'ai du temps perdu je suis dessus.

Merci beaucoup pour votre aide, mais certaine choses ont l'air plutôt sont simple pour vous, ce qui n'est pas le cas pour moi !

[Murayama]

Bonjour!

Je vois. Donc les boutons sont réellement nécessaires.

Ce que j'essaie de vous expliquer, c'est que le problème n'est pas simple seulement
pour moi, il est simple tout court. Même pour un débutant. Il suffit de s'y attaquer
de la bonne façon.
- Je pense que vous comprenez que comme il n'y a qu'une télécommande, il y aura
un message par passage dans la boucle. Il est donc inutile de parcourir des switches
similaires é répétition. Vous regardez quelle touche a été pressée et vous agissez
en conséquence.
- Je vous ai réécrit un pseudo=code ci-dessous. Vous devez utiliser une variable par
exemple tracknum (numéro de piste) et une variable key. Voici 2 simulation de ce que ça
fait dans le cas d'un chiffre (par exemple 9) et de 2 chiffres (par ex. 17)

1. Vous pressez sur la touche 9.
Au départ tracknum = 0. 0 x 10 = 0, 0 + 9 = 9. La variable tracknum contient 9.
2. Comme vous voulez la piste 9 dans cet exemple, vous pressez directement validation.
Dans ce cas, vous envoyez le 9, puis vous remettez tracknum à 0.

Deuxième cas: (envoi d'un nombre à 2 chiffres, par ex. 17)
1. Presser sur 1
2. Update: tracknum = 0. 0 x 10 = 0. 0+1 = 1. Tracknum vaut maintenant 1.
3. Presser sur 7.
4. Update: tracknum = 1. 1x10 = 10, 10 + 7 = 17.
5. Validation: vous envoyez 9, vous remettez tracknum à 0.

Et ainsi de suite. Si vous avez 3 chiffres ou n chiffres, ça continuera à fonctionner
sans aucun changement de code à part le fait qu'à partir d'un certain nombre de chiffres,
la variable va saturer et se transformer en n'importe quoi.

Maintenant, si c'est une commande, vous enovyez directement la commande.

Conclusion: ce que vous avez à faire:
- Enlever les variables de validation qui ne servent à rien
- Réécrire comme ci-dessous:
(à partir de if irrecv.decode(&results) :

    if (irrecv.decode(&results)) {
        key = 10;    //    Par defaut, la touche n'est pas un nombre. Si c'en est un, la
                    //    valeur prendra une valeur entre [0 ... 9]
        Serial.println(results.value, HEX);
        switch (results.value) {
        case Ci :
            key = i;
            break;
        case C99 :    //    Je suppose que c'est la validation
            if(tracknum != 0) {
                myDSA.sendMessage(0x01, tracknum);    //    Envoyer le nombre s'il n'est pas nul
                tracknum = 0;            //    Remettre le numéro de piste à 0
            }
            break;
        case command:        //    Toutes les commandes, play, stop, etc...
            corresponding_command_function();
            break;
        }
        if(key < 10) {    //    Donc key qui était 10 en début de boucle a été modifier. Nous
                        //    avons donc un chiffre.
            tracknum *8 10;
            tracknum += key;
        }
    }

Et voilà. Le programme tiendra en très peu de lignes.
Maintenant, il y a des astuces pour faire encore plus simple. Par exemple en créant
un tableau de boutons, et aussi un tableau de fonctions pour play, pause, etc...
Avantage: si vous voulez ajouter une fonction, vous la déclarez, définissez et
stockez son pointeur dans un tableau, et vous ajoutez un code de touche pour l'appeler.
ET C'EST TOUT! Le programme fonctionnera directement avec la nouvelle fonction
sans aucune modification du programme. Bon, implémetez ce qui est ci dessus, on pourra
voir tout ça quand tout fonctionnera.

Pascal

[invite56ce0df1]

Bonjour,

Merci beaucoup pour cette formidable aide, voilà j'ai modifié le code en espérant qu'il soit bon cette fois ci !

 if (irrecv.decode(&results)) {
    key = 10; // Par defaut, la touche n'est pas un nombre. Si c'en est un, la
    // valeur prendra une valeur entre [0 ... 9]
    Serial.println(results.value, HEX);
    switch (results.value) {
    case C1 :
      key = 1;
      break;
    case C2 :
      key = 2;
      break;
    case C3 :
      key = 3;
      break;
    case C4 :
      key = 4;
      break;
    case C5 :
      key = 5;
      break;
    case C6 :
      key = 6;
      break;
    case C7 :
      key = 7;
      break;
    case C8 :
      key = 8;
      break;
    case C9 :
      key = 9;
      break;
    case C0 :
      key = 0;
      break; 

    case C99 : // Je suppose que c'est la validation
      if(tracknum != 0) {
        myDSA.sendMessage(0x01, tracknum); // Envoyer le nombre s'il n'est pas nul
        tracknum = 0; // Remettre le numéro de piste à 0
      }
      break;
    case VOL_PLUS : 
      break;

    case VOL_MOIN : 
      break;

    case NEXT : 
      parameter = 0;               
      opcode = 0x01;
      parameter = actualTitle + 1;
      if (parameter > numberOfTracks)
        parameter == 1;
      myDSA.sendMessage(opcode, parameter);    
      break;

    case PREVIEW :
      parameter = 0;                // on met les parametres DSA 0
      opcode = 0x01;
      parameter = actualTitle - 1;
      if (parameter == 0)
        parameter = numberOfTracks;
      myDSA.sendMessage(opcode, parameter);
      break;

    case LECTURE : 
      myDSA.sendMessage(0x01,1);
      break;

    case PAUSE : 
      opcode = paused ? 0x05 : 0x04;
      myDSA.sendMessage(opcode, 0);
      break;

    case STOP :       
      actualTitle = 0;      
      opcode = 0x02;
      myDSA.sendMessage(opcode, 0);
      break;
    }
    if(key < 10) { // Donc key qui était 10 en début de boucle a été modifier. Nous
      // avons donc un chiffre.
      tracknum *10;
      tracknum += key;
    }
    irrecv.resume(); // Receive the next valuE 
  }

[Murayama]

Bonjour!

Oui, ça a l'air d'être ça, mais je n'ai aucun moyen de vérifier.

Une remarque:
Que se passe-t-il si vous appuyez 1, puis next? Ce n'est pas prévu, mais il faut
toujours prévoir les choses imprévues parce que vous ne pouvez pas empêcher que
l'utilisateur presse sur un chiffre puis sur une commande. Alors je serais vous,
je remettrais tracknum à 0 dans tous les autres cas.

Autre chose: il n'est peut–etre pas utile de faire tant de cases dans le switch.
Il y a une certaine cohérence dans les codes de télécommande.
Tous commencent par 0x15EA. Du moins tous les nombres.
Ensuite, il y a le numéro symétrique(1) suivi de 0, puis l'opposé binaire (2) du numéro
suivi de l'opposé binaire de 0 qui est F

(1) par symétrique, je veux dire en ordre inverse. Exemple 1 se transforme en 8,
2, se transforme en 4, 3 se transforme en C, etc...
(2) ce que je veux dire par là, c'est que chaque 1 est transformé en 0 et réciproquement.

Exemple: C4
Prenez 4 et inversez l'ordre des bits (0100 -> 0010), vous obtenez 2.

#define C4 0x15EA20DF

Ensuite mettez un 0, prenez l'opposé binaire de 2 (0010 -> 1101 = D)

#define C4 0x15EA20DF

Puis terminez par l'opposé binaire de 0 qui est F.

En bref, si vous regardez uniquement le 5e chiffre du code et que vous l'inversez,
vous avez le chiffre correspondant.

Exemple:

#define C7 0x15EAE01F

E -> 1110 -> 0111 -> 7 (donc C7)

Vous pouvez donc faire une fonction qui au lieu
de fonctionner au cas par cas, calcule le nombre et retoune 10. Mais pour faire cela,
il faut connaître les autres codes de commande, et je ne les ai pas.

Pascal

[invite56ce0df1]

Bonjour,

j'ai tester le programme, lorsque j'appuie sur la touche 5 et je valide, il va à la piste 5. Lorsque j'appuie sur la touche 1 et la touche 2, il va à la piste 2. seulement le dernier chiffre composé est envoyé.

merci