Posts | Comments

Planet Arduino

Archive for the ‘led hacks’ Category

Light painting: there’s something that never gets old about waving lights around in a long exposure photo. Whilst most light paintings are single shots, some artists painstakingly create frame-by-frame animations. This is pretty hard to do when moving a light around by hand: it’s mostly guesswork, as it’s difficult to see the results of your efforts until after the photo has been taken. But what if you could make the patterns really precise? What if you could model them in 3D?

[Josh Sheldon] has done just that, by creating a process which allows animations formed in Blender to be traced out in 3D as light paintings. An animation is created in Blender then each frame is automatically exported and traced out by an RGB LED on a 3D gantry. This project is the culmination of a lot of software, electronic and mechanical work, all coming together under tight tolerances, and [Josh]’s skill really shines.

The first step was to export the animations out of Blender. Thanks to its open source nature, Python Blender add-ons were written to create light paths and convert them into an efficient sequence that could be executed by the hardware. To accommodate smooth sliding camera movements during the animation, a motion controller add-on was also written.

The gantry which carried the main LED was hand-made. We’d have been tempted to buy a 3D printer and hack it for this purpose, but [Josh] did a fantastic job on the mechanical build, gaining a solidly constructed gantry with a large range. The driver electronics were also slickly executed, with custom rack-mount units created to integrate with the DragonFrame controller used for the animation.

The video ends on a call to action: due to moving out, [Josh] was unable to continue the project but has done much of the necessary legwork. We’d love to see this project continued, and it has been documented for anyone who wishes to do so. If you want to check out more of [Josh]’s work, we’ve previously written about that time he made an automatic hole puncher for music box spools.

Thanks for the tip, [Nick].

As if you already weren’t agonizing over whether or not you should build your own arcade cabinet, add this one to the list of compelling reasons why you should dedicate an unreasonable amount of physical space to playing games you’ve probably already got emulated on your phone. [Rodrigo] writes in to show off his project to add some flair to the lighted buttons on his arcade controller. (Google Translate)

The wiring for this project is about as easy as you’d expect: the buttons connect to the digital inputs on the Arduino, and the LEDs on the digital outputs. When the Arduino code sees the button getting pressed, it brings the corresponding LED pin high and starts a fade out timer using the SoftPWM library by [Brett Hagman].

It’s worth noting that the actual USB interface is being done with a stand-alone controller, so the Arduino here is being used purely to drive the lighting effects. The more critical reader might argue that you could do both with a single microcontroller, but [Rodrigo] was in a classic “Use what you’ve got” situation, and already had a USB controller on hand.

Of course, fancy lit arcade buttons won’t do you much good without something to put them in. Luckily we’ve covered some fantastic looking arcade cabinets to get you inspired.

Tired of risking his life every time he had to signal a turn using his hands while riding his bicycle in rainy Vancouver, [Simon Wong] decided he needed something a bit higher tech. But rather than buy something off the shelf, he decided to make it into his first serious Arduino project. Given the final results and the laundry list of features, we’d say he really knocked this one out of the park. If this is him getting started, we’re very keen to see where he goes from here.

So what makes these turn signals so special? Well for one, he wanted to make it so nobody would try to steal his setup. He wanted the main signal to be easily removable so he could take it inside, and the controls to be so well-integrated into the bike that they wouldn’t be obvious. In the end he managed to stuff a battery pack, Arduino Nano, and an HC-05 module inside the handlebars; with just a switch protruding from the very end to hint that everything wasn’t stock.

On the other side, a ATMEGA328P microcontroller along with another HC-05 drives two 8×8 LED matrices with MAX7219 controllers. Everything is powered by a 18650 lithium-ion battery with a 134N3P module to bring it up to 5 VDC. To make the device easily removable, as well as keep the elements out, all the hardware is enclosed in a commercial waterproof case. As a final touch, [Simon] added a Qi wireless charging receiver to the mix so he could just pull the signal off and drop it on a charging pad without needing to open it up.

It’s been some time since we’ve seen a bike turn signal build, so it’s nice to see one done with a bit more modern hardware. But the real question: will he be donning a lighted helmet for added safety?


[JohnathonT] has a two-year-old who can’t reliably tell time just yet. Every morning, he gets up before the rooster crows and barges into his parents’ room, ready to face the day.

In an effort to catch a few more Zs, [JohnathonT] built a simple but sanity-saving clock that tells time in a visual, kid-friendly way. Sure, this is a simple build. But if a toddler is part of your reality, who has time to make one from logic gates? The hardware is what you’d expect to see: Arduino Nano, a DS1307 RTC, plus the LEDs and resistors. We think an RGB LED would be a nice way to mix up the standard stoplight hues a bit.

At a glance, little Mr. Rise and Shine can see if it’s time to spread cheer, or if he has to stay in his room and play a bit longer. At 6:00AM, the light powers on and glows red. At 6:50, it turns yellow for 10 minutes. At the first reasonable hour of the day, 7:00AM, it finally turns green. In reading the code, we noticed that it also goes red at 8:00PM for 45 minutes, which tells us it also functions as a go-to-sleep indicator.

When his son is a little older, maybe [JohnathonT] could build him  a clock that associates colors with activities.

There are plenty of cheap projection clocks available, but as [Thomas Pototschnig] points out in this project, where’s the fun in just buying something? He set out to build a cheap projection clock using a small LCD screen, a cheap LED backlight, and a cheap lens. Cheap is the order of the day here, and [Thomas] succeeded admirably, creating a design that can be made with a couple of cheap PCBs, a 3D printer and the other parts mentioned above. He does a nice job of laying out his thinking in this design, showing how he calculated the projection path and made other decisions. His project has room to grow as well: it runs from an Arduino compatible STM32 that could handle many things other than showing the time if you were inclined to expand the project further.

[Thomas] has released all of the files he created for the project, including a number of options for the case that can use C-mount and Sony E-mount lenses. I’m not sure if you would want to attach your expensive camera lenses to a home-made projector like this, but it’s good to have the option if you have a dead E-mount lens that you were going to tear apart for parts anyway.

We’ve covered plenty of persistence of vision (POV) displays before, but this one from [Vadim] is rather fun: it’s built on top of a PC fan. He’s participating in a robot building competition soon and wanted to have a POV display. So, why not kill two birds with one stone and build the display onto a fan that could also be used for ventilation?

The display is a stand-alone module that includes a battery, Neopixels, Arduino and an NRF240L01 radio that receives the images to be displayed. That might seem like overkill, but putting the whole thing on a platform that rotates does get around the common issue of powering and sending signals to a rotating display: there is no need for slip connections.

[Vadim] goes into a good level of detail on how he built the display, including the problems he had diagnosing a faulty LED chip, and why it is important to test at each stage as it is easier to debug when the display isn’t whizzing around at high speed.

It’s a bit of a rough build that uses more protoboard than might be necessary, but we’re keeping our fingers crossed that it doesn’t fly off during the competition.

Light painting is a technique which allows you to “draw” on a photograph by moving a light past the camera during a long exposure shot. While it can be difficult to master, light painting allows for some incredible effects such as text and images that appear to be hovering in mid-air. Think of it like a very slow but much cooler version of an augmented reality app.

[Reven] recently wrote in to tell us about the Arduino light painter he put together, and while DIY (and even commercial) light painting gear isn’t exactly new at this point, we think he’s raised the bar a bit with his design. With the addition of a slick 3D printed enclosure and on-board display and menu system, his light painter looks exceptionally professional for being built out of hardware he had on hand.

On his blog, [Reven] has done a phenomenal job of documenting the build from start to finish. Not only does he include a detailed Bill of Materials and the STL files so you can build your own version of his light painter, he walks the reader though his design process and explains why he did the things he did. Even if you aren’t interested in building a light painter, there’s almost certainly something of interest for anyone who’s ever looked at a pile of parts on their workbench and wondered how they were going to turn it into a functioning device.

