IR Arduino Remote Receiver für TSOP7000 und Beo4

[Peter S. (petersieg)]

Moin.
Hatte lange gegoogeln aber nichts wirklich fertiges gefunden.
Einzig ein Hinweis auf die Adafruit IR-Raw Lib/Code brachte dann den 
Erfolg:

https://learn.adafruit.com/ir-sensor/reading-ir-commands
https://github.com/adafruit/Raw-IR-decoder-for-Arduino
https://github.com/adafruit/Adafruit_Learning_System_Guides/tree/main/IR_Sensor/Arduino

Mit IR-Raw den Code als C Array ausgeben lassen.

/* Raw IR decoder sketch!
 
 This sketch/program uses the Arduno and a PNA4602 to 
 decode IR received. This can be used to make a IR receiver
 (by looking for a particular code)
 or transmitter (by pulsing an IR LED at ~38KHz for the
 durations detected 
 
 Code is public domain, check out www.ladyada.net and adafruit.com
 for more tutorials! 
 */
 
// We need to use the 'raw' pin reading methods
// because timing is very important here and the digitalRead()
// procedure is slower!
//uint8_t IRpin = 2;
// Digital pin #2 is the same as Pin D2 see
// http://arduino.cc/en/Hacking/PinMapping168 for the 'raw' pin mapping
#define IRpin_PIN      PIND
#define IRpin          2
 
// the maximum pulse we'll listen for - 65 milliseconds is a long time
#define MAXPULSE 65000
 
// what our timing resolution should be, larger is better
// as its more 'precise' - but too large and you wont get
// accurate timing
#define RESOLUTION 20 
 
// we will store up to 100 pulse pairs (this is -a lot-)
uint16_t pulses[100][2];  // pair is high and low pulse 
uint8_t currentpulse = 0; // index for pulses we're storing
 
void setup(void) {
  Serial.begin(115200);
  Serial.println("Ready to decode IR!");
}
 
void loop(void) {
  uint16_t highpulse, lowpulse;  // temporary storage timing
  highpulse = lowpulse = 0; // start out with no pulse length
  
  
//  while (digitalRead(IRpin)) { // this is too slow!
    while (IRpin_PIN & (1 << IRpin)) {
     // pin is still HIGH
 
     // count off another few microseconds
     highpulse++;
     delayMicroseconds(RESOLUTION);
 
     // If the pulse is too long, we 'timed out' - either nothing
     // was received or the code is finished, so print what
     // we've grabbed so far, and then reset
     if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
       printpulses();
       currentpulse=0;
       return;
     }
  }
  // we didn't time out so lets stash the reading
  pulses[currentpulse][0] = highpulse;
  
  // same as above
  while (! (IRpin_PIN & _BV(IRpin))) {
     // pin is still LOW
     lowpulse++;
     delayMicroseconds(RESOLUTION);
     if ((lowpulse >= MAXPULSE)  && (currentpulse != 0)) {
       printpulses();
       currentpulse=0;
       return;
     }
  }
  pulses[currentpulse][1] = lowpulse;
 
  // we read one high-low pulse successfully, continue!
  currentpulse++;
}
 
void printpulses(void) {
  Serial.println("\n\r\n\rReceived: \n\rOFF \tON");
  for (uint8_t i = 0; i < currentpulse; i++) {
    Serial.print(pulses[i][0] * RESOLUTION, DEC);
    Serial.print(" usec, ");
    Serial.print(pulses[i][1] * RESOLUTION, DEC);
    Serial.println(" usec");
  }
 
  // print it in a 'array' format
  Serial.println("int IRsignal[] = {");
  Serial.println("// ON, OFF (in 10's of microseconds)");
  for (uint8_t i = 0; i < currentpulse-1; i++) {
    Serial.print("\t"); // tab
    Serial.print(pulses[i][1] * RESOLUTION / 10, DEC);
    Serial.print(", ");
    Serial.print(pulses[i+1][0] * RESOLUTION / 10, DEC);
    Serial.println(",");
  }
  Serial.print("\t"); // tab
  Serial.print(pulses[currentpulse-1][1] * RESOLUTION / 10, DEC);
  Serial.print(", 0};");
}

Diesen in ircommander.h erfassen.

/******************* our codes ************/

int Beo4_TV_0[] = {
// ON, OFF (in 10's of microseconds)
  22, 298,
  24, 298,
  22, 1582,
  24, 296,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 1260,
  24, 0};

int Beo4_TV_1[] = {
// ON, OFF (in 10's of microseconds)
  24, 296,
  22, 298,
  24, 1582,
  22, 298,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 618,
  24, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 620,
  22, 618,
  24, 940,
  22, 1262,
  22, 0};

