Ankündigung

Einklappen
Keine Ankündigung bisher.

Funktionen in Logiken

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

    Funktionen in Logiken

    Ich habe versucht in einer Logik eine Funktion zu schreiben. Das heißt, wie man das so in Python macht:

    Code:
    def Funktion(param1, param2):
    Ich kann die aber nicht aufrufen, weil die nicht gefunden wurde. Geht das überhaupt in Logiken?

    #2
    Klar kann man Funktionen in Logiken aufrufen, mache ich ständig. Was jedoch nicht so einfach geht, ist Funktionen aus andern Funktionen in der Logik aufzurufen. Das liegt daran, dass der Kontext der Logik nicht dem globalen Kontext eines Python Programmes entspricht. Die Funktionen sind lokal zum Lauf der Logik.

    Zu dem Thema gibt es hier schon mindestens einen Thread im Forum. Da musst Du mal die Suche bemühen.
    Viele Grüße
    Martin

    Stay away from negative people. They have a problem for every solution.

    Kommentar


      #3
      Guckst du hier: https://knx-user-forum.de/forum/supp...ionen-benutzen
      Wär vielleicht mal was für die Doku..

      Kommentar


        #4
        Danke den Thread habe ich gefunden. Also prinzipiell geht es wohl. :-)

        Allerdings muss man wohl beachten, dass die Funktion im Code vor dem Aufruf "definiert" werden muss, sonst wird die nicht gefunden. Ich weiß nicht, ob das eine Eigenart von Python ist oder ob das hier bei SmartHomeNG so sein muss.

        Kommentar


          #5
          Das ist eine "Eigenart" von Python.
          Viele Grüße
          Martin

          Stay away from negative people. They have a problem for every solution.

          Kommentar


            #6
            Zitat von Msinn Beitrag anzeigen
            Das ist eine "Eigenart" von Python.
            ... von Python und von sämtlichen 'klassischen' Programmiersprachen.

            /tom

            Kommentar


              #7
              Zitat von Tom Bombadil Beitrag anzeigen
              sämtlichen 'klassischen' Programmiersprachen
              Dem widerspreche ich mal einfach. Weder bei BASIC, Pascal, C, C++, C# ist das notwendig. Und die bezeichne ich mal als klassische Programmiersprachen.

              Zitat von Msinn Beitrag anzeigen
              Das ist eine "Eigenart" von Python.
              Danke. :-)

              Was ich aber auch irgendwie nicht richtig gefunden habe, auch nicht im anderen Thread, wie kann ich items in der Funktion übergeben und diese daann darin auch verwenden?

              Code:
              def Funktion(myItem):
                  myItem.timer(60, 10)
              Aufruf mit:

              Code:
              Funktion(sh.Licht.schalten)
              geht so nicht oder?

              Kommentar


                #8
                Zitat von Cannon Beitrag anzeigen
                Dem widerspreche ich mal einfach.
                Da muss ich Dir widersprechen. Ich hatte 'Eigenart' bewusst in Anführungsstriche gesetzt, da die Definition vor Nutzung für viele Programmiersprachen gilt. Ganz besonders für Interpreter-Sprachen wie BASIC. Das schließt nicht aus, dass es Implementationen dieser Sprachen gibt, die diese Einschränkung nicht haben. Das sind dann aber keine Interpreter-Inplementationen sondern Compiler mit anschließendem Linker.

                Andererseits gilt diese Beschränkung auch für Compiler Sprachen wie Delphi-Pascal:

                Routinen werden wie die globalen Typen, Konstanten und Variablen im Deklarationsblock oberhalb des begin vom Hauptprogramm deklariert. Die Routinen können sich auch untereinander aufrufen. Dabei gilt die Lesereihenfolge von oben nach unten: alle oben genannten Routinen sind denen darunter bekannt und können von diesen aufgerufen werden.
                Viele Grüße
                Martin

                Stay away from negative people. They have a problem for every solution.

                Kommentar


                  #9
                  Hi,

                  Zitat von Cannon Beitrag anzeigen
                  C, C++,
                  auch in C, C++ kannst Du nur bereits definierte Funktionen aufrufen. Das fällt da nur nicht auf, weil normalerweise alle Funktionen als forward deklarationen in den Header-Files stecken und diese gleich zu Anfang inkludiert werden.

                  Gruß, Waldemar

                  Kommentar


                    #10
                    Jupp, insbesondere bei Compiler-Sprachen wie Turbo Pascal / Delphi, Borland C, Basic etc. Wer einmal ein größeres Projekt in damaligen Zeiten auf den Kopf stellen musste, kennt das Gefluche.

                    Ich habe wahrlich keinen Komplettüberblick, aber die Unsitte, Funktionen / Prozeduren auch erst nach Gebrauch definieren zu können, scheint mir eine 'Unsitte' von modernen Interpretern zu sein ...

                    /tom

                    Kommentar


                      #11
                      Die im Prinzip einfachste Lösung ist es selbst ein Plugin für den Eigengebraucht zu schreiben und die benötigten Funktionen dort unterzubringen. Das war auch mal ursprünglich 2013 der Rat von callidomus als ich die gleiche Problematik hatte. Allerdings ist bisher nix so kompliziert gewesen, das ich unbedingt ein Plugin hätte selber schreiben müssen.
                      Du kannst natürlich ein Plugin bauen, das aus einem bestimmten Verzeichnis alle *.py Dateien einliest und im Namensraum eines Plugins zur Verfügung stellt. Das wäre dann mal was für die Allgemeinheit :-)

                      Kommentar


                        #12
                        Zitat von mumpf Beitrag anzeigen
                        auch in C, C++ kannst Du nur bereits definierte Funktionen aufrufen. Das fällt da nur nicht auf, weil normalerweise alle Funktionen als forward deklarationen in den Header-Files stecken und diese gleich zu Anfang inkludiert werden.
                        Das gilt aber nur für Funktionen, die du außerhalb der eigenen "Datei" aufrufen willst. Für Funktionen innerhalb eine Code-Datei braucht man das nicht.

                        Zitat von Tom Bombadil Beitrag anzeigen
                        Ich habe wahrlich keinen Komplettüberblick, aber die Unsitte, Funktionen / Prozeduren auch erst nach Gebrauch definieren zu können, scheint mir eine 'Unsitte' von modernen Interpretern zu sein ...
                        Was heißt "Unsitte"? Es ist nur eine Frage der Form. In den meisten Hochsprachen definiert man die Funktionen ja sowieso strukturiert in einer eigenen Datei. Bei kurzen Codezeilen ist es eher eine Frage des persönlichen Geschmacks. Und ich packe die Funktionen lieber ans Ende, weil ich die weniger oft anfasse als den eigentlichen "Programm"-Code. Wobei das sowieso sehr abstrakt ist, weil wenn man über C++ / C# redet ist sowieso fast jede Funktion woanders definiert.

                        Wobei mir das auch nicht ganz klare ist in Python. Hier mal ein Auszug aus einem plugin:

                        Code:
                            # Initialize connection
                            def __init__(self, smarthome, host, port=502, cycle=50):
                                self.logger = logging.getLogger(__name__)
                                self._host = host
                                self._port = int(port)
                                self._sh = smarthome
                                self._cycle = int(cycle)
                                self._lock = threading.Lock()
                                self._is_connected = False
                                self._items = {}
                                self.connect()
                                # pydevd.settrace("10.20.0.125")
                        
                            def connect(self):
                                start_time = time.time()
                                if self._is_connected:
                                    return True
                                self._lock.acquire()
                                try:
                                    self.logger.info("Pluggit: connecting to {0}:{1}".format(self._host, self._port))
                                    self._Pluggit = ModbusTcpClient(self._host, self._port)
                                except Exception as e:
                                    self.logger.error("Pluggit: could not connect to {0}:{1}: {2}".format(self._host, self._port, e))
                                    return
                                finally:
                                    self._lock.release()
                                self.logger.info("Pluggit: connected to {0}:{1}".format(self._host, self._port))
                                self._is_connected = True
                                end_time = time.time()
                                self.logger.debug("Pluggit: connection took {0} seconds".format(end_time - start_time))
                        Wenn ich mir das "connect" so ansehe, wird das erst nach der aufzurufenden Zeile definiert und das verstehe ich dann doch nicht.

                        Zitat von bmx Beitrag anzeigen
                        Du kannst natürlich ein Plugin bauen, das aus einem bestimmten Verzeichnis alle *.py Dateien einliest und im Namensraum eines Plugins zur Verfügung stellt. Das wäre dann mal was für die Allgemeinheit :-)
                        Das ist eine gute Idee. Macht aber nur Sinn, wenn es Funktionen sind, die man immer mal wieder brauchen würde. Bei mir geht es explizit um eine Bewässerungssteuerung und die macht für globale Funktionen wenig Sinn. Ich werde die aber dennoch zur Verfügung stellen, wenn es so läuft, wie ich mir das gern vorstelle. Die Funktion aber deshalb, damit ich nicht für jeden Sprinklerkreis die kompletten Konditionen prüfen muss und dafür jedes mal den gleichen Code habe.

                        Kommentar

                        Lädt...
                        X