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

[HaWe]

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?

#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

[Ceos]

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

[HaWe]

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!

[Ceos]

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)

[HaWe]

danke vielmals, so passts!

[HaWe]

das erste in eine Funktion zu packen mit Rückgabewert, ist ja einfach -

//---------------------------------------------------------
// 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):

//---------------------------------------------------------
// 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);
}