Einige Router, die mit OpenWRT geflasht sind, haben zu wenig Speicher, um größere Programme zu installieren.
Für Analysezwecke habe ich zum Beispiel das Programm „tcpdump“ benötigt, hatte dafür aber zu wenig Speicher zur Verfügung.
tcpdump Installation OpenWRT TP-Link TL-WR841N/ND v10 weiterlesen
Nachdem die Teile zum Ausprobieren von Homegear angekommen sind, kann ich endlich ein wenig ausprobieren.
Komponenten Liste:
– RaspberryPi
– CUL1101 v3.4
Der RaspberryPi läuft mit einem Debian Jessie minimal Image, das ich frisch für die Verwendung aufgesetzt habe.
Der CUL muss mit der passenden Firmware geflasht werden, um verwendet werden zu können. Zuerst muss der CUL in dem RaspberryPi eingesteckt werden. Mit ‚lsusb‘ kann überprüft werden, ob der USB Stick erkannt wurde.
Es wird die Software ‚dfu-programmer‘ benötigt, um den CUL zu flashen.
Jetzt kann die Firmware auf den RaspberryPi heruntergeladen werden. Stand heute ist es mit diesem Link möglich. Ich empfehle aber, die neueste Version herunterzuladen.
http://culfw.de/culfw-1.66.tar.gz
Die neueste Version kann hier nachgeschaut werden: http://culfw.de/culfw.html#Links (Source)
Dann mit ‚tar xzf‘ entpacken. In das Verzeichnis wechseln:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
~/Downloads$ ls -l insgesamt 2196 drwxrwxr-x 9 johannes johannes 4096 Apr 7 21:03 culfw-1.66 -rw-rw-r-- 1 johannes johannes 2241714 Apr 7 21:07 culfw-1.66.tar.gz ~/Downloads$ cd culfw-1.66/ ~/Downloads/culfw-1.66$ ls -l insgesamt 48 drwxrwxr-x 5 johannes johannes 4096 Sep 9 21:50 avr-uip -rw-rw-r-- 1 johannes johannes 11656 Mär 20 19:39 CHANGED drwxrwxr-x 3 johannes johannes 4096 Sep 9 21:50 clib drwxrwxr-x 23 johannes johannes 4096 Sep 9 21:50 Devices drwxrwxr-x 2 johannes johannes 4096 Sep 9 21:50 docs drwxrwxr-x 2 johannes johannes 4096 Sep 9 21:50 fonts drwxrwxr-x 4 johannes johannes 4096 Sep 9 21:50 lufa -rwxrwxr-x 1 johannes johannes 154 Mär 29 2014 README drwxrwxr-x 2 johannes johannes 4096 Sep 9 21:50 tools -rw-rw-r-- 1 johannes johannes 108 Nov 29 2015 version.h ~/Downloads/culfw-1.66$ cd Devices/CUL/ |
Der CUL muss jetzt vom Raspberry getrennt werden.
Mit gedrücktem RESET Knopf jetzt den CUL wieder an den Raspberry stecken.
Danach folgende Befehle ausführen:
|
1 2 3 |
sudo dfu-programmer atmega32u4 erase sudo dfu-programmer atmega32u4 flash CUL_V3.hex sudo dfu-programmer atmega32u4 reset |
Nachdem der CUL nochmals aus und angesteckt wurde (diesmal natürlich ohne Reset Knopf), sollte er von ‚lsusb‘ erkannt werden als
|
1 |
Bus 009 Device 003: ID 03eb:204b Atmel Corp. LUFA USB to Serial Adapter Project |
Mit ’screen‘ kann überprüft werden, ob der CUL auch funktioniert.
|
1 2 |
screen /dev/ttyACM0 V |
Das sollte die Version des CUL zurückgeben.
Um jetzt mit den Homematic Geräten kommunizieren zu können, wird Homegear benötigt.
Zum hinzufügen des Repositories:
|
1 2 3 4 5 6 7 |
cd ~/Downloads wget https://homegear.eu/packages/Release.key sudo apt-key add Release.key rm Release.key sudo echo 'deb https://homegear.eu/packages/Raspbian/ jessie/' >> /etc/apt/sources.list.d/homegear.list # ggf. muss dieser Befehl auch als root ausgefuehrt werden. sudo apt update sudo apt install homegear homegear-homematicbidocs |
Unter „https://www.homegear.eu/index.php/Downloads“ ist alles genau beschrieben. Achtung! Es gibt drei Reiter (Debian, Raspbian, Ubuntu). Ich war zu schnell und hatte es mit Debian ausprobiert und das hat natürlich nicht funktioniert. 🙂
Der letzte Schritt kann gerade auf den älteren RaspberryPis einige Zeit in Anspruch nehmen. Be patient…
Jetzt müssen wir natürlich Homegear noch sagen, über welche Schnittstelle es kommunizieren soll. Hierfür muss die Konfigurations-Datei entsprechend angepasst werden.
|
1 |
vim /etc/homegear/families/homematicbidcos.conf |
In dieser Datei gibt es einen Sektor „CUL“. Dieser muss wie folgt angepasst werden:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
####################################### ################# CUL ################# ####################################### ## The device family this interface is for [CUL] ## Specify an unique id here to identify this device in Homegear id = first-cul ## When default is set to "true" Homegear will assign this device ## to new peers. default = true ## Options: cul, cc1100, coc, cunx, hmcfglan, hmlgw, hm-mod-rpi-pcb deviceType = cul device = /dev/ttyACM0 ## Default: responseDelay = 95 ## Should be "95" for CUL or COC, "100" for TI CC1101 and "60" for HM-CFG-LAN or HM-LGW responseDelay = 95 |
Einige Konfigurationen müssen/können/sollen (:)) im „General“ Abschnitt auch noch gemacht werden:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
####################################### ########## General Settings ########## ####################################### [General] ## The BidCoS address of Homegear. It is recommended to change this to a random 3 byte hexadecimal ## value starting with 0xFD (e. g. 0xFD43AB). Only change this, when no HomeMatic BidCoS devices ## are paired to Homegear as existing pairings will not work anymore! #centralAddress = 0xFD0001 centralAddress = <youreaddresshere> ## Specify a 16 byte (32 characters) long AES key here to protect your wireless communication ## !!! IMPORTANT: It is highly recommended to change this key before pairing the first device. ## !!! IMPORTANT: Never ever lose this key. That would render your devices useless. ## To remove the key from your devices, you need to factory reset them #rfKey = 00112233445566778899AABBCCDDEEFF rfKey = <yourekeyhere!!!> ## With each key change currentRFKeyIndex needs to be ## incremented by 1 currentRfKeyIndex = 1 ## When you change rfKey, put the old key here. To change the key Homegear needs to know the ## old and the new one. ## !!! Do not set oldRFKey when you set rfKey for the first time !!! ##oldRFKey = 00112233445566778899AABBCCDDEEFF ## When set to "true" unsigned broadcast packets are processed by Homegear. This could enable an ## attacker to make Homegear do things, you don't want. That means, this option is a security ## risk. processBroadcastWithAesEnabled = false |
Bei Adresse und Key einfach schon einfallsreich sein ^^
Danach kann homegear gestartet werden:
|
1 2 |
systemctl start homegear systemctl status homegear |
Soweit so gut. Jetzt wird es spannend.
Jetzt können wir zum ersten Mal Homegear starten:
|
1 2 3 |
$ homegear -r Connected to Homegear (version 0.6.7-1480). > |
Ob Homegear die Homematic Familiy geladen hat, kann mit dem Kommando „families list“ nachgeschaut werden. So sollte es nicht ausschauen:
|
1 2 3 4 5 6 |
> families list ID │ Name ──────┼─────────────────────────────── 254 │ Miscellaneous ──────┴─────────────────────────────── > |
Ich hatte bei mir vergessen, den deviceType einzukommentieren. Naja jetzt geht es auch:
|
1 2 3 4 5 6 7 8 |
Connected to Homegear (version 0.6.7-1480). > families list ID │ Name ──────┼─────────────────────────────── 0 │ HomeMatic BidCoS 254 │ Miscellaneous ──────┴─────────────────────────────── > |
Jetzt kann die Homematic Family ausgewählt werden:
|
1 2 3 4 5 6 7 8 |
$ homegear -r Connected to Homegear (version 0.6.7-1480). > families select 0 Device family "HomeMatic BidCoS" selected. For information about the family's commands type: "help" (Family)> peers list No peers are paired to this central. (Family)> |
So sieht das Ganze aus, wenn noch keine Geräte gepaired sind.
Das Pairen werde ich im nächsten Artikel beschreiben, da mein Raspberry Pi gerade in „Wartung“ ist und ich so nicht auf ihn zugreifen kann.
Da ich alles schnell ausprobieren wollte und ich den Artikel dann drei Tage später aus dem Kopf geschrieben habe (und von meinem Desktop PC aus, aber ohne Raspberry) kann es sein, dass ich was vergessen habe. Bei Fragen helfe ich natürlich gerne.
Vor einiger Zeit hatte ich openHab bereits ausprobiert. Leider aber nur einen einfachen Baustein und ohne richtige Anwendungsmöglichkeit. Licht an, Licht aus – per Skript über die GPIOs von meinem RaspberryPi. Jetzt möchte ich dieses Projekt wieder in Angriff nehmen. Meine Installationsanleitung und die Blog Artikel waren nicht unbedingt praxisnah gestaltet.
In den nächsten Artikeln werde ich beschreiben, wie man openHab auf dem RaspberryPi installiert, Homegear für die Kommunikation mit Homematic Geräten einrichtet und die beiden Systeme zusammenführt.
Im Vordergrund stehen für mich zunächst die Steuerung eines Heizkörpers. Danach möchte ich einige Rolläden steuern und die Beleuchtung einbinden. Mal sehen, in welche Richtungen das Projekt ausgeweitet werden kann. Ich denke da an Fensterkontakte und Sonnensensoren.
Für den Anfang habe ich mir also folgende Dinge bestellt, bzw. hatte ich rumliegen:
– RaspberryPi v2
– CUL1101 v3.4 von Busware
– Homematic Heizkörper Thermostat
Das Ziel dieses Projektes soll ein Smart Home sein, dass durch openHab gesteuert wird. Allerdings möchte ich auf keine manuelle Funktion verzichten. Das bedeutet, dass alles sowohl per Hand, als auch per App/Webinterface/Automatisch gesteuert werden kann.
Die Homematic Integration möchte ich nicht per CCU oder einer anderen Homematic Centrale umsetzen. Ich hoffe, dass hierfür der CUL die komplette Kommunikation über nehmen kann. Das werde ich sehen, sobald die Teile da sind.
Mit OpenWRT wird der TP-Link Router (TL-WR1043ND) zum All-Inclusive Gerät. So wird es zum Beispiel möglich, mit VLANs zu arbeiten.
Bei mir wird mein Internetzugang durch ein Modem bereitgestellt. Mein Router steht auf einem Regal in der Mitte der 
Wohnung. Ein 10 Meter Kabel verbindet die beiden Geräte miteinander. Ich möchte nun einen Drucker in die Ecke zu dem Modem stellen und meine TV Geräte (auch auf der Seite mit dem Modem) ebenfalls in das LAN einbinden.
Um das zu realisieren habe ich diesen Switch (TL-SG105E) von TP-Link gekauft. Die Zeichnung zeigt den logischen Aufbau des Netzwerkes, wie es geplant ist.
Den TP-Link Router (TL-WR1043ND) habe ich schon länger im Einsatz und mit OpenWRT geflasht. Um nun ein VLAN einzurichten wechsle ich von der GUI (Luci) auf die Kommandozeile. Ich habe es anfangs auch per Luci probiert, allerdings hat es nie funktioniert. Nachdem ich es per Kommandozeile (genau die selbe Konfiguration) gemacht habe, hat alles funktioniert.
Hier habe ich die Datei „/etc/config/network“ editiert und folgendes hinzugefügt:
|
1 2 3 4 5 |
config interface 'lan' option ifname 'eth0.3' option proto 'static' option ipaddr '192.168.1.1' option netmask '255.255.255.0' |
‚lan‘ steht für den Interface-Namen, der bei Luci unter dem Punkt Interfaces aufgelistet wird.
‚eth0.3‘ ist das physikalische Interface, das der VLAN-ID 3 zugeordnet wurde.
Es gibt auch Router, die mehrere physikalische Interfaces besitzen. Dort müssen die VLAN Interfaces mit z.B. „eth1.3“ angelegt werden. Da mein Router nur ein Interface besitzt, muss ich darauf nicht achten.
Der Switch in dem Router (Port 0-4) muss ebenfalls konfiguriert werden. Hier müssen die VLANs entsprechen „getagged“ oder „untagged“ konfiguriert werden.
Meine Konfiguration sieht so aus:
|
1 2 3 4 5 6 7 8 9 |
config switch_vlan option device 'rtl8366rb' option vlan '3' option ports '1t 2 5t' config switch_vlan option device 'rtl8366rb' option vlan '2' option ports '0 1t 5t' |
„config switch_vlan“ stellt ein VLAN an dem Switch bereit.
„option device“ gibt das Gerät an.
„option vlan“ gibt die VLAN ID an.
„option ports“ gibt die Ports des Switches an, wobei der Port und ein „t“ dahinter (z.B. 1t) „tagged“ bedeutet.
Da für das VLAN „LAN“ (in meinem Fall) auch DHCP aktiviert werden soll, muss das in die Konfigurationsdatei „/etc/config/dhcp“ eingetragen werden:
|
1 2 3 4 5 |
config dhcp 'lan' option interface 'lan' option start '100' option limit '150' option leasetime '12h' |
Mit dieser Konfiguration werden nun aus meinem LAN IP’s aus der Range „192.168.1.100 – 192.168.1.250“ vergeben.
Danach muss noch der Netzwerk Dienst neu gestartet werden:
|
1 |
# /etc/init.d/network restart |
Den Switch kann man nur über die GUI/Software von TP-Link konfigurieren. Diese einfach auf der Webseite herunterladen. Am besten auch gleich noch die aktuellste Firmware. Wenn die Software gestartet wird, erscheint eine Übersicht aller TP-Link Easy Smart Switche. Einfach die IP-Konfiguration des Gerätes anklicken und dort die neue IP angeben. Nachdem der Hostname des Switch und das Passwort des „admin“ Users geändert wurden, kann das VLAN konfigurieren anfangen.
Die VLANs werden in dem oberen Tab-Reiter eingetragen und konfiguriert. Hier habe ich „802.1Q VLAN“ aktiviert und meine VLANs eingetragen. Die Ports habe ich entsprechend meiner Zeichnung oben konfiguriert.
Nach dem Speichern der Konfiguration konnte ich den Switch testen. Hier war es mir sehr wichtig das Testen abzuschließen, bevor ich das WAN anschließe. Ich wollte ungern eins meiner Geräte direkt ins Internet durch reichen.
Alle Tests verliefen positiv und somit konnte ich die Hardware nach der Zeichnung verkabeln. Performance ist wie zuvor. Ich habe eine 100Mbit Leitung und lade nach wie vor mit maximaler Geschwindigkeit herunter.
Nachdem ich die L293D verstanden hatte, habe ich mir eine Platine geholt und die Bauteile aufgelötet. Leider hatte ich nur drei verschiedene Farben Draht zur Verfügung. Also habe ich für Ground Weiß, für +V Braun und für alles andere Grün genommen. Sehr übersichtlich ist es nicht. Vielleicht mache ich das Ganze nochmals neu, wenn alles einmal läuft.
A
ls nächstes habe ich mir überlegt, wie ich am besten die Akkus anbringe. Diese wollte ich unbedingt auf der unteren Ebene befestigen, vor allem wegen dem Gewicht. Auch die Zugänglichkeit für den Rapberry und Co ist hier wichtiger.
Außerdem steht in der Zukunft noch an, dass ich ein Ladegerät für sechs AA-Akkus organisiere und diese dann über einen Steckmechanismus laden kann. Somit müsste ich die obere Ebene nicht jedes Mal ab- und wieder anschrauben.
Als nächstes habe ich einige Jumper Kabel abgezwickt und mit den einzelnen Kabeln der Motoren verknüpft. Zwei Jumper habe ich noch an die Enden der Batteriefächer gelötet. Auf die Platine habe ich die dementsprechend Anzahl Pins montiert. Jetzt kann ich meine Motoren sehr leicht an und ausstecken.
Zusätzlich habe ich noch einen Schalter angebracht, mit dem ich die Batteriefächer zuschalten kann. Eine rote LED mit Vorwiderstand zeigt mir an, ob die Spannung aktiv ist oder nicht.
Die Platine ist mit etwas längeren Schrauben an der oberen Ebene befestigt und der Raspberry Pi versetzt darunter (siehe Bild). Hinter oder unter erstere soll die Powerbank für den Raspberry Pi angebracht werden. Leider ist meine bisherige ein paar Millimeter zu breit. Hier muss ich mir unbedingt noch eine Lösung einfallen lassen.
Die Löcher für die Montage habe ich einfach mit einem passenden Bohrer hinzugefügt. Das Plastik hält das durchaus aus. Trotzdem ist Vorsicht besser als Nachsicht. Laufen zu viele Löcher in einer Bahn, hat man schnell eine Sollbruchstelle. Mir ist beim Verschrauben vorne Rechts der Zapfen mit dem Loch für die Verbindungsstrebe abgebrochen. Obwohl ich mit wenig Druck gearbeitet hatte. Aber mit diesem Schaden kann ich durchaus leben.
Ein wenig Code habe ich auch schon geschrieben. Zum eine die Motor Klasse, die ich benutze, um die Motoren zu steuern. Und meine „main“, in der ich eben alles andere regele. Bisher funktioniert leider nur das Testen der Motoren, für den Rest muss ich mir noch ein wenig Steuerungscode ausdenken. Ich möchte unbedingt eine GUI mit Tkinter erstellen und über diese das spätere Webcam Bild ausgeben lassen. Zudem soll auf ihr der Status der einzelnen Räder und aller zusammen angezeigt werden. Ich überlege auch, eine Socket Connection herzustellen und die Steuerungssoftware auf einem Windows PC laufen zu lassen.
Hier die Motor Klasse:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
#!/bin/python # Imports import RPi.GPIO as io from time import sleep io.setmode(io.BCM) # Steuerung eines Motors mit allen Funktionen class Motor(): # PWM Pin Nummer (Integer) global pwmPin # PWM Signal global geschwindigkeit # Geschwindigkeit in Lesbaren Zahlen global speed # In Pins Nummer (Integer) global pinInEins global pinInZwei # In Pins Stati global pinInEinsStatus global pinInZweiStatus # Konstruktor def __init__(self, pwmPin, pinInEins, pinInZwei): self.pwmPin = pwmPin self.pinInEins = pinInEins self.pinInZwei = pinInZwei self.pinInEinsStatus = False self.pinInZweiStatus = False self.setupInPins() self.setupPWM() # Pins konfigurieren # Sollte nur einmal, am Anfang, aufgerufen werden def setupInPins(self): io.setup(self.pinInEins, io.OUT) io.setup(self.pinInZwei, io.OUT) io.setup(self.pwmPin, io.OUT) self.changeInPinSignal() #PWM konfigurieren # Darf/sollte nur einmal, am Anfang aufgerufen werden def setupPWM(self): # Pulse Weite self.geschwindigkeit = io.PWM(self.pwmPin, 100) # Start des Pulses self.geschwindigkeit.start(0) # Stillstand vorgeben self.geschwindigkeitAendern(0) # Vorwaerts fahren def moveVorwaehrts(self): self.pinInEinsStatus = False self.pinInZweiStatus = True self.changeInPinSignal() # Rueckwaerts fahren def moveRueckwaerts(self): self.pinInEinsStatus = True self.pinInZweiStatus = False self.changeInPinSignal() # Bremsen; Output auf False def bremsen(self): self.pinInEinsStatus = False self.pinInZweiStatus = False self.changeInPinSignal() self.geschwindigkeitAendern(0) # Pin Signale veraendern def changeInPinSignal(self): io.output(self.pinInEins, self.pinInEinsStatus) io.output(self.pinInZwei, self.pinInZweiStatus) # Geschwindigkeit veraendern def geschwindigkeitAendern(self, speed): # pwmPin Range 0-100, Angabe fuer den Benutzer 0-9 # Multiplikator ist 11, um auf die Prozentzahl zu kommen speed = int(speed) * 11 self.geschwindigkeit.ChangeDutyCycle(speed) self.speed = speed def getGeschwindigkeit(self): return self.speed def getInPinEinsStatus(self): return self.pinInEinsStatus def getInPinZweiStatus(self): return self.pinInZweiStatus def testen(self): print("Vorwaerts:") self.moveVorwaehrts() for x in range(0, 11): if x != 10: print("Geschwindigkeit: " + str(x)) self.geschwindigkeitAendern(x) else: print("Bremsen") self.bremsen() sleep(1) self.moveRueckwaerts() for y in range(0, 11): if y != 10: print("Geschwindigkeit: " + str(y)) self.geschwindigkeitAendern(y) else: print("Bremsen") self.bremsen() sleep(1) |
Und das ist meine „main“:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
#!/bin/python # Imports import RPi.GPIO as io # Import own class from Motor import * # Abfrage nach dem naechsten Kommando def frageKommando(text): eingabe = raw_input(text) return eingabe # Kommando bearbeiten def bearbeiteKommando(kommando): action = kommando[0] # Programm beenden if action == "x": beenden() elif action == "t": # Motortest starten testeMotor() elif action == "s": # Programm starten print("Comming Soon") else: print("Ungueltiges Kommando") # Komplettes Programm beenden und cleanup durchfuehren def beenden(): print("Das Programm wird nun beendet!") io.cleanup() exit() # Motoren testen def testeMotor(): weitererTest = True while True: kommando = frageKommando("""Bitte den zu testenden Motor auswaehlen: lh = Motor links hinten rh = Motor rechts hinten lv = Motor links vorne rv = Motor rechts vorne tb = Tests beenden """) motorauswahl = kommando[0] + kommando[1] if motorauswahl == "lh": print("Motor links hinten ausgewaehlt. Tests werden druchgefuehrt.") motorLinksHinten.testen() print("Test beendet.") elif motorauswahl == "rh": print("Motor rechts hinten ausgewaehlt. Tests werden druchgefuehrt.") motorRechtsHinten.testen() print("Test beendet.") elif motorauswahl == "lv": print("Motor links vorne ausgewaehlt. Tests werden druchgefuehrt.") motorLinksVorne.testen() print("Test beendet.") elif motorauswahl == "rv": print("Motor rechts vorne ausgewaehlt. Tests werden druchgefuehrt.") motorRechtsVorne.testen() print("Test beendet.") elif motorauswahl == "tb": # Tests beenden print("Test wird beendet") weitererTest == False break else: print("Falsches Kommando.") # || MAIN || # if __name__ == '__main__': # Motoren initialisieren motorLinksVorne = Motor(23, 2, 3) motorRechtsVorne = Motor(15, 27, 22) motorLinksHinten = Motor(18, 10, 9) motorRechtsHinten = Motor(14, 4, 17) # Willkommensnachricht print("Willkommen beim Raspberry Car.") while True: # Kommando abfragen kommando = frageKommando("""Bitte waehle eine Option: t = Motortests starten s = Programm starten x = Programm beenden """) # Kommando verarbeiten bearbeiteKommando(kommando) # Cleanup io.cleanup() |
Den aktuellsten Code gibt es immer in meinem GitHub Repo:
github.com/PetzJohannes/RaspberryCar_v2
Hier noch zwei Bilder vom Aufbau:
