Rod's Electronics Projects

Arduino based Big Countdown Timer for New Year

2011-11-05T08:14:00.001-07:00

The finished project at 11:39.

Background:
I spent last new year at a relative's apartment at the beach, where hundreds of people gathered in the street right next to it so they could see the fireworks launched from a nearby raft at the sea.

This is what it looks like an hour before.

This gets so crowded at midnight that you can't see the asphalt.

It's hard to synchronize a countdown when you have hundreds of people with individual wristwatches, so what usually happens is that many of them count in groups and while a group is hugging after the new year and watching at the skies waiting for the fireworks, others are yelling "nine!... eight!... seven!... six!..."

Happy new year!

Solution:
Inspired in Sparkfun's GPS clock, I decided to help all these folks to count in unison by building my own version of a big clock: hopefully simpler and designed to countdown for the new year.

1) The concept
So we don't need a 24h clock. A partial clock will suffice, say... something that tells the time from 11:00p to 11:58p and turns into a countdown timer for the last minute (11 turns off and the countdown starts from second 59 to 00).
The idea of starting at 11:00 is to let everyone know that the clock is actually there.

This design at saved me 6 segments and some space too.

2) The clock itself:
Go big, readable. I used super-bright LEDs (not ultra-bright) and some transistors. I do like Ben Krasnow's way of dealing with transistors.

3) Controlling the clock:
I used an Arduino and shift registers to control the segments, you can also use two Arduinos via I2C.

4) Time accuracy:
I want this thing to be accurate. The Atmega chip keeps track of time but they are not very accurate, reason why I added a RealTime Clock Module.
Now, in order to have the RTC set at the right time, I added NTP Atomic Clock Synchronization capabilities through an Ethernet Shield.

5) The Design:
I couldn't think of a simpler design: Before the shift registers, I used a two-arduino approach with served me well while shift registers were not available at the local store.

I considered an LCD serial display for monitoring status as well as a button for set-up purposes :

6) The building:

This design calls for portable and lightweight, so let's use these convenient cardboard box lid.

I had these boxes in my storage room. I borrowed 3 lids.

Design of the digits. I drew them proportional to a small 7 segment display, under the assumption that it will increase readability.

Good, let's add some LEDs to this then:

8 segments in place. Each segment consists of 3 LEDs

Cool. Time to solder some wire, add current limiting resistors, some transistors and more resistors for their base. In other words, let's follow the original design!

Wiring at the back. The chip at the center is a resistor array.

How about testing the code from the Arduino?

First digit is complete and code sends number 3.

Voilá! We have the first digit.

And then another instance of the same digit plus a third that only does number 11, to get the project complete.

Front of the completed project, the three digits can be easily separated and piled up for easy transportation.

Back of the unit

Test scenario: balcony. View from ground, 8 floors below:

Photo Enhanced ASA800 (Canon S3IS)

Normal Photo (ASA 100)

7) Power:

When all of the LEDs are on, consumption of the whole circuit is very low.
This allows me to power the entire system with a 2000[mAh] 11.1[V] Lithium Polymer battery, making the clock 100% autonomous.

Arduino Protoshield Mods

2011-01-05T15:43:00.000-08:00

Three simple and quick modifications that will transform your protoshield to a fully functional monster.

1) One millimeter higher:

Use 4 male header plastic bits. One for each of the 4 corners of the protoshield

This way, the protoshield stands a little higher than standard

But the benefits are great: You don't have to worry about shorts with the USB connector anymore.

Safe distance. At the same time, the protoshield is so much easier to plug and unplug now.

2) An LED tester

I don't use the BlueSmirf socket. But I connected the female headers because it provides an extra +5 and extra GND for prototyping.
With a single 300 Ohm resistor between GND and the centermost pin (originally unused in the Sparkfun protoshield, you will be able to use the two centermost pins to test any led: Very handy!!!

3) A Power LED on top

If you add a resistor to +5 and an LED on top will serve as a Power LED on top of the protoshield. This is very handy to make sure your system is powered:

Enjoy!

Helping hand mods

2010-12-01T15:41:00.000-08:00

This is only a placeholder. Photos and details coming soon...

How to get more help from your helping hand:

1) Add more weight to the base

2) Add a third hand to your third hand

Atari SIO interface using a Duemilanove

2010-07-29T18:35:00.000-07:00

How to interface your vintage Atari 130XE (800XL and others) with a laptop in order to download and play games using the laptop as a substitute for the Atari floppy disk drive.

Click here to go to Arduino Forums and see the post

Extremely simple I/O port expansion using two arduinos and I2C

2010-03-21T17:10:00.000-07:00

Here's a simple way to expand your I/O ports using two Arduinos.

I like this approach better than going for an Arduino Mega because you get to use all your smaller shields at the time it's a more affordable solution. It works flawlessly in my projects, even with other I2C devices hooked up at the same time. This is not as good and certainly not as cheap as using a multiplexer, shift registers, a MuxShield or so many other ways of doing this but hey, it's dead simple and will definitely save you if in need of more ports and you have more than one Atmega328 lying around.

The connection diagram: two Atmel microcontrollers will be less expensive than two actual Arduino boards, just like the one in the video.

