Arduino: A Quick-Start Guide, Second Edition (2015)

---

Figure 5. The Arduino IDE is well organized.

It has no advanced features such as a debugger or code completion. You can change only a few preferences, and as a Java application it does not fully integrate into the Mac desktop. It’s still usable, though, and even has decent support for project management.

The image that follows shows the IDE’s toolbar, which gives you instant access to the functions you’ll need most:

· With the Verify button, you can compile the program that’s currently in the editor. So, in some respects, “Verify” is a misnomer, because clicking the button doesn’t only verify the program syntactically, it also turns the program into a representation suitable for the Arduino board. You can invoke this function using the ⌘R keyboard shortcut on a Mac or Ctrl-R on all other systems.

· When you click the Upload button (⌘U or Ctrl-U), the IDE compiles the current program and uploads it to the Arduino board you’ve chosen in the IDE’s Tools > Serial Port menu. (You’ll learn more about this in Compiling and Uploading Programs.)

· The New button (⌘N or Ctrl-N) creates a new program by emptying the content of the current editor window. Before that happens, the IDE gives you the opportunity to store all unsaved changes.

· Open (⌘O or Ctrl-O) opens an existing program from the file system.

· Save (⌘S or Ctrl-S) saves the current program.

· The Arduino can communicate with a computer via a serial connection. Clicking the Serial Monitor button (⇧⌘M or Ctrl-Shift-M) opens a serial monitor window that allows you to watch the data sent by an Arduino and also to send data back.

Although using the IDE is easy, you might run into problems or want to look up something special. In such cases, take a look at the Help menu. It points to many useful resources at the Arduino’s website that provide not only quick solutions to all typical problems, but also reference materials and tutorials.

Hello, World!

To get familiar with the IDE’s most important features, we’ll create a simple program that makes an light-emitting diode (LED) blink. An LED is a cheap and efficient light source, and the Arduino already comes with several LEDs. One LED shows whether the Arduino is currently powered, and two other LEDs blink when data is transmitted or received via a serial connection.

In our first little project, we’ll make the Arduino’s status LED blink. The status LED is connected to digital IO pin 13. Digital pins act as a kind of switch and can be in one of two states: HIGH or LOW. If set to HIGH, the output pin is set to 5 volts, causing a current to flow through the LED so it lights up. If set back to LOW, the current flow stops, and the LED turns off. You don’t need to know exactly how electricity works at the moment, but if you’re curious, take a look at Current, Voltage, and Resistance.

Open the IDE and enter the following code in the editor:

Welcome/HelloWorld/HelloWorld.ino
Line 1	const unsigned int LED_PIN = 13;
-	const unsigned int PAUSE = 500;
-
-	void setup() {
5	pinMode(LED_PIN, OUTPUT);
-	}
-
-	void loop() {
-	digitalWrite(LED_PIN, HIGH);
10	delay(PAUSE);
-	digitalWrite(LED_PIN, LOW);
-	delay(PAUSE);
-	}

Let’s see how this works and dissect the program’s source code piece by piece. In the first two lines, we define two unsigned int constants using the const keyword. LED_PIN refers to the number of the digital IO pin we’re using, and PAUSE defines the length of the blink period in milliseconds.

Every Arduino program needs a function named setup, and ours starts in line 4. A function definition always adheres to the following scheme:

<return value type> <function name> '(' <list of parameters> ')'

In our case the function’s name is setup, and its return value type is void: it returns nothing. setup doesn’t expect any arguments, so we left the parameter list empty. Before we continue with the dissection of our program, you should learn more about the Arduino’s data types.

Arduino Data Types

Every piece of data you store in an Arduino program needs a type. Depending on your needs, you can choose from the following:

· boolean values take up one byte of memory and can be true or false.

· char variables take up one byte of memory and store numbers from -128 to 127. These numbers usually represent characters encoded in ASCII; that is, in the following example, c1 and c2 have the same value:

	char c1 = 'A';
	char c2 = 65;

· Note that you have to use single quotes for char literals.

