Lösung gesucht: LEDs umschalten mit weichem Übergang (fading)

Hallo,

ich programmiere gerade eine Uhr mit:

  • Arduion Mega2560
  • DS3231 Real Time Clock
  • 2m Led Strip 120 Leds (WS2812)

Grundsätzlich funktioniert alles, ich möchte aber einen weichen Übergang der Leds für den Sekundenzeiger haben, wie in diesem Video bei 01:10 www.youtube.com/watch?v=JNpjX5mobfI

Der Sekundenzeiger besteht quasi aus 5 Leds, das mittlere soll am hellsten leuchten, die zwei nach links und rechts schwächer.

Leider weiß ich gar nicht wie ich das anstellen soll, da ich vom DS3231 ja nur Sekunden bekomme und keine Millisekunden.

Kann mir da eventuell jemand weiterhelfen?

Mein bescheidender Code bisher:

#include <FastLED.h>
#include <Wire.h>
#include "DS3231.h"

#define NUM_LEDS 120
#define DATA_PIN 22

int second = 0;
int minute = 0;
int hour = 0;
int led_second = 0;
int led_minute = 0;
int led_hour = 0;

int pause = 100;

int mode = 1;
int i = 0;

int color_second = 0;     // wird über Sättigung 0 geregelt
int color_minute = 160;
int color_hour = 192;
int color_quater = 0;
int brightness_quater = 128;

bool h12;
bool PM;

CRGB leds[NUM_LEDS];

DS3231 Clock;

void get_time()
{
  //Uhrzeit auslesen
  second = Clock.getSecond();
  minute = Clock.getMinute();
  hour = Clock.getHour(h12, PM);
  if (hour > 12 ) hour = hour - 12;   // bereinigt auf 0 - 11

  led_second = (second * 2) - 1;
  led_minute = (minute * 2) - 1;
  led_hour = (hour * 10) - 1;
}

void effect_mode_1()
{  
  FastLED.clear();
  leds[led_second-2] = CHSV(color_second, 0, 20);
  leds[led_second-1] = CHSV(color_second, 0, 100);
  leds[led_second] = CHSV(color_second, 0, 255);
  leds[led_second+1] = CHSV(color_second, 0, 100);
  leds[led_second+2] = CHSV(color_second, 0, 20);

  leds[led_minute-1] = CHSV(color_minute, 255, 20);
  leds[led_minute] = CHSV(color_minute, 255, 255);
  leds[led_minute+1] = CHSV(color_minute, 255, 20);

  leds[led_hour-1] = CHSV(color_hour, 255, 20);
  leds[led_hour] = CHSV(color_hour, 255, 255);
  leds[led_hour+1] = CHSV(color_hour, 255, 20);
  
  leds[0] = CHSV(color_quater, 255, brightness_quater);
  leds[29] = CHSV(color_quater, 255, brightness_quater);
  leds[59] = CHSV(color_quater, 255, brightness_quater);
  leds[89] = CHSV(color_quater, 255, brightness_quater);
  
  FastLED.show();
}

void effect_mode_2()
{
  // Nightmode mit Helligkeitssensor
}

void setup() 
{
  Wire.begin();
  FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
  FastLED.clear();
}

void loop() 
{
  get_time();

  switch(mode)
  {
    case(1):
      effect_mode_1();
      break;
    case(2):
      effect_mode_2();
      break;
  }

  FastLED.delay(pause);
}

Leider weiß ich gar nicht wie ich das anstellen soll, da ich vom DS3231 ja nur Sekunden bekomme und keine Millisekunden.

millis() ist doch auch bei deinem Arduino dabei, oder?

Sorry, bin ganz neu im Arduino Business...

ich dachte wenn mir der DS3231 auch Millisekunden ausgeben würde, könnte ich bei jedem loop aus den Millisekunden irgendwie die Helligkeitswerte berechnen.

millis() kannte ich noch nicht, kann ich das irgendwie mit der RTC verbinden? Aber ich frage ja nur die Zeit ab, und bekomme ja keinen Interrupt, wenn "eine neue Sekunde da ist".

Hi

Du merkst Dir, wie groß millis() bei Sekundenwechsel ist (die letzten drei Stellen reichen) und hast somit die Millisekunden ab der letzten vollen Sekunde oder bis zur nächsten vollen Sekunde.

MfG

Du kannst aber feststellen, wann eine "Neue Sekunde" angebrochen ist. Dann speicherst du denn aktuellen millis() wert.

Somit kannst du jederzeit die Differenz zwischen gespeichertem und aktuellen Wert berechnen, und weißt damit wo dein Sekunden Zeiger gerade stehen muss.

Moin User77 versuche es doch aml über die PWMausgänge da die sich regeln lassen. MfG Lutz

Hi

@Crayidriver Da wir hier über WS2812 LEDs sprechen - Die bekommen drei Byte und managen die Helligkeiten der drei eigenen LEDs selber - das sind LEDs mit eigenem µC. In Deinem Bereich könntest Du so alle LEDs am Stück verkabeln und nur den einzelnen LEDs, Die sich gerade ändern sollen, andere Werte schicken (die gesamte Kette bekommt die Werte erneut übermittelt, im Arduino wird aber in einem Array nur die Änderung eingepflegt). Musst halt oft genug aktualisieren, wenn ein Blitzlicht nach 5ms wieder aus sein soll, muß nach 5ms halt die Kette aufgefrischt werden.

MfG

ich habe jetzt den 1 Herz Interrupt eingebaut und bekomme so Stunde, Minute, Sekunde und Millisekunden.

ich kann jetzt die Helligkeit über die Millisekunden steuern, aber habe noch keine Lösung wie ich einen langsamen Übergang zur nächsten LED machen kann.

zB: wenn Sekunde 33 ist, soll während dieser 1s zur Sekunde 34 die LED34 langsam hell werden, die LED33 leuchten und die LED32 langsam schwächer werden und dann wieder von vorne anfangen.

Das ist zwar etwas mit Kanonen auf Spatzen geschossen aber schaue Dir doch mal FastLED an.

Gruß Tommy

Hi

Was hindert Dich daran, binnen von 1000ms den Wert der LED 34 von 0 auf 100% anzuheben und gleichzeitig den Wert der LED 32 von 100 auf 0% abzusenken? 1000ms und 100% passen dabei auch noch echt schön zusammen.

Du musst also 'nur' schauen, wie weit die Sekunde bereits vortgeschritten ist und die LEDs 32 und 34 entsprechend in der Helligkeit anpassen. Wenn die Sekunde bereits vorbei ist (wird wohl irgendwann der Fall sein, daß Du bereits 1ms über der geforderten Zeit bist), wird die LED 32 ausgeschaltet, die LED 34 angeschaltet und der Mittelpunkt des Sekundenzeiger auf die 34 versetzt. Ab jetzt kümmerst Du Dich in der Helligkeit um die LEDs 33 und 35 (die 32 ist bereits auf Null, die 34 auf 100%). Wenn noch andere 'Zeiger' von diesen LEDs angezeigt werden sollen, musst Du Diese natürlich noch berücksichtigen.

Irgendwie bekomme ich Lust, Das auch zu proggen ... wieder eine Baustelle mehr, zu Der ich nicht komme ...

MfG

Im Thema IR Code in bestehenden Code mit Tastenabfrage integrieren ist ein Code enthalten, der sowas macht. Hinter if (coptionfade) wirst Du fündig. Mit FastLED sieht das dann so aus:

  // Sekunden
  if (coptionfade) {
    leds[pixelCheck(second + 1)] = CRGB(0, counter * 10, 0); // sekundenzeiger breite und ein und ausblenden
    leds[pixelCheck(second)] = CRGB(0, 240, 0);  // sekundenzeiger
    leds[pixelCheck(second - 1)] = CRGB(0, 240 - (counter * 10), 0); // sekundenzeiger breite und ein und ausblenden
    if (counter < 20) {
      counter++;
    }
  }
  else {
    leds[pixelCheck(second)] = CRGB(0, 240, 0);
  }

Meine Uhr mit LEDs.

ok, hatte den richtigen Ansatz, aber eine variable rücksetzten vergessen.

funktioniert jetzt!

hi,

ich hab’ vor zwei jahren oder so mal einen code für eine equinox geschrieben. ich hoffe, es war dieser, der funktioniert:

#include <FastLED.h>
#include <Wire.h> 

