Moin,
ich habe Farben in RGB Werte (jeweils 0-255) und möchte diese in das hier umrechnen "0x03EF".
Was ist das? HEX?!
Und wie rechnet man das um?
Hier ein paar Beispiele:
Farbe: R / G / B = hex?!
Weiß: 255 / 255 / 255 = 0xFFFF
Gelb: 255 / 255 / 0 = 0xFFE0
Rot: 255 / 0 / 0 = 0xF800
Grün: 0 / 255 / 0 = 0x07E0
Blau: 0 / 0 / 255 = 0x001F
Schwarz: 0 / 0 / 0 = 0x0000
Lieben Dank und lieben Gruß,
Chris
Du hast eine R/G/B = 5/6/5 Farbdarstellung. Die Zahlen beziehen sich auf die Bits.
Rot: 255 / 0 / 0 = 0xF800 = 0b1111 1000 0000 0000
Grün: 0 / 255 / 0 = 0x07E0 = 0b0000 0111 1110 0000
Blau: 0 / 0 / 255 = 0x001F = 0b0000 0000 0001 1111
themanfrommoon:
Moin,ich habe Farben in RGB Werte (jeweils 0-255) und möchte diese in das hier umrechnen "0x03EF".
Was ist das? HEX?!
Und wie rechnet man das um?
Hier ein paar Beispiele:
Farbe: R / G / B = hex?!
Weiß: 255 / 255 / 255 = 0xFFFF
Gelb: 255 / 255 / 0 = 0xFFE0
Rot: 255 / 0 / 0 = 0xF800
Grün: 0 / 255 / 0 = 0x07E0
Blau: 0 / 0 / 255 = 0x001F
Schwarz: 0 / 0 / 0 = 0x0000Lieben Dank und lieben Gruß,
Chris
Weiß ist 0xFFFFFF oder 0x00FFFFFF oder 0xfff je nach Konvention.
0x03EF ist nach HTML Konvention auch mit 0x33EEFF identisch.
Hallo,
RGB16 im 5-6-5 Format (65k Farben)
RGB16 = ((rgb24 & $f80000) >> 8) || ((rgb24 & $fc00) >> 5) || ((rgb24 & $f8) >> 3) ))
Ohne Garantie falls ich mich vertippt habe...
Gruß aus Berlin
Michael
Okay, wenn das RGB565 ist, dann gibt's sogar eine Umrechnung in der TFT_eSPI Library
tft.color565(R,G,B);
Super wunderbar, nu komme ich wieder weiter.
Danke und lieben Gruß,
Chris
themanfrommoon:
Okay, wenn das RGB565 ist, ...
Och !
Wieso weißt du das nicht?
Weil ich nur Gelegenheitsprogrammierer bin aber trotzdem das eine oder andere Projekt verwirklichen möchte.
Ich programmiere sehr unregelmäßig, manchmal (1-2x pro Jahr) ne ganze Nacht durch, dann aber oft Monate gar nicht.
Und wenn man sich so selten damit befasst, dann springt einem nicht die ganze Bibliothek in den Kopf.
Leider, schön wärs, oder auch gruselig.
Aber dafür gibt's ja die Community.
Klar, man könnte auch alles lernen und Bücher wälzen und, und, und.....
….aber dann würde meine Projekte nie was werden, weil dazu einfach die Zeit nicht da ist.
Also, lieben Dank und lieben Gruß,
Chris
Nee, das meine ich nicht!
Irgendwo für wirst du es ja brauchen.
Und dieses wird ja wohl eine Doku haben, wo steht, welches der ca 500 verschiedenen Farbmodelle dort verwendet werden muss.
Wir können das nicht wissen.
Nur vermuten.
Denn, den Zweck hältst du geheim. (warum auch immer)
Achso, ja Moment:
Ich lese mit einem TCS34725 über die <Adafruit_TCS34725.h> die Farbe ein.
Das geht mit einer Funktion
getRawData_noDelay(&yR, &yG, &yB);
Diese wirft dann mit der Einstellung
TCS34725_INTEGRATIONTIME_154MS
Werte von 0-65535 raus.
Diese teile ich dann mit
yR /= 256; yG /= 256; yB /= 256;
und bekomme so meine RGB Werte von 0-255
Dann gebe ich die einzelnen RGB Werte als Balken mit der <TFT_eSPI.h> auf einem TFT Display aus.
Und als letztes wollte ich die RGB Werte wieder zu einer Farbe zusammenmischen, um zu sehen wie das aussieht was der Sensor da so einliest.
Das geht auch schon, ich mache jetzt noch ein bisschen Kosmetik (alte Daten vom Display löschen und Maximalwerte merken und sowas)
Und dann geht es darum herauszufinden, wie der Sensor die Farben am besten erkennen kann 
Lieben Gruß,
Chris
Und hier denn nun auch mein ganzer Code, der so läuft wie ich es mir vorstelle
(Ist nur zum Testen des TCS34725. Es wird zusätzlich ein 2,8" TFT zur Anzeige verwendet)
#include <Wire.h>
#include <Adafruit_TCS34725.h>
#include <SPI.h>
#include <TFT_eSPI.h> // Hardware-specific library
TFT_eSPI tft = TFT_eSPI(); // Invoke custom library
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_154MS, TCS34725_GAIN_16X);
// TCS34725_INTEGRATIONTIME_2_4MS // 2.4ms - 1 cycle - Max Count: 1024
// TCS34725_INTEGRATIONTIME_24MS // 24ms - 10 cycles - Max Count: 10240
// TCS34725_INTEGRATIONTIME_50MS // 50ms - 20 cycles - Max Count: 20480
// TCS34725_INTEGRATIONTIME_101MS // 101ms - 42 cycles - Max Count: 43008
// TCS34725_INTEGRATIONTIME_154MS // 154ms - 64 cycles - Max Count: 65535
// TCS34725_INTEGRATIONTIME_700MS // 700ms - 256 cycles - Max Count: 65535
// TCS34725_GAIN_1X // No gain
// TCS34725_GAIN_4X // 4x gain
// TCS34725_GAIN_16X // 16x gain
// TCS34725_GAIN_60X // 60x gain
int mx;
int my;
int yR;
int yG;
int yB;
int yRold;
int yGold;
int yBold;
int yRmax;
int yGmax;
int yBmax;
unsigned long previousMillis = 0;
unsigned long interval = 10000;
/***********************************************************************************************************************************/
void getRawData_noDelay(uint16_t *r, uint16_t *g, uint16_t *b)
{
*r = tcs.read16(TCS34725_RDATAL);
*g = tcs.read16(TCS34725_GDATAL);
*b = tcs.read16(TCS34725_BDATAL);
}
/***********************************************************************************************************************************/
void setup() {
Serial.begin(115200);
delay (50);
tft.init();
tft.setRotation(2);
mx = tft.width();
my = tft.height();
Serial.print(mx);
Serial.print(" ");
Serial.println(my);
tft.fillScreen(TFT_BLACK);
if (tcs.begin()) {
Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1);
}
// Set persistence filter to generate an interrupt for every RGB Cycle, regardless of the integration limits
tcs.write8(TCS34725_PERS, TCS34725_PERS_NONE);
tcs.setInterrupt(true);
Serial.flush();
}
/***********************************************************************************************************************************/
void loop() {
uint16_t yR, yG, yB ;
getRawData_noDelay(&yR, &yG, &yB);
yR /= 256; yG /= 256; yB /= 256;
Serial.print("R: "); Serial.print(yR, DEC); Serial.print(" ");
Serial.print("G: "); Serial.print(yG, DEC); Serial.print(" ");
Serial.print("B: "); Serial.print(yB, DEC); Serial.print(" ");
Serial.println(" ");
Serial.flush();
if (yR > yRmax) { //höchsten Rot Wert merken
yRmax = yR;
};
if (yG > yGmax) { //höchsen Grün Wert merken
yGmax = yG;
};
if (yB > yBmax) { //höchsten Blau Wert merken
yBmax = yB;
};
tft.fillRect(30, 288 - yRmax + 1 , 20, yRmax - yR - 1, TFT_BLACK);
tft.fillRect(60, 288 - yGmax + 1 , 20, yGmax - yG - 1, TFT_BLACK);
tft.fillRect(90, 288 - yBmax + 1 , 20, yBmax - yB - 1, TFT_BLACK);
tft.fillRect(30, 288 - yR , 20, yR, TFT_RED);
tft.fillRect(60, 288 - yG , 20, yG, TFT_GREEN);
tft.fillRect(90, 288 - yB , 20, yB, TFT_BLUE);
tft.drawLine(30, 288 - yRmax, 50 - 1, 288 - yRmax, TFT_WHITE);
tft.drawLine(60, 288 - yGmax, 80 - 1, 288 - yGmax, TFT_WHITE);
tft.drawLine(90, 288 - yBmax, 110 - 1, 288 - yBmax, TFT_WHITE);
tft.fillRect(120, 188, 20, 100, tft.color565(yR, yG, yB));
tft.fillRect(140, 188, 20, 100, tft.color565(yRmax, yGmax, yBmax));
if (millis() - previousMillis > interval)
{
tft.drawLine(30, 288 - yRmax, 50 - 1, 288 - yRmax, TFT_BLACK);
tft.drawLine(60, 288 - yGmax, 80 - 1, 288 - yGmax, TFT_BLACK);
tft.drawLine(90, 288 - yBmax, 110 - 1, 288 - yBmax, TFT_BLACK);
yRmax = 0;
yGmax = 0;
yBmax = 0;
previousMillis = millis();
}
}
Lieben Gruß,
Chris
unsigned int rgb565 = ((unsigned int)(red & 0xF8) << 8) | ((unsigned int)(green & 0xFC) << 3) | (blue >> 3);
Blau kommt auf Bits 0-4. Du willst die oberen Bits. Also schiebt man einfach 3 nach rechts
Grün kommt auf Bits 5-7. Die unteren 2 Bits die wegfallen müssen auf 0 gesetzt werden damit man Blau nicht überschreibt. Daher das UND mit 1111 1100
Rot kommt auf Bits 11-15. Hier müssen die unteren 3 Bits auf 0 sein damit man Grün nicht überschreibt