A few years ago, [Marc] had access to a really big, very expensive 3D printer. Daft Punk helmets were – and still are – extremely cool builds, so with a bit of modeling, [Marc] and his friend [Alex] put together a model and printed out a Daft Punk [Thomas] helmet with the intention of turning it into the keystone of a great costume. A few things got in the way, and the [Thomas] helmet was left on a shelf for a few years. Fast forward to a few months ago and [Marc] took up the project again. The result is a 3D printed Daft Punk helmet loaded up with 320 WS2811 LEDs.
The 3D printed helmet was modeled well and printed in polycarbonate, but with any extrusion-based printer, there will be ridges and layers to sand, fill, prime and paint. This task was delegated to another friend, [Shaggy], while [Marc] got busy on the electronics.
The LEDs for the visor and ‘earmuffs’ are WS2811 LEDs, but not the SMD versions we’re so used to seeing. These are 8mm through-hole LEDs mounted in a lasercut piece of acrylic. Control of the LEDs is done with a Teensy 3.1 with [Paul Stoffregen]’s OctoWS2811 library. With the matrix wired up, batteries installed, WiFi capability added, and the helmet painted (not chromed; that will probably happen later, though), [Marc] had a copy of the [Thomas] helmet controllable through an iPhone.
If you’d like to check out more of [Marc]’s work, we posted something on his RGB LED suit and pneumatic Star Trek doors a few years ago.
Continue reading “iPhone-Controlled Daft Punk Helmet”
[Andrew] wrote in with a new take on the classic persistence of vision bike spoke hack. While many of these POV setups use custom PCBs and discrete LEDs, [Andrew]’s design uses readily available off-the-shelf components: WS2811 LED strips, an Arduino, an Invensense IMU breakout board, and some small LiPo batteries.
[Andrew] also implemented a clever method of controlling his lights. His code detects when the rider taps the brakes in certain patterns, which allows changing between different light patterns. He does note that this method isn’t incredibly reliable due to some issues with his IMU, so now he senses when the rider taps on the handlebars as well.
If you want to build your own bike POV setup, you’re in luck. [Andrew] wrote up detailed instructions that outline the entire build process. He also provides links to sources for each part to make building your own setup even easier. His design is pretty affordable too, coming in at just under $50 per wheel. Check out a video of [Andrew]’s setup in action after the break.
Continue reading “Simple POV Bike Effects with WS2811 Strips”
Last year, [Ytai] went to Burning Man for the first time. He was a bit inexperienced, and lacked the lumens to make him visible on the Playa. This year, he made up for it by building an extra bright LED Jacket.
The jacket consists of 48 LEDs, at 150 lumens each. Each RGB LED module was placed on its own PCB, and controlled by the tiny PIC12F1571 microcontroller. This microcontroller was a great fit since it has three PWM channels (one for each color) and costs 50 cents. Firmware on the PIC allows the boards to be daisy-chained together to reduce wiring. This was done by using a protocol similar to the popular WS2811 LEDs.
Assembling 50 of the boards presented a challenge. This was addressed by using surface mount components, a solder stencil from OSH Stencils, an electric skillet, and a good amount of patience. The final cost of each module was about $3.
With 50 of the boards assembled, a two layer jacket was sewn up. The electronics were sandwiched between these two fabric layers, which gave the jacket a clean look. A wrist mounted controller allows the wearer to select different patterns.
For a full rundown of the jacket, check out the video after the break.
Continue reading “A Very Bright LED Jacket”
Typically bit-banging an I/O line is the common method of driving the WS2812B (WS2811) RGB LEDs. However, this ties up precious microcontroller cycles while it waits around to flip a bit. A less processor intensive method is to use one of the built-in Serial Peripheral Interface (SPI) modules. This is done using specially crafted data and baud rate settings, that when shifted out over the Serial Data Out (SDO) pin, recreate the needed WS2812B signal timing. Even when running in SPI mode, your hardware TX buffer size will limit how many pixels you can update without CPU intervention.
[Henrik] gets around this limitation by using peripheral DMA (Direct Memory Access) to the SPI module in the Microchip PIC32MX250F128B microcontroller. Once properly configured, the DMA controller will auto increment through the defined section of DMA RAM, sending the pixel data over to the SPI module. Since the DMA controller takes care of the transfer, the micro is free to do other things. This makes all of DMA memory your display buffer. And leaves plenty of precious microcontroller cycles available to calculate what patterns you want the RGB LEDs to display.
Source code is available at the above link for those who would like to peruse, or try it out. This is part of [Henrik’s] Pixel Art Project. Video of DMA based SPI pixels after the break:
Continue reading “Driving WS2812B Pixels, With DMA Based SPI”
NeoPixels, or WS2812 RGB LEDs, are the display device du jour for impressive and blinding lighting projects. Commonly known for very tight timing requirements, [Josh] discovered this is, in fact, usually unnecessary. The timing requirements for NeoPixels aren’t as bad as they seem, once you get to know them.
The official WS2812 timing specs give values that are fairly constraining for anyone writing a library to drive these RGB LED pixels, but simplifying the timing diagram by assuming a 50% duty cycle on the data lines and ignoring the longer maximum times results in a surprising conclusion: the only tight timing parameter for NeoPixel signaling is the maximum width of the 0-bit pulse.
Realizing this, [Josh] wrote a simple demo program to drive over 1000 NeoPixels – an 11 meter long strip – using 1K of RAM on an Arduino. The trick comes by simply delaying the bitbanging a set number of cycles. No obtuse assembly required.
There is only one problem with [Josh]’s method of driving a nearly unlimited amount of NeoPixels – building a display where every NeoPixel is an element in a larger image, such as in a video display, is impossible on systems with limited amounts of RAM. The code writes values to the NeoPixel strip algorithmically, so if you can’t build your animation with for loops, you’re out of luck. Still, Driving this many NeoPixels is a migraine trigger, and we have to give [Josh] credit for doing this with 1K of RAM.
Check out the video of [Josh]’s extreme NeoPixel strip below.
Continue reading “Driving 1000 NeoPixels With 1k Of Arduino RAM”
[Finchronicity] over on Hackaday Projects has made a pretty awesome furry LED Vest to keep him warm and well lit at this year’s Burning Man. He is using a Teensy 3.0 that drives strips of 470 WS2811 LEDs.
The vertically aligned strips run on a continuous sequence which reaches up to 31 frames per second using precompiled animations. The effects rendered in Processing or video mapped, are captured frame by frame and stored as raw color data to an SD card. Playback uses the NeoPixel library to control the strips. The high resolution LEDs, with the video mapped fire and the long pile fur, create one of the nicest flame effects we have seen on clothing.
We’ve also seen the Teensy 3.0 and WS2811 LEDs used as a popular combination for building huge displays, a 23ft tall pyramid, and more recently in the RFID jacket at Make Fashion 2014. Have you made or seen a great Teensy/WS2811 project you would like to share with us? If so, let us know the details in the comments below.
Continue reading “Wearable flames with fur and LED strips”
One morning [overflo] decided to protest the European Parliament’s stance on equine rights of defecation, a cherished liberty dating back to the time of Charlemagne. The best way to do this is, of course, blinking lights. He calls his project Blinkenschild, and it’s one of the best portable LED displays we’ve seen.
The display is based around fifteen RGB-123 LED panels, each containing an 8×8 matrix of WS2811 LEDs. That’s 960 pixels, all controlled with a Teensy 3.1. Power is supplied by fifteen LiPo cells wired together in parallel giving him 6 Ah of battery life. Clunky, yes, but it’s small enough to fit in a backpack and that’s what [overflo] had sitting around anyway.
The animations for the display are generated by Glediator, an unfortunately not open source control app for LED matrices. Glediator sends data out over a serial port but not over IP or directly into a file. Not wanting to carry a laptop around with him, [overflo] created a virtual serial port and dumped the output of Glediator into a file so it could be
played back stored on an SD card and controlled with an Android app. Very clever, and just the thing to raise awareness of horse and Internet concerns.
UPDATE: Check out [overflo’s] clarification in the comments below.
Continue reading “Blinkenschild, The RGB LED Display For Every Occasion”