Posts | Comments

Planet Arduino

Archive for the ‘LED’ Category

There’s not much time left now. If you’re going to put something together to give the youngsters some night terrors in exchange for all that sweet candy, you better do it quick. This late to the game you might not have time to do anything too elaborate, but luckily we’ve come across a few quick Halloween hacks that can get you some pretty cool effects even if it’s only a few hours before the big night.

As a perfect example, these LED “blinking eyes” were created by [Will Moser]. Using nothing more exotic than some bare LEDs, an Arduino, and a cardboard box, these little gadgets can quickly and easily be deployed in your windows or bushes to produce an unsettling effect after the sun goes down. Thanks to the pseudorandom number generator in the Arduino code, the “eyes” even have a bit of variability to them, which helps sell the idea that your Halloween visitors are being watched by proper creatures of the night.

The hardware side of this project is very simple. [Will] takes a container such as a small cardboard box and cuts two holes in it to serve as the eyes. He notes that containers which are white or reflective on the inside work best. You’ll want to get a little artistic here and come up with a few different shaped sets of eyes, which is demonstrated in the video after the break. Inside each box goes a colored LED, wired back to the Arduino.

For the software, [Will] is using a floating analog pin as a source of random noise, and from there comes up with how often each LED will blink on and off, and for how long. Both the hardware and software sides of this project are perfect for beginners, so it might be a good way to get the Little Hackers involved in the festivities this year; if you’re the type of person who enjoys replicating small humans in addition to creeping them out.

LEDs seem to be the hacker’s decoration of choice come Halloween, from wearable LED eyes to remote controlled illuminated pumpkins.

We’ll admit it: sometimes we overthink things. We imagine some of you are the same way; there seems to be something in the hacker mentality that drives us to occasionally over-engineer ideas to the point of unrecognizability. There’s nothing inherently wrong with this, but sometimes it does keep us from seeing easier solutions.

For example, the very slick looking personalized LED sign (Google Translate) that [Clovis Fritzen] recently wrote in to share with us. If we were tasked with creating something like this there would certainly have been a 3D printer and likely a CNC involved before all was said and done, and a few days later we’d still be working out the bugs in our OpenSCAD code. But his approach is very different. Fantastically simple and constructed largely from household items, this is a good project to keep the Junior Hackers entertained on a rainy weekend.

The first step of the process is to draw out the characters you want onto a piece of cardboard, and then carefully cut it out. If you’re worried that you’re not particularly artistic, this step will go a bit better if you print out the design and tape the paper over the cardboard to serve as a template. Once you’ve got your design cut out, you glue or tape a piece of standard printer paper over it. This is the face of the display; it just needs to be lit from behind.

If you wanted to make a sign that was just a single color and didn’t have individually addressable elements, then it would be enough to illuminate the whole cutout with a single light source. But where’s the appeal in that? As [Clovis] shows, you can get much better results by constructing a segmented box, with one LED in each cell. By wiring each LED to a pin on an Arduino or other microcontroller, you’ll have control over the color and brightness of each section of the sign.

Of course, if you’re not big on the whole cardboard aesthetic, you could even recreate this design with the aforementioned CNC and 3D printer. [Clovis] shows how the basic concept works, and that it can be scaled pretty easily depending on the kind of materials you have access to.

When you show up at a party wearing this bare PCB watch, there are effectively two possible reactions you might receive from the other people there. Either they are going to snicker at the nerd who’s wearing a blinking circuit board on their wrist in public, or they are going to marvel at the ridiculously low part count. We’ll give you one guess as to which reaction you’d likely get at any event Hackaday is involved in.

Designed and built by [Electronoobs], this extremely simple watch consists of a ATmega328P microcontroller, a dozen LEDs with their associated 200 Ω resistors, and a battery. There’s also a single push button on the front which is used to not only set the watch, but turn the LEDs on when you want to check the time. Short of dropping down to one LED and blinking out the time, it’s hard to imagine a timepiece with fewer components than this.

You’re probably wondering how [Electronoobs] pulled this off without an external clock source for the ATmega328P chip. The chip actually has an internal 8 MHz oscillator that can be used, but you need to flash the appropriate bootloader to it first. Accordingly, the backside of the PCB has both SPI and a UART solder pads for external bootloader and firmware programming.

As you might expect, there’s a downside to using the internal oscillator: it’s not very good. The ATmega328P spec sheet claims a factory calibrated accuracy of ±10%, and [Electronoobs] has found that equates to a clock drift of around 15 seconds per day. Not exactly great, but considering the battery only lasts for two days anyway, it doesn’t have much of an impact in this case.

Compared to other “analog” LED watches we’ve seen, the simplicity of this build is really quite remarkable. The closest competitor we’ve seen so far is this slick binary watch.

We’d seen it done with buttons, switches, gestures, capacitive touch, and IR remote, but never like this. [electron_plumber] made an LED that can be blown out like a candle, and amazingly it requires no added sensors. The project uses an Arduino to demonstrate turning a tiny LED on and off in response to being blown on, and the only components are the LED and a resistor.

[electron_plumber] used an 0402 LED and thin wires to maximize the temperature responses.
How is this done? [electron_plumber] uses an interesting property of diodes (which are the “D” in LED) to use the LED itself as a temperature sensor. A diode’s voltage drop depends on two things: the current that is being driven through the diode, and the temperature. If the current is held constant, then the forward voltage drop changes reliably in response to temperature. Turning the LED on warms it up and blowing on it cools it off, causing measurable changes in the voltage drop across the device. The change isn’t much — only a handful of millivolts — but the effect is consistent and can be measured. This is a principle [Elliot Williams] recently covered in depth: using diodes as temperature sensors.

It’s a clever demo with a two important details to make it work. The first is the LED itself; [electron_plumber] uses a tiny 0402 LED that is mounted on two wires in order to maximize the temperature change caused by blowing on it. The second is the method for detecting changes of only a few millivolts more reliably. By oversampling the Arduino’s ADC, an effectively higher resolution is obtained without adding any hardware or altering the voltage reference. Instead of reading the ADC once, the code reads the ADC 256 times and sums the readings. By working with the larger number, cumulative changes that would not register reliably on a single read can be captured and acted upon. More details are available from [electron_plumber]’s GitHub repository for LEDs as Sensors.

Embedded below is a video that is as wonderful as it is brief. It demonstrates the project in action, takes a “show, don’t tell” approach, and is no longer than it needs to be.

In the past we have seen LEDs that can be blown out like candles in different ways; one used a microphone to detect blowing while another used a thermistor to detect the temperature change from blowing. [electron_plumber]’s project is notable not only for using no added parts, but also for being documented in a way that just about anyone can get up and running, and that’s something we always like to see.

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.

There was a time when having a blinking blue LED on a project was all you needed to be one of the cool kids. But now you need something more complex. LEDs should not just snap on, they should fade in and out. And blinking? Today’s hotness is breathing LEDs. If that’s the kind of project you want, you should check out [jandelgado’s] jled library.

At first glance, an Arduino library for LED control might seem superfluous, but if you are interested in nice effects, the coding for them can be a bit onerous. If you don’t mind stopping everything while you fade an LED on (or off) then sure, you just write a loop and it is a few lines of code. But if you want to have it happen while other things continue to execute, it is a little different. The library makes it very simple and it is also nicely documented.

Obviously, to create a special effect LED, you need to create a JLed object. Then you can use modifier methods on that object to get certain effects. The only overhead is that you need to call the update method on the LED periodically. Here is one of the examples from the project:

#include <jled.h>

// connect LED to pin 13 (PWM capable). LED will breathe with period of
// 2000ms and a delay of 1000ms after each period.
JLed led = JLed(13).Breathe(2000).DelayAfter(1000).Forever();

void setup() { }

void loop() {
   led.Update();
}

Pretty easy and readable. Just remember that some Arduinos can’t do PWM on pin 13, so you might have to adjust. Our only complaint is that you have to update each LED. It would be nice if the JLed constructor kept a linked list of all LED objects so you could have a class method that updates all of them with one call. In the examples, the author keeps all the LEDs in an array and steps through that. However, that would be easy to fork and add. Oh wait, we did it for you. The library does do a lot of work, including taking advantage of higher PWM resolution available on the ESP8266, for example.

The library can turn an LED on or off (including delays), blink or breathe an LED forever or for a certain number of times, or fade an LED on or off. In addition to the presets, you can provide your own brightness function if you want to do some kind of custom pattern. You can modify most actions by specifying a delay before or after, a repeat count (which can be forever) and you can also tell the library that your LED is active low, so you don’t have to mentally remember to flip everything around in your code.

Rocket science? No. But we like it. Blocking for an LED effect is bad and this makes fancy asynchronous LEDs simple. Why not use it? Recent IDEs can install it from the manage library dialog, so it takes just a second.

Really, libraries are a key to building systems simple. Why not stand on the backs of others? Some of our favorites handle SPI and proportional integral derivative (PID) control.

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.

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.

When tossing something into the rubbish bin, do you ever concoct that momentary mental scenario where you’re on a basketball court charging the net — the game’s final seconds ticking down on the clock — making a desperate stretch and flicking some crumpled paper perfectly into the basket only for no one to notice your awesome skills? Well, now you can show off how good you are at throwing out garbage.

Well, not strictly garbage. The genesis of this IoT basketball hoop was in fact an inflatable ball on [Brandon Rice]’s desk that he felt would be more fun to fidget with if he could keep score. The hoop and backboard were laser cut on his Epilog cutter, and sport a Particle Photon to track and upload his running point tally to the Internet. An Arduino and IR sensor detect objects passing through the hoop — ultrasound proved to be too slow to keep up with [Rice]’s shots.

This smart hoop also has an LCD screen which displays [Rice]’s score, and a strip of LEDs that flash every five points. Not a bad way to spend $50, if you ask him. With the advent of smart basketball nets, there will be robots out-shooting us at free-throws in no-time. Wait, that’s already happened?



  • 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