Hi Pierre,

Did you mean to post this in Dutch or did you by accident end up on the Dutch forum?
(this forum is intended for those speaking Dutch, if you'd like to write in English, then please consider using the English Arduino forum instead)

Coming back to your question:

If In understand your message right: All LEDs to white, turns black after 10 minutes, even with a 10A power supply.

135 LEDs would pull, at max, around 8A (135 x 60 ma = 8.1 A), so a 10A power supply should pull that off just fine.
So either the power supply isn't really consistently providing at least 8.1A, or the LED strip may be getting hot (just guessing here)?

What happens if you only set half the LEDs to white? And how about 3/4 of the LEDs? etc.
Or what happens when using all LEDs and setting white to 250,250,250 ...?
Do you have an alternative 8A power supply to test with?

Please feel free to respond in Dutch, if you're a Dutch speaking person.
Otherwise please open a new topic in the English forum 😊 

Dag Hans,

Er was bij mij een kleine verwarring, Nederlands of Engels.

Heb geen 5V 8A maar wel getest met 5V 10A, in kleur werkt 5V 5A zonder probleem.

Kan niet zien hoe de settings van de lichtsterkte zijn, veronderstel dat dit dan 250,250,250 is.

Het komt wel van uw allereerste programma "AllLEDEffects-NeoPixel.

Zelfde programma maar in kleur werkt wel perfect.

Geen probleem 😉 

Normaal is wit 255,255,255. Met 250,250,250 bedoel ik een stapje lager in helderheid.

Ik neem aan dat je deze AllLedEffects bedoelde?
Ik weet alleen zo 1-2-3 niet waar je de kleur op wit zet.

Als alles met kleuren wel werkt, dan klinkt het alsof de voeding het niet aan kan als je alles op wit zet.
Alles with (255 voor R, G en B) is de maximale belasting, en dat is 3 x 20 mA per LED blokje, dus x 135 = 8,1 A.
Maar dat wist je al.

Bij kleur is die belasting duidelijk lager - ik volg zelf de vuistregel dat de voeding dan tussen de 20mA en 40mA (ipv 60 mA) per LED blokje berekend wordt. Blijkbaar werkt dat in jouw geval dus niet, zelfs niet met een 10A voeding.

Vandaar mijn gedachten:

1. De 10A voeding is niet echt in staat om 8A te leveren (vreemd genoeg natuurlijk),
2. De LEDs oververhitten door de hogere belasting (met name de eerste paar in de strip).

Als experiment kun je ook proberen om de + en de - aan beide uiteinden van de strip aan te sluiten. Niet meteen een oplossing voor jouw situatie, maar misschien helpt het (ik had dit nodig als alle LEDs op wit stonden, waarbij aan het einde van de strip de LEDs minder wit werden).

Dag Hans,

De leds aansluiten op het eind, dat zal nu niet meer lukken, zit verwerkt in een isomo spook; heeft bovendien zes knoppen met elk een specifiek programma.

Het eigenaardige is dat het twee jaar terug en vorig jaar nog geen probleem gaf.

Dus zal ik ofwel dat programma vergeten of kan ook proberen met een nieuwe chip atmega 328 te branden en plaatsen.

Toch bedankt om even mee te denken.

Als het voorgaande jaren wel goed werkte, dan is dit inderdaad een minder fijne verrassing.

Weet je waar je in de code je de kleur op wit zet? (post evt. de code hier)

Dit is de originele code waar de gebruikte onderdelen in de kleur wit zijn gezet.

#include

#define PIN 6
#define NUM_LEDS 132
// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
// NEO_KHZ800 800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
// NEO_KHZ400 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
// NEO_GRB Pixels are wired for GRB bitstream (most NeoPixel products)
// NEO_RGB Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

//  REPLACE FROM HERE 
void loop() {
  // ---> here we call the effect function <---

  // RGBLoop();

  FadeInOut(0xff, 0xff, 0xff); // white
  FadeInOut(0xff, 0xff, 0xff); // white
  FadeInOut(0xff, 0xff, 0xff); // white

  Slower:
    Strobe(0xff, 0xff, 0xff, 10, 100, 1000);
  Strobe(0xff, 0xff, 0xff, 10, 100, 1000);
  Fast:
    Strobe(0xff, 0xff, 0xff, 10, 50, 1000);

  // Fixed:
  // HalloweenEyes(0xff, 0x00, 0x00, 1,4, true, 10, 80, 3000);
  // or Random:
  // HalloweenEyes(0xff, 0x00, 0x00,
  // 1, 4,
  // true, random(5,50), random(50,150),
  // random(1000, 10000));

  // CylonBounce(0xff, 0, 0, 4, 10, 50);

  NewKITT(0xff, 0xff, 0xff, 8, 10, 50);

  // Twinkle(0xff, 0, 0, 10, 100, false);

  // TwinkleRandom(20, 100, false);

  Sparkle(0xff, 0xff, 0xff, 0);

  // SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));

  // RunningLights(0xff,0,0, 50); // red
  RunningLights(0xff, 0xff, 0xff, 50); // white
  RunningLights(0xff, 0xff, 0xff, 50); // white
  // RunningLights(0,0,0xff, 50); // blue
  // RunningLights(0xff,0xff,0x00, 50);

  colorWipe(0xff, 0xff, 0xff, 50);
  // colorWipe(0x00,0x00,0x00, 50);

  // rainbowCycle(20);

  theaterChase(0xff, 0xff, 0xff, 50);
  theaterChase(0xff, 0xff, 0xff, 50);

  // theaterChaseRainbow(50);

  // Fire(55,120,15);

  // BouncingBalls(0xff,0,0, 3);

  // byte colors[3][3] = { {0xff, 0,0},
  // {0xff, 0xff, 0xff},
  // {0 , 0 , 0xff} };
  // BouncingColoredBalls(3, colors);
}

// ---> here we define the effect function <---
//  REPLACE TO HERE 

void showStrip() {
  #ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip.show();
  #endif
  #ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  FastLED.show();
  #endif
}

void setPixel(int Pixel, byte red, byte green, byte blue) {
  #ifdef ADAFRUIT_NEOPIXEL_H
  // NeoPixel
  strip.setPixelColor(Pixel, strip.Color(red, green, blue));
  #endif
  #ifndef ADAFRUIT_NEOPIXEL_H
  // FastLED
  leds[Pixel].r = red;
  leds[Pixel].g = green;
  leds[Pixel].b = blue;
  #endif
}

void setAll(byte red, byte green, byte blue) {
  for (int i = 0; i < NUM_LEDS; i++) {
    setPixel(i, red, green, blue);
  }
  showStrip();
}

void RGBLoop() {
  for (int j = 0; j < 3; j++) {
    // Fade IN
    for (int k = 0; k < 256; k++) {
      switch (j) {
      case 0:
        setAll(k, 0, 0);
        break;
      case 1:
        setAll(0, k, 0);
        break;
      case 2:
        setAll(0, 0, k);
        break;
      }
      showStrip();
      delay(3);
    }
    // Fade OUT
    for (int k = 255; k >= 0; k--) {
      switch (j) {
      case 0:
        setAll(k, 0, 0);
        break;
      case 1:
        setAll(0, k, 0);
        break;
      case 2:
        setAll(0, 0, k);
        break;
      }
      showStrip();
      delay(3);
    }
  }
}

void FadeInOut(byte red, byte green, byte blue) {
  float r, g, b;

  for (int k = 0; k < 256; k = k + 1) {
    r = (k / 256.0) * red;
    g = (k / 256.0) * green;
    b = (k / 256.0) * blue;
    setAll(r, g, b);
    showStrip();
  }

  for (int k = 255; k >= 0; k = k - 2) {
    r = (k / 256.0) * red;
    g = (k / 256.0) * green;
    b = (k / 256.0) * blue;
    setAll(r, g, b);
    showStrip();
  }
}

void Strobe(byte red, byte green, byte blue, int StrobeCount, int FlashDelay, int EndPause) {
  for (int j = 0; j < StrobeCount; j++) {
    setAll(red, green, blue);
    showStrip();
    delay(FlashDelay);
    setAll(0, 0, 0);
    showStrip();
    delay(FlashDelay);
  }

  delay(EndPause);
}

void HalloweenEyes(byte red, byte green, byte blue,
  int EyeWidth, int EyeSpace,
  boolean Fade, int Steps, int FadeDelay,
  int EndPause) {
  randomSeed(analogRead(0));

  int i;
  int StartPoint = random(0, NUM_LEDS - (2 * EyeWidth) - EyeSpace);
  int Start2ndEye = StartPoint + EyeWidth + EyeSpace;

  for (i = 0; i < EyeWidth; i++) {
    setPixel(StartPoint + i, red, green, blue);
    setPixel(Start2ndEye + i, red, green, blue);
  }

  showStrip();

  if (Fade == true) {
    float r, g, b;

    for (int j = Steps; j >= 0; j--) {
      r = j * (red / Steps);
      g = j * (green / Steps);
      b = j * (blue / Steps);

      for (i = 0; i < EyeWidth; i++) {
        setPixel(StartPoint + i, r, g, b);
        setPixel(Start2ndEye + i, r, g, b);
      }

      showStrip();
      delay(FadeDelay);
    }
  }

  setAll(0, 0, 0); // Set all black

  delay(EndPause);
}

void CylonBounce(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {

  for (int i = 0; i < NUM_LEDS - EyeSize - 2; i++) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }

  delay(ReturnDelay);

  for (int i = NUM_LEDS - EyeSize - 2; i > 0; i--) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }

  delay(ReturnDelay);
}

