Arduino and WS2812 LEDs

Thanks Thomas!

ADAFruit and others recommend this to “dampen” spikes on the data pin … in my [limited] experience with electronics, I would have grabbed a capacitor for that, but they recommend a resistor.

In my experience: the setup works just fine with the resistor – I have yet to blow up my Arduino  …

hans

Hello-

  I just wanted to tell you how much I enjoyed this write up !  Why?  The graphics are top notch but now I’ll say what impressed me s much.  You style of writing is without a doubt-one of the best I have read.   You writing is lucid, informative, succinct, and explicit.  This is-in my opinion-something very rare, especially as it relates to informing someone about a technical subject!  Any fool can complicate a subject!  Rare is the person who can take a fairly complex subject, and make it simple to understand.

Well done!!

Cappy Anderson

Adafruit_NeoPixel şerit = Adafruit_NeoPixel (60, PIN, NEO_GRB + NEO_KHZ800);        

Benim ilk uno lütfen çok acil 1 mega-2 nano-LED çalışmıyor ws2811

canufuk

salute me

1uno

2 nano

1meg to

does not work in there, but none

ws2811 LED strips and mushrooms in 2811

please help

Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800); 

Thank you in advance stays here

canufuk

Thanks Showtime 

I very much appreciate the positive feedback. 

hans

Hi Dave,

I haven’t had time yet to start that part of the project and I ran into one problem being that one of the strips I ordered was failing.
However … I do plan to start this project! I’ll post a comment here once I’ve completed the project (I’ll be posting an article about it as well).

hans

I’m not able to look into this right now (hopefully soon!) but as far as I recall you’ll need to configure the boblight plugin for XBMC to talk “properly” to your Arduino.

On this (Russian) page, a guy used a WS2812 like that: http://habrahabr.ru/post/200200/ (not sure if Google Translate works this way, but here is the translated link). I also found some Arduino code at PasteBin for this purpose.

I’m sorry I haven’t gotten to this little project yet – I’m trying to finish up another project before starting a new one.

hans

Awesome Dave! Glad you got it to work! 

I’m still stuck in the “build a bracket” phase. My TV is 80″, so I need a rather big bracket and I haven’t been able to find materials for that (looking at local stores). I’ve been thinking about using aluminium square tubes or maybe something useful I can find in the local hardware store (my initial ideal was using a sheet of plexiglass with openings cut into it – until I found out how expensive plexiglass can be).

One of the strips I have fails after LED number 20, probably a minor issue (poor connection or dead chip), which I’ve figured a purpose for already. At the bottom of my TV, I wouldn’t need the full width anyway, so I could cut this strip in 2 parts. Sounds like you’re running in a similar issue. Although mine came in 5x 1 meter strips. You can could the strips, as long as you reconnect +5V, GND and Din from one strip to another.

Maybe these strips are designed to be 1 meter? Can you see anything that suggest this?

I did see at AdaFruit that they recommend having power fed to the strips in between (as shown in this article or this picture) – unlike the Russian website that suggests using thick wires between the strips.

hans

What kind of XBMC setup are you running? (ie. Windows, Mac, Linux, OpenElec, RaspBMC, etc)
I read in an article about a possible delay issue with OpenElec, so I was just wondering if I’d had to switch to another XBMC distro (using OpenElec right now).

hans

Well, I made some progress … I did build a nice aluminium frame (used countertop trims/edging), and installed the LED strips.
I used the test program (above) to make sure all LEDs worked OK, and found only one that was dead.
I fixed that by bypassing the LED (Shortcut Din and Dout of the LED). So the above demo works great.

Now I’m kind-a stuck in getting XBMC to talk to the Arduino … did you use the Sketch of the Russian website?
(I did recreate the config file with a script I found here)

I’m sure the Sketch of AdaFruit is not going to work, since it expects a WS2801 instead of the WS2811/WS2812.

hans

Hi Melissa,

Thanks for the compliment and thanks for visiting!

Hope that clarifies it a little bit 

hans

My apologies …

In this article I used a simple 2A 5V power supply, an Arduino Uno R3 and a strip of WS2812 LEDs.

hans

For a simple project like this one: Yes, I would assume so.

Maybe it’s easier to look at this comparison of the different models, there is for example a Nano with the same ATMega328 …

hans

That sounds right – it’s actually what I use.

I have 5 meter, with 60 LEDs per meter, and I bought a 5V 10A Powerbrick on Ebay. Has been working very well for quite a while now … 

hans

Awesome! 

I think my preferences would go towards NeoPixel (as you can see in my BobLight project).
But to be honest, FastLED is most certainly very good as well and the difference in programming might make you chose (it did for me).

hans

Hi Seyhun! 

Glad it works, but I’m not sure what you mean with little delays?

hans

I read on adafruit you have to use GRB instead. Switch that and it should work.

Nick

Switching the colors appears to be relatively common, even though I have yet to run into that situation.

I have read somewhere, but I could be wrong, that you can use CGRB instead of CRGB – might want to give that a try. Some LED types have Green and Red swapped like you described (manufacturer specific it seems). 

hans

Hi Nick!

Well, when I look at using the LEDs for Boblight, I see that every Boblight variant has a gamma correction option, and I suppose that exists for a very good reason. If banana yellow becomes almost white, then I suppose gamma correction must be applied.

Some reads I found:

– Wiki Gamma Correction (very theoretical – so I’m not sure how useful it will be for you)
– Image Processing Algorithms Part 6 – Gamma Correction (pretty good article!)
– Stackoverflow – How to process gamma correction if having RGB data (short and sweet!)

Hope this helps you on your way. 

hans

Awesome!  

Thanks Nick for posting it here as well!

hans

Looks like we were using an older LUT that doesn’t allow for the full range of the new neopixel strips. This is the LUT that should be used so there is full 255 range. An adafruit admin gave me this information in a separate post.

uint8_t gamma[] PROGMEM = {

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,

    1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2,

    2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5,

    5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10,

   10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,

   17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,

   25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,

   37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,

   51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,

   69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,

   90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,

  115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,

  144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,

  177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,

  215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };

Since the table is in PROGMEM, the adafruit admin says you need to use pgm_read_byte() to fetch elements, e.g.:

CODE: SELECT ALL | TOGGLE FULL SIZE

bar = pgm_read_byte(&gamma[foo]);

Where ‘foo’ is the original (un-corrected) brightness (0-255) and ‘bar’ is the gamma-corrected result (also 0-255).

Nick

Thanks Mat13! Always great to hear positive feedback, and I’m glad the article was helpful to you! 

hans

I’m not familiar with this little guy, but by the info in the pictures I’d be inclined to say Yes.

hans

Hello Claire! 

I’m assuming you mean something like a “running” light?
Well, either way: You’d have to do a little programming.

The following examples use “Adafruit_NeoPixel“.

To set a LED color, set LED 10 to red for example:

c = strip.Color(255, 0, 0);  // define the variable c as RED (R,G,B)
strip.setPixelColor(10, c);  // set LED 10 to the color in variable c (red)
strip.show();  

To switch LED 10 off, you’ll have to set it to black (0,0,0):

c = strip.Color(0, 0, 0);  // define the variable c as RED (R,G,B)
strip.setPixelColor(10, c);  // set LED 10 to the color in variable c (red)
strip.show();  

Before calling strip.show(), you can set all other LEDs, so you have to call it only once.

So for your idea (if I understood it right) you’d probably want to do something like this:

...
void loop()
{
  // if analog input pin 0 is unconnected, random analog noise will cause the call to randomSeed() to generate
  // different seed numbers. randomSeed() will then shuffle the random function.
  randomSeed(analogRead(0));
  memset(leds, 0, 15 * 3); // 15 LEDs
  for(int i = 0; i < 15; j++) { 
        c = strip.Color(0,0,0); // set all to black
        strip.setPixelColor(i,c);
      }
      c = strip.Color(255,255,255);
      strip.setPixelColor(random(14),c);
      strip.show();
      delay(10);
    }
  }
}

You’d have to play a little with this … specially since “random” isn’t really random. (see also: Arduino Random)

FastLED works in a similar way, you'll just have to assign the color to the individual LED a little different:
leds[10] = CRGB::Red; // Set LED 10 to red
FastLED.show();       // Show changes 
...
leds[10].r = 255;     // set red for LED 10 (Color = Red + Green + Blue)
leds[10].g = 125;     // set green for LED 10
leds[10].b = 0;       // set blue for LED 10
FastLED.show();       // Show changes

Hope this helps a little – feel free to ask if you need more assistance. 

(p.s. I’m traveling at the moment so I don’t have any Arduino/LED gear with me to test …)

hans

Oops little typo in the code:

...
void loop()
{
  // if analog input pin 0 is unconnected, random analog noise will cause the call to randomSeed() to generate
  // different seed numbers. randomSeed() will then shuffle the random function.
  randomSeed(analogRead(0));
  memset(leds, 0, 15 * 3); // 15 LEDs

  for(int i = 0; i < 15; j++) { 
        c = strip.Color(0,0,0); // set all to black
        strip.setPixelColor(i,c);
      }

  c = strip.Color(255,255,255); // define white
  strip.setPixelColor(random(14),c); // set one of the LEDs (0...14) to white

  strip.show(); // Now show all LEDs with their newly assigned colors
  delay(10);
}

hans

Based on the email you sent me:

Considering the code in the article, your code will look something like this:

#include <Adafruit_NeoPixel.h>
#define PIN 6
// 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(60, PIN, NEO_GRB + NEO_KHZ800);

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

void loop()
{
  // if analog input pin 0 is unconnected, random analog noise will cause the call to randomSeed() to generate
  // different seed numbers. randomSeed() will then shuffle the random function.
  randomSeed(analogRead(0));
  memset(leds, 0, 15 * 3); // 15 LEDs

  // Set all LEDs to OFF
  for(int i = 0; i < 15; i++) { 
        c = strip.Color(0,0,0); // set all to black
        strip.setPixelColor(i,c);
      }

  delay(3000); // wait 3 seconds
  
  // Set ONE random light to ON
  c = strip.Color(255,255,255); // define white
  strip.setPixelColor(random(14),c); // set one of the LEDs (0...14) to white
  strip.show(); // Now show all LEDs with their newly assigned colors

  delay(3000); // wait 3 seconds
}

Hope this helps 

hans

Hi Claire,

no problem, let me see if I can help – My apologies for the errors, I had to write the code without any hardware to test.

Please give this a try, I removed some comments and addressed the lack of defining “c” and the fact that “leds” was not needed after all.

#include <Adafruit_NeoPixel.h>
#define PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

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

void loop()
{
  uint32_t c; // define 'c' for color
  randomSeed(analogRead(0));
  
  // Set all LEDs to OFF
  c = strip.Color(0,0,0); // set all to black
  for(int i = 0; i < 15; i++) { 
        strip.setPixelColor(i,c);
      }
  delay(3000); // wait 3 seconds
  
  // Set ONE random light to ON
  c = strip.Color(255,255,255); // define white
  strip.setPixelColor(random(14),c); // set one of the LEDs (0...14) to white
  strip.show(); // Now show all LEDs with their newly assigned colors
  delay(3000); // wait 3 seconds
}

Let me know how it works … 

hans

Hi Claire!

You’re welcome, I love it when folks try these kind of things even though they are not experts. Kind-a the motto of my website is to make stuff like this accessible for everybody … sharing knowledge makes life better for all of us …

The Sketch does not seem to behave like I wanted it to. The timing seems off (we just use 3 second delays) and the repeat of pattern is not right either. The timing is a little odd, the repeat of pattern might be avoidable by setting the random seed in the loop() function.

Can you test this modification:

#include <Adafruit_NeoPixel.h>
#define PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
  strip.begin();
  strip.show(); // Initialize all pixels to 'off’
  randomSeed(analogRead(0));
}
void loop()
{
  uint32_t c; // define 'c' for color
  
  // Set all LEDs to OFF
  c = strip.Color(0,0,0); // set all to black
  for(int i = 0; i < 15; i++) { 
        strip.setPixelColor(i,c);
      }
  delay(3000); // wait 3 seconds
  
  // Set ONE random light to ON
  c = strip.Color(255,255,255); // define white
  strip.setPixelColor(random(14),c); // set one of the LEDs (0...14) to white
  strip.show(); // Now show all LEDs with their newly assigned colors
  delay(3000); // wait 3 seconds
}

hans

Hi Walter …

Thanks for the nice compliment …

Your project sounds interesting, but unfortunately I’m not familiar with Jinx! (this one?) or Glediator (is it this matrix LED control application?) …
For Glediator, there seems to be a sketch available (here).

I’m not sure about the documentation, but I would expect for either applications that a description exists? Maybe the sketch needed for either are even the same?

Hopefully other readers pick up on your question and add additional info …

hans

Hi Lucien,

I’m not sure what you mean with your question, since this article describes how to control the LEDs without the need for a computer (unless you use the computer as the powersupply)?
Please elaborate. 

hans

Lucien,

Once you have uploaded your sketch to the Arduino, the Arduino may be disconnected from the PC.

When the Arduino is connected to the PC, the Arduino gets its power from the PC.

When you disconnect the Arduino from the PC, you will need to connect it another source of power. Hans has a diagram above that shows you how to make that power connection. //www.tweaking4all.com/wp-content/uploads/2014/01/arduino_no_computer_power.jpg

L. K.

Hi Lucien,d

In line 32 you’ll find a call to this function. The parameter passed is the delay. So

theaterChaseRainbow(50);

could become:

theaterChaseRainbow(0);

Hope this goes fast enough,… 

hans

Hi Richard,

having a DJI Quadcopter myself, I suspect that the battery does not supply enough Amps. Have you tried less LEDs? I’d start with one if possible, but since it’s most likely a strip you’d like to use, I can imagine that to be difficult.

I assume the battery provides 5.4V, but as the load increases, the voltage may drop even below 5V.
It might be an idea to look for 3.3V (or less) LED strips, then again, that might not work either, as the used wattage (volt x amps) might remain consistent.

hans

How about never drive more than 1 LED on at a time. Sweep all of the LEDs quickly using pov to have them all appear on? This will reduce your overall current draw on your battery system while retaining what appears to be all LEDS lit if necessary.

Dannlh

Hi Martin,

Thanks for the compliment,… 

You’re not wrong!
I understand that Vin is the preferred method.
However +5V works as well when using a proper power-supply.

p.s. I’ll add a note about that in the text.

hans

Hi Tiz,

Don’t worry about your English … it’s perfectly readable …

First thing I’d check is if the arrow on the strip is pointing in the right direction (“away” from the Arduino).
Next thing to check is if power is connected properly.
And finally the wires to the Arduino (fig.4 and 5) pin 6. 

It should work with the sketch from this article, after you changed it to 12 LEDs in the code of course.

If these seem OK, then it’s time to test if there is an issue with the strand you’re using – In one of my strands for example, the first LED was defective, and as of that LED nothing worked. Easiest test would be by trying another strand with your current setup. See if that one fails as well.

If none of this works, then it’s time to start toying with the settings

//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(12, 6, NEO_GRB + NEO_KHZ800);

Try the NEO_KHZ400, …. with the RGB/GRB variants, only the colors will be wrong, but you should still see them light up.

All under the assumption that the strip is indeed a WS2811 or WS2812 of course.
Let me know if none of this works … 

hans

P.s. Thank you very much for the very nice compliment – cool! 

hans

I’ve been having the same problem (using Arduino Diecimila and FastLED). The examples do not seem to work, but the strip flashes once when the power supply is turned on. 

I’ve also noticed that the first LED never seems to flash, possibly suggesting some defect. My question is if I simply remove the first LED and solder again on the second will that fix the possibly faulty connection? The strips take a long time to arrive here so I can’t really test with another strip very quickly. 

Thank you and best regards!

Mehmet

8 not 6

Gabi

The LEDs would need Ground as well, and 8 LEDs means that you need to do the math on your PowerSupply.

Not 100% sure how many Amps the Arduino pulls, but the LEDs alone is already 8 x 60mA (480 mA). If your Power supply is not “strong” enough, the LEDs will not go on. LEDs going on when the soldering iron is near is not a 100% guarantee that everything in the 2812 is working properly.

hans

Awesome! Glad to hear that. 

hans

Hi Andrey,

sorry to hear you’re running in to this problem.

Your power supply seems potent enough, so that would not be the problem.

I can only guess that it might be a fault somewhere in the strip(s).
Did you try the individual strips, one at a time, just for testing?
The fact that AdaFruit and NeoPixel show the same problem, makes me think it’s a hardware issue.

hans

Hi Jason!

Thanks for the compliment, it’s always much appreciated! 

3fps is pretty super slow indeed, specially when you consider that I’m using it with Boblight (an Ambilight clone) where 3 fps would not be acceptable at all, yet it keeps up just fine. I’m sure you looked at the uberguide at Adafruit where they state that under best conditions 328fps show be achievable for 100 LEDs, so roughly 110 fps for 300 LEDs.

I actually use 290 LEDs for my Boblight setup and it keeps up wonderfully … and that even includes reading data from the serial port, conversion and steering the individual LEDs. For my setup I’m using the UNO as well.

If I look at your code, then I can’t really see anything wrong there.

So that leaves: Arduino somehow slow, or LEDs somehow slow,… which could caused by the wiring maybe? One or the other Arduino pin shorting? (I’m just guessing here)

hans

Doh! 

You’re 100% right! That’s what I get from replying before properly waking up first  ….
You’re right in the second loop line

strip.setPixelColor(i-1,strip.Color(0,0,0));

Where i=0 then makes it -1 … 

Sorry for not reading your message not properly.

hans

Hi Roger! 

That’s a nice and practical use for the LEDs – I like it!

What I would do for the pattern button:

First define a global variable, say:

int selectedpattern = 1;

Then in the loop(), when a button press is detected, increase the value of “selectedpattern”.
If selectedpattern is >5 then set it back to 1 and handle the pattern display with a switch case.

if ( button pressed detected )
{
  selectedpattern++;
  if (selectedpattern>5) { selectedpattern=1 }
}

