Codesnippet: php / Raspberry Pi => Fritzbox => Telefonanruf

Jaaaa, ich hab‘ endlich auch einen Raspberry Pi und bin total begeistert – obwohl ich nach wie vor keine Ahnung habe was ich damit jetzt konkret anstellen soll 🙂
Beim rumspielen ist jetzt ein Snippet entstanden, das sich per telnet an der Fritzbox anmeldet und per AT-Befehl kurz eine Nummer anruft.

!#/usr/bin/php5
<?php

$fritzIP  = '192.168.178.1';
$pass     = 'xxxxxxxxxx';
$number   = '0173xxxxxx';
$sleep    = 10;


if ($fp = fsockopen($fritzIP, 23)) {
  $buffer = '';
  while (!feof($fp) && !preg_match('/password/', $buffer)) {
    $buffer .= fread($fp, 1);
  }
  
  fputs($fp, $pass . "rn");
  sleep(1);
  fputs($fp, 'echo "ATDT' . $number . '" | nc 127.0.0.1 1011' . "rn");
  sleep($sleep);
  fputs($fp, 'echo "ATH" | nc 127.0.0.1 1011' . "rn");
  sleep(1);
  
  
} else {
  echo 'Telnet connection failed ' . $fritzIP;
}
Advertisements

Use any Arduino pin for transmission with the IRremote libary by soft PWM

I really love Ken Shiriffs IRremote libary for Arduino but it had a dealbreaking limitation for my current project: it makes use of the PWM functionality and is therefore bound to pin 3. As I really needed all PWM pins for other stuff and didn’t want to upgrade to a Mega board, I worked out this hack.

A IR signal consists of on- and off states and that is literally switching the IR LED on and off in special periods. While a off state is actually switching the LED off at all, a on state is more like blinking with a really high frequency of 38kHz. This is a typical task for PWM but after all it is again nothing else than just switching it on and off.

First at all we have to find out how fast we have to switch on/off with this frequency.

36000 / 1s = 1 / n * s
n = 1/36000s =  27,7 μs

So we have to switch it on and off every 27,7μs (fortunately the delayMicroseconds function works accurately for values above 3μs) and it’s simple as this:

while (OnStateDuration) {
  digitalWrite( sendPin, HIGH);
  delayMicroseconds(14);
  digitalWrite( sendPin, LOW);
  delayMicroseconds(14);
}

=== Instruction ===
You can download the modified libary here or go through these steps:

Replace the following methods in IRremote.cpp:

void IRsend::mark(int time) {
  unsigned long n = micros();
  while (micros()-n < time) {
    digitalWrite(irparams.sendpin, HIGH);
    delayMicroseconds(irparams.pulselength);
    digitalWrite(irparams.sendpin, LOW);
    delayMicroseconds(irparams.pulselength);
  }
}

void IRsend::space(int time) {
  digitalWrite(irparams.sendpin, LOW);
  delayMicroseconds(time);
}

void IRsend::enableIROut(unsigned int khz) {
  irparams.pulselength = 500 / khz;
  pinMode(irparams.sendpin, OUTPUT);
  digitalWrite(irparams.sendpin, LOW); // When not sending PWM, we want it low
}

IRrecv::IRrecv(int recvpin)
{
  irparams.recvpin = recvpin;
  irparams.blinkflag = 0;
}

Add the sendpin parameter to the constructor signature in IRremote.h:

class IRsend
{
public:
  IRsend(int sendpin);

Define the sendpin and period variables in IRremoteInt.h:

typedef struct {
  uint8_t sendpin;
  unsigned int pulselength;


When using in a sketch, you have to specify the pin for transmission:

IRsend irsend;  // deprecated
IRsend irsend(10);  // send on pin 10


Flattr this

======

PS: If you’re experimenting with IR you might find this useful. You can use an ordinary red LED instead of a IR LED on short a short distance of let’s say about 2 or 3 cm. I accident found this and I’m very happy about not needing to use my mobile phones camera to check the IR light any more.

Funkfernbedienungen: neue Erkentnisse und decodieren

Kennst du eine, kennst du alle. Wie ich inzwischen festgestellt habe, basieren die meisten billigen Funkfernbedienungen auf dem gleichen Protokoll. Neben den bei Funksteckdosen beliebten SC2262, HX2262, PT2262 wären da noch die EV1527, RT1527, FP1527, HS1527 (alle untereinander kompatibel, gefunden in den Funkdimmern von Pollin oder erschreckenderweise auch in der Fernbedienung für die Zentralverriegelung meines Autos… ich glaube zu dem Thema werde ich nochmal einen eigenen Artikel schreiben) zu erwähnen.

Die 2262er senden vom Nutzer konfigurierte 8 oder 10Bit lange Adressen gefolgt von 4 oder 2Bit langen Befehlen und einem Sync-Bit. Die 1527er senden einen Sync-Bit, eine fest im Chip verdratete, „einmalige“ 20Bit Adresse und einen 4Bit langen Befehl. Da man die Three-State Bits „1“, „0“, „F“ bei den 2262ern auch zu je zwei Two-State Bits „1“, „0“ substituieren kann (1=11, 0=00, F=01), senden also eigentlich beide letzendlich immer nur einen 24Bit Wert und eine Pause an deren Länge man das Timing ermitteln kann.

Hier ist mein erstes zusammengehacktes Arduino Sketch zum decodieren aller 433MHz Fernbedienungen die nach diesem Prinzip funktionieren (433MHz AM Empfänger oder falls nicht zur Hand einfach den im vorletzten Blogeintrag beschriebenen Dout der Fernbedienung an Pin#2):

#define maxChanges 500

unsigned int duration;
unsigned int changeCount;
unsigned int timings[maxChanges];
unsigned long lastTime;
unsigned int repeatCount;

void setup() {
  Serial.begin(9600);
  
  lastTime = micros();
  repeatCount = 0;
  changeCount = 0;
  
  attachInterrupt(0, r, CHANGE); 
}

void loop() {

}

void output() {
  unsigned long code = 0;
  unsigned long delay = timings[1] / 31;
  unsigned long delayTolerance = delay*0.2;
  Serial.print("Delay: ");
  Serial.println(delay);
  for (int i = 2; i+1<changeCount ; i=i+2) {
    if (timings[i] > delay-delayTolerance && timings[i] < delay+delayTolerance && timings[i+1] > delay*3-delayTolerance && timings[i+1] < delay*3+delayTolerance) {
      Serial.print("0");
      code = code << 1;
    } else if (timings[i] > delay*3-delayTolerance && timings[i] < delay*+delayTolerance && timings[i+1] > delay-delayTolerance && timings[i+1] < delay+delayTolerance) {
      Serial.print("1");
      code+=1;
      code = code << 1;
    } else {
      Serial.println("");
      Serial.print("Failed: ");
      Serial.print(i);
      Serial.print("/");
      Serial.print(timings[i]);
      Serial.print("/");
      Serial.println(timings[i+1]);
    }
  }
  code = code >> 1;
  Serial.println();
  Serial.print("Code: ");
  Serial.println(code);
    Serial.println();
}

void r() {
  long time = micros();
  duration = time - lastTime;
  
  if (duration > 5000 && duration > timings[1] - 200 && duration < timings[1] + 200) {
    repeatCount++;
    if (repeatCount == 2) {
      output();
      repeatCount = 0;
    }
    changeCount = 0;
  } else if (duration > 6000) {
    changeCount = 0;
  }
  
  if (changeCount >= maxChanges) {
    changeCount = 0;
    repeatCount = 0;
  } else {
    changeCount++;
  }
  timings[changeCount] = duration;
  lastTime = time;
}

Update: Eine Empfangs- und Decodierfuntion findet sich inzwischen auch in der RCSwitch Libary


Flattr this

Funksteckdosen mit dem Handy steuern

Nachdem die Arduino Libary für die 433MHz Steckdosen fertig ist, ist die Ansteuerung über eine serielle Bluetooth Schnittstelle fast schon ein no brainer.

Hardware
1.) Die RC Fernbedienung mit Strom versorgen (Arduino: Vin + GND), Datenleitung beim Arduino an Pin #10

2.) Den Bluetooth Mate mit Strom versorgen (BTMate VCC => Arduino 5V, BTMate GND => Arduino GND), serielle Schnittstelle verbinden (BTMate RX-1 => Arduino TX, BTMate TX-0 => RX) und beim BTMate noch CTS1 + RTS0 kurzschließen.

3.) Android Handy bereithalten 🙂

Android App
qrcodeFür den Anfang tut es eine fertige App. Im Market gibt es z.B. Blue Control, welches einfach auf Knopfdruck einzelne Bytes an das verbundene Gerät sendet. Die mit A..H beschrifteten Knöpfe senden jeweils den entsprechenden (Klein)Buchstaben (nicht wundern, in Version 1.0 sind außerdem b und c vertauscht), Die Pfeiltasten sind U (up), D (down), L (left), R (right) und C (center).