Powered by an Arduino Uno, the light painter provides a user interface on a 16×2 LCD which allows control over not only the brightness of the WS2812 LED strips but selecting and loading different images from the micro SD card. The case was designed in FreeCAD, and while [Reven] mentions there are a number of issues which could be improved, satisfies all his design goals.

We covered the original Adafruit project that [Reven] based his code all the way back in 2013, though there’s certainly been more modern interpretations of the idea since then.

Quality software development examples can be hard to come by. Sure, it’s easy to pop over to Google and find a <code> block with all the right keywords, but having everything correctly explained can be hit or miss. And the more niche the subject, the thinner the forum posts get. Bucking the downward trend [HansLuijten] provides an astoundingly thorough set of LED strip patterns in his comprehensive post titled Arduino LED strip effects.

Don’t let the unassuming title lead you astray from the content, because what’s on offer goes beyond your average beginner tutorial on how to setup a strand of NeoPixels. [HansLuijten] is thorough to a fault; providing examples for everything from simple single color fades and classic Cylon eyes to effects that look like meteors falling from the sky. Seriously! Check out the video after the break. Those chasing lights you see around theater signs? Check. Color twinkle and sparkle? Check. Color wipes and rainbow fades? Check, and check.

At this point, an average forum post would be a jumbled mess of source which only works on an authentic Arduino Duemilanove running at 3.3v sitting on top of the 2nd printing of the author’s favorite issue of Make. But not here! These samples work with Adafruit’s easy to use NeoPixel library as well as FastLED, the quickest pixel in the West. On top of that the examples are clear and concise and explanation is plentiful. But the best part is definitely that each effect has a video clearly showing what it looks like.

If only everything were this easy to use, the open source revolution would already be here.

Stecchino demo by the creator

Self-described “Inventor Dad” [pepelepoisson]’s project is called Stecchino (English translation link here) and it’s an Arduino-based physical balancing game that aims to be intuitive to use and play for all ages. Using the Stecchino (‘toothpick’ in Italian) consists of balancing the device on your hand and trying to keep it upright for as long as possible. The LED strip fills up as time passes, and it keeps records of high scores. It was specifically designed to be instantly understood and simple to use by people of all ages, and we think it has succeeded in this brilliantly.

To sense orientation and movement, Stecchino uses an MPU-6050 gyro and accelerometer board. An RGB LED strip gives feedback, and it includes a small li-po cell and charger board for easy recharging via USB. The enclosure is made from a few layers of laser-cut and laser-engraved material that also holds the components in place. The WS2828B LED strip used is technically a 5 V unit, but [pepelepoisson] found that feeding them direct from the 3.7 V cell works just fine; it’s not until the cell drops to about three volts that things start to glitch out. All source code and design files are on GitHub.

Games are great, and the wonderful options available to people today allow for all kinds of interesting experimentation like a blind version of tag, or putting new twists on old classics like testing speed instead of strength.

If you’ve spent any serious time in libraries, you’ve probably noticed that they attract people who want or need to be alone without being isolated. In this space, a kind of silent community is formed. This phenomenon was the inspiration [MoonAnchor23] needed to build a network of connected house plants for a course on physical interaction and realization. But you won’t find these plants unleashing their dry wit on twitter. They only talk to each other and to nearby humans.

No living plants were harmed during this project—the leaves likely wouldn’t let much light through, anyway. The plants are each equipped with a strip of addressable RGB LEDs and a flex sensor controlled by an Arduino Uno. Both are hot glued to the undersides of the leaves and hidden with green tape. By default, the plants are set to give ambient light. But if someone strokes the leaf with the flex sensor, it sends a secret message to the other plant that induces light patterns.

Right now, the plants communicate over Bluetooth using an OpenFrameworks server on a local PC. Eventually, the plan is use a master-slave configuration so the plants can be farther apart. Stroke that mouse button to see a brief demo video after the break. [MoonAnchor23] also built LED mushroom clusters out of silicone and cling wrap using a structural soldering method by [DIY Perks] that’s also after the break. These work similarly but use force-sensing resistors instead of flex-sensing.

Networking several plants together could get expensive pretty quickly, but DIY flex sensors would help keep the BOM costs down.

  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook