Ir remote et Spot RGB

Bonjour a tous,

j’ai récemment acheté des émetteur , récepteur infrarouge afin de pouvoir copier la télécommande de mes spots RGB.

La partie IR :

La télécommande en question :

J’utilise la bibliothèque Irremote by shirriff en version 2.2.3.

J’ai téléversé le code ci-dessous (IRecvDumpV2) disponible dans les modèles afin de pouvoir enregistrer les signaux.

//------------------------------------------------------------------------------
// Include the IRremote library header
//
#include <IRremote.h>

//------------------------------------------------------------------------------
// Tell IRremote which Arduino pin is connected to the IR Receiver (TSOP4838)
//
int recvPin = 11;
IRrecv irrecv(recvPin);

//+=============================================================================
// Configure the Arduino
//
void  setup ( )
{
  Serial.begin(9600);   // Status message will be sent to PC at 9600 baud
  irrecv.enableIRIn();  // Start the receiver
}

//+=============================================================================
// Display IR code
//
void  ircode (decode_results *results)
{
  // Panasonic has an Address
  if (results->decode_type == PANASONIC) {
    Serial.print(results->address, HEX);
    Serial.print(":");
  }

  // Print Code
  Serial.print(results->value, HEX);
}

//+=============================================================================
// Display encoding type
//
void  encoding (decode_results *results)
{
  switch (results->decode_type) {
    default:
    case UNKNOWN:      Serial.print("UNKNOWN");       break ;
    case NEC:          Serial.print("NEC");           break ;
    case SONY:         Serial.print("SONY");          break ;
    case RC5:          Serial.print("RC5");           break ;
    case RC6:          Serial.print("RC6");           break ;
    case DISH:         Serial.print("DISH");          break ;
    case SHARP:        Serial.print("SHARP");         break ;
    case JVC:          Serial.print("JVC");           break ;
    case SANYO:        Serial.print("SANYO");         break ;
    case MITSUBISHI:   Serial.print("MITSUBISHI");    break ;
    case SAMSUNG:      Serial.print("SAMSUNG");       break ;
    case LG:           Serial.print("LG");            break ;
    case WHYNTER:      Serial.print("WHYNTER");       break ;
    case AIWA_RC_T501: Serial.print("AIWA_RC_T501");  break ;
    case PANASONIC:    Serial.print("PANASONIC");     break ;
    case DENON:        Serial.print("Denon");         break ;
  }
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpInfo (decode_results *results)
{
  // Check if the buffer overflowed
  if (results->overflow) {
    Serial.println("IR code too long. Edit IRremoteInt.h and increase RAWBUF");
    return;
  }

  // Show Encoding standard
  Serial.print("Encoding  : ");
  encoding(results);
  Serial.println("");

  // Show Code & length
  Serial.print("Code      : ");
  ircode(results);
  Serial.print(" (");
  Serial.print(results->bits, DEC);
  Serial.println(" bits)");
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpRaw (decode_results *results)
{
  // Print Raw data
  Serial.print("Timing[");
  Serial.print(results->rawlen-1, DEC);
  Serial.println("]: ");

  for (int i = 1;  i < results->rawlen;  i++) {
    unsigned long  x = results->rawbuf[i] * USECPERTICK;
    if (!(i & 1)) {  // even
      Serial.print("-");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
    } else {  // odd
      Serial.print("     ");
      Serial.print("+");
      if (x < 1000)  Serial.print(" ") ;
      if (x < 100)   Serial.print(" ") ;
      Serial.print(x, DEC);
      if (i < results->rawlen-1) Serial.print(", "); //',' not needed for last one
    }
    if (!(i % 8))  Serial.println("");
  }
  Serial.println("");                    // Newline
}

//+=============================================================================
// Dump out the decode_results structure.
//
void  dumpCode (decode_results *results)
{
  // Start declaration
  Serial.print("unsigned int  ");          // variable type
  Serial.print("rawData[");                // array name
  Serial.print(results->rawlen - 1, DEC);  // array size
  Serial.print("] = {");                   // Start declaration

  // Dump data
  for (int i = 1;  i < results->rawlen;  i++) {
    Serial.print(results->rawbuf[i] * USECPERTICK, DEC);
    if ( i < results->rawlen-1 ) Serial.print(","); // ',' not needed on last one
    if (!(i & 1))  Serial.print(" ");
  }

  // End declaration
  Serial.print("};");  // 

  // Comment
  Serial.print("  // ");
  encoding(results);
  Serial.print(" ");
  ircode(results);

  // Newline
  Serial.println("");

  // Now dump "known" codes
  if (results->decode_type != UNKNOWN) {

    // Some protocols have an address
    if (results->decode_type == PANASONIC) {
      Serial.print("unsigned int  addr = 0x");
      Serial.print(results->address, HEX);
      Serial.println(";");
    }

    // All protocols have data
    Serial.print("unsigned int  data = 0x");
    Serial.print(results->value, HEX);
    Serial.println(";");
  }
}

//+=============================================================================
// The repeating section of the code
//
void  loop ( )
{
  decode_results  results;        // Somewhere to store the results

  if (irrecv.decode(&results)) {  // Grab an IR code
    dumpInfo(&results);           // Output the results
    dumpRaw(&results);            // Output the results in RAW format
    dumpCode(&results);           // Output the results as source code
    Serial.println("");           // Blank line between entries
    irrecv.resume();              // Prepare for the next value
  }
}

Pour les autres télécommandes disponibles à la maison, je récupère bien les informations nécessaires pour pouvoir émettre le signal par la suite .

Encoding  : NEC
Code      : 16D648B7 (32 bits)
Timing[67]: 
     +8950, -4400     + 550, - 550     + 550, - 550     + 550, - 550
     + 550, -1650     + 600, - 500     + 600, -1650     + 500, -1700
     + 550, - 550     + 550, -1650     + 550, -1650     + 550, - 550
     + 550, -1650     + 550, - 550     + 550, -1700     + 550, -1650
     + 550, - 550     + 550, - 550     + 550, -1650     + 550, - 550
     + 550, - 550     + 550, -1650     + 550, - 550     + 550, - 550
     + 550, - 550     + 550, -1650     + 600, - 500     + 550, -1700
     + 550, -1650     + 550, - 550     + 550, -1650     + 550, -1650
     + 600, -1600     + 600
unsigned int  rawData[67] = {8950,4400, 550,550, 550,550, 550,550, 550,1650, 600,500, 600,1650, 500,1700, 550,550, 550,1650, 550,1650, 550,550, 550,1650, 550,550, 550,1700, 550,1650, 550,550, 550,550, 550,1650, 550,550, 550,550, 550,1650, 550,550, 550,550, 550,550, 550,1650, 600,500, 550,1700, 550,1650, 550,550, 550,1650, 550,1650, 600,1600, 600};  // NEC 16D648B7
unsigned int  data = 0x16D648B7;

Par contre pour la télécommande en photo, la réception du signal est la suivante :

Encoding  : UNKNOWN
Code      : 8C4A11CE (32 bits)
Timing[47]: 
     + 150, -1100     + 200, -1000     + 850, - 350     + 850, - 450
     + 150, - 950     + 150, -1150     + 800, - 350     + 900, - 300
     + 250, -1000     + 150, -1050     + 150, -1200     + 650, - 450
     + 800, - 450     + 800, - 350     + 250, -1000     + 800, - 350
     + 150, -1100     + 150, -1100     + 150, -1050     + 150, - 200
     + 450, -3200     + 450, - 700     + 500, - 450     + 150
unsigned int  rawData[47] = {150,1100, 200,1000, 850,350, 850,450, 150,950, 150,1150, 800,350, 900,300, 250,1000, 150,1050, 150,1200, 650,450, 800,450, 800,350, 250,1000, 800,350, 150,1100, 150,1100, 150,1050, 150,200, 450,3200, 450,700, 500,450, 150};  // UNKNOWN 8C4A11CE

Et à chaque réception du signal provenant de la même touche le résultat est différent.

Connaissez vous une méthode d’apprentissage de ce protocole?

Merci pour vos réponses.

J’ai testé d’envoyer le signal brut via IRsendRawDemo présent dans la bibliothèque en utilisant le code suivant:

#include <IRremote.h>

IRsend irsend;

void setup()
{

}

void loop() {
  int khz = 38; // 38kHz carrier frequency for the NEC protocol
  unsigned int irSignal[] = {150,1100, 200,1000, 850,350, 850,450, 150,950, 150,1150, 800,350, 900,300, 250,1000, 150,1050, 150,1200, 650,450, 800,450, 800,350, 250,1000, 800,350, 150,1100, 150,1100, 150,1050, 150,200, 450,3200, 450,700, 500,450, 150}; //AnalysIR Batch Export (IRremote) - RAW
  
  irsend.sendRaw(irSignal, sizeof(irSignal) / sizeof(irSignal[0]), khz); //Note the approach used to automatically calculate the size of the array.

  delay(5000); //In this example, the signal will be repeated every 5 seconds, approximately.
}

Mais aucun résultat … si quelqu’un à une piste je suis preneur.

Akenfufu:
J'ai testé d'envoyer le signal brut via IRsendRawDemo présent dans la bibliothèque en utilisant le code suivant:

Bonsoir
Comment a tu récupéré les valeurs data "RAW" venant de ta télécommande ?

Il est présent dans le moniteur série lors de l'appui sur une touche en utilisant le code IRecvDumpV2.

Cf la fin du résultat ci dessous :

Encoding  : UNKNOWN
Code      : 8C4A11CE (32 bits)
Timing[47]: 
     + 150, -1100     + 200, -1000     + 850, - 350     + 850, - 450
     + 150, - 950     + 150, -1150     + 800, - 350     + 900, - 300
     + 250, -1000     + 150, -1050     + 150, -1200     + 650, - 450
     + 800, - 450     + 800, - 350     + 250, -1000     + 800, - 350
     + 150, -1100     + 150, -1100     + 150, -1050     + 150, - 200
     + 450, -3200     + 450, - 700     + 500, - 450     + 150
unsigned int  rawData[47] = {150,1100, 200,1000, 850,350, 850,450, 150,950, 150,1150, 800,350, 900,300, 250,1000, 150,1050, 150,1200, 650,450, 800,450, 800,350, 250,1000, 800,350, 150,1100, 150,1100, 150,1050, 150,200, 450,3200, 450,700, 500,450, 150};  // UNKNOWN 8C4A11CE