Funksteckdose fernsteuern mit Arduino

Achtung: Diesen Artikel habe ich waehrend meiner Schulzeit mit nur laienhaften Kenntnissen geschrieben. Es koennen grobe Fehler enthalten sein.

Kaffee fertig zum Weckerklingeln oder Geraete einfach per Computer ein und ausschalten. Ich steuer alles gerne ueber meinen Homeserver/DesktopPC, der aufgrund seines Stromverbrauchs von nur ca 10Watt immer laeuft, und da ich mir letztens eine kleine Kaffeemaschine gekauft habe war es nur eine Frage der Zeit bis mein PC auch Herr ueber die Kaffeemaschine/Steckdosen werden sollte. Ich hatte noch ein Set Funksteckdosen von Elro, das ich mal fuer 10€ bei Media Markt gekauft hatte, das sich hierfuer anbot. Aufgrund des niedrigen Preises und der hohen Sicherheit (vgl. zusammengebastelte 240V Relays), zusaetzlich Draht- und trotzdem Batterielos, eignet sich so ein Funksteckdosenset fuer solche Vorhaben am besten. Funksteckdosen mit einem Arduino verbinden mag auf den ersten Blick zwar kompliziert wirken, aber eigentlich duerfte das jeder Anfaenger koennen. Das noetige Wissen dazu werde ich euch in diesem Tutorial versuchen zu vermitteln. Ich habe im Internet 1-2 Artikel gefunden, die sich auch mit diesem Thema beschaeftigen, jedoch beschraenken die sich meist einfach auf eine Library deren Befehle man sich ersteinmal anschauen muss (und dann vielleicht trotzdem nichts mit den ausgegebenen Werten anfangen kann), obwohl eine genaue Beschaeftigung und selbststaendige Messung+Programmierung genausoschnell gehen wuerde (und man hierbei noch einen deutlichen Lerneffekt hat). Fangen wir also an:

Anforderungen
Encodieren der Tasten
Senden
Schalten mit dem PC(Linux)

Anforderungen

Wir brauchen: Ein 434Mhz Funksteckdosenset (Es kann auch 433Mhz oder 433.92Mhz etc. sein), einen 434Mhz Empfaenger und einen 434Mhz Sender. Ich werde mit dem Watterott Empfaenger und Sender arbeiten und ich empfehle diese auch zu kaufen. Mit Versand kommt ein Gesammtpreis von 11.20€ zustande, der nun wirklich nicht hoch ist (Abgesehn davon hat Watterott ne Menge gute Sachen, die die Versandkosten druecken wuerden). Dies ist nahe an der guenstigsten Moeglichkeit und hat den Vorteil, dass sich diese Modelle besonders leicht verwenden lassen. Ein Arduino sollte auch noch in Besitz sein und du solltest wenigstens Wissen, wie man damit Leds leuchten laesst. Sollte dies nicht der Fall sein, solltest du dich erstmal in langweiligen Led-Tutorials (z.B. Hier) damit vertraut machen. Natuerlich brauchst du auch noch was zum Verbinden, sprich Kabel/Draht oder aehnliches. Zum Messen werden wir den Mikrofonanschluss deines PCs benutzen, also solltest du irgendwie ein beidendiges 3.5mm(Klinke)Kabel haben oder irgendwas anderes um an die Kontakte zu kommen.
Fuer den PC brauchst du noch die Software Audacity.
Optimal: Breadboard (ich nutze meist ein kleines 3€(Endpreis!) Board von Ebay). Es geht auch ohne, aber das kann zu Frust fuehren. Die von mir genannte Hardware ist Breadboard ausgelegt. Da ein Breadboard guenstig ist und immer wieder gebraucht wird, sollte dies nirgendswo fehlen.

Encodieren der Tasten

Wenn du alle Bestandteile hast und dich auch ein wenig mit der Funktionsweise der Funksteckdose vertraut gemacht hast, sprich die beigelegte Anleitung, gelesen hast [damit es nicht daran scheitert, dass du vergessen hast, Fernbedienung und Steckdosen aufeinander abzustimmen], koennen wir anfangen den Empfaenger anzuschliessen. Zuvor moechte ich dir aber noch erklaeren was wir genau machen:

Ein Mikrofon wandelt eigentlich nur Schalldruck in Spannungsaenderungen um (mehr?: Wikipedia). Unser Empfaenger wandelt Elektromagnetische Wellen der Frequenz 434Mhz in Spannungsaenderungen um. Da den PC nur die Spannungsaenderung interessiert kann, bietet es sich an den Empfaenger als Mikrofon anzuschliessen um dann die Fernbedienung(bzw. die Tastendruecke) aufzunehmen und zu analysieren. Dies geht mit Audacity meiner Meinung nach am besten. Hier koennen wir uns die Signale genau anschauen. Erstmal muessen wir jedoch den Empfaenger anschliessen:

Es ist hilfreich wenn ihr euch erstmal das Dokument zum Modul durchliest.

Ich habe aufgrund der schlecht unterscheidbaren Kabel, einfach mal farbige Linien drueber gezeichnet. (Orange: Ground | Gelb: Daten | Blau: 5V)

Der Arduino dient jetzt nur als Stromzufuhr, da der Empfaenger leider nicht Passiv arbeitet. Achtet bitte genau auf die Verkabelung, sodass kein Kurzschluss entsteht. Ich habe einen Adapter verwendet, weil der 3.5mm Anschluss mir ein wenig zu klein war. Sollte dich die Verkabelung vor ein Raetzel stellen, solltest du dich eventuell ueber Breadboards informieren. Wenn trotzdem etwas unverstaendlich sein sollte, zoeger nicht die Kommentarfunktion zu benutzen, damit ich dieses Tutorial ausbesseren kann.

Wenn wir nun alles angeschlossen haben (moeglichst nicht direkt vor der Tastatur, sonst koennte es gleich schnell wieder kaputt gehen) koennen wir nun anfangen den Funk zu entschluesseln. Dafuer nutzen wir nun Audacity. Du solltest evtl. vorher schon ein wenig Erfahrung mit Audacity sammeln indem du einfach ein Micro anschliesst du irgendwas aufnimmst. Audacity ist etwas komplexer als einfache Aufnahmeprogramme auch wenn wir eigentlich nur den leicht erkennbaren Aufnahme- und Stopbutton brauchen werden. Stelle einfach sicher, dass der Mikrofonanschluss nicht in den Systemeinstellungen gemuted ist oder du den falschen Anschluss ausgewaehlt hast. Dies ist keine grosse Herrausforderung, aber es waere aerglich, wenn man nichts empfaengt und glaubt man haette etwas auf dem Breadboard falsch verkabelt. Dieses Wissen ist auch fuer jede Menge anderer Projekte sinnvoll. Falls du also noch keine Ahnung von Audacity hast, ist es keinenfalls Zeitverschwendung.

So, jetzt solltest du einfach den Empfaenger als Mikrofon anschliessen und mit Audacity aufnehmen koennen. Du solltest ein leichtes Rauschen sehen koennen (auf dem “Diagram” der Audiospur von Audacity) wenn du auf Aufnehmen drueckst. Wenn du nun die Fernbedienung in die Naehe des Empfaengers haelst und eine Taste drueckst, sollte es einen staerkeren Ausschlag geben. Nach der Aufnahme drueckst du auf den Stopbutton um die Aufnahme zu stoppen und dir die Aufnahem anzusehen.

Wenn du mit <ctrl> bzw. <strg> (je nach Tastaturlayout) und Scrollrad reinzoomst kannst du dir die Aufnahme genauer ansehen.

Du wirst merken, dass jeder Tastendruck aus mehreren Staffeln mit den selben Ausschlag-Mustern besteht. Du musst dir eigentlich nur die negativen Ausschlage ansehen, die kleinen positiven sind lediglich eine physikalische Wechselwirkung auf die negativen. Die genaue Ausschlagsstaerke kannst du auch vernachlaessigen, denn du solltest aus dem Muster erkennen, dass es sich um einen Binaercode handelt, der mehrere Male (um Fehlsignale zu verhindern muss der Code mehrmals empfangen werden) gesendet wird. Obwohl Binaercode eigentlich aus An und Aus (1 und 0) besteht, kann man dies nicht genau hierdrauf anwenden, denn sonst wuerden ja die halbe Zeit Code gesendet (der zwar nur aus 0en besteht, aber dadurch koennte man z.B. 0010 und 0100 nicht unterscheiden). Deshalb bestehen die 1en und 0en nochmal selbst aus einem Code. Zusaetzlich kommt noch ein Synchronisationssignal, damit der Empfaenger erkennt, wo der Anfang und das Ende ist. Du kannst selber versuchen den Code zu dechiffrieren, was relativ schwer ist, wenn man es zum ersten Mal macht, oder einfach dir die Loesung angucken:

Dies ist ein Beispielcode. Du kannst einen anderen haben. Sollte der Code ganz anders aussehen, sprich du kannst deinen Code nicht so mit 1en und 0en ausfuellen, hast du evtl. ein anderes Modell das neben 1 und 0 [+x(sync)] noch ein weiteres Zeichen hat. Da ich so ein Modell nicht habe, kann ich leider auch nichts dazu abbilden, aber es laeuft nach dem selben Prinzip ab. Du solltest improvisieren koennen. Wenn du nicht weiterkommst, kannst du mich notfalls mit Screenshots versorgen und ich erweiter dann das Tutorial.

0= Kurzer Ausschlag, Lange Pause, Langer Auschlag, kurze Pause
1= Kurzer Ausschlag, Lange Pause, Kurzer Ausschlag, Lange Pause
x(Sync-Signal)=Kurzer Ausschlag, Sehr lange Pause

Ein Code besteht also aus 12Bits(0en und 1en)+1Sync-Signal(x). Die einzelnen Bits(Mit der Zeitleiste abgemessen: ca 2.8ms) koennte man selbst nochmal in 8Bits(a 350us) (Diesmal An/Aus) unterteilen. Dies macht das spaeter Umsetzen mit dem Arduino einfacher.

0=10001110 (8bits a’350us; insg.: 2.8ms)       [An: 350us | Aus: 1050us | An: 1050us | Aus: 350us]
1=10001000  (8bits a’350us; insg.:2.8ms)      [An: 350us | Aus: 1050us | An: 350us | Aus: 1050us]
x=100000000000000000000000000000000 (32Bits a’350us; insg.: 11.2ms)   [An: 350us | Aus: 10.85ms]

Du solltest nun aus jeder Taste so einen Code bilden koennen. Bei mir sehen die Codes so aus:

_            On            |            Off
A   000111000010x  |  000111000001x

B   000110100010x  |  000110100001x

C   000110010010x  |  000110010001x

D   000110001010x  |  000110001001x

Man erkennt, dass die ersten 5 Bits immer gleich sind. Dies ist die Verschluesselung die man in der Fernbedienung und den Empfaengern einstellen kann. Praktischerweise passt die 5 Bits genau zu den 5 Schaltern (mit 0=Unten und 1=Oben).

Die Naechsten 5 Bits sind bei jedem Buchstaben gleich. Sie entsprechen also dem Buchstaben. Auch hier passt die Reihenfolge wie angegossen [A:10000 | B:01000 |… ]

Die letzten zwei Bits sind immer bei On oder Off gleich. [On:10 | Off: 01]

Das x am Ende ist wie schon vorher angesprochen das Sync-Signal, dass die Bitcodes trennt und somit Anfang und Ende einer Reihenfolge definiert. Dies ermoeglicht das mehrfache Wiederholen des Codes, denn die Steckdosen wollen den Code mehrmals hintereinander empfangen, damit sie wissen, dass es nicht nur ein zufaellig passendes Stoersignal ist (siehe Elektrosmog).

So koennten wir uns jetzt auch ohne messen den Code ausrechnen, was darauf hinweisst, dass unser Codesystem auch richtig ist. Wir sind mit diesem Kapitel also fertig. Als naechstes wollen wir den Code auch senden.

Senden

Eigentlich koennten wir den Sender auch mit passender Stromversorgung am Audioausgang des PCs anschliessen und einfach die Aufnahme abspielen. So wuerden wir genau das senden, was wir auch empfangen/aufgenommen haben. Dies ist jedoch eine sehr unelegante Loesung und wenn wir Musik abspielen wuerden, wuerde der Sender die ganze Zeit dazu irgendwas senden und viel Elektrosmog produzieren. Wir modulieren das Signal also mit dem Arduino nach. Dies ist durch unseren Binaercode ziemlich einfach.

Zuerst muessen wir den Sender anschliessen:

Du solltest alles erkennen koennen, zusaetzlich steht auf dem Sender selbst noch, was wohin muss. Ansonsten guck einfach in das Dokument von oben.

Nun basteln wir uns den Code fuer den Arduino:

Zuerst schreiben wir eine Funktion, die 1,0 oder x sendet.

void sendByte(char i) { //Diese Funktion soll 0,1 oder x senden koennen. Wir speichern die gewuenschte Ausgabe in der Variabel i
  switch(i){ //nun gucken wir was i ist
  case '0':{ //Der Code fuer '0'
    digitalWrite(rc_pin,HIGH);
    wait(1); //da die Pausen x*350us lang sind, machen wir daraus eine Funktion
    digitalWrite(rc_pin,LOW);
    wait(3);
    digitalWrite(rc_pin,HIGH);
    wait(3);
    digitalWrite(rc_pin,LOW);
    wait(1);
    return;
  }
  case '1':{ //Der Code fuer '1'
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(3);
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(3);
    return;
  }
  case 'x':{ //Der Code fuer x(sync)
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(31);
  }

}
}

void wait(int x) {
  delayMicroseconds(x*350); //warte x*350us
}

Nun brauchen wir noch eine Funktion die einen Code in die Bits unterteilt.

boolean sendCode(char code[]){ //empfange den Code in Form eines Char[]
  for(short z = 0; z<7; z++){ //wiederhole den Code 7x
    for(short i = 0; i<12; i++){ //ein Code besteht aus 12bits
      sendByte(code[i]);
    }
  sendByte('x'); //da der code immer mit x/sync abschliesst, brauchen wir den nicht im code und haengen es automatisch immer hinten ran.
  }
  return true;
}

Nun fuegen wir den Code zusammen:

short rc_pin=13; //der Pin auf dem der Datenpin des Senders angeschlossen ist.

void setup() {
  pinMode(rc_pin, OUTPUT);  //definiere rc_Pin als Ausgang (schliesslich wollen wir senden)
}

void loop() {
sendCode("000110010001"); //sende den Beispiel Code[Aus]
delay(1000);
sendCode("000110010010"); //sende den Beispiel Code[An]
delay(1000);
}
boolean sendCode(char code[]){ //empfange den Code in Form eines Char[]
  for(short z = 0; z<7; z++){ //wiederhole den Code 7x
    for(short i = 0; i<12; i++){ //ein Code besteht aus 12bits
      sendByte(code[i]);
    }
  sendByte('x'); //da der code immer mit x/sync abschliesst, brauchen wir den nicht im code und haengen es autisch immer hinten ran.
  }
  return true;
}
void sendByte(char i) { //Diese Funktion soll 0,1 oder x senden koennen. Wir speichern die gewuenschte Ausgabe in der Variabel i
  switch(i){ //nun gucken wir was i ist
  case '0':{ //Der Code fuer '0'
    digitalWrite(rc_pin,HIGH);
    wait(1); //da die Pausen x*350us lang sind, machen wir daraus eine Funktion
    digitalWrite(rc_pin,LOW);
    wait(3);
    digitalWrite(rc_pin,HIGH);
    wait(3);
    digitalWrite(rc_pin,LOW);
    wait(1);
    return;
  }
  case '1':{ //Der Code fuer '1'
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(3);
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(3);
    return;
  }
  case 'x':{ //Der Code fuer x(sync)
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(31);
  }

}
}

void wait(int x) {
  delayMicroseconds(x*350); //warte x*350us
}

Nun sollten wir problemlos eine Funksteckdose mit dem Arduino ein und ausschalten koennen. Leider nicht auf Befehl, aber dazu kommen wir nun im naechsten Kapitel.

Sebastian hat in den Kommentaren noch einen Code für die Lidl Funksteckdosen RC-710 von Libra gepostet, den ich euch nicht vorenthalten will. Da Copy&Paste aus den Kommentaren nur begrenzt geht (z.B. ‘ ” ‘ wird mit einem anderen Symbol ersetzt), gibt es den auch hier in formatierte und kopierbarer Form:

#define ch1on "10110000000000010001"
#define ch1off "10110000000000000000"
#define ch2on "10110000000010010011"
#define ch2off "10110000000010000010"
#define ch3on "10110000000001010000"
#define ch3off "10110000000001000001"
#define ch4on "10110000000011010010"
#define ch4off "10110000000011000011"
#define chMon "10110000000011110000"
#define chMoff "10110000000011100001"
#define dimmUp1 "10110000000000001010"
#define dimmDn1 "10110000000000011011"
#define dimmUp2 "10110000000010001000"
#define dimmDn2 "10110000000010011001"
#define dimmUp3 "10110000000001001011"
#define dimmDn3 "10110000000001011010"
#define dimmUp4 "10110000000011001001"
#define dimmDn4 "10110000000011011000"

short rc_pin=2;

