Ankündigung

Einklappen
Keine Ankündigung bisher.

sh.py & threading (smarthomeNG)

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

    sh.py & threading (smarthomeNG)

    Hallo zusammen,

    bin z.Zt. dabei ueber ein BBB meine DMX Steuerung zu machen. Hardwareseitig laeuft das Ganze seit ein paar Monaten stabil (siehe DYI-forum) und fuer den naechsten Schritt des Anbindens an KNX ueber smarthome.py habe ich eine Frage:

    Wenn das plugin nicht nur Schaltvorgaenge, sondern auch heller-/dunkler-dimmen soll, z.b. 0%...100% in 3000 ms, brauche ich eine Moeglichkeit um (a) den Dimmvorgang zu starten und (b) zu stoppen und das fuer parallel laufende Dimmvorgaenge.

    Hierfuer hatte ich Folgendes gedacht:
    1) dimmstart ueber KNX => thread starten mit einem event als argument
    2) dimmstop ueber KNX => thead stoppen ueber event.set()

    Meine Frage: gibt es "Bedenken" bzgl. der Vorgehensweise bzw. was waere hierfuer eine bessere Herangehensweise?

    Danke fuer alle Hilfe, Kommentare etc. und LG - tullsta


    ein beispielhafter code (ohne error-handling etc.) waere hier:

    Code:
    def thread1(e, threadID, startTime):
            dimTime = 2.0
            idx = 0;
            print('starting thread', str(threadID))
            while not e.isSet():
                idx = idx + 1
                print(str(threadID) + '\t -> ' + str(idx))
                time.sleep(dimTime/255.0)
            print('stop-event for thread ', str(threadID), 'set at time', str(timedelta(seconds = time.monotonic()-startTime)))
            pass
    
    
    # starte Dimmvorgaenge
    e1 = threading.Event()
    t1  = threading.Thread(target=thread1,  args=(e1, 1, time.monotonic()))
    t1.start()
    
    e2 = threading.Event()
    t2  = threading.Thread(target=thread1,  args=(e2, 2, time.monotonic()))
    t2.start()
    
    time.sleep(0.1)
    
    e3 = threading.Event()
    t3  = threading.Thread(target=thread1,  args=(e3, 3, time.monotonic()))
    t3.start()
    
    # stoppe Dimmvorgaenge
    time.sleep(0.1)
    e1.set()
    
    time.sleep(0.1)
    e2.set()
    time.sleep(0.1)
    e3.set()
    time.sleep(5)

    #2
    Hi,
    kennst du eigentlich die fade() Methode der Items? Die macht meiner Meinung nach das was du implementierst.
    Such mal hier im Forum nach fade

    Grüße
    Christian

    Kommentar


      #3
      Hallo Christian,

      danke!

      Zitat von cmalo Beitrag anzeigen
      Hi,
      kennst du eigentlich die fade() Methode der Items?
      jetzt ja - vorher noch nicht

      Wenn ich es richtig sehe, koennte man das verwenden, wenn ein paar Dinge moeglich sind:
      - nach jedem "step" eine Funktion aufzurufen => Ansteuerung des DMX interfaces fuer dieses "step" / dimm-Umkehr beim Eintasten-Dimmen bei erreichen des max-/min-Wertes
      - "break" eines fades => KNX dim stopp message

      In der Doku hab' ich dazu nichts gefunden, aber vielleicht weiss es hier ja jemand.

      Danke und liebe Gruesse - tullsta

      Kommentar


        #4
        Hallo,

        hab' das jetzt so geloest, dass ich eine Klasse "DmxChannel" definiert hab, die einen DMX Kanal "bedienen" kann.

        Diese Klasse stellt verschiedene Methoden (e.g. SwitchOn, SwitchOff, DimToLevel, StartDimming) sowie Attribute (lastDimLevel, currentDimLevel, isSwitchedOn, etc.) zur Veruegung. Eine Instanz dieser Klasse kann man dann z.B. ueber "dmxChan_01.SwitchOn()" mit dem alten dim-wert einschalten.

        Beim Dimmen hab ich es dann Sobald eine Instanz dieser Klasse mit "dmxChan_01.StartDimming()" angesteuert wird, wird eine Klassenmethode als Thread gestarted:
        e1 = threading.Event()
        t1 = threading.Thread(target=self.dmxDimWorker, args=(e1))
        t1.start()
        Dieser dim-thread besorgt dann das Dimmen in definierbaren Schritten.

        Bei der Methode "DimToLevel" (z.B. bei Szenen) liegt das Stopp-Kriterium fest, so dass der dim-Thread selbst sein Ende berechnen kann.

        Beim Start-Stop-Dimmen kommt das stopp-Kriterium von aussen (KNX-Telegramm) und dieses wird/soll dann ueber das Stopp-Event and den dim-Thread durchgereicht werden.

        In der Testbench (ausserhalb von smarthome.py) funktioniert das ganz gut (soweit ich das jetzt sagen kann).

        Gibt es etwas an diesem Konzept, bei dem erfahrenere smarthome.py-Programmierer die Haende ueber dem Kopf zusammenschlagen bzw. etwas, was hier besser/einfacher/resourcen-schonender geht? Bei uns gaebe es dann maximal 40 parallel laufende threads (40 Lampengruppen).

        Danke fuer jeden Kommentar und lg - tullsta


        Kommentar


          #5
          hat jemand von den smarthome-Kennern zu der Vorgehensweise evtl. einen Kommentar?

          Danke und lg - tullsta

          Kommentar

          Lädt...
          X