int Beo4_TV_2[] = {
// ON, OFF (in 10's of microseconds)
  24, 298,
  22, 298,
  24, 1580,
  24, 298,
  22, 620,
  22, 620,
  20, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 618,
  24, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 940,
  24, 298,
  22, 1260,
  24, 0};

int Beo4_TV_3[] = {
// ON, OFF (in 10's of microseconds)
  24, 296,
  22, 298,
  24, 1582,
  22, 298,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 620,
  20, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 618,
  24, 940,
  22, 620,
  22, 1260,
  24, 0};

int Beo4_TV_4[] = {
// ON, OFF (in 10's of microseconds)
  24, 298,
  22, 298,
  24, 1580,
  24, 298,
  22, 620,
  22, 620,
  20, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 618,
  24, 618,
  24, 618,
  24, 618,
  22, 620,
  24, 938,
  24, 298,
  22, 618,
  24, 1260,
  24, 0};

int Beo4_TV_5[] = {
// ON, OFF (in 10's of microseconds)
  22, 300,
  22, 298,
  22, 1582,
  24, 296,
  24, 618,
  24, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 620,
  22, 620,
  22, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 940,
  24, 298,
  22, 940,
  22, 1262,
  22, 0};
  
int Beo4_TV_6[] = {
// ON, OFF (in 10's of microseconds)
  22, 298,
  24, 296,
  22, 1584,
  22, 298,
  24, 618,
  22, 620,
  22, 618,
  24, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 620,
  20, 620,
  24, 618,
  22, 940,
  24, 618,
  24, 298,
  22, 1262,
  22, 0};
  
int Beo4_TV_7[] = {
// ON, OFF (in 10's of microseconds)
  24, 298,
  20, 300,
  24, 1580,
  24, 298,
  22, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 620,
  20, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 938,
  22, 620,
  24, 618,
  22, 1262,
  22, 0};
  
int Beo4_TV_8[] = {
// ON, OFF (in 10's of microseconds)
  24, 296,
  22, 300,
  24, 1580,
  24, 298,
  22, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  24, 618,
  22, 940,
  24, 298,
  22, 620,
  20, 620,
  24, 1260,
  24, 0};
  
int Beo4_TV_9[] = {
// ON, OFF (in 10's of microseconds)
  22, 300,
  22, 298,
  22, 1582,
  24, 298,
  24, 618,
  22, 620,
  22, 618,
  24, 618,
  24, 618,
  22, 620,
  24, 618,
  22, 620,
  22, 618,
  24, 618,
  24, 618,
  22, 620,
  24, 938,
  24, 298,
  22, 620,
  24, 938,
  22, 1262,
  22, 0};

Beispielverarbeitung siehe: IR_Commander.ino.

/* Raw IR commander
 
 This sketch/program uses the Arduno and a PNA4602 to 
 decode IR received.  It then attempts to match it to a previously
 recorded IR signal.  Limor Fried, Adafruit Industries
 
 MIT License, please attribute
 check out learn.adafruit.com  for more tutorials!  
 
 2021-06-25 - P. Sieg: used with TSOP7000 ir receiver to decode Beo4 B&O ir remote control
 */

// We need to use the 'raw' pin reading methods
// because timing is very important here and the digitalRead()
// procedure is slower!
//uint8_t IRpin = 2;
// Digital pin #2 is the same as Pin D2 see
// http://arduino.cc/en/Hacking/PinMapping168 for the 'raw' pin mapping
#define IRpin_PIN      PIND
#define IRpin          2

// the maximum pulse we'll listen for - 65 milliseconds is a long time
#define MAXPULSE 65000
#define NUMPULSES 50

// what our timing resolution should be, larger is better
// as its more 'precise' - but too large and you wont get
// accurate timing
#define RESOLUTION 20 

// What percent we will allow in variation to match the same code
#define FUZZINESS 20

// we will store up to 100 pulse pairs (this is -a lot-)
uint16_t pulses[NUMPULSES][2];  // pair is high and low pulse 
uint8_t currentpulse = 0; // index for pulses we're storing

#include "ircommander.h"

void setup(void) {
  Serial.begin(115200);
  Serial.println("Ready to decode IR!");
}

