614

Die Rollladensteuerung arbeitet über I2C mit den angeschlossenen Port-Expandern MCP23017. Ein Port-Expander arbeitet als Input und ein weiterer als Output für die Relaiskarte. Alle externen Programmteile der Peripherie werden in C geschrieben. Anleitungen in Python gibt es ja schon und können im Internet nachgelesen werden.

Die Rollladensteuerung arbeitet über I2C mit den angeschlossenen Port-Expandern MCP23017. Ein Port-Expander arbeitet als Input und ein weiterer als Output für die Relaiskarte. Alle externen Programmteile der Peripherie werden in C geschrieben. Anleitungen in Python gibt es ja schon und können im Internet nachgelesen werden.

Realisierung einer klassischen Prozesskette nach dem EVA Prinzip.

Eingabe: Schaltermodul zur Gruppensteuerung oder evtl. Fernbedienung

Verarbeitung: Raspberry Pi und OpenHAB Software für Gebäudeautomatisierung

Ausgabe: Steuerplatine für Relais die einzelne Motoren für die Rollläden ansteuern

Für das Arbeiten am RPi empfehle ich nach dem ein funktionierendes Image vorliegt, dass installieren eines SSH Servers. Dazu folgendes Kommando in der Konsole eingeben:

  • sudo apt-get install openssh-server

Jetzt kann man sich per ssh mit dem RPi verbinden. Somit kann man auf Tastatur und Monitor am RPi verzichten.

Schritt 1: Raspberry Pi vorbereiten
Folgende Kommandos dienen dazu das Raspian mit Hilfe der Paketquellen auf den aktuellen Stand zu bringen.
  • sudo apt-get update
  • sudo apt-get upgrade
  • sudo apt-get rpi-update

Schritt 2: Openhab Verzeichnis anlegen und Pakete installieren

  • sudo mkdir /opt/openhab
  • cd /opt/openhab
  • sudo wget https://github.com/openhab/openhab/releases/download/v1.6.1/distribution-1.6.1-runtime.zip
  • sudo unzip distribution-1.6.1-runtime.zip
  • sudo rm distribution-1.6.1-runtime.zip

Nun wurden die Pakete für das Openhab heruntergeladen, entpackt und das nicht mehr benötigte zip-File gelöscht. Um externe Programme im Openhab aufzurufen braucht man entsprechende Bindings. Diese können über die Addons nachgeladen werden.

Schritt 3: Addons installieren

  • cd /opt/openhab/addons
  • sudo wget https://github.com/openhab/openhab/releases/download/v1.6.1/distribution-1.6.1-addons.zip
  • sudo rm distribution-1.6.1-addons.zip

Schritt 4: Openhab beim Booten des RPi automatisch starten

  • sudo nano /etc/init.d/openhab

Das Bash Script sollte wie folgt aussehen:

#! /bin/sh
# /etc/init.d/

touch /var/lock/openhab

case "$1" in
start)
echo "Starting RasPi Openhab ... "
/opt/openhab/./start.sh > /dev/null &
;;
stop)
echo "Killing RasPi Openhab ..."
killall start.sh
;;
*)
echo "Usage: /etc/init.d/openhab {start|stop}"
exit 1
;;
esac
exit 0
 
  • sudo chmod 755 /etc/init.d/openhab
  • sudo update-rc.d openhab defaults
Quelle: http://www.itbasic.de/openhab-automatisch-starten/

Anschließend muss noch das I2C Modul freigeschalten werden. In der Datei Raspian /boot/config.txt muss am Dateiende noch die Parameter eingetragen werden:

dtparam=i2c1=on
dtparam=i2c0=on

Die nötigen Treiber werden nach dem Aktivieren der I2C Module automatisch geladen. Dies geschieht im Raspi-Konfigurationsmenü mit

sudo raspi-config

Im Untermenü "Advanced Configuration" können die Treiber für I2C aktiviert werden.

Ob das I2C Modul korrekt geladen wurde kann mit dem Befehl

ls /dev/i2c*

überprüft werden. In der Ausgabe sollten alle Module gelistet sein, die zuvor konfiguriert wurden.

Openhab-Beschreibung:

openhab.cfg: In der Konfigurationsdatei werden grundlegende Konfigurationen eingestellt. Einstellungen für Bindings werden ebenfalls hier eingetragen.

Rules: Im Openhab können verschiedene Regeln festgelegt werden um ein definiertes Verhalten seines Smarthomes zu erreichen. Dazu werden im Verzeichnis /opt/openhab/configuration/rules/ Dateien mit der Endung .rules angelegt. Eine Prozedur die beim Starten des Systems aufgerufen wird, z.B. zum intialisieren der Anlage,  kann dann wie folgt aussehen:

rule "Startup"

when System started

then

//hier sämtliche Aufrufe

end

Konzept: Das Bedienkonzept der Rollladensteuerung sieht wie folgt aus: Ein Port Expander dient als Input für das Bedienelement und sendet bei Tastendruck einen Interrupt an das RPi. Dieses prüft welche Taste gedrückt wurde und ändert den Zustand der angesprochenen Gruppe. Die Rollläden der gewählten Gruppe werden dann syncron in die entsprechende Drehrichtung geschalten. Dafür werden verschiedene Programme benötigt:

  • Programm zum Initalisieren der Port-Expander für Input und Output
  • Programm zum Einlesen des Tastenfeldes
  • Programm zum Setzen bzw. Rücksetzen des Relais

Hinweis: Alle C Programme werden hier mit Hilfe des Editors nano geschrieben. Für die Übersetzung des Programmcodes wird der GNU C-Compiler verwendet.

Um festzustellen ob ein I2C Teilnehmer korrekt antwortet kann das Programm i2cdetect eingesetzt werden. Sollte dies nicht installiert sein, kann es mittels

sudo apt-get install i2c-tools

nachinstalliert werden.

Nun können alle Teilnehmer im Adressbereich überprüft werden. Dies geschieht mit dem Aufruf i2cdetect und dem I2C-Bus.

i2cdetect 1

Dieser Befehl prüft alle Teilnehmer am i2c-1. Die Ausgabe ist im Anhang sichtbar. Dort ist zu erkennen unter welcher Adresse ein Teilnehmer geantwortet hat.
 
Grundsätzlich können die I2C Module aus dem Kernelspace oder aus dem Userspace kontolliert werden. Um die Hardwareschnittstellen auch in anderen Projekten nutzen zu können, wird hier allgemein der Zugriff auf die I2C Module aus dem Userspace heraus behandelt.
Bemerkung: Eine Implementierung eines MCP23017 Treibers erfolgt evtl. zu einem späteren Zeitpunkt.

Programm zum Initialisieren der Port Expander:

Die Adressvergabe der Portexpander ist willkürlich und wird deshalb im Programm berücksichtigt. Die erste Adresse, die an das Programm übergeben wird ist der Input und die zweite der Output.

Für die Inbetriebnahme wird ein eigenstädiges Programm für den Port-Expander des Output geschrieben.

Dieses Programm initalisiert alle I/O Pins des MCP23017 als Output. Der Pegel, der einzelnen Pins nach der Initialisierung, ist Low.

#include < stdio.h >
#include < stdlib.h >
#include < linux/i2c-dev.h >
#include < linux/swab.h >
#include < fcntl.h >
#include < unistd.h >
#include < inttypes.h >

/*
arg[0]= first argument i2c-device
arg[1]= second argument slave device addr
arg[2]= register
*/

#define FILENAME_LENGTH 20

#define IODIRA 0x00
#define IODIRB 0x01
#define GPIOA 0x12
#define GPIOB 0x13

int main (int argc,char *argv[]){
float ret=0.0;
int file=0;
if(argc <3){
exit(1);
}

char filename[FILENAME_LENGTH];
snprintf(filename,FILENAME_LENGTH-1,argv[1]);
file= open(filename,O_RDWR); // open the specific device
  int addr = 0x20; /* The I2C address */
 __u8 reg = 0x00; /* Device register to access */
__s32 res=0;



  if (ioctl(file, I2C_SLAVE, addr) < 0) {
 exit(1);
  }

char tempreg=0;
sscanf(argv[2],"%x",&tempreg);
char config=0x00;
reg=IODIRA;
config=0x00;
i2c_smbus_write_byte_data(file, reg, config);
reg=IODIRB;
config=0x00;
i2c_smbus_write_byte_data(file, reg, config);

reg=GPIOA;
config=0x00;
i2c_smbus_write_byte_data(file, reg, config);

reg=GPIOB;
config=0x00;
i2c_smbus_write_byte_data(file, reg, config);

close(file); //close device file
return ret;
}

Zur Erklärung des Programmcodes werden nun die einzelnen Kommandos bzw. der Programmablauf erläutert.

Als erstes muss das jeweilige Device File geöffnet werden. Dazu kann der jeweilige String an das Programm übergeben werden, oder fest im Programm vorgegeben sein.

file =open("/dev/i2c-1", O_RDWR);

Als nächstes muss das I2C Gerät ausgewählt werden, mit dem kommuniziert werden soll. Dazu muss die Adresse des I2C Gerätes bekannt sein. Im Beispiel handelt es sich um eine 8-bit Adressierung.

ioctl(file,I2C_SLAVE,0x20);

Der Rückgabewert kann hier zur Fehlerbetrachtung verwendet werden.

Mit Hilfe der i2c_smbus-Funktionen kann auf den Bus geschrieben, bzw. von ihm gelesen werden.

Bemerkung: Beim Lesen von 16-bit Werten muss die Reihenfolge von High- und Lowbyte beachtet werden.

Anschließend muss das Device File wieder geschlossen werden.

close(file);

Programm zum Einlesen des Tastenfeldes: