There are a lot of blinky glowy things at Burning Man every year, and [Mark] decided he would literally throw his hat into the ring. He built a high visibility top hat studded with more RGB LEDs than common sense would dictate. It’s a flashy hat, and a very good example of the fashion statement a few hundred LEDs can make.

[Mark]’s top hat has 481 WS2812b addressable LEDs studded around the perimeter, a common LED choice for bright and blinky wearables. These LEDs are driven by a Teensy 3.1, with a Bluetooth transceiver, a GPS module, a compass, and gyro/accelerometer attached to the microcontroller. That’s a lot of hardware, but it gives [Mark] the capability of having the hat react to its own orientation, point itself North, and allow for control via a modified Nintendo NES controller.

The WS2812 LEDs draw a lot of power, and for any wearable project having portable power is a chief concern. [Mark]’s original plan was to use an 8x battery holder for the electronics enclosure, and use five AA batteries to power the hat. The total idle draw of the LEDs was 4.5 Watts, and with even a few LEDs blinking colors there was a significant voltage drop. The idea of powering the hat with AA batteries was discarded and the power source was changed to a 195 Watt-hour lithium ion battery bank that was topped off each day with a solar panel.

The hat is awesome, exceedingly bright, and something that gets a lot of attention everywhere  it goes. For indoor use, it might be too bright, but this could be fixed with the addition of a bit of black stretchy fabric, like what our own [Mike Szczys] did for his DEF CON hat. [Mark]’s hat is just version 1, and he plans on making a second LED hat for next year.

Sure, you could get a regular light fixture like a normal person… Or you could use close to a thousand RGB LEDs to light your room!

That’s what [Dmitry] decided to do after trying to figure out the best way to light his pad. You see, his room is 4 by 4 meters, and WS2812 RGB LED strips happen to come in 4 meter lengths… Coincidence? We think not.

The problem with using 16 meters of LED strips is powering them… You see, at 16 meters, you’re looking at about 5V @ 57.6A — and we’re guessing you probably don’t have a 5V 60A power supply handy. Not to mention if you run them in series, the resistance of the system is going to kill your efficiency and the last LEDs probably won’t even work… So [Dmitry] had to break the system up. He has two power supplies feeding the strips from the middle of each pair — that way, he doesn’t have to worry about any voltage drops due to the length of the strips.

Controlling them was the next fun part. Using an ATMega, and a Nordic FOB (discontinued but useful RF remote) he’s able to control the lights to do whatever he wants — and he’s shared the source on his website as well.

For an even fancier LED room setup, check out this sculpted LED lit room that looks more like an ice cave than anything else!

While the gold standard for colorful blinky projects are individually controllable RGB LEDs, the usual offerings aren’t really that impressive. Yes, a few hundred Neopixels, WS2812, or other RGB LEDs will sear your retinas, but what if you wanted blinky glowy stuff that is so over the top as to be an affront to whatever creator you believe in?

This is it. [Ytai Ben-Tsvi] created an individually addressable RGB LED called the Pixie that is perfect for all the times when you need something bright, colorful, and want to blind a few people in the process.

WS2812s and Neopixels are basically RGB LEDs with a small microcontroller tucked tucked away inside, and so far there is no design house or fab plant in China that is crazy enough to add one of these tiny dies to an already overpowered LED. To build the Pixie, [Ytai] took a bare RGB LED module and added a microcontroller – a PIC12FF157X in this case. It’s not exactly a powerful microcontroller, but it can handle the shift register-like function of an individually addressable RGB, and adds gamma correction, over heating protection (something necessary when you’re dumping this much power into a tiny board, and other safeguards for each individual LED.

[Ytai] is working with Adafruit to produce these Pixies, and although they’re rather expensive at $15 per LED, you won’t need very many to blind yourself.

Gavin Morris has been working on his awesome sound responsive LED sculptures for a while. Technically the sculpture is an interesting application of WS2812 RGB LEDs, Raspberry Pis and a load of styrofoam cups and flower pots. However the artistic development, and inspiration for this project is equally interesting. Gavin shares his thoughts and a brief technical description of the project below.

This year I’ve been artist in residence at the Eastville Project Space, a new art space in Yeovil, Somerset UK. During the residency I created The LED Roundsystem, a series of lighting chandeliers. They were inspired by the work of one of the founders of the artspace, Zoe Li whose flowerpot sculpture I saw at “Salvage – A Hacker Farm Field Trip” a kind, of magical mystery tour organised by the band/noise collective which Zoe’s husband Farmer Glitch was a member at the time. His petrol can synths are certainly amazing but I was immediately drawn to the flowerpot chandelier and wanted to put LEDs in it from the moment I saw it.

Much time passed before it all came together. Amazingly for me, Zoe and Stephen started a new artspace and offered me a residency to work on some ideas. Over a few months the LED Roundsystem was born…. The globes respond to volume and pitch, lighting up a different colour for each note. They also have the capability to record and playback live sound.

On the face of it it’s just some pretty lights but there’s quite a lot going on behind the scenes.

The globes themselves are made from styrofoam cups. There is a long history of using styrofoam to create interesting artwork. Generally the cups and bowls are stuck together with a combination of solvent free adhesives. I read somewhere that you can produce cyanide by melting the foam with the wrong glue, so I guess you have to be a bit careful! I made a hole in each cup using a hollow punch, glued them together and then pushed a WS2812 pixel through each one; around 80 pixels in each globe (there are a few slightly different shapes).

Each globe has a Raspberry Pi in it with a wifi dongle and a USB soundcard. I am running the Satellite CCRMA image. The image is based on Raspbian with some optimizations for use of audio as well as adding Pure Data and Node.js, both of which I used for this project. I’ve got mixed feelings about using the Pi for this kind of thing, it’s amazing that it works but it was a slightly painful development process.

I’ve learned a lot of command line Linux stuff. There are quite a few hurdles to get over and workarounds needed – but that’s always the way I guess!

The globes have several different modes of operation as documented in the video. Firstly they are OLA (open lighting architecture) nodes which means I can control them from lighting software via Artnet over WiFi. I’ve been using Jinx! because it has some nice patterns and a great price. To get the Pi to control WS2812 pixels I’ve been using Martin Schuhfuss’ Node module which provides native bindings to the rpi-ws281x library by Jeremy Garff. It’s a bit of a mouthful but it’s been faultless for me so far and Martin has encouraged me to carry out some very minor fixes to get the library to work with my set up.

As I said the globes are all fitted with USB soundcards and have microphones attached. Some of these are set up to detect ambient noise and others more localized sound (e.g. a singer or instrumentalist). A Pure Data sketch analyzes the pitch of the incoming audio using Miller Puckette’s amazing Sigmund~ external, then chooses a hardcoded colour for each pitch. It then sends this colour and volume data via OSC to a Node.js script running on the Pi. There are a number of different lighting patterns available and these are chosen randomly or can be set via TouchOSC on a phone or tablet. The Node script runs the lights setting the colour and intensity according to the incoming data.

Two of the globes also have a looper feature where audio can be recorded, layered and played back with accompanying light patterns. Again there are some parameters which can be set via TouchOSC (loop length, feedback and various thresholds and gains) in a performance. Alternatively general settings can be applied for use in an installation. It’s a pretty basic looper but its good fun – you can build up vocal loops, beatbox rhythms, or play a bit of guitar or melodica. Then you can add more loops on another globe and then play over the top into the middle one. It’s quite an interesting effect and feels a bit churchy to me. But can also easily descend into chaotic noise, especially if a bunch of school kids turn up and start playing with them.

I realised that many people are also shy to make sound in public so I developed a tablet interface to control the globes. Input from a sequencer on the tablets is passed to a server which update all the globes. Beats tapped in by users are immediately updated across all connected Roundsystems. There are also some one shot buttons where sounds can be immediately triggered. These are a bit more accessible to people not familiar with the step sequencer format, although people usually suss it out pretty quickly anyway.

So that’s it for the moment. Though there’s certainly still potentially for development. I’m considering taking them on the road as part of my Digital Funfair show. The concern is that Funfair is quite a hectic environment and the globes work best with a bit of silence and darkness. Hopefully something unexpected will happen. I welcome your suggestions!

Two days at a company sponsored hackathon? Sounds like fun to us! And productive too – the end result for [GuuzG] and two of his workmates from their company’s annual “w00tcamp” was this festive and versatile 16×16 pixel mega display.

From the sound of it, [GuuzG] and his mates at q42.com are not exactly hardware types, but they came up with a nice build nonetheless. Their design was based on 16 WS2812 LED strips for a 256 pixel display. An MDF frame was whipped up with cross-lap joints to form a square cell for each pixel. Painted white and topped with a frosted Plexiglass sheet, each RGB pixel has a soft, diffuse glow yet sharply defined borders. Powered by a pair of 5A DIN rail DC supplies and controlled by a Raspberry Pi, the finished display is very versatile – users can draw random pixel art, play the Game of Life, or just upload an image. [GuuzG] and company are planning to add Tetris, naturally, and maybe a webcam for fun.

We’ve seen lots of uses for the ubiquitous WS2812 LEDs, from clocks to Ambilight clones to ground-effect lighting for an electric skateboard. But if you’re in the mood for a display that doesn’t use LEDs, there’s always this multithreading display.

[via Reddit]

There’s nothing like a good clock project, and tacking the steampunk modifier on it only makes it better. [José] built a steampunk clock that does it much better than just gluing some gears on an enclosure and calling it a day. This build includes glowing jewels displaying the time in different colors while displaying the a steampunker’s prowess with a pipe cutter.

The body of the clock is a piece of finely lacquered wood, hiding a perfboard construction with a DS3231 real time clock, a DHT22 temperature and humidity sensor, and a light sensor for dimming the WS2812 LEDs according to the ambient light level.

The rest of the clock is a bunch of 12mm copper pipe, elbows, and t couplers. The end of these pipes are capped off with marbles, with the RGB LEDs behind each of the ‘digits’ of the clock. This is a chromatic clock, with the digits 0 through 9 assigned a different color, based on the resistor color code scheme with exceptions for black and brown. Once you’ve figured out how to tell time with this clock, you should have no problem finding that single 56k resistor in your junk box.

You can check out the video of the clock below.

We love clocks, and [Chris] got our attention with the internet enabled Light Clock. Time is displayed via RGB LED strip in a number of different ways around a 3D printed white disk. All the modes are based on two selectable colors to indicate hours and minutes, either in a gradient fashion or a hard stop.

Light is provided by a 144 LED neopixel strip and is powered by a beefy 4 amp 5 volt power supply, which also powers the controller. Brains are provided by a ESP8266 powered NodeMCU-12E board, and software is written using ESP8266 for Arduino core.

Being a WiFi enabled micro controller it is a simple matter of connecting to the clock using WiFi and using the embedded web pages to select your local timezone, color palette, and display mode. The correct time is set by network and will never be wrong. While there is a Kickstarter for selling the finished project, instructions and software are provided for making your own if you wish.

Join us after the break for the promotional Kickstarter and demonstration video

One of the redeeming qualities of many modern cheap keyboards is the built-in volume control buttons. But this is Hackaday, and many of us (and you) have Model Ms or newfangled mechanical keyboards that only have the essential keys. Those multimedia buttons only adjust the system volume anyway. We would bet that a lot of our readers have sweet sound systems as part of their rig but have to get up to change the volume. So, what’s the solution? Build a color-changing remote USB volume knob like [Markus] did.

Much like the Instructable that inspired him, [Markus] used a Digispark board and a rotary encoder. The color comes from a WS2812 LED ring that fits perfectly inside a milky plastic tub that once held some kind of cream. When the volume is adjusted, the ring flashes white at each increment and then slowly returns to whatever color it’s set to. Pushing the button mutes the volume.

The components are pretty lightweight, and [Markus] didn’t want the thing sliding all over the desk. He took an interesting approach here and filled the base with the lead from a shotgun round and some superglue. The rotating part of the button needed some weight too, so he added a couple of washers for a satisfying feel. Be sure to check out the demonstration after the break.

Digispark board not metal enough for you? Here’s a volume knob built around a bare ATtiny85 (which is the same thing anyway).

Knowing where to start when adding a device to your home automation is always a tough thing. Most likely, you are already working on the device end of things (whatever you’re trying to automate) so it would be nice if the user end is already figured out. This is one such case. [Aditya Tannu] is using Siri to control ESP8266 connected devices by leveraging the functionality of Apple’s HomeKit protocols.

HomeKit is a framework from Apple that uses Siri as the voice activation on the user end of the system. Just like Amazon’s voice-control automation, this is ripe for exploration. [Aditya] is building upon the HAP-NodeJS package which implements a HomeKit Accessory Server using anything that will run Node.

Once the server is up and running (in this case, on a raspberry Pi) each connected device simply needs to communicate via MQTT. The Arduino IDE is used to program an ESP8266, and there are plenty of MQTT sketches out there that may be used for this purpose. The most recent example build from [Aditya] is a retrofit for a fiber optic lamp. He added an ESP8266 board and replaced the stock LEDs with WS2812 modules. The current version, demonstrated below, has on/off and color control for the device.

[via reddit]

[Norwegian Creations] makes things as a business model. Tired of the mundane lamp above their heads, they decided to put their skills to use. The basic idea was simple, plot out a cool 3D function, put some RGB LEDs behind it, make it an awesome mathematical rainbow light display, hang it right above their desks, and then ignore it for their monitors while they worked.

The brains of the project is a Raspberry Pi B+, WS2812 LED strips, and a Fadecandy controller from Adafruit. They 3D printed hexagonal towers out of clear plastic and labeled each carefully. Then they attached the strips to the board, glued on the hexagons, and covered the remaining surface in cotton balls to give it a cloud-like appearance.

The lamp normally plays patterns or maintains a steady light. As the day turns to night it reflects the world outside. However, if someone likes their Facebook page the light has a little one robot strobe party, which we imagine can get annoying over time. Video after the break.

Seb Lee-Delisle has built a career around large installations that use powerful lasers and high-end projects to make people happy. It’s a dream job that came to fruition through his multi-discipline skill set, his charismatic energy, and a mindset that drives him to see how he can push the boundaries of what is possible through live interaction.

His talk at the Hackaday | Belgrade conference is about his Laser Light Synth project, but we’re glad he also takes a detour into some of the other installations he’s built. The synth itself involves some very interesting iterative design to end up with a capacitive touch audio keyboard that is lit with addressable LEDs. It controls a laser that projects shapes and images to go along with the music, which sounds great no matter who is at the keyboard thanks to some very creative coding. As the talk unfolds we also hear about his PixelPyros which is essentially a crowd-controlled laser fireworks show.

See his talk below and join us after the break for a few extra details.

If you haven’t yet heard of PixelPyros you are in for a treat. Giant projected digital fireworks alone are pretty cool, but it’s a lot more fun if the audience is controlling the show. And then it begins to get supercharged when you add an 11-Watt laser to the mix. The laser is much more vivid than the projectors and the combination of the two is much more than the sum of their parts. As the fireworks are playing out, infrared cameras are watching the screen from behind to detect the audience touching the screen. When they hit the screen, fireworks launch in real time thanks to Seb’s software.

At this point he considers himself as addicted to using the high powered laser. His work on the Smashing Conference light show in 2014 is breathtaking. The event was held in a cathedral Oxford Town Hall with Seb blending the laser’s intensity to break out of the screen and use the entire space. The VU meter on the organ pipes with particles shooting out the top is magnificent!

All of this is just the preamble to his discussion of the Laser Light Synth project! The finished project is installed in a building featuring massive stone columns. Around the base of each column are user controllers that affect both the music and the laser show which is drawing visualizations on the columns. Although it may be hard for all but the closest spectators to see the keyboards, the columns are visible to all.

The hardware build for the controller is a great story. You see the finished product at the top of the post. Each key is packed with RGB LEDS. The trick was for Seb to establish a way to incorporate all of those LEDs with a capacitive touch controller that doesn’t obscure the light.

He started with a big pad of copper just to make sure the concept worked. He then experimented with adhesive copper tape, conductive paint, and finally settled on cutting the wavy pattern seen here out of copper foil using a vinyl cutter. It is adhered to the keyboard’s acrylic face-plate using transfer tape. The pattern doesn’t block the LEDs, and connects to the circuit boards with an ingenious use of copper pins and copper sequins that are soldered for a robust connection.

The keyboard is great, but Seb was nowhere near done. He really brought the project to life with some amazing code to make everyone a jazz musician. This comes in the form of custom Ableton Live patches which he demonstrated for us using a volunteer from the audience. They utilize the pentatonic scale to make sure the pitches match with what’s already going on in the music. Rhythm is as much a concern as pitch so he also wrote custom patches to arpeggiate the pitches in time with the beat, and to switch up rhythmic interest as the show plays out. You’ve got to watch Dex, the volunteer with no musical experience, rock out.

Seb proves the skills of an artist have no bounds. It’s wonderful to not only see his end product, but to have him share every single aspect of how he did it through concept, prototype, electronics, enclosure, and software. His talk is a shining example of why you should document your builds at every step of the way. The audience gobbled up his presentation and so will you!

[Main image of Laser Light Synth controller was taken by Oleg Pulemjotov]

What makes the WS2812-style individually addressable pixel LEDs so inviting? Their rich colors? Nope, you can get RGB LEDs anywhere. Their form factor? Nope. Even surface-mount RGBs are plentiful and cheap. The answer: it’s the integrated controller. It’s just so handy to speak an SPI-like protocol to your LEDs — it separates the power supply from the data, and you can chain them to your heart’s desire. Combine this controller and the LEDs together in a single package and you’ve got a runaway product success.

But before the WS2812, there was the WS2811 — a standalone RGB controller IC. With the WS2812s on the market, nobody wants the lowly WS2811’s anymore. Nobody except [Michael Krumpus], that is. You see, he likes the old-school glow of incandescent, but likes the way the WS2812 strings are easy to drive and extend. So he bought a bag of WS2811s and put the two together.

The controller IC can’t handle the current that an incandescent bulb requires, so he added a MOSFET to do the heavy lifting. After linking a few of these units together, he discovered (as one does with the LED-based WS2812s eventually) that the switching transients can pull down the power lines, so there is a beefy capacitor accompanying each bulb.

He wanted each bulb to be independently addressable, so he only used the blue line of the RGB controller, which leaves two outputs empty. I’m sure you can figure out something to do with them.

Needless to say, we’ve seen a lot of WS2812 hacks here. It’s hard to pick a favorite. [Mike] of “mike’s electric stuff” fame built what may be the largest installation we’ve seen, and this hack that effectively projection-maps onto a randomly placed string of WS2812s is pretty cool. But honestly, no project that blinks or glows can go far wrong, right?

[burgerga] loves attending Music Festivals. He’s also a MechE who loves his LED’s. He figured he needed to put it all together and do something insane, so he build a huge, 15″ geodesic sphere containing 540 WS2812B addressable LED’s. He calls it the SOL CRUSHER. It sips 150W when all LED’s are at full intensity, making it very, very, bright.

As with most WS2812B based projects, this one too is fairly straightforward, electrically. It’s controlled by four Teensy 3.2 boards mounted on Octo WS2811 adapter boards. Four 10,000 mAh 22.2V LiPo batteries provide power, which is routed through a 5V, 30Amp heatsinked DC-DC converter. To protect his LiPo batteries from over discharge, he built four voltage monitoring modules. Each had a TC54 voltage detector and an N-channel MOSFET which switches off the LiPo before its voltage dips below 3V. He bundled in a fuse and an indicator, and put each one in a neat 3D printed enclosure.

The mechanical design is pretty polished. Each of the 180 basic modules is a triangular PCB with three WS2812B’s, filter capacitors, and heavy copper pours for power connections. The PCB’s are assembled in panels of six and five units each, which are then put together in two hemispheres to form the whole sphere. His first round of six prototypes set him back as he made a mistake in the LED footprint. But it still let him check out the assembly and power connections. For mechanical support, he designed an internal skeleton that could be 3D printed. There’s a mounting frame for each of the PCB panels and a two piece central sphere. Fibreglass rods connect the central sphere to each of the PCB panels. This lets the whole assembly be split in to two halves easily.

It took him over six months and lots of cash to complete the project. But the assembly is all done now and electrically tested. Next up, he’s working on software to add animations. He’s received suggestions to add sensors such as microphones and accelerometers via comments on Reddit. If you’d like to help him by contributing animation suggestions, he’s setup a Readme document on Dropbox, and a Submission form. Checkout the SolCrusher website for more information.

Thanks [Vinny Cordeiro], for letting us know about this build.

Mathematicians. If you let them use the concept of infinity, there’s almost nothing they won’t be able to prove. Case in point: the Turing machine. The idea is that with an infinite length of tape, one could build a thought-experiment machine with only a few instructions that should be able to compute anything that’s computable.

[Igor]’s Turing machine is one of the nicest we’ve ever seen built. The “tape” is significantly shorter than infinity, which limits the computations he can achieve, the use of 3D printing, electric contacts, and WS2812 RGB LEDs for the tape are profoundly satisfying.

A bit on the tape is portrayed as unused if the LED is off, zero if it is red, and one if it is green. Each station on the tape is indexed by a set of blue LEDs observed by the gantry of the writing head which uses a 3D printed finger and motor to change the state of each bit. Programs are stored on a home-built punch card, which gets extra geek points from us.

Watch it run through “busy beaver” (embedded below) and tell us that it’s not awesome, even if it is a couple of LEDs short of infinity.

For more Turing machine builds, check out this exquisite version, this one made from Lego, and this Turing machine played out on an infinite deck of Magic the Gathering cards (what?!?!).

Sequencers allow you to compose a melody just by drawing the notes onto a 2D grid, virtually turning anyone with a moderate feel for pitch and rhythm into an electronic music producer. For  [Yuvi Gerstein’s] large-scale grid MIDI sequencer GRIDI makes music making even more accessible.

Instead of buttons, GRIDI uses balls to set the notes. Once they’re placed in one of the dents in the large board, they will play a note the next time the cursor bar passes by. 256 RGB LEDs in the 16 x 16 ball grid array illuminate the balls in a certain color depending on the instrument assigned to them: Drum sounds are blue, bass is orange and melodies are purple.

Underneath the 2.80 x 1.65 meters (9.2 x 4.5 foot) CNC machined, sanded and color coated surface of the GRIDI, an Arduino Uno controls all the WS2812 LEDs and reads back the switches that are used to detect the balls. A host computer running Max/MSP synthesizes the ensemble. The result is the impressive, interactive, musical art installation you’re about to see in the following video. What better tune to try out first than that of Billie Jean whose lighted sidewalk made such an impression on the original music video.

If you like LED clocks and illuminated bicycle wheels, [Harald Coeleveld] has just the right weekend project for you. His RGB pixel LED clock is as simple as it is beautiful, and it can be built in no time: The minimalist and sporty design consist of not much more than a LED strip wrapped around a bicycle wheel rim.

[Harald] took 2 meters of addressable WS2812 LED strip (with 30 LEDs per meter, we assume), wrapped it around a 27″ bicycle rim padded with a foam strip, and obtained 60 equally spaced RGB LEDs on a ring, ideal for displaying time. Apparently, the rim-tape circumference of this particular 27″ bicycle wheel is close enough to 2 meters, so it lines up perfectly.

On the electronics side, the project employs an Arduino Nano and a DS3231 precision RTC module. For switching between two illumination modes for day and night, [Harald] also added a photoresistor. During the day, colored dots around the ring display the time: A red dot for the seconds, a blue one for the minutes, and a group of 3 green LEDs for the hours. At night, the entire ring shimmers with an effective red glow for easier readability.

The Arduino code for this build can be downloaded from the project page, enabling anyone to effortlessly replicate this design-hack in under an hour!

You would think that there’s nothing to know about RGB LEDs: just buy a (strip of) WS2812s with integrated 24-bit RGB drivers and start shuffling in your data. If you just want to make some shinies, and you don’t care about any sort of accurate color reproduction or consistent brightness, you’re all set.

But if you want to display video, encode data in colors, or just make some pretty art, you might want to think a little bit harder about those RGB values that you’re pushing down the wires. Any LED responds (almost) linearly to pulse-width modulation (PWM), putting out twice as much light when it’s on for twice as long, but the human eye is dramatically nonlinear. You might already know this from the one-LED case, but are you doing it right when you combine red, green, and blue?

It turns out that even getting a color-fade “right” is very tricky. Surprisingly, there’s been new science done on color perception in the last twenty years, even though both eyes and colors have been around approximately forever. In this shorty, I’ll work through just enough to get things 95% right: making yellows, magentas, and cyans about as bright as reds, greens, and blues. In the end, I’ll provide pointers to getting the last 5% right if you really want to geek out. If you’re ready to take your RGB blinkies to the next level, read on!

Gamma

If you’ve ever dimmed a single LED using pulse-width modulation (PWM) before, you have certainly noticed that the response is non-linear. If you ramp up the duty cycle from 0% to 100%, it looks like the LED gets brighter very quickly in the beginning and then somewhere around the 50% mark stops getting brighter at all. On a WS2812, with its eight-bit-per-color resolution, stepping from a red value of 5 to a red value of 10 more than doubles the apparent brightness, while stepping from 250 to 255 can barely be noticed at all.

It’s not the LED or the PWM controlling it that’s to blame, however. It’s your eyes.. We perceive brightness using some kind of power law: if B is perceived brightness and L is the luminance — the amount of physical light that’s getting through your irises — the relationship looks roughly something like this:

That exponential relationship, requiring more and more additional light to create a perceptible difference in brightness, is characterized by that Greek exponent: gamma. For your intuition, gamma values from just around 1.5 to around 3 are probably reasonable to consider. Arbitrarily picking gamma to be 2 makes that fractional gamma exponent into a more comfortable square root and usually isn’t too far wrong. 2.2 is a standard value for CRT monitors in the PC world, and 1.8 used to be the standard for Macs.

But if you really care about the way your LEDs look, you’ll want to tweak the gamma to your particular conditions. I like to think of choosing a gamma in terms of black-and-white photography. If we gamma-correct with a value that’s bigger than your eye’s natural gamma an image will look too contrasty — there will be jumps in the brightness where you’d want it to be smooth. If the gamma is set lower than your eye’s gamma, differences will be muted, and it will look muddy. Get it just right, and you get a smooth transition from dark to light across the full range.

Taking the 2.314’th root of a given number is a tall task to ask of a microcontroller, though, and it’s probably overkill. In the end, I usually implement the gamma correction as a lookup table that turns the desired brightness directly into whatever numbers the chip’s PWM routine wants, so there’s no math left to do at all at runtime. Here’s a quick and dirty Python script that will generate the lookup table for you.

Now in Color

Gamma correction can make your single-color LED effects look a lot better. But what happens when you step up from monochrome to RGB color? Imagine that you’ve gone through the whole gamma experiment above with just the red channel of a WS2812 LED. Now you add the green and blue LEDs to the mix. How much brighter does it seem? If you weren’t paying attention above (yawn, math!) you’d say three times brighter. The right answer is the gamma’th root of three.

Strictly speaking, computing brightness depends on the mix of light coming out of all three LEDs. The good news is that you can also figure out the brightness of any arbitrary color combination with gammas. Here’s the formula:

Given any ratio of red to green to blue, you can use this formula to work out the PWM values for each LED that you need to brighten or dim the overall color in equally-sized steps.

Cross-Fading

The other use of the brightness formula above is in fading from one color to another, keeping the perceived brightness constant. For instance, to fade from red to blue naïvely, you might start at (255,0,0) and head over toward (0,0,255) by subtracting some red and adding the same amount of blue. Plugging those values into the brightness formula, the result appears significantly dimmer in the middle: down to about 70% of the brightness of the pure colors. Unfortunately, this is the way that nearly everyone online tells you to do it. That doesn’t make it right. (Or maybe they just don’t care about brightness?)

A great way to figure out the gamma that you’d like for RGB LEDs is to set up a color fade and adjust the gamma until there is apparently uniform brightness across the strip. In fact, you can do this with just three LEDs. To make the effect most dramatic, it helps to start with medium brightness on either end of the fade: I’ll use (70,0,0) and (0,70,0) for instance. The middle LED should be some kind of yellow with equal parts of red and green. Tweak the amounts of these values until you think that all three LEDs are about the same brightness, and you can solve for your personal gamma.

Color Palettes and Lookup Tables

On a slow microcontroller, or on one that should be doing more important things with its CPU time than computing colors, constantly adjusting color values for brightness is a no-go. In the single-LED case, a lookup table worked well. But in RGB space, a three-dimensional array is needed. For a small number of colors, this can still be workable: five levels of red, blue, and green produces a palette with only 125 (5³) entries. If you’ve got flash memory to spare, you can extend this as far as you’d like.

An alternative workaround is to gamma-adjust the individual channels first. This gets the brightness right, but it also affects the rate at which the hue changes across the cross-fade. You might like this effect or you might not — the best is to experiment. It’s certainly simple.

Color Sensitivity and Other Details

For me, getting control of the brightness of a color LED is about 95% of the battle. The remaining 5% is in getting precise control of the hue. That said, there are two quirks of the human visual system that matter for the hues.

The situation with the cross-fade of colors is actually more complicated than I’ve made them out to be; the eye isn’t uniformly sensitive to each wavelength of light. If you mixed together 10 lumens of red, 10 lumens of green, and 10 lumens of blue, the result would look overwhelmingly blue. The good news is that this effect is so strong that monitor and RGB LED manufacturers pre-weight the amount of light coming out of each LED for you.

So when you assign a value of (10%, 10%, 10%) to an RGB LED, each of the red, green, and blue LEDs are on for 10% of the time, but the green LED is about three times brighter than the red, and ten times brighter than the blue. The LEDs used take care of the (rough) color-balancing for you, so at least that’s one thing that you don’t have to worry about.

Perceptual Uniformity of Hue

If you’re trying to encode numerical values in colors, however, there’s one last quirk of the human perceptual system that you might want to be aware of. We are more sensitive to differences in some colors than in others. In particular, hues around the yellow and cyan regions are really easy for us to distinguish, while different shades of reds and blues are much more difficult. Getting this right is non-trivial, not least because our perception of one color depends on the colors that it’s surrounded by. (Remember the “white and gold” dress?)

Anyway, here’s a library that does pretty darn well at addressing the perceptual uniformity of hues issue, given they’re constrained to using piecewise linear functions. They sacrifice some degree of uniform brightness to get there, though.

If you just need a few colors along a perceptually uniform color gradient, Color Brewer has your back. Python’s matplotlib is going to change its default color scale to one with significantly increased perceptual uniformity and constant brightness, and this video explaining why and how has a great overview of the subject. It’s not simple, but at least they’re getting it right.

Finally, if you’d really like to dive into color theory, this series has much more detail than you’re ever likely to need to know.

Conclusion

You can get lost in colors fairly easily, and it’s fun and rewarding to geek out a bit. On the other hand, you can make your LED blinky toys look a lot better just by getting the brightness right, and you do that by figuring out the appropriate gamma for your situation and applying a little math. The “right” gamma is a matter of trial and error, but something around two should work OK for starters. Give it a shot and let me know what you think in the comments. Or better yet, use RGB-gamma-correction in your next project and show us all.

We saw this jacket at the UK’s Electromagnetic Field festival (Thanks [Jasmine] for the tip!), LED jackets are a festival favourite. We’ve had quite a few LED jackets over the years, here’s a round-up we did in 2013.

[Martin Hubáček] wrote in with his WS2812 LED library for the STM32F3 series processors. [Martin]’s library takes the same approach as [Paul Stoffregen]’s OctoWS2811 for the Teensy, and [Erich Styger]’s for the Freescale FRDM-K64F board. That is, it uses three DMA channels to get the signal out as fast as possible.

He has a good overview of the method that you can check out for details, but it goes something like this. The WS2812 uses a PWM-like encoding to transfer data. If the signal is high for 1/3 of the time, it’s a zero, and if it’s high for 2/3 of the time, it’s a one.

The first DMA signal sends the start of a bit, setting all outputs high. The second DMA channel sends out a low signal for all of the zeros, and the third DMA channel sends out a low signal for the ones. Each of these three DMAs are clocked at just the right times to make the pulse timing work out.

The advantage of this GPIO/DMA setup over other methods is that it can drive a whole bank of pins — up to 16 strips simultaneously for the STM32F10x chips. It also loops the graphic buffer around so that you can drive repeating patterns without using much memory. And all the CPU has to do is load up the DMA buffer when it’s (half) empty, which means that even with a full load of LEDs, it’s still got most of its time left for number crunching.

Finally, to show off, [Martin] pulled a sweet trick and captured it on video. Since the digital signals are on/off encoded for the red, green, and blue channels, he decided to experiment with digital color mixing. He ands and ors two simultaneous signals together and demonstrates that it works just as you’d expect. Check it out in the video below.

[Facelessloser] is interested in glanceable information. Glancable devices are things like your car’s dashboard, your wristwatch, or widgets on a smartphone lockscreen. The glanceable information distribution system in this case is rpi_status, [facelessloser’s] entry in the Enlightened Raspberry Pi Contest.

[Facelessloser] coupled a ring of eight WS2812 RGB LEDs with a small OLED screen managed by a the common ssd1306 controller. Since he was rolling his own board for this project, [faceless] some buttons and a BMP180 temperature sensor. Going with popular parts like this meant libraries like the Pimoroni unicorn hat library for the WS2812 were readily available.

A simple display like this can show just about anything – from status of a nightly software build, to traffic along your morning commute. [Facelessloser] is using it for weather data. His data source is Weather Underground’s API. Weather information is displayed on the OLED. The WS2812’s display the temperature. A single blue light means cold. The ring fills as the temperature warms up. After eight degrees of blue, the color changes to orange, followed by red.

Check out the video after the break for a short demo of the board.

Just teach us a how to do something awesome with a Pi. (See more entries)