· byte variables use one byte and store values from 0 to 255.

· An int variable needs two bytes of memory; you can use it to store numbers from -32,768 to 32,767. Its unsigned equivalent unsigned int also consumes two bytes of memory but stores numbers from 0 to 65,535.

· For bigger numbers, use long. It consumes four bytes of memory and stores values from -2,147,483,648 to 2,147,483,647. The unsigned variant unsigned long also needs four bytes but ranges from 0 to 4,294,967,295.

· float and double are the same at the moment on most Arduino boards, and you can use these types for storing floating-point numbers. Both use four bytes of memory and are able to store values from -3.4028235E+38 to 3.4028235E+38. On the Arduino Due, double values are more accurate and occupy eight bytes of memory.

· You need void only for function declarations. It denotes that a function doesn’t return a value.

· Arrays store collections of values having the same type:

	int values[2]; // A two-element array
	values[0] = 42; // Set the first element
	values[1] = -42; // Set the second element
	int more_values[] = { 42, -42 };
	int first = more_values[0]; // first == 42

· In the preceding example, the arrays values and more_values contain the same elements. We have used only two different ways of initializing an array. Note that the array index starts at 0, and keep in mind that uninitialized array elements contain unreliable values.

· A string is an array of char values. The Arduino environment supports the creation of strings with some syntactic sugar—all these declarations create strings with the same contents.

	char string1[8] = { 'A', 'r', 'd', 'u', 'i', 'n', 'o', '\0' };
	char string2[] = "Arduino";
	char string3[8] = "Arduino";
	char string4[] = { 65, 114, 100, 117, 105, 110, 111, 0 };

· Strings should always be terminated by a zero byte. When you use double quotes to create a string, the zero byte will be added automatically. That’s why you have to add one byte to the size of the corresponding array.

In Emailing Directly from an Arduino, you’ll learn how to use the Arduino’s String class. It makes working with strings safer and more convenient.

Arduino Functions

Arduino calls setup once when it boots, and we use it in our “HelloWorld” example in Hello, World!, for initializing the Arduino board and all the hardware we have connected to it. We use the pinMode method to turn pin 13 into an output pin. This ensures the pin can provide enough current to light up an LED. The default state of a pin is INPUT, and both INPUT and OUTPUT are predefined constants.^[34]

Another mandatory function named loop begins in line 8. It contains the main logic of a program, and the Arduino calls it in an infinite loop. Our program’s main logic has to turn on the LED connected to pin 13 first. To do this, we use digitalWrite and pass it the number of our pin and the constant HIGH. This means the pin will output 5 volts until further notice, and the LED connected to the pin will light up.

The program then calls delay and waits for 500 milliseconds doing nothing. During this pause, pin 13 remains in HIGH state, and the LED continues to burn. The LED is eventually turned off when we set the pin’s state back to LOW using digitalWrite again. We wait another 500 milliseconds, and then the loop function ends. The Arduino starts it again, and the LED blinks.

In the next section, you’ll learn how to bring the program to life and transfer it to the Arduino.

Compiling and Uploading Programs

Before you compile and upload a program to the Arduino, you have to configure two things in the IDE: the type of Arduino you’re using and the serial port your Arduino is connected to. Since Arduino 1.6.0, the IDE tries to identify all Arduino boards that are connected to your computer automatically. This feature works quite well, but it also fails sometimes. So, you need to learn how to determine the type of your Arduino board and the name of the serial port it is connected to.

Identifying the Arduino type is easy, because it is printed on the board. Popular types are Uno, Duemilanove, Diecimila, Nano, Mega, Mini, NG, BT, LilyPad, Pro, or Pro Mini. In some cases, you also have to check what microcontroller your Arduino uses—most have an ATmega328. You can find the microcontroller type printed on the microcontroller itself. When you have identified the exact type of your Arduino, choose it from the Tools > Board menu.