Arduino Sketch
Schaltet die erste Steckdose aus der ersten Gruppe bei „a“ an und bei „e“ aus.

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch(10);  // Sender is connected to Pin #10

void setup() {
  Serial.begin(115200);
}

void loop() {
  
  if (Serial.available()) {
    byte inBT = Serial.read();
    if (inBT == 'a') {
        mySwitch.switchOn(1, 1);
    }
    if (inBT == 'e') {
        mySwitch.switchOff(1, 1);
    }
  }
  
}


Flattr this

Low cost RC power sockets (radio outlets) + Arduino

[Deutsche Version]

For cheap home automation purposes I’d like to present you my new Arduino libary for operating up to 16 low cost 433MHz RC power sockets. I’ve bought this RC switch set for about 10 EUR.

There is a SC5262 chip (datasheet) built in the hand set which – depending on which key is pressed – generates a data telegram and relays it to the actual RC sender. After studying the datasheet and some other resources (1, 2, 3 – sorry, all in german) on similar projects I was able to control the switches using only one I/O pin at the Arduino.

Theory
If you know how the data telegrams look like, you can generate them with the microcontroller and therefore resign the encoder chip from the hand set.

A code bit consists of two on/off states. The important thing are the cronological lengths of these states. You can think of it like morse. There are thre possible code bits at all, that is „0“, „1“ and „F“. Furthermore there is another sync. bit (I’ll call it „S“).

"0" Bit => 1/8 cycles on, 3/8 cycles off, 1/8 cycles An, 3/8 cycles off   -...-...
"1" Bit => 3/8 cycles on, 1/8 cycles off, 3/8 cycles An, 1/8 cycles off   ---.---.
"F" Bit => 1/8 cycles on, 3/8 cycles off, 3/8 cycles An, 1/8 cycles off   -...---.
"S" Bit => 1/8 cycles on, 31/8 cycles off -...............................

A code word consists of 9 address bits, 3 data code bits and one sync. bit. It represents the command (data bits) to a specific switch (address bits).

A code frame consists of 4 code words. Basically every command is repeated 4 times.

The conrad power switches are coded as follows:
4 bits group address + 4 bits switch address + 1 unused adress bit + 1 unused data bit + 2 data/command bits + 1 sync. bit


group address I = "0FFF"
group address II = "F0FF"
group address III = "FF0F"
group address IV = "FFF0"

switch 1 = "0FFF"
switch 2 = "F0FF"
switch 3 = "FF0F"
switch 4 = "FFF0"

unused databits = never mind, could be either "F" or "0"

command on = "FF"
command off = "F0"

So if you want to switch the 3rd switch from the 4th group off, you’ll have to send „FF0FFFF0FFF0S“.

Hardware / Hacking the hand set

Open your hand-held transmitter and solder a wire to the positive pole (+), one to the negative pole (-) of the battery holder and another one to the DOUT Pin of the SC5262S chip.
Altough my transmitter was operated with a 12V battery it also worked with 5V, so I think it’s fine to power it directly from the Arduino (5V and GND). Connect DOUT to any available I/O pin from the Arduino.

Software
Download RCSwitch.zip and extract it to your /Arduino/Libaries directory. The following sketch should be self explaining 🙂

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch(11);  // Sender is connected to Pin #11

void setup() {
}

void loop() {
    mySwitch.switchOn(1, 1);         // Switch 1st socket from 1st group on
    delay(1000);
    mySwitch.switchOff(1, 1);        // Switch 1st socket from 1st group off
    delay(1000);
}

Updates

  • The libary is hosted at google code now (here).
  • New sending methods (other outlet types than described here or raw codes)
  • New functionality to receive and decode signals from your remote hand set


Flattr this

Low cost Funksteckdosen + Arduino

[English version]

Für die billige Haus-Automatisierung möchte ich hier heute meine frisch geschriebene Arduino Libary für „433MHz Baumarkt Funksteckdosen“ vorstellen. Weil Conrad aber näher als Max Bahr ist und ich auch lieber bei Conrad shoppe, habe ich für knapp 10 EUR die hier gekauft.

In der Fernbedienung schlummert ein SC5262 Chip (Datenblatt), welcher je nach gedrücktem Knopf ein digitales Datentelegram erzeugt und an den eigentlichen Funksender weitergibt. Nach intensivem Studium des Datenblatts und verschiedenen anderen Quellen (1) (2) (3) mit ähnlichen Projekten habe ich es auch tatsächlich auch wie folgt geschafft, die Steckdose mit einem einzigen Datenkabel am Arduino zu steuern.

Theorie
Wenn man weiss wie die Datentelegramme aussehen müssen, kann man die auch selbst mit dem Mikrocontroller erzeugen und somit auf den Encoderchip aus der Fernbedienung verzichten. Im Datenblatt steht folgendes:

Ein Code Bit besteht aus zwei An/Aus-Zuständen, wichtig ist hierbei die zeitliche Länge dieser Zustände, kann man sich so ähnlich vorstellen wie Morsezeichen. Es gibt insgesamt drei mögliche Code Bits, nämlich „0“, „1“ und „F“. Darüber hinaus gibt es noch ein Sync. Bit (ich nenn‘ es mal „S“).

"0" Bit => 1/8 Taktlänge An, 3/8 Taktlängen Aus, 1/8 Taktlänge An, 3/8 Taktlängen Aus   -...-...
"1" Bit => 3/8 Taktlängen An, 1/8 Taktlänge Aus, 3/8 Taktlängen An, 1/8 Taktlänge Aus   ---.---.
"F" Bit => 1/8 Taktlänge An, 3/8 Taktlängen Aus, 3/8 Taktlängen An, 1/8 Taktlänge Aus   -...---.
"S" Bit => 1/8 Taktlänge An, 31/8 Taktlängen Aus -...............................

Ein Code Word besteht aus 9 Adress Code Bits, 3 Data Code Bits und einem Sync Bit und repräsentiert quasi den Befehl welche Steckdose (Adress Bits) was machen soll (Daten Bits).

Ein Code Frame besteht aus 4 Code Words, also im Grunde genommen wird jeder Befehl 4x wiederholt.

Die Conrad Steckdosen sind dabei folgendermaßen Codiert:
4 Bits Gruppenadresse + 4 Bits Steckdosenadresse + 1 ungenutzter Adress Bit + 1 ungenutzer Daten Bit + 2 Daten/Befehls Bits + 1 Sync Bit


Gruppenadresse I = "0FFF"
Gruppenadresse II = "F0FF"
Gruppenadresse III = "FF0F"
Gruppenadresse IV = "FFF0"

Steckdose 1 = „0FFF“
Steckdose 2 = „F0FF“
Steckdose 3 = „FF0F“
Steckdose 4 = „FFF0“

Ungenutze Datenbits = egal, also „F“ oder „0“

Befehl An = „FF“
Befehl Aus = „F0“

Wenn ich also die 3. Steckdose aus der 4. Gruppe ausschalten möchte, muss ich ein „FF0FFFF0FFF0S“ senden.

Hardware / Fernbedienung anzapfen

Fernbedienung öffnen, am DOUT Pin ein Kabel und zwei weitere für die Stromversorgung anlöten. DOUT kann an jeden beliebigen I/O Pin vom Arduino, den Strom kann man auch vom Arduino abzapfen (5V und GND), denn obwohl da eigentlich eine 12V Batterie drin war funktioniert das ganze auch wunderbar mit 5V.

Software
RCSwitch.zip runterladen und im Arduino/Libaries Verzeichnis entpacken. Der folgende Sketch ist eigentlich selbsterklärend 🙂

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch(11);  // Sender is connected to Pin #11

void setup() {
}

void loop() {
    mySwitch.switchOn(1, 1);         // Switch 1st socket on
    delay(1000);
    mySwitch.switchOff(1, 1);        // Switch 1st socket off
    delay(1000);
}

Updates

  • Die Libary liegt jetzt bei Google Code
  • Steckdosen mit DIP-Switches (in der Regel mt HX2262 oder PT2262 Encoder in der Original Fernbedienung) können auch angesteuert werden (Anleitung).
  • Billiger: Bei Praktiker gibt es 3er Sets mit etwas Glück für 6,99 EUR im Sonderangebot (thx @ Reinhard); ich persönlich habe inzwischen zur Erweiterung die Steckdosen von Pollin (9,99 EUR 3er Set)genommen.
  • Version 0.7 kann jetzt auch Codes einer Fernbedienung empfangen und decodieren
  • Einfacher: Wer nicht löten möchte, sollte sich ein fertiges Modul kaufen. Gibt es ab 5 EUR. Am billigsten inclusive Versand von Händlern aus Hong Kong/China bei eBay (Suche nach „433 Arduino“ oder „RF Link“). Ansonsten hier eine Liste mit Bezugsquellen.
  • Unterstützung von Intertechno Steckdosen (thx @ Holger)


Flattr this