bonjour(ou bonsoir), alors je vous expliques mon problemes(ou mes...), mon but a travers cet activité personnelle, est de fabriquer une telecommande freebox revolution avec un arduino censer être connecter par usb a ma freeplayer, le tout se passes en IR, j'ai a ma disposition une télécommande standard 21 touches fournis avec le kit arduino, la telecommande lance son code et le récepteur IR VS1838B le reçois et transmets l'information vie la clable usb sur la free.

Alors je me doutes bien que le code lancé par la télécommande ne sera pas reconnu par la free, c'est pour ce la que j'ai ajouter au programme une liste étant censer <<changer>> le code recu en code freebox compatibles que j'ai recopier sur ce site: https://dev.freebox.fr/sdk/freebox_player_1.1.4_codes.html

mais tous d'abord ce qui m'as interpeller dans le code c'est le fait qu'il ya des lettres et des chiffres, j'en ai déduis c'est de l'hexadecimal,donc j'ai adapté mon code en conséquence le "x" au mileir ne m'as pas faciliter la taches... je vous montres mon travail de débutant total:

#include <IRremote.h>

int RECV_PIN = 8;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
    int touche[7];
touche[0]=30;//Power
touche[1]=1815;//free
touche[2]=149;//vol+
touche[3]=1410;//vol-
touche[4]=28;//OK
touche[5]=912;//prog+
touche[6]=913;//prog-
touche[7]=209;//info

  Serial.begin(9600);
  irrecv.enableIRIn(); // Initialise le recepteur
}

void loop() {
if (irrecv.decode(&results)) 
{
  int conv;
  switch(results.value) 
  {
    case 16753245: conv=touche[0];break;
    case 16736925: conv=touche[1];break;
    case 16748655: conv=touche[2];break;
    case 16754775: conv=touche[3];break;
    case 16769055: conv=touche[4]:break:
    case 16761405: conv=touche[5];break;
    case 16712445: conv=touche[6];break;
    case 16756815: conv=touche[7];break;
  }
  if (conv>0) 
  { 
    Serial.write(conv, 8);
  }
  irrecv.resume();
}

  }
}

Donc j'ai déja essayé de le compiler le "touche" n'est pas detecter(pas déclarer apperemment)bref, c'est pas vraiment un probleme sa ...

Comme vous avez pu le voir le code envoyé par la telecommande standard s'ecrit sur des millions(du decimal?) mais en faisant la conversion de ce code la avec le code du site de free sa feras l'affaires? le x entre 0(x) et 30(par ex..) m'interpelles je dois le rentrer telles quelle faire une modification?

Je me suis aidé de ce site pour faire le "boulot":https://www.ituilerie.com/wp-content/uploads/TelIRFBX_Thomas_Feillant_V2.pdf

Il explique comment faire avec une telecommande harmony(ce que je n'ai pas) je me suis en quelque sortes inspirée de son code; et le fais de flasher l'arduino pour convertir l'usb en série (c'est quoi la série?) ou en clavier usb y'as juste besoin de sa pour transmettres les infos receuillis de la telecommande vers le recepteur IR (on recois) et de l'arduino vers la freebox player(grace a serial write?)?

BOn voila c'est un peu long, mais j'avais besoin d'exprimer beaucoup de point pour que la comprehension soit maximale. :) 

Ma principale question étant, quelle moyens mettre en oeuvre pour réussir ?

Merci d'avance (y)

-
Edité par serakoc 24 avril 2017 à 3:22:11

En programmation, le 0x veut dire que le nombre qui suit est codé en hexadécimal.

Le x n'a donc aucune signification dans le nombre hormis le fait qu'il indique qu'il s'agit d'hexadécimal.

Exemple :

- 0xAB correspond au nombre AB en hexa et donc au nombre 171 en décimal

- 0x24 correspond au nombre 24 en hexa et donc au nombre 36 en décimal

Le compilateur arduino gère très bien l'hexadécimal donc tu n'es pas obligé en de tout convertir en décimal.

Par exemple, ces 2 lignes ont exactement le même effet :

touche[1] = 0x20;
touche[1] = 36;

----------

Concernant ta variable non déclarée, cela vient du fait que tu déclares ton tableau en variable local de la fonction setup alors que tu devrais le déclarer dans l'espace global.

Ton code actuel :

[...]

