Maximale aantal ledstrip op Arduino One

Hoeveel ledstrips achter elkaar kan ik aansluiten op een Arduino one?

Ik kan er nu maximaal 2x5 meter achter elkaar aansluiten (leds 2811S).
het geheel heb ik voorzien van een 5v voeding die maximaal 20 Ampere levert.

Sluit ik nu de derde ledstip aan dan doet alles niets meer.
in totaal zou ik graag 20m oftewel 4 lestrips achter elkaar op aan willen sluiten .
Wie heeft hier een oplossing voor?

in iedergeval alvast bedankt ! grtzz Marco

Het geheugen van de Arduino Uno is maar beperkt en je hebt misschien meer stroom nodig.

Wat voor ledstrip is het ? hoeveel leds per meter ? Kun je een link geven naar waar je het hebt gekocht ?

Er wordt vaak een weerstand voor de veiligheid gebruikt in de datalijn naar de ledstrip en een condensator bij het begin van een ledstrip.
Verder is het nodig om vanaf de voeding draden naar de ledstrip te voeren op regelmatige afstanden voor voldoende stroom. De ledstrip zelf kan zoveel stroom niet goed doorgeven tot het eind.

Heb je een multimeter ? Dan kun je meten hoeveel de spanning is gezakt na 5 meter.

Stel je hebt WS2811 leds van maximaal 60 mA per led, 60 per meter, 20 meter totaal. Dat wordt 72 Ampère.

De Arduino Uno heeft weinig geheugen. Volgens mij zal 300 leds nog wel lukken en heel misschien 600. Bij 60 leds per meter kun je dus één ledstrip van 5 meter aansturen en heel misschien wat meer.

Voor de sketch zijn er twee libraries: de Adafruit Neopixel library of the FastLED library. Bij de FastLED library kun je aangeven wat de maximale stroom is die de totale ledstrip mag trekken, dan worden de leds gedimd als dat nodig is.

1 Like

600 leds keer 3 bytes met de standaard bibliotheken; ik denk dat @marcorens heel veel geluk moet hebben :wink:

1 Like

Als je zorgt dat elke meter er maar een voedingspunt is, dan kun je er heel veel aan elkaar hangen, want in elke led zit een signaaloppoetser voor de DATA. Echter in de arduino heb je geheugen nodig om alle data in op te slaan en te verzenden, en dat is natuurlijk beperkt, maar is afhankelijk wat je gebruikt zoals een 2560 kan veel meer dan een 328.

1 Like

Bedankt voor je reaktie.
De ledstrips zijn de ws2812 gekocht bij aliexpress. Ze hebben 60 leds per meter . 300 per strip.

@sterretje het geluk is aan mijn zijde , ik heb er 2 aan elkaar gehad en dit werkt goed op een voeding van 5 v 20a😉

Beste allen ,
Is er een arduino die dit mogelijk wel kan ? Of is het mogelijk om er 2 aan elkaar te koppelen bijvoorbeeld.

Het is mijn bedoeling dat ik er een grote cirkel van maak ( gehele plafond rond) en dat ik als ik meer kennis krijg van het programmeren, dat ik dan een soort van lichtshow maak op muziek. Vandaar zou ik het graag aan elkaar zien .

Het is voor mij allemaal nieuw , ik heb nog nooit iets gedaan met arduino maar vind het wel al beren interessant.

Als je dit werkend hebt, dan kun je misschien ook een ESP32 werkend krijgen.
Ik adviseer om geen speciaal Adafruit of Sparkfun board te gebruiken, maar het meest algemene, meest gebruikte ESP32 board: https://www.tinytronics.nl/shop/nl/development-boards/microcontroller-boards/met-wi-fi/esp32-wifi-en-bluetooth-board-cp2102.

Er is een nadeel: De ledstrip heeft een digitaal signaal van 5V nodig, en de ESP32 is een 3.3V processor die maar een signaal van 3.3V geeft. Je hebt extra hardware nodig om het signaal op te krikken.

De ESP32 is geen officieel Arduino board. Er zitten nogal wat haken en ogen aan.
Als je deze tutorials doorleest vanaf het begin, dan weet je iets over de (on)mogelijkheden van de pinnen: https://randomnerdtutorials.com/projects-esp32/

Des te langer de ledstrip, des te langer het duurt om de hele trein van signaalpulsen er naar toe te sturen. Je kunt niet hele snelle dingen doen.

Heb je wel eens van "Wokwi" gehoord ?
Je kunt online de Neopixel en FastLED libraries uitproberen met de Wokwi simulator.
Dan kun je allerlei dingen uitproberen, zoals hier: https://wokwi.com/arduino/projects/288882857041986061
De ESP32 simulatie is in ontwikkeling, misschien lukt het al om FastLED met ESP32 te simuleren.

1 Like

@Koepel super bedankt ik ga hier zeker naar kijken​:top::+1:

Kun je de sketch laten zien? Gewoon nieuwsgierig wat die allemaal doet. Ik heb een opstelling met 420 leds en in een van de sketches gebruikt die bijna 1900 bytes geheugen; dat is 420x3 plus wat het programma verder nodig heeft (RTC, seriele communicatie, ...).

