The logo is a derivative of the Arduino Community Logo licensed under Creative Commons license CC-SA-BY-NC 3.0

Update: Winners Announced

The winners of the contest have been announced. Please see the Meta post for details.

To celebrate 10 years of Arduino, we are proud to announce the first event ever on Arduino Stack Exchange.

Get your boards and soldering equipment out, dig out the ICs and resistors. The first Arduino Stack Exchange contest is just round the corner. We will be looking for interesting projects that are built using Arduinos. The contest is aimed towards sharing, discussing and providing feedback on projects that you and other members are working on. See announcement post


  • The prize is an official Stack Exchange t-shirt
  • Limit two entries per person. If more than two are provided, only the first two will be considered.
  • Clones are allowed.
  • Projects for consideration will be accepted through March 29th, 2014 at 4:00 UTC. The question will still remain open in case someone wants to show off their project they made on Arduino Day 2014.

Visit the Meta post for discussion about this event and further information.

Answer Format

You may post up to two projects (as two separate answers) as entries for the contest. All extra entries will be deleted. Consider following the following template for entries:

Project Title

Very Brief Description


What is your project? What does it do? What problem does it solve?


Things to include in this section:

  • Schematics and other design documentation. Fritzing is a good tool for drawing breadboard schematics like the one shown in the project logo above.
  • Components used to build the project
  • Pictures or video


Final thoughts. What did you learn from doing this project? What would you do differently if you had to start over?

You can copy/paste the following text if you want to use this template.

# Project Title
**Very Brief Description**

# Description
What is your project? What does it do? What problem does it solve?

# Design
Things to include in this section:

- Schematics and other design documentation. [Fritzing][8] is a good tool for drawing breadboard schematics like the one shown in the project logo above.
- Components used to build the project
- Pictures or video

# Conclusion
Final thoughts. What did you learn from doing this project? What would you do differently if you had to start over?


There are two prizes! The winner will be the submission getting the maximum number of upvotes (downvotes do not count) and will get a Stack Exchange T-shirt*! There will be something for the runner-up as well. The runner-up will be decided at the discretion of the event organizers.

*Certain restrictions may apply. International shipping may take a few weeks.

Where do I submit my projects?

Post your projects as answers to this post.

  • What exactly is the qualification for being an "arduino" project? I use optiboot in lots of places, but I can't see that as being "arduino", since it's just a project that the arduino toolchain uses. Short of using a board in the arduino-form-factor, I can't see a clear way of delineating between "arduino" and "non-arduino", unless you explicitly require that the project be compiled using the arduino text-editor, and that will probably disqualify all the decent projects since the arduino editor is horrible, and all the good coders stopped using it long ago. Mar 25, 2014 at 5:16
  • @FakeName let's take this discussion to the Meta Post
    – sachleen
    Mar 25, 2014 at 6:22

14 Answers 14


Stateful questbox

A GPS powered box that makes you visit a few spots before opening


It is similar to questbox, but it stores a small amount state of information in EEPROM, so you have to visit two or three different places before it opens.


Needed hardware:

  • Arduino Uno
  • Reverse Geocache Version 2 (or a protoshield)
  • GlobalSat EM-406A GPS module
  • 2×8 blue LCD with connector header and cable
  • Hitec HS-55 servo motor
  • 4-40 push rod and clevis for latch (some versions provide a Z-bend rod instead)
  • 2 AA battery holder
  • Metallic push button with embedded blue LED and 4-pin cable
  • Pololu low voltage switch
  • Pololu 5 V boost regulator
  • JST connector for EM-406A GPS module
  • Straight and right-angle header pins for the display, servo, and pushbutton connectors
  • Two resistors for current limiting and display contrast adjustment
  • Two small capacitors for power smoothing
  • larger capacitor for display contrast circuit

Total hardware cost: 137$ + shipping

Aditional materials:

  • A nice box
  • Epoxy glue, wood to cover pieces, tools

You can find assembling instructions in sundial page (you can buy most materials from them)

I will upload stateful code and post a link here, unfortunately I wont get all need hardware on time, so this is just an idea :)

Code written so far:

Inspiration:Original questbox


Learned how to integrate many components and libraries all toghether, I'll have to travel a bit to test it :)

Budget can be cut quite a bit changing the concept a bit:

  • Change GPS with a numerical keypad: the 'player' has to guess/obtain a code instead of traveling to a location
  • Polulu switch and regulator can be exchanged for a latching relay with capacitance coupling

Energy saver for the absent-minded PC user

This device switches on/off my desk lights when it is dark(ish) and in sync with my PC screensaver.


The project is little more than an combination of a light sensitive sensor, a relay and some smart code that monitors the screensaver on my PC. When it is dusk and when screen saver is not active, it switches on the lights over my desk. When I subsequently leave my desk the screensaver will activate, which will in turn trigger the desk light to be turned off. When there is enough light during day time, the lights are not switched on at all. The problem solved is to reduce the waste of energy due to the lighting in my office being switched on when I have left the room.


Because the power of microcontrollers / Arduino only a little extra hardware is required to create a useful project. The same goes for this project where the hardware is little more than:

  • An Arduino
  • A couple of screw shields to connect the external components
  • An LDR in series with a resistor to measure ambient light
  • A relay card to switch on and off the mains powered lights
  • A 10 μF capacitor from GND to RST to prevent the board from being reset and accidentally being programmed.


simulate this circuit – Schematic created using CircuitLab


I learned how to interface the PC over the USB serial link with Arduino and how to read current state of the screensaver on my PC. If I would start over, I'd use a much smaller controller as I really only need a single digital output and a single analog input. Probably base the project on V-USB. Arduino however is excellent for the quick and easy proof of concept (PoC). (The PoC has been on my desk for at least two years already).

  • It'd be cool to see pictures of your final board and setup. What's the response time like? Instant? After a minute?
    – sachleen
    Mar 23, 2014 at 22:01
  • @sachleen The daemon on my PC that polls the screensaver runs every 30 seconds when the screensaver off (when I'm working on my PC) and every 5 seconds when turned on. I can increase that speed, but that influences CPU load and with that power use... There is also a capacitor attached to prevent the Arduino from resetting and accidentally being programmed.
    – jippie
    Mar 24, 2014 at 6:04
  • @sachleen as dusk falls slowly over time, this 30 seconds isn't really an issue. Nobody notices the difference in darkness over 30 seconds. Within 5 seconds of moving my mouse or hitting my keyboard when I return the lights turn on. There is a slight hysteresis betweet what is considered dark and light, to prevent the lights from turning on/off every so many seconds when it is sloowwwwly getting dark enough to get activated.
    – jippie
    Mar 24, 2014 at 6:14
  • You should modify it to dim it at 50% for 10-15 seconds so you're not in the dark completely and it gives you a little "warning" Apr 1, 2014 at 22:30
  • @AnnonomusPerson I am switching the 240VAC side of a SMPS that is spec'd 100-250VAC input. Not going to happen I'm afraid as I don't want to switch secondary side. Nice idea though, maybe I can add a smart small white LED somehow.
    – jippie
    Apr 2, 2014 at 5:11

Sonic Ray Gun

Two projects by kids

I'm working with a couple of home educated kids and we are having a lot of fun with an arduino. Their first project was a fake-bomb, like you see in the movies, with a LCD countdown timer and a classic "do you cut the red or blue wire?" type problem.

Project two started with showing them the toneMelody example and a small speaker. The quickly found out that if you turn the frequency up to 15kHz it was rather annoying to teenagers. An hour later they had improved the design with a cup, toilet roll and a switch made from a paperclip making a directional sonic ray gun.

Sadly no pictures.


Don't leave kids unattended with an arduino.

  • 3
    Can you describe it a bit more (code, Fritzing, etc?)? Mar 25, 2014 at 1:36

(fake) Linux on Arduino

I recently acquired a small composite LCD screen, which I quickly began playing with using the Arduino TVout library. What came next? Linux!


While playing around with my TV screen and the TVout library, I discovered there is a premade terminal handler for the TV. I soon began to experiment with using it as a TV terminal hooked up to a PS/2 keyboard. There were some problems with the PS/2 library I used, so I transitioned it to use the USB library on my Mega ADK along with a USB keyboard. That worked much better. Now for storage.

My SD card shield isn't compatible with my Mega, so I wired it up somewhat haphazardly to the SPI at the end of the board. I wrote command handling to preform a few tasks like listing files and finding disk size, free space, etc.. The entire assembly isn't by any means finished, but I am happy with the progress I have made.

The code will be relocated to Github eventually, watch the comments.


zoomed out pic

clse up screen


I had a lot of trouble concatenating the inputted charactars to the string storing the current command because I wasn't casting right. Once I got that figured out, I also needed to fix the problem where some keys printed random garbage to the screen. This was caused by reading memory before the letter definitions, so a few ifs cleared that up.


I am very satisfied with the code. Once I add a few more utilities to it, I will put it on Github, so watch the comments. Overall, it was a very fun project. I learned how to use Stino in the process.


I think this kind of barely fits within the rules, but it's interesting enough that I figure I'd post it anyways.

High-Precision, GPS-Synchronized timestamp generator for data-acquisition purposes.

This is a rather interesting project that is intended to be used for providing a easy way of synchronizing multiple independent data-acquisition systems.

Basically, I work in a research lab, and we often have instruments that have multiple independent data-acquisition systems, which can be physically separated by as much as 50 feet. We need to be able to correlate the time at which samples from each system were taken, which can be difficult if you want to resolve sampling-times to a great degree of precision. Using something like a USB data-acquisition system, just the USB latency can introduce several hundred milliseconds of unknown latency, that can vary from acquisition to acquisition.

The previous solution was a 24-bit parallel counter that was simply bussed everywhere, requiring an enormous wiring harness, and was kind of a pain in the butt.

This system uses a specialized timing GPS module that can synthesize arbitrary frequency clocks, that are phase and frequency locked to the atomic clocks in the GPS satellites.

The MCU is responsible for tying together the GPS data messages (I had to heavily extend and optimize a existing protocol parser for the GPS data). The GPS is configured to use a proprietary binary protocol, and it's all parsed by the parser I wrote.

The project has gone through a number of revisions (pictured below).


Revisions! enter image description here
Rev 1: Never worked, due to the fact that I was initially hoping to use a software dPLL off a much less expensive GPS, to synthesize a higher-frequency clock from only the 1 PPS output. It's probably possible to make it work, but the time-investment just made it not worthwhile. (and I'm too crappy a coder)

Used a parallax propeller MCU. The lack of decent compiled languages was a major issue as well.

enter image description here
Rev 2: Shifted to a ATmega2560. Worked, had lots of funky design aspects inherited from the first rev. Primarily, the continued use of shift-registers for the 32-bit output, despite the more then sufficient number of IO on the ATmega2560.

First board that ran Optiboot, and was actually programmed entirely using the standard Arduino toolchain, before I got irritated with it and started modifying the toolchain to better suit my purposes.

enter image description here
Rev 3: Also worked. The bodged wiring is because this board incorporated a built-in USB hub to reduce the number of required USB ports (the FTDI interface requires 1 USB, and the GPS has a USB interface as well). Unfortunately, the GPS wouldn't properly enumerate, though the FTDI device worked fine, and I've used this hub elsewhere without issue. Weird.

I don't have a proper USB debugger, so I just dropped the USB hub entirely, rather then trying to fix the issue. The GPS usb isn't really used much outside of set-up anyways.

enter image description here
Rev 4: Semi-final ATmega2560 version. Added a LCD for GPS status, fiddled with LEDs and so forth. Also, better footprints for the possible super-capacitors for maintaining the GPS status when not powered.

This is the last Optiboot version.

MStime is the MSTOW, or Millisecond-Time-Of-Week, which is the name of the GPS data value that is output on the timestamp out. It's a 32-bit variable that increments once per milliseond, and rolls over each week. It's a more obscure part of the GPS standard.

ITOW is another GPS-related value, being a value that corresponds to the 1PPS signal. The correlation between the two isn't properly reflected on the LCD, since I do not have the CPU time to update the LCD at the rate I'd like. This was actually one of the major things that improved in the upgrade to the Xmega devices.

enter image description here
Rev 5: Complete architecture switch. Now uses a ATxmega128A1U processor. Not really "Arduino" at all anymore, but the ability to have multiple interrupt levels on the xmega processor series allowed me to considerably improve the code structure.

The two bodge-wires are from me doing some experimentation, the board worked fine without them as well.

Looking forward:

Rev 6! enter image description here
Add the ability to use different LCD sizes, more ESD protection on GPS antenna connection (that was an issue), ability to use a CR2032 battery for maintaining the GPS clock instead of super-capacitors.

Also, much better labeling of debug and status LEDs.

enter image description here
And bonus Nyan-Cat!

enter image description here

(These boards are out for fabrication right now. When I get them, I'll add pictures of the real board.)

I did some long-duration testing between two of the ATmega2560 boards, and over 72 hours, the RMS time-error between the two units was ~20 uS. This was with two completely independent antennas too. My design goal was < 1 ms, so I'm pretty damn happy with that.

On the whole, I think this does a good job illustrating how Arduino can be a useful tool for early prototyping for "real" products/systems. I use it for getting an initial test-version running with minimal effort, and when I'm confident the idea will work, I actually put the work in to migrate away to a completely custom, purpose-specific implementation.

Design files:
(In the "GPS Timestamp" series of directories).
(Note: Files are from Altium Designer. The are not eagle files).

Source code:
Again, in the "gpsTimeStamp" series of directories.

Sorry for the crappy cell-phone pictures.

  • Could you please reduce the number of pictures? 3-4 should be sufficient to get the idea across. It takes a fairly long time to load on slow connections.
    – asheeshr
    Mar 27, 2014 at 12:49
  • 7
    @AsheeshR - I strongly disagree. I could drop one of the pictures from the last rev, but having the progression of system design I think is quite valuable. Mar 27, 2014 at 22:54
  • 1
    Having fun with the silkscreen?
    – TheDoctor
    Apr 14, 2014 at 13:08
  • Oooh, 3D view PCB. Aww, it's Altium and pretty expensive? :$ Pretty fun to see these projects, or to see whatever projects others are doing..
    – aaa
    May 31, 2016 at 12:02

TV Antenna Rotator

IR remote controlled antenna rotation

Can't get off the couch to adjust the direction of the TV antenna? And even if you do, sometimes your proximity to the antenna changes the reception. It would be nice to be able to adjust the antenna from the couch. Using the TV remote.


Arduino Uno, IR receiver, Stepper motor w/ driver board, 1" ID bearing, Swiffer mop handle, Plastic box,

behind TV Arduino w/ IR receiver up front Close up of box and bearing Swiffer handle These two buttons don't do anything on the TV anyways


Use an old Swiffer mop handle as the antenna post. Got a 1" ID bearing from my favorite online store, which the mop handle just squeezes into and stops. I drilled a hole into the plastic box big enough for the mop handle to fit through, but not for the bearing. I drilled a rectangular hole into the mop handle end to fit the shaft of a 28BYJ-48 stepper motor, and stuck the contraption into the box as shown. The mop handle actually rests on the bearing, and the bearing is super glued to the top of the plastic box.

Used the stepper.h library to rotate the motor from an Uno.

I took apart an unused DVD player and salvaged the IR receiver from it. You can take apart any consumer appliance that has a remote and use the IR receiver from it, it'll work. The IR receiver uses the IRremote.h library. Using the serial monitor, I printed out the hex code that corresponded to the two buttons on the TV remote that I want to use to operate the antenna motor. One for rotating left, one for right.

To save energy, use the small_stepper.motorOff() function to turn off the coils after each movement.


This was a fun project that was also useful for my wife. I didn't implement any acceleration/deceleration in the movement, which might be nice, especially if the antenna had more rotational inertia.

Edit: sorry about the picture being sideways! It's right side up on my computer, I have no idea why it's sideways online.



AVR based, Arduino compatible, board that mounts to the back of an 8x1 up to 20x4 Character LCD Screen.


I just designed this board and the custom library to make it easier to use and LCD. Though they are pretty easy to use at the moment. It cuts down the number of output pins used from 6 to 3. It also has the option to expand the I/O by adding more shift registers on to the one that drives the display. The processor used is an ATTiny45 or ATTiny85 which has, after using the shift register, digital pins 1 (PWM) and 4 available and analog pin 2 (same pin as digital pin 4) available.


Schematic OSH Park render Unsoldered Board


One unforeseen challenge I faced was when I started I was using digital pins 0-2 to run the shift register, these also happened to be the programming pins (MISO, MOSI, SCK). So every time I reprogrammed the device the LCD would get sent a whole bunch of gibberish messages where the power would have to be turned off in order to reset the display. I solved this problem by moving the shift registers latch pin to digital pin 3 which is not a programming pin. Solving this also solved another problem for me because when I moved the latch pin it opened up digital pin 1 which had PWM usage, allowing for more things to be done with the board.


Granted this may not be the coolest product or idea, it still has its uses. The answer the question directly, "What did you learn from doing this project" I learned how to design from start to finish a PCB board. If I could do anything differently it would have been to use surface mount parts instead of through hole, then again it is just a prototype, one-off board.

  • How did you program your ATtiny? What code was involved? IDE? (Please just comment, do not edit your post.) Mar 23, 2014 at 13:57
  • @AnnonomusPerson Looks like the person who posted what I did before removed their comment, so this is the where I got the things needed (Arduino IDE files and programming schematic) to program the ATTiny. highlowtech.org/?p=1695 Mar 24, 2014 at 3:12
  • Why use surface mount? Soldering through-hole at home is much easier? I think SMD is only for production runs, or is there something else to it?
    – aaa
    May 31, 2016 at 12:06

Button-pushing robot.

A four-wheeled eight-pound remote-control laser-shooting robot that pushes buttons.


I made this project over the course of last school year. I was in robotics class, and we decided to have a competition. Each team would make a robot that has a large button and a way to push other buttons. At the end of the year, we would have the final contest, where the three robots would try to push each other's buttons.

By the end of the year, my robot only partially worked. Every part of the robot had at some point been working, but between a fried Arduino, fried motor drivers, terrible code organization, and me being the only person on my team to work on the robot for a total of more than five hours, I couldn't get it completely working.

I haven't touched my robot in almost a year, so I know that if I wanted to get it working again I would have to rewire the bot and rewrite the code. I may decide to do that some day, but for now I'm going to work on less ambitious projects.


Overall Design

enter image description here

Information/electricity flow

+--------------------------+   +-------------------------------------------------+
|         Computer         |   |      Robot                                      |
|--------------------------|   |-------------------------------------------------|
|                          |   |                                                 |
| Keyboard +--> Processing |   |  Button +-------------+        Motor    Motor   |
|                          |   |                       |          ^       ^      |
|                    +     |   |                       |          |       |      |
|                    |     |   |  Batteries +-----+    |          +       +      |
|                    v     |   |                  |    |   +----> Motor Driver   |
|                          |   |                  v    v   +                     |
|               Bluetooth +-----> Bluetooth +--> Arduino Uno +--> Motor driver   |
|                          |   |                  +    +  +       +       +      |
+--------------------------+   |                  |    |  |       |       |      |
                               |                  |    |  |       v       v      |
                               |                  |    |  |    Motor     Motor   |
                               |                  |    |  |                      |
                               |                  |    |  |                      |
                               |                  |    |  +-----> Laser          |
                               |  +---------------|----|----+                    |
                               |  |       Arm     |    |    |                    |
                               |  |---------------|----|----|                    |
                               |  |     +---------+    v    |                    |
                               |  |     |      Motor Driver |                    |
                               |  |     v              +    |                    |
                               |  |  Servo             |    |                    |
                               |  |                    v    |                    |
                               |  |                  Motor  |                    |
                               |  +-------------------------+                    |


  • Arduino Uno, (fried)
  • Transportation:
  • Easy Button
  • Arm:
    • Servo, (continuous rotation)
    • Motor driver, (fried)
    • Motor, (12v, found in teacher's junk pile)
    • Eraser
    • Counterweight, (homemade paper bag filled with pennies)
  • 2 battery packs, (12V, 1300mAh, Ni-MH rechargeable)
  • 2 solderless breadboards
  • Laser, (5mW)
  • Bluetooth:
  • Lots of wires
  • Lots of scrap metal and plexiglass, (found in teacher's machine shop)


I didn't organize my code very well, so I hope this is the right code.

More pictures

enter image description here enter image description here

Terrible video of a slow, armless, buttonless, laserless, and bluetoothless early version of the robot.



I'm really good at frying electronics.

This was my first experience in an actual machine shop. I got to use a CNC milling machine, manual milling machine, lathe, and bandsaw. If I started a project like this again, I would make much better documentation, so I could figure out what the heck I was doing a year later.

  • 1
    Nice work! Nothing is as valuable as experience and the important bit is that you now know how to do a better job next time.
    – jippie
    Mar 24, 2014 at 18:12


- Learn how to create your own low cost wireless sensors and connect them to the world.


We call it "Internet of Your Things"


We've combined the Arduino platform with a small radio transceiver into a fun, flexible world of low cost wireless sensors.

All the nitty-gritty details about the sensor communication has been packaged into a convenient software library so you don't have to worry about them.

It is as easy as 1, 2, 3. Arduino + NRF24L01+

  1. Connect the parts. 2. Download the provided examples. 3. Start measuring and controlling the world!

Read more about how the sensor network is automatically being formed using our Arduino Library on the site. It basically forms a star network and can reach hundred of meters.

The sensor network

In the middle you place an Arduion or Raspberry gateway that collects the information from your sensors. Raspberry Controller

Arduino Gateway

Design and schematics

Here is one of the prototype motion sensors I created to control the garden light outside of my house. The motions status is sent to my HA controller which turns on the light (via z-wave) when motion has been detected. A light sensor (not in the image) makes sure only to turn on the lights at night.
enter image description here

You will find all the build instructions here: http://www.mysensors.org/build/

Othe site there is also easy-to-follow build instructions for a bunch of other wireless sensors and actuators. Here are some examples:

Distance Sensor, Motion sensor, Relay actuator, Humidity, Light, Pressure, Rain, Temperature, ...


The project is still in the starting blocks and we hope to provide plugins for a growing list of Home Automation controllers. The first thing on our list right now is to provide a DIY controller that provides a free cloud storage for your sensor data.


See you @ mysensors.org

/Henrik Ekblad (the creator of the Open Source Arduino Library used for the communication between the sensors)

  • UPDATE 27/3. Made the example more concrete and added my affiliation with the open source project.
  • 4
    Welcome to Arduino.SE! I'm afraid your website doesn't fit the criteria of our showcase. We're looking for specific projects which demonstrate a practical application of Arduino (as seen in the other examples here). Perhaps you could provide an example of a sensor project you've built? Mar 26, 2014 at 16:04
  • Ok, maybe i'm missing the point ;). The "specific project" here is that we use Arduinos to create self healing wireless sensor network. To archive this we have created an Open Source Arduino library for the NRF24L01+ transceiver.
    – hek
    Mar 26, 2014 at 16:25
  • 4
    This sounds more like an advert than a project. Change the tone, maybe make it a bit more specific to a single application. I suspect that is why you got a down vote. Mar 26, 2014 at 16:54
  • Welcome to Ard.SE! Based on your profile website, you work at or own the site being promoted above. It is SE policy that you disclose this in your answer. Please edit it to include that. Also, can you add an example of using this? Mar 26, 2014 at 20:43
  • I've been developing this (Open Source) MySensors library for the past 6 months on my free time. To help other people use the library properly we (more people have joined the project the last couple of months) launched the build-instruction-page just 3 days ago. I thought it would be a good Arduino project to get feedback on in this "Project Showcase". I don't think I've tried to hide my participation in the project in any way and I'm sorry if the description is perceived as an advertisement. We are just very happy about the project!
    – hek
    Mar 26, 2014 at 22:22

4-Digits LED display for Arduino

Small board with 4 7-segments LED digits, managed through 3 pins.


When I started working with Arduino, I wanted a way to display values collected by various sensors I experimented, but I did not want to output these values through Serial to a PC.

I wanted a small board that I could easily reuse from one project to another and I wanted to spare a breadboard.

This board, along with its small library, currently allows 4-digits numbers display and does not source any Arduino current during display (current is sourced only when communicating to the board the new value to display from now on).

display board with counter


The design is rather simple as I decided to reuse a MAX-7219 chip to drive my LED display (I had a few of them on hand).

Thanks to this chip, the schematic was much simple, but it was important to correctly understand how to use it; fortunately, its datasheet was pretty clear.

The original design was done on a breadboard and used 4 single LED 7-segment digits; but it required too much wiring for my taste (need to connect segments by groups of 4). Also, during my very first experiment with 7-segment LED digits, I have fried one: it had 2 Ground pins, but I connected only one to GND instead of both :-(

Then I decided to go for a 4x7-segment display, common cathode, with segment anodes already connected for 4 digits: that's only 4+8 pins!

Board Schematic

During my tests, I have found a useful Arduino library for working with MAX-7219 which I decided to reuse. I have built my own library upon it, with a very simple API.

After breadboarding, it was time to make the design more permanent; since I had a bunch of stripboards on hand, I decided to go for it.

I searched and found an easy Stripboard designer for PC that I have used for designing my board.

The first stripboard design was not optimized in terms of space and I decided not to implement it:


Then I have reviewed the design to optimize the cost and size (just one small 50x75mm stripboard); that was easy with the stripboard designer I found before:


Once the board was ready, I decided to check it with an Arduino UNO and an Ultrasonic Sensor:


It seemed to work except I often had strange, inconsistent displayed values; after investigation, I found it was due to noise triggered by the display board, noise that interfered with the sensor. I just needed to add a decoupling cap as near the current supply pins of the sensor as possible and that worked perfectly (note that the display board already had decoupling caps for the MAX-7219 chip).

Parts list:

  • 1 x LN5461AS: common cathode 7-segments block of 4 digits
  • 1 x MAX7219: multiplexed LED driver chip
  • 1 x IC support (24 pins)
  • 1 x 22K resistor
  • 1 x 10uF electrolytic cap
  • 1 x 100nF cap
  • 1 x male pin header (5 pins)
  • 1 x 90x50mm stripboard
  • wires, solder...


30 years after my last electronics experiments, I could get the virus again with Arduino and with this very first project which, although rather simple, taught me several things:

  • interpret datasheets for the components used (MAX7219 and LED display)
  • learn how to use and be effective with stripboard design
  • all pins marked GND or V+ should be connected: you don't choose the one you feel like connecting!
  • if there's something that appears strange when you test your circuit and you don't understand why: don't search, it must be noise, try to add a decoupling cap and that should do it!
  • learn how to create an Arduino library (not just a sketch)

If I was to start this project again today, I would:

  • try to optimize further the stripboard design (probably I could reduce the size a bit further)
  • replace the straight pin headers on the board with right-angled headers so that wires connecting to Arduino are more protruding in front of the board

Digital Wall Clock with Radio Frequency (RF) Remote Control

A large (40x30cm / 16x12") 7-segment display wall clock with R/F remote control.

enter image description here


This project features a large (40x30cm / 16x12") 7-segment display digital wall clock with R/F remote control. It has the following features:

  • It shows the current time and date (hours, minutes, seconds, day, month, year) in two formats (hours or date in the large digits).
  • It shows the current temperature in °C.
  • Has a user defined countdown which will sound an (annoying) alarm when it reaches zero.
  • All functions controlled remotely by an RF remote control.
  • Has a small cursor keypad for controlling its functions (when the remote control isn't available).
  • Brightness control independent for each display line.
  • It continues to keep the current time accurately even when off, thanks to a real time clock IC powered by a coin cell battery.


The key aspects of this project were the following:

  • It's completely based on Arduino and AVR ATmega328 microcontroller.
  • It keeps current time even when off, thanks to DR1307 RTC powered by a coin cell battery.
  • The digits are never multiplexed. Instead, each digit has a dedicated 8-bit serial shift register IC (74HC595) that keeps selected segments on independently of what's being displayed on the other digits and what the MCU is doing.
  • Segments are powered by Darlington arrays due to current consumption that exceeds that of the MCU or the shift registers.
  • The clock is controlled by a keypad on the controller board and also by an RF remote control. Radio communication is performed by a pair of inexpensive 434MHz radio receiver and transmitter.
  • The project has a modular design in which a single controller can manage up 12 single digits. Controller also accepts expandable modules for unlimited number of digits (maximum number of digits is limited by timing delay due to daisy chaining of shift registers and the attenuation of their clock signal).
  • The design supports a number of ready-made 7-segment display digits or custom digits made with LEDs.

Below are the schematics for the controller and one of the 7-segments boards:

enter image description here enter image description here

Here are some pictures of the boards that I designed, etched, and assembled, and the remote control:

enter image description here enter image description here enter image description here

And finally, here's a picture of another version of the clock. In this one, I'm making the 7-segment displays myself using rectangular LEDs and discrete components.

enter image description here


This project took me a lot of time, effort and learning to get to this stage (it's never finished, as I've learned), but it was lots of fun. A few things I've learned:

  1. Study all the libs you're going to use in your project before you assign GPIO pins in your controller so you avoid potential conflicts. I've been unlucky to use the same PWM pin for brightness control that is associated with VirtualWire timer, so I had to patch the board to get brightness and RF working at the same time.

  2. Crimping KK molex and modu connectors takes A LOT OF TIME!!

  3. Laser cut acrylic pieces are the future. They add a lot of quality to the device even if you are clumsy.

  • How did you make the PCBs (etching and drilling)?
    – sachleen
    Mar 29, 2014 at 0:58
  • 1
    @sachleen I use the toner transfer method with ironing. I print the board design into ink jet photo paper in a laser printer, then I iron it onto the board, then I etch the board in FeCl. It takes a while to find the right paper and printer settings. I use a dremel drill press for drilling, but I only use phenolic boards and high speed drill bits. Fiberglass boards are much harder on the drill bits, usually requiring the more expensive and brittle carbide drill bits.
    – Ricardo
    Mar 29, 2014 at 2:33
  • Where did you get those LEDs? I have some that look exactly like that! Mar 29, 2014 at 12:04
  • 1
    @TheGuywithTheHat The green rectangular ones? Those are pretty common around here in Brazil. I got those at one of our online electronic components shop. Here are some links: at DigiKey, at eBay. Here's where I got them.
    – Ricardo
    Mar 29, 2014 at 12:11

The Knock-knock lamp

A lamp that toggles on/off when the desk is knocked on. Currently in alpha phase, still prototyping, but I think it's the most useful Arduino project in existence. Included corny joke generator... from previously recorded knock-knock jokes. Note: I know I can't win in the rules, but there's no rule about entering... I can show off my project, too.


So far I've pretty much explained most of it. You knock, and the light turns on and off. I'm currently on breadboard. I'm using a piezo element to detect the knocks with vibrations. In parallel, I have a 1 megaohm resistor to protect my Arduino Uno SMD.

I thought of this design after nearly knocking (haha punny) my lamp off of my desk while searching for the little toggle switch. I'm not exactly... well adroit. It's nice just to knock on the desk and then have light. I'm also using a Power Switch Tail SSR (solid state relay: no noise) to control it with two of my Arduino's pins.


Photo Image taken with webcam hanging over monitor... eek!

Fritzing Diagram

Components used to build the project:

  • Piezo element ($3.00 USD)
  • Megaohm resistor ($0.30 USD each in 5pk)
  • Arduino Uno SMD (on hand)
  • Power Switch Tail SSR (~$25.00 USD with ship, but had on hand so no cost)
  • Breadboard and jumpers/extra wire (~$5.00 USD, but had on hand so no cost)

Cost to me: $3.30 USD + $0.02 USD (tax) == Only $3.32!


Overall, it is a simple project but it's actually useful. That's a struggle with my Arduino projects: can I build something that I would actually use? Blinking an LED isn't exactly going to help you in life. It's fun, but that's about it.

The biggest issue I faced (and kinda still do) is not getting a strong enough signal. I learned a lot about electrical signals: I figured out how to find the "peak" of a pulse and not just read the pin at a random interval and miss the higher voltage. I would try getting more sensitive piezo element. A larger one would help. I'm trying to modify my circuit to not limit the voltage as much, but protect the Arduino. Some sort of fuse would help in this situation. I'm also playing around with resistor values. It'd help a lot to have a scope for this, but I guess not... :P

After I perfect the circuit, I'm going to work on getting it on a PCB with an ATtiny... and maybe even develop some kits. I'll try to publish my findings on how to make the element more sensitive without risking my board in the process.

Status update: I've been really busy recently. I'm going to order a zener diode (4.3V) here in a week or two to remove the megaohm resistor to prevent diluting the signal while protection the chip. I may build a simple voltage amp here if needed (alongside the zener) to try to make the sensor more sensitive.

  • 1
    Moving to something with differential and gain ADCs would help you get more sensitivity out of the piezo. And possibly using a TVS instead of a resistor. Mar 25, 2014 at 21:43
  • Are you using ADC for detection or an interrupt? Any idea of how large the voltage peak is you want to detect?
    – jippie
    Mar 26, 2014 at 18:34
  • @jipie ADC for detection, I have fairly efficient code: it loops and finds the peak for every 250 ms. No delays. For peak, IIRC it's around 14/1024 (too lazy to convert that now). I should look into the AREF pin too, but there might be problems with if it's dropped it can make ~9V. Mar 26, 2014 at 20:38
  • Try this as input buffer. The transistor acts as a current amplifying half wave rectifier / peak detector. No need to detect a single peak with the ADC, the transistor / capacitor will strech it for you. As configured the output voltage has a 2.2V DC bias, but you can change that to anything you prefer by changing the resistive divider. That way you can make the input even more sensitive by selecting the 1V1 or 2V56 bandgap reference. The 10M resistor ensures the capacitor discharges over about a second and was in reality my DMM.
    – jippie
    Mar 31, 2014 at 18:00

Heating Controller

You know how it is - you set the heating to come on at a certain time and how many days do you work late and it's been on full bore for hours, or you go away for a few days and forget to turn it off? Or the rare occasion that you get home early and the house is cold? I decided that the simple way to get around this was to build a device that would allow me to turn my heating on or off by text message / sms. It would be in addition to the existing control system so as not to lose the flexibility which that can provide.

The project consists of a few major parts: an Arduino Uno clone, a Seeedstudio GSM shield, a DHT22 temperature sensor and a 25 amp SSR.

How it works:

The existing heating controls are set to 'Off' and the new controller is wired up to override them. The Uno is programmed to respond to three different messages - On, Off and Query. In the case of the latter the unit will read the DHT22 and reply to the sender with the current temperature and the status of the unit (on or off). If the command is either On or Off then it will respond with a confirmation of the action carried out. Once messages have been acted upon they are deleted; any messages that do not conform to the specific message structure are left in the SIM card memory and can be examined later if desired.

Power to the unit is supplied by a five volt three amp switch mode power supply. As the power pins on the Arduino are simply exposing the board's internal 5v bus I decided to power the ensemble through these and configure the shield to draw power from the Arduino.

The unit has three status LEDs. One green one to indicate that there is power, a blue one to indicate that the GSM board is 'live' and a red one to indicate the status of the heating. These are in addition to the status LEDs provided on the Arduino and shield. There is also a push button switch that allows manual control of the heating, with a 100nF capacitor to handle the debounce.


Much of the code relies upon good old delay() to give the shield enough time to perform its actions. I plan to improve the code so that it waits for confirmation from the shield rather than assuming that it has done what it was told to within the time allocated! I will also add a 'still alive' feature - at fixed intervals turn off the blue LED, send the AT command to the shield and on an acknowledgement turn the LED on again. The shield is under software control so if it fails to respond then turn it off and back on again.

The whole ensemble is to be mounted in a suitable enclosure and mounted adjacent to the existing controller. I have an internally illuminated push button switch that I will use instead of separate switch and red LED to handle the override.

Longer term I'm planning to add an RTC, a 20 x 4 LCD and additional push buttons to allow the unit to be programmed and act as a time switch as well.

Prototyping has already started!


There is something slightly decadent about waking up on a cold winter's rest day, sending a text message / sms to turn the heating on, and rolling over and going back to sleep for an hour! And when you realise that you haven't turned it off on a night you can do so from the comfort of your bed!

Controller Image 1 Controller Image 2


Serial Box

A portable serial monitor in a box


Sometimes it's useful for a device (Arduino or otherwise) to output some debug information via serial. That's great if you've got a computer on hand with an appropriate serial input. However, that's not always the case for a variety of reasons.

This project is my attempt to address that problem by creating a portable Arduino-powered serial monitor, which I can hook-up to other devices in the field.

By default, it will simply display text in a scrollback format; i.e. text appears on the bottom line, and everything scrolls up to make room when more arrives. This means it should work very neatly with all sorts of generic devices. However, it will also be possible to use escape sequences to control the display more precisely, so that devices can also be programmed specifically to take advantage of its capabilities.


The design consists of a set of 4 alphanumeric LCD displays (16x2 characters each), aligned in a box something like this:

3d mockup of the Serial Box design

The displays are Epson EAX16027AR's, which unfortunately are not compatible with the standard Hitachi HD44780 driver. As such, I had to write my own library for them.

I chose to use these displays (rather than e.g. one large display) mainly because I just had them lying around, and wanted to do something interesting with them. I also thought it would be quite handy to be able to control each display independently for some applications (e.g. displaying different information on each one).

In terms of circuit design, the displays are connected in parallel, with chip select pins being used to direct data/commands to each one as needed.

An ATMega328 will be the brains of the final unit, with serial data coming from a TTL-level line (for connecting directly to the TX of a similar MCU), or optionally from an RS232 9-pin D-sub socket (for connecting to various other systems). The unit will also have a contrast dial, a button for clearing the display, and a button for initiating a self-test mode. In future, I'd like to add buttons which let the user move through a scrollback history too.

Below is a very preliminary circuit layout (I had a lot of trouble getting Fritzing to play nicely for some reason!). It includes an 8-bit SIPO shift register for driving the LCDs' data lines, which are shown in green. You can also see the chip select lines in orange.

Preliminary circuit layout

At the moment, the project is still at the working prototype stage, driven from an Uno (clone) board. Below, you can see a photo of it in action, displaying text which was passed via serial from my computer.

The prototype in action

Source code

I'm making my LCD library available on GitHub at the link below. Please note that it's at an early stage in development. In the near future, I intend to make it much more similar to the core LiquidCrystal library so that it's easier to transition between the two.

You can find some basic code for my Serial Box prototype in the "examples" folder.


I think the project is coming along very nicely, and I was extremely pleased to get the prototype working. My main challenge is going to be mounting the whole thing in a box. I've already made a start on cutting out suitable holes for the displays, but I'm not very experienced at that sort of thing, and am finding it quite tricky to line everything up.

I'll get there in the end though. It just may not look very pretty by the time I'm finished! :)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.