We love 'em.
LED strips are pretty amazing. You can create amazing lighting installations, shimmering wearables or just add some blinky bling to your living room! But for the beginner, there are some issues which are confusing. Here's a quick walk through some of the main points.
Different Shapes But Still Strips
We'll talk here about LED strips (lines), but most of what we say here will apply to other shapes. The LED rings we sell are still 'strips', just strips that have been bent into circles. Some of the LED panels we sell are still strips, but they have been zigzagged into a square or rectangular arrangement. We sell quarter circles of LEDs too - guess what, these are 'strips' too. The very cool thing is that when you buy a flexible strip from us, you can cut the strip into different lengths and rearrange them into your own crazy shapes. Half-moons, tick-marks, letters, whatever you want! Alternatively, you can connect strips together to make longer strips, almost ad-infinitum.
Plug and Play? No Way.
So you've bought an LED strip and you want it to pulse colours like a deep sea monster. Just plug it in right? Wrong. Each LED strip usually needs some form of controller. The controller 'tells' each individual LED what colour and brightness to assume. By doing this quickly over time, the controller can make the LED flash, glow, stay steady, whatever you've programmed into the controller. So what's a controller? Basically anything that can send data pulses to the LED strip in the correct pattern. Some examples might be, any of the Arduino family, any of the Genuino family, the Raspberry Pi (with caveats), the mbed 1768, the Teensy 3.2 etc... If you need the closest thing we have to plug and play, try the T-1000S controller. It's specifically built to drive LED strips, but be careful - it doesn't drive some flavours of LED strip, for example, the APA102.
Power
How much power does an LED strip need? This is a really common question but it depends on how many LEDs are on the strip or strips you're using.
Here's an example : John has 12 of our 60 LED RGB addressable strips. He's going to send data to them using an Arduino Uno. John knows that the Arduino UNO can't provide enough power to drive 12 strips, but he needs to know how big a power supply unit (PSU) he needs to buy.
So here's the maths bit :
12 strips with 60 LEDs = 12 x 60 = 720 LEDs.
Each 'LED' on a RGB pixel actually contains 3 LEDs inside the housing. A red, a green and a blue LED. Our RGBW LEDs contiain 4 : Red, Green, Blue and White.
So we actually have
12 x 60 x 3 = 2160 LEDs.
As an estimate, at full brightness, each LED is going to use up to 30mA. So in total for 12 stips at full brightness :
12 x 60 x 3 x 0.030 = 64.8 A
No way! Nearly 65 Amps? That's like, more than the Apollo Lunar Lander had available!
So - the lesson here is that you don't get bright, beautiful, blink LED strips for nothing. They use current, and as a result, will also generate heat.
Don't panic too much. Chances are that you're not going to run all your LED pixels on full brightness for 100% of the time. This would mean lower power consumption.
More Power Stuff
It gets worse. What happens if you try to pass 65 Amps through a long, thin wire? Actually, the answer to that is rooted firmly in Ohms law, but for the purposes of this FAQ, we can tell you that your long, thin wire is going to get hot in places, and possibly have no voltage in other places.
The solution, and good practice when powering strips longer than a couple of meters is to inject power every few meters rather than just at one end. This could mean multiple power supplies, or several big, fat wires from one whopping power supply. Your application - your decision.
So What to Do?
If you're a beginner we recommend you start with a one meter LED strip and an Arduino/Genuino Uno. The Uno can pretty much power the strip and there are loads of bits of example code out there. Once you've mastered coding for the LED strip, move on to several strips and an external power supply. After that, the world's your (blinky, flashing) oyster.
Resources
Pololu LED strip Arduino Library (WS2812B)
Pololu LED strip mbed Library (WS2812B)
Example Code for Arduino using Neopixel WS2812B
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
#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'
}//Set colour 1st methodstrip.setPixelColor(n, red, green, blue);strip.setPixelColor(11, 255, 0, 255);//Set colour 2nd methodstrip.setPixelColor(n, color);//Convert values into single 32-bit typeuint32_t magenta = strip.Color(255, 0, 255);//Push colour data to stripstrip.show();//Query colour of previous set pixeluint32_t color = strip.getPixelColor(11);//Query number of stripsuint16_t n = strip.numPixels();//Adjust overall brightnessstrip.setBrightness(64);//Multiple objects on different pinsAdafruit_NeoPixel strip_a = Adafruit_NeoPixel(16, 5);Adafruit_NeoPixel strip_b = Adafruit_NeoPixel(16, 6); |