Ankündigung

Einklappen
Keine Ankündigung bisher.

MDT Glastaster HSV(HSB) nach RGB(W) wandeln?

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

    MDT Glastaster HSV(HSB) nach RGB(W) wandeln?

    Hallo SmarthomeNG Community!

    ich habe bei meinen Glastaster die Möglichkeit komfortabel über ein Farbverlaufsbalken die Lichtfarbe einzustellen.
    Leider unterstützt MDT nur HSV Ansteuerung.
    Aktuell verwende ich ein DALI Gateway von Gira, dort fehlt diese :-(.

    Da ich ungern ein neues Gateway kaufen möchte, meine Frage an euch:

    1. Gibt es schon eine Logik die diese Konvertierung vornimmt?
    2. Wenn nein, wie habt ihr das Thema gelöst.

    Schönen Sonntag noch

    #2
    Die größte Herausforderung ist das W. Ich bin da auch gerade dran. Ohne dem W wäre colorsys.hsv_to_rgb() die richtige Funktion. Dazu gibts hier schon einen Thread. Mit dem RGBW habe ich das modifiziert und läuft auch, aber ist noch nicht, dass was ich so richtig will:

    Code:
            myRGB = colorsys.hsv_to_rgb(value[0]/360.0,value[1]/100.0,value[2]/100.0)
            myRGBr = myRGB[0]
            myRGBg = myRGB[1]
            myRGBb = myRGB[2]
            myRGBw = abs(value[1]-100)/100.0*value[2]/100.0
            mincol = min(myRGBr, myRGBg, myRGBb)
            minwhite = min(mincol, myRGBw)
            myRGBr -= minwhite
            myRGBg -= minwhite
            myRGBb -= minwhite
            item.RGBW.R(round(myRGBr*255))
            item.RGBW.G(round(myRGBg*255))
            item.RGBW.B(round(myRGBb*255))
            item.RGBW.WW(round(myRGBw*255))
    Das kannst du so nicht 1:1 übernehmen, sondern musst das noch deinem Item anpassen.

    Kommentar


      #3
      Danke Cannon für die Logik, das konvertieren hat auf Anhieb funktioniert.
      Auch der Beitrag von Henfri bzgl. des relativen dimmen's hat mir an der Stelle weitergeholfen.
      Mit den (W) werde ich mich später nochmals beschäftigen....

      Kommentar


        #4
        Hallo,

        Hab ich gerade alles gemacht. Kann ich morgen Posten.

        Gruß,
        Hendrik

        Kommentar


          #5
          Zitat von pancho Beitrag anzeigen
          Danke Cannon für die Logik, das konvertieren hat auf Anhieb funktioniert.
          Danke. Ich bin da dran, noch mehr von den Funktionen zu basteln, sodass es so passt, wie ich das will. Ich habe noch andere Möglichkeiten getestet. Bin damit nur noch nicht ganz fertig. Ich glaube ein Farbbereich wird noch nicht abgedeckt un das s wird nicht berücksichtigt. Kannst das aber gern mal probieren. Achtung: Basis ist wieder 1.0, sodass man den noch durch den max-Wert, wie oben dividieren müsste.

          Code:
          def hsv_to_rgbw(h, s, v):
              h = min(0.0, max(1.0, h))
              s = min(0.0, max(1.0, s))
              v = min(0.0, max(1.0, v))
              h1 = h*4
              w1 = int(h1/3); b1 = int(h1/2)-w1; g1 = int(h1)-2*b1-3*w1; r1 = 1-g1-b1-w1
              w2 = (h1-2)*b1; b2 = (h1-1)*g1; g2 = h1*r1; r2 = (h1-3)*w1
              r = (r1+r2-g2)*v; g = (g1+g2-b2)*v; b = (b1+b2-w2)*v; w = (w1+w2-r2)*v
              return(r, g, b, w)

          Kommentar


            #6
            Hallo,

            @Cannon: Das kann ich ohne Erklärung nicht ganz nachvollziehen...
            Bisher habe ich folgendes realisiert:
            1) Relatives dimmen in sh.py umgesetzt https://knx-user-forum.de/forum/supp...latives-dimmen
            2) HSV nach RGB (ohne W) wie folgt:

            struct.yaml:
            Code:
            RGBW:
            
                Dimmwert:
                   type: num
                   influx: 'true'
                   eval: 'avg'
                   eval_trigger:
                      - '..R.Dimmwert'
                      - '..G.Dimmwert'
                      - '..B.Dimmwert'
                      - '..W.Dimmwert'                  
            
                Leistung:
                    type: num
                    value: 46
            
                Verbrauch:
                    type: num
                    cycle: 60  # wenn cycle erhöht wird auch * 60.0 erhöhen
                    eval: self()+self.return_parent().Dimmwert()/100   * self.return_parent().Leistung() * 60.0 / 60.0 / 60.0 / 1000
                    eval_trigger: ..Leistung
                    database: 'init'
                    influx: 'true'
            
                sequencer:
                    type: bool
                    knx_dpt: 1
                    
                H:
                    type: num
                    knx_dpt: '5.001'
            
                    RelativDimmen:
                        type: list
                        knx_dpt: 3
            
                S:
                    type: num
                    knx_dpt: '5.001'
            
                    RelativDimmen:
                        type: list
                        knx_dpt: 3
            
                V:
                    type: num
                    knx_dpt: '5.001'
            
                    RelativDimmen:
                        type: list
                        knx_dpt: 3              
            
                B:
                    type: bool
                    knx_dpt: 1
            
                    Dimmwert:
                        type: num
                        knx_dpt: '5.001'
            
                    RelativDimmen:
                        type: list
                        knx_dpt: 3
            
                G:
                    type: bool
                    knx_dpt: 1
            
                    Dimmwert:
                        type: num
                        knx_dpt: '5.001'
            
                    RelativDimmen:
                        type: list
                        knx_dpt: 3
            
                R:
                    type: bool
                    knx_dpt: 1
            
                    Dimmwert:
                        type: num
                        knx_dpt: '5.001'
            
                    RelativDimmen:
                        type: list
                        knx_dpt: 3
            
                W:
                    type: bool
                    knx_dpt: 1
            
                    Dimmwert:
                        type: num
                        knx_dpt: '5.001'
                        
                        Sollwert:
                          type: num
            
                            
                    RelativDimmen:
                        type: list
                        knx_dpt: 3
            Licht.yaml
            Code:
            eg:
                 raum1:
                    StripeOben:
                        struct: RGBW              
            
                        Leistung:
                            type: num
                            value: 46
            
                        sequencer:
                            type: bool
                            knx_dpt: 1
                            knx_listen:
                                - 0/1/2
                                - 0/1/3
                            
                        H:
                            knx_status: 1/1/24
                            knx_send:   1/1/24
            
                            RelativDimmen:
                                knx_listen: 1/1/25
            
                        S:
                            knx_status: 1/1/26
                            knx_send:   1/1/26
                            
            
                            RelativDimmen:
                                knx_listen: 1/1/27
            
                        V:
                            knx_status: 1/1/28
                            knx_send:   1/1/28
            
                            RelativDimmen:
                                knx_listen: 1/1/29          
            
                        R:
                            knx_send:  1/1/45
                            knx_cache: 1/1/48
                            
                            Dimmwert:
                                knx_send:  1/1/47
                                knx_cache: 1/1/49
            
                            RelativDimmen:
                                knx_listen: 1/1/46
            
                        G:
                            knx_send:  1/1/54
                            knx_cache: 1/1/57
                            
                            Dimmwert:
                                knx_send:  1/1/56
                                knx_cache: 1/1/58
            
                            RelativDimmen:
                                knx_listen: 1/1/55
            
                        B:
                            knx_send:  1/1/74
                            knx_cache: 1/1/77
                            
                            Dimmwert:
                                knx_send:  1/1/76
                                knx_cache: 1/1/78
            
                            RelativDimmen:
                                knx_listen: 1/1/75
            
                        W:
                            knx_send:  1/1/0
                            knx_cache: 1/1/3
                            
                            Dimmwert:
                                knx_send:  1/1/2
                                knx_cache: 1/1/4
            
                            RelativDimmen:
                                knx_listen: 1/1/1
            Der Vorteil der struct.yaml:
            - Es 'zwingt' mir die gleiche Struktur in verschiedenen Räumen auf --> Logiken lassen sich wiederverwenden
            - Die Licht.yaml wird übersichtlicher

            Nun noch die Logik:
            Code:
            #!/usr/bin/env python3
            # hsv_to_rgb.py
            
            def hsv2rgb(h,s,v):
                    try:
                        import colorsys as cs
                    except:
                        logger.error("could not import colorsys")
                    return tuple(round(i * 100) for i in cs.hsv_to_rgb(h,s,v))
            
            try:
                input_parent=  items.return_item(trigger['source']).return_parent()
                
                #lower case Variables are Values
                h=input_parent.H()
                s=input_parent.S()
                v=input_parent.V()
                
                logger.info("[HSV] Input Items identified, H/S/V are {}/{}/{}".format(h,s,v))
                #logger.warning("[HSV] Input Items identified, H/S/V are {}/{}/{}".format(h*3.6,s,v))
                
                #capital Variables are Items
                R= input_parent.R.Dimmwert
                G= input_parent.G.Dimmwert
                B= input_parent.B.Dimmwert
                
                logger.info("[HSV] Output Items identified")
                
                r,g,b=hsv2rgb(h/100.0,s/100.0,v/100.0)
                
                logger.info("[HSV] Conversion R/G/B are {}/{}/{}".format(r,g,b))
                #logger.warning("[HSV] Conversion R/G/B are {}/{}/{}".format(r*2.55,g*2.55,b*2.55))
                
                R(r)
                G(g)
                B(b)
                
                logger.info("[HSV] Values set")
            
            except:
                logger.error("This logic must be triggered by an Item whose parent has an R/G/B.Dimmwert item")
            und deren Konfiguration:
            Code:
            hsv_raum1:
                filename: hsv_to_rgb.py
                watch_item:
                -   eg.raum1.StripeOben.H
                -   eg.raum1.StripeOben.S
                -   eg.raum1.StripeOben.V
            Ich hoffe das hilft!

            Gruß,
            Hendrik

            Kommentar


              #7
              Zitat von henfri Beitrag anzeigen
              @Cannon: Das kann ich ohne Erklärung nicht ganz nachvollziehen...
              Ich habe versucht den Farbkreis in 4 Farben zu teilen, damit man auch das warmweiß realisieren kann. Das ist aber noch nicht ganz so, wie ich mir das vorstelle, aber mal zum testen eine Möglichkeit. Das Problem bei dem Farbkreis in 4 Teile, dass es wieder einen Teile gibt (nämlich Teil 4 zu Teil 1), der nicht abgedeckt ist. Hintergrund ist der, dass per KNX die Abbildung zu RGB(W) sehr unpraktisch ist, wenn man einen Tastsensor nehmen will. Daher bastele ich noch an Lösungen, dass es so geht.

              Kommentar

              Lädt...
              X