ich hatte in einem anderen Thread (mal so nebenbei) erwähnt, daß ich meine LCN-Anlage mit einem Python-Progrämmchen "dokumentiere" (siehe "www.python.org"
). Nicht falsch verstehen: Ich greife mit dem Programm nicht auf den Bus zu, sondern ersetze durch das Programm meine nicht mehr verständlichen Excel-Sheets! Dieses Progrämmchen möchte ich hier mal kurz vorstellen.In meinem Programm erzeug ich zunächst Objekte der Typen Ausgang, Relais, BinSensor oder Summe und weise sie sprechenden Variablen-Namen zu. Diese Typen (Ausgang, Relais, BinSensor und Summe) hab ich natürlich vorher im Programm als eine sogenannte Klasse definiert von denen ich nun beliebig viele Objekte erzeugen kann. Folgender Auszug aus meinem Python-Quellcode zeigt wie ich diese Objekte erzeuge (Kommentare beginnen mit einem "#"):
# -------------------
# Ausgänge für Lampen
# -------------------
Lampe_EG_Kueche_Schrank = Ausgang(True , 21)
Lampe_EG_Kueche_Decke = Ausgang(True , 21)
Lampe_EG_Kueche_Tisch = Ausgang(True , 21)
Lampe_EG_Treppenhaus_Wand = Ausgang(True , 22)
Lampe_EG_Treppenhaus_Ufos = Ausgang(True , 22)
Lampe_EG_Treppenhaus_Strahler = Ausgang(True , 22)
...
# "True" bedeutet, daß die Statuskommandos der Ausgänge
# eingeschaltet werden sollen.
# Die Zahlen an zweiter Stelle (21, 22) definieren eine
# Gruppen-ID. Diese IDs werden zum Aufrufen von Lichtszenen
# verwendet.
# ------------------------------------------------
# Virtuelle Relais zum Einschalten von Lichtszenen
# ------------------------------------------------
LS_EG_Kueche_1 = Relais(True) # Essen machen
LS_EG_Kueche_2 = Relais(True) # Essen
LS_EG_Kueche_3 = Relais(True) # Aufräumen
LS_EG_Kueche_4 = Relais(True) # Party
LS_EG_Wohnen_1 = Relais(True) # Lesen
LS_EG_Wohnen_2 = Relais(True) # Fernsehen
LS_EG_Wohnen_3 = Relais(True) # Essen
LS_EG_Wohnen_4 = Relais(True) # Kino
LS_EG_Wohnen_5 = Relais(True) # Kartenspielen
LS_EG_Wohnen_6 = Relais(True) # Party
...
# "True" bedeutet auch hier, daß die Statuskommandos der
# (hier: virtuellen) Relais benötigt werden. "False" würde
# bedeuten, daß Statuskommandos nicht benötigt werden.
# ---------------
# Bewegungsmelder
# ---------------
BW_EG_Kueche = BinSensor()
BW_EG_Treppenhaus = BinSensor()
BW_EG_WC = BinSensor()
...
# -----------------------------
# Summen zum Zentralstaubsauger
# -----------------------------
Staubsauger_EG = Summe(Staubsauger_EG_Kueche |
Staubsauger_EG_WF |
Staubsauger_EG_Wohnzimmer)
Staubsauger_DG = Summe(Staubsauger_DG_Treppe |
Staubsauger_DG_Anziehkammer)
Staubsauger_Angefordert = Summe(Staubsauger_EG |
Staubsauger_DG |
Staubsauger_Garage)
Staubsauger_Ein = Summe(Staubsauger_Angefordert &
Alarm_OK &
Panik_OK &
~TK_Anlage_Relais_Anruf &
~Haustuerklingel_aktiv)
# "|" stellt eine ODER- und "&" eine UND-Verknüpfung dar.
# "~" bedeutet, daß die eingehende Bedingung negiert werden soll.
#
# Zum Verständnis dieser 4 Verknüpfungen: Bei den Objekten
# "Staubsauger_xG_..." handelt es sich um Binärsensoren in den
# Saugdosen. Bei "Alarm_OK" und "Panik_OK" handelt es sich
# um Summen, die bei einem Alarm oder beim Betätigen eines Panik-
# schalters jeweils als Ergebnis "False" liefern.
# "TK_Anlage_Relais_Anruf" wurde als Binärsensor definiert, der
# von der TK-Anlage bei einem Anruf eingeschaltet wird. Bei
# "Haustuerklingel_aktiv" handelt es sich um ein virtuelles Relais,
# daß durch den Haustürklingeltaster gesetzt und nach 45 Sekunden
# oder dem Bewegunsmelder im Flurbereich zurückgesetzt wird
.# Ist die Summe "Staubsauger_Ein" nun erfüllt, wird der
# Zentralstaubsauger eingeschaltet und ist sie nicht erfüllt,
# wird er ausgeschaltet.
Wenn ich nun alle Objekte auf diese Weise definiert hab, weise ich sie irgendwelchen Modulen zu. Dazu benutze ich folgenden Befehl (Beispiel aus meinem Quellcode):
EG_Garage_Verteilung = Modul(n_ModulID = 28,
o_Ausgang_1 = Lampe_EG_WC,
o_Ausgang_2 = Lampe_EG_Aussen_Haustuer,
o_Relais_1 = Staubsauger_Schalter,
o_Relais_2 = Staubsauger_Spannung,
o_Relais_3 = AS_Garage_1,
o_Relais_4 = AS_Garage_2,
o_Relais_5 = AS_Garage_3,
o_Relais_6 = Li_EG_Garage_1,
o_Relais_7 = Li_EG_Garage_2,
o_Relais_8 = Li_EG_Garage_3,
o_BinSensor_1 = Staubsauger_Garage,
o_BinSensor_2 = Tuerschloss_Garage,
o_BinSensor_3 = FK_Garage_1,
o_BinSensor_4 = FK_Garage_2,
o_BinSensor_5 = Funk_Garagentor,
o_BinSensor_6 = Funk_Haustuer,
o_BinSensor_7 = Funk_Alarmanlage,
o_BinSensor_8 = Funk_Wasser,
o_Summe_1 = Alarm_OK,
o_Summe_2 = Panik_OK,
o_Summe_3 = Staubsauger_Angefordert,
o_Summe_4 = Staubsauger_Ein)
Tritt beim Zuweisen der Ausgänge, Relais, Binärsensoren oder Summen zum Modul ein Fehler auf (z.B. Überlappung der Statuskommandos oder die 12 Lämpchen im Modul reichen für die Summen nicht aus), so bricht das Python-Programm mit einer Fehlermeldung ab
.Wenn ich nun alle Ausgänge, Relais, Binärsensoren, Summen und Module definiert hab, ist meine Doku eigentlich komplett. Ich weiß nun genau wie meine Module belegt sind (Doppelbelegungen sind dabei ausgeschlossen). Falls etwas noch mehr Kommentierung benötigt, füge ich einfach noch weitere Kommentare ("#") in meinen Python-Code ein
.Als nächsten Schritt checke ich im Code, ob Ausgänge, Relais, Binärsensoren oder Summen noch keinem Modul oder doppelt zugeordnet sind. Wenn ja, bricht das Programm ebenfalls ab!
Als letzten Schritt erzeuge ich für jedes Modul eine Bildschirm-Ausgabe, die mir genau zeigt welche Eigenschaften ich für das Modul einstellen muß, welche Lämpchen ich wie definieren und wie ich sie den Summen zuordnen muß. Beispiel-Ausgabe eines Moduls mit der ID 28:
Modul: 28
Gruppen: [123, 204]
Statusk. Ausgänge: ["EIN", "AUS"]
Statusk. Relais: ["AUS", "AUS"]
Piepen: AUS
Summe C1: kurz = EIN / lang = AUS / los = AUS
Summe C2: kurz = EIN / lang = AUS / los = AUS
Summe C3: kurz = EIN / lang = EIN / los = AUS
Summe C4: kurz = EIN / lang = AUS / los = AUS
Lämpchen 1: 25 [Summe 2: AUS, EIN, AUS]
Lämpchen 2: 25 [Summe 3: AUS, EIN, EIN]
Lämpchen 3: 25 [Relais 6: AUS, EIN, -]
Lämpchen 4: 25 [Relais 7: AUS, EIN, -]
Lämpchen 5: 25 [Relais 8: AUS, EIN, -]
Lämpchen 6: 166 [Summe 2: EIN, AUS, EIN]
Lämpchen 7: 107 [Summe 3: EIN, AUS, EIN]
Lämpchen 8: 28 [Binärsensor 1: EIN, AUS, -]
Lämpchen 9: 28 [Summe 3: EIN, AUS, EIN]
Lämpchen 10: 35 [Binärsensor 1: AUS, EIN, -]
Lämpchen 11: 154 [Relais 6: AUS, EIN, -]
Summe 1: EIN = 1, 2
Summe 2: EIN = 3, 4, 5
Summe 3: EIN = 6, 7, 8
Summe 4: EIN = 1, 2, 3, 4, 5, 9, 10, 11
"Summe C1-C4" zeigt welche Tasten gedrückt werden, wenn die Bedingung erfüllt ist ("EIN") oder nicht erfüllt ist ("AUS").
"Lämpchen 1-12" zeigt die Lämpchen-Einstellungen.
"Summe 1-4" definiert die Lämpchen, die für die jeweilige Summe auf "EIN" geprüft werden sollen.
Nun bin ich hergegangen und hab diese Einstellungen in meine ganzen LCN-Module (manuell natürlich) übertragen. Mit Excel-Sheets hätte ich das nie so komfortabel und fehlerfrei bewältigen können
.Ich hoffe, daß meine Ausführungen einigermaßen verständlich waren. Wenn nicht, einfach nochmal nachfragen! Falls jemand Python installiert hat und Interesse an meinem kleinen Progrämmchen (ca. 2300 Zeilen Code) hat, möge sich melden, dann könnte ich es per Mail verschicken.
Gruß, Bernd || der Kommentare in den LCN-Modulen nicht (mehr) benötigt
