-         
Seite 1 von 7 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 63

Thema: Farben nach R,G,B umwandeln in 4-stell. hex-code?

  1. #1
    Erfahrener Benutzer Robotik Einstein Avatar von HaWe
    Registriert seit
    09.10.2014
    Beiträge
    3.321

    Farben nach R,G,B umwandeln in 4-stell. hex-code?

    Anzeige

    Hallo,
    Adafruit verwendet für Farben einen 4-stelligen hex-Code, der nicht mit den 6-stelligen hex-Codes identisch ist, wie man sie von html kennt.
    Kennt jemand eine Konvertierungs-Routine oder Vorschrift, um die R,G,B-Werte (jew. 0-255) in den Adafruit Code umzurechnen?
    Code:
    #define ILI9341_BLACK       0x0000  ///<   0,   0,   0
    #define ILI9341_NAVY        0x000F  ///<   0,   0, 123
    #define ILI9341_DARKGREEN   0x03E0  ///<   0, 125,   0
    #define ILI9341_DARKCYAN    0x03EF  ///<   0, 125, 123
    #define ILI9341_MAROON      0x7800  ///< 123,   0,   0
    #define ILI9341_PURPLE      0x780F  ///< 123,   0, 123
    #define ILI9341_OLIVE       0x7BE0  ///< 123, 125,   0
    #define ILI9341_LIGHTGREY   0xC618  ///< 198, 195, 198
    #define ILI9341_DARKGREY    0x7BEF  ///< 123, 125, 123
    #define ILI9341_BLUE        0x001F  ///<   0,   0, 255
    #define ILI9341_GREEN       0x07E0  ///<   0, 255,   0
    #define ILI9341_CYAN        0x07FF  ///<   0, 255, 255
    #define ILI9341_RED         0xF800  ///< 255,   0,   0
    #define ILI9341_MAGENTA     0xF81F  ///< 255,   0, 255
    #define ILI9341_YELLOW      0xFFE0  ///< 255, 255,   0
    #define ILI9341_WHITE       0xFFFF  ///< 255, 255, 255
    #define ILI9341_ORANGE      0xFD20  ///< 255, 165,   0
    #define ILI9341_GREENYELLOW 0xAFE5  ///< 173, 255,  41
    #define ILI9341_PINK 0xFC18 ///< 255, 130, 198
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  2. #2
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    33
    Beiträge
    2.744
    Die Farben sind MSB>LSB 5bit R, 6bit G und 5bit B codiert

    du könntest also ganz simpel mit maskieren und shiften 3 bytes daraus machen wie du es gewohnt bist

    R = (0b1111100000000000 & input) >> 11;
    G = (0b0000011111100000 & input) >> 5;
    B = (0b0000000000011111 & input);

    https://en.wikipedia.org/wiki/List_o...tes#16-bit_RGB
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

  3. #3
    Erfahrener Benutzer Robotik Einstein Avatar von HaWe
    Registriert seit
    09.10.2014
    Beiträge
    3.321
    Zitat Zitat von Ceos Beitrag anzeigen
    Die Farben sind MSB>LSB 5bit R, 6bit G und 5bit B codiert

    du könntest also ganz simpel mit maskieren und shiften 3 bytes daraus machen wie du es gewohnt bist

    R = (0b1111100000000000 & input) >> 11;
    G = (0b0000011111100000 & input) >> 5;
    B = (0b0000000000011111 & input);

    https://en.wikipedia.org/wiki/List_o...tes#16-bit_RGB
    aha, danke!
    verstehe ich das richtig:
    also z.B. für LightHeliotrop (220, 139, 231):

    uint16_t R = (0b1111100000000000 & 220) >> 11;
    uint16_t G = (0b0000011111100000 & 139) >> 5;
    uint16_t B = (0b0000000000011111 & 231);

    uint16_t colorcode=R+G+B;

    ?

    - - - Aktualisiert - - -

    hmm, nee, scheint genau anders rum zu arbeiten...

    mit der Bitarithmetik komme ich aber nicht zurecht - wie sähe die Umkehrfunktion aus, aus den RGW-Einzelwerten die hex colorcode Zahl?

    einfach
    R =220 << 11;
    G = 139 << 5;
    B = 231;
    colorcode=R+G+B;

    ?

    PS,
    ja, schein zu klappen so rum...
    Danke!
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  4. #4
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    33
    Beiträge
    2.744
    ne das war die umrechnung von 16bit (sog. 65k Farbraum) auf R G B

    wolltest du es umgekehrt? Sorry

    RGB16 = ((uint16_t)R << 11) | (((uint16_t)G << 5) & 0b0000011111100000) | ((uint16_t)B & 0b0000000000011111);

    (uint16_t) muss zwingend vorher stehen und castet den 8bit auf einen 16bit, sonst fallen die bits nach dem 8ten ins nirvana

    ich kenne gerade nicht den 16bit unsigned int typ für arduino sorry

    (PS: Das ist auch der Grund weswegen ich so einen sprechenden typen verwende, egal welcher compiler oder welche umgebnung jeder macht es anders)
    Geändert von Ceos (06.09.2018 um 18:41 Uhr)
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

  5. #5
    Erfahrener Benutzer Robotik Einstein Avatar von HaWe
    Registriert seit
    09.10.2014
    Beiträge
    3.321
    danke vielmals, so passts!
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  6. #6
    Erfahrener Benutzer Robotik Einstein Avatar von HaWe
    Registriert seit
    09.10.2014
    Beiträge
    3.321
    das erste in eine Funktion zu packen mit Rückgabewert, ist ja einfach -
    Code:
    //---------------------------------------------------------
    // ColorRGB2color16bit
    //---------------------------------------------------------
    
    int16_t ColorRGB2color16bit(uint16_t R, uint16_t G, uint16_t B) {
    
       return  ((uint16_t)R << 11) | (((uint16_t)G << 5) & 0b0000011111100000) | ((uint16_t)B & 0b0000000000011111);
    ]
    kann man die Rückwärtstransformierung so programmieren (bin mir unsicher wegen pass per reference):


    Code:
    //---------------------------------------------------------
    // Color16bit2RGB
    //---------------------------------------------------------
     
    void Color16bit2RGB(uint16_t color16, uint16_t &R, uint16_t &G, uint16_t &B) {
    
       R = (0b1111100000000000 & color16) >> 11;
       G = (0b0000011111100000 & color16) >> 5;
       B = (0b0000000000011111 & color16);
    }
    Geändert von HaWe (07.09.2018 um 00:12 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  7. #7
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    33
    Beiträge
    2.744
    im zweifelsfall mit pointer

    Code:
    void Color16bit2RGB(uint16_t color16, uint8_t* R, uint8_t* G, uint8_t* B) {
    
       *R = (uint8_t)((0b1111100000000000 & color16) >> 11);
       *G = (uint8_t)((0b0000011111100000 & color16) >> 5);
       *B = (uint8_t)((0b0000000000011111 & color16));
    }
    muss gestehen dass ich solche reference calls meide, weils mir leicht spanisch ist
    pointer sind für mich persönlich einfacher zu handhaben

    beim aufruf musst du dann natürlich dioe adressen auflösen

    Code:
    uint8_t myR,myG,myB;
    Color16bit2RGB(some16bitColor, &myR, &myG, &myB);
    printf("<font color=\"#%00h%00h%00h\">",myR,myG,myB);

    PS: ich habe die einzelnen farben mal auf 8 bit reduziert und einen expliziten cast mit eingebaut damit alles sauber aussieht
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

  8. #8
    Erfahrener Benutzer Robotik Einstein Avatar von HaWe
    Registriert seit
    09.10.2014
    Beiträge
    3.321
    danke für die Mühe!
    Ich muss allerdings auch etwas gestehen...: dass mir das mit diese Pointern mit * und dann doch wieder & im Hauptprogramm noch viel unklarer ist, mit Pointer hin und vorher und hinterher referenzieren oder dereferenzieren oder wie auch immer das heißt - wenn möglich würde ich lieber eindeutige Variablennamen im Hauptprogramm verwenden, die dann per Referenz übergeben werden und auf die man dann nach Ende der Funktion wieder als aktuaisierte Werte per Variabennamen zugreifen kann.
    Aber auch da komme ich immer ins Schleudern. Hatte gehofft, das könnte irgendwer aus dem Stegreif...

    so, nochmal getestet - das mit dem "&" klappt...
    Rest nochmal in Arbeit...



    funktioniert noch nicht ganz perfekt...

    - - - Aktualisiert - - -

    Code:
    uint16_t ColorRGB216bit(uint16_t R, uint16_t G, uint16_t B) {
    
       return  ((uint16_t)R << 11) | (((uint16_t)G << 5) & 0b0000011111100000) | ((uint16_t)B & 0b0000000000011111);
    }
    
    
    void Color16bit2colorRGB(uint16_t color16, uint16_t &R, uint16_t &G, uint16_t &B) {
    
       R = (uint8_t)((0b1111100000000000 & color16) >> 11);
       G = (uint8_t)((0b0000011111100000 & color16) >> 5);
       B = (uint8_t)((0b0000000000011111 & color16));
       Serial.println("");
       Serial.println("Unterprogramm color16 zu RGB:");
       Serial.println( (String)"color16="+(String)color16);
       Serial.println( (String)"R="+(String)R);
       Serial.println( (String)"G="+(String)G);
       Serial.println( (String)"B="+(String)B); 
    }
    
    void setup() {
      // put your setup code here, to run once:
    
       uint16_t r=255, g=102, b=78, 
                col16=0;               // Dark Pink (255,102,78)
    
    
       Serial.begin(115200);
       
       Serial.println("Hauptprogramm vor Aufruf:");
       Serial.println( (String)"col16="+(String)col16);
       Serial.println( (String)"r="+(String)r);
       Serial.println( (String)"g="+(String)g);
       Serial.println( (String)"b="+(String)b);
       Serial.println("");
       
       col16=ColorRGB216bit(r,g,b);
       r=g=b=0; // Rücksetzen!
    
       Serial.println("Hauptprogramm nach rgb zu col16-Berechnung (rgb Einzelwerte dann gelöscht):");
       Serial.println( (String)"col16="+(String)col16);
       Serial.println( (String)"r="+(String)r);
       Serial.println( (String)"g="+(String)g);
       Serial.println( (String)"b="+(String)b);
       
       Color16bit2colorRGB(col16, r, g, b);
       Serial.println("");
       Serial.println("Hauptprogramm nach col16 zu rgb:");
       Serial.println( (String)"col16="+(String)col16);
       Serial.println( (String)"r="+(String)r);
       Serial.println( (String)"g="+(String)g);
       Serial.println( (String)"b="+(String)b);   
        
    }
    
    void loop() {
      // put your main code here, to run repeatedly:
    
    }
    Ausgabe:

    Hauptprogramm vor Aufruf:
    col16=0
    r=255
    g=102
    b=78

    Hauptprogramm nach rgb zu col16-Berechnung (rgb Einzelwerte dann gelöscht):
    col16=64718
    r=0
    g=0
    b=0

    Unterprogramm color16 zu RGB:
    color16=64718
    R=31
    G=38
    B=14

    Hauptprogramm nach col16 zu rgb:
    col16=64718
    r=31
    g=38
    b=14
    Geändert von HaWe (10.09.2018 um 13:29 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  9. #9
    Erfahrener Benutzer Robotik Einstein Avatar von HaWe
    Registriert seit
    09.10.2014
    Beiträge
    3.321
    kann es sein, dass die zurück-Richtung clolor16 => r,g,b nicht richtig rechnet? Zumindest schein es so nach direkter Kontrolle der (lokalen) Rechenschritte
    R = (uint8_t)((0b1111100000000000 & color16) >> 11);
    G = (uint8_t)((0b0000011111100000 & color16) >> 5);
    B = (uint8_t)((0b0000000000011111 & color16));

    denn die geben ja andere Ergebnisse als die hinwärts-Richtung r,g,b => color16:


    die hinwärts-Richtung ermittelt ja aus den 3 rgb-Werten
    r=255
    g=102
    b=78
    die color16-Zahl 64718

    die Rückwärts-Funktion dann aber aus color16=64718
    die (abweichenden) rgb-Werte
    R=31
    G=38
    B=14

    Hatte ich etwas falsch c+p'tet ?
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  10. #10
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    11.12.2007
    Ort
    weit weg von nahe Bonn
    Alter
    33
    Beiträge
    2.744
    Sorry dass ich nicht früher antworten konnte, hatte nicht viel gelegenheit überhaupt mal länger als 5 Minuten ins Forum zu schauen.

    Mir ist da ein Denkfehler passiert, bei der Rückrechnung der einzelnen Komponenten stimmt zumindest schonmal deine Formel, bei der Umrechnung von Komponenten auf RGB16 allerdings ist rigendwas schief, da komme ich auf einen anderen Wert.

    Der primäre Denkfehler liegt jedoch beim Rückrechnen von RGB16 auf R G B

    G wird hier mit 6Bit aufgelöst, also müsste man streng genommen >> 6 statt >> 5 machen ... was allerdings der größte Denkfehler von mir war ... die Werte sind doch nur 5 bzw. 6Bit groß und müssten ja nochmal auf 8Bit aufgeblasen werden (inklusive eines Verlust der Auflösung selbsttverständlich)

    Und ich glaube beim Maskieren und schieben ist auch noch ein dreher drinne ... ich habe immer die MSB ausmaskiert und da kann nur blödsinn bei rauskommen XD

    Ich versuche heute Nachmittag mal eine Korrektur, da ich jetzt noch was wegschaffen muss bevor hier alles abbrennt
    Es gibt 10 Sorten von Menschen: Die einen können binär zählen, die anderen
    nicht.

Seite 1 von 7 123 ... LetzteLetzte

Ähnliche Themen

  1. String nach Array umwandeln (?)
    Von slavezero im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 3
    Letzter Beitrag: 07.06.2012, 18:21
  2. Chips die nach Seriell umwandeln
    Von dundee12 im Forum Elektronik
    Antworten: 13
    Letzter Beitrag: 12.08.2010, 10:08
  3. word nach byte umwandeln
    Von magic33 im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 10
    Letzter Beitrag: 21.02.2007, 17:04
  4. C-Code in hex umwandeln
    Von elkokiller im Forum C - Programmierung (GCC u.a.)
    Antworten: 2
    Letzter Beitrag: 16.02.2006, 10:41
  5. PAL-Videosignal irgendwie nach seriell umwandeln?
    Von Trabukh im Forum Elektronik
    Antworten: 39
    Letzter Beitrag: 14.09.2005, 14:15

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •