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.