“We want to get this done quick, not right.”
[CNLohr]’s favorite desk lamp broke, so he gave himself a challenge: convert the lamp to LED and control it via WiFi within 5 hours, from scratch. He video recorded and narrated the whole process and did a nice job of explaining the tricky parts and failures along the way, fast forwarding us through the slow parts.
Some bits and pieces were simple and obvious: gut the old bulb, wire some LEDs, add a few power resistors, toss in a power supply from “like a monitor or something, don’t care” for the LEDs, add in what looks like an LM2596 adjustable power supply for the logic, some kind of ATMega, that new ESP8266 (Wi07C), splice on a power cord, etc. Standard stuff.
To our readers who’s hacks tend to start with soldering irons and screwdrivers, the video shows harder parts of designing an electronics project: creating the PCB in software (he used KiCad), lithographically transferring the circuit to a PCB, bismuth solderpasting & populating the board, and writing and documenting his code on Github. Perhaps most reassuringly, he also showed the consequences of every greedy shortcut and the process of troubleshooting around them.
If you have ever tried to follow a recipe from a cooking show and noticed how easy it all seems when everything is measured and prepped beforehand – and then what a disaster it is when you try it – the same is revealed here. Overall, it is a very thorough demonstration of what it actually takes to design a project – not just perfect circuits and perfect steps to follow.
In the end he got it done
in the nick of time an hour late because he cannot add. Close enough.
Thanks [gokkor] for the tip.
Whether you call them individually controllable RGB LEDs, WS2812, or NeoPixels, there’s no denying they are extremely popular and a staple of every glowey and blinkey project. Fresh off the reel, they’re nearly useless – you need a controller, and that has led to many people coming up with many different solutions to the same problem. Here’s another solution, notable because it’s the most minimal WS2812 driver we’ve ever seen.
The critical component in this build is NXP’s LPC810, an ARM Cortex M0+ in an 8-pin DIP package. Yes, it’s the only ARM in a DIP-8, but still able to run at 30MHz, and hold a 4kB program.
JeeLabs is using the SPI bus on the LPC810 to clock out data at the rate required by the LEDs. The only hardware required is a small LED to drop the voltage from 5V to 3.3V and a decoupling capacitor. Yes, you could easily get away with this as a one-component build.
The build consists of a ring of sixty WS2812b RGB LEDs, and the chip dutifully clocking out bits at the correct rate. It’s the perfect start to an LED clock project, an Iron Man arc reactor (are we still doing those?), or just random blinkey LEDs stuffed into a wearable.
Thanks [Martyn] for sending this one in.
[Stephen] designed a standalone Ambilight clone built around an FPGA and recently added many new features to make his design even better. His original design was based around a Spartan 3-E FPGA, but his new design uses the Papilio One board with a Spartan-6 LX9 FPGA. This gives him dedicated DSP hardware and more RAM, allowing him to add more processing-intensive features.
[Steven]’s new board can drive up to 4096 LEDs total, and each LED is colored from one of 256 segmented screen areas. The output of the LEDs is smoothed over a configurable time period which makes the result a bit more pleasant. [Steven] also added color correction matrices and gamma correction tables to make up for differences in LED coloration and so the output can be fine-tuned to the color of the wall behind the TV.
Finally, [Steven] added multiple configurations which can be stored in Flash memory. The FPGA can detect letterboxes and pillarboxes in the video stream and change to a corresponding configuration automatically, so settings rarely need to be manually adjusted. He also added an extensive serial interface to configure all of the parameters and configurations in Flash. Be sure to check out the video after the break to see his setup in action.
Continue reading “FPGA Ambilight Clone Packs a Ton of Features”
It’s that time of the year again, and the halls are being decked with trees, the trees covered in lights, and everyone working in retail is slowly going insane from Christmas songs piped over the PA. [Dan] has a tree and a bunch of programmable LEDs, but merely pumping jollity down that strip of LEDs wouldn’t be enough. The Nerd Quotient must be raised even higher with a tree that displays a Unix timestamp.
This build was inspired by an earlier, non-tree-based build that displays Unix time on a 32 LED array. That build used an ATMega328p for toggling LEDs on and off. This time around, [Dan] is using a dedicated LED controller – the AllPixel – that just wrapped up a very successful Kickstarter campaign. The AllPixel is, in turn, controlled by a Raspberry Pi running the BiblioPixel library,
The tree displays the current time stamp in binary across 32 spaces, with green representing a ‘one’ and a red representing ‘zero’. The top of the tree is the least significant bit, but in case [Dan] gets tired of the bottom of the tree staying completely still for the rest of this holiday season, he can switch the order making the base of the tree the LSB.
Continue reading “The Epoch Christmas Tree”
[Tim] got his hands on some APA102 RGB LEDs, which are similar in function to the common WS2812 addressable LEDs seen in many projects we’ve featured. The advantage of APA102 LEDs is that they don’t have the strict timing requirements of the WS2812. These LEDs are controlled with a SPI bus that can be clocked at any arbitrary rate, making them easy to use with pretty much any microcontroller or embedded system.
After working with the LEDs, [Tim] discovered that the LEDs function a bit differently than the datasheet led him to believe. [Tim] controlled a strand of APA102 LEDs with an ATtiny85 and connected a logic analyzer between some of the LEDs. He discovered that the clock signal of the SPI interface isn’t just passed through each LED, it actually looks like it’s inverted on the output. After some investigation, [Tim] found that the clock signal is delayed by a half period (which looks like an inversion) before it’s passed to the next LED. This gives the next LED in the strand enough time for data on the data line to become valid before latching it in.
Since the clock is delayed, [Tim] discovered that additional bits must be clocked as an “end frame” to generate clock signals which propagate the remaining data to the end of the strand. Although the datasheet specifies a 32-bit end frame, this only works for strings of up to 64 LEDs. More bits must be added to the end frame for longer strands, which the datasheet doesn’t even mention. Check out [Tim]’s post for more information, where he walks you through his logic analysis of the APA102 LEDs.
This schematic is all you need to build your own voltage converter. [Lutz] needed a converter that could boost 5 V to 30 V to power a string of LEDs. The solution was to use low cost ATtiny85 and some passive components to implement a boost converter.
This circuit follows the classic boost converter topology, using the ATtiny85 to control the switch. The 10 ohm resistor is fed back into the microcontroller’s ADC input, allowing it to sense the output voltage. By measuring the output voltage and adjusting the duty cycle accordingly, the circuit can regulate to a specified voltage setpoint.
A potentiometer is used to change the brightness of the LEDs. The software reads the potentiometer’s output voltage and adjusts the voltage output of the circuit accordingly. Higher voltages result in brighter LEDs.
Of course, there’s many other ways to implement a boost converter. Most practical designs will use a chip designed for this specific purpose. However, if you’re interested in rolling your own, the source and LTSpice simulation files are available.
Photographer [Stephen Orlando] has an awesome body of work that focuses on human motion. The images he captures with colored light and a camera set up in a setting of choice tell a story of time in a way that’s visually stunning.
[Stephen] has experimented with various types of action. He’s attached LED strips onto props like oars in order to capture the rhythmic movements of rowing, or directly onto parts of the body to visualize more chaotic gestures, like the forms of a martial artist. His camera is set up to take long exposures, soaking in the light as it plots itself through space over time.
Though this isn’t a hack directly in itself, [Stephen’s] experimentation with time and light is a great case of technology being added to the arsenal of traditional mediums we’re accustomed to seeing in the production of artistic work. The clean execution of his idea to tell a story about what we don’t typically get to see by use of light should inspire all of us who love to play around with LEDs in our projects. Sometimes the more interesting aspects of our work are created in the negative space we forget to consider.
The next time you find yourself working on a hack, look at what you’re creating from a perspective beyond its original context. For example, 3D printing with a delta robot is a bit of a departure from it’s original purpose as a pick and place machine. Even further yet is the concept of using one to draw images in space with light. Often the process of somethings creation, as well as the byproduct of what it took to make it, is just as worthy of investigation. Don’t forget to search between the lines… that’s where the magic is.