Linux: /usr/share/arduino/hardware/arduino/boards.txt
Windows 7: C:\Program Files (x86)\Arduino\hardware\arduino\boards.txt
Windows XP: C:\Program Files\Arduino-0022\hardware\arduino\boards.txt

With my favourite text editor I openned them up and appended the following lines:

##############################################################

atmega168bb.name=ATmega168 on a breadboard (8 MHz internal clock)

atmega168bb.upload.protocol=stk500
atmega168bb.upload.maximum_size=14336
atmega168bb.upload.speed=57600

atmega168bb.bootloader.low_fuses=0xE2
atmega168bb.bootloader.high_fuses=0xD9
atmega168bb.bootloader.extended_fuses=0x07
atmega168bb.bootloader.path=arduino:atmega
atmega168bb.bootloader.file=ATmegaBOOT_168_pro_8MHz.hex
atmega168bb.bootloader.unlock_bits=0x3F
atmega168bb.bootloader.lock_bits=0x0F

atmega168bb.build.mcu=atmega168
atmega168bb.build.f_cpu=8000000L
atmega168bb.build.core=arduino:arduino 

##############################################################

atmega328bb.name=ATmega328 on a breadboard (8 MHz internal clock)

atmega328bb.upload.protocol=stk500
atmega328bb.upload.maximum_size=32720
atmega328bb.upload.speed=57600

atmega328bb.bootloader.low_fuses=0xE2
atmega328bb.bootloader.high_fuses=0xDA
atmega328bb.bootloader.extended_fuses=0x05
atmega328bb.bootloader.path=arduino:atmega
atmega328bb.bootloader.file=ATmegaBOOT_168_atmega328_pro_8MHz.hex
atmega328bb.bootloader.unlock_bits=0x3F
atmega328bb.bootloader.lock_bits=0x0F

atmega328bb.build.mcu=atmega328p
atmega328bb.build.f_cpu=8000000L
atmega328bb.build.core=arduino:arduino 

##############################################################

usbtiny168.name=[usbtinyisp]ATmega168

usbtiny168.upload.using=usbtinyisp
usbtiny168.upload.maximum_size=14336

usbtiny168.build.mcu=atmega168
usbtiny168.build.f_cpu=8000000L
usbtiny168.build.core=arduino

##############################################################

usbtiny328.name=[usbtinyisp]ATmega328

usbtiny328.upload.using=usbtinyisp
usbtiny328.upload.maximum_size=32768

usbtiny328.build.mcu=atmega328p
usbtiny328.build.f_cpu=16000000L
usbtiny328.build.core=arduino

After that, I saved the file and restarted the Arduino software. Now I had four new menu items available. Go to Tools -> Board and you will find your new options. The two prefixed with USBTinyISP will not upload a sketch over the USB to Serial connection but rather it will require the 6 pin ISP header and will wipe out your bootloader. Of course, you can always rebootload your ATmega with your ISP programmer so that shouldn’t be an issue. The benefit to doing it this way is that it’s a little bit faster to upload and it takes up less memory on the chip so there’s no wasted space and less of a boot time when the micro powers up.

You Will Need

• Atmel AVR STK-500 Development Board
• An ATMEGA or ATTiny chip
• AVR Studio 4 Software
• Arduino 0022 Software
• Arduino Bootloader HEX File

Configuring the STK-500

This is the trickiest part of the setup, if you have the manual you’ll be following the directions for the ATmega8 device. The configuration is exactly the same for the ATmega168 as well as the ATmega328. To make sure there is no confusion, if I say to the right I’m referring to the side with the power and two RS232 ports, and the left would be the opposite side where you’ll see a row of push buttons. Though this should go without saying, make sure you have the power disconnected from the board and you are properly grounded so that you do not cause any E.S.D. damage to your board or components.

First you’ll be setting some jumpers. Place a jumper across the pins for VTARGET, AREF, RESET and XTAL1. Next you’ll place a jumper over the two right-most pins of OSCSEL. You’ll also be installing two jumpers on the PJUMP pins, be sure to connect the top two pins with one jumper and the bottom two with another, so the jumpers will be running left to right. The next jumper will be one of the trickier ones, you will need a longer jumper wire and you will be running it from the right most pin of BSEL2 to the pin labeled PC2 which is located in the bank of pins labeled PORTC which is to the bottom left side of the development board.

Next you’ll be running two ribbon cables across the board (as seen in section 3.7.2.1 of the manual). You’ll be connecting the PROG DATA header to the PORTB header as well as connecting the PROG CTRL header to the PORTD header. I’ve included figure 3-17 from the manual to demonstrate this:

Finish up by placing the chip into the socket labeled SCKT3200A2 which is the one outlined in Green. Pay attention to the small notch on the left edge of the socket, this will match up with a notch on one end of the chip.

Burning the Bootloader