void loop(void) {
  int numberpulses;
  
  numberpulses = listenForIR();
#ifdef DEBUG   
  Serial.print("Heard ");
  Serial.print(numberpulses);
  Serial.println("-pulse long IR signal");
#endif 
  if (IRcompare(numberpulses, Beo4_TV_0,sizeof(Beo4_TV_0)/4)) {
    Serial.println("Beo4_TV_0");
  }
  if (IRcompare(numberpulses, Beo4_TV_1,sizeof(Beo4_TV_1)/4)) {
    Serial.println("Beo4_TV_1");
  }
  if (IRcompare(numberpulses, Beo4_TV_2,sizeof(Beo4_TV_2)/4)) {
    Serial.println("Beo4_TV_2");
  }
  if (IRcompare(numberpulses, Beo4_TV_3,sizeof(Beo4_TV_3)/4)) {
    Serial.println("Beo4_TV_3");
  }
  if (IRcompare(numberpulses, Beo4_TV_4,sizeof(Beo4_TV_4)/4)) {
    Serial.println("Beo4_TV_4");
  }
  if (IRcompare(numberpulses, Beo4_TV_5,sizeof(Beo4_TV_5)/4)) {
    Serial.println("Beo4_TV_5");
  }
  if (IRcompare(numberpulses, Beo4_TV_6,sizeof(Beo4_TV_6)/4)) {
    Serial.println("Beo4_TV_6");
  }
  if (IRcompare(numberpulses, Beo4_TV_7,sizeof(Beo4_TV_7)/4)) {
    Serial.println("Beo4_TV_7");
  }
  if (IRcompare(numberpulses, Beo4_TV_8,sizeof(Beo4_TV_8)/4)) {
    Serial.println("Beo4_TV_8");
  }
  if (IRcompare(numberpulses, Beo4_TV_9,sizeof(Beo4_TV_9)/4)) {
    Serial.println("Beo4_TV_9");
  }
  if (IRcompare(numberpulses, ApplePlaySignal,sizeof(ApplePlaySignal)/4)) {
    Serial.println("PLAY");
  }
    if (IRcompare(numberpulses, AppleRewindSignal,sizeof(AppleRewindSignal)/4)) {
    Serial.println("REWIND");
  }
    if (IRcompare(numberpulses, AppleForwardSignal,sizeof(AppleForwardSignal)/4)) {
    Serial.println("FORWARD");
  }
  delay(500);
}

//KGO: added size of compare sample. Only compare the minimum of the two
boolean IRcompare(int numpulses, int Signal[], int refsize) {
  int count = min(numpulses,refsize);
#ifdef DEBUG 
  Serial.print("count set to: ");
  Serial.println(count);
#endif  
  for (int i=0; i< count-1; i++) {
    int oncode = pulses[i][1] * RESOLUTION / 10;
    int offcode = pulses[i+1][0] * RESOLUTION / 10;
    
#ifdef DEBUG    
    Serial.print(oncode); // the ON signal we heard
    Serial.print(" - ");
    Serial.print(Signal[i*2 + 0]); // the ON signal we want 
#endif   
    
    // check to make sure the error is less than FUZZINESS percent
    if ( abs(oncode - Signal[i*2 + 0]) <= (Signal[i*2 + 0] * FUZZINESS / 100)) {
#ifdef DEBUG
      Serial.print(" (ok)");
#endif
    } else {
#ifdef DEBUG
      Serial.print(" (x)");
#endif
      // we didn't match perfectly, return a false match
      return false;
    }
    
    
#ifdef DEBUG
    Serial.print("  \t"); // tab
    Serial.print(offcode); // the OFF signal we heard
    Serial.print(" - ");
    Serial.print(Signal[i*2 + 1]); // the OFF signal we want 
#endif    
    
    if ( abs(offcode - Signal[i*2 + 1]) <= (Signal[i*2 + 1] * FUZZINESS / 100)) {
#ifdef DEBUG
      Serial.print(" (ok)");
#endif
    } else {
#ifdef DEBUG
      Serial.print(" (x)");
#endif
      // we didn't match perfectly, return a false match
      return false;
    }
    
#ifdef DEBUG
    Serial.println();
#endif
  }
  // Everything matched!
  return true;
}