#define NUM_LEDS 60
struct CRGB leds[NUM_LEDS];

uint8_t h;
uint8_t m;
uint8_t s = 15;

byte sdim = 0;
byte ledmax = 200;
byte ledRest = 40;
byte mill_akt;
byte mill_alt = 39;

boolean neu = true;
               
byte ledrf[] = {53,54,55,56,57,58,59,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,
                26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,
                50,51,52,53,54,55,56,57,58,59,0,1,2,3,4};

byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}

boolean sek_sig() {
  if (digitalRead(8) == HIGH) {
    if (neu == true) {
      neu = false;
      return true;
    }
  } else {
    neu = true;
  }
  return false;
}

void holeZeit() {
  Wire.beginTransmission(0x68);
  Wire.write(byte(0));
  Wire.endTransmission(); 
  Wire.requestFrom(0x68, 7);
  s = bcdToDec(Wire.read() & 0x7f) + 2;
  m = bcdToDec(Wire.read());
  h = bcdToDec(Wire.read() & 0x3f);
  h = (h % 12)*5+int((m+5)/12);
}

void setLEDs_Dim_Blink() {
  Serial.println(s);
  memset(leds, 0, 180);
  leds[ledrf[s+5]] = CHSV(200, 255, 245 - sdim * 5);     //39
  leds[ledrf[s+4]] = CHSV(200, 255, 245 - sdim * 3);  //99
  leds[ledrf[s+3]] = CHSV(200, 255, 245 - sdim * 1); //139
  leds[ledrf[s+2]] = CHSV(200, 255, 245 - sdim * 1); //139
  leds[ledrf[s+1]] = CHSV(200, 255, 245 - sdim * 3); //99
  leds[ledrf[s  ]] = CHSV(200, 255, 245 - sdim * 5);  //0
  leds[ledrf[m+3]] = CHSV(170, 255, 80); //139
  leds[ledrf[m+4]] = CHSV(170, 255, 139); //99
  leds[ledrf[m+5]] = CHSV(170, 255, 80);  //39
  leds[ledrf[h+4]] = CHSV(150, 255, 179);  //0
  FastLED.show();
}

void setLEDs_Blink_Dim() {
  Serial.println(s);
  memset(leds, 0, 180);
  leds[ledrf[s+3]] = CHSV(200, 255, sdim * 2);     //39
  leds[ledrf[s+2]] = CHSV(200, 255, sdim * 3);  //99
  leds[ledrf[s+1]] = CHSV(200, 255, sdim * 5); //139
  leds[ledrf[s  ]] = CHSV(200, 255, sdim * 5); //139
  leds[ledrf[s-1]] = CHSV(200, 255, sdim * 3); //99
  leds[ledrf[s-2]] = CHSV(200, 255, sdim * 2);  //0
  leds[ledrf[m+1]] = CHSV(170, 255, 80); //139
  leds[ledrf[m+2]] = CHSV(170, 255, 139); //99
  leds[ledrf[m+3]] = CHSV(170, 255, 80);  //39
  leds[ledrf[h+2]] = CHSV(150, 255, 179);  //0
  FastLED.show();
}

void setLEDs_Snake() {
  Serial.println(s);
  memset(leds, 0, 180);
  leds[ledrf[s+4]] = CHSV(200, 255, 245 - sdim * 1);  //99
  leds[ledrf[s+3]] = CHSV(200, 255, 245 - sdim * 2); //139
  leds[ledrf[s+2]] = CHSV(200, 255, 245 - sdim * 3); //99
  leds[ledrf[s+1]] = CHSV(200, 255, 245 - sdim * 4);  //39
  leds[ledrf[s  ]] = CHSV(200, 255, 245 - sdim * 5);  //0
  leds[ledrf[m+1]] = CHSV(170, 255, 80); //139
  leds[ledrf[m+2]] = CHSV(170, 255, 139); //99
  leds[ledrf[m+3]] = CHSV(170, 255, 80);  //39
  leds[ledrf[h+2]] = CHSV(150, 255, 179);  //0
  FastLED.show();
}

