addition: Logik weiter verfeinern

Der 1. Baustein läuft, aber es ist noch nicht sehr hübsch. Wie kann man das jetzt verbessern? Einmal, in dem man versteht, wie man eigene Funktionen in Python definiert. Nach dem wir verstanden habe, was Funktionen sind, können wir auch eigene Funktionen anlegen und rufen diese Funktion einfach auf, sobald wir sie brauchen. Das sieht dann so aus:

Im Grunde die gleiche Logik wie vorher, nur dass wir die einzelnen Pfade je if/elif in einer Funktion zusammen fassen/definieren und diese Funktion dann aufrufen.
Wichtig ist dabei die Einrückung der Definition der Funktion, sie muss auf der gleichen Einrückung wie die Funktionen darüber definiert werden und die Funktion muss in der Instanz self definiert werden. Damit sie Zugriff auf die self Variablen darunter hat.
Der Aufruf der Funktion muss dann in der Einrückung der if Bedingungen darüber erfolgen, damit die Funktion an der richtigen Stelle/Reihenfolge erfolgen kann.


    Summe = 0

    def on_init(self):
        self.REM_VALUE_1 = 0.0
        self.REM_VALUE_2 = 0.0
        self.REM_VALUE_3 = 0.0
        self.REM_VALUE_4 = 0.0

    def on_input_value(self, index, value):
        if index == 1:
            self.REM_VALUE_1 = value
        elif index == 2:
            self.REM_VALUE_2 = value
        elif index == 3:
            self.REM_VALUE_3 = value
        elif index == 4:
            self.REM_VALUE_4 = value

        self.rechnen_funktion()

    def rechnen_funktion(self):
        Summe = self.REM_VALUE_1 + self.REM_VALUE_2 + self.REM_VALUE_3 + self.REM_VALUE_4
        self._set_output_value(self.PIN_O_ERGEBNIS, Summe)

Addition mit leben füllen und im HS rechnen

Der Generator hat jetzt das Grundgerüst erstellt und wie in der Hilfe zu lesen ist, muss man jetzt „nur“ noch seinen Python Code im Verzeichnis „src“ einfügen:
„Anfänglich wird der Generator einmal aufgerufen, um die o.g. Dateien zu generieren. Nachdem der Entwickler seinen eigenen Python-Code im Script im Verzeichnis src eingefügt hat, kann der Generator erneut, und zwar beliebig oft, aufgerufen werden. Er generiert dann die „.hsl“- und „.py“-Dateien in den Verzeichnissen release und debug erneut unter Berücksichtigung der zwischenzeitlich durchgeführten Modifikationen (Python-Code Injektion).
Außerdem wird auch der generierte Teil der „.py“-Dateien im Verzeichnis src neu erstellt.“

Das Ziel ist jetzt, den Baustein in den Homeserver zu bekommen und anschließend mit ihm zu rechnen und anders als der Homeserver eigene Baustein, mit mehr als nur 2 Zahlen.

Ihr merkt evtl. schon, dass zwischen diesem Beitrag und den vorherigen Beiträgen etwas Zeit vergangen ist. Dies hatte den Grund, dass ich einfach nicht weiter gekommen bin. Egal wie viele Beispiele ich mir angeschaut habe, nie habe ich kapiert was dort gemacht wurde. Also habe ich etwas herum geraten und es kam immer der Tipp „Lerne Python!“. Da soll nochmal einer sagen, nur Elektriker sind überhebliche Ar…er, das können Programmierer auch sein. Aber sie hatten recht! Also äh alle! 🙂

Also habe ich mir die 24 Videos von hier angeschaut und bei Video 23 bekam ich eine Ahnung und bei Video 24 und etwas Übungen (2-3 Tage) hat es endlich klick gemacht! Besonders wichtig ist Video 23/24, in welchem die Funktionen und Referenzen erklärt werden.

Dadurch wird folgendes klar:
JA WIE ZUM HIMMEL KOMMEN JETZT DIE WERTE IN UND AUS DEM SCH… BAUSTEIN?

Ich habe unzählige Versuche gebraucht, damit mein Baustein so aussah, die Erklärungen dazu findet ihr als Kommentare:

# coding: utf-8
##!!!!##################################################################################################
#### Own written code can be placed above this commentblock . Do not change or delete commentblock! ####
########################################################################################################
##** Code created by generator - DO NOT CHANGE! **##

