Willkommen auf unserer neuen Forenplattform für das Bus-Profi Forum

Neue Felder für die persönlichen Daten
Man kann jetzt seine öffentlich einsehbare Daten genau bestimmen. Details findet ihr in in diesem Beitrag.

Durch die neue Forensoftware und die Portierung der Daten konnten die Passwörter aus dem alten Forum nicht übernommen werden, bitte lassen Sie sich ein neues Passwort über die Passwort vergessen Funktion zusenden. Sollte es zu Problemen kommen kontaktieren Sie das Bus-Profi Team per E-Mail.

Dokumentieren mit Python


Themenersteller
BerndR
Fleißiges Mitglied
Fleißiges Mitglied
Beiträge: 383
Registriert: Mo 14. Feb 2005, 07:46
Kontaktdaten:

#1 Dokumentieren mit Python

Beitragvon BerndR » Mi 10. Mai 2006, 21:51

Hi @ all,

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 ;-)

Benutzeravatar

MartinH
Lord Forum
Lord Forum
Beiträge: 1511
Registriert: Di 11. Mai 2004, 16:39
Hat sich bedankt: 4 Mal
Kontaktdaten:

#2 RE: Dokumentieren mit Python

Beitragvon MartinH » Do 11. Mai 2006, 01:09

Bernd, vielen Dank für dieses "Posting des Monats" !

Auch wenn ich noch nicht alles verstanden habe, gefällt mir der Ansatz gut.

So etwa habe ich es verstanden:
Anscheinend hast Du in Deinen Python-Program all die Abhängigkeiten (Überprüfungen) hineinprogrammiert, die die Ausgänge, Relais, Binärsensoren oder Summen usw. haben - zumindest so wie sie heute in den LCN-Modulen sind.
Wenn man also die Objekte richtig "dokumentiert" hat und passend den gewünschten Modulen zugeordnet hat, meldet Dein Prüf-Programm keine Widersprüche/Fehler, sondern spuckt sogar die nötigen LCN-Modul-Einstellungen aus.
[zitat]diese Einstellungen in meine ganzen LCN-Module (manuell natürlich) übertragen[/zitat]
Ich denke, Deine Software brauchte eigentlich nur noch die entsprechenden LCN-Programmierbefehle zu kennen und dann könnte diese Programmierung der LCN-Module auch direkt (automatisch natürlich) von Deiner Software übernommen werden.
[hr]
Wenn ich das insgesamt so betrachte, ist das doch ein LCN-Logik-Compiler (!)
Der nimmt die "Dokumentation" (das ist quasi gleichzeitig eine neue "LCN-Logik-Programmiersprache")
und überprüft diese auf syntaktische und semantische Fehler.
Weitere Randbedingungen werden in der Modulzuordnung (welcher Ausgang, welches Relais,..) festgelegt.
Daraus generiert der LCN-Logik-Compiler konkreten LCN-Modul-Code, der nur noch in die Module zu transferiert werden braucht.
Genau diese Art der Programmierung wünscht man sich doch als Informatiker (!)
Schreibe einfach nur "LCN-Dokumentation" und der Compiler wird daraus schon einen lauffähigen "LCN-Code" machen.
Der Compiler kennt alle Abhängigkeiten der verwendeten Hardware und macht das beste raus, wenn es geht - sonst ERROR. (ERROR könnte auch heissen: "Sie müssen noch 1 HU und 3 UPS oder 1 LCN-L Modul kaufen, damit die gewünschte Logik laufen kann.")

Gruss, Martin || werden wir in Zukunft LCN-Pro vergessen können und den LCN-Compiler einsetzen ???


Themenersteller
BerndR
Fleißiges Mitglied
Fleißiges Mitglied
Beiträge: 383
Registriert: Mo 14. Feb 2005, 07:46
Kontaktdaten:

#3 RE: Dokumentieren mit Python

Beitragvon BerndR » Do 11. Mai 2006, 07:28

Jau Martin,

die Logik entspricht dem heutigen Stand der Module. Einschränkungen älterer Module hab ich nicht implementiert, wäre aber auch nicht so schwer mit einzubauen ...

Ich hatte schon überlegt das Programm so zu ändern, daß mir Python die virtuellen Relais und Summen automatisch auf die Module verteilt. Dies hatte ich aber wieder verworfen, da 1. der Algorithmus recht komplex werden würde (da hab ich nicht wirklich Zeit für) und 2. ich doch noch etwas Einfluss auf die Verteilung haben möchte :-) .

Die Werte automatisch in die Module zu transferieren wäre natürlich super. Es fehlen bei meinem Ansatz allerdings die Aktionen (Tasten), die bei Erfüllung einer Summe ausgeführt werden. Dieses füge ich z.Z. in den Quell-Code nur als Kommentar ein (nicht immer aber immer öfter).

Wünschenswert wäre es eine ähnliche Funktionalität mit in die LCN-Pro zu integrieren. Auf den heutigen PCs fuchtelt ja auch (fast) niemand mehr mit Bits herum, da es genug Compiler auf"m Markt gibt ... obwohl es eigentlich Spaß macht :-) :-) :-) :-) .

Gruß, Bernd.

Benutzeravatar

Uwe
...
Beiträge: 14246
Registriert: So 26. Mai 2002, 23:10
Hat sich bedankt: 13 Mal
Danksagung erhalten: 56 Mal
Kontaktdaten:

#4 RE: Dokumentieren mit Python

Beitragvon Uwe » Sa 13. Mai 2006, 01:35

[zitat]Genau diese Art der Programmierung wünscht man sich doch als Informatiker [/zitat]
auf lcn.de heißt es:
[zitat]Vorteile des LCN:
Einfach vom Elektroinstallateur zu warten / kein teurer Spezialist erforderlich: geringe Betriebskosten [/zitat]

Ich lasse mir da gerne von euch helfen - aber: mach es selbst, dann weißt du was du hast ;-)

Die englischsprachige Downloadseite schreckt mich jetzt (ein wenig :( ) ab.
Kriege ich das als Hobby-Informatiker auch so hin wie ihr eure Hobby-Elektroinstallation (?)

... und Spaß dabei ;-)
Uwe
----------------o00o----'(_)'----o00o---------------------

Benutzeravatar

MartinH
Lord Forum
Lord Forum
Beiträge: 1511
Registriert: Di 11. Mai 2004, 16:39
Hat sich bedankt: 4 Mal
Kontaktdaten:

#5 RE: Dokumentieren mit Python

Beitragvon MartinH » Sa 13. Mai 2006, 14:50

[zitat]Genau diese Art der Programmierung wünscht man sich doch als Informatiker [/zitat]
muss ich wohl noch etwas klarer stellen:
Die Puristen unter den Informatikern würde vielleicht in einer einfachen ASCII-Datei die gewünschte LCN-Logik in Prolog beschreiben. Und dann generiert der Logik-Compiler daraus ausführbare LCN-Programme (= ladbare LCN-Projekte).
[hr]
Ich würde dann gerne noch "einen" Schritt weitergehen und dem Benutzer (LCN-Installateur, LCN-Planer oder dem LCN-Do-It-Yourself [Wo]Man) eine graphische Oberfläche anbieten, in der er die gewünschte Haus-Logik aufmalt (= dokumentiert). Das grafische Editorprogramm erstellt dazu immer passend eine interne Logik-Beschreibung und prüft gleichzeitig (oder auf Knopfdruck), ob eine vorhandene LCN-Hardware-Umgebung (Module, Bauteile, Taster, ... Verdrahtung) die gewünschte Logik umsetzen kann. Falls nicht, gibt es eine Liste, welche Bausteine noch fehlen und/oder wie die Verdrahtung geändert werden müsste, damit "es geht".
Dann brauchte der Anwender sich nicht mehr mit LCN-Internas wie Tastentabellen, Mehrfachbelegungen, virtuellen Relais, usw. herumschlagen, sondern nur noch in seiner Begriffswelt (Taster, Rolladen, Leuchte, ...) zu denken. Den Rest übernimmt der Grafik-Logik-Compiler.
Naja, wie so eine graphische Logik aussehen müsste, dazu habe ich allerdings auch keine konkreten Ideen. ;-)
[hr]
Aber erst mit einem "graphischen Editor" hätte man wieder einen Ersatz für LCN-Pro erreicht, dem man jedem Anwender zumuten kann. Der Weg zurück aus einer LCN-Programmierung wieder eine vollständige LCN-Dokumentation zu generieren, wäre wohl nicht möglich (es sei denn die komplette Dokumentation wird als "Source-Code" mit im Modul abgelegt).
Also hier noch mal meine angepasste Aussage:
[zitat]Der [Graphik-Editor] nimmt die "Dokumentation" .. und überprüft diese auf .. Fehler. Weitere Randbedingungen werden in der Modulzuordnung (welcher Ausgang, welches Relais, [welche Verdrahtung], ..) festgelegt. Daraus generiert der LCN-Logik-Compiler konkreten LCN-Modul-Code, der nur noch in die Module .. transferiert wird.
Genau diese Art der Programmierung wünscht man sich doch als Informatiker [/zitat]

Insofern, kann die hier vorgestellte "Dokumentation in Python" nur ein Zwischenschritt sein.
Bernd, vielen Dank für die Initiative! (Ich komme auf Dich zu ..)

Gruss, Martin || der immer noch träumt


Themenersteller
BerndR
Fleißiges Mitglied
Fleißiges Mitglied
Beiträge: 383
Registriert: Mo 14. Feb 2005, 07:46
Kontaktdaten:

#6 RE: Dokumentieren mit Python

Beitragvon BerndR » Sa 13. Mai 2006, 14:52

Hi Uwe,

die einen machen Elektrik und die anderen programmieren :-) . Ich versuche beides ... hat bisher auch ganz gut geklappt.