void setLEDs() {
  leds[ledrf[m+5]] = CHSV(200, 255, ledRest);
  leds[ledrf[h+6]] = CHSV(200, 255, ledRest);
  leds[ledrf[s+7]] = CHSV(200, 255, scale8(sdim, ledmax) + ledRest);
  leds[ledrf[s+6]] = CHSV(200, 255, scale8(sdim + 49, ledmax) + ledRest);
  leds[ledrf[s+5]] = CHSV(200, 255, scale8(sdim + 98, ledmax) + ledRest);
  leds[ledrf[s+4]] = CHSV(200, 255, scale8(sdim + 147, ledmax) + ledRest);
  leds[ledrf[s+3]] = CHSV(200, 255, scale8(196 - sdim, ledmax) + ledRest);
  leds[ledrf[s+2]] = CHSV(200, 255, scale8(147 - sdim, ledmax) + ledRest);
  leds[ledrf[s+1]] = CHSV(200, 255, scale8(98 - sdim, ledmax) + ledRest);
  leds[ledrf[s  ]] = CHSV(200, 255, scale8(49 - sdim, ledmax) + ledRest);
  leds[ledrf[m+8]] = CHSV(180, 255, scale8(100, ledmax) + ledRest);
  leds[ledrf[m+7]] = CHSV(180, 255, scale8(150, ledmax) + ledRest);
  leds[ledrf[m+6]] = CHSV(180, 255, scale8(100, ledmax) + ledRest);
  leds[ledrf[h+7]] = CHSV(160, 255, scale8(150, ledmax) + ledRest);
  FastLED.show();
}

void setLEDs_Short() {
  Serial.println(s);
  memset(leds, 0, 180);
  leds[ledrf[s+5]] = CHSV(200, 255, sdim);     //39  
  leds[ledrf[s+4]] = CHSV(200, 255, sdim + 49);  //99
  leds[ledrf[s+3]] = CHSV(200, 255, sdim + 98); //139
  leds[ledrf[s+2]] = CHSV(200, 255, 147 - sdim); //99
  leds[ledrf[s+1]] = CHSV(200, 255, 98 - sdim);  //39
  leds[ledrf[s  ]] = CHSV(200, 255, 49 - sdim);  //0
  leds[ledrf[m+1]] = CHSV(170, 255, 80); //139
  leds[ledrf[m+2]] = CHSV(170, 255, 139); //99
  leds[ledrf[m+3]] = CHSV(170, 255, 80);  //39
  leds[ledrf[h+2]] = CHSV(150, 255, 179);  //0
  FastLED.show();
}

void setup() {
  FastLED.addLeds<WS2812, 12, RGB>(leds, NUM_LEDS);
  pinMode(8, INPUT);
  memset(leds, 0, 180);
  Wire.begin();
  Serial.begin(9600);
  holeZeit();
  s--;
  fill_solid( &(leds[0]), 60, CHSV( 200, 255, ledRest));
}

void loop() {
  mill_akt = millis() % 20;
  if (mill_akt < mill_alt) {
    setLEDs();
    sdim++;
    if (sdim > 49) {
      sdim = 0;
    }
  }
  mill_alt = mill_akt;
  if (sek_sig() == true) {
    s++;
    sdim = 0;
    if (s>59) {
      holeZeit();
    }
  }
}

Du kannst verschiedene setLEDs-funktionen verwenden. einfach in der loop austauschen. 330ohm widerstand zwischen arduino und data nicht vergessen.

gruß stefan

EDIT: achja, das 1Hz-signal der RTC muß eingeschaltet sein.

Es wäre schön, wenn Du Deinen funktionierenden Sketch für die Furumsuser bereitstellen könntest.

Gruß Tommy

Hi

postmaster-ino:
Irgendwie bekomme ich Lust, Das auch zu proggen … wieder eine Baustelle mehr, zu Der ich nicht komme …

Habe mir Heute Mal ‘frei’ genommen - also die normal anstehenden Tätigkeiten beiseite geschoben und versucht, den Neopixeln gedimmtes Leben einzuhauchen.
Das ist dabei heraus gekommen:

#include <Adafruit_NeoPixel.h>    //v1.1.3, aus der Bibkliotheks-Verwaltung

//Arduino MEGA2560 R3
//WS2812-LED-Platine 4x4, Reihenfolge wie folgt:
// GND  00 01 02 03 GND
// Vdd  07 06 05 04 Vdd
// DIn  08 09 10 11 Dout
// GND  15 14 13 12 GND

//Der Sketch dient nur dazu, wie man LEDs in einem WS2812-Verbund als 'Sekundenzeiger' dimmen kann
//Für eine eigene Uhr wird man sich selbst die Mühe machen müssen, Das hier an die eigenen Bedürfnisse anzupassen.

//Anzahl der verbauten WS2812, bei der 4x4-Platine dann hier 16
const uint16_t PixelCount = 16; // make sure to set this to the number of pixels in your strip

//... die Platine steckt an einem MEGA in der hinteren Sockelleiste - Näheres im Setup.
const uint8_t PixelPin = 53;  // make sure to set this to the correct pin, ignored for Esp8266

//in der hier gespeicherten Reihenfolge leuchten die LEDs nacheinander auf
//davor wird die LED herunter gedimmt, danach hochgedimmt
//bei einem Uhren-Segment (15 LED auf 90° Bogen) werden die Zahlen wohl eher 'komplett am Stück' einzutragen sein
byte ledreihenfolge[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 8, 7, 0, 1, 2, 3, 4, 11, 12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3, 4, 11, 12, 13, 10, 5, 2, 1, 6, 9, 14, 15, 8, 7};

//byte ledreihenfolge[]={0,1,2,3};

//Die Maximal-Farbe für 100% - r Rot, g Grün, b Blau - also hier den RGB-Wert der maximalen Helligkeit eintragen
const byte rmax = 255;    //Wert 0...255 bei maximaler Helligkeit
const byte gmax = 60;
const byte bmax = 55;

//Die Wartezeit zwischen zwei 'benachbarten' LED - für den Sekundenzeiger hier 1000 für 1000ms verwenden, unter 300 ist von dem Aus/Abdimmen nicht mehr viel zu sehen.
const int wartezeit = 300;   //Zeit zwischen den Einzelpixeln

//Hiermit wird die Berechnung durch Modulo begrenzt (bei 4 Elementen ergeben sich die Werte 0..1..2..3)
//Deshalb ermitteln wir hier die Anzahl der im Array eingetragenen 'Leuchtpunkte'
const byte AnzahlElemente = sizeof(ledreihenfolge) / sizeof(byte);

//Hilfsvariablen, um die vergangene Zeit mitzuhalten
long lasttime;      //Zeit, als der letzte Mittel-Pixel gewechselt wurde
long aktutime;      //aktuelle Zeit, wird im Script laufend neu auf millis() gesetzt

//mit welcher LED soll begonnen werden? Hier müssen händisch die LEDs davor/dahinter eingetragen werden
//wenn der Abstand größer als 1 ist, leuchten halt mehrere LEDs in voller Helligkeit
byte aktuelleLed = 1;
byte LED_davor = 0, LED_danach = 2;


//Den Stripe initialisieren
Adafruit_NeoPixel rgbstripe = Adafruit_NeoPixel(PixelCount, PixelPin, NEO_GRB + NEO_KHZ800);


void setup() {
  // put your setup code here, to run once:

  //für Neopixel - da ich ein fauler Hund bin, wird die WS2812-Platine direkt vom Port versorgt - nicht zur Nachahmung empfohlen, bei mir jedoch noch keinerlei Schwierigkeiten (auch bei voller Beleuchtung)
  //einzig, daß die LEDs direkt vom Port versorgt 'flimmern' - unschön, aber für 'Q&D' soll's reichen
  pinMode(49, OUTPUT);
  digitalWrite(49, LOW);
  pinMode(51, OUTPUT);
  digitalWrite(51, HIGH);
  rgbstripe.begin();          //Stripe initiieren, RAM vorbereiten
  rgbstripe.setBrightness(127);  //Helligkeit auf bestimmten Wert

  //Der Sketch soll geschwätzig sein
  Serial.begin(9600);

  //Unter Anderem, wie viel Speicher für das Array drauf gegangen ist (hatte zuvor per sizeof() die nächsten LEDs bestimmt, also eine Alt-Last)
  Serial.print ("Speicher:");
  Serial.print(sizeof(ledreihenfolge));
  Serial.print (" Platz pro Element:");
  Serial.println(sizeof(byte));

  //Das Auge will auch was davon haben - eine 'Start-Animation'
  for (int t = 0; t < 16; t++) {
    rgbstripe.setPixelColor(t, rmax, gmax, bmax);
    rgbstripe.show();
    delay(100);
  }
  for (int t = 0; t < 16; t++) {
    rgbstripe.setPixelColor(t, 0, 0, 0);
    rgbstripe.show();
    delay(100);
  }

  //damit der Start nett aussieht, werden alle LEDs von 'davor' bis 'dahinter' auf 100% gesetzt
  //im Sketch werden die 'äußeren' LEDs dann hoch/runter gedimmt
  byte x = LED_davor;
  while (x != LED_danach) {
    Serial.print ("Setze LED Nr.");
    Serial.print (x);
    Serial.println("auf 100%");
    rgbstripe.setPixelColor(ledreihenfolge[x], rmax, gmax, bmax);
    x = (x + 1) % AnzahlElemente;
  }
  //  die eingestellten Farben im Stripe anzeigen/die Daten in die WS2812 schicken
  rgbstripe.show();
  lasttime = millis();    //unsere Berechnungsgrundlage - die 'allererste' Zeit
}

void loop() {
  // put your main code here, to run repeatedly:

  //die aktuelle Zeit einlesen
  aktutime = millis();

  //die Differenz zwischen dem letzten Umsetzen der Mittel-Pixel
  int milisek = aktutime - lasttime; //ergibt irgenbdwas bis knapp über 1000, alsp die ms, seit dem letzten Pixel-Wechsel

  //wenn die bereits vergangene Wartezeit größer oder zumindest gleich der Wartezeit zwischen den Pixeln ist, werden die Nachbar-Pixel an, bzw. aus gestellt.
  if (milisek >= wartezeit) {
    //die 'Umsetz-Zeit' wird um die Wartezeit erhöht - so wird die Wartezeit immer eingehalten, auch, wenn der Script Mal irgendwo etwas langsamer war
    lasttime += wartezeit;
    //die Pixel davor/danach voll an/aus schalten
    rgbstripe.setPixelColor(ledreihenfolge[LED_danach], rmax, gmax, bmax);
    rgbstripe.setPixelColor(ledreihenfolge[LED_davor], 0, 0, 0);

    //Geschwätz
    Serial.print(milisek);
    Serial.print(" Aktuelle LED jetzt ");
    
    //hier ist auch die 'Berechnung' der nächsten aktiven LEDs zu sehen, ist aber eigentlich nur die Stelle im Array.
    aktuelleLed = (aktuelleLed + 1) % AnzahlElemente;   //wird eigentlich nicht mehr gebraucht, hatte zuvor diese LED voll gesetzt - reicht aber, daß die 'danach'-LED auf 100% gesetzt wurde, auf Diese 'gehen wir zu' - somit ist die Mitte unseres 'Sekundenzeiger' immer auf maximaler Helligkeit
    LED_davor = (LED_davor + 1) % AnzahlElemente;
    LED_danach = (LED_danach + 1) % AnzahlElemente;

    Serial.print(aktuelleLed);




    //**************************************
    //etwas Geschwätz
    Serial.print ("  Davor:");
    Serial.print(LED_davor);
    Serial.print ("  Danach:");
    Serial.println(LED_danach);

    //**********************************

  } else {
    //ansonsten, werden die Farben je nach 'Abstand' rauf/runter gedimmt, 100% entspricht der anfangs definierten Farbe
    rgbstripe.setPixelColor(ledreihenfolge[LED_danach], map(milisek, 0, wartezeit, 0, rmax), map(milisek, 0, wartezeit, 0, gmax), map(milisek, 0, wartezeit, 0, bmax));
    rgbstripe.setPixelColor(ledreihenfolge[LED_davor], rmax - map(milisek, 0, wartezeit, 0, rmax), gmax - map(milisek, 0, wartezeit, 0, gmax), bmax - map(milisek, 0, wartezeit, 0, bmax));
  }
  //Und wieder raus mit den Daten an den Stripe
  rgbstripe.show();
}

Ups - auf Posten statt Vorschau geklickt
Habe noch diverse ‘Falschzeichen’ in lesbare Schrift umgewandelt …