Now you have to choose the serial port your Arduino is connected to from the Tools > Serial Port menu. On Mac OS X, the name of the serial port usually starts with /dev/tty.usbserial or /dev/tty.usbmodem. (On my MacBook Pro, it’s /dev/tty.usbmodem24321.) On Linux systems, it should be /dev/ttyUSB0, /dev/ttyUSB1, or something similar, depending on the number of USB ports your computer has.

On Windows systems, you have to use the Device Manager to find out the right serial port. In the Device Manager, look for USB Serial Port below the Ports (COM & LPT) menu entry. (See Installing the Drivers for Current Arduino Boards) Usually the port is named COM1, COM2, or something similar.

After you have chosen the right serial port, click the Verify button, and you should see the following output in the IDE’s message area (the Arduino IDE calls programs sketches):

	Build options changed, rebuilding all
	Sketch uses 1,030 bytes (3%) of program storage space. Maximum is 32,256 bytes.
	Global variables use 9 bytes (0%) of dynamic memory, leaving 2,039 bytes for
	local variables. Maximum is 2,048 bytes.

This means the IDE has successfully compiled the source code into 1,030 bytes of machine code that we can upload to the Arduino. If you see an error message instead, check whether you have typed in the program correctly. (When in doubt, download the code from the book’s website.)^[35]Depending on the Arduino board you’re using, the byte maximum may differ. On an Arduino Duemilanove, it’s usually 14336, for example. Also, the size of the sketch might be slightly different depending on the version of the Arduino IDE.

Now click the Upload button, and after a few seconds, you should see the following output in the message area:

	Sketch uses 1,030 bytes (3%) of program storage space. Maximum is 32,256 bytes.
	Global variables use 9 bytes (0%) of dynamic memory, leaving 2,039 bytes for
	local variables. Maximum is 2,048 bytes.

This is exactly the same message we got after compiling the program, and it tells us that the 1,030 bytes of machine code were transferred successfully to the Arduino. In case of any errors, check whether you have selected the correct Arduino type and the correct serial port in the Tools menu.

During the upload process, the TX and RX LEDs will flicker for a few seconds. This is normal, and it happens whenever the Arduino and your computer communicate via the serial port. When the Arduino sends information, it turns on the TX LED. When it gets some bits, it turns on the RX LED. Because the communication is pretty fast, the LEDs start to flicker, and you cannot identify the transmission of a single byte. (If you can, you’re probably an alien.)

As soon as the code has been transmitted completely, the Arduino executes it. In our case, this means the status LED starts to blink. It turns on for half a second, then it turns off for half a second, and so on.

The figure shows the activity on pin 13 while the program is running.

The pin starts in LOW state and doesn’t output any current. We use digitalWrite to set it to HIGH and let it output 5 volts for 500 milliseconds. Finally, we set it back to LOW for 500 milliseconds and repeat the whole process.

That’s it! You’ve created your first physical computing project. You’ve written some code, and it makes the world brighter. Your very own digital version of “fiat lux.”^[36]

Admittedly, the status LED doesn’t look spectacular. In Chapter 3, Building Binary Dice, we’ll attach “real” LEDs to the Arduino.

You’ll need the theory and skills you’ve learned in this chapter for nearly every Arduino project. In the next chapter, you’ll see how to gain more control over LEDs, and you’ll learn how to benefit from more advanced features of the Arduino IDE.

What If It Doesn’t Work?

Choosing the wrong serial port or Arduino type is the most common mistake when doing the first experiments with an Arduino. If you get an error message such as “Serial port already in use” when uploading a sketch, check whether you have chosen the right serial port from the Tools > Serial Port menu. If you get messages such as “Problem uploading to board” or “Programmer is not responding,” check whether you have chosen the right Arduino board from the Tools > Board menu.

Your Arduino programs, like all programs, will contain bugs. The compiler will detect typos and syntax errors. Figure 6, The Arduino IDE explains syntax errors nicely shows a typical error message. Instead of pinMode, we called pinMod, and because the compiler didn’t find a function with that name, it stopped with an error message. The Arduino IDE highlights the line, showing the error with a yellow background, and prints a helpful error message.