switch(selectedpattern) {
  case 1: startpattern1; break;
  case 2: startpattern2; break;
  case 3: startpattern3; break;
  case 4: startpattern4; break;
  case 5: startpattern5; break;
  }

Assuming startpattern1 is a function for pattern 1, etc.

You could do something similar for brightness, maybe even use 3 settings: Bright, Medium, Off?
Brightness can be controlled in several ways (see this AdaFruit Forum Topic) and I suspect that in your case, setting the brightness before calling the pattern display will work just fine by using:

strip.setBrightness(255); // Full
strip.setBrightness(128); // Half
strip.setBrightness(0); // Off

For half the brightness I just picked and arbitrary number, you might want to experiment what would be the right value for you.

So everything combined could be something like this:

Global variables:

int selectedpattern = 1;
int ledbrightness = 255;

And in the loop():

if ( brightness button press detected) 
{
  // if FULL then go to HALF, if HALF then go to OFF, if OFF go back to FULL
  switch(ledbrightness) {
    case 255: ledbrightness = 128; break;
    case 128: ledbrightness = 0;   break;
    case 0:   ledbrightness = 255; break;
  }

  strip.setBrightness(ledbrightness);
}

if ( pattern button press detected ) {
  selectedpattern++;
  if (selectedpattern>5) { selectedpattern=1 }
}

switch(selectedpattern) {
  case 1: startpattern1; break;
  case 2: startpattern2; break;
  case 3: startpattern3; break;
  case 4: startpattern4; break;
  case 5: startpattern5; break;
  }

Please note that I have not tested this code, as I do not have my equipment with me to test – I’m traveling at the moment.
As you can see: I have not “implemented” the button press catching part … I have never used this, but it should be fairly easy to do. See this Arduino Push Button example.

In this I assume your code keeps calling the pattern generation in the loop() over and over again. With this example we simply switch to another patter that is being displayed over and over again.

Hope this gets you started 

hans

If the Arduino is USB Powered:

Connect the additional power-supply as follows:

+5V to LEDs, GND to LEDs and Arduino. (see figure 4)

If the Arduino is NOT powered through USB (i.e. USB cable NOT connected):

Connect the additional power-supply as follows:

+5V to LEDs and Arduino, GND to LEDs and Arduino. (see figure 5)

The USB bus will most likely not provide enough power to light up the LEDs, and you would not want the power of the power-supply go back into your USB (over simplified explanation).

Hope I read your explanation correctly and hope this helps …

hans

Glad to hear that Jay! 

Well, the part that you got it fixed of course ….

hans

Hi Chris!

Nice to see you here! My dad used to enjoy HAM radio and that’s how I got started with electronics .

Are you thinking of rotating “flags” or fixed?
Meaning; when switching your Arduino+LEDs on, show only one pattern or alternate patterns?

I am sure I can help you get started with this – once you see how it’s done, I’m sure you’ll know how to modify to meet your needs.

p.s. in case you’re Dutch:
Each article on my website is also available in Dutch, for example this is the Dutch version of this article.

hans

I bought a 5m WS2812B RGB LED strip on eBay.

I cut the 5m strip into 1m strips.

I laid the 1m strips on a piece of corrugated plastic but a thin piece of wood would work.

