Arduino Uno SOS

Almost all tutorials youll find start by making an LED (light emitting diode) blink, and this is a
great way to start since it takes the absolute minimum amount of parts and steps to make a
functioning project. So well do the same with this Arduino Uno Tutorial. If you already have
experience with Arduinos, then you can probably just read through this section.


Imagine that you are stranded at sea and can see other boats or planes, but dont have a radio
or cell phone? What to do, send an SOS of course, that is the international Morse code distress
signal. ( SOS does not officially stand for anything, it is used because it is very easy to
send/receive and remember, 3 dots, 3 dashes, 3 dots . (http://en.wikipedia.org/wiki/SOS ).
Creating an SOS beacon with an Arduino is about as easy as it gets, a tiny LED like well be
using would not be bright enough to signal another ship, you would need a lot more power than
what the Arduino Uno can supply by itself to run a light bright enough for that. This can be done
easily by having the Arduino connected to an electrical relay, but thats a different lesson
altogether, well stick with just a simple LED for now.
We only need 3 pieces of hardware for this first tutorial
1) Arduino Uno.
2) USB cable.
3) one LED, just about any LED should work.
First, here is a quick overview everything youll need to do for this part of the tutorial.
1) Download and install the Arduino software.
2) Connect the Uno to your computer using the USB cable.
3) Open the IDE.
4) Select your board and Serial Port.
5) Copy and paste the code from here.
6) Upload the program.
7) Install the LED.
The first thing to do if you have not already done so is to download and install the Arduino
software, it is available for Windows, MAC or Linux. I will walk you through how to install it for
windows. It is just as easy to install on Mac or Linux, Ill provide some links for those.
For Installing Windows:
You can find the installer at http://arduino.cc/en/main/software . Youll notice that there are two
files for windows, an installer, and a zip file. Its easiest just to use the installer as this will install
the IDE and the drivers for you. If you instead download the zip file you will probably need to
install the drivers manually. The official Arduino pages give a good description of how to do
this. http://arduino.cc/en/Guide/windows. I always use the installer.
go to where you saved the Installer and run it.







For installing on MAC see: http://arduino.cc/en/Guide/MacOSX
For installing on Linux see: http://playground.arduino.cc/learning/linux
Now that the Arduino software is installed, we need to connect the Uno through the USB port.

Navigate to where you have installed your Arduino folder ( mine
is C:\electronics\Arduino\arduino-1.0.5 ), and open the Arduino IDE.
First we need to tell the Arduino software what board we are using and which serial port to use
to program the board.
Click Tools->Board->Uno,


then Click Tools->Serial Port->COM1 ( or whatever serial port you are using ). It not always
obvious which serial to choose, I usually keep trying until I find the right one.


Next, copy and paste this code into the IDE.
// flashes a LED in a 3dots-3dashes-3dots pattern
const int led_pin = 13;

void setup() {
// set the digital pin as output:
pinMode(led_pin, OUTPUT);
Serial.begin(9600);
}

void loop()
{
// write the 'S'.
digitalWrite(led_pin, LOW);
delay(250);
Serial.println("writing low");
digitalWrite(led_pin, HIGH);
delay(250);
Serial.println("writing high");
digitalWrite(led_pin, LOW);
delay(250);
Serial.println("writing low");
digitalWrite(led_pin, HIGH);
delay(250);
Serial.println("writing high");
digitalWrite(led_pin, LOW);
delay(250);
Serial.println("writing low");
digitalWrite(led_pin, HIGH);
delay(250);
Serial.println("writing high");
// write the 'O'
digitalWrite(led_pin, LOW);
delay(1000);
Serial.println("writing low");
digitalWrite(led_pin, HIGH);
delay(1000);
Serial.println("writing high");
digitalWrite(led_pin, LOW);
delay(1000);
Serial.println("writing low");
digitalWrite(led_pin, HIGH);
delay(1000);
Serial.println("writing high");
digitalWrite(led_pin, LOW);
delay(1000);
Serial.println("writing low");
digitalWrite(led_pin, HIGH);
delay(1000);
Serial.println("writing high");
}
Lets get the light blinking, then well discuss how this code works.
Click Sketch->compile and verify that the code compiles.
Now click on the upload button, this will compile and upload your first Arduino sketch (
program).

This is the most common place to get some errors, having the correct board and serial port
selected is very important. Things will not work if they arent correct , and the errors you get
might not be very informative. You also must have the drivers installed. Here is a list of the most
common problems I see.
I see this error whenever the board is not plugged in, or the wrong serial port is selected

and this is what I get when the wrong board is chose

While Im talking about errors, Ill mention a few more common issues that I have encountered,
not necessarily related to compiling and uploading. When using an Arduino that is being
powered by batteries alone, if the batteries start to run down, you might expect that things just
start to run slowly, but in reality all sorts of bizarre things can happen. If bizarre things start
happening and there isnt a good explanation as to why, it is always good to check your have a
reliable power source.
Sometimes having a a wire hooked up to pin 1 pr pin 2 can cause problems, because the serial
monitor can also be used through ports 1 and 2.You can try disconnecting whatever is
connected to ports 1 and 2, then upload your program, then reconnect whatever was connected
to ports 1 and 2.
Having an external power supply hooked up while you upload the program cause some
problems, e.g. with the motor shield used for this robot, youll may need to disconnect power
from the shield to program the Uno, upload your program, then reconnect the power supply.
Sometimes when doing a lot of tinkering and debugging, the Arduino just seems to get frazzled,
and if I just unplug the usb cable and restart the IDE, then plug the cable back in, things go back
to normal.
Once we have successfully uploaded the sketch, we are ready to insert the LED, a LED is a
polarized device, there is a (+) terminal and a (-) terminal, if you dont hook it up correctly, it
wont work, and in some situations can catch fire and burn up, it can also burn up if it draws
more power than it is rated for. This is why you need to pay attention to how much current your
LED can handle, if you hook a LED directly to a power supply it will probably catch fire and burn
up. I went ahead and hooked up a LED directly to the Arduino Uno, because we are blinking the
LED it does not draw current continuously. It would take a pretty small LED to get burned up
here, but its possible, so if you arent sure you should hook up a current limiting resistor. If you
are not familiar with the concept of a current limiting resistor, just Google it, there are a bunch a
great explanations, for example
https://www.sparkfun.com/tutorials/219. http://forum.arduino.cc/index.php/topic,3649.0.html. Ive
burned up LEDs, capacitors, and various other devices more times than I can count, its usually
not a big deal, but be careful, usually you will start to smell it before you see it, if you do start to
burn something up, just cut the power,( you should always a have an easily accessible way to
cut the power, e.g. plug the usb cable into the front of the computer so you can pull it out easily).
Then dont touch anything for a couple minutes to make sure things have cooled down. If you
really do it well it will set off your homes smoke detector. You can also ruin your Arduino if you
draw too much power from one of the ports, e.g. if you directly connect an output port to an
input port with a piece wire. LEDs have some internal resistance, which prevents this from
happening here. Here is a great write up ways to damage your Arduino.
( http://ruggedcircuits.com/html/ancp01.html)
Alright, the easiest way to tell positive from negative with LEDs is that one of the the wires is
almost always longer than the other. The longer wire is positive (+), which means the shorter
wire is negative. The other way to tell is that there will be a flat side on the plastic casing of the
negative wire. (if you really squint you can see the flat side of the LED in the second picture, it
was really hard to get the camera to focus on it). Almost every LED will have one of these
features, if not you are going to need a multimeter to figure it out. Use the ohm meter to
measure resistance, you will see a smaller resistance when the polarity is correct (forward-
biased), and a larger resistance when its hooked up backwards ( reverse-biased). If you need
more help with this check out http://www.allaboutcircuits.com/vol_3/chpt_3/2.html


hook up your led as shown here, the positive wire (the longer one) is inserted into port 13, and
the negative wire ( shorter wire, flat side ) into the GND pin that is next to port 13.


And the LED should be flashing now, like this
Now that you have seen what it takes to produce a simple sketch and upload it to the Arduino,
lets talk a bit about how the code works. One thing Im doing here that isnt usually done with an
introductory program is with all theSerial.println() commands, which are the simplest way to
debug a sketch that is running on an Arduino. You simply include lines like Serial.println(writing
low) , then with the usb cable still connected to the PC, click on Tools->Serial Monitor. In the
window that pops up you need to select the baud rate that matches what you have it set to in
the code, here it is set to Serial.begin(9600); when this code executes on the Arduino, the value
will get written to the window.


I need to go on a little side rant here, my first exposure to programming was a very long time
ago in a C programming class (this had nothing to do with Arduinos or embedded systems, just
programming a computer) , and the instructor did not show us or teach us how to use a
debugger. I had the same instructor for my second programming class, and again there was no
instruction on using a debugger, I ended up getting shown what a debugger from a classmate
about half way through that semester, and it cut down the amount of time I needed to complete
assignments drastically. As the years went by and I continued to educate myself, the
importance of good debugging grew more and more apparent. In particular, it was in one of my
favorite books, the Art of Unix Programming, which despite its name is a book on general
programming principles, and applicable to just about any sort of programming, that I first read
the following quote by Brian Kernighan.
Controlling complexity is the essence of computer programming [Kernighan-
Plauger]. Debugging dominates development time, and getting a working system out
the door is usually less a result of brilliant design than it is of managing not to trip over
your own feet too many times. ( The art of Unix programming page 36)
The author lays out 17 rules or principles, which the book is written around, here is number 7.
7. Rule of Transparency: Design for visibility to make inspection and debugging
easier.
and a quote later ( in Chapter 6)
Dont let your debugging tools be mere afterthoughts or treat them as throwaways.
They are your windows into the code; dont just knock crude holes in the walls, finish
and glaze them. If you plan to keep the code maintained, youre always going to need to
let light into it.
It is this last excerpt that I have come to appreciate the most, and what Im trying to pass on to
you, get yourself in the habit of thinking about your debugging from the very point you start a
new program, not when the first problem crops up. This will not only make you more productive,
but if someone else ever needs to read and/or modify your code, you will have done them an
enormous favor, not just with debugging your code, but in telling them where to look, a
enormous amount of information can be gleaned simply by knowing where the original author
would have looked to debug problems.
It is true that all this is less relevant with smaller programs like these, but since debugging is
what most programmers spend the most time on, I think you should take this approach with
every program you write, be it for your smartphone, PC or Arduino, whether your program is
small or large. Also debugging with an embedded system like Arduino is fundamentally harder
to set up than with a general purpose computer like your PC since we are writing the code on a
different device than it is executing on, there are many, much more sophisticated tools for
debugging an embedded system, but thats for another day. The Serial Monitor will be sufficient
for this tutorial, and thats what we will stick with here.
Having said all that, the debugging statements do clutter up the code a bit, so here is the code
without them.
// flashes a LED in a 3dots-3dashes-3dots pattern
const int led_pin = 13;

void setup()
{
// set the digital pin as output:
pinMode(led_pin, OUTPUT);
}

void loop()
{
// write the 'S'.
digitalWrite(led_pin, LOW);
delay(250);
digitalWrite(led_pin, HIGH);
delay(250);;
digitalWrite(led_pin, LOW);
delay(250);
digitalWrite(led_pin, HIGH);
delay(250);;
digitalWrite(led_pin, LOW);
delay(250);
digitalWrite(led_pin, HIGH);
delay(250);

// write the 'O'
digitalWrite(led_pin, LOW);
delay(1000);
digitalWrite(led_pin, HIGH);
delay(1000);
digitalWrite(led_pin, LOW);
delay(1000);
digitalWrite(led_pin, HIGH);
delay(1000);
digitalWrite(led_pin, LOW);
delay(1000);
digitalWrite(led_pin, HIGH);
delay(1000);
}

Notice that there are 3 sections in this program, the setup function, the loop function, and
everything outside these two functions. You will see at least these 3 sections in every program
you write. The setup function executes whenever you first power on the Arduino, or press the
reset button. Then the loop function will execute indefinitely, over and over again.
The line
const int led_pin = 13;
creates a variable that we will use to write to the port that the (+) wire of the LED is connected
to.
Then in the setup function the line
pinMode(led_pin, OUTPUT);
declares the port 13 is going to be used as an output, and that is all the setup that we will need,
in the main loop we only need two commands
digitalWrite(led_pin, LOW);
which simply sets the output to be HIGH ( 5 Volts) or LOW (0 Volts), since the negative wire of
the LED is inserted into the ground port (0 volts), when we set port 13 to be HIGH, well have a
potential difference of 5V across the LED and it will light up. When we set port 13 to LOW, there
will not be a potential difference and the LED will not illuminate. Lastly we just need to vary the
amount of time between the LED being on and off. This is done with

delay(1000);

where the time to delay is in milliseconds, 250 ms for the S ( dots) and 1000 ms for the O (
dashes )

And that is it for your first Arduino project! Congratulations, now if we are going to take over the
world, were gonna need some robots, so lets get to work building one!