Unlike when using an ISP programmer through the Arduino software there are a few more things to do than just click “Burn Bootloader.” For just the cliff notes follow the list on the right, or to jump to the video, otherwise keep reading. If you’ve just opened the software for the first time and it’s asking you to start a new project or open one, you’ll actually want to hit cancel. Now in your IDE select the Tools menu and then Program AVR and then select Connect… Now you’ll be presented with a screen asking about the LockBits, click back to the Main tab and select your Device and set the programming mode to HVSP. Before leaving this tab I recommend hitting Read Signature to to see if it reads the device fine, if it’s not hooked up right it will likely fail at this point.

Move on to the Program tab and then load your hex file. You’re going to need the right hex file for the chip and board you’re going to be working with. So go into your Arduino folder (e.g. C:\Program Files\Arduino\) under the Hardware\arduino\bootloaders\ and start looking for one that makes the most sense. If you don’t have the Arduino software installed yet or on this computer then another good source is LeafLabs on Google Code. To be honest I’m not sure what the difference is between all the bootloaders, I just use the one in the atmega8 folder and have had no issues. It’s also only 3kb verses 30kb which is the one whose name best maches the ATMega168 chips I’m using in this example. Once you’ve loaded the file into the AVR Studio under the Flash heading you can go ahead and hit program. I always have the options to erase the chip and verify afterwards, so if you don’t you may want to do that manually. If there are no errors in the bottom text move on to the Fuses tab.

Under the Fuses tab you will have to set some hex values. For the ATMega18 I was using in this example I had to set Extended to 0xF8 then High to 0xDF and Low to 0xFF. This may vary depending on the chip so make sure to look it up before hand. Before moving on click Program and check the log for errors.

Finally, check the LockBits page. These seem to reset to 0xFF after every program action so set them to 0xCF and hit Program.

At this point your bootloader should be burnt onto your ATMega chip and you should now be able to use it in your Arduino board. So pop it out of the STK500 and back into your Arduino board and fire up the software. From the examples menu select Blink and upload it to your device. If the LED alternates between on and off endlessly then you are ready to rock.

The first thing you’re going to need is AVR Studio. Even if you’ll be burning your bootloader through the Arduino program you’ll still need AVR Studio for the drivers. Unfortunately I could not locate stand alone drivers and was forced to download all 600mb of AVR Studio for this purpose only, so I suggest starting that process first so you can get everything else ready while it downloads.

You Will Need

• Atmel AVR Dragon Board
• An ATMEGA or ATTiny chip
• An Arduino board (or breadboard)
• 6 pin ISP Programming Cable
• AVR Studio 4/5 Software
• Arduino Bootloader HEX File

Setup the AVR Dragon

In this example I’ll be using the 6 pin ISP header which I will connect to my Arduino board. The AVR Dragon can do High Voltage Programming (HVSP) if you solder on a DIP or ZIF socket on the breadboard area to the right side. See this Instructables Guide for instructions on how to do that.

Unlike setting up the STK500 for HVSP programming the setup for the AVR Dragon in ISP mode is a breeze. The only “gotchya” is when hooking up the ISP cable make sure to align the cable so the wire with the red stripe matches the Pin 1 marker on each end. The AVR Dragon does provide power to the destination board via the VCC headers but I found it’s easier to power the Arduino by hooking it up to another USB cable or via a walwart adapter. Once both boards have power and are connected via the ISP header you are ready to fire up AVR Studio and program the bootloader onto the chip.

Programming it in AVR Studio 4

AVR Studio is a free program that only requires you register with AVR in order to download it. AVR Studio 5 is now available, and is the recommended software for this task, but this guide will stand for all who have not yet chosen to update.

After loading the program you will be prompted to create a new project or load an old one. We will do neither so hit Cancel and then on the main menu select Tools -> Program AVR -> Connect…. Now select the AVR Dragon as your platform and the USB Port and then click Connect again.

On the next screen select your device, in this case the ATmega168, and select ISP as your Programming Mode. I always hit Read Signature to make sure everything is connected properly. Now move on to the Program tab and under the Flash section select your HEX file. They can be found in your Arduino installation directory, check /hardware/arduino/bootloaders and you will find several variations there, more can be found online. After you have loaded the correct one hit Program and then when complete move to the next tab.

Next you’ll sit the Fuse settings. The correct settings for the ATmega168 chip are 0xF8, 0xDF, 0xFF but make sure to use the correct settings for the chip you are using. Click Program then go to the Fuse Bits tab and set it to 0xCF and hit Program again.

At this point your Arduino is ready. You can plug it in as per usual and upload a Sketch in the Arduino software. I usually start by loading the Blink program as it is a quick and easy way to test the bootloader as the built in LED on Pin 13 will allow you to easily access if the program is running. Make sure to upload a sketch again to make sure your lock bits were set properly, as if they are not the sketch will overwrite the bootloader and a subsequent upload will fail.

Programming it in AVR Studio 5

AVR Studio 5 is the new and improved way to build your AVR programs. It runs off the Visual Studio Shell which gives .Net developers an “at home” feeling when using the software. Beyond that I couldn’t tell you what the extra features are as I only use it for programming the bootloaders and everything else I do right in the Arduino software. The software can still be downloaded for free after registering, and is unfortunately about 600mb to download, which is a lot for what we’ll be doing today.

Uploading the bootloader is pretty much the same. Start off by going to Tools then AVR Programming. On the next window select AVR Dragon as your Tool and ATmega168 as your Device. Then ISP as your Interface then click Apply. Click Read for both Device ID and Target Voltage to make sure everything is hooked up correctly and to initialize some settings.

Jump to the Memories tab and under Flash select your HEX file from the Arduino folder. They can be found in /hardware/arduino/bootloaders or easily found online. Make sure to load the proper HEX file for the chip you are working with, in this case we are using an ATmega168 chip so the file I use is ATmegaBOOT_168_atmega328.hex since I was too lazy to complile the ATmegaBOOT_168.c file. Once the proper file is loaded click Program.

Now move on to the Fuses tab and set them to 0xF8, 0xDF, 0xFF and then hit Program before moving on to the Lockbits tab where you will set it to 0xCF before hitting Program again. Once again, verify the settings for your chip as they will vary. You may also want to tweak them to your own needs, for instance you may want to use the internal oscillator to run the chip at 8 MHz instead of the 16 MHz you get with the external crystal. The lockbits will be configured to prevent the bootloader from being wiped each time you upload a sketch, so if you’re bootloaded chip only works once through the Arduino software’s upload method, then you likely forgot to set the lockbits or didn’t set them correctly.

Testing Your Bootloaded Chip

After flashing the bootloader you can disconnect the ISP header and plug the Arduino board into your USB port before loading the Arduino software. Once it is loaded open the Blink sketch and then select your board and port before uploading. The blink sketch is the best tool for testing a chip as Arduinos now come with a mini LED and a resistor already installed on Pin 13 which this sketch is configured to use. Please note that older versions of the Arduino only had the 1k ohm resistor preinstalled so it will still need an external LED on Pin 13. If your sketch uploads without an error you shouldn’t have any problems, but either way I suggest watching the LED for a few seconds to ensure that it alternates between on and off, if it does this then upload the sketch one more time to make sure you didn’t set the lockbits wrong. If it works the second time then your bootloaded ATmega is ready to go!

The Arduino Playground does a pretty good job of directing users on how to install Arduino on Debian based distributions but there were a couple of spots where I found it was lacking, and had to go out to do my own research. The main thing it lacked was instructions on how to set up a launcher for your desktop or Gnome menu. I will outline those at the end of this guide, but first I will give you a quick overview of the installation process from the start as I performed it on both my Linux Mint laptop and my Ubuntu 9.10 desktop. Although this guide was written with Linux Mint users in mind, there is absolutely no reason this will not work on other Debian based distros.

Open up your console and run the following commands to install some necessary prerequisites. If you know for a fact you have them installed you can skip installing them again. You will most likely be prompted to enter Y before the installation will begin.

sudo apt-get install sun-java5-jre
sudo apt-get install gcc-avr
sudo apt-get install avr-libc

Now that you have the prerequisites installed you will need to download the newest version of Arduino. You can save it to your desktop for now. After it has finished downloading open up the folder and extract it to your desired location (such as your home directory) or you can do it in your console as well:

tar xvzf ~/Desktop/arduino-0017.tgz ~/Arduino

At this point it is safe to delete the tarball on your desktop.

At this point Arduino is installed and ready to use. This is also where the Arduino Playground leaves you hanging, no one wants to open up their console every time to launch a program or browse to it with their file explorer. I initially tried creating an installer just as I normally would, by pointing it to ~/Arduino/arduino) only to find that the program did not launch when I clicked it. So I then created a bash script which called the same file and made sure it was executable. Still nothing! So that’s when I realized that I had to do things a bit differently. Nothing too fancy, just a slightly different way of approaching it.

First create an empty bash file and make it executable.

touch ~/Arduino/runArduino.sh
chmod a+x ~/Arduino/runArduino.sh

Then open it in your favourite text editor (e.g. emacs or pico), and add the following contents to your bash script:

#!/bin/bash
cd ~/Applications/Arduino && ./arduino

Save the file and close your terminal. Right click the Gnome menu and select Add to Panel. Select Custom Application Launcher and hit Add. Enter Arduino for the name, and in the path put /home/username/Arduino/runArduino.sh. You can also select an icon for the launcher, which is another place Linux users were left out in the cold as the tarball does not contain an SVG file. Fortunately, I did manage to dig up a PNG version to use. Save this icon to your install directory and select it by clicking the “spring” icon and navigating to your install directory. From there click close to save the settings and add the launcher to your panel.