Behalve voor het geheugen gebruik kan het daarom beter zijn om voor meerdere Arduinos te kiezen. Maar dan moet je wel weer een mechanisme hebben om ze op hetzelfde moment dingen te laten doen.

Voor je informatie, het verversen van de data van 1 led neemt 24 x 1,25 microseconden = 30 microseconden. Keer 300 leds op een 5 meter strip is 9 milliseconden. Twee strips in serie geeft 18 milliseconden; maar als je twee strips ieder hun eigen Arduino hebben blijft het 9 milliseconden.

1 Like

@sterretje
Volgens mij is het deze , ik heb er meerder getest en geprobeerd .

#include <Adafruit_NeoPixel.h>

// A basic everyday NeoPixel strip test program.

// NEOPIXEL BEST PRACTICES for most reliable operation:
// - Add 1000 uF CAPACITOR between NeoPixel strip's + and - connections.
// - MINIMIZE WIRING LENGTH between microcontroller board and first pixel.
// - NeoPixel strip's DATA-IN should pass through a 300-500 OHM RESISTOR.
// - AVOID connecting NeoPixels on a LIVE CIRCUIT. If you must, ALWAYS
//   connect GROUND (-) first, then +, then data.
// - When using a 3.3V microcontroller with a 5V-powered NeoPixel strip,
//   a LOGIC-LEVEL CONVERTER on the data line is STRONGLY RECOMMENDED.
// (Skipping these may work OK on your workbench but can fail in the field)

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
 #include <avr/power.h> // Required for 16 MHz Adafruit Trinket
#endif

// Which pin on the Arduino is connected to the NeoPixels?
// On a Trinket or Gemma we suggest changing this to 1:
#define LED_PIN    6

// How many NeoPixels are attached to the Arduino?
#define LED_COUNT 300

// Declare our NeoPixel strip object:
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Argument 1 = Number of pixels in NeoPixel strip
// Argument 2 = Arduino pin number (most are valid)
// Argument 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)
//   NEO_RGBW    Pixels are wired for RGBW bitstream (NeoPixel RGBW products)


// setup() function -- runs once at startup --------------------------------

void setup() {
  // These lines are specifically to support the Adafruit Trinket 5V 16 MHz.
  // Any other board, you can remove this part (but no harm leaving it):
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
  clock_prescale_set(clock_div_1);
#endif
  // END of Trinket-specific code.

  strip.begin();           // INITIALIZE NeoPixel strip object (REQUIRED)
  strip.show();            // Turn OFF all pixels ASAP
  strip.setBrightness(50); // Set BRIGHTNESS to about 1/5 (max = 255)
}


// loop() function -- runs repeatedly as long as board is on ---------------

void loop() {
  // Fill along the length of the strip in various colors...
  colorWipe(strip.Color(255,   0,   0), 50); // Red
  colorWipe(strip.Color(  0, 255,   0), 50); // Green
  colorWipe(strip.Color(  0,   0, 255), 50); // Blue

  // Do a theater marquee effect in various colors...
  theaterChase(strip.Color(127, 127, 127), 50); // White, half brightness
  theaterChase(strip.Color(127,   0,   0), 50); // Red, half brightness
  theaterChase(strip.Color(  0,   0, 127), 50); // Blue, half brightness

  rainbow(10);             // Flowing rainbow cycle along the whole strip
  theaterChaseRainbow(50); // Rainbow-enhanced theaterChase variant
}


// Some functions of our own for creating animated effects -----------------

// Fill strip pixels one after another with a color. Strip is NOT cleared
// first; anything there will be covered pixel by pixel. Pass in color
// (as a single 'packed' 32-bit value, which you can get by calling
// strip.Color(red, green, blue) as shown in the loop() function above),
// and a delay time (in milliseconds) between pixels.
void colorWipe(uint32_t color, int wait) {
  for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
    strip.setPixelColor(i, color);         //  Set pixel's color (in RAM)
    strip.show();                          //  Update strip to match
    delay(wait);                           //  Pause for a moment
  }
}

// Theater-marquee-style chasing lights. Pass in a color (32-bit value,
// a la strip.Color(r,g,b) as mentioned above), and a delay time (in ms)
// between frames.
void theaterChase(uint32_t color, int wait) {
  for(int a=0; a<10; a++) {  // Repeat 10 times...
    for(int b=0; b<3; b++) { //  'b' counts from 0 to 2...
      strip.clear();         //   Set all pixels in RAM to 0 (off)
      // 'c' counts up from 'b' to end of strip in steps of 3...
      for(int c=b; c<strip.numPixels(); c += 3) {
        strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
      }
      strip.show(); // Update strip with new contents
      delay(wait);  // Pause for a moment
    }
  }
}

// Rainbow cycle along whole strip. Pass delay time (in ms) between frames.
void rainbow(int wait) {
  // Hue of first pixel runs 5 complete loops through the color wheel.
  // Color wheel has a range of 65536 but it's OK if we roll over, so
  // just count from 0 to 5*65536. Adding 256 to firstPixelHue each time
  // means we'll make 5*65536/256 = 1280 passes through this outer loop:
  for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) {
    for(int i=0; i<strip.numPixels(); i++) { // For each pixel in strip...
      // Offset pixel hue by an amount to make one full revolution of the
      // color wheel (range of 65536) along the length of the strip
      // (strip.numPixels() steps):
      int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels());
      // strip.ColorHSV() can take 1 or 3 arguments: a hue (0 to 65535) or
      // optionally add saturation and value (brightness) (each 0 to 255).
      // Here we're using just the single-argument hue variant. The result
      // is passed through strip.gamma32() to provide 'truer' colors
      // before assigning to each pixel:
      strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue)));
    }
    strip.show(); // Update strip with new contents
    delay(wait);  // Pause for a moment
  }
}

// Rainbow-enhanced theater marquee. Pass delay time (in ms) between frames.
void theaterChaseRainbow(int wait) {
  int firstPixelHue = 0;     // First pixel starts at red (hue 0)
  for(int a=0; a<30; a++) {  // Repeat 30 times...
    for(int b=0; b<3; b++) { //  'b' counts from 0 to 2...
      strip.clear();         //   Set all pixels in RAM to 0 (off)
      // 'c' counts up from 'b' to end of strip in increments of 3...
      for(int c=b; c<strip.numPixels(); c += 3) {
        // hue of pixel 'c' is offset by an amount to make one full
        // revolution of the color wheel (range 65536) along the length
        // of the strip (strip.numPixels() steps):
        int      hue   = firstPixelHue + c * 65536L / strip.numPixels();
        uint32_t color = strip.gamma32(strip.ColorHSV(hue)); // hue -> RGB
        strip.setPixelColor(c, color); // Set pixel 'c' to value 'color'
      }
      strip.show();                // Update strip with new contents
      delay(wait);                 // Pause for a moment
      firstPixelHue += 65536 / 90; // One cycle of color wheel over 90 frames
    }
  }
}

even een foutje van mijn kant recht zetten ,
De ledsstrip die ik gebruik is niet de WS2812 maar de WS2811.

omdat ik er een grote cirkel van wil maken en op de muziek straks wil gaan programeren , mag het wel uit 2 delen bestaan maar het moet wel tegelijk werken en met elkaar werken .

Ik heb nog een arduino one tot mijn beschikking mischien dat er iemand is die weet hoe ik deze samen kan laten werken ?

om een indruk te geven wat uiteindelijk mijn doel is om te maken , hierbij de link.

Nu meende ik gelezen te hebben dat je het over muziek had maar het blijkt een opname van een marteling of iets dergelijks te zijn ........ (niet serieus bedoelt hoor)

Zou dat, wat jij wil, mogelijk zijn met heel veel pca9685 modules?

1 Like

Het getoonde programma heeft slechts300 leds :wink:

Als je de NeoPixel bibliotheek gebruikt, geeft de IDE niet het echte gebruik van het RAM geheugen weer omdat er gebruikt wordt gemaakt van dynamische geheugen reservering (malloc()).

1 Like

@Frits1956 je hebt wel gelijk dat het geen muziek is , verre van dat zelfs . maar ik vind het wel mooi gemaakt en werkt precies op het ritme/melodie van deze muziek .

Dit zou ik dus graag willen maken op de goede muziek :wink:

maar ben nog steeds niet tot een oplossing gekomen om 20m ledstrips (WS2811) aan elkaar op de muziek te laten werken.

tevens weet ik ook niet hoe ze in het filmpje dit voor elkaar gekregen hebben .
Ze hebben het steeds over een picture daar zou de arduino mee overweg kunnen .

Mij zegt dit als newby niet zoveel misschien dat er iemand hier meer kaas van gegeten heeft.
en er misschien iemand is die mij een uitleg kan en wil geven hoe dit werkt.

het zou geweldig zijn als dit voor mijn muziek mogelijk zou zijn .
alvast bedankt voor het meedenken .

grts marco

@sterretje , scherp en goed opgelet ! maar ik heb de leds op 600 gezet en dit ging nog goed. :hugs:

Ik doe normaliter geen YouTubes maar heb even het filmpje bekeken.

Je kunt overwegen om de 4 strips in parallel te gebruiken; ze zullen dan alle vier hetzelfde patroon tonen maar dat is mogelijk geen probleem.

1 Like

Zou het mogelijk zijn om esp32 te gebruiken en dan alleen de data lijn te gebruiken en de voeding van de ledstrip gewoon 5v te gebruiken . Misschien simpel en eenvoudig gedacht maar moet ergens beginnen. :yum:

Dat is dus altijd not 50 Hz. Dat is in elk geval nog niet schokkerig.

Beste Allen,

Iemand enig idee hoelang de datakabel maximaal mag zijn vanaf de arduino tot aan de ledstrip?
Of is er een oplossing om toch een lange datakabel te kunnen monteren . ik denk dan aan iets wat de data zou kunnen versterken . (als dat uberhaupt bestaat)

grt Marco