"Home Automation" mit dem Arduino und 433 MHz - Der Rolladen, Teil 2

(English version) Die Theorie zur Steuerung des Rolladens ist bekannt - jetzt geht es an die praktische Ansteuerung.

Das Protokoll zur Steuerung des Rolladens ist ja wie bereits erwähnt sehr ähnlich dem Protokoll zur Steuerung der Funksteckdosen. Da lag es nahe, bei der Entwicklung der passenden Software nicht ganz bei Null anzufangen, sondern die bereits existierende und bewährte rc-switch-Library zu verwenden. Natürlich sind einige Anpassungen nötig.

Anpassungen rc-switch

Die Library bietet von Haus aus drei Protokolle für unterschiedliche Steckdosen. Diese unterscheiden sich hauptsächlich in der Pulslänge und der Form des Sync-Bits. Ich habe mich entschieden, für den Rolladen ein viertes Protokoll hinzuzufügen.

Die erste Anpassung muss also in der Funktion setProtocol() vorgenommen werden:

void RCSwitch::setProtocol(int nProtocol) {
  this->nProtocol = nProtocol;
  if (nProtocol == 1){
    this->setPulseLength(350);
  }
  else if (nProtocol == 2) {
    this->setPulseLength(650);
  }
  else if (nProtocol == 3) {
    this->setPulseLength(100);
  }
  //edit: Protokoll 4 für Rolladen mit Pulslänge 250ms und 4 Wiederholungen
  else if (nProtocol == 4) {
    this->setPulseLength(250);
    this->setRepeatTransmit(4);
  }
}

Alle Änderungen sind mit einem //edit-Kommentar markiert. Ich habe hier im Prinzip nur einen vierten else-if-Zweig für das Protokoll 4 eingefügt. Wird das Protokoll 4 gewählt, setzt der Code die Pulslänge (ein Puls entspricht einem Viertel) auf 250µs.Außerdem wird die Funktion setRepeatTransmit mit dem Parameter 4 aufgerufen. Dies bewirkt, dass jeder Befehl automatisch immer viermal gesendet wird (so wie es auch die Fernbedienung macht).

Als nächste Anpassung musste eine Funktion eingefügt werden, mit der das Senden eines Quad-State-Befehls möglich ist. Dafür habe ich einfach die sendTriState()-Funktion erweitert:

//edit: Quad-State-Befehl mit zusätzl. Q senden
void RCSwitch::sendQuadState(char* sCodeWord) {
  for (int nRepeat=0; nRepeat<nRepeatTransmit; nRepeat++) {
    //Syn-Bit wird hier VOR Übertragung gesendet!
 this->sendSync(); 
 int i = 0;
    while (sCodeWord[i] != '\0') {
      switch(sCodeWord[i]) {
        case '0':
          this->sendT0();
        break;
        case 'F':
          this->sendTF();
        break;
        case '1':
          this->sendT1();
        break;
        case 'Q':
          this->sendQQ();
        break;
      }
      i++;
    }   
  }
}

Ein großer Unterschied zwischen Rolladen und Steckdosen ist das Sync-Bit. Während es bei den Steckdosen erst NACH Übertragung des Befehls gesendet wird, muss beim Rolladen zuerst das Sync-Bit und dann der Befehl übertragen werden. Daher wird in der Funktion sendQuadState die Funktion sendSync() zu Beginn der Funktion aufgerufen - bei der ursprünglichen sendTriState()-Funktion erfolgte der Aufruf erst am Ende. Als weitere Änderung habe ich einen vierten Case eingefügt. Stößt das Programm beim "abarbeiten" des zu sendenden Codeworts auf ein Q, wird die (ebenfalls von mir eingefügt) Funktion sendQQ() aufgerufen.

/**
 * edit: Sends a Quad-State "Q" Bit
 *            ___   _
 * Waveform: |   |_| |___
 */
void RCSwitch::sendQQ() {
  this->transmit(3,1);
  this->transmit(1,3);
}

Die Funktion sendet mit transmit(3,1) zuerst ein langes HIGH-Signal, gefolgt von einem kurzen HIGH-Signal. Der erste Parameter der Funktion gibt an, wie viele Pulslängen die HIGH-Phase andauert. Der zweite Parameter gibt entsprechend die Länge der LOW-Phase an.

Die letzte Anpassung wurde in der Funktion zum Senden des Sync-Bits vorgenommen:

void RCSwitch::sendSync() {

    if (this->nProtocol == 1){
        this->transmit(1,31);
    }
    else if (this->nProtocol == 2) {
        this->transmit(1,10);
    }
    else if (this->nProtocol == 3) {
        this->transmit(1,71);
    }
 
    //edit: Syn-Bit für Rolladen
    else if (this->nProtocol == 4) {
        this->transmit(18,6);
    }
}

Das Sync-Bit des Rolladens besteht bekanntermaßen aus einer HIGH-Phase von 4500µs Dauer, gefolgt von einer 1500µs andauernden LOW-Phase. Das Sync-Bit besteht also aus 18 Pulslängen HIGH und 6 Pulslängen LOW (bei einer Pulslänge von 250µs).

Mit diesen kleinen Änderungen lässt sich die rc-switch Library nun auch zur Steuerung des Rolladens verwenden.

Jetzt wird es spannend

Nach so viel Theorie soll nun endlich der Praxistest erfolgen!

Also schnell ein kleines Programm zusammen gebastelt, dass unter Verwendung der modifizierten Library den Rolladen hoch und runter fahren lässt:

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

void setup() {
  Serial.begin(9600);
  Serial.println("Bereit...");
  mySwitch.enableTransmit(10);
  mySwitch.setProtocol(4);
}

void loop() {
  //runter
  Serial.println("Runter...");
  mySwitch.sendQuadState("0F0F0100QQ0F100F0101");
  mySwitch.sendQuadState("0F0F0100QQ0F100F0110");
  
  delay(5000);
  
  //Stopp
  Serial.println("Stopp...");
  mySwitch.sendQuadState("0F0F0100QQ0F100FFFFF");
  
  delay(1000);
  
  //rauf
  Serial.println("Rauf...");
  mySwitch.sendQuadState("0F0F0100QQ0F100F0F0F");
  mySwitch.sendQuadState("0F0F0100QQ0F100F0F1Q");
  
  delay(5000);
  
  //Stopp
  Serial.println("Stopp...");
  mySwitch.sendQuadState("0F0F0100QQ0F100FFFFF");
  
  delay(1000);
}

In der setup()-Funktion wird das Protkoll auf 4 gesetzt - sonst kann der Rolladen nichts mit dem Funksignal anfangen. In der loop()-Funktion werden dann mit der neuen sendQuadState()-Funktion zuerst die Befehle zum herunterlassen des Rolladens gesendet (woher die Befehle kommen habe ich in Teil 1 beschrieben). Dann wird 5 Sekunden lange gewartet, der Rolladen wird gestoppt, wieder herauf gefahren, nach 5 Sekunden wieder gestoppt usw.

Im letzten Schritt muss nun nur noch die Steuerung von Steckdose und Rolladen zusammengefasst werden, um die gewünschte Funktionalität (Steckdose an, Rolladen verfahren, Steckdose aus) zu erhalten.