After ordering a few more supplies on the weekend my shipment arrived on Wednesday, the main thing I was waiting on was a time keeping chip and I had selected the DS1302 from Maxim IC to do that job. Aside from that I got a crystal for the clock, a few mini servos, some stackable headers (to make my proto shield and motor shield stackable), push buttons, a piezo speaker and some other various headers and connectors.

I was very eager to try out the clock chip and rushes straight home and went to work. I pulled a 3V battery out of an old motherboard and popped it into a 3V battery holder I had bought a while back (note: the 3V battery and holder is represented by a piezo speaker in this diagram as there was no part for a 3V battery). I popped that into one side of the mini breadboard on the Protoshield and installed the DS1302 on the other side. Wiring the circuit was a breeze and I didn’t even have to pull up the data sheet. The chip came attached to a business card sized information sheet that had the pin outs on the back. Thank you HVW Technologies! I’ll be using the pin labels from that card and providing the alternative marker from the Fritzing diagrams in brackets.

The DS1302 has two pins for power input and which ever is capable of providing more power will take over and power the clock and crystal. So I hooked the Vcc1 (V+) to the 3.3v pin and the Vcc2 (Vbat) to the 3v battery. The idea being that if I unplug the device (USB or power adapter) the 3.3v pin will stop providing power to circuit and the battery will seamlessly take over so no time is lost. When the circuit regains power the DS1302 has a built in trickle charge circuit that will charge up the 3v battery for you. The X1 and X2 pins are bridge with a crystal, the ground to the ground rail of course and the remaining three pins are SCLK, I/O and RST (CE) are run to pins 7, 6 and 5, respectively.

The code was very simple and was all build on the RTC Library which I found on the Arduino site. The code is very rough at this point and just prints the time every second over serial, during the range of 9pm to midnight it will print Unlocked and all other hours will print Locked. Eventually the code will be altered to query the locked/unlocked status on button press and if it falls within the time range the servo will unlock the box.

//  @author: Brad Fettes <http://www.fettesps.com>
//  @thanks: Matt Sparks <http://quadpoint.org/projects/arduino-ds1302>
//  @date: December 9, 2010
//  @purpose: Check the ds1302 to see if the chronobox should be locked or unlocked

#include <stdio.h>
#include <string.h>
#include <DS1302.h>

// Set the appropriate digital I/O pin connections
uint8_t CE_PIN   = 5;	// RST
uint8_t IO_PIN   = 6;
uint8_t SCLK_PIN = 7;

// Create a DS1302 object
DS1302 rtc(CE_PIN, IO_PIN, SCLK_PIN);

// Create buffers
char buf[50];
char day[10];

// Thanks to the Arduino library...
void check_alarms() {
  // Get the current time and date from the chip
  Time t = rtc.time();

  // Name the day of the week
  memset(day, 0, sizeof(day));  // clear day buffer 

  // Check the hour
  snprintf(
             buf, sizeof(buf), "%02d:%02d:%02d",
             t.hr, t.min, t.sec
          );
  Serial.print(buf);
  Serial.print(" - ");
  switch (t.hr) {
    case 21: // After 9 pm
      Serial.println("UNLOCKED");
      break;

    case 22: // After 10 pm
      Serial.println("UNLOCKED");
      break;

    case 23: // After 11 pm
      Serial.println("UNLOCKED");
      break;

    default:
      Serial.println("LOCKED");
  }
  Serial.println();
}

void set_time() {
  /*
     Initialize a new chip by turning off write protection and clearing the
     clock halt flag. These methods needn't always be called. See the DS1302
     datasheet for details.
  */
  rtc.write_protect(false);
  rtc.halt(false);

  // Make a new time object to set the date and time
  Time t(2010, 12, 9, 11, 11, 0, 4);  // e.g. Thursday, Dec 9, 2010 at 11:11:00

  // Set the time and date on the chip
  rtc.time(t);
}

void setup() {
  // Ensure that we have a few seconds to upload code
  delay(2500);

  // then start serial communication
  Serial.begin(9600); 

  // Uncomment to set the time to the one defined above
  // make sure to upload it again uncommented or it will reset
  // the date each time gets powered up
  //set_time();
}

/* Loop and print the time every second */
void loop() {
  check_alarms(); // Lock or Unlock
  delay(1000); // wait one sec
}

The next step here is to combine this sketch with the one from Part 2 where I controlled a locking mechanism with a servo. I will also need a way to provide feedback to the user by a piezo or LCD panel. Stay tuned for Part 4 which will be posted just after the new year. Happy holidays!

Download the Project Files:
Frizing Project
Arduino Code

The other day I wrote about a project I was building that was a time based lockbox which I have now dubbed the “Chronobox.” Much like the Reverse Geocache this lockbox can only be opened from the inside and that will only happen if a certain set of parameters are met. In this case, that parameter is time.

Today, rather than focusing on Fritzing, I’ll be starting to cover some builds I’ve done on the protoshield to get familiar with each of the components needed for this project as well as to try out a few different locking mechanisms I’ve had on my mind.  The first will be a simple circuit used to control a servo which will open a latch. My setup is just a standard blue Arduino Duemilanove and a Proto Shield from Adafruit with a mini breadboard fastened on top.  I also have a motor shield from Adafruit as well but I need to remove the current headers and replace them with stackable headers before its of any use to me, why all shields font come with these by default is beyond me.  My final configuration will likely be built out on a Hardcopy (which is apparently now known as the Protino).

Wiring the circuit was quite simple, I took 3 break away header pins and slit the center divider down to the middle and pushed it into the header from the servo which then allowed me to plug the header into the bottom right of the mini breadboard.The black wire was ran to the ground rail and the red wire run to the 5v rail (if you’re not using a proto shield you can just run them directly to the ground and 5v pins on the arduino). The yellow control wire was run to on of the Digital PWM pins (Pin 9 in my case). The switch was wired by running a ground wire with a 1k Ohm resistor bridging the gap and a wire run to the 5v rail. Another line is then run from Digital pin 10 to a position between the 1k Ohm resistor and the push button. When the button is idle the current will run from the ground, through the resistor into the input pin giving you a reading of low and when you press the button 5v is sent through the circuit into a the digital pin which will cause it to read high. The resistor is there to stop the 5v current from running directly to the ground instead of the digital pin.

The code is pretty straight forward and is a combination of the Sweep and Button examples that came with the platform. The pushbutton will be set to pin 10 for input and the LED pin will be pin 9 set for output and the servo will be attached to pin 5. If you aren’t using the Protoshield you can skip the LED or just use the built in LED and 1k Ohm resistor on pin 13 instead. When the button is pressed the LED pin will be set high and using the servo library I’ll be rotating between two positions which through experimentation I’ve determine to be just the right arc to lock or unlock the box.

// @author : Brad Fettes <http://www.fettesps.com>
// @date   : Dec 04, 2010
// @thanks : Sweep by BARRAGAN <http://barraganstudio.com>
//		   : Button by Tom Igoe <http://www.arduino.cc/en/Tutorial/Button>

#include <Servo.h>

int inputPin = 10;      // Push button input pin
int btnVal = 0;         // Current value of pushbutton

int ledPin = 5;			// Pin for Green LED built into proto shield

int outputPin = 9;      // Servo pin
int servo_pos = 0;      // Current servo position
int servo_pos_a = 20;   // Position destination a
int servo_pos_b = 65;   // Position destination b
int servo_state = 0;    // 0 = position a, 1 = position b

Servo mrservo;  // create servo object to control the servo

void setup() {
  pinMode(inputPin, INPUT); // Push Button
  pinMode(ledPin, OUTPUT); // LED

  mrservo.attach(outputPin);  // attaches the servo on pin 9 to the servo object

  // Debug messages via serial monitor
  Serial.begin(9600);
  Serial.println("Starting...");
}

void loop() {
  // Check to see if button is LOW or HIGH (5v)
  btnVal = digitalRead(inputPin);

  if(btnVal == LOW) {
    Serial.println("Button: LOW");
    digitalWrite(ledPin, LOW);

    if(servo_state) {
      Serial.println("Position: a");
    } else {
      Serial.println("Position: b");
    }
  }

  if(btnVal == HIGH) {
    Serial.println("Button: HIGH");
    digitalWrite(ledPin, HIGH);

    if(servo_state) {
      Serial.println("Position: a");
    } else {
      Serial.println("Position: b");
    }

    // Move from position a to position b
    if(servo_state == 0) {
      // I don't know how to concatenate
      Serial.print(servo_pos_a); Serial.print(" to "); Serial.println(servo_pos_b);

      for(servo_pos = servo_pos_a; servo_pos < servo_pos_b; servo_pos += 1) {
        mrservo.write(servo_pos);
        delay(15);                       // waits 15ms for the servo to reach the position
      }
      servo_state = 1;

    } else {  // Move from position b to position a

      Serial.print(servo_pos_b); Serial.print(" to "); Serial.println(servo_pos_a);

      for(servo_pos = servo_pos_b; servo_pos >= servo_pos_a ; servo_pos -= 1) {
        mrservo.write(servo_pos);
        delay(15);
      }
      servo_state = 0;
    }
  }

  // Separate each cycle's output
  Serial.println(); Serial.println();
  delay(250);
}

Here’s a video out the servo with a meccano arm attached rotating between positions A and B:

I sculpted a prototype out of a small box I had lying around. It isn’t perfectly to scale as it’s not nearly as tall as my lockbox but the base dimensions are about the same. After building a few latches out of cardboard and tacks I found a design I liked and made a more permanent latch with some mecanno like materials I had. I affixed it to the front of the box and hot glued a servo in place and wrote some code to try out the lock and see how it works.

I ran into a bit of an issue where when it’s in its reseting state the weight of the latch pulls down on the pivot point causing the longer shaft to lift up over the center line of the pivot point so when it pushes forward again the latch spins the wrong way. In order to prevent this from happen I took another random piece of meccano and glued it under the latch so it had a resting post. After a few tests runs I was satisfied with this solution.

I’m still not sure I’m happy with this latching method, so I think I’ll be testing out some other builds before I choose which method I’ll use in my final build. One idea that was suggested to me, which made me chuckle because it was so simple I couldn’t believe I hadn’t thought of it, is to just attach the latch itself to a servo and mount it higher up, that way you don’t have joints which could fault on you and leave you with a lockbox jammed shut. I’ve been considering this idea as well as doubling up and having two servos locking and unlocking the box, as I don’t want someone to be able to pull it open with brute force. On top of that I’m resisting the urge to take the Dremel to the back casing on the key lock which is built into the cash box so I can see what’s going on in there, and possibly control it with a servo instead of a key. The built in lock is very solid and you’d never be able to pull it open with brute force.

Download the Project Files:

Frizing Project
Arduino Code

Start off by loading the Arduino development environment and on the main menu select File->Examples->Stubs->HelloWorld. The following project will be loaded into your sketchbook:

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println("Hello World!");
}

This is the basic structure of all Ardino programs. These two functions are the heart of every program you will write, so it doesn’t hurt to take a moment and discuss them. Both functions must be declared outside of the scope of all other functions. They are declared as void so they are not expected to return any value and they do not require any parameters. The setup funciton is called once when your board first powers up, and is used to initialize any devices or pins that are going to be used in your program. After the setup function executes the loop function begins to run, and it will continue to run endlessly until you power off your board. When first beginning to work with microcontrollers it takes a bit of time to wrap your head around the way the execute code, in an infinite loop, as this is somewhat different from the way any programs would run on your desktop or server computer.

In the setup function you will see that the board is configured for serial communications with the command Serial.begin(9600);. It is set to communicate at 9600 baud and it is important to note that even though we are using an emulated serial port over USB that pins 0 (Rx) and 1 (Tx) are wired to the FTDI USB-to-TTL Serial chip so they will be unavailable whenever you are performing serial communication over USB.

In the loop function Serial.println(“Hello World!”); is used to echo Hello World back to the computer over the serial connection. In order to see this message you will have to hit the Serial Monitor button on your toolbar. The serial monitor provides us with one of our only ways to debug our code, by echoing debug information back to our computer. And of course the serial communication ports on the Arduino can be used for more advanced purposes.

So how can we make this example a little more interesting? How about programming the onboard LED to flash Hello World in morse code? If you have a pack of LEDs and transistors you could also set up an array of LEDs to spell it out in binary. Since the Experiementation Kit did not include these, I will stick with using the LED connected to pin 13. The first step was to find a reference for morse code, a quick trip to Wikipedia gave me everything I needed. After that you will need a quick intro to working with LEDs, the best way to do that is to select File->Examples->Digital->Blink from the menu and take a look at the code there.

/*
Blink

Turns on an LED on for one second, then off for one second,
repeatedly.

The circuit:
* LED connected from digital pin 13 to ground.

* Note: On most Arduino boards, there is already an LED on the
board connected to pin 13, so you don't need any extra components
for this example.

Created 1 June 2005
By David Cuartielles

http://arduino.cc/en/Tutorial/Blink

based on an orginal by H. Barragan for the Wiring i/o board
*/

int ledPin =  13;    // LED connected to digital pin 13

void setup()  {
  // initialize the digital pin as an output:
  pinMode(ledPin, OUTPUT);
}

// the loop() method runs over and over again,
// as long as the Arduino has power
void loop() {
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(1000);                  // wait for a second
  digitalWrite(ledPin, LOW);    // set the LED off
  delay(1000);                  // wait for a second
}

The command pinMode in the setup function is used to tell the micro that pin 13 is going to be used for output. In your main loop you are simply telling it to turn on (HIGH) and off (LOW) by passing the pin number and mode to the digitalWrite command. You could also use the analogWrite command but since pin 13 does not support PWM you would only be able to set it to on or off, rather than adjust the brightness. Pins 3, 5, 6, 9, 10, and 11 on the Duemilanove support PWM and if you need to create a pulsing effect with your LEDs you will have to to hook up an LED and 1K Ohm resistor to one of those pins. At this point, stick with pin 13, and hit the upload button again and watch what happens. From there I would suggest tweaking the delays to create different blinking patterns if you feel you need to get a bit more comfortable with LEDs before moving on.

When you’re ready, we’ll begin splicing these two examples together and creating our morse code flasher. If you have an extra LED sitting around feel free to plug the long leg into pin 13 and the short leg into the ground (GND) beside it. Since pin 13 has a resistor built in we to not need to do anything more than that. At the top of your project declare some new variables. We’re going to do this before any of the core functions as they need to be accissible by all of them.

int delayDot = 200;
int delayDash = 500;
int delayLetter = 250;
int delayWord = 500;

These variables store the delay time in milliseconds for the two different “characters” and the spacing between them. These can be tweaked to your liking, I personally don’t know Morse Code so I’m not sure how acturate the timings are.

Next you will be adding some code to the setup() and loop() functions.

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  print_morse_code("h");
  print_morse_code("e");
  print_morse_code("l");
  print_morse_code("l");
  print_morse_code("o");
  print_space(1);
  print_morse_code("w");
  print_morse_code("o");
  print_morse_code("r");
  print_morse_code("l");
  print_morse_code("d");
  delay(1000);
}

The setup() function tells the board it will be outputting over the FTDI bus and prepares Pin 13 for output. The loop calls a function called print_morse_code() which is a very basic character map for the differenet pulses, it simply masses the character passed in with its list of options and outputs the proper sequence for each. At the end of the main loop is a 1 second delay before it starts over from the beginning.

Before we look at the print_morse_code() function lets look at the functions that create the characters.

void print_dot() {
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(delayDot);                  // wait for a second
}

void print_dash() {
  digitalWrite(ledPin, HIGH);   // set the LED on
  delay(delayDot);                  // wait for a second
}

// Turn off LED
// 0 = Letter
// 1 = Word
void print_space(byte len) {
  digitalWrite(ledPin, LOW); // set LED off
  if(len) {
      delay(delayWord);
  } else {
      delay(delayLetter);
  }
}

They’re quite simple functions. The LED is set to HIGH and the module waits 250ms for a dot and 500ms for a dash before it moves on to the next digit. The next function, print_space(), is a bit more intricate. It requires a parameter to be passed in to determine which delay is going to be used after turning the LED off. We want a 200ms space between each letter and a 500ms space between each word.

The last function we need is print_more_code() which ties it all together. It’s not pretty, but it works.

// Convert letters to to morse code via LED and Serial echos
void print_morse_code(char* letter) {
  // Hello
  // ****  *  *-**  *-**  ---

  // World
  // *--  ---  *-*  *-**  -**

  if(letter=="h") {
      Serial.println("****");
      print_dot();
      print_dot();
      print_dot();
      print_dot(); 

  } else if (letter=="e") {
      Serial.println("*");
      print_dot();

  } else if (letter=="l") {
      Serial.println("*-**");
      print_dot();
      print_dash();
      print_dash();
      print_dash();

  } else if (letter=="o") {
      Serial.println("---");
      print_dash();
      print_dash();
      print_dash();

  } else if (letter=="w") {
      Serial.println("*--");
      print_dot();
      print_dash();
      print_dash();

  } else if (letter=="r") {
      Serial.println("*-*");
      print_dot();
      print_dash();
      print_dot();

  } else if (letter=="d") {
      Serial.println("-**");
      print_dash();
      print_dot();
      print_dot();
  }

  print_space(0);
}

A character is passed in and matched to a sequence of calls to print_dot() and print_dash() to create the desired letter. At the end a letter space is added for padding making it easier to understand the transmission. And just to help out with decrypting the message I output the currect character to the serial port so you can follow along on your computer.

The code for this entire project is available on Google Code for reference. I encourage anyone to build off of it or optimize it. Just keep in mind I’m not a C programmer

Comparison

They had two packages available, the Arduino Experiementation Kit for $85 CDN and the Arduino Basic Kit for $55 CDN. Both kits come with the Arduino Duemilanove board, a mini solderless breadboard, a USB cable for power and programming the micro and a jumper wire kit. The basic kit also comes with a power supply, which for some reason the more expensive kit lacks. The experimentation kit adds a servo, rotation sensor, infrared sensor and some break away headers. Since I wanted to be able to actually make something with my micro and not need to pick up tons of extra parts from elsewhere I went with the experimentation kit.

Analysis

Arduino Duemilanove USB Microcontroller Module

Comes fully assembled and the ATMega328 is pre-loaded with the Arduino bootoader. I was immediately disappointed by the fact that my row of 6 analog connectors was soldered in crooked. Rather than be at a 90 degree angle with the board it is sitting at about 75 degrees. The solder joint is solid enough that I can’t just bend it back in to position, and I’m confident that in its current state I will not be able to snap on any shields unless I heat up the solder joint and reposition it. The board is usuable, however I don’t feel it should have made it past quality control.

Sharp GP2D12 IR Range Sensor