void setup()
{
    int touche[7]; // Déclaration dans l'espace local de setup
    [...]
}
 
void loop() {
    [...]
}

Le code que tu devrais avoir :

[...]
int touche[7]; // Déclaration de l'espace global

void setup()
{
    [...]
}
 
void loop() {
    [...]
}

----------

Par contre, j'ai bien peur de te décevoir mais la liaison série USB de l'arduino n'est pas reconnu comme un périphérique HID.

Du coup, tu auras beau envoyer des codes 0x.. sur le Serial, cela n'aura aucun effet sur le Freebox player.

Il te faut une carte capable d'émuler un périphérique clavier HID sur USB pour que cela fonctionne.

d'abord mercide m'avoir répondu, j'ai fais comme tu viens de m'apprendre le tableau dans la fonction loop(), ensuite il est belle et bien possible de faire de l'arduino un clavier HID dans ce lien il l'explique a la fin ( https://www.ituilerie.com/wp-content/uploads/TelIRFBX_Thomas_Feillant_V2.pdf ) pour sa il faut flasher la carte il l'explique aussi sur le site de l'arduino ( https://www.arduino.cc/en/Hacking/DFUProgramming8U2) donc mon code ressemble maintenant a sa :

#include <IRremote.h>

int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
uint8_t buf[8] = { 0 }; 

void setup()
{
    irrecv.enableIRIn();// Initialise le recepteur
  Serial.begin(9600);
   
}

void loop() {
  int touche[8];
touche[0]=0x30;//Power
touche[1]=0x18f;//free
touche[2]=0xe9;//vol+
touche[3]=0xea;//vol-
touche[4]=0x28;//OK
touche[5]=0x9c;//prog+
touche[6]=0x9d;//prog-
touche[7]=0x209;//info

if (irrecv.decode(&results)) 
{
  switch(results.value) 
  {
    case 16753245: buf[2]=touche[0];break;
    case 16736925: buf[2]=touche[1];break;
    case 16748655: buf[2]=touche[2];break;
    case 16754775: buf[2]=touche[3];break;
    case 16769055: buf[2]=touche[4];break;
    case 16761405: buf[2]=touche[5];break;
    case 16712445: buf[2]=touche[6];break;
    case 16756815: buf[2]=touche[7];break;
  }
  if (buf[2] >0) 
  { 
    Serial.write(buf, 8);// appuie sur la touche
    delay(100);           
    releaseKey(); //relache la touche
  }
  irrecv.resume();
}

  }
void releaseKey() 
{
  buf[0] = 0; buf[2] = 0;
  Serial.write(buf, 8);  // signale que l'on relache la touche  

}

j'ai copié le code de Thomas le mien avait pas l'air de tenir la route(c'est surtout la compatibilité... son tableau buf ma perturbé la maniere de typer son "tableau"(sa y ressemble pas vraiment en fait?):uint8_t buf[8] = { 0 };  ma laisser perplexe, bref avec ce programme la pas de soucis (je pense?) sa c'est bien compiler, televersement ok : manque plus qu'a flasher l'arduino et c'est partit, bon dernier soucis..:

le code hex(de Darran Hunt) que passe le tutoriel pour flasher la carte n'est plus bon (le lien n'est pas valide)du coup je compte bien me ressourcé sur le site d'arduino: https://www.arduino.cc/en/Hacking/DFUProgramming8U2 donc petite recherche, je tombe sur le bon: https://github.com/arduino/Arduino/tree/master/hardware/arduino/avr/firmwares/atmegaxxu2/arduino-usbserial c'est le arduino-usbserial-uno.hex qui me semble pertinent donc je lance flip (un bug au départ avec fichier dll lors de la connexion de l'usb: réglé), mais j'ai un autre besoin de connaissance j'ai une arduino uno R3, et lors du choix du "device" il y a plein de nom de modele je ne sais pas lequel choisisr :

donc certes mais il y aussi le fais que quand je choisis mon fichier HEX dans file>load hex files; il me lance "invalid hex file syntax" donc je comprend pas trop.

en bref : Le code = C'est réglé et téléverser; mon principale probleme se penche maintenant sur le flashage de la carte, est-ce que j'ai choisis le bon fichier .hex, quel device choisir ? voila ce sont mes 2 principaux problemes apres ce seras réglé (j'espère en tt cas théoriquement! :p)

ps: https://dyrk.org/2015/10/27/utiliser-votre-arduino-uno-pour-simuler-des-touches-clavier/ un lien utiles qui m'as pas mal aider(j'avais besoin d'avoir acces a d'autre possibilité donc je google et google )

ps: y'as beaucoup de texte encore mais j'arrive pas a faire autrement désolé :s

merci encore (y)

-
Edité par serakoc 24 avril 2017 à 19:43:41

Sur une carte Arduino, il y a 2 processeurs :

- un processeur qui se charge de gérer l'USB (je le nommerais "processeur USB" dans la suite de ce message)

- un processeur qui se charge qui se charge d'exécuter le code arduino (je le nommerais "processeur Arduino" dans la suite de ce message)

Entre ces 2 processeurs, il y a une liaison série hardware (un fil Tx, un fil Rx).

En utilisation normal, on ne touche jamais au processeur de gestion de l'USB.

Ce processeur USB est déjà pré-programmé avec un programme se chargeant d'émuler une liaison série sur le port USB afin de retransmettre toutes les données au processeur arduino qui exécute ton code.

-----

Exemple:

Quand tu fais un Serial.print sur le processeur arduino pour afficher quelque chose, celui-ci envoie les données sur la liaison série hardware.

Vu que la liaison série hardware est reliée au processeur USB, celui-ci reçoit ce que ton programme arduino a envoyé.

Le processeur USB va alors renvoyer ces données au PC par le fil USB au travers de la liaison série qu'il émule sur le port USB.

Ainsi, le PC peut recevoir et afficher que ce le processeur arduino envoie.

-----

Pour en revenir à ton problème, le processeur USB émule une liaison série sur l'USB donc il n'est pas reconnu comme un périphérique HID.

Si tu reprogrammes ce processeur USB, alors tu peux effectivement changer son comportement.

Par exemple, si tu trouves un programme HEX qui se charge d'émuler un périphérique HID plutôt que d'émuler une liaison série, alors tu auras résolu ton problème.

Cependant, encore faut-il trouver le bon fichier HEX à mettre...

Celui que tu proposes se nommant "Arduino-usbserial-uno.hex", j'ai bien peur qu'il s'agisse du programme classique d'émulation d'un liaison série par USB et non un programme d'émulation d'un périphérique HID.

-----

Et pour finir, je tient à te signaler un problème que tu n'as pas anticiper : la reprogrammation !

Quand tu appuis sur le bouton "téléverser" pour envoyer ton nouveau code, le PC se sert du processeur USB et de sa liaison série émulée par USB pour reprogrammer le processeur arduino.

Du coup, si le processeur USB se comporte comme un périphérique HID, le PC n'a plus accès à la laison série émulée par USB pour reprogrammer le processeur aruino.

Si tu constates une erreur dans ton code, il faudra d'abord reprogrammer le processeur USB avec le programme USBSerial classique, puis uploader ton sketch, puis reprogrammer le processeur USB avec le programme HID.

-----

Pour toutes ces raisons, j'ai donc pour habitude de dire que l'arduino UNO se limite à un sérial émulé par USB.

Mais effectivement, si l'on s'en donne les moyens, alors on peut faire beaucoup plus de choses, dont probablement un périphérique HID.

-----

Quand au nom à sélectionner dans ta liste, il s'agit du ATMEGA8U

i'm frozen! réponses très complète j'te remerci lorrio (y)

pour le nom j'ai choisis le 16u puisqu'après observation, le nom est noté sur un "carré" (le processeur dont tu m'as parlé surement) du coup la carte est detecter pas de soucis par contre,

tu sais pas a quoi est du l'erreur "invalid hex file syntax"?

j'ai sauvegarder mon hex d'origine grace a la touche avec la fleche qui sort du bouquin, j'ai telecharger un hex potentiellement faisaible (Arduino-keyboard-0.3) mais quand je clique sur "OK" il me lances cette erreur je sais pas a quoi c'est du ?

edit:c'était un fichier html désolé je te tient au courant si sa a fonctionné j'en profiterais pour fermer le sujet :

-
Edité par serakoc 25 avril 2017 à 0:46:06

Effectivement, la UNO R3 est bien doté d'un 16U2.

C'était les anciennes versions de arduino UNO qui avaient un 8U.

flashage réussi, j'ai réussi à connecter lardui no à la free player donc seul la touche OK fonctionne, l'appui sur les touches est pourtant bien detecter  j'ai bien copier chaque code dont j'avais besoin comme power, prog -/+ sur le programme arduino juste 1tiuche fonctionne ... J'ai vérifier aussi "l'authenticité" du code hex de chaque touche envoyer par la télécommande au récepteur ir c'est bon aussi ...

https://dev.freebox.fr/sdk/freebox_player_1.1.4_codes.html

vu que ok fonctionne avec la bonne touche j'en deduis donc que c'est les code donner par le site free qui ne sont pas compatible avec la Freebox qu'en penses-tu?

-
Edité par serakoc 27 avril 2017 à 13:52:11

Quel est le code arduino que tu as utilisé ?

Et d'où provient le .hex que tu as flashé ?

Le code arduino c'est celui-la: 

#include <IRremote.h>

int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
uint8_t buf[8] = { 0 }; 

void setup()
{
    
  Serial.begin(9600);
  irrecv.enableIRIn();
  // Initialise le recepteur
  delay(200);
}

void loop() {
  
  int touche[11];
  touche[0]=0x30;//Power
  touche[1]=0x18f;//free
  touche[2]=0xe9;//vol+
  touche[3]=0xea;//vol-
  touche[4]=0x28;//OK
  touche[5]=0x9c;//prog+
  touche[6]=0x9d;//prog-
  touche[7]=0x209;//info
  touche[8]=0xe2;//mute
  touche[9]=0xcd;//pause
  touche[10]=0x204;//back

if (irrecv.decode(&results)) 
{
  switch(results.value) 
  {
    case 0xFFA25D: buf[2] = touche[0];break;
    case 0xFF629D: buf[2] = touche[1];break;
    case 0xFF906F: buf[2] = touche[2];break;
    case 0xFFA857: buf[2] = touche[3];break;
    case 0xFF9867: buf[2] = touche[4];break;
    case 0xFFC23D: buf[2] = touche[5];break;
    case 0xFF02FD: buf[2] = touche[6];break;
    case 0xFFB04F: buf[2] = touche[7];break;
    case 0xFFE21D: buf[2] = touche[8];break;
    case 0xFF22DD: buf[2] = touche[9];break;
    case 0xFFE01F: buf[2] = touche[10];break;
    
  }
  if (buf[2] >0) 
  { 
    Serial.write(buf, 8);
    delay(100);
    releaseKey();
  }
  irrecv.resume();
}

  }
void releaseKey() 
{
  buf[0] = 0; buf[2] = 0;
  Serial.write(buf, 8);  // signale que l'on relache la touche  
}

Et le fichier hex recuperer provient de ce site : https://github.com/coopermaa/USBKeyboard/blob/master/firmware/Arduino-keyboard-0.3.hex

Ce que je trouve bizarre c'est que la touche OK fonctionne et pas les autres...

Tout d'abord, buf est déclaré comme un tableau de uint8 donc il ne peut contenir que des valeurs de 0 à 255, ce qui représente 2 digits hexa maxi.

Du vas donc avoir un problème pour :

  touche[1]=0x18f;//free
  touche[7]=0x209;//info
  touche[10]=0x204;//back

----------

Ensuite, je dirais que ta lib émule un clavier classique donc peut-être qu'elle ne fonctionne pas avec tous les codes spéciaux.

Si tu regardes la colonne "Expected code" sur ton lien, il y a la signification de chaque touche.

Pour le OK, il s'agit de "Keyboard / Enter", soit la touche "Entrée" sur un clavier classique.

Vu que cette touche existe sur tous les claviers standards, ta lib arrive à la gérer correctement.

Je pense que les touches "Keyboard / Keypad0-9" fonctionneront aussi car il s'agit des touches numérique sur un clavier.

En revanche, pour les autres code, on a : "Consumer / Power", "Consumer / VCR/TV", "Consumer / AC Exit"... qui sont des touches spéciales qui n'existent pas sur un clavier standard.

Du coup, ta lib ne les gère probablement pas correctement.

-
Edité par lorrio 28 avril 2017 à 10:10:47

Ah ouais d'accord! a la limite je pense mettre que les touches 0 a 9 et les fleches, le code pour les les fleches ressemblent a sa : 0x4f-0x52

et les touches 0-9 : 0x62, 0x59-0x61  Le code 0x62 pour un clavier et 0x59-61 pour le keypad la telecommande que j'ai ressemble a sa 

Celle de gauche

le tiret entre les 2 codes représente quoi, sur la telecommande j'ai 10touches numériques et il me donne que 2 codes? a la limite 0x59 = 89  si je rajoute 10 j'ai 0x63 donc pas de correspondance .. 

ce que je vais faire c'est trouver la correspondance du code chacun de mes touches clavier et les inscrire dans le code assigner a la touche de la telecommande de même pour les fleches(grace a sa http://www.free.fr/assistance/im/faq/assistance/Fbx6/interfacetv/corresp_clavier.png je peux voir quelle touche est relié a quelle fonctions)  je vais voir si sa fonctionne, mais je sais pas a quoi sa correspond 

mon code maintenant

#include <IRremote.h>

int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
uint8_t buf[8] = { 0 }; 

void setup()
{
    
  Serial.begin(9600);
  irrecv.enableIRIn();
  // Initialise le recepteur
  delay(200);
}

void loop() {
  
  int touche[21];
  touche[11]=0x60;//0
  touche[12]=0x61;//1
  touche[13]=0x62;//2
  touche[14]=0x63;//3
  touche[15]=0x64;//4
  touche[16]=0x65;//5
  touche[17]=0x66;//6
  touche[18]=0x67;//7
  touche[19]=0x68;//8
  touche[20]=0x69;//9
  touche[2]=0xaf;//vol+ verif
  touche[3]=0xae;//vol- verfi
  touche[4]=0x28;//OK verif
  touche[5]=0x6b;//prog+ verif
  touche[6]=0x6d;//prog- verif
  // fonctione pas :
   touche[0]=0x30;//Power
  touche[1]=0x18f;//free
  touche[7]=0x209;//info
  touche[8]=0xe2;//mute
  touche[9]=0xcd;//pause
  touche[10]=0x204;//back

if (irrecv.decode(&results)) 
{
  switch(results.value) 
  {
    case 0xFFA25D: buf[2] = touche[0];break;
    case 0xFF629D: buf[2] = touche[1];break;
    case 0xFF906F: buf[2] = touche[2];break;
    case 0xFFA857: buf[2] = touche[3];break;
    case 0xFF9867: buf[2] = touche[4];break;
    case 0xFFC23D: buf[2] = touche[5];break;
    case 0xFF02FD: buf[2] = touche[6];break;
    case 0xFFB04F: buf[2] = touche[7];break;
    case 0xFFE21D: buf[2] = touche[8];break;
    case 0xFF22DD: buf[2] = touche[9];break;
    case 0xFFE01F: buf[2] = touche[10];break;
    case 0xFF6897: buf[2] = touche[11];break;//0
    case 0xFF30CF: buf[2] = touche[12];break;//1
    case 0xFF18E7: buf[2] = touche[13];break;//2
    case 0xFF7A85: buf[2] = touche[14];break;//3
    case 0xFF10EF: buf[2] = touche[15];break;//4
    case 0xFF38C7: buf[2] = touche[16];break;//5
    case 0xFF5AA5: buf[2] = touche[17];break;//6
    case 0xFF42BD: buf[2] = touche[18];break;//7
    case 0xFF4AB5: buf[2] = touche[19];break;//8
    case 0xFF52AD: buf[2] = touche[20];break;//9
 }
  if (buf[2] >0) 
  { 
    Serial.write(buf, 8);
    delay(100);
    releaseKey();
  }
  irrecv.resume();
}

  }
void releaseKey() 
{
  buf[0] = 0; buf[2] = 0;
  Serial.write(buf, 8);  // signale que l'on relache la touche  
}

-
Edité par serakoc 28 avril 2017 à 20:29:55

J'ai reglé le soucis, voila a quoi ressemble le code (18touche sur 21total)

#include <IRremote.h>

int RECV_PIN = 7;
IRrecv irrecv(RECV_PIN);
decode_results results;
uint8_t buf[8] = { 0 }; 

void setup()
{
    
  Serial.begin(9600);
  irrecv.enableIRIn();
  // Initialise le recepteur
  delay(200);
}
void loop() {
  
  int touche[21];
  touche[0]=0x66;//Power ver5f
  touche[1]=0x65;//menu
  touche[2]=0x4f;//fleche droite
  touche[3]=0x50;//       gauche
  touche[4]=0x58;//info verif
  touche[5]=0x52;//fleche haut
  touche[6]=0x51;//       bas  
  touche[7]=0x28;//ok        
  touche[8]=0x63;//XmuteX
  touche[9]=0x46;//XpauseX
  touche[10]=0x45;//XbackX
  touche[12]=0x59;//1
  touche[13]=0x5a;//2
  touche[14]=0x5b;//3
  touche[15]=0x5c;//4
  touche[16]=0x5d;//5
  touche[17]=0x5e;//6
  touche[18]=0x5F;//7
  touche[19]=0x60;//8
  touche[20]=0x61;//9
  touche[11]=0x62;//0
  
if (irrecv.decode(&results)) 
{
  switch(results.value) 
  {
    case 0xFFA25D: buf[2] = touche[0];break;// power
    case 0xFF629D: buf[2] = touche[1];break;//mode
    case 0xFF906F: buf[2] = touche[2];break;//plus
    case 0xFFA857: buf[2] = touche[3];break;//moin
    case 0xFF9867: buf[2] = touche[7];break;// ok
    case 0xFFC23D: buf[2] = touche[5];break;// prog plus
    case 0xFF02FD: buf[2] = touche[6];break;//prog plus
    case 0xFFB04F: buf[2] = touche[4];break;// info 
    case 0xFFE21D: buf[2] = touche[8];break;//mute mort
    case 0xFF22DD: buf[2] = touche[9];break;//pause mort
    case 0xFFE01F: buf[2] = touche[10];break;//back mort
    case 0xFF6897: buf[2] = touche[11];break;//0
    case 0xFF30CF: buf[2] = touche[12];break;//1
    case 0xFF18E7: buf[2] = touche[13];break;//2
    case 0xFF7A85: buf[2] = touche[14];break;//3
    case 0xFF10EF: buf[2] = touche[15];break;//4
    case 0xFF38C7: buf[2] = touche[16];break;//5
    case 0xFF5AA5: buf[2] = touche[17];break;//6
    case 0xFF42BD: buf[2] = touche[18];break;//7
    case 0xFF4AB5: buf[2] = touche[19];break;//8
    case 0xFF52AD: buf[2] = touche[20];break;//9
 }
  if (buf[2] >0) 
  { 
    Serial.write(buf, 8);
    delay(100);
    releaseKey();
  }
  irrecv.resume();
}

  }
void releaseKey() 
{
  buf[0] = 0; buf[2] = 0;
  Serial.write(buf, 8);  // signale que l'on relache la touche  
}

merci lorrio tu m'as bien aider pour les détails technique c'était cool d'apprendre (un peu) avec toi (y)

 du coup projet terminé(touche retour, free, pause introuvable; dommage j'aurais bien aimer remplir les 21 touches de la telecommandes)

Merci encore 

Créer un tableau pour ne faire aucun calcul ni manipulation dessus, ça n'apporte franchement pas grand chose.

Cela prend de la place en mémoire et du temps de calcul pour remplir tout le tableau alors qu'un seul élément sera utilisé.

Tu pourrais très bien t'en passer avec le code suivant :

void loop() {

	if ( irrecv.decode(&results) ) {
	
		switch(results.value) {
			case 0xFFA25D: buf[2] = 0x66; break; // power
			case 0xFF629D: buf[2] = 0x65; break; // mode
			case 0xFF906F: buf[2] = 0x4f; break; // plus
			case 0xFFA857: buf[2] = 0x50; break; // moin
			case 0xFF9867: buf[2] = 0x58; break; // ok
			case 0xFFC23D: buf[2] = 0x52; break; // prog plus
			case 0xFF02FD: buf[2] = 0x51; break; // prog plus
			...
		}
		
		if ( buf[2] > 0 ) {
			Serial.write(buf, 8);
			delay(100);
			releaseKey();
		}
		
		irrecv.resume();
		
	}
	
}

Je te conseille aussi de revoir tes commentaires car ils n'ont pas l'air d'être très correct.

Par exemple, on a :

touche[3]=0x50;//       gauche
case 0xFFA857: buf[2] = touche[3];break;//moin

Comment la touche 3 pourrait être la fois "gauche" et "moins" ???

-
Edité par lorrio 30 avril 2017 à 19:20:11

Alors pour le tableau c'est pour faire plus propre par rapport a moi savoir quelle touche servait a quoi et l'avoir direcetement en visuel quand je manipulais les case switch au liue de passer par le bloc note tous sa ... 

ensuite..  les commentaire dans le switch ->//moins c'est la touche sur la telecommande physique (sa decrit surtout le numéro de case)

et

les commentaires au niveau de l'initialisation du tableau decrivent le code hex de la free, donc //fleche gauche c'est le code hid pour la freebox pour la fleche de gauche 

j'ai placer la commande fleche gauche sur le moins de la telecommande car elle pas de touche flecher...

ouais ta raison maintenant que j'ai plus a changer ceci cela je peux enlever le tableau mais maintenant que c'est sur l'arduino ... (et que sa fonctionne super d'ailleurs (y))

-
Edité par serakoc 30 avril 2017 à 22:41:07

Bonjour

=> Nouveaux codes! :-)

Je déterre le sujet car je viens de terminer ma télécommande FREEBOX 6 en IR, avec une télécommande de chaine Hi-fi Sony, et un Arduino Uno 3, SANS ETHERNET SHIELD (c'est toujours ça d'économisé vu qu'une télécommande Free se trouve maintenant à 20€). Et vive la satisfaction d'avoir fait MA propre telecommande, avec du matos recyclé. Halte au gaspi! ... et quel challenge intellectuel!

J'ai fait un petit programme (voir ci-dessous) qui permet de taper les codes HEX avec un clavier et de les injecter dans le port USB: ça permet de tester toutes les combinaisons. J'ai trouvé des codes supplémentaires (ils sont en décimal, mais j'ai laissé les anciens sont en hexa):

int touche[31]= {

  98,//0

  89,//1

  90,//2

  91,//3

  92,//4

  93,//5

  94,//6

  95,//7

  96,//8

  97,//9

  0x125,//10 AV INOPERANT

  102,//11 power

  41,//12 back

  82,//13 haut

  0x129,//14 free

  0x50,//15 gauche

  40,//16 OK

  0x04f,//17 droite

  60,//18 menu

  81,//19 bas

  61,//20 info

  0x18f,//21 search INOPERANT

  128,//22 vol+

  127,//23 mute

  75,//24 prog+

  129,//25 vol-

  0x136,//26 rec

  78,//27 prog -

  0xcd,//28 play/pause INOPERANT

  0x139,//29 REW INOPERANT

  0x13a,//30 FFW INOPERANT

  };

Il me manque encore AV, Search, Play, REW, FFW, mais ce sont des touches dont je me sers jamais alors j'ai laissé tomber...

Il faut préciser aussi que pour flasher l'ATméga16U2 avec Flip, il faut ENLEVER LES FILS une fois qu'on a connecté la broche RESET à la masse et fait la petite touchette sur le petit composant CMS. Si on laisse le Reset à la masse, Flip ne peut pas ouvrir le port USB... J'ai galéré plusieurs heures avec Flip, les drivers etc. avant de me rendre compte de ça: c'est un point mal expliqué dans la doc de Thomas Feillant (et partout ailleurs aussi).

Voilà j'espère que ces infos feront gagner du temps au prochain qui voudra fabriquer lui-même sa propre télécommande Freebox.

---****----

Au fait...

Je vous joins le petit programme pour taper les codes directement: (bien sûr, dans la partie "SWITCH CASE..." il faudra changer les codes IR avec ceux des touches de votre telecommande...). Le reste, il suffit de 

A noter qu'il faut brancher un LCD 16x2. Pas besoin d'IC 2. Voir brochage à la ligne "const int rs..."

Le récepteur IR TSOP est sur la broche 10.

A noter qu'on peut se passer du bricolage de la variable "g", qui est un truc provisoire bricolé un peu bancal : j'avais un effet rebond et ça effaçait plusieurs caractères quand je faisais retour arrière. Maintenant ca limite l'effacement à 1 seul caractère quand je fais retour arrière.

Ensuite je pense qu'il est assez simple pour se passer de commentaires ... 

//Recherche de Codes clavier pour Telecommande free
//Keyboard report buffer

#include <LiquidCrystal.h>
#include <IRremote.h>

byte buf[8] = { 0 } ; // j'ai toujours pas bien compris le principe de ce buffer, mais bon si il faut en passer par là ...
unsigned int i=0;
String c = "";
bool g=false; // on peut se passer de la variable g ; c'est pour faire 1 correction par appui (j'avais un effet rebond)
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;

IRrecv irrecv(10);
decode_results results;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() 
{
  Serial.begin(9600);
  lcd.begin(16, 2);
  irrecv.enableIRIn();
  pinMode(13,OUTPUT);
  delay(250);
  affiche(); actionneBouton(); // initialise l'affichage
}

void loop() 
{

if (irrecv.decode(&results))
 {
  
  switch(results.value)
  {
    case 0x4CB9C: if (c.length()<6) { c = c + "1"; affiche(); g=false;}; break;// ajoute le chiffre 1 au code entré
    case 0x9CB9C: if (c.length()<6) { c = c + "2"; affiche(); g=false;}; break;// ajoute le chiffre 2 au code entré
    case 0x1CB9C: if (c.length()<6) { c = c + "3"; affiche(); g=false;}; break;// ajoute le chiffre 3 au code entré
    case 0x0CB9C: if (c.length()<6) { c = c + "4"; affiche(); g=false;}; break;// ajoute le chiffre 4 au code entré
    case 0x8CB9C: if (c.length()<6) { c = c + "5"; affiche(); g=false;}; break;// ajoute le chiffre 5 au code entré
    case 0x00F11: if (c.length()<6) { c = c + "6"; affiche(); g=false;}; break;// ajoute le chiffre 6 au code entré
    case 0xCCB9C: if (c.length()<6) { c = c + "7"; affiche(); g=false;}; break;// ajoute le chiffre 7 au code entré
    case 0x2CB9C: if (c.length()<6) { c = c + "8"; affiche(); g=false;}; break;// ajoute le chiffre 8 au code entré
    case 0x00481: if (c.length()<6) { c = c + "9"; affiche(); g=false;}; break;// ajoute le chiffre 9 au code entré
    case 0x003E1: if (c.length()<6) { c = c + "0"; affiche(); g=false;}; break;// ajoute le chiffre 0 au code entré
    case 0x00C81: if (!g) {c = c.substring(0,(c.length())-2); g=true; affiche();}; break;// efface le dernier chiffre
    case 0x00A81: c = ""; affiche(); g=false; break;// efface tout
// là je fais 4 commandes rapides pour "cycler" sans avoir à taper les chiffres et appuyer sur "enter" 
    case 0x1EB9C: i = i + 100; actionneBouton();break; // incrémente de 100 et injecte
    case 0x9EB9C: i = i - 100; actionneBouton();break; // décrémente de 100 et injecte
    case 0x5EB9C: i--; actionneBouton(); break; // incrémente de 1 et injecte
    case 0xDEB9C: i++; actionneBouton(); break; // décrémente de 1 et injecte
    case 0x3EB9C: i = c.toInt(); actionneBouton(); c = ""; affiche();// injecte le code affiché à l'écran 
   }
   releaseKey();
   irrecv.resume();
 }
}

void affiche() // nettoye l'affichage et affiche le code en cours de frappe
{
  digitalWrite(13,HIGH);
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Ind:");
  lcd.setCursor(4,0);
  lcd.print(c);
  lcd.setCursor(9,0);
  lcd.print("Buf:");
  lcd.setCursor(0,1);
  lcd.write("Caractere:");
  digitalWrite(13,LOW);
}

void actionneBouton() // injecte le code dans le freebox, clignote la LED de l'Arduino, et actualise l'affichage
{
  buf[2]=i ;
  digitalWrite(13,HIGH);
  Serial.write(buf, 8);
  c=String(i);
  affiche();
  lcd.setCursor(13,0);
  lcd.print(buf[2]);
  lcd.setCursor(11,1);
  lcd.write(buf[2]);
  digitalWrite(13,LOW);
}

//Relache d'une touche
void releaseKey() 
{
  buf[0]=0;buf[2] = 0; // j'ai toujours pas compris pourquoi on touche à ce buf[0] mais je laisse ça sinon ça boggue...
  Serial.write(buf, 8); // signale que l'on relache la touche  
}

-
Edité par michelpolski 19 février 2018 à 0:55:55

bien joué