The connection is the same as what you would do with a standard I2C between two arduinos. I added pull-up resistors to each wire.

Basically what this does is to allow the master Arduino to access the remote's I/O pins, thus, expanding its original I/O capacity. You can hook up many Arduinos in parallel expanding to more I/O pins as needed.

Needless to say, this also duplicates you processing capabilities at the time it allows you to add software watchdogs for a crash-self-recover system.

You don't really need to use two Arduinos: You can also use a barebones ATmegas just like I did in the video tutorial if you want to keep your costs low..

For the code, I started with "Wire Slave Receiver" by Nicholas Zambetti and modified it to this purpose:

The code at the Master Arduino:

#include <Wire.h>

#define LOCAL_PIN_TWO 2      // Pin 2 on local
#define REMOTE_PIN_TWO 102          // Pin 2 on remote
#define TEMPERATURE_PROBE_PIN 103   // Pin 3 on remote
#define SPEAKER_PIN 104         // Pin 4 on remote

void setup()
{
Wire.begin(); // join i2c bus (address optional for master)
}

void loop()
{
// Whenever you want to write to the other Arduino just go with something like expansionWrite(102,HIGH);
// That will -for example- set the pin 2 on the second arduino to high. I used the 102 nomenclature only to differentiate the two boards. It makes it easier and avoids confusion. You will see how the exceeding 100 is substracted when the time comes.
}

void expansionWrite(int pin, int value)
{
pin = pin-100; // substracts 100 to it maps to the real ports on the expansion arduino
Wire.beginTransmission(2); // transmit to device #2
Wire.send(pin); // sends one byte stating the pin to be addressed
Wire.send(value); // sends the value to be transmitted to the pin selected
Wire.endTransmission(); // stop transmitting
}

The code at the Slave Arduino:

#include <Wire.h>

void setup()
{
Wire.begin(2); // join i2c bus with address #2
Wire.onReceive(receiveEvent); // register event
}

void loop()
{
// Whatever. maybe nothing.
}

void receiveEvent(int howMany)
{
int port = Wire.receive(); // receive byte as an integer
int value = Wire.receive(); // receives the byte with the value
digitalWrite(port,value); // sets the pin to the desired value
}

Final Note: You can even use the second arduino for READING at the same time even it's a slave machine. The only thing you need to do is add some extra code as follows:

Master requests the value on a certain pin located at the slave Arduino:

Wire.beginTransmission(2); // transmit to device #2
Wire.requestFrom(2, 1); // Requests 1 byte from device #2
auxiliary_power_status = Wire.receive();
Wire.endTransmission(); // stop transmitting

Then the slave needs something like this:

void setup()

{

Wire.onRequest(requestEvent); // register event

}

and somewhere else in your code something like this:

void requestEvent()

{

byte variable_name = digitalRead(pin_of_your_choice);

Wire.send(variable_name); // respond with message of 1 byte as expected from Master

}

About me

2010-01-31T07:26:00.000-08:00

2010: I am not 40 yet, but getting closer.

I am an Civil Engineer in Informatics.I am no EE, however electronics have been a hobby since I was 8. Please bear that in mind, because it means that the information posted here could be inaccurate from an EE perspective.

Formal engineering studies helped me out to understand the basics of electronics and has allowed me to build some simple projects providing hours and hours of fun.At the age of 20, I stepped away from electronics mainly because of life-changing priorities like family, studies, other hobbies, sports and work in business-related areas.

....But, something changed dramatically not too long ago: while browsing the web looking some information about servos for my remote control helicopters, I bumped -by accident- into this video from Marc Devinck: How-To Tuesday: Arduino 101 potentiometers and servos.

It was late October of 2009, so the Arduino Duemilanove was the model out there. "Did I just find a board you can program in C with several digital and analog input output pins to play with?" I thought. The idea blew my mind.

Hours after, I learned more about Arduinos, the Italian/Spanish/American team behind it, the shields and of course after a couple days, I had one in my hand (I was lucky enough to find a store that carried them, right where I lived).

So that's the start. I'll never forget that day in where the Arduino opened a huge door to hours of fun right in front of me without even knowing it.

****

Of course many other people came into the teaching-dance without noticing, so after a 2+ year of continuous learning, I'll start by thanking the people who contributes to the OpenSource Hardware community, spreading the knowledge for free:

Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis for putting together such an awesome environment.
Marc de Vinck : for his cool videos. It all started right there.
Sparkfun : Nate, Rob, everyone: Such a cool job and such a relevant role to bring electronics to regular people. Most of my lab tools and parts comes from there.
Collin Cunningham : for putting great sense of humor and great music into his teaching. I've seen them all man.
Phil Torrone and LadyAda from Adafruit : I rarely miss an AAE show as [ChileanRegulator].
The people behind Fritzing. What a great piece of project design software.
The people behind Hack A Day. Every morning goes like this: Coffe, HaD, then the newspaper.
Guys at Pachube. I think I was one of the early adopters. Incredible project, extremely useful. My Home Automation Project was listed for several months at Pachube as the second most popular! I'm honored.
The entire Make Magazine team.