void NewKITT(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  LeftToRight(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  RightToLeft(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  OutsideToCenter(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
  CenterToOutside(red, green, blue, EyeSize, SpeedDelay, ReturnDelay);
}

void CenterToOutside(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = ((NUM_LEDS - EyeSize) / 2); i >= 0; i--) {
    setAll(0, 0, 0);

    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);

    setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS - i - j, red, green, blue);
    }
    setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10);

    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void OutsideToCenter(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = 0; i <= ((NUM_LEDS - EyeSize) / 2); i++) {
    setAll(0, 0, 0);

    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);

    setPixel(NUM_LEDS - i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(NUM_LEDS - i - j, red, green, blue);
    }
    setPixel(NUM_LEDS - i - EyeSize - 1, red / 10, green / 10, blue / 10);

    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void LeftToRight(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = 0; i < NUM_LEDS - EyeSize - 2; i++) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void RightToLeft(byte red, byte green, byte blue, int EyeSize, int SpeedDelay, int ReturnDelay) {
  for (int i = NUM_LEDS - EyeSize - 2; i > 0; i--) {
    setAll(0, 0, 0);
    setPixel(i, red / 10, green / 10, blue / 10);
    for (int j = 1; j <= EyeSize; j++) {
      setPixel(i + j, red, green, blue);
    }
    setPixel(i + EyeSize + 1, red / 10, green / 10, blue / 10);
    showStrip();
    delay(SpeedDelay);
  }
  delay(ReturnDelay);
}

void Twinkle(byte red, byte green, byte blue, int Count, int SpeedDelay, boolean OnlyOne) {
  setAll(0, 0, 0);

  for (int i = 0; i < Count; i++) {
    setPixel(random(NUM_LEDS), red, green, blue);
    showStrip();
    delay(SpeedDelay);
    if (OnlyOne) {
      setAll(0, 0, 0);
    }
  }

  delay(SpeedDelay);
}

void TwinkleRandom(int Count, int SpeedDelay, boolean OnlyOne) {
  setAll(0, 0, 0);

  for (int i = 0; i < Count; i++) {
    setPixel(random(NUM_LEDS), random(0, 255), random(0, 255), random(0, 255));
    showStrip();
    delay(SpeedDelay);
    if (OnlyOne) {
      setAll(0, 0, 0);
    }
  }

  delay(SpeedDelay);
}

void Sparkle(byte red, byte green, byte blue, int SpeedDelay) {
  int Pixel = random(NUM_LEDS);
  setPixel(Pixel, red, green, blue);
  showStrip();
  delay(SpeedDelay);
  setPixel(Pixel, 0, 0, 0);
}

void SnowSparkle(byte red, byte green, byte blue, int SparkleDelay, int SpeedDelay) {
  setAll(red, green, blue);

  int Pixel = random(NUM_LEDS);
  setPixel(Pixel, 0xff, 0xff, 0xff);
  showStrip();
  delay(SparkleDelay);
  setPixel(Pixel, red, green, blue);
  showStrip();
  delay(SpeedDelay);
}

void RunningLights(byte red, byte green, byte blue, int WaveDelay) {
  int Position = 0;

  for (int i = 0; i < NUM_LEDS * 2; i++) {
    Position++; // = 0; //Position + Rate;
    for (int i = 0; i < NUM_LEDS; i++) {
      // sine wave, 3 offset waves make a rainbow!
      //float level = sin(i+Position) * 127 + 128;
      //setPixel(i,level,0,0);
      //float level = sin(i+Position) * 127 + 128;
      setPixel(i, ((sin(i + Position) * 127 + 128) / 255) * red,
        ((sin(i + Position) * 127 + 128) / 255) * green,
        ((sin(i + Position) * 127 + 128) / 255) * blue);
    }

    showStrip();
    delay(WaveDelay);
  }
}

void colorWipe(byte red, byte green, byte blue, int SpeedDelay) {
  for (uint16_t i = 0; i < NUM_LEDS; i++) {
    setPixel(i, red, green, blue);
    showStrip();
    delay(SpeedDelay);
  }
}

void rainbowCycle(int SpeedDelay) {
  byte * c;
  uint16_t i, j;

  for (j = 0; j < 256 * 5; j++) { // 5 cycles of all colors on wheel
    for (i = 0; i < NUM_LEDS; i++) {
      c = Wheel(((i * 256 / NUM_LEDS) + j) & 255);
      setPixel(i, * c, *(c + 1), *(c + 2));
    }
    showStrip();
    delay(SpeedDelay);
  }
}

byte * Wheel(byte WheelPos) {
  static byte c[3];

  if (WheelPos < 85) {
    c[0] = WheelPos * 3;
    c[1] = 255 - WheelPos * 3;
    c[2] = 0;
  } else if (WheelPos < 170) {
    WheelPos -= 85;
    c[0] = 255 - WheelPos * 3;
    c[1] = 0;
    c[2] = WheelPos * 3;
  } else {
    WheelPos -= 170;
    c[0] = 0;
    c[1] = WheelPos * 3;
    c[2] = 255 - WheelPos * 3;
  }

  return c;
}

void theaterChase(byte red, byte green, byte blue, int SpeedDelay) {
  for (int j = 0; j < 10; j++) { //do 10 cycles of chasing
    for (int q = 0; q < 3; q++) {
      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        setPixel(i + q, red, green, blue); //turn every third pixel on
      }
      showStrip();

      delay(SpeedDelay);

      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        setPixel(i + q, 0, 0, 0); //turn every third pixel off
      }
    }
  }
}

void theaterChaseRainbow(int SpeedDelay) {
  byte * c;

  for (int j = 0; j < 256; j++) { // cycle all 256 colors in the wheel
    for (int q = 0; q < 3; q++) {
      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        c = Wheel((i + j) % 255);
        setPixel(i + q, * c, *(c + 1), *(c + 2)); //turn every third pixel on
      }
      showStrip();

      delay(SpeedDelay);

      for (int i = 0; i < NUM_LEDS; i = i + 3) {
        setPixel(i + q, 0, 0, 0); //turn every third pixel off
      }
    }
  }
}

void Fire(int Cooling, int Sparking, int SpeedDelay) {
  static byte heat[NUM_LEDS];
  int cooldown;

  // Step 1. Cool down every cell a little
  for (int i = 0; i < NUM_LEDS; i++) {
    cooldown = random(0, ((Cooling * 10) / NUM_LEDS) + 2);

    if (cooldown > heat[i]) {
      heat[i] = 0;
    } else {
      heat[i] = heat[i] - cooldown;
    }
  }

  // Step 2. Heat from each cell drifts 'up' and diffuses a little
  for (int k = NUM_LEDS - 1; k >= 2; k--) {
    heat[k] = (heat[k - 1] + heat[k - 2] + heat[k - 2]) / 3;
  }

  // Step 3. Randomly ignite new 'sparks' near the bottom
  if (random(255) < Sparking) {
    int y = random(7);
    heat[y] = heat[y] + random(160, 255);
    //heat[y] = random(160,255);
  }

  // Step 4. Convert heat to LED colors
  for (int j = 0; j < NUM_LEDS; j++) {
    setPixelHeatColor(j, heat[j]);
  }

  showStrip();
  delay(SpeedDelay);
}

void setPixelHeatColor(int Pixel, byte temperature) {
  // Scale 'heat' down from 0-255 to 0-191
  byte t192 = round((temperature / 255.0) * 191);

  // calculate ramp up from
  byte heatramp = t192 & 0x3F; // 0..63
  heatramp <<= 2; // scale up to 0..252 // figure out which third of the spectrum we're in:
  if (t192 > 0x80) { // hottest
    setPixel(Pixel, 255, 255, heatramp);
  } else if (t192 > 0x40) { // middle
    setPixel(Pixel, 255, heatramp, 0);
  } else { // coolest
    setPixel(Pixel, heatramp, 0, 0);
  }
}

void BouncingBalls(byte red, byte green, byte blue, int BallCount) {
  float Gravity = -9.81;
  int StartHeight = 1;

  float Height[BallCount];
  float ImpactVelocityStart = sqrt(-2 * Gravity * StartHeight);
  float ImpactVelocity[BallCount];
  float TimeSinceLastBounce[BallCount];
  int Position[BallCount];
  long ClockTimeSinceLastBounce[BallCount];
  float Dampening[BallCount];

  for (int i = 0; i < BallCount; i++) {
    ClockTimeSinceLastBounce[i] = millis();
    Height[i] = StartHeight;
    Position[i] = 0;
    ImpactVelocity[i] = ImpactVelocityStart;
    TimeSinceLastBounce[i] = 0;
    Dampening[i] = 0.90 - float(i) / pow(BallCount, 2);
  }

  while (true) {
    for (int i = 0; i < BallCount; i++) {
      TimeSinceLastBounce[i] = millis() - ClockTimeSinceLastBounce[i];
      Height[i] = 0.5 * Gravity * pow(TimeSinceLastBounce[i] / 1000, 2.0) + ImpactVelocity[i] * TimeSinceLastBounce[i] / 1000;

      if (Height[i] < 0) {
        Height[i] = 0;
        ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];
        ClockTimeSinceLastBounce[i] = millis();

        if (ImpactVelocity[i] < 0.01) {
          ImpactVelocity[i] = ImpactVelocityStart;
        }
      }
      Position[i] = round(Height[i] * (NUM_LEDS - 1) / StartHeight);
    }

    for (int i = 0; i < BallCount; i++) {
      setPixel(Position[i], red, green, blue);
    }

    showStrip();
    setAll(0, 0, 0);
  }
}

void BouncingColoredBalls(int BallCount, byte colors[][3]) {
  float Gravity = -9.81;
  int StartHeight = 1;

  float Height[BallCount];
  float ImpactVelocityStart = sqrt(-2 * Gravity * StartHeight);
  float ImpactVelocity[BallCount];
  float TimeSinceLastBounce[BallCount];
  int Position[BallCount];
  long ClockTimeSinceLastBounce[BallCount];
  float Dampening[BallCount];

  for (int i = 0; i < BallCount; i++) {
    ClockTimeSinceLastBounce[i] = millis();
    Height[i] = StartHeight;
    Position[i] = 0;
    ImpactVelocity[i] = ImpactVelocityStart;
    TimeSinceLastBounce[i] = 0;
    Dampening[i] = 0.90 - float(i) / pow(BallCount, 2);
  }

  while (true) {
    for (int i = 0; i < BallCount; i++) {
      TimeSinceLastBounce[i] = millis() - ClockTimeSinceLastBounce[i];
      Height[i] = 0.5 * Gravity * pow(TimeSinceLastBounce[i] / 1000, 2.0) + ImpactVelocity[i] * TimeSinceLastBounce[i] / 1000;

      if (Height[i] < 0) {
        Height[i] = 0;
        ImpactVelocity[i] = Dampening[i] * ImpactVelocity[i];
        ClockTimeSinceLastBounce[i] = millis();

        if (ImpactVelocity[i] < 0.01) {
          ImpactVelocity[i] = ImpactVelocityStart;
        }
      }
      Position[i] = round(Height[i] * (NUM_LEDS - 1) / StartHeight);
    }

    for (int i = 0; i < BallCount; i++) {
      setPixel(Position[i], colors[i][0], colors[i][1], colors[i][2]);
    }

    showStrip();
    setAll(0, 0, 0);
  }
}