Definitely a fun sensor to play with. One of my first designs was a motion sensor that lights up an LED when you put your hand in front of the sensor. From there I improved it by changing the brightness of the LED based on the distance from the sensor. A quick Google search for this sensor and you will find the datasheet as well as plenty of code examples as it seems to be a very common choice.

Phidgets Rotation Sensor

All my research on this device has told me to use it with the Phidgets Interface Kit. So it was like they had a bunch of these lying around and just tossed them in to get rid of them. I did manage to find a Product Manual for it thankfully and was able to determine that it used the analog pins and returned a value between 0 and 1000 based on the position of the knob.

Hitec HS-422 Servo Motor

Haven’t played with this part much yet, sometime this week I will hook it up and the rotation sensor and see if I can get the two working together. Other than that, it looks well made and its by a reputable manufacturor.

Mini Self Adheasive Solderless Breadboard

I’d be lost without this component. I am the worst at soldering and I certainly don’t want to make any of my circuits permanent at this point. The breadboard allows me to prototype out all my little ideas and make mistakes along the way. It does seem weird to be using it without the Proto Shield though, as it is forced to sit to the side rather than on top of the module.

Pre-formed Jumper Wire Kit

Wasn’t really sure what these were going to be until I got them. Now that I know what they are I love them. No need to measure, cut or strip wires — just find the right jumper and plug it in. It’s really simple.

Break Away Headers

Haven’t found these to be very useful. So far I’ve only broken off 3 and it was to use to connect the IR sensor to the breadboard. Problem is the plastic strip that divides the two ends isn’t centered. So either I get a good connection on the breadboard or a good connection on the IR sensor, not both. As a result I’ve knocked the sensor out many times while playing with it.

Getting Set Up

Since right now my main OS is Windows 7 I will be doing all of my development under it.  The development environment is written in Java so if you are more at home in OSX or Linux then you can just as easily do your development there.  The software package can be download directly from Arduino.cc where you can also look up code examples and anything else you need to get going.

The Arduino works be emulating a serial port over USB and uses the FTDI drivers which come packaged with the development software. Unfortunately this bundled set of drivers is out dated and would not work with my computer. I had to try several sets of drivers before I found ones that worked with Windows 7 x64. The most up-to-date drivers can be obtained from FTDI’s website. One thing to note is that when installing virtual com port drivers you will notice that after the first device is installed you will again be prompted to install another set of drivers. One is the USB Serial Converter and the second is the USB Serial Port. I personally didn’t like the port that was auto assigned to my Arduino so I went into device manager and disabled what was already on COM1 (which I was not using) and opened up the properties of the USB Serial Port, clicked the Port Settings tab, then Advanced. Here I selected COM1 and hit ok, after accepting the warning that another device was using that port I was back to Device Manager. From there I right clicked Communications Port (COM1) and selected disable. Even if you don’t want to change the port it is running under you would still be wise to go into Device Manager and find out for sure which port it is using as you will need to know this when it comes time to upload your program to your Arduino.

After installing both the FTDI drivers and the Arduino development environment all that’s left is a small amount of configuration. Start up Arduino 0017 and select Tools -> Board -> Arduino Duemilanove or Nano w/ ATmega328. Then again under the Toosl menu select Serial Port and the port you are using (in my case COM1). Your software is now configured, at this point I would recommend reading some of the examples found under the file menu.

Conclusion

Overall I’m happy with the kit, I’ve been itching to get my hands on a Arduino board for some time now and they had it in my hands just two days after ordering the kit online. On top of that it came with two sensors and one device to output through (not including the onboard LED). The devices it came with are certainly not the ones I would have picked if I was building a kit of my own they are definitely handy and I will have lots of fun finding a use for them.

I would have liked to have seen three things included in this kit, as they were strangely absent. The first is the power supply. It strikes me as very odd that it would be offered in the cheaper package but not the high end package. The second is a pack of LEDs, they’re cheap enough that they should have thrown in at least two or three different colours to play with. To go with those you would have needed a pack of resistors, they are also quite cheap and are essential for lighting LEDs without blowing them. I picked up a pack of both at Radio Shack as I felt lost without them. There are other things, such as a proto shield, that I would have loved to have in my starter kit but those are a fair bit more expensive and would have certainly raised the price of the kit. My biggest gripe would definitely be the crooked row of analog Pins. I was extremely disappointed to discover this.

The Arduino Experimentation Kit offers a beginner developer enough to get started, and it is packaged at a reasonable price. If you know specifically what you’d like to start building you’d be better off to build your own kit out of parts that are easily available on their website. I will definitely be going back to RobotShop.ca for some more supplies as their prices are reasonable and they are conveniently quite close to me. However if you live in the states, or you don’t have tons of random electrical components laying around your apartment waiting for you to build something out of them like I do, then you’d probably be wiser to order The Advanced Arduino Starter Kit from MakerShed which would come with almost everything you could possibly need in your early stages of Arduino proto-typing.