class AdditionsUEbung19111(hsl20_4.BaseModule):

    def __init__(self, homeserver_context):
        hsl20_4.BaseModule.__init__(self, homeserver_context, "addition")
        self.FRAMEWORK = self._get_framework()
        self.LOGGER = self._get_logger(hsl20_4.LOGGING_NONE,())
        self.PIN_I_INPUT_A=1
        self.PIN_I_INPUT_B=2
        self.PIN_I_INPUT_C=3
        self.PIN_I_INPUT_D=4
        self.PIN_O_ERGEBNIS=1
        self.REM_VALUE_1=1
        self.REM_VALUE_2=2
        self.REM_VALUE_3=3
        self.REM_VALUE_4=4

########################################################################################################
#### Own written code can be placed after this commentblock . Do not change or delete commentblock! ####
###################################################################################################!!!##

## setzt die Variable "Summe" auf den Inhalt 0
    Summe = 0

## Setzt die remanenten Variablen alle auf 0. Ihr könnt das auch weg lassen, dann merkt sich der Baustein bei jedem
## booten den zuletzt empfangen Wert.
    def on_init(self):
        self.REM_VALUE_1 = 0.0
        self.REM_VALUE_2 = 0.0
        self.REM_VALUE_3 = 0.0
        self.REM_VALUE_4 = 0.0

## Jetzt kommt der eigentliche Teil.  Bzw das Programm. Da Gira/Dacom uns das Framework zur Verfügung stellt
## sind die Eingänge und Ausgänge selbst Funktionen, diese werden oben in hsl20_4.BaseModule definiert.
    def on_input_value(self, index, value):
## Diese Zeile bedeutet, wenn der index 1 etwas empfängt, dann setze die Variable 1 auf den Wert (value) des
## Eingang 1 und dann rechne 1+2+3+4 und schreibe das in die eigene Funktion auf den Ausgangs Pin 1, hier Ergebnis.
        if index == 1:
            self.REM_VALUE_1 = value
            Summe = self.REM_VALUE_1 + self.REM_VALUE_2 + self.REM_VALUE_3 + self.REM_VALUE_4
            self._set_output_value(self.PIN_O_ERGEBNIS, Summe)
## Diese Zeile bedeutet, wenn der index 2 etwas empfängt, dann setze die Variable 2 auf den Wert (value) des
## Eingang 2 und dann rechne 1+2+3+4 und schreibe das in die eigene Funktion auf den Ausgangs Pin 1, hier Ergebnis.
        elif index == 2:
            self.REM_VALUE_2 = value
            Summe = self.REM_VALUE_1 + self.REM_VALUE_2 + self.REM_VALUE_3 + self.REM_VALUE_4
            self._set_output_value(self.PIN_O_ERGEBNIS, Summe)
        elif index == 3:
            self.REM_VALUE_3 = value
            Summe = self.REM_VALUE_1 + self.REM_VALUE_2 + self.REM_VALUE_3 + self.REM_VALUE_4
            self._set_output_value(self.PIN_O_ERGEBNIS, Summe)
        elif index == 4:
            self.REM_VALUE_4 = value
            Summe = self.REM_VALUE_1 + self.REM_VALUE_2 + self.REM_VALUE_3 + self.REM_VALUE_4
            self._set_output_value(self.PIN_O_ERGEBNIS, Summe)

Mit dem Generator eine leere hülle erstellen – rechnen mit Python

Um sich die Arbeit etwas zu erleichtern, erstellt der Generator ein Grundgerüst für den Logikbaustein.

Die Hilfe findet ihr unter: „/Entwicklung/Logikbausteine/Schnittstelleninformationen/HSL/HSL SDK 2.0.7/doc_extra/de/gen_xml.html“

Damit der Generator arbeiten kann, erstellt ihr eine XM-Definitionsdatei an. diese muss folgende Grundlagen enthalten:

Die XML-Definitionsdatei legt die grundlegenden Eigenschaften von HSL-2.0 Logikbausteinen fest:

  • Name, ID, Kategorie (zur Verwaltung im Experten und zur Anzeige im GLE)
  • Kontext
  • Anzahl, Bezeichnungen und Typen von Ein- und Ausgängen
  • Anzahl und Bezeichnungen von remanenten Variablen
  • Framework- und Standardmodule, die importiert werden müssen
  • Art des Logging

Ich versuche für mich klein anzufangen und ein XML zu erstellen, welches einen Logikbaustein zum rechnen erstellt. Dafür habe ich mir folgende xml Config erstellt:

<?xml version="1.0" encoding="UTF-8"?>
<config>
   <modules>
     <module category="pythonlesson" context="addition" id="19111" name="Additions Übung" version="v1.0">
       <inputs>
        <input type="number" const_name="input_a" init_value="0">I1</input>
         <input type="number" const_name="input_b" init_value="0">I2</input>
       </inputs>
       <outputs>
         <output type="number" const_name="Ergebnis" init_value="0">O</output>
       </outputs>
       </module>
    </modules>
</config>

Diesen Text erstellt ihr in einer datei „config.xml“ und legt diesen unter „../framework/projects/<Name eures Projekts>“ ab. Geht via Windows CMD in das Verzeichnis des Generators und ruft diesen mit folgendem Befehl auf „python generator.pyc addition utf-8“, wobei addition für den Namen eures Bausteines steht. Danach erstellt der Generator automatisch das Projekt Verzeichnis für den Baustein:

Gira HSL 2.0 Logikbaustein Generator

Gira hilft einem beim entwickeln von Logikbausteinen. Da ich ungern in der Vergangenheit leben möchte, beziehe ich mich hier auf HLS 2.0 und höher. Höher vermute ich, da Python 2.7 Anfang 2021 auch langsam die angedachte Lebensdauer überschreitet und damit ausläuft.

Zitat. „Ende zu: Wie 2015 angekündigt, endet der Support für Python 2 am 31. Dezember 2019.“

Quelle: https://m.heise.de/developer/artikel/Die-Tage-sind-gezaehlt-End-of-Life-fuer-Python-2-4427023.html?seite=all

Zuerst findet man Infos dazu hier: https://partner.gira.de/service/software-tools/developer.html

Dort ladet ihr euch die „Schnittstelleninformationen“ herunter und entpackt sie.

Danach sieht das ganze so aus:

Dort könnt ihr jetzt fleißig in der readme lesen oder gleich ins Verzeichnis Schnittstelleninformationen\HSL\HSL2 SDK 2.0.7\framework navigieren.

Dort befindet sich der Logikbausteingenerator „generator.py“. Wie ihr aus der Hilfe entnommen habt legt ihr im Verzeichnis „projects“ dann ein Verzeichnis für euren Logikbaustein an. Anschließend erstellt ihr eine Datei in diesem Verzeichnis mit den Namen „config.xml“ und füllt diese mit Code.

schnell und schmutzig, neues Video online!

Guten Morgen,

die LnB 2018 kündigt sich ja langsam und und damit auch jede menge neuer Produkte. Die ersten Produkte kann man auch schon kaufen und GVS hat neue Tastsensoren mit Temperatursensor, RGB LEDs, jede Menge Logik und passend für 55er Schalterprogramme in reinweiß glänzend und matt. Einen ersten Eindruck und das Auspacken könnt ihr euch hier verschaffen:

Ein ausführliches Video folgt natürlich noch!

Gruß

Roman

Neues Jahr, neuer Stammtisch… neues Vor.. ach auch schon egal

Willkommen in 2018 und auf meinem Blog!

Irgendwie habe ich den armen Kerl mal wieder vernachlässigt, also schreibe ich doch wieder etwas.

KNX Stammtisch in Nürnberg:
Am 26.01.2018 ist in Nürnberg wieder ein KNX Stammtisch vom KNX-User-Forum aus.

Am 26.01.2018 im Gasthaus Max, Rollnerstraße 99 in Nürnberg. Ich muss bis 16.01.2018 mitteilen, wie viele Leute ca. kommen, also könnt ihr euch hier gerne ab und anmelden: KNX-User-Forum

Gruß

Roman

1. KNX Twiddlers Video online

Einen schönen 1. Mai zusammen,

puh, ist das echt schon wieder so lange her mit dem Update? Schaut so aus! 🙂

Aktuell habe ich die „schöne-teure Taster Wand“ etwas umgebaut, Basalte hat im Showroom Einzug erhalten, muss aber noch parametriert werden. Da werden das nächste mal ein paar Fotos folgen.

Aber um mal was neues zu berichten, ich habe mich mit ein paar netten Kollegen zu den KNX Twiddlers vereinigt. Unser 1. Video könnt ihr hier sehen:   https://www.youtube.com/watch?v=Aou66lx1YnM

Den Berker Bewegungsmelder könnt ihr dann natürlich auch im Showroom erleben, sobald Frank ihn mir wieder zurück geschickt hat.

Einen schönen 1. Mai.

Roman