Stimmt, daß LCN im Prinzip einfach durch einen Elektroinstallateur zu warten ist. Ich als Informatiker will mehr :) :) :) :) :) ! Wenn ich BUS höre denke ich an viele Nette Spielereien die man damit anstellen kann. So wie ich meine LCN-Anlage zuhause "vergewaltige" könnte es kein Elektroinstallateur der Welt machen, da ich ihn für seine aufgebrachte Zeit nicht bezahlen könnte :-( .

Ich glaub ein Elektriker auf der Baustelle hat nur die Möglichkeit einfache Dinge zu parametrieren (Rolladen hoch/runter, Licht ein/aus, ... und ein paar kleinere Spielereien). Alles andere würde zu teuer werden, da zuviel Zeit bei draufgehen würde ... Als privater Bauherr hat man viel mehr Zeit und Muse dafür seine Anlage zu perfektionieren!

Falls du Python ausprobieren willst, solltest du schon einige Basis-Kenntnisse des Programmierens mitbringen (eine FOR-Schleife sollte dir nicht ganz unbekannt sein ;-) ) Ähnlich verhält es sich mit jemanden der eine Elektro-Installation durchführen möchte - da sollte man sogar schon mehr mitbringen als Basiskenntnisse :( !. Aber: Python ist recht einfach zu erlernen und macht Spassssssss - wenn man Spasssss am Programmieren hat.
Mein Traum wäre es, wenn es eine LCN-Zugriffsbibliothek (geschrieben z.B. in C++) auf dem PC geben würde. Dann würde ich diese in Python einbinden und die komplette Haus-Logik darin abbilden. Man hat mit einer "richtigen" Programmier-Sprache einfach mehr Möglichkeiten, als mit vorgefertigtem Programm-Code dessen Verhalten man nur durch eine Konfiguration anpassen kann. So geschieht es ja auch bei LCN: Die Konfiguration wird mit der PRO erstellt und dann in die Module hochgeladen ...

Grüße, Bernd.

P.S.: Die richtige Python-Download-Seite heißt übrigens "python.org" ohne "www" am Anfang ;-) . Der obige Link funzt dehalb nicht.


Themenersteller
BerndR
Fleißiges Mitglied
Fleißiges Mitglied
Beiträge: 383
Registriert: Mo 14. Feb 2005, 07:46
Kontaktdaten:

#7 RE: Dokumentieren mit Python

Beitragvon BerndR » Sa 13. Mai 2006, 15:08

Ich hab noch einen:

Für wen wurde LCN eigentlich enwickelt? Für den Elektro-Installateur? Für den Bauherren? Für irgendwelche dahergelaufenen Informatiker, die glauben LCN einsetzen zu müssen? Ich glaub die Zielgruppe für LCN sollte jederman sein! Jeder hat aber andere Anforderungen an einen Installations-Bus :) :) :) !

Elektriker wollens einfach (mit Konfigurationen und vorgefertigtem Kram und wenig Installationsaufwand) ... Informatiker möglichst umfangreich (mit Programmiersprachen und so :O :O :O ) ... Bauherren möglichst günstig (mit ohne viel Kohle ... :-O :-O :-O ) ...

Ich bin Informatiker und versuche daher mit meinen Möglichkeiten viel aus LCN herauszuholen (z.Z. klemmt es gerade wieder ein wenig, da ich noch eine Summe unterbringen muß und mir mein Python-Programm jedesmal erzählt, daß ich zuviele Lämpchen in dem jeweiligen Modul verbrauche - kann ich da nich noch irgendwie "n externes Lämpchen anklemmen ;-) ???) ...

Grüße vom Python-Freund und Informatiker, der auch Elektrik kann :-),
Bernd.

Benutzeravatar

Thomas.Einzel
Lord Forum
Lord Forum
Beiträge: 1159
Registriert: Do 30. Mai 2002, 07:59
Hat sich bedankt: 2 Mal
Danksagung erhalten: 10 Mal

#8 RE: Dokumentieren mit Python

Beitragvon Thomas.Einzel » Sa 13. Mai 2006, 17:24

nur mal so als Frage: kennt ihr LCL?

die LCN Macrosprache gibt es bereits länger...

Thomas


Themenersteller
BerndR
Fleißiges Mitglied
Fleißiges Mitglied
Beiträge: 383
Registriert: Mo 14. Feb 2005, 07:46
Kontaktdaten:

#9 RE: Dokumentieren mit Python

Beitragvon BerndR » Sa 13. Mai 2006, 18:21

Ich hab schonmal gehört von LCL, weiß aber nicht so genau wie/wo man das benutzen kann und was man dazu benötigt !?!?!?! Wo findet man Infos darüber?

Bernd.

Benutzeravatar

Uwe
...
Beiträge: 14246
Registriert: So 26. Mai 2002, 23:10
Hat sich bedankt: 13 Mal
Danksagung erhalten: 56 Mal
Kontaktdaten:

#10 RE: Dokumentieren mit Python

Beitragvon Uwe » Sa 13. Mai 2006, 18:30

Nur auf Anfrage bei Fa. Issendorff ...

:-O
----------------o00o----'(_)'----o00o---------------------


Zurück zu „Eigenproduktionen SW“

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 6 Gäste