int listenForIR(void) {
  currentpulse = 0;
  
  while (1) {
    uint16_t highpulse, lowpulse;  // temporary storage timing
    highpulse = lowpulse = 0; // start out with no pulse length
  
//  while (digitalRead(IRpin)) { // this is too slow!
    while (IRpin_PIN & (1 << IRpin)) {
       // pin is still HIGH

       // count off another few microseconds
       highpulse++;
       delayMicroseconds(RESOLUTION);

       // If the pulse is too long, we 'timed out' - either nothing
       // was received or the code is finished, so print what
       // we've grabbed so far, and then reset
       
       // KGO: Added check for end of receive buffer
       if (((highpulse >= MAXPULSE) && (currentpulse != 0))|| currentpulse == NUMPULSES) {
         return currentpulse;
       }
    }
    // we didn't time out so lets stash the reading
    pulses[currentpulse][0] = highpulse;
  
    // same as above
    while (! (IRpin_PIN & _BV(IRpin))) {
       // pin is still LOW
       lowpulse++;
       delayMicroseconds(RESOLUTION);
        // KGO: Added check for end of receive buffer
        if (((lowpulse >= MAXPULSE)  && (currentpulse != 0))|| currentpulse == NUMPULSES) {
         return currentpulse;
       }
    }
    pulses[currentpulse][1] = lowpulse;

    // we read one high-low pulse successfully, continue!
    currentpulse++;
  }
}
void printpulses(void) {
  Serial.println("\n\r\n\rReceived: \n\rOFF \tON");
  for (uint8_t i = 0; i < currentpulse; i++) {
    Serial.print(pulses[i][0] * RESOLUTION, DEC);
    Serial.print(" usec, ");
    Serial.print(pulses[i][1] * RESOLUTION, DEC);
    Serial.println(" usec");
  }
  
  // print it in a 'array' format
  Serial.println("int IRsignal[] = {");
  Serial.println("// ON, OFF (in 10's of microseconds)");
  for (uint8_t i = 0; i < currentpulse-1; i++) {
    Serial.print("\t"); // tab
    Serial.print(pulses[i][1] * RESOLUTION / 10, DEC);
    Serial.print(", ");
    Serial.print(pulses[i+1][0] * RESOLUTION / 10, DEC);
    Serial.println(",");
  }
  Serial.print("\t"); // tab
  Serial.print(pulses[currentpulse-1][1] * RESOLUTION / 10, DEC);
  Serial.print(", 0};");
}

VG Peter

[Kurt (Gast)]

Du zeigst da eine langweilige Reihe von (glaube ich) Code-Abläufen von
irgendeiner IR-Fernsteuerung für irgendein Gerät mit 455 kHz 
Trägerfrequenz.
Wonach hast du denn gesucht?

Gibt es da ein zu steuerndes Gerät, das du bedienen willst - oder eine 
Fernsteuerung, die du entschlüsseln willst? Oder wie, oder was?

Rede einfach mal Klartext:

- Es geht um ...
- Ich will ...
- Ich habe schon ...

[Klaus R. (klaus2)]

Frage schei3e bzw nicht vorhanden, Format ebenso €÷×¥₩%$#@.

Was ist denn daran so schwer sich mal in den Leser rein zu versetzten?

FW, Klaus.

[Peter S. (petersieg)]

Hmm. Liebe Forumsteilnehmer Kurt und Klaus.

Der Forumsbereich hier heißt "Projekte und Code". Ich habe hier ggf. für 
weitere Interessierte aufgezeigt, wie ich das für mein Projekt gelöst 
hatte, eine Beo4 = Bang & Olufson Beo4 Fernbedienung zu nutzen.

Eine Frage ist darin nicht enthalten ;-)

Details zum Projekt (hier: Fernbedienung der Spiele) - wen es 
interessiert:
https://github.com/petersieg/ScopeClock-alt

Ansonsten aber noch frohe Weihnachtsfesttage.

VG Peter

[Klaus R. (klaus2)]

Peter S. schrieb:
> Der Forumsbereich hier heißt "Projekte und Code".

Ok, muss man erstmal wissen...etwas mehr prosa schadet nicht. Und irmp 
ist dafür auch geeignet, oder was ist das besondere an deiner Lsg.?

Peter S. schrieb:
> Ansonsten aber noch frohe Weihnachtsfesttage.

Dito!

Klaus.

[Schlaumaier (Gast)]

Der Thread ist zwar schon 6 Monate alt, die Lösung ist viel einfacher.

Man braucht den Unsinn nicht i.d.R.

Man nehme ein Empfänger (richtige Khz-Zahl sonst ausprobieren, so teuer 
sind die Empfänger nicht) !!!, baue ihn in die Schaltung ein. Nehme 
seine FB und das IR-Scan Prg. (findet man im Netz).  Draufdrücken und 
auf den Serial-Monitor die Zahl ablesen und mit der Taste aufschreiben.

Nun die Zahl an die IR-Send-Diode schicken und das war's.

So habe ich von ALLEN FB's "Backups" gemacht. Und genau so funktioniert 
eine Commando-Steuerung von mir. Die via Tasten-Makros jede Menge 
Befehle an jeden Menge Geräte sendet.