void setup() {
  pinMode(rc_pin, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  while(Serial.available()>0){
    byte command = Serial.read();
    switch(command){
    case '1': 
      {
        sendCode(ch1on); 
        Serial.println("command ch1on executed"); 
        break; 
      }
    case '2': 
      {
        sendCode(ch1off); 
        Serial.println("command ch1off executed"); 
        break;
      }
    case '3': 
      {
        sendCode(ch2on); 
        Serial.println("command ch2on executed"); 
        break;
      }
    case '4': 
      {
        sendCode(ch2off); 
        Serial.println("command ch2off executed"); 
        break;
      }
    case '5': 
      {
        sendCode(ch3on); 
        Serial.println("command ch3on executed"); 
        break;
      }
    case '6': 
      {
        sendCode(ch3off); 
        Serial.println("command ch3off executed"); 
        break;
      }
    case '7': 
      {
        sendCode(ch4on); 
        Serial.println("command ch4on executed"); 
        break;
      }
    case '8': 
      {
        sendCode(ch4off); 
        Serial.println("command ch4off executed"); 
        break;
      }
    case '9': 
      {
        sendCode(chMon); 
        Serial.println("command chMon executed"); 
        break;
      }
    case 'a': 
      {
        sendCode(chMoff); 
        Serial.println("command chMoff executed"); 
        break;
      }
    case 'b': 
      {
        sendCode(dimmUp1); 
        Serial.println("command dimmUp1 executed"); 
        break;
      }
    case 'c': 
      {
        sendCode(dimmDn1); 
        Serial.println("command dimmDn1 executed"); 
        break;
      }
    case 'd': 
      {
        sendCode(dimmUp2); 
        Serial.println("command dimmUp2 executed"); 
        break;
      }
    case 'e': 
      {
        sendCode(dimmDn2); 
        Serial.println("command dimmDn2 executed"); 
        break;
      }
    case 'f': 
      {
        sendCode(dimmUp3); 
        Serial.println("command dimmUp3 executed"); 
        break;
      }
    case 'g': 
      {
        sendCode(dimmDn3); 
        Serial.println("command dimmDn3 executed"); 
        break;
      }
    case 'h': 
      {
        sendCode(dimmUp4); 
        Serial.println("command dimmUp4 executed"); 
        break;
      }
    case 'i': 
      {
        sendCode(dimmDn4); 
        Serial.println("command dimmDn4 executed"); 
        break;
      }
    default: 
      Serial.println("command not found");
    }
  }
}
boolean sendCode(char code[]){ //empfange den Code in Form eines Char[]
  sendSymbol('x');
  for(short z = 0; z<7; z++){ //wiederhole den Code 7x
    for(short i = 0; i<20; i++){ //ein Code besteht aus 20bits
      sendSymbol(code[i]);
    }
    sendSymbol('x'); //da der code immer mit x/sync abschliesst, brauchen wir den nicht im code und haengen es autisch immer hinten ran.
  }
  return true;
}
void sendSymbol(char i) { //Diese Funktion soll 0,1 oder x senden koennen. Wir speichern die gewuenschte Ausgabe in der Variabel i
  switch(i){ //nun gucken wir was i ist
  case '0':
    { //Der Code fuer '0'
      digitalWrite(rc_pin,LOW);
      delayMicroseconds(600);
      digitalWrite(rc_pin,HIGH);
      delayMicroseconds(1400);
      return;
    }
  case '1':
    { //Der Code fuer '1'
      digitalWrite(rc_pin,LOW);
      delayMicroseconds(1300);
      digitalWrite(rc_pin,HIGH);
      delayMicroseconds(700);
      return;
    }
  case 'x':
    { //Der Code fuer x(sync)
      digitalWrite(rc_pin,LOW);
      delay(81);
      digitalWrite(rc_pin,HIGH);
      delayMicroseconds(800);
    }

  }
}

Desweiteren gibt es auch eine Library von picoPAN .

Schalten mit dem PC(Linux)

//Natuerlich kann man auch mit dem SerialMonitor der ArduinoIDE arbeiten, aber die ist eher zum Testen als zum richtigen Umsetzen. Der Code laesst sich trotzdem auch mit dem SerialMonitor verwenden.

Damit der Arduino weiss, wann er was senden muss, muessen wir ihm irgendwie Informationen senden. Dies machen wir am besten mit einer seriellen Verbindung ueber USB. Ich habe hierfuer mal den Anfang des Codes leicht veraendert:

short rc_pin=13;
char code[12]; //neu: hier wird der Code gespeichert

void setup() {
  pinMode(rc_pin, OUTPUT);
  Serial.begin(9600); //neu: hier stellen wir die Baudrate fuer die serielle USB Verbindung ein
}
void loop() {
  while(Serial.available() <= 0){ delay(10);} //Warten bis eine USB-Verbindung $
  while(Serial.read() != 'b'){ delay(10);} //Warten bis ein 'b' empfangen wird
  for(short i=0; i<12; i++){ //Nun werden die naechsten 12 Zeichen als Code erk$
    while(Serial.available() <= 0){ delay(10);} //Warten bis eine USB-Verbindun$
    code[i] = Serial.read();
  }
  Serial.println(code); //zur Kontrolle gibt der Arduino nun den Code nochmal w$
  sendCode(code); //Den Code senden
}

Zuerst wartet der Arduino auf ein ‘b’ und wartet dann auf einen 12stelligen Code aus ‘1’ und ‘0’. Alle anderen Zeichen werden ignoriert. Du kannst nun im Serialmonitor einfach z.B. “b000110010001” eingeben und dann wird der Code “00011 00100 01” gesendet und anschliessend zur Kontrolle nochmal ausgegeben. Das ganze nun nochmal in komplett:

short rc_pin=13;
char code[12]; //neu: hier wird der Code gespeichert

void setup() {
  pinMode(rc_pin, OUTPUT);
  Serial.begin(9600); //neu: hier stellen wir die Baudrate fuer die serielle USB Verbindung ein
}
void loop() {
  while(Serial.available() <= 0){ delay(10);} //Warten bis eine USB-Verbindung $
  while(Serial.read() != 'b'){ delay(10);} //Warten bis ein 'b' empfangen wird
  for(short i=0; i<12; i++){ //Nun werden die naechsten 12 Zeichen als Code erk$
    while(Serial.available() <= 0){ delay(10);} //Warten bis eine USB-Verbindun$
    code[i] = Serial.read();
  }
  Serial.println(code); //zur Kontrolle gibt der Arduino nun den Code nochmal w$
  sendCode(code); //Den Code senden
}

boolean sendCode(char code[]){ //empfange den Code in Form eines Char[]
  for(short z = 0; z<7; z++){ //wiederhole den Code 7x
    for(short i = 0; i<12; i++){ //ein Code besteht aus 12bits
      sendByte(code[i]);
    }
  sendByte('x'); //da der code immer mit x/sync abschliesst, brauchen wir den nicht im code und haengen es autisch immer hinten ran.
  }
  return true;
}

void sendByte(char i) { //Diese Funktion soll 0,1 oder x senden koennen. Wir speichern die gewuenschte Ausgabe in der Variabel i
  switch(i){ //nun gucken wir was i ist
  case '0':{ //Der Code fuer '0'
    digitalWrite(rc_pin,HIGH);
    wait(1); //da die Pausen x*350us lang sind, machen wir daraus eine Funktion
    digitalWrite(rc_pin,LOW);
    wait(3);
    digitalWrite(rc_pin,HIGH);
    wait(3);
    digitalWrite(rc_pin,LOW);
    wait(1);
    return;
  }
  case '1':{ //Der Code fuer '1'
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(3);
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(3);
    return;
  }
  case 'x':{ //Der Code fuer x(sync)
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(31);
  }

}
}

void wait(int x) {
  delayMicroseconds(x*350); //warte x*350us
}

Um das ganze jetzt per Tastenkombination oder aehnliches zu machen muessen wir hierraus erstmal einen Terminal-Befehl machen. Dies geht am einfachsten mit ttyUSB. Hierzu hatte ich bereits mal ein Tutorial geschrieben. Doch ich fasse es nochmal kurz hier zusammen:

Zuerst muessen wir den Arduino initalisieren. Initalisieren tun wir mit dem Befehl: stty -F /dev/ttyUSB0 cs8 9600 -hupcl (Pfad: /dev/ttyUSB0 Baudrate: 9600)

Anschliessend koennen wir mit echo ‘Code’ > /dev/ttyUSB0 senden. z.B. echo ‘b000110010001’ > /dev/ttyUSB0

Das Initalisieren muss nach jedem Systemstart einmal gemacht werden. Hier eignet sich ein Autostart. Den Sendebefehl kannst du nun ueberall einfuegen.

Advertisements

85 thoughts on “Funksteckdose fernsteuern mit Arduino

  1. Hallo,

    wirklich eine tolle Anleitung. Ich hab gleich mal entsprechende Bestellungen aufgegeben, um das nachbauen zu können. Ich hab allerdings ein Problem: Das Sendemodul gibt es in dem Laden nicht mehr.
    Kannst du mir sagen, ob man auch ein solches Modul verwenden kann: http://goo.gl/Vc91O? Das sieht für meine unerfahrenen Augen doch recht anders aus.

    Danke für diese Anleitung. Sehr gut erklärt ;).

    Gruß,
    Alex

    Like

    1. Es sollte funktionieren. Das Datenblatt ist zwar zu knapp gehalten um da eine Garantie zu geben, aber allgemein funktioniert nahezu jedes Modul. Notfalls laesst sich sogar die Fernbedienung selbst verwenden, hierfuer muss man meiner Erinnerung nach nur 2 Kontakte setzen (Ich kann mich jedoch leider gerade nichtmehr an genaues erinnern).
      Mit dem Modul machst du dir aber vermutlich deutlich weniger Muehe.

      Danke fuer dein Lob und noch viel Spass beim Basteln!
      Dominik

      Like

      1. Ich wollte auch erst die Fernbedienung verwenden. Die wollte allerdings 12V. Mit 5V war die Sendeleistung einfach lächerlich. Da ich das ganze so einfach wie möglich halten möchte, werde ich die Module verwenden. Danke fürs Feedback.

        Ich kann die Lieferung gar nicht erwarten :O

        Like

  2. Hey,
    danke für das super Tutorial. Insbesondere die Idee die Funksignale mit dem Mikrofonanschluss aufzunehmen find ich sehr schön!

    Würde das auch mit einem Infrarotempfänger und -sender funktionieren? Die Idee dahinter ist mein Heimkino mittels des Arduino komplett einzuschalten (und z.B. der Beamer hat eine Infrarot Fernbedienung).

    Like

    1. Ja, dies ist moeglich. Ich selbst habe das schon mit meinem Fernsehr gemacht. Leider traten bei mir aber merkwuerdige Ergebnisse auf, beim Versuch die Signale anschliessend auch zu senden. Meine Infrarot-Leds waren aber auch von sehr niedriger Qualitaet und da ich in meiner Studentenbude keinen Fernsehr oder anderes IR-Geraet mehr habe, gab es fuer mich keinen Grund dies erneut zu probieren.
      PS: Bei IR sollte es auch sehr einfach moeglich sein, das Signal mit einem Handy ueber den Headsetanschluss aufzunehmen und abzuspielen (Sensor an Microphone, Led an Audioausgang). Auch dieser Versuch scheiterte aber damals mit meinen Leds.

      Like

      1. Danke für die schnelle Antwort. Ich bau demnächst einfach mal den Empfänger und die Sender aus nem alten Fernseher + Fernbedienung aus und dann schau ich mal obs klappt…

        Like

  3. Hallo Dominik,
    hammer Tutorial! Wirklich sehr sehr gut beschrieben und funktionierte
    bei mir auf Anhieb!

    Mir waren nur folgende Punkte nicht sofort klar:
    – aus den 8 Blöcken (Staffeln wie du sie bezeichnest) kann man sich EINEN beliebigen heraussuchen UND nimmt sich am besten den mit den “eckigsten” Kurven. In Audacity war das bei mir immer die untere Tonspur.
    – Eine “0” ist immer ein schmaler Ausschlag nach unten UND ein breiter Ausschlag nach unten
    – Eine “1” sind immer 2 schmale Ausschläge nacheinander nach unten

    Du schreibst zwar, dass es “relativ schwer” sei, aber man muss sich nur den BESTEN eckigsten Block heraussuchen. Dann geht es wirklich einfach. Zur Kontrolle kann man sich einen weiteren Block heraussuchen und ihn dechiffrieren.

    Wirklich ein TOP Tutorial!

    Gruß Markus

    Like

  4. Hallo,
    vielen Dank für das Tutorial. Hat mir mit meinem Arduino gut weiter geholfen. Ich schalte bei mir zu Hause die Lidl Steckdosen (RC-710 von Libra), deren Code etwas anders war. Für diejenigen, die mit diesen Steckdosen arbeiten wollen, poste ich hier das modifizierte Sketch mit den entsprechenden Codes:

    #define ch1on “10110000000000010001”
    #define ch1off “10110000000000000000”
    #define ch2on “10110000000010010011”
    #define ch2off “10110000000010000010”
    #define ch3on “10110000000001010000”
    #define ch3off “10110000000001000001”
    #define ch4on “10110000000011010010”
    #define ch4off “10110000000011000011”
    #define chMon “10110000000011110000”
    #define chMoff “10110000000011100001”
    #define dimmUp1 “10110000000000001010”
    #define dimmDn1 “10110000000000011011”
    #define dimmUp2 “10110000000010001000”
    #define dimmDn2 “10110000000010011001”
    #define dimmUp3 “10110000000001001011”
    #define dimmDn3 “10110000000001011010”
    #define dimmUp4 “10110000000011001001”
    #define dimmDn4 “10110000000011011000”

    short rc_pin=2;

    void setup() {
    pinMode(rc_pin, OUTPUT);
    Serial.begin(9600);
    }

    void loop() {
    while(Serial.available()>0){
    byte command = Serial.read();
    switch(command){
    case ‘1’: {sendCode(ch1on); Serial.println(“command ch1on executed”); break; }
    case ‘2’: {sendCode(ch1off); Serial.println(“command ch1off executed”); break;}
    case ‘3’: {sendCode(ch2on); Serial.println(“command ch2on executed”); break;}
    case ‘4’: {sendCode(ch2off); Serial.println(“command ch2off executed”); break;}
    case ‘5’: {sendCode(ch3on); Serial.println(“command ch3on executed”); break;}
    case ‘6’: {sendCode(ch3off); Serial.println(“command ch3off executed”); break;}
    case ‘7’: {sendCode(ch4on); Serial.println(“command ch4on executed”); break;}
    case ‘8’: {sendCode(ch4off); Serial.println(“command ch4off executed”); break;}
    case ‘9’: {sendCode(chMon); Serial.println(“command chMon executed”); break;}
    case ‘a’: {sendCode(chMoff); Serial.println(“command chMoff executed”); break;}
    case ‘b’: {sendCode(dimmUp1); Serial.println(“command dimmUp1 executed”); break;}
    case ‘c’: {sendCode(dimmDn1); Serial.println(“command dimmDn1 executed”); break;}
    case ‘d’: {sendCode(dimmUp2); Serial.println(“command dimmUp2 executed”); break;}
    case ‘e’: {sendCode(dimmDn2); Serial.println(“command dimmDn2 executed”); break;}
    case ‘f’: {sendCode(dimmUp3); Serial.println(“command dimmUp3 executed”); break;}
    case ‘g’: {sendCode(dimmDn3); Serial.println(“command dimmDn3 executed”); break;}
    case ‘h’: {sendCode(dimmUp4); Serial.println(“command dimmUp4 executed”); break;}
    case ‘i’: {sendCode(dimmDn4); Serial.println(“command dimmDn4 executed”); break;}
    default: Serial.println(“command not found”);
    }
    }
    }
    boolean sendCode(char code[]){ //empfange den Code in Form eines Char[]
    sendSymbol(‘x’);
    for(short z = 0; z<7; z++){ //wiederhole den Code 7x
    for(short i = 0; i<20; i++){ //ein Code besteht aus 20bits
    sendSymbol(code[i]);
    }
    sendSymbol('x'); //da der code immer mit x/sync abschliesst, brauchen wir den nicht im code und haengen es autisch immer hinten ran.
    }
    return true;
    }
    void sendSymbol(char i) { //Diese Funktion soll 0,1 oder x senden koennen. Wir speichern die gewuenschte Ausgabe in der Variabel i
    switch(i){ //nun gucken wir was i ist
    case '0':{ //Der Code fuer '0'
    digitalWrite(rc_pin,LOW);
    delayMicroseconds(600);
    digitalWrite(rc_pin,HIGH);
    delayMicroseconds(1400);
    return;
    }
    case '1':{ //Der Code fuer '1'
    digitalWrite(rc_pin,LOW);
    delayMicroseconds(1300);
    digitalWrite(rc_pin,HIGH);
    delayMicroseconds(700);
    return;
    }
    case 'x':{ //Der Code fuer x(sync)
    digitalWrite(rc_pin,LOW);
    delay(81);
    digitalWrite(rc_pin,HIGH);
    delayMicroseconds(800);
    }

    }
    }

    Like

  5. Hey tolle Anleitung.

    Mir ist aufgefallen im fertigen Testcode ist in den Kommentaren ON und OFF vertauscht:
    sendCode(“000110010001”); //sende den Beispiel Code[An]
    delay(1000);
    sendCode(“000110010010”); //sende den Beispiel Code[Aus]
    muss heissen:
    sendCode(“000110010001”); //sende den Beispiel Code[Aus]
    delay(1000);
    sendCode(“000110010010”); //sende den Beispiel Code[An]

    Leider bekomm ich das Beispiel von Sebastian nicht zum laufen,
    gibts den den funktionierenden Code irgendwo anders ?

    Like

  6. Hi,

    der Blogeintrag hat mir wirklich sehr gut gefallen. So gut das es mich gepackt hat und ich das ganze auch mal ausprobieren wollte. Ich benutze jedoch keine Funksteckdosen sondern die Funkfernbedienung meiner Motorleinwand. Diese sendet auf 433MHz. Ich habe mir also einen entsprechenden Empfänger und Sender besorgt und ein signal aufgezeichnet. Leider werde ich aus dem Code nicht so richtig schlau. Der beschriebene lässt sich zumindest nich darauf anwenden.
    Daher wollte ich hier einmal nach Hilfe suchen. Ich habe einmal eines der Signale hochgeladen. Hier ist der Link . Wär klasse wenn mir jemand dabei helfen kann 😀

    Danke schonmal im vorraus.

    Like

    1. Also ein Muster habe ich schnell finden können. Allerdings kann ich aus einem einzigen Packet natürlich kein Packetmuster erkennen.
      Die Bits sollten aber so aussehen: Modified sketch
      An und Aus könnten je nach Polung auch umgekehrt sein. Ich bin aber selber nichtmehr ganz in der Materie drinnen (Das Tutorial ist älter als die Website…).

      Like

  7. hi zusammen,

    ich habe ein seltsames Problem mit meinen neuen ‘Flamingo’ Funksteckdosen (z.Zt. bei Obi 8.99€ für 3 stück).

    Ich habe auch den ‘soundkarten-oszi’-trick eingesetzt um die Remote der Flamingo zu dekodieren.

    (the Flamingo dosen scheinen auch von ELRO zu sein btw., ähnlich den ELRO 440, aber ohne DIP switches).

    das ‘ch a off’ signal der fernbedienung in audacity:

    Konnte das Signal auch schnell nachbauen mit Dominiks Code
    (musste nur in der ‘wait’ function von 350 microsekunden auf 324 gehen).

    klappt auch mit RC switch, welches allerdings eine ‘PulseLength: 331 microseconds’ erkannte.

    Um in Audacity identisch aussehende Signale zu bekommen, musste ich 324 statt 331 nehmen,
    aber jetzt sehen die Signale gleich aus (oben ist die original remote, unten das vom arduino):

    RC switch captures der orig remote (ch a off):

    Decimal: 5243156 (24Bit) Binary: 010100000000000100010100 Tri-State: FF00000F0FF0 PulseLength: 331 microseconds Protocol: 1
    Raw data: 10280,352,964,956,372,352,956,944,388,340,976,344,976,352,956,352,972,356,956,360,968,360,964,320,992,348,968,332,996,332,976,964,352,360,968,344,976,348,964,956,376,344,972,952,368,348,972,340,980,

    das ganze in Sui’s oszi:

    scheint also alles zu stimmen, aber die blöden Dosen schalten nur mit der Fernbedienung, nicht mit meinem Sender…

    Sender Setup ist aber OK, ich kann immer noch die RC-710 schalten, und kann die Signale ja auch in Audacity sehen…

    hat irgendjemand eine Idee, wo hier der Fehler stecken kann?

    danke & grüße

    Like

    1. Hallo,

      konntest du das Problem mit den Flamingo Steckdosen lösen, habe das selbe Problem.

      Wäre für Hilfe dankbar.

      Like

      1. Ich habe das gleiche Problem, auch mit selbstlernenden Flamingo/Mumbi Dosen. Empfangen der Originalcodes klappt mit RC-Switch, aber senden des (offenbar nicht) gleichen Codes interessiert die Dosen nicht.
        Ich werde noch ein bisschen herumprobieren (mit der Pulselength z.B.), aber bisher klappt’s bei mir auch nicht.

        Wer eine Idee hat, darf gerne auch eine Mail an priv.tom.janson at gmail.com schreiben.

        Like

  8. Wie bekekommst du die roten vertikalen 350µ sek unterteilungen in dem Bild hin?
    Und gibt es eine möglichkeit möglichkeit z.B. 350 oder 250µ sec vorzuspringen, es gibt viele mögliche Tastenkombinationen aber ich hab noch nichts gefunden um gut im µsec bereich ablesen zu können.

    danke

    Yaku

    Like

    1. einfach ein datenpaket auschneiden, und dann in neuer Spur einfügen.

      dann lässt sich das bei entsprechendem Zoom gut ablesen.

      außerdem ist es gut, zuerst die gesamt Zeit aller Bits abzulesen, und diese dann durch die Anzahl der Bits zu teilen.

      ist genauer als ein Bit abzulesen.

      Like

  9. Hi!

    Cooles Tutorial!
    Habe mir alles besorgt und auch schon ausprobiert.
    Allerdings habe ich ein Problem bei der Entschlüsselung des Codes.
    Ich bekomme keine “sauberen” Codes.
    Vielleicht sind die verschlüsselt oder so.
    Kannst du vielleicht den Namen deines Funksteckdosensets sagen damit ich einfach deinen Quelltext übernehmen kann? Würde das dann funktionieren?

    Danke schonmal!

    Like

    1. Es sind mir keine Funksteckdosen bekannt, die verschlüsselt sind. Eine ernsthafte Verschlüsselung würde meines Wissens nach eines beidseitigen Funkverkehrs bedürfen und da die Funksteckdosen nur Empfänger sind ist dies unwahrscheinlich. Wenn es also eine (halbherzige) Verschlüsselung gibt, dann würde die sich einfach durch Aufnehmen und Abspielen des Signals austricksen lassen. Versuch am besten einfach mal ein einziges Signal aufzunehmen und zu modelieren. Der Fehler liegt vermutlich nicht an den Steckdosen (Es sei denn die arbeiten auf einer anderen Frequenz als erwartet, dann würdest du aber nur rauschen bekommen.).

      Ich selber benutz(t)e Funksteckdosen aus zwei verschiedenen Elro AB440 Serien, die beide die gleiche Kodierung aufweisen.

      Like

      1. Ich gehe stark davon aus. Ich habe gerade nochmal auf die Herstellerseite geguckt und nach der sollte das genau das gleiche Model sein.

        Es gibt Funktsteckdosen mit 433MHz (hier genutzt) und ab und zu auch mit 866MHz, die nicht kompatibel sind, aber genauso aussehen. Bei diesen würde nur Rauschen rauskommen und eine Vermutung von mir wäre gewesen, dass es sich bei dir um solche handelt.

        Like

      2. Ok dann wird es wohl daran liegen.

        Dann werde ich mir die mal bestellen und jetzt schonmal den Quelltext aufs Arduino laden.
        Danke für die schnelle und gute Hilfe 🙂

        Like

  10. Hallo,

    cooler Beitrag,
    mit dem Aufzeichnen hat soweit geklappt, leider habe ich einen Code der irgendwie nicht zu der Systematik von Deinem Code passt.
    siehe Link http://www.tackers-si.de/Upload/Code.jpg
    entweder hat er mehr bits oder komplett andere Codes für 0 und 1 ?
    Kannst mir da auf die Sprünge helfen.
    Ist allerdings für Rollläden.

    Danke
    Gruß Tacker

    Like

    1. Also ich würde folgendes schätzen:
      1. Es gibt folgende Grundeeinheiten: SHORT-HIGH+SHORT-LOW (SHSL), SHORT_LOW+SHORT_HIGH(SLSH), LONG_HIGH(LH), LONG_LOW(LL).
      2. SHSL/SLSH entspricht der 0, LH/LL entspricht der 1 (wobei das getauscht werden kann. Ist nur symbolisch)
      3. Die Entscheidung nach der entsprechenden Variante fällt nach folgendem Algorithmus
      SENDE 0:
      IF output==high THEN send(SLSH) ELSE send(SLSH);

      SENDE 1:
      IF output==high THEN send(LL) ELSE send(LH);

      Der Anfang ist nur Synchronisation.
      Somit ergeben sich nach meinen Notizen 5 Byte(a 8 Bit), was eine vertrauenswürdige Zahl ist.
      In wie weit da jetzt Semantik drinnen steckt kann ich nicht sagen. 5 Bytes sind eine ganze Menge und ich schätze das da noch fehlerkorrigierendes Zeug drinnen steckt.

      Like

      1. Du meinst hinter dem Anfang mit dem längeren gleichen Ausschlägen müsste ich in 5 Teile für die 5 Bytes teilen und müssten dann SLSH, SHSL und LL LH suchen?.
        Könntest Du mir das in meinem Screanshot mal kenntlich machen und senden wo die Bytes liegen?
        Danke

        Like

      2. Ganz auf die schnelle:

        Das erste Byte vollständig und das zweite angefangen. Sollte hoffentlich ersichtlich sein, wie es mMn weiter gehen sollte.

        Korrektur: Bei den Bytes habe ich mich wohl verzählt. 5 Bytes kommen nicht hin.

        Like

      3. ah jetzt verstehe ich es, also ist der unterschied von 0 und 1 nicht hight oder low sondern Lang und 2 Kurz
        Ich probiere es mal und melde mich….

        Danke

        Like

      4. Da keien eindeutiges Muster zu erkennen ist, wo ich sagen kann ist die Adresse für den Empfänger und der Rest die Befehle, habe ich mir mal die Mühe gemacht und jedes high und low als Bit gesetzt.Und habe dden Byte in eien Zahl umgewandelt, leider sehe ich auch kein Muster.
        denn meien 3 Signale die ich im Moment habe sind Auf, Stop, Zu und die müssten ja einen gleichen Teil für den Empfänger haben, im Moment nur die ersten 9 Byte….
        Ich nehem später mal andere Kanäle auf und vergleiche….

        Like

      5. Je nach Codierung gibt es eine solche Aufteilung nicht unbedingt. Es gibt teils sehr ausgefeilte mathematische Codierungen um beschädigte Signale rekonstruieren zu können. Die einfachere und gängiger Variante ist einen Befehl einfach mehrfach hintereinander zu senden, wie es z.B. bei den meisten Funksteckdosen der Fall ist. Auch sollen Manchester Codierungen etc. meiner Erinnerung nach nicht selten sein.
        Während eine Manchester Codierung noch kein großes Problem darstellt, könnten zum Verständnis eines fehlertoleranten Codes schon höhere mathematische Kenntnisse von Nöten sein. Im bekannten Werk ‘Computernetze’ von Tanenbaum gibt es meiner Erinnerung nach eine gute Einführung und Übersicht.

        Nachträgliche Anmerkung: Schau dir mal das Beispiel zum Manchester Code auf http://de.wikipedia.org/wiki/Manchester-Code an. Ich könnte mir vorstellen, dass der Manchester Code IEEE 802.3 verwendet wurde.

        Like

    2. Hallo Zusammen,

      echt interessantes Tutorial.

      Ich hab das auch mal bei Maclean Funktsteckdosen probiert. Allerdings werde ich aus der Kurve/Signal nicht schlau.

      Kann mir jemand helfen?

      Bilder könnte ich schicken.

      Like

      1. Am einfachsten ist es, wenn du hier einen Link zu einem entsprechenden Screenshot o.Ä. dazu packst. Dann würde ich wenn ich Zeit habe mal drüber gucken. Ansonsten könntest du es mir natürlich auch mailen an die Links angegebene Addresse.

        Like

      2. Hallo,

        hab Dir gerade per Email meine Audacity Datei geschickt.

        Ich freu mich über Hilfe.

        Meine Funksteckdosen haben so eine “Learn” Taste, um die Steckdosen nach eigenen Wünschen zu belegen mit den Tasten der FB. Ich hoff, das ist kein Problem für die Arduino Ansteuerung?!

        Like

      3. Hey Dominik,

        ich glaubs nicht. Ich bin unendlich dankbar für Deine Hilfe. Ich habs tatsächlich hinbekommen, die Steckdosen zu schalten.

        DANKE!!!!

        Viele Grüße,
        Thomas

        Like

  11. Hey,

    ich versuche jetzt, die Funksteckdosen über ein Web Interface zu steuern. Kennt Ihr euch da aus?

    Habe versucht, Deine IDE mit einer anderen Web-Server IDE zu koppeln. Dies funktioniert aber nicht. Meiner Meinung nach müsste sich so zumindest die erste Dose einschalten lassen:

    #if ARDUINO > 18
    #include // Für Arduino Version größer als 0018
    #endif
    #include
    #include
    #include

    short rc_pin=13;
    char code[40]; //neu: hier wird der Code gespeichert

    byte mac[] = { 0x5A, 0xA2, 0xDA, 0x0D, 0x56, 0x7A }; // MAC-Adresse des Ethernet-Shield
    byte ip[] = { 192, 168, 1, 177 }; // IP zum aufrufen des Webservers
    byte sdPin = 4; // Pin der SD-Karte

    EthernetServer server(80); // Server port

    File webFile;

    void setup()
    {
    pinMode(rc_pin, OUTPUT);
    Ethernet.begin(mac, ip); // Client starten
    server.begin(); // Server starten
    Serial.begin(9600);
    Serial.println(“ARDUINO – STEUERUNG”);

    Serial.println(“Initialisiere SD-Karte…”);
    if (!SD.begin(sdPin))
    {
    Serial.println(” – Initialisierung der SD-Karte fehlgeschlagen!”);
    return;
    }
    Serial.println(” – SD-Karte erfolgreich initialisiert.”);

    if (!SD.exists(“index.htm”))
    {
    Serial.println(” – Datei (index.htm) wurde nicht gefunden!”);
    return;
    }
    Serial.println(” – Datei (index.htm) wurde gefunden.”);

    Serial.println();
    Serial.println(“Verbraucher schalten”);
    }

    void loop()
    {
    EthernetClient client = server.available(); // Auf Anfrage warten

    if(client)
    {
    /*****************************************
    Ausgänge über das Webformular steuern *
    *****************************************/
    TextFinder finder(client);

    if(finder.find(“GET”))
    {
    while(finder.findUntil(“Dose”, “\n\r”))
    {
    char typ = client.read();
    int pin = finder.getValue();
    int val = finder.getValue();

    if(typ == ‘D’)
    {

    Serial.print(“Dose”+String(pin));
    }

    if(val==1)
    {
    Serial.println(” ein”);
    if(pin==1)
    {
    code[0] = 1;
    code[1] = 1;
    code[2] = 0;
    code[3] = 1;
    code[4] = 0;
    code[5] = 1;
    code[6] = 0;
    code[7] = 1;
    code[8] = 1;
    code[9] = 0;
    code[10] = 1;
    code[11] = 1;
    code[12] = 0;
    code[13] = 1;
    code[14] = 1;
    code[15] = 1;
    code[16] = 0;
    code[17] = 0;
    code[18] = 1;
    code[19] = 0;
    code[20] = 1;
    code[21] = 0;
    code[22] = 1;
    code[23] = 0;
    code[24] = 0;
    code[25] = 1;
    code[26] = 0;
    code[27] = 0;
    code[28] = 1;
    code[29] = 0;
    code[30] = 0;
    code[31] = 0;
    code[32] = 0;
    code[33] = 1;
    code[34] = 1;
    code[35] = 1;
    code[36] = 1;
    code[37] = 0;
    code[38] = 0;
    code[39] = 0;

    Serial.println(code);
    }
    }
    }
    else if(val==0)
    {
    Serial.println(” aus”);
    if(pin==1)
    {

    Serial.println(pin);
    Serial.println(val);

    }
    }
    }

    sendCode(code);
    }

    }

    /************************
    Webformular anzeigen *
    ************************/
    boolean current_line_is_blank = true; // eine HTTP-Anfrage endet mit einer Leerzeile und einer neuen Zeile

    while (client.connected())
    {
    if (client.available()) // Wenn Daten vom Server empfangen werden
    {
    char c = client.read(); // empfangene Zeichen einlesen
    if (c == ‘\n’ && current_line_is_blank) // wenn neue Zeile und Leerzeile empfangen
    { // Standard HTTP Header senden
    client.println(“HTTP/1.1 200 OK”);
    client.println(“Content-Type: text/html”);
    client.println(“Connection: close”);
    client.println();

    // Website von SD-Karte laden
    webFile = SD.open(“index.htm”); // Website laden
    if (webFile)
    {
    while(webFile.available())
    {
    client.write(webFile.read()); // Website an Client schicken
    }
    webFile.close();
    }
    break;
    }
    if (c == ‘\n’)
    {
    current_line_is_blank = true;
    }
    else if (c != ‘\r’)
    {
    current_line_is_blank = false;
    }
    }
    }
    delay(1);
    client.stop();
    }

    boolean sendCode(char code[]){ //empfange den Code in Form eines Char[]
    for(short z = 0; z<6; z++){ //wiederhole den Code 6x
    for(short i = 0; i<40; i++){ //ein Code besteht aus 40bits
    sendByte(code[i]);
    }
    sendByte('x'); //da der code immer mit x/sync abschliesst, brauchen wir den nicht im code und haengen es automatisch immer hinten ran.
    }
    return true;
    }

    void sendByte(char i) { //Diese Funktion soll 0,1 oder x senden koennen. Wir speichern die gewuenschte Ausgabe in der Variabel i
    switch(i){ //nun gucken wir was i ist
    case '0':{ //Der Code fuer '0'
    digitalWrite(rc_pin,HIGH);
    wait(1); //da die Pausen x*200us lang sind, machen wir daraus eine Funktion
    digitalWrite(rc_pin,LOW);
    wait(8);
    return;
    }
    case '1':{ //Der Code fuer '1'
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(4);
    return;
    }
    case 'x':{ //Der Code fuer x(sync)
    digitalWrite(rc_pin,HIGH);
    wait(2);
    digitalWrite(rc_pin,LOW);
    wait(100);
    digitalWrite(rc_pin,HIGH);
    wait(2);
    digitalWrite(rc_pin,LOW);
    wait(2);
    digitalWrite(rc_pin,HIGH);
    wait(2);
    digitalWrite(rc_pin,LOW);
    wait(2);
    digitalWrite(rc_pin,HIGH);
    wait(15);
    digitalWrite(rc_pin,LOW);
    wait(15);
    }

    }
    }

    void wait(int x) {
    delayMicroseconds(x*200); //warte x*200us
    }

    Auf der SD-Karte habe ich die Webseite index.htm gespeichert. Die hat folgenden Code:

    Arduino Steuerung

    h2 { margin-bottom:5px; }

    Funksteckdosen-steuerung

    Steckdose 1:
    Ein
    Aus

    Steckdose 2:
    Ein
    Aus

    Steckdose 3:
    Ein
    Aus

    Steckdose 4:
    Ein
    Aus

    Könnt ihr mir helfen?

    Like

    1. Mhh, das mit dem HTML Code posten, der auf der SD Karte ist, hat wohl nicht so geklappt, hier noch mal:




      ” Arduino Steuerung

      ” h2 { margin-bottom:5px; }


      ” Funksteckdosen-steuerung

      ” Steckdose 1:
      Ein
      Aus

      ” Steckdose 2:
      Ein
      Aus

      ” Steckdose 3:
      Ein
      Aus

      ” Steckdose 4:
      Ein
      Aus



      “”

      Like

      1. Scheiße, der formatiert des immer um. Also das wichtige von dem SD Karten HTML Code ist denk ich folgendes:

        h2>Steckdose 1:EinAus und < Zeichen weg gemacht außen, damit er das nicht wieder umformatiert.

        Like

      2. Mal testen: Ok, WordPress ist da wirklich ein bisschen unglücklich.

        Mit HTML-Server kenne ich mich leider nicht sonderlich aus, sodass ich hier glaube ich nicht weiterhelfen kann. Vielleicht kann es ja aber wer anderes.

        Grüße,
        Dominik

        PS: Ich glaube nicht, dass du IDE (Integrated Development Environment) meinst. ‘Sketch’ ist bei Arduino vermutlich das richtige Wort.

        Like

  12. Hallo Zusammen,

    ich hab es nun hin bekommen, meine MACLEAN ENERGY MCE07G Funksteckdosen (http://www.amazon.de/Maclean-MCE07G-Funksteckdosen-Fernbedienung-Funkschalter-12-Monate-Garantie-Sofort-betriebsbereit/dp/B00DW6VGLQ) zu schalten.
    Und zwar über einen Webserver. D.h. ich kann meine Funksteckdosen auch über Handy schalten.
    Dazu habe ich einen Arduino UNO r3 und ein passendes Ethernet Shield benutzt und natürlich den RF Transmitter. Der Webserver läuft über die SD-Karte, welche im Ethernet Board steckt.
    Hier das Sketch:
    #if ARDUINO > 18
    #include // Für Arduino Version größer als 0018
    #endif
    #include
    #include
    #include

    short rc_pin=7;
    char code[40]; //neu: hier wird der Code gespeichert

    byte mac[] = { 0x5A, 0xA2, 0xDA, 0x0D, 0x56, 0x7A }; // MAC-Adresse des Ethernet-Shield
    byte ip[] = { 192, 168, 1, 177 }; // IP zum aufrufen des Webservers
    byte sdPin = 4; // Pin der SD-Karte

    EthernetServer server(80); // Server port

    File webFile;

    void setup()
    {
    pinMode(rc_pin, OUTPUT);
    Ethernet.begin(mac, ip); // Client starten
    server.begin(); // Server starten
    SD.begin(sdPin);

    }

    void loop()
    {
    EthernetClient client = server.available(); // Auf Anfrage warten

    if(client)
    {
    /*****************************************
    Ausgänge über das Webformular steuern *
    *****************************************/
    TextFinder finder(client);

    if(finder.find(“GET”))
    {
    while(finder.findUntil(“DoseD”, “\n\r”))
    {
    int pin = finder.getValue();
    int val = finder.getValue();

    if(val==1 && pin==1)
    {
    sendCode(“1101010110110111001010100100100001111000”);
    }
    else if(val==1 && pin==2)
    {
    sendCode(“1101010110110111001010100100100010110100”);
    }
    else if(val==1 && pin==3)
    {
    sendCode(“1101010110110111001010100100100000111100”);
    }
    else if(val==1 && pin==4)
    {
    sendCode(“1101010110110111001010100100100011010010”);
    }
    else if (val==0 && pin==1)
    {
    sendCode(“1101010110110111001010100100100010000111”);
    }
    else if(val==0 && pin==2)
    {
    sendCode(“1101010110110111001010100100100001001011”);
    }
    else if(val==0 && pin==3)
    {
    sendCode(“1101010110110111001010100100100011000011”);
    }
    else if(val==0 && pin==4)
    {
    sendCode(“1101010110110111001010100100100000101101”);
    }

    }
    }

    /************************
    Webformular anzeigen *
    ************************/
    boolean current_line_is_blank = true; // eine HTTP-Anfrage endet mit einer Leerzeile und einer neuen Zeile

    while (client.connected())
    {
    if (client.available()) // Wenn Daten vom Server empfangen werden
    {
    char c = client.read(); // empfangene Zeichen einlesen
    if (c == ‘\n’ && current_line_is_blank) // wenn neue Zeile und Leerzeile empfangen
    { // Standard HTTP Header senden
    client.println(“HTTP/1.1 200 OK”);
    client.println(“Content-Type: text/html”);
    client.println(“Connection: close”);
    client.println();

    // Website von SD-Karte laden
    webFile = SD.open(“index.htm”); // Website laden
    if (webFile)
    {
    while(webFile.available())
    {
    client.write(webFile.read()); // Website an Client schicken
    }
    webFile.close();
    }
    break;
    }
    if (c == ‘\n’)
    {
    current_line_is_blank = true;
    }
    else if (c != ‘\r’)
    {
    current_line_is_blank = false;
    }
    }
    }
    delay(1);
    client.stop();
    }
    }

    boolean sendCode(char code[]){ //empfange den Code in Form eines Char[]
    for(short z = 0; z<6; z++){ //wiederhole den Code 6x
    for(short i = 0; i<40; i++){ //ein Code besteht aus 40bits
    sendByte(code[i]);
    }
    sendByte('x'); //da der code immer mit x/sync abschliesst, brauchen wir den nicht im code und haengen es automatisch immer hinten ran.
    }
    return true;
    }

    void sendByte(char i) { //Diese Funktion soll 0,1 oder x senden koennen. Wir speichern die gewuenschte Ausgabe in der Variabel i
    switch(i){ //nun gucken wir was i ist
    case '0':{ //Der Code fuer '0'
    digitalWrite(rc_pin,HIGH);
    wait(1); //da die Pausen x*200us lang sind, machen wir daraus eine Funktion
    digitalWrite(rc_pin,LOW);
    wait(8);
    return;
    }
    case '1':{ //Der Code fuer '1'
    digitalWrite(rc_pin,HIGH);
    wait(1);
    digitalWrite(rc_pin,LOW);
    wait(4);
    return;
    }
    case 'x':{ //Der Code fuer x(sync)
    digitalWrite(rc_pin,HIGH);
    wait(2);
    digitalWrite(rc_pin,LOW);
    wait(100);
    digitalWrite(rc_pin,HIGH);
    wait(2);
    digitalWrite(rc_pin,LOW);
    wait(2);
    digitalWrite(rc_pin,HIGH);
    wait(2);
    digitalWrite(rc_pin,LOW);
    wait(2);
    digitalWrite(rc_pin,HIGH);
    wait(15);
    digitalWrite(rc_pin,LOW);
    wait(15);
    }

    }
    }

    void wait(int x) {
    delayMicroseconds(x*200); //warte x*200us
    }

    Die Webseite ist sehr einfach und sieht so aus:

    Arduino Steuerung

    h2 { margin-bottom:5px; }

    Strom Fernseher:
    Ein
    Aus

    Abendbeleuchtung:
    Ein
    Aus

    Arbeitsplatz Tina:
    Ein
    Aus

    Danke nochmal an Dominik für die viele Unterstützung.

    Viel Spaß damit.

    Viele Grüße,
    Thomas

    Like

    1. Hallo Thomas!
      Nachdem mir Dominik mitgeteilt hat, dass er von Deinem Protokoll keine Kurven mehr hat und mir empfohlen hat, dass aus Deinem Programm ‘rückwärts’ wieder zu erzeugen, wage ich noch einen letzten Versuch:
      Hast Du noch die Protokollinformationen (Messkurven -wie sieht z.B. die Syncronisation aus) der Maclean Funkschalter da und könntest sie mir zusenden?
      So eine Messung gibt einen guten Gesamtüberblick sofort und ist daher vorzuziehen.
      Natürlich könnte ich die Messungen auch mit meinen eigenen Dosen wiederholen. Dazu müßte ich aber erst einen Meßaufbau generieren.
      Ich hoffe nur, dass dieser Kommentar direkt bei Dir landet und nicht wieder auf Dominiks Bildschirm. (in diesem Fall könnte vielleicht Dominik das an Dich weiterreichen)

      Like

  13. Hi Dominik,
    Danke für die tolle Anleitung 😉

    Ich habe mir über das schalten von Steckdosen schon länger Gedanken gemacht, und hatte erst die Idee den Knopfdruck der Fernbedienung mit einem Relais zu simulieren, allerdings ist diese Methode noch viel schöner 🙂

    Ich hab gerade noch meinen 433 MHz Sender/Empfänger entdeckt. Kann ich meine 433,92 MHz-Funksteckdosen damit schalten?

    Dankeschön 🙂

    Like

    1. Hallo…
      Nach etwas längerem ausprobieren muss ich einfach nochmal fragen: Meine aufgenommene Spur: http://www.filefactory.ch/download/bcd61f42cad3c098f1072f1450f56bde.html zeigt eigentlich keine Wiederholungen an :/
      Mein Funkset ist dieses: http://www.amazon.de/Silvercrest-Aussen-Funksteckdosen-teilig-Reichweite/dp/B00I7WOQSK
      und Receiver dieser: http://m.ebay.de/itm/433Mhz-Sender-Empfaenger-Superregeneration-FS1000A-XY-FST-XY-MK-5V-Raspberry-Pi-/121230187056

      Like

      1. Erstmal ist es schlecht ein verlustbehaftetes Format zu verwenden (mp3). Diese verfälschen die Daten.
        Ich kann auch nichts darin lesen. So sollte das nicht aussehen.

        Grüße,
        Dominik

        Like

      1. oh tatsächlich. mein fehler.
        habe es verpolt und dafür den postiven ausschlag verwendet! hat auch funktioniert! 🙂

        Like

  14. Vielen Dank für das prima Tutorial!

    Die Auswertung lief bei mir ein bissl anders und mein Signal sieht auch anders aus. Die Auswertungmethode hab ich mal beschrieben und hochgeladen, evtl hilfts ja jemanden weiter. Die Ausgabezeiten mussten im Code dafür auch leicht verändert werden.

    Meine Auswertemethode:

    veränderte Ausgabezeiten:

    case ‘0’:{ //Der Code fuer ‘0’
    digitalWrite(rc_pin, HIGH);
    wait(1); //da die Pausen x*350us lang sind, machen wir daraus eine Funktion
    digitalWrite(rc_pin, LOW);
    wait(3);
    digitalWrite(rc_pin, HIGH);
    wait(1);
    digitalWrite(rc_pin, LOW);
    wait(3);
    return;
    }
    case ‘1’:{ //Der Code fuer ‘1’
    digitalWrite(rc_pin, HIGH);
    wait(1);
    digitalWrite(rc_pin, LOW);
    wait(3);
    digitalWrite(rc_pin, HIGH);
    wait(3);
    digitalWrite(rc_pin, LOW);
    wait(1);
    return;

    P.s. Im Tutorial ist der Ausgabe Pin des Senders in Pin 11 gesteckt, sendet im Code aber über Pin 13

    Like

  15. Hallo,
    aufgrund des Tutorials habe ich mir einen Sender und Empfänger zugelegt. Meine Signale, die ich empfange, sehen leider ganz anders aus und ein Muster kann ich leider nicht erkennen.

    Über eine Hilfe oder das Lesen der Codierung würde ich mir sehr freuen!

    Hier einmal ein Link zu meinem Signal:

    Schöne Grüße
    Torben

    Like

    1. Hallo Torben,
      Ich würde schätzen, dass der Anfangsteil bis nach den zwei Langen Blöcken die Synchronisationsphase ist. Anschließend gibt es nur noch zwei Typen von Blöcken: Kurz und Lang.
      Ich nehme jetzt mal an, dass Positiv=Signal und negativ=Pause bedeutet: Dann haben die Blöcken immer die gleich Signal-Länge und die Codierung steckt in kurzer oder langer Pause. Also z.B. lange Pause =1, kurze Pause =0.
      Von den Blöcken gibt es genau 40 Stück (=40Bit bzw. 5Byte).
      Das letzte Signal mit der finalen langen Pause ist wohl das Endzeichen.

      Zumindestens wäre das meine Einschätzung auf den ersten Blick.

      Grüße,
      Dominik

      Like

      1. Vielen Dank für deine schnell Antwort Dominik!

        Ich habe jetzt aber (ohne das ich die Codierung auslesen muss) versucht das per Sounddatei zu senden.

        Dieses klappt allerdings auch nicht. Ich habe mit Audacity das Signal für einschalten der Steckdose 1 aufgenommen. Anschließend den Sender angeschlossen und gebe das Signal per Output an den Sender weiter. Anschließend spiele ich die Aufnahme aus Audacity ab und nichts passiert.

        Was mache ich falsch? Hast du Ideen?

        Schöne Grüße
        Torben

        Like

      2. Untersuche mal was du genau sendest, indem du das wie bei der Fernbedienung aufnimmst. Vielleicht hast du einfach nur einen Pol vertauscht.
        Sollte der Code korrekt aussehen wird es komplizierter…

        Grüße,
        Dominik

        Like

      3. Hi,
        ich habe folgendes Empfangen (oben) und unten mein gesendetes.

        Diese unterscheiden sich verdammt stark. Ich arbeite auch mit einem Raspberry aber das sollte ja nicht das Problem sein.

        Hier ist mein Test php Code:
        else if (isset($_GET[‘send’])){
        $code = array(“1″,”1″,”0″,”1″,”1″,”0″,”1″,”1″,”1″,”1″,”0″,”0″,”1″,”0″,”0″,”0″,”0″,”0″,”1″,”0″,”0″,”1″,”0″,”0″,”0″,”0″,”1″,”1″,”0″,”1″,”1″,”1″,”1″,”0″,”0″,”0″,”0″,”1″,”1″,”1”);

        $Pause_Kurz = 400;
        $Pause_Lang = 1150;

        foreach($code as $bit){
        if ($bit == “0”){
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 1”));
        usleep($Pause_Kurz);
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 0”));
        usleep($Pause_Lang);
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 1”));
        usleep($Pause_Lang);
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 0”));
        usleep($Pause_Kurz);
        }
        else if ($bit == “1”){
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 1”));
        usleep($Pause_Kurz);
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 0”));
        usleep($Pause_Lang);
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 1”));
        usleep($Pause_Kurz);
        trim(@shell_exec(“/usr/local/bin/gpio -g write 22 0”));
        usleep($Pause_Lang);

        Ich bin kurz davor das Projekt zu beenden… :-/

        Like

      4. Aufgrund der beschränkten Verschachtelung antworte ich hier oben:
        Vermutlich steuerst du den Sender nur falsch an 😉
        Es sollte eigentlich genau das modeliert werden was du sendest. Versuch erstmal irgendeinen ganz einfachen beliebigen Code zu modelieren, d.h. reduziere das Problem auf den Sender korrekt anzusteuern.

        Like

  16. Hallo Leute!
    Ich habe mit Vergnügen gelesen dass Ihre den Code der Maclean Funksteckdose entschlüsselt habt!
    Dort sitzt nämlich kein bekannter Chip drin, alles vergossen! Die Decodiering in der Steckdose wird über einen Mikroprocessor gemacht. Bisher habe ich keine Infos dazu gefunden.
    Wenn ich vorstehend aslles richtig gelesen habe, kennt Ihr das Protokoll!
    Um so mehr verwundert es mich, dass Ihr es “geheim haltet”.
    Wie wäre es mit einer Offenlegung? Oder habe ich was übersehen, Thomas, Dominik?

    Like

      1. Hallo Dominik!
        Vielen Dank für die schnelle Antwort!Natürlich weiß ich, das ich durch eine Art “reverse engineering” das Protokoll wieder erzeugen kann. Da ich aber grundsätzlich nicht das Rad neu erfinden möchte: Dein Dialog mit Thomas vom 15.September 2014 zeigt, dass ein Bild einer brauchbaren Kurvenform des Maclean vorlag und dass Du sie passend kommentiert hast. Das ist etwas sehr Anschauliches und wesentlich besser zu handhaben, als Code.
        Ich vermute mal, dass es so ähnlich aussiehtr wie Dein gepostetes Code-Mod.jpg. I nehme an, das bezieht sich auf die Elpro Steckdosen?
        Wenn also so etwas (ähnliches) von Maclean auch existiert, wäre es schön wenn Du es entweder posten oder mir per email schicken könntest.

        Like

  17. Hallo, vielen Dank für das Tutorial.
    Leider hab ich bei meinen EasyHome Funksteckdosen noch keine Lösung gefunden..
    Ich füge einfach mal den Screenshot ein:

    Problem 1: Audacity nimmt_immer_ was (Random noise) auf, wenn ich mit der Fernbedienung ein Signal sende, kommt das Muster, der random noise hört auf
    Problem 2: Ende vom Signal nur sehr schwer zu erkennen

    Handsender ist ein Globaltronics GT-9000 mit EasyHome branding, Aufnahmechip ist dieser hier: http://www.ebay.de/itm/271826847405

    Like

    1. Hallo,

      Das sieht merkwürdig aus. Irgendwas ist mit dem Empfänger nicht in Ordnung, würde ich auf den ersten Blick behaupten. Evtl. schlecht verkabelt oder falsch gepolt. Sobald das Signal eintrifft sieht es ja gesünder aus, also ganz falsch ist es nicht. Vielleicht ist auch einfach der Sender selbst ein wenig kaputt.
      Zum Testen kannst du dir ein eigenes Signal mit dem Sender generieren und versuchen es zu empfangen. Dann weißt du wenigstens wie das Muster aussehen sollte.

      Mehr fällt mir dazu gerade leider nicht ein. Habe in den letzten Jahren nur sehr wenig Zeit für Elektronikbasteleien gehabt und bin dementsprechend aus der Übung.

      Grüße,
      Dominik

      Like

      1. Habs nochmal probiert, gleiches Ergebnis.
        Nochmal fürs Protokoll: der Empfänger ist ein MX-05V, hat 4 Pins, (GND, Data, Data (Inversed?), VCC). VCC an Arduino 5V+, GND an Arduino GND und Klinke GND, Data oder Data 2 an Klinke rechts (Ring).

        Kann es sein das mein Empfänger nicht mit dieser Methode funktioniert? Ich habe 2 Stück und habe es mit beiden getestet.

        Like

      2. Es sollte theoretisch funktionieren, es ist ja auch ein stark verrauschtes Signal zu erkennen. Das Signal scheint auch analog zu sein (ein digitales Signal sollte kein Noise haben) und damit sollte der Receiver die Fernbedinungssignal wiedergeben. Er arbeitet auch mit Amplitudenmoderlierung. Der Receiver hat jedoch ein breites Frequenzspektrum, evtl. müssen daher zusätzliche Dinge beachtet werden (wie etwa Antennenlänge). Zusätzlich kann es natürlich sein, dass die Funksteckdosen anders arbeiten (unwahrscheinlich bei billigen, Entwicklung eigener Methoden kostet).

        Mögliche weitere Fehlerquelle: Arduino liefert eine instabile Spannung (Kondensator könnte helfen).

        Like

  18. Hallo,

    ich bin auch gerade dabei mich mit den Funksteckdosen des großen Discounters zu beschäftigen und diese über RPi oder Arduino zu schalten.

    Die Fernbedienung GT-9000 hat zusätzlich zu den Tastern und dem Sendeteil noch eine blaue LED. Hier liegt die Spannung nach Tastendruck zwischen dem rechten Pin des Widerstands und der LED als TTL-Pegel (0 -5V) an. Der Vorteil liegt auf der Hand: kein Hintergrundrauschen mehr, nur noch das Nutzsignal an sich. Man kann sich dann das Protokoll mit Hilfe eines Logicanalyzers aufzeichnen lassen.
    Eine Weitere Möglichkeit ist, wie hier schon beschrieben Audacity dafür zu verwenden. Hier muss allerdings eine Schutzbeschaltung dazwischen (siehe http://atom007.heimat.eu/tmt/gsf_dyno_de.html#HowtoConnect).

    Like

  19. Hallo,
    sehr anschauliches Tutorial besten Dank.
    Leider komme ich beim dechiffrieren nicht wirklich weiter.
    Können Sie mir vileicht etwas Input geben?

    Der Sender ist ein Flamingo FA500R.

    Grüsse Onyx

    Like

    1. Hallo,
      Das sieht doch schon mal sehr vielversprechend aus! Schönes sauberes Signal.
      Schnell erkennbar sind zwei unterschiedliche Bausteine: Kurz High+Lang Low sowie Lang High+Kurz Low. Das werden die beiden unterschiedlichen Bits 1 und 0 sein. Für den gegeben Code etwa 01100111101000110110110000100 (1 und 0 vertauschbar, kann auf die schnelle Fehler enthalten). Ob die Ausschläge ganz am Anfang und Ende mit dazugehören (Synchronization) oder zu einem anderen Signal gehören kann ich mit den gegeben Ausschnitt nicht sehen.
      Einfach mal für unterschiedliche Tasten die Signal decodieren und dann auf Muster untersuchen.

      Grüße,
      Dominik

      Like

  20. Hallo,
    ich sitze z. Zt. an einem Signal, welches irgendwie nicht in das Muster passt … ich bekomme immer gleiche Abstände zwischen 2 Signalen und komme mit dem Decodieren nicht voran.
    Das Einzige, was ich fest machen kann, ist, das jedes Signal anscheinend mit “lang” “kurz” “kurz” “lang” “lang” anfängt und insgesamt 26 Impulse hat.
    Hier habe ich mal verschiedene Signale aufgezeichnet.



    Freue mich über jede Hilfe.
    Gruß
    Rainer

    Like

    1. Es ist immer möglich, dass irgendeine schwer durchschaubare Codierung genutzt wurde oder gar jeder Taste zufällig irgendein Code zugeordnet wurde. In diesen Fällen muss man das dann einfach Hardcodieren.
      Am einfachsten ist das Decodieren wenn man die ganzen Codes (in diesem Falle) als Binärcode darstellst und dann nach Mustern sucht. Graphisch ist das immer schwer zu vergleichen wenn das Muster nicht offensichtlich ist. Die zwei unterschiedlichen Bits hast du ja schon entdeckt.
      Mehr kann ich derzeit leider während der Prüfungszeit nicht helfen.

      Grüße,
      Dominik

      Like

      1. Hallo Dominik,
        vielen Dank für den Gedankenanstoß. Ich habe es jetzt tatsächlich geschafft, allerdings halt “nur” hardcoded, aber Hauptsache, es läuft.
        Vielen Dank für die tolle Seite und viel Glück bei den Prüfungen.
        Gruß
        Rainer

        Like

  21. Hallo Dominik,

    geniale Idee den Mikrofon Eingang vom PC zur Analyse zu missbrauchen 🙂
    Dass merke ich mir.
    Ich habe mit dem Projekt nun auch begonnen und würde Dich bitte mein Ergebnis mal zu überprüfen.
    Ich kam auf folgende Lösung:
    0001000100000101010100010

    Vielen lieben Dank.

    Gruß

    Thomas

    Like

    1. Entschuldige bitte meine späte Antwort, ist derzeit alles ein wenig stressig bei mir.
      Der Bitcode scheint auf den ersten Blick zu passen. Das Signal für die einzelnen Bits sieht aber ein wenig merkwürdig aus.

      Grüße,
      Dominik

      Like

  22. Hallo Dominik,

    vielen Dank für das anschauliche Tutorial!

    Ich versuche meine alten Funkstecker von Lidl (TR-502MSV) in FHEM zum Laufen zu bringen. Dabei kommt folgendes Signal heraus:

    Die obere Spur ist der Befehl für aus, unten für an. Einen Unterschied sehe ich nur ganz am Schluss, also letztes Bit.

    Kannst du dir das Signal mal anschauen?

    Viele Grüße,
    Michael

    Like

    1. Bitte entschuldige meine späte Anwort, ich bin derzeit recht ausgelastet.
      Ich sehe zwei unterschiedliche Bits in deinem Bild (auf etwa 3/4 ist noch ein Unterschied).
      Die nach unten gehenden Ausschläge sind gleichmäßig, relevant sind also die nach oben gehenden. Codierung je nach dem ob der Ausschlag am Anfang oder Ende des Taktes ist.
      Das ist leider das einzige was mir auf den ersten Blick dazu einfällt.

      Grüße,
      Dominik

      Like

  23. Hallo,
    ich hab hier mal mit gelesen und hab auch das Problem das ich die GT-9000 nicht ausgelesen und Angesteuert per Arduino.
    Ich habe hier auch noch mehrere HE844A Fernbedienungen wenn man die GT-9000 und die HE844A aufschraubt sehen die beide identisch aus. Leider wurde die Bezeichnung vom IC abgekratzt. Jetzt meine Frage hat jemand schon es hin bekommen die beiden Funken per Arduino anzusprechen? Der Hintergrund ist, ich würde gerne per Echo Dot. einen ESP8266 ansprechen der dann wieder einen Arduino schaltet.
    Vielleicht hat ja noch einer eine Idee oder kann mir Helfen, das mit den Protokollen habe ich ehrlich nicht verstanden.

    Lg

    Stef

    Like

Leave a Reply to Sebastian K Cancel reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.