Je zou kunnen proberen elke waar "0xFF" (255) te vervangen door b.v. "0xF0" (240) in de "loop()" functie.
Je mag 0xFF ook vervangen door normale decimale nummers, dus alle 0xFF door 255 vervangen (of een lager nummer voor het doel van ons experiment).

Dus bijvoorbeeld (de rest van de code ervoor en erna, blijft natuurlijk hetzelfde):

void loop() {
  // ---> here we call the effect function <---

  // RGBLoop();

  FadeInOut(240, 240, 240); // white
  FadeInOut(240, 240, 240); // white
  FadeInOut(240, 240, 240); // white

  Slower:
    Strobe(240, 240, 240, 10, 100, 1000);
  Strobe(240, 240, 240, 10, 100, 1000);
  Fast:
    Strobe(240, 240, 240, 10, 50, 1000);

  // Fixed:
  // HalloweenEyes(240, 0x00, 0x00, 1,4, true, 10, 80, 3000);
  // or Random:
  // HalloweenEyes(240, 0x00, 0x00,
  // 1, 4,
  // true, random(5,50), random(50,150),
  // random(1000, 10000));

  // CylonBounce(240, 0, 0, 4, 10, 50);

  NewKITT(240, 240, 240, 8, 10, 50);

  // Twinkle(240, 0, 0, 10, 100, false);

  // TwinkleRandom(20, 100, false);

  Sparkle(240, 240, 240, 0);

  // SnowSparkle(0x10, 0x10, 0x10, 20, random(100,1000));

  // RunningLights(240,0,0, 50); // red
  RunningLights(240, 240, 240, 50); // white
  RunningLights(240, 240, 240, 50); // white
  // RunningLights(0,0,240, 50); // blue
  // RunningLights(240,240,0x00, 50);

  colorWipe(240, 240, 240, 50);
  // colorWipe(0x00,0x00,0x00, 50);

  // rainbowCycle(20);

  theaterChase(240, 240, 240, 50);
  theaterChase(240, 240, 240, 50);

  // theaterChaseRainbow(50);

  // Fire(55,120,15);

  // BouncingBalls(240,0,0, 3);

  // byte colors[3][3] = { {240, 0,0},
  // {240, 240, 240},
  // {0 , 0 , 240} };
  // BouncingColoredBalls(3, colors);
}

Dit ga ik zo snel mogelijk uit testen.

Maar ga naar iets gaan van 210 als getal, dit omdat ik het zou willen laten werken op 5V 5A.

Denk dat dit iets meer ruimte zal geven.

Laat zeer snel reactie hoe het loopt.

Alvast bedankt voor de moeite om er toch opnieuw een goed resultaat van te verkrijgen.

Oh je kunt zeker met de getallen experimenteren en misschien zelfs met 5A uit de voeten ... 
Ik ben benieuwd! 😊 

Dag Hans,

Het is terug in orde, met het plaatsen van alles op 210, werkt het terug op 5A.

Hartelijk bedank voor uw gouden tip.

Mooi om te horen Pierre! Ik ben blij dat het werkt 😊 

Merk op:
Dat wil dan wel zeggen dat jouw 10A voeding waarschijnlijk niet langdurig 8A kan leveren 😞 

Nee, het probleem zit blijkbaar in de installatie. De LEDs zitten ingesloten en kunnen de warmte niet voldoende kwijtraken.

Met ingesloten bedoel ik isomo (foam) van 5 cm dik, in het midden op 1 cm breed en 1 cm diep uitgehaald, LEDstrip er in en dan een strook isomo er over en gelijmd met TEC 7 aan de zijkanten.

Bij de 10A is dat iets erger, dus nog iets grotere warmte die blijft hangen.

De 5V 10A heb ik in andere projecten en die kunnen 24 op 24 hun volle kracht geven, had ik eerst al met testbestelling gecontroleerd..

Posted by: @pierre

De LEDs zitten ingesloten en kunnen de warmte niet voldoende kwijtraken

Dat zou inderdaad ook een erg goede reden kunnen zijn 😊 
Ik was niet bekend met Isomo ... sorry 😊 

Heb een bericht met link verwijderd. Is een link waar je het effect kan zien met LEDS in isomo

Wil de link wel geven maar verknipt: 'youtu.be' dan "/0Nl4uaJ6JzY".