{ 1m strip #1 }

{ 1m strip #2 }

{ 1m strip #3}

{ 1m strip #4 }

{ 1m strip #5 }

Space the strips about 1 inch (25.4mm) apart.

My LEDs are spaced about 1 inch apart horizontally, so you would want to space them about 1 inch apart vertically.

Solder wires to connect end of strip #1 to start of strip #2, end of strip #2 to start of strip #3, and so forth.

ieee488

Altight, sounds like you’re making a real flag banner! Cool! 

So we have 5 strips of 30 LEDs, and for each we would need to define the colors.
There are a few methods you could try – unfortunately, I do not have access to my usual hardware (traveling), but let’s see how far we can go … maybe a good start for another article for me to write!

Note : I’ll assume we will be using FastLED for this purpose. 

If you’d be creating straight forward striped flags then we could do this “easy”, meaning define the color for each row. But seeing your earlier example (3 red, 3 white, 3 blue), I’m assuming you want to set the color per “pixel” (LED).

A 2 dimensional array would be helpful to define the flag colors. In this example (untested on an actual LED setup, but it compiles in the Arduino IDE) I’ve use an array called “flagcolors” which holds the color values for all LEDs, based on Row and Column. We can, thank goodness, define the array pretty easy in one “step”.

So here we go, first do the usual FastLED steps (include, definer number of LEDs, set LED array for FastLED, define Arduino pin).

In setup() we basically initialize FastLED, and then copy the array colors to the appropriate LED positions (if I didn’t screw up haha).

#include "FastLED.h"

// Number of RGB LEDs in the strand
#define NUM_LEDS 150 

// Define the array of leds
CRGB leds[NUM_LEDS];

// Arduino pin used for Data
#define PIN 6 

// Define a few colors
#define Red   0xFF0000
#define White 0xFFFFFF
#define Blue  0x0000FF
#define Green 0x00FF00

uint32_t flagcolors[5][30] = { 
    {  Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red  },  // row 1
    {  Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red  },  // row 2
    {  White, White, White, White, White, White, White, White, White, White, 
       White, White, White, White, White, White, White, White, White, White, 
       White, White, White, White, White, White, White, White, White, White }, // row 3
    {  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue },   // row 4
    {  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue }   // row 5
  };

void setup()
{
  FastLED.addLeds<NEOPIXEL, PIN, RGB>(leds, NUM_LEDS);
  
  // For setting the flag one time
  for(int row = 0; row < 5; row++) {
    for(int col = 0; col < 30; col++) {
      leds[ (row*30)+col ] = flagcolors[row][col];
    }
  }
  
  FastLED.show();
}

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

The reason why I’ve used an array can be made more visible in the next example where I toggle between Dutch flag and Italian flag.

As you can see, you can define pretty much any picture of 5 x 30 pixels this way.
Define more colors if you need them, and use them in the same way.
A list of color hex code’s can be found at the end of the article … 

#include "FastLED.h"

// Number of RGB LEDs in the strand
#define NUM_LEDS 60 

// Define the array of leds
CRGB leds[NUM_LEDS];

// Arduino pin used for Data
#define PIN 6 

// Define a few colors
#define Red   0xFF0000
#define White 0xFFFFFF
#define Blue  0x0000FF
#define Green 0x00FF00

// Define flags
uint32_t dutchflag[5][30] = { 
    {  Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red  },  // row 1
    {  Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red, 
       Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red,   Red  },  // row 2
    {  White, White, White, White, White, White, White, White, White, White, 
       White, White, White, White, White, White, White, White, White, White, 
       White, White, White, White, White, White, White, White, White, White }, // row 3
    {  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue },   // row 4
    {  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue, 
       Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue,  Blue }   // row 5
  };
uint32_t italianflag[5][30] = { 
    {  Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red  },  // row 1
    {  Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red  },  // row 2
    {  Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red  }, // row 3
    {  Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red  },   // row 4
    {  Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red, 
       Green, Green, Green, White, White, White, White, Red,   Red,   Red  }   // row 5
  };

void setup()
{
  FastLED.addLeds<NEOPIXEL, PIN, RGB>(leds, NUM_LEDS);
}

void loop() {
  // put your main code here, to run repeatedly:
  showflag(dutchflag);
  delay(1000);
  showflag(italianflag);
  delay(1000);
}

void showflag(uint32_t flagcolors[5][30])
{
  // Copy flag colors
  for(int row = 0; row < 5; row++) {
    for(int col = 0; col < 30; col++) {
      leds[ (row*30)+col ] = flagcolors[row][col];
    }
  }
  
  FastLED.show();  
}

Here I created a special function to “show” a flag. Simply pass the flag name and it will show.

Now … I had an Arduino Mega and the Arduino IDE available … but no LEDs. 
I assume these sketches will work, but I’m only human, so it is possible that I made a typo or mistake.

And before anyone jumps on it: I’m sure there are other, maybe even better ways to do this.
Just seemed the easiest for this purpose.

Let me know if this is what you had in mind … 

hans

No worries Chris!

(see: I speak Australian too )

I live in the USA but I’m currently with family in the Netherlands – so I know all about the time difference issues.  

The sketch I wrote can be used for your purposes as well. You will just have to enter the 3×3 pattern manually.

If you really only intend to use a 3x 3 Color pattern, then maybe this is a more appropriate approach:

#include "FastLED.h"

// Number of RGB LEDs in the strand
#define NUM_LEDS 150 

// Define the array of leds
CRGB leds[NUM_LEDS];

// Arduino pin used for Data
#define PIN 6 

// Define a few colors
#define Red   0xFF0000
#define White 0xFFFFFF
#define Blue  0x0000FF
#define Green 0x00FF00

void setup()
{
  FastLED.addLeds<NEOPIXEL, PIN, RGB>(leds, NUM_LEDS);
  
  // Set the 3 color pattern
  for(int row = 0; row < 150; row=row+9) {
    for (int light = 0; light < 3; light++) 
      if(row+light<150) leds[row+light] = Red;
    for (int light = 3; light < 6; light++) 
      if(row+light<150) leds[row+light] = White;
    for (int light = 6; light < 9; light++)
      if(row+light<150) leds[row+light] = Blue;
  }
  
  FastLED.show();
}

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

After the usual FastLED setup, I’m making a loop that goes from 0 to up to (not including) 150, each time increasing by 9.

In that loop, I have 3 loops which each count from 0 to 3 (3 not included) to set a color for a LED.

So we set row+light to the given color, ie. 0+0=0, 0+1=1, 0+2=2, … , 0+6=6, 0+7=7, 0+8=8, 9+0=9,… etc.

I had to put an IF check in there since 150 cannot be divided by 9, so at the last run “row+light” might exceed 150 and we cannot assign a value to a LED beyond 150.

I compiled the code but again, was unable to test it actually with a strand of LEDs.

The next step could be having the colors “run”, ie in the first cycle have 3xred, 3xwhite, 3xblue, next cycle 3xwhite, 3xblue, 3x red, next cycle 3xblue, 3xred, 3xwhite, and do it all over again.

The sloppy/lazy way of doing that:

#include "FastLED.h"

// Number of RGB LEDs in the strand
#define NUM_LEDS 150 

// Define the array of leds
CRGB leds[NUM_LEDS];

// Arduino pin used for Data
#define PIN 6 

// Define a few colors
#define Red   0xFF0000
#define White 0xFFFFFF
#define Blue  0x0000FF
#define Green 0x00FF00

void setup()
{
  FastLED.addLeds<NEOPIXEL, PIN, RGB>(leds, NUM_LEDS);  
}

void loop() {
  // put your main code here, to run repeatedly:
  
  // Set the first 3 color pattern
  for(int row = 0; row < 150; row=row+9) {
    for (int light = 0; light < 3; light++) 
      if(row+light<150) leds[row+light] = Red;
    for (int light = 3; light < 6; light++) 
      if(row+light<150) leds[row+light] = White;
    for (int light = 6; light < 9; light++)
      if(row+light<150) leds[row+light] = Blue;
  }
  
  FastLED.show();
  delay(500);
  // Set the second 3 color pattern
  for(int row = 0; row < 150; row=row+9) {
    for (int light = 0; light < 3; light++) 
      if(row+light<150) leds[row+light] = White;
    for (int light = 3; light < 6; light++) 
      if(row+light<150) leds[row+light] = Blue;
    for (int light = 6; light < 9; light++)
      if(row+light<150) leds[row+light] = Red;
  }
  
  FastLED.show();
  delay(500);
  
  // Set the third 3 color pattern
  for(int row = 0; row < 150; row=row+9) {
    for (int light = 0; light < 3; light++) 
      if(row+light<150) leds[row+light] = Blue;
    for (int light = 3; light < 6; light++) 
      if(row+light<150) leds[row+light] = Red;
    for (int light = 6; light < 9; light++)
      if(row+light<150) leds[row+light] = White;
  }
  
  FastLED.show();
  delay(500);
}

I call this sloppy, because this can be solved in a much more elegant way, but this way you can see clearly what’s going on.

In the loop() (the code that the Arduino keeps repeating) we define and set the first pattern, wait half a second, do the 2nd pattern, wait half a second, do the 3rd pattern, wait half a second and do it all over again …

Please give it a try … again, I didn’t test the code by lack of actually having a strand available, but it compiles OK. 

hans

Hi ShowTime! 

Do not worry about your English,… it’s pretty good and I’m understanding just fine what you’re saying.

If I understand you correctly (explaining a desired effect can be hard):

You want the SwipeUp and SwipeDown, just 4 LEDs at a time, instead of one at a time.

If that’s what you’re looking for then a modification something like this should work:

// Fill the dots one after the other with a color
 void colourWipeUp(uint32_t c, uint8_t wait) {
   for(uint16_t i=strip.numPixels(); i < -1; i--) {
      strip.setPixelColor(i, c);
      if( ((i+1) % 4==0) || (i==0) ) {
          strip.show();
          delay(wait);
     }
  }
 }

So what it does;

It goes through the usual swipe, however only displays the changes if the led count is dividable by 4 (I have to add 1 to “i” since it’s zero based – ie. Led 4 would actualy have i=3). If dividable by 4, then the modulo (%) or “left over” of the division should be zero, or if we’ve reached the first LED (i==0), then display the changes.

So it sets the LED values for the first 4, then shows the changes. Then for the next 4, and show the changes again, … repeat until we reach the first LED.

I have not been able to test this, as I do not have a strand available – I’m traveling.

The other function should look something like this – I hope I didn’t screw up with the strip.numPixels():

// Fill the dots one after the other with a color
 void colourWipeDown(uint32_t c, uint8_t wait) {
   for(uint16_t i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
     if( ((i+1) % 4==0) || (i==strip.numPixels()-1) ) {
        strip.show();
        delay(wait);
     }
  }
 }

Hope this is what you’re looking for.

hans

Hi Chris,

no better school than trying yourself and playing with the results haha 

Glad the code works – I’m sure I could have come up with a more elegant method, but I figured this one is easiest to understand and to work with for other “applications” ,… 

I have a little trouble understanding what you’d like to do with option a). You mean led 1 on, led 2 on,… led n on. All leds off. And repeat? If so, then I think you can achieve that with:

void showflag(uint32_t flagcolors[5][30])
{
  // Copy flag colors
  for(int row = 0; row < 5; row++) {
    for(int col = 0; col < 30; col++) {
      leds[ (row*30)+col ] = flagcolors[row][col];
      FastLED.show();
      delay(100); // some delay between LEDs
    }  
  delay(1000); // delay when the strand completed
}

Maybe fun to make the LEDs walk around, with a minor (untested) modification:

void showflag(uint32_t flagcolors[5][30])
{
  // Copy flag colors
  for(int row = 0; row < 5; row++) {
    for(int col = 0; col < 30; col++) {
      leds[ (row*30)+col ] = flagcolors[row][col];
      FastLED.show();
      delay(100); // some delay between LEDs
      leds[ (row*30)+col ] = CRGB::Black; // set LED to black if I'm right
      FastLED.show();
      delay(100);
    }  
  delay(1000); // delay when the strand completed
}

For flashing the LEDs, you could try using Brightness maybe …

I do not know for sure if this will work, but I’m pretty sure it will work …

void loop()
{
  set Brightness(255);   // Max Brightness
   showflag(..);                // Show the flag as you did before
   setBrightness(128);   // Dim brightness
   showflag (..);               // Show flag like you did before
   FastLED.clear();          // All LEDs OFF
}

You might have to tweak the delays in the code a little bit, and I took the liberty to make dimmed brightness in between. You can remove that in case you don’t like it.

Oh and do not forget to look at the FastLED demo’s, or this demo that I found at AndyPi.
I have learned, and am still learning, a lot from those.

Hope this is what you’re looking for 

hans

Hi Chris,

feel free to ask about the jargon – we all went through that process … some I do not even know .

If this is the exact sketch you’re using then the error is caused because you didn’t close the loop() function.

A function (I’ll take the look as example) has this format:

void loop() {
  ...
}

Where “…” should be replaced with code.
You see how the block of code is enclosed with accolades?

The error messages you’re seeing are pretty useless except for the line

sketch_may04a.ino:37:13: error: expected '}' at end of input

since you forgot the closing accolade.

As for the red color in the error log, I fully agree – it’s difficult to read.
You can modify it, but this can be rather cumbersome to find the right file to do that. The file is called “theme.txt”.
The location of this file might be a little different on your computer, but in general it’s in the directory where the Arduino IDE has been installed.

Under MacOS X I found it here:

/Applications/Arduino.app/Contents/Java/lib/theme/theme.txt

Under Windows I found it here:

C:\Program Files\Arduino\lib\theme\theme.txt

Under Ubuntu I found it here:

/usr/share/arduino/lib/theme.txt

In “theme.txt” you’ll find this little bit of text:

# GUI - CONSOLE
console.font = Monospaced,plain,11
console.font.macosx = Monaco,plain,10
console.color = #000000
console.output.color = #eeeeee
console.error.color = #A61717

Changing the “console.error.color” would change the text color that is currently red. Change it for example to yellow:

console.error.color = #ffff00

You’ll have to restart the Arduino IDE after saving that file.

If you’d rather have a white background (console.color), with a darker red text, try:

console.color = #FFFFFF
console.error.color = #861300

If you’d like to use a bigger font, use the Arduino preferences, and set “Editor font size” to for example 14.

Hope this helps 

p.s. when posting code, would you mind marking the code with the far right button so it’s put in a separate box – makes the message more readable (I’ve manually modified your previous posts to get that effect).

hans

Hi Chris,

well as far as I know, the loop() must be defined.

So at the end of your code it should say at least:

void loop() {
}

Both loop() and setup() are required.

hans

Maybe it is an idea to start a forum topic about this? Otherwise the comments get quite convoluted … 

I took the liberty to start a forum topic.

hans

Hi Lucas,

that depends on which of the libraries you’ll be using. For example in Adafruit Neopixel this would be:

...
c = strip.Color(0, 0, 255);  // define the variable c as BLUE (R,G,B)
strip.setPixelColor(35, c);  // set LED 36 to the color in variable c (blue)
strip.show();                // Update all LEDs
delay(5000); /// 5 second delay
c = strip.Color(0, 0, 0); // define the variable c as BLACK (R,G,B)
strip.setPixelColor(35, c); // set LED 36 to the color in variable c (blue)
strip.show(); // Update all LEDs
...

You’ll need the initialization code (the #include and the setup() procedure) to get going, and put this code in the loop() procedure).
Note that LEDs are numbered 0 … n (zero based counting).
So the first LED will not be “1” but “0”, and equally LED 36 will be “35”.

hans

Hi AlexPeres!

The trick is to capture the motion (and possible fade) in a loop.
Quickly looking at it, you’d need to think of the LED strip as 2 halves, where the LEDs light up mirrored.
Next thing to remember is that a number of LEDs “walk” together, with a possible dim of the first/last LED.
But maybe it’s good to leave the “fade” at the ends out, until you have a basic loop going.

Unfortunately, I’m a little short on time – I’m in the middle of moving from the USA to Europe, so I’m having a hard time keeping up with things as it is.
I will try to get back to this question with a loop as soon as I can.

hans

Hi Anders,

Data direction is indeed critical.

Power however does not matter, some even connect both ends to the power supply.

hans

Just to expand on Hans’ reply, it is helpful to connect both ends because of voltage loss from one end to the other of the strip. If you have all of your LEDS turned on the far end of the strip away from the power can be dimmer than the near end depending on number of LEDS and the length of the strip. Additionally it gives two paths for current draw into the LEDS effectively doubling your current carrying capacity from the power supply into the strip.

Dannlh

You must make the -ve of the battery connect to the ground of the Arduino. But you must not connect the +ve of the battery to the +ve of the Arduino. Also the battery voltage must not be higher than 5V.

Grumpy_Mike

Hi Ray,

I’ve been using the WS2812 LED strands + Arduino Uno R3 + 10A 5V Power supply with OpenElec for a while now. My setup runs OpenElec on an AMD Fusion computer, without a single hick-up. 

For those running OpenElec on a Raspberry Pi, I’d recommend looking into Hyperion as it uses much less resources. I hope to find the time in the next few months to write an article for that as well.

I’ve seen other being very successful with a comparable setup, even when running Kodi in a Virtual Machine (!).

Unfortunately, I’m not familiar with the details of LightPack. I only read somewhere that it needs a serial number or address. This does not mean that the LighPacks will not work, I’m just not familiar with all the details, and you’re the first person here to even mention the LightPacks. 

Your basic shopping list:

– WS2811 or WS2812 LED strand(s) – either from eBay, Amazon, or AliExpress for example.
– Arduino Uno R3 (other models will often work – but you’ll have to check if the pins match etc) – I recommend the original, not a clone.
– Suitable 5V power supply (see calculation above) – I found some good ones at eBay and AliExpress.
– USB cable to connect Arduino to your HTPC. (USB A to USB B)

You might need a few connectors or cables – depending on your choices how to connect the power supply and how to connect individual strands.a

After uploading a sketch to your Arduino, connect the LED strands to your Arduino, connect power to the first LED strand, connect the Arduino to your HTPC, install Boblightd on your HTPC, install the Boblight addon in Kodi, and you’re good to go. Well, naturally you’d want to go through the article for certain details.

hans

Hi Chris!

I can’t say much about the brightness of the LEDs, since these are the only ones I have used so far. They are pretty bright though and I actually had to tone down the brightness to get good results.

I’m having 290 LEDs around my 80″ TV, and Boblight does not seem to have an issue with that. Therefore I can safely say that 240 won’t be a problem either – especially since your HTPC is more powerful that my dinky HTPC (AMD Fusion). Just make sure the power supply is powerful enough (say 10A for convenience), and it could be good to connect +5V and GND to both ends of your 8 meter “strand”.

I’ve noticed with my setup (power only connected to one end), that the last few LEDs loose brightness. So once I can access my stuff again (it’s in transit from the U.S. to Europe), I will connect power on both ends as well.

Looks like an exciting and cool project … 108″ is a pretty large screen … 

hans

I think 60 LEDs/meter would not be a bad idea with a black wall. 
I think Boblight might be able to handle 500 individual LEDs just fine.

However, if you find that it will not work, then we most certainly can see if we can adapt the sketch to support grouping of LEDs.

hans

H Louis!

Welcome to Arduino and LED’s 

To control speed, you have a few options, for example in the AdaFruit_NeoPixel example:

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
      strip.show();
      delay(wait);
  }
}

The function colorWipe takes a variable called “wait”, increase this value and the swipe will go slower.

You see in one of the earlier lines:

  colorWipe(strip.Color(0, 0, 255), 50); // Blue

Increase that number 50, and it will go slower.

The function theaterChase() works in the same way.

In those functions, you see a line “delay(wait)”, this delay() statement takes an integer value, which indicates how many milliseconds the Arduino should pause. So if you’d put that somewhere in your code, then you can delay that way as well. For example delay(1000) pauses the Arduino for a second. 

Is this what you’re looking for?

hans

Solved by learning how to multi-task here.

Louis

Nice and neat find! 

hans

Hi Kathleen!

Thank you very much for the enthusiastic “Thank you” note .

To fade in/out a individual pixel, your code needs to change that particular pixel color to a light (in) or darker (out) color.

c = strip.Color(255, 255, 255);  // define the variable c as WHITE (R,G,B)
strip.setPixelColor(10, c);  // set LED 10 to the color in variable c (white)
strip.show();                // Update all LEDs (= make LED 10 white)

The code above sets the color of a pixel based on 4 numbers. 3 number (in Color()) to define the color, the lower the numbers the darker the light gets, the higher the number, the brighter they get.

The 4th number I mentioned is the specific LED you’d like to change (in setPixelColor()).

Once set, we call show() to make the actual change.

To accomplish your idea (and I’m really super curious about the end result, so please share when you have your sculpture done) you’d probably want to use a loop. For now I assume you’ll be using white as a “color”, but the same (albeit a little bit more work) would apply to other colors.

This is just a part of the code, and I’m assuming you’re using NeoPixel …

Now for the loop, which we’d call once the proximity sensors picks up a person near your sculpture. So when the sensor detects motion/proximity call:

StartFades();

The function (untested, I’m nowhere near my stuff at the moment to even try this) should be something like this:

void StartFades()
{
  // Make sure all LEDs are off
  for (int i=0; i < strip.numPixels(); i=++) {
    strip.setPixelColor(i+q, 0);        //turn every pixel off
  }
  strip.show();

  // Do this for every LED "loop"
  for (int activeLED=0; activeLED < strip.numPixels(); activeLED++) 
  {

    // Fading the active LED in, so one step at a time get red, green and blue to 255 (max brightness)
    for (int fadeIN=0; fadeIN <= 255; fadeIN++) 
    {
      strip.setPixelColor(activeLED, strip.Color(fadeIN, fadeIN, fadeIN)); // set red, green and blue
      strip.show();
      delay(10); // change this to a lower number to go faster, or higher to go slower 
    }

    delay(10); // change this number if you want to change the delay between fading IN and OUT

    // Fading the active LED out, same here, just getting red, green and blue to go to zero (off)
    for (int fadeOUT=255; fadeIN >= 0; fadeIN--) 
    {
      strip.setPixelColor(activeLED, strip.Color(fadeOUT, fadeOUT, fadeOUT)); // set red, green and blue 
      strip.show();
      delay(10); // change this to a lower number to go faster, or higher to go slower
    }

    delay(10); // change this number if you want to change the delay for going to the next LED
  }
}

Hope this gets you started  …

hans

Hi Cindy – thank you very much for the compliment! 

I like the idea of creating a place where folks can share their lightning effects!
I’ve seen some interesting ideas so far with the visitors here.

For now I’d recommend posting in the forum – which would allow attachments as well (code, pictures, etc).
I started a topic just now for that purpose. “Arduino/WS2811/WS2812 – Share you lighting effects and patterns here … ” …

I’m curious to see who is going to post what kind of effects … 

hans

Hi FireFly,

If you follow the same wiring as seen in figure 4 (above), you should be good to go.
Granted, I have never tried a 12V WS2811, but the data (Din) will be using 5V no matter what.
Just don’t mix ‘m up …

Since I never had hears of these 12V strands, I decided to look around a bit and found this Arduino Forum Thread – maybe you’d like to read that one.
From that thread and from this one, I understand that the individual Red, Green and Blue LEDs might not be addressable.
So you might want to look into that one.

hans

Hi Fetret,

Weird flashes and glitches feels like either contacts not working great or failing LEDs (only one failing LED is enough to make the rest go nuts).

Doe these glitches start as off a certain LED? Or it’s just the entire strand?

I don’t think 4.6V should be a problem, unless it’s your power-supply tanking the voltage because it cannot keep up.
You could try a more powerful power-supply, or use a shorter strip. And if you go the shorter-strip route; try different pieces, to see if the glitch only happens in one part (trying to narrow it down to the LED that causes the issue.

You could (depending on your strip) leave +5V and GND connected to the strip, but move the Din wire from the first LED to the second LED and see what happens. Keep moving it to the next LED until the glitches disappear.

I have zero experience with APA102 and APA104 LEDs … so I have no idea if they are any good or not. 

hans

Hi Julius!

You’re always free to ask questions … and thank you for the compliment! 

I have no experience with Lightdesk / Art-net whatsoever.

I did however find this Github project that seems to offer an Arduino Library for use with WS2811/WS2812 LEDs (and others, since they seem to use NeoPixel). As far as I can see in this example, you’d need an Arduino, an Ethernet Shield, and a LED strip.

Not sure how this fits in to your question, but I did see this DMX to WS2811 controller on eBay as well. Maybe that is easier/helpful too.

But keep in mind: this is the first time I look at this particular topic … when looking for information online, things get a little confusing. I have the impression that you’re talking about a “protocol” (DMX) that can be used for all kinds of devices and can be controlled with (for example) an Android App. I did find some control specifications here for those interested.

Interesting topic though, and I’m sorry I can’t provide much more help (at this time).

If you have any specific links, feel free to post them here.

Oh, … and I think you’re right that a good guide for Art-Net might not be bad to have. What I have seen so far as pretty vague or very technical.

hans

Hi Dan!

Thanks for the compliments, I wish I could be more helpful, but I have been doing a lot of traveling lately, so I haven’t had as much time to help as I’d like to.
But, this week I’ll give it another try, since I will have more time available. (just got back)

I will try to get back to asap,…

Hope you had a great holiday as well! 

hans

Dan, am I understanding this right that your question is similar to this one in the forum?

hans

To prevent large postings with code, I started a Forum topic for your question, hope you don’t mind … 

hans

Hi Dan,

I created a piece of code in that forum post that might do the trick (toggle switch not included). 

hans

Hi Cristiano!

Unfortunately, I have no experience with 12V powered LED strips.
If this indeed is a real WS2811, then it commonly is powered with 5V (did you try that? Wouldn’t hurt the strip).

I have seen one or two other users here that use such a 12V strip as well, maybe they can chime in?
You might also want to check the Boblight Project, since there will be more users there that might be able to answer your question.

Personally; I doubt the resistor, or lack there of, will cause this. I suspect this might not be a “real” WS2811 and the code sent by the Arduino might actually be the wrong kind for your strip. Then again; I have not played with 12V powered strips before.

hans

Mooi om te horen! 

En dank je wel voor het de moeite nemen om een bedankje te posten! 

hans

Hi Tal,

sorry to hear you’re running into trouble there.

You’re the first one to report such an issue.
I can only image a few reasons why this might happen.

1) The LEDs are powered by your computer, which would pull way to much on your USB port.
This can happen when the extra power supply is not connected properly.

2) Somehow there is a short close to the USB connection, again draining too much power from the USB port (because of the short).
I’d go through all my wiring, and consider testing a different USB cable.

Try connecting the Arduino, without the LED strip or extra power supply being connected. If that works OK, then we at least can exclude the Arduino and the USB cable.

hans