Ankündigung

Einklappen
Keine Ankündigung bisher.

Byte -> RGBW

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

    Byte -> RGBW

    Ich habe hier einen DALI-Treiber von Lunatone, der über ein Byte die Lichtfarbe in RGBW umsetzt. Dazu unten mal ein Bild. Die Helligkeit verändert man mit einem weiteren Byte.

    Ich möchte das ganze per Software für ein anderes Gerät nachbilden, finde aber den passenden Rechenweg nicht. Ich brauche also jeweils einen Wert für R, G, B und W. Und das erst einmal unabhängig von der Helligkeit. Das kann man dann ja immer noch später realisieren. Hat jemand Ideen?

    rot, also 0, wäre dann R=100%, G=0%,, B=0%, W=0%
    blau, also ca. 90, wäre dann R=0%, G=0%,, B=100%, W=0%
    lila, also ca. 45, wäre dann R=50%, G=0%,, B=50%, W=0%

    Switch2Dim.png

    #2
    http://service.knx-user-forum.de/?co...nload&id=12234
    Gruß Matthias
    EIB übersetzt meine Frau mit "Ehemann Ist Beschäftigt"
    Meine Homepage - PN nur für PERSÖNLICHES!

    Kommentar


      #3
      Der Link ist zu irgendein Logikbaustein. Es geht ja hier um de Rechenweg, ohne Baustein.

      Kommentar


        #4
        Dann google einfach

        https://www.rapidtables.com/convert/...gb-to-hsl.html

        https://www.rapidtables.com/convert/color/index.html
        Gruß Matthias
        EIB übersetzt meine Frau mit "Ehemann Ist Beschäftigt"
        Meine Homepage - PN nur für PERSÖNLICHES!

        Kommentar


          #5
          Zitat von Cannon Beitrag anzeigen
          irgendein Logikbaustein
          Überwinde Dich und schau in den Baustein, der ist open source. Unter "Modul" steht der Quellcode und in den Kommentaren stehen die gewünschten Formeln

          Kommentar


            #6
            Zitat von knxPaul Beitrag anzeigen
            Überwinde Dich und schau in den Baustein, der ist open source. Unter "Modul" steht der Quellcode und in den Kommentaren stehen die gewünschten Formeln
            Achso. Ich dachte das ist eine Hardware.
            Die Umrechnungen im Unternet sehe ich. Aber es gibt keine, die von einem Byte zu RGBW konvertiert. und HSL ist das doch nicht oder stehe ich auf dem Schlauch?

            Kommentar


              #7
              Zitat von Cannon Beitrag anzeigen
              DALI-Treiber von Lunatone
              welcher Typ ist es denn? Hoffentlich läßt sich damit die Frage nach HSL beantworten. Wikipedia kennt unterschiedliche Farbräume ...

              Kommentar


                #8
                Zitat von knxPaul Beitrag anzeigen
                welcher Typ ist es denn?
                Der hier https://www.lunatone.com/produkt/dal...dimmer-cv-dt8/

                Aber wie gesagt ich will das nur per Software nachbilden mit einem anderen Dimmer. Das heißt, dass hat erst mal nicht unbedingt was mit DALI zu tun. Aber wenn ich das jetzt von den meisten hier richtig verstanden habe, handelt es sich um HSL, was ich dann nur noch von 360 auf 255 runterbringen muss. Damit versuche ich mal zu rechnen und schaue, was raus kommt.

                Kommentar


                  #9
                  Zitat von Cannon Beitrag anzeigen
                  von 360 auf 255 runterbringen
                  dabei aber von 1 Byte auf 4 Byte Wandlung nicht vergessen. HSL findet sich in Wikipedia

                  sogar mit Formeln für die Umrechnung HSV in RGB

                  Kommentar


                    #10
                    Ein Teil des Rätsels ist jetzt gelöst. Das ist nicht HSL, sondern HSB, was dann insofern passt, dass nur rot und blau im RGB vertauscht werden müssen. Hier alles unter der Annahme, dass ich mit Werten von 0-255 arbeite.

                    H = Farbe
                    S = Helligkeit
                    B = immer 255, also 100 %

                    In Python gibt es dafür eine lib und dann gehts easy:

                    Code:
                            myRGB = colorsys.hsv_to_rgb(value[0]/255.0,value[1]/255.0,value[2]/255.0)
                            RGB.R = round(myRGB[0]*255)
                            RGB.G = round(myRGB[2]*255)
                            RGB.B = round(myRGB[1]*255)
                    oder eine Funktion, die ich im Netz gefunden habe:

                    Code:
                    def hsv_to_rgb(h, s, v):
                        if s == 0.0: return (v, v, v)
                        i = int(h*6.) # XXX assume int() truncates!
                        f = (h*6.)-i; p,q,t = v*(1.-s), v*(1.-s*f), v*(1.-s*(1.-f)); i%=6
                        if i == 0: return (v, t, p)
                        if i == 1: return (q, v, p)
                        if i == 2: return (p, v, t)
                        if i == 3: return (p, q, v)
                        if i == 4: return (t, p, v)
                        if i == 5: return (v, p, q)
                    Was allerdings noch fehlt ist die Umrechnung des 4. Wertes, nämlich den WW-Wert. Ich vermute mal im Prinzip ist das das gleiche, man muss (nur) 4 Werte als Ergebnis unterbringen. Und da stehe ich dann wieder vor dem gleichen Problem. Dazu finde ich aber leider nichts im Netz.

                    Kommentar


                      #11
                      So richig komme ich nicht weiter. Kann jemand helfen?

                      Wenn ich das als Farbkreis sehe, siehe oben, dann ist zusätzlich in dem Kreis noch eine weitere Farbe vorhanden, das wäre das weiß. Deshalb müsste man den Kreis nach meinem Verständnis nicht auf 6 Teile aufteilen, sondern auf 8. Ich wüsste aber nicht, wie dann da die Formal aussehen sollte bzw. wo da noch was zwischen muss. Denn aus meiner Sicht wäre das weiß, wie jede andere Farbton auch zu betrachten. Das x wäre dann hier die 4. Farbe. Jemand Ideen?

                      Code:
                      def hsv_to_rgbw2(h, s, v):
                          if s == 0.0: return (v, v, v, v)
                          i = int(h*6.) # XXX assume int() truncates!
                          f = (h*6.)-i
                          p,q,t = v*(1.-s), v*(1.-s*f), v*(1.-s*(1.-f))
                          i%=6
                          x = 0
                          if i == 0: return (v, t, p, x)
                          if i == 1: return (q, v, p, x)
                          if i == 2: return (p, v, t, x)
                          if i == 3: return (p, q, v, x)
                          if i == 4: return (t, p, v, x)
                          if i == 5: return (v, p, q, x)

                      Kommentar


                        #12
                        Ja, genau: W steht für Weiss, bei LED stripes die vierte weisse LED.
                        Auf Wikipedia steht oben rechts das Bild

                        da sich gleiche Anteile von rot, grün und blau zu weiss mischen, sollte als "Formel" der kleinste Wert von R, G und B das W werden. Möglicherweise muss dann das resultierende W jeweils von R, G und B wieder abgezogen werden, um nicht "doppelt" ins Ergebnis einzugehen

                        Kommentar


                          #13
                          Zitat von knxPaul Beitrag anzeigen
                          Ja, genau: W steht für Weiss, bei LED stripes die vierte weisse LED.
                          Im Prinzip habe ich das auch ausprobiert und so ähnlich gemacht. Nur, dass ich W aus dem S und V genommen habe. Das funktioniert erstaunlich gut.

                          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))
                          Allerdings gibt es einen Haken. Das W ist einn Warmweiß mit 2700K und das weiß aus RGB ist ein Kaltweiß. Damit lässt sich dann am Ende kein Kaltweiß mehr darstellen, weil das quasi ersetzt wird.

                          Das Problem hier ist aber, dass ich ja den Weißwert schon im H einbauen will, wie oben in dem Bild, damit S dann entfallen kann. Denn das brauche ich aktuell nur für das Weiß.

                          Kommentar


                            #14
                            Nur dass ich da jetzt mitkomme: Wird am Ausgang ein RGBW mit Kaltweiß oder ein RGBWW mit Warmweiß benötigt?

                            in der letzten Zeile steht "item.RGBW.WW". WW ist Warmweiß. Wenn Kaltweiß benötigt wird, dann würde ich nacheinander umsetzen:
                            hsv_to_rgb und dann rgb_to_rgbw

                            Kommentar


                              #15
                              Zitat von knxPaul Beitrag anzeigen
                              Nur dass ich da jetzt mitkomme: Wird am Ausgang ein RGBW mit Kaltweiß oder ein RGBWW mit Warmweiß benötigt?
                              Mit Warmweiß, also WW. Aber ich brauche die Umrechnung des Farbkreises von HSV / HSB über die Farben rot, blau, grün, weiß, anstatt rot, blau, grün. Das ist die eigentliche Herausforderung, Weil ich die Grundfarbe separat brauche. Alle anderen Schritte, die ich hier mache, sind nur Zwischenschritte.

                              Kommentar

                              Lädt...
                              X