RGB Wechsler - LEDs flackern

Hallo zusammen, ich bin neu beim programmieren und hatte bis dato eigentlich nichts damit am Hut.

Mein erstes Projekt ist eine Steuerung für RGB LEDs. Mit einem Schalter kann ich zwischen zwei Modi wählen - erstens die Farben werden automatisch schön gewechselt, mit einem Poti kann ich dauer des Vorgangs verändern

Modi zwei: eine Fixe Farbe entsteht, durch drei Potis kann ich die Werte für Rot, Grün und Blau einstellen. So weit so gut. Hier der Code:

int rot = 11; //LED Ausgänge
int gruen = 10; 
int blau = 9;  
int schalter = 7; //Schalter Variable
int wertrot = 0;  //Helligkeitsvariablen
int wertgruen = 0; 
int wertblau = 0;
int rotpot = A0;   //Potieingaenge
int gruenpot = A1;
int blaupot = A2;
int zeitpot = A3;
long zeit;          //Wert für zeitwechsel
float sinzahl = 0; //Zähler für Sinus
float pi = 3.14159265;
void setup() {
  pinMode (rot, OUTPUT);       //LED Ausgänge
  pinMode (gruen, OUTPUT);
  pinMode (blau, OUTPUT);
  pinMode (schalter, INPUT);   //Taster Eingang
  pinMode (rotpot, INPUT);     //Poti Eingänge
  pinMode (gruenpot, INPUT);
  pinMode (blaupot, INPUT);
  pinMode (zeitpot, INPUT);
  Serial.begin(9600);
}
void loop() {

  if (digitalRead(schalter) == LOW)
  {
    zeit=map(analogRead(zeitpot), 0, 1024, 10, 1000);      //Poti für Zeit wird ausgewerter 
    wertrot = sin(sinzahl / zeit) * 1000;                  //sinus, rot)
    wertgruen = sin(sinzahl / zeit + pi * 2 / 3) * 1000;   //sinus, grün, 120° Phasenverschoben)
    wertblau = sin(sinzahl / zeit + pi * 4 / 3) * 1000;    //sinus, blau, 240° Phasenverschoben
    wertrot = map(wertrot, -1000, 1000, 0, 255);           //auf Werte für LED übertragen
    wertgruen = map(wertgruen, -1000, 1000, 0, 255);
    wertblau = map(wertblau, -1000, 1000, 0, 100);
    analogWrite(rot, wertrot);                             //Farbe anzeigen
    analogWrite(gruen, wertgruen);                           
    analogWrite (blau, wertblau);
    sinzahl++;                            //zähler +1 für Sinuskurve
    delay (10);
  }

  else if (digitalRead(schalter) == HIGH) {

    wertrot = map(analogRead(rotpot), 0, 1024, 0, 255);        //Poti auslesen und in werte für LED umwandeln
    analogWrite (rot, wertrot);                                //Farbe anzeigen 
    wertgruen = map(analogRead(gruenpot), 0, 1024, 0, 255);
    analogWrite (gruen, wertgruen);
    wertblau = map(analogRead(blaupot), 0, 1024, 0, 255);
    analogWrite(blau, wertblau);
    

        }
  }

Erstmal wird der Schalter Abgefragt, damit ich eben in Modus eins oder zwei komme. Der Modus funktioniert soweit, das umschalten und alles klappt auch.

Im modus wird erst das Poti für die Zeit eingelesen, dann sind drei Sinusfunktionien, die um 120° Phasenverschoben sind.. danach kommt die Map funktion und dann wird der Zähler wider um eins erhöht. In den Sinusen (schreibt man das so?) wird die Zählervariable (sinzahl) durch die ausgelsene Zeit vom Poti geteilt. Durch das teileh verändert sich die Frequenz und dadurch läuft die ganze Geschichte langsamer oder schneller ab.

Beim Modus eins, dem automatischen wechsel tritt aber das Problem auf. Die LED flackert. Je nach Stellung des Potis mehr oder weniger, mal mit größeren mal mit kleineren Pausen aber immer flackert es etwas. Die zeit an sich mit dem Poti einstellen geht aber.

Was mich allerdings wundert: Wenn ich statt der Variable zeit eine Festzahl, die nicht abhängig vom Poti ist verwende, funktioniert das ganze einwandfrei.. also ohne Fehler und ohne Probleme, ohne Flackern. Also wenn der Code in etwa so aussieht:

    zei =163;
    wertrot = sin(sinzahl / zeit) * 1000;                  //sinus, rot)
    wertgruen = sin(sinzahl / zeit + pi * 2 / 3) * 1000;   //sinus, grün, 120° Phasenverschoben)
    wertblau = sin(sinzahl / zeit + pi * 4 / 3) * 1000;    //sinus, blau, 240° Phasenverschoben
    wertrot = map(wertrot, -1000, 1000, 0, 255);           //auf Werte für LED übertragen
    wertgruen = map(wertgruen, -1000, 1000, 0, 255);
    wertblau = map(wertblau, -1000, 1000, 0, 100);
    analogWrite(rot, wertrot);                             //Farbe anzeigen
    analogWrite(gruen, wertgruen);                           
    analogWrite (blau, wertblau);
    sinzahl++;                            //zähler +1 für Sinuskurve
    delay (10);

Dabei spielt es eigentlich keine Rolle welchen Wert ich da eingebe. habe so um die 20 verschiedene Zahlen zwischen 10 und 1000 reingeschmissen und es lief alles super.

An der Schaltung sollte der Fehler nicht liegen.. Es handelt sich um eine common Anode LED; angesteuert über 3 NPN Transistoren. Potis liegen zwischen plus und minus, Schleifer geht zum analogen eingang. Beim Schalter ist 10K Pulldown widerstand.

Und die Vorwiderstände (Basen der Transistoren, LEDs), sind mit Sicherheit ebenfalls richtig; entweder das oder ich sollte mir einen anderen Job suchen, im zweiten Lehrjahr EGS sollte man das können :D

Nun woran könnte das liegen? bin relativ ratlos... vor allem weil es mit einem fixen Wert klappt. Hat da einer ne Idee?

Achja falls das noch von bedeutung ist, es Handelt sich um einen originalen Uno SMD Version, Revision 3

Lass dir die Analogwerte mal mit der seriellen Schnittstelle ausgeben. Ich schätze, da liegt das Problem: lange Leitungen die Störungen aufnehmen und natürlich die nicht vermeidbaren kleinen Schwankungen bei AD-Wandler. Meistens hilft ein kleiner Tiefpass aus C=100 nF (direkt über Analog-In und GND) und R=10 kOhm (in Serie, zwischen Abgriff des Potis und dem Eingang) - evtl etwas größer - schon wunderbar. Wenn nicht, einen Tiefpass in Software modellieren, entweder mit gleitendem Mittelwert oder wie hier beschrieben.

Gruß, Marvin

Haber vorhin noch Kondensatoren zwischen den schleifern und Masse gesetzt... gab leider keine unterschiede... Widerstand bracht jetzt auch keine änderung... Poti wurde auch ausgetauscht. wenn ich die Variable des Potis auslese, dann ist das eigentlich immer konstant.

bei der Zeitvariable sind minimale Sprünge drin. das maximale was ich gesehen habe waren +0-3. Sollte nicht die Welt ausmachen.

wenn ich aber rotwert, gruenwert, oder blauwert auslese sieht die sache schon wieder ganz anders aus. da sind große sprünge (auch in die andere richtiung und wider zurück ) drin...

edit: habe da auch noch direkt beim Sinus auslesen lassen... Da kommt, je nach dem wie stark das flackern ist, recht viel Mist raus. Große Sprünge, alles durcheinander, von -200 auf +100 und wieder zurück und so weiter... Also da ist eindeutig was faul.. Aber was ??

Wenn mich nicht alles täuscht, sollte das Problem ja auch eher beim Code oder Arduino liegen und nicht auf dem Steckbrett durch irgendwelche Störungen o.Ä. . Ihc mein sonst würde ich beim Auslesen des Eingangspotis doch auch nur bockmist und ebenfalls große Sprünge angezeigt bekommen?? oder mach ich da nen denkfehler oO

Hallo,

kann es sein das Du einen Werteüberlauf hast. sinzahl kann man hochzählen lassen ohne Ende. wertgrün, wertblau und wertrot sind int Datentypen. Irgendwann laufen die über. Vielleicht haste mit 163 einen Wert erwischt wo es länger dauert bis zum Überlauf. Die sinzahl würde ich bei einem Maximum abfangen und limitieren.

Lasse Dir auf die serielle Zwischenwerte ausgeben, dann kannste das bestimmt besser nachvollziehen.

Nochwas. Bist Du Dir sicher das wertgrün, wertblau und wertrot die Werte berechnet bekommen die du möchtest? Eigentlich sind das float Datentypen. Sicherlich kann man das mit Ganzzahlen geschickt abschneiden lassen, aber nur wenn hinterher die Rechnung noch stimmt. Also bis auf die Nachkommastellen. Wie gesagt, lass mal was auf die serielle raus, dann siehst schon was passiert.

Bitte den gesamten Sketch.

pi * 2 sind nicht 120 Grad Verschiebung sondern 360. 3/4 Pi sind 120 Grad.

Ist eine HUE - RGB Umrechnung nicht einfacher?

Grüße Uwe

Dass 2pi 360 sind ist logisch, aber ich hab 2/3 und 4/3 und wenn mich nicht wirklich alles täuscht sind das 120 bzw. 240 Grad.. naja selbst wenn tut hier nix zur sache.

ich spiele morgen nochmal ein wenig rum, resette den counter und ähnliches, gleich habe ich keine Zeit mehr, ihr wisst schon, die Frauen :D

Wobei ich nicht glaube dass es, nach der kurzen Zeit am Zhler liegt. Schließlich tritt das problem driekt oder kurz nach dem Start auf und naja da kann das gnaze einfach noch nicht überfüllt sein...

die gruenwert rotwert und blauwert variablen sollten shcätze ich auch kein Problem sein, schließlich ist hier n Sinus am werkeln, mehr als +- 1000 in meinem Fall geht einfach nicht.

Also ich spiele gerade ein bishcen rum.

An der Hardware sollte, also dem Board kanns nicht liegen, ich hab da noch nen Arduiono Nano Clone, neu, bei dem ist es exakt das selbe.

Was mich gerade extrem verwundert: Wenn ich Sinzahl als long deklariere, ist das ganze etwas seltsam... Zwar zählt die zahl schön hoch laut seriellem Monitor, aber naja irgendwie klappt das mit dem fading nicht mehr so richtig. Eine Farbe wird da je nach zeiteinstellung recht lange gehalten und dann kippt das auf einmal um und die nächste Farbe ist.

Hingegen bei float geht es wider. Obwohl Sinzahl ja immer nur eine ganze Zahl sein kann. Kann mir das jemand erklären?

Und in der Zeit in der das flackern losgeht sind die Variablen weit weit unter dem Bereich in dem die Variable "voll" wäre. kann daran nicht liegen. Habe dennoch per if abfrage mal eben nen reset auf 1 reingehaut. Schaden kanns ja auch nicht; und ich hätte das früher oder später eh noch riengeschrieben hätte ich gemerkt, dass nach Zeit X irgendwas ganz aus dem Ruder läuft :D

Mit den anderen Variablen habe ich auch rumbespielt. Alles mal verändert, mal n long, mal n float, mal wieder zurück, aber nix schafft abhilfe..

Beim einlesen der zeit sind jetzt aber auch wieder sprünge

43
43
43
40
43
43
47
44
44
44
43
42
44
44
51
43

Könnte aber an nem schlechteren A/D Wandler beim Clone liegen?

vielleicht könnte es gehen, wenn der Arduino nur alle, keine Ahnung 10 Werte das poti neu ausließt? Wie würde das gehen? Oder besser noch der Mittelwert aus diesen... Ich will doch nur dass die doofen LEDs das tun was sie tuen sollen - faden :D

Was hast du nun? einen “originalen Uno SMD Version, Revision 3” oder “nem schlechteren A/D Wandler beim Clone”

Dass 2pi 360 sind ist logisch, aber ich hab 2/3 und 4/3 und wenn mich nicht wirklich alles täuscht sind das 120 bzw. 240 Grad… naja selbst wenn tut hier nix zur sache.

360° /3 ist 120°
2*120 = 240°
4*120 = 480° also 360°+120°
Es kommen 120° und 240° heraus aber das Drehfeld rotiert in die andere Richtung. (leg Dich nicht mit einem Elektrotechniker an! Du ziehst den Kürzeren :wink: :wink: :wink: )
Aber wie Du sagst ist das ein anderes Problem das nicht die falschen Werte erklährt.

Die Funktion sin() gibt Werte von -1 bis 1 aus und erwartert Werte von 0 bis 2Pi ( für Winkel von 0 bis <360°)

Der Zähler für die Sinuskurve ( sinzahl ) wird nie zurückgesetzt. Bei der Ungenauigkeit der float Variable ist spätestens bei einigen Millionen Durchgängen Schluß. Das inkrementieren um 1 ergibt keine höhere Zahl mehr weil es unter der Darstellungsgenauigkeit der Floatzahlen fällt sondern wackelt um einen Weret herum. Da die Sinusberechnung eine funktion mit der Wiederholung alle 2Pi ist werden die Einerstellen wichtig. Ein Floatzahl hat bei arduino nur 6 bis 7 significante Stellen.

Schreibe den Sketch so, daß sinzahl nach 360° wieder auf null gesetzt wird. Außerdem korrigiere den Fehler mit der Berechnung der Phasenverschiebung.

Grüße Uwe

Nachtrag: Die Float-Zahl wird bei 16777216 nicht mehr weiter erhöht. Das müßte bei Deinem Sketch nach ca 2 Tagen passieren.

Wieso muß der Zähler sinzahl ein Float sein? Wieso muß zeit ein long sein wenn sie nur Werte zwischn 10 und 1000 annimmt?

Grüße Uwe

Naja ich hab generell schon n bischen probiert mit den Variablen, schaun obs dann irgendwie geht oder so. Naja bisher bin ich erflogslos.

Naja gut in welche Richtung sich das Drehfeld bewegt, ist mir eigentlich relativ Wurst. Die Farben wechseln schön sauber (...wenn ich die Frequenz nicht über poti ändern will....) und darauf kommts an.

Reset ist klar dass da noch ein anständiger rein muss, habe unten noch eine if abfrage reingebastelt, die provisorisch das ganze bei 10000000 zurücksetzt. Wie ich das ganze mache, dass er nach 2pi das Ding zurücksetzt also ohne dass es einen Sprung gibt muss ich noch austüfteln, habe mir aber noch keine Große gedanken darum gemacht. Vielleicht auch mit nem Sinus? Egal, erst mal muss das flackern dringenst weg.

Welchen ich denn nun habe? Einen originalen Uno SMD Version, Rev.3 und mittlerweile auch noch einen Nano Clone. Mit dem Nano habe ich die Schaltung auch mal eben aufgebaut, erstens mal um zu sehen ob das Ding aus China funktioniert und 2.um 100% sicher zu sein, dass es kein Hardware defekt ist; denn der Uno war/ist gebraucht und habe ich von einem Freund geschenkt bekommen. Hardware defekt kann ich aber auf jeden Fall ausschließen, sonst würde der Nano denke ich nicht exakt gleich "spinnen"

Nun wider zurück zum flackern. ich habe mir ja jetzt gedacht ich will am liebsten 10 Werte oder so einlesen und daraus den Mittelwert bilden, vielleicht bleiben dann Sprünge aus und es läuft flüssig. So wie ich das versucht habe geht das aber nicht, es läuchten dauerhaft alle drei Farben :D

so habe ich das versucht:

void loop() {

  if (digitalRead(schalter) == LOW)
  { 

   float zeitarray[arrayzahl];
   
   if (arrayzahl ==10)
      {
         zeit=(zeitarray[0]+zeitarray[1]+zeitarray[2]+zeitarray[3]+zeitarray[4]+zeitarray[5]+zeitarray[6]+zeitarray[7]+zeitarray[8]+zeitarray[9])/10;
        arrayzahl=1;
      }
   zeitarray[arrayzahl]=map(analogRead(zeitpot), 0, 1023, 0, 1000);
   Serial.println(zeitarray[1]);
  
   //zeit=map(analogRead(zeitpot), 0, 1023, 10, 1000);      //Poti für Zeit wird ausgewerter 
   // Serial.println(analogRead(zeitpot));
   //Serial.println(zeit);
  arrayzahl++;

die als Kommentar angefügten zeilen sind nur der alte code, zum rumprobieren. Der Rest vom Code ist beim alten geblieben, mal abgesehen nach der Abfrage für Reset.

Nimm doch FastLEDs sin8() oder beatsin8() Funktionen. So wirst Du die haesslichen floats los und hast sofort Ergebnisse im Byte Bereich.

Fuer eine Geschwindigkeitsregelung kannst Du auch z.B. sowas machen:

color.red = sin8( millis() / speed );

Die Sache mit dem rauschenden Analog-In bekommst Du in den Griff, indem Du entweder die gelesenen 10 Bit reduzierst (vielleicht reichen Dir ja auch 7 Bit Aufloesung = 128 Zwischenstufen), oder indem Du mehrfach samplest und einen Mittelwert bildest.

Aber optimal ist ein Poti + AnalogIn fuer sowas nicht. Schon mal ueber einen Drehencoder nachgedacht?

Gruss,

Helmuth

P.S: Ich stimme Uwe zu, dass man im HSV Farbmodell bessere Ergebisse bekommt. "Zufaellige" RGB Sinuskurven fuehren zu desaturierten (=matschigen) Farben, weil die Nulldurchgaenge zu kurz sind und die meiste Zeit alle 3 LEDs an sind.

Wiewowas? Also mit dem sin8 oder beatsin8 kann ich jetzt recht wenig anfangen.. Also erstens gebe ich zu habe ich keine Ahnung davon und zweitens, ist das doch eher für ne Matrix, ich hab hier nur n paar LEDs im fertigen Projekt, die dann aber alle das selbe machen.

was heißt mehrfach sampeln?

Und das mit dem Mittelwert versuch ich gerade, aber kriegs nicht so richtig hin, siehe letzter post von mir..

Ansosnten über andere Lösungen hab ich bisher eigentlich nicht nachgedacht; Potis schienen mir aber eigentlich ideal... Naja am Schluss doch nur Probleme :D

Naja aber gerade komm ich dann auch an nichts anderes ran, wegen ein zwei Bauteilen brauch ich nix bestellen....

FastLED hat auch eine interessante Mathebibliothek integriert - lib8tion.h

Wenn man FastLED verwendet, wird uebrigens nur das compiliert, was man auch tatsaechlich verwendet - es blaeht also den Speicherbedarf nicht unnoetig auf.

sin8() erwartet einen Bytewert (0-255) entsprechend 0 bis 2pi und gibt einen Bytewert (0-255) entsprechend -1 bis +1 zurueck.

Dann ersparst Du dir das Rumgefummel mit den verschiedenen Datentypen.

Mehrfach samplen heisst, mehrfach nacheinander den Analogeingang lesen.

Wo ist das Problem mit dem Mittelwert? Im einfachsten Fall liest Du den Eingang in einer For-Schleife 10x nacheinander und addierst das Ergebnis zu einer Variable passenden Datentyps. Ergebnis durch 10 teilen, fertig ist der Mittelwert. Vor der Schleife die Summenvariable wieder auf 0 setzen.

Den Durchschnittswert ggf. noch durch 4 teilen, dann hast Du das Ergebnis im Byte Bereich, was Du mit AnalogWrite oder sin8 direkt weiterverarbeiten kannst.

P.S. Pseudocode:

void loop
int Summe = 0;
for (byte i = 0; i<10; i++)
Summe += analogRead(zeitpot);
Durchschnitt = Summe / 10;

Du kannst auch einen Mittelwert auf alle Analogwerte bilden.

wert = 0.9* Alterwert + 0.1*Neuerwert; Alterwert = wert;

So geht ein Außreiser in der Messung des Potis weniger in den Mittelwert ein, verlangsamt aber jede Änderung.

Die Werte 0.9 und 0.1 können beliebig verändert werden um den Einfluß des neuen Wertes auf den mittelwert zu ändern.

Grüße Uwe

Hab zur Zeit mal wider sehr wenig Zeit für irgendwas :/

Naja den Tip von Uwefed konnte ich gerade mal probieren. Leider leuchtet jetzt die LED auch nur dauerhaft in einer Farbe. Ich habe bloß mal wider keine Ahnung warum zum teufel oO... eigentlich sollte ja durch die zusätzlichen zeilen nur der Wert sich langsamer ändern und große Sprünge ausgleichen.... Ich glaub ich bin zu hohl für Microcontroller :()

Den Mittelwert nach Helmuth habe ich jetzt versucht zu bilden... naja also eigentlich tut es das was es soll... wenn ich die Werte durch den Mittelwertfleischwolf haue, schwankt die Zeit nur noch um ca. +-1.

Leider brachte das auch keine nenenswerte verbesserung. Anfangs läuft bei vielen Stellungen des Potis das ganze flüssig und gut. Nach 1-2 Minuten lässt sich bei vielen ein fading wenn überhaupt nur noch mit Phantasie erkennen.

Am auslesen des Zeitpotis kann es eigentlich gar nicht mehr liegen. Nach dem die Schwankungen anfangs genau so stark sind wie am ende, und das schwanken immer stärker wird.

Weitere Tips? wie gesagt, auslesen der Zeit lässt sich als Fehlerquelle ebenfalls mittlerweile ausschließen :/

Bitte den neuen Sketch.

Versuch mal http://eduardofv.com/read_post/179-Arduino-RGB-LED-HSV-Color-Wheel-
Der Farbwert wird als hue Wert zwischen 0 und <360 angegeben.

Grüße Uwe

Hier ist mal der neue Sketch.

int rot = 11; //LED Ausgänge
int gruen = 10; 
int blau = 9;  
int schalter = 3; //Schalter Variable
int wertrot = 0;  //Helligkeitsvariablen
int wertgruen = 0; 
int wertblau = 0;
int rotpot = A0;   //Potieingaenge
int gruenpot = A1;
int blaupot = A2;
int zeitpot = A3;
int zeit;          //Wert für zeitwechsel
float sinzahl = 0; //Zähler für Sinus
float pi = 3.14159265;
int zeitsumme=0;

 

void setup() {
  pinMode (rot, OUTPUT);       //LED Ausgänge
  pinMode (gruen, OUTPUT);
  pinMode (blau, OUTPUT);
  pinMode (schalter, INPUT);   //Taster Eingang
  pinMode (rotpot, INPUT);     //Poti Eingänge
  pinMode (gruenpot, INPUT);
  pinMode (blaupot, INPUT);
  pinMode (zeitpot, INPUT);
  Serial.begin(9600);
}
void loop() {

  if (digitalRead(schalter) == LOW)
  { 
int zeitzaehler=0;
for(zeitzaehler=0; zeitzaehler<10; zeitzaehler++);
{
  zeitsumme+=analogRead(zeitpot);
if (zeitzaehler ==10)
{
  zeitsumme=zeitsumme/10;
} 
  } 
   zeit=zeitsumme;
   Serial.println(zeit);
   wertrot = sin(sinzahl / zeit) * 1000;                  //sinus, rot)
   // Serial.println(wertrot);
    wertgruen = sin(sinzahl / zeit + pi * 2 / 3) * 1000;   //sinus, grün, 120° Phasenverschoben)
    //Serial.println(wertgruen);
    wertblau = sin(sinzahl / zeit + pi * 4 / 3) * 1000;    //sinus, blau, 240° Phasenverschoben
    //Serial.println(wertblau);
    wertrot = map(wertrot, -1000, 1000, 0, 255);           //auf Werte für LED übertragen
    wertgruen = map(wertgruen, -1000, 1000, 0, 255);
    wertblau = map(wertblau, -1000, 1000, 0, 100);
    analogWrite(rot, wertrot);                             //Farbe anzeigen
    analogWrite(gruen, wertgruen);                           
    analogWrite (blau, wertblau);
    sinzahl++;                            //zähler +1 für Sinuskurve
   // if (sinzahl ==2000000000)
     //   {
       //   sinzahl=1;
      //}    
     //Serial.println (sinzahl);
     delay (10);
    
  }

  else if (digitalRead(schalter) == HIGH) {

    wertrot = map(analogRead(rotpot), 0, 1023, 0, 255);        //Poti auslesen und in werte für LED umwandeln
    analogWrite (rot, wertrot);                                //Farbe anzeigen 
    wertgruen = map(analogRead(gruenpot), 0, 1023, 0, 255);
    analogWrite (gruen, wertgruen);
    wertblau = map(analogRead(blaupot), 0, 1023, 0, 255);
    analogWrite(blau, wertblau);
  Serial.println(wertgruen);

        }
  }

Wie gesagt, der Mittelwert scheint zu tun was er soll. Aber nach einer gewissen Zeit wird nach einem Anfangs schönen fading ein einziges geflacker… Ohmann ein kleines feautre will man einbauen und nüscht geht mehr xD

Der HUE code… naja also den kapiere ich nicht mal im Ansatz oO

Sesselmann: Der HUE code.. naja also den kapiere ich nicht mal im Ansatz oO

Vielleicht hilft es, erstmal das Konzept dahinter zu kapieren. Schau dir mal das Diagramm an.

Beim HSV hast Du 3 Werte:

  • die Farbe HUE als Wert zwischen 0 und <360 als wert der Farbe in einem Farbrad.
  • die Helligkeit
  • die Farbsättigung.

Grüße Uwe