In this new tutorial series, robotics educator and author Myke Predko introduces you to the basics of Arduino with simple projects that can be created in just a few minutes with inexpensive and easy-to-obtain parts. In this tutorial, Myke dives into how to program your Arduino so that you can plan an effective software architecture and monitor your application. Look for new tutorials every 2-3 weeks, or see all the tutorials in this series here. 

Welcome back. In this article, I want to discuss some of the particulars of programming an Arduino so that you better understand what is happening when your program is built. I’ll also discuss how to best architect your software. The Arduino software approach is somewhat unusual compared to other devices and, for beginners at least, takes away the need to do the high level design of the application. As a result, there are a few things to understand and keep in the back of your mind if you want your application to run without anything unexpected happening. In this article, I will provide you with a couple of simple applications to illustrate how Arduino software works, as well as a way to monitor the operation of the application.

In case you found the opening paragraph ominous and were wondering the Arduino is a potential minefield when it comes to software development, let me reassure you that it is as easy to program as any other device I’ve worked with and has been designed to allow for very sophisticated applications. It balances the needs of the beginner and expert application developer quite nicely.

When you’re creating with real time applications (applications that respond to different inputs), the common basic architecture is:

• System Initialization (“setup()”)
  • Define and initialize system and state variables
  • Setup hardware interfaces
• Repeat input/output processing code (“loop()”)
  • Get inputs
  • Process inputs with/update system and state variables
  • Drive outputs

The Arduino development software eliminates the need to come up with this program type, instead using the “setup()” and “loop()” methods, which provide this capability for you. As can be seen in Figure 1, when you first start the Arduino development tool or start a new “sketch” .ino (which I usually hear called an “ee-no”) file, the basic code with “setup()” and “loop()”are created – it is now up to you to put in the code for these two methods.

You may have heard that Arduino programming is really C++. However, when you compare example C++ programs to the Arduino .ino code, you will find that though there are some similarities, they really don’t look the same. This is because the .ino code is appended to the end of the C++ file containing the following “main()”:

#include <Arduino.h>

void setup();
void loop();

int main(void)
{
 setup();

#if defined(USBCON)
USBDevice.attach();
#endif

setup();
for (;;) {
  loop();
  if (serialEventRun) serialEventRun();
 }
 return 0;
}

// user .ino file is appended here

In the “main()” code, you can see the calls to the “setup()” and “loop()” methods, along with a few other pieces that need to be explained.

The first is the “#include <Arduino.h>” statement, in which the basic operations provided by the Arduino system are defined. “#include” statements copy in the contents of the specified file before the file is compiled.

Next are the “USBCON” and “USBDevice” statements. These are required if an Arduino USB Host Shield is used in the application. An Arduino USB Host Shield is a shield that enables the Arduino application to be augmented with USB hubs, keyboards, mice, joysticks, thumb drives and other devices.

We will be discussing the “for” statement and looping in a later article, but I wanted to point out that the “for(;;)” statement is a way of creating an infinite loop. When execution reaches this statement, the statements inside the curly braces (“{“ & “}”) that follow will be repeated as long as the Arduino is running.

I will discuss the “Serial Events” in a bit more detail below, but its purpose is to poll the Arduino’s serial communications hardware and perform any necessary operations. This is an important function for helping you to understand how your application is working.

Finally, the “return 0;” statement is put there as a matter of form – execution will never reach it because of the infinite loop above it. Many compilers will flag a warning or an error if a return statement is not at the end of your code, so putting it in will avoid this potential problem.

To demonstrate the operation of the “setup()” and “loop()” methods, I created the Console_Test application, which you can copy and paste into the Arduino development system:

// Console_Test - Message from "setup()" and "loop()"
//
// myke predko
void setup() {
 Serial.begin(9600);       // Initialize Serial Library
 Serial.println("Hello world!"); // Output with New Line
}

void loop() {
 Serial.println("Loop Line"); // Output with New Line
}

This application performs the following actions:

• Enables “Serial Events”, and outputs a message indicating that it is up and running
• Every time the “loop()” method is called, outputs a message

To test out this application, start up the Arduino development system and copy the following statements into “setup()”:

Serial.begin(9600);       // Initialize Serial Library
Serial.println("Hello world!"); // Output with New Line

and the following statement into “loop()”:

Serial.println("Loop Line"); // Output with New Line

Next, save the sketch as “Console_Test” and then transfer it to your Arduino using the “Upload” button shown in Figure 1. To see the application running and outputting the messages, click on the “Open Serial Monitor” button at the top right corner of Figure 1. After a few seconds, the Arduino will reset and restart running the application. You will see a display like Figure 2 for a second or so … at least until the repeating “Loop Line” messages cause the “Hello World!” message to scroll off the screen.

The “Serial.begin” statement loads in and starts (“instantiates” in Object Orientated speak) the “Serial” object, which is used for serial communications between the Arduino’s processor and the host PC. Serial communications are set at 9,600 bits per second (bps), which is actually 960 bytes per second (as ten bits are required for sending each byte of data). The “Serial.println” statements send the included string of characters to the host PC.

Serial Events are a great way to show that your application is working and to provide instructions to the Arduino during operation, but there are a couple of things to be wary of.

If you look at the “main()” code above, you will see that Serial Events only execute after a “loop()” operation. In the Arduino, Serial Events are not interrupt-driven; the receive buffer is only checked after a “loop()” and while the send buffer is being transmitted. The hardware receive registers in the ATMega, the processor used in the Arduino, can really only store one byte at a time safely, so the “loop()” code must execute in less time than it takes to receive a single byte (which is 10.4 milliseconds). This is not a major issue but it does mean that you should make your “loop()” code execute as quickly as possible – this is especially true if you work at higher speeds. Normally, I like to have communications at a minimum of 115,200 bps, which means that if I were to run at this communications speed in an Arduino, my “loop()” code must always execute in less than 87 microseconds to avoid the possibility of losing characters.

When you’re starting out, running Arduino “Serial” communications at 9,600 bits per second will probably be fast enough for most applications. As long as you don’t have long delays in your “loop()” code, you should not have any issues.

The second potential issue to watch for is the size of the “Serial” send and receive buffers, which are only 64 bytes in size. These are in software, and are independent of the hardware registers. Sending a message longer than 64 bytes will result in parts of it being “truncated” (cut off) and allowing the receive buffer to grow beyond 64 bytes will result in incoming data being lost. This may seem like an unlikely occurrence, but it can happen if all the bytes in the send message(s) in “setup()” are longer than 64 bytes, as they aren’t sent until “loop()” is first executed. It is possible to increase the size of the “Serial” send and receive buffers, but with a bit of care in your programs, there will be no need to.

While it is not important at this point in time, everything that is loaded into the Arduino is built during the transfer operation. This includes “Libraries” and any other code that you want to bring in to your Sketches. The advantage of doing this is to avoid the need for separate build processes; it also allows the code to be modified easily. You may notice that the time the Arduino development tool takes to compile your application seems unreasonably long – that is because it is going out and getting all possible library and include file code, and compiling it along with your application before building an executable with only the necessary pieces.

I realize that there is a lot of information here. It can all be boiled down to the following statements for the beginning user:

1. Application setup is put in “setup()”
2. Repeating code for the application is put in “loop()” and must execute as quickly as possible
3. “Serial” is used for providing information about the execution of a program

… but, I wanted to provide background information for individuals who may have had some programming experience on different platforms and wanted to understand how the Arduino works “behind the curtains”. For completely new users, I’m hoping that the information here will help you when you start doing your own applications and things go a bit wonky.

Example Programs:

• Console_Test

Next Article: Arduino Integer Data Types

Websites for Further Reading:

• http://arduino.cc/en/Hacking/BuildProcess “Aduino Build Process” explaining the nuts and bolts of how things go together
• https://code.google.com/p/arduino/wiki/BuildProcess A practical explanation of how the build process works
• http://arduino.cc/en/Hacking/Bootloader?from=Tutorial.Bootloader Arduino Bootloader description and information
• http://arduino.cc/en/reference/libraries Arduino Libraries
• http://www.instructables.com/id/HOW-TO-use-the-ARDUINO-SERIAL-MONITOR/ How-To use the Arduino Serial Monitor
• http://arduino.cc/en/Main/ArduinoUSBHostShield Arduino USB Host Shield

Most “getting started” Arduino tutorials start by getting to you build a flashing LED application. While the application I present here is similar, rather than just getting the Arduino’s built-in LED to flash as a “one off” application, we will be setting up the parts and tools for projects that we will implement in the future. While I provide you with the tools to create your first Arduino application, you’ll be preparing for creating your own Arduino-based robots down the line.

Before we get started, let’s talk about some basic electrical rules you will need to understand for this project. Chances are you already know them, but it never hurts to spend a minute and review:

1. Current flows from positive voltage (marked with red) to negative voltage (marked with black, and often referred to as “ground” or “Gnd”).
2. Current flows through an LED in only one direction (which causes it to light) and the negative connection is normally marked with a flat on its package.

As I go on with the article series, I will expand upon these electrical rules, but this is all you have to know for now. If you look at Figure 1 at the start of this article, you will see that positive voltage from the Arduino has a red connection, the negative (Gnd) has a black connection, and the LED has a flat side that indicates for the direction of current flow through the device.

The parts needed for this first iteration of your Arduino development station are:

• Arduino Uno (R3 or R3 SMD). When you start out, I recommend that you use the “R3” version with the long rectangular chip in a socket rather than the small, flat square chip. The socketed chip can be replaced if it is ever damaged and it is about $5.00 cheaper.
• Breadboard for quickly creating (and taking apart) your circuits.
• 5mm PTH red LED. This common LED consists of a red “bead” that lights when current passes through it. As noted above, current only flows through an LED in one direction with the negative connection marked with a flat on the side of the package.
• 100 Ohm, 1/4Watt resistor. This part reduces the current that will flow through the LED. While you can get a single 100 Ohm resistor, I recommend that you get a kit of resistors so that you have a stock of different values that can be applied in different circumstances.
• 22 gauge wire. This is for connections – it is worth purchasing a breadboard wiring kit with precut and stripped wires for the breadboard.

There are many places where these parts can be bought. At the end of the article, I have provided pointers to Sparkfun and their part numbers for the components listed above. Sparkfun is an excellent supplier and one that I feel confident recommending – but I should point out that you may want to explore local electronics shops in your area. None of the components are hard to get and chances are you can buy the components locally for about the same price without having to wait for shipping.

The “Breadboard” is a type of electronic circuit board in which wires and component leads can be pushed into (and pulled out of) to make simple circuits quickly. As can be seen in Figure 2, the middle holes are connected together vertically while the holes on the outside rows are connected horizontally. I place components in the central area and let the vertical connections connect components together while the horizontal connections are used for “power rails”. Note that I connect the ground power rails on both sides of the breadboard, but only provide power to one side; I will be discussing the reason for this in a future article.

The “5V” and “Gnd” connections from the Arduino to the Breadboard power rails are a convention that I will be using for future articles. This setup allows for fast wiring of application circuitry while allowing for high power devices to be supplied separately and not from the Arduino. Many Arduino applications use its power supply in ways that could lead to burning it out or worse. This wiring convention and reasons behind it will be discussed in future articles.

With the electronics parts together, there are a few tools that I recommend that you buy at this time:

• Plastic kit box to provide for quick clean up and transportation to other locations. This should have separate compartment for various parts and tools. I like the Stanley Sortmaster because the compartment separators can be set to allow storage of larger parts, and there is very little chance that the small parts in one compartment will find their way into another.
• 6’ A-B USB Cable.
• Needle nose pliers.
• Wire strippers. These can double as wire cutters.

All these components can be purchased at a local dollar store. The USB Cable really doesn’t belong as a “tool”, but I wanted to make the point of looking for it at a dollar store – it will be considerably cheaper at a dollar store than at a specialty electronics store.

With the parts and tools available, you can now wire the circuit as shown in Figure 1. The circuit is quite simple: an LED with 100 Ohm resistor is connected to the “5V” output of the Arduino and the Arduino’s pin “3”. When pin “3” outputs a “LOW” voltage, current flows through the LED and it lights. When pin “3” outputs a “HIGH” voltage, current no longer flows through the LED and it no longer lights. This action can be tested by connecting the Arduino to your PC using the USB power (which provides power to the circuit) followed by disconnecting the wire from the Arduino’s pin 3 (the LED’s negative (flat) side) and connecting it to the 5V rail or one of the two Gnd rails on the breadboard.

As a side point, I highly recommend designing your circuits so they can be tested easily without requiring any Arduino software. I guarantee you that it will save hours of wondering why Arduino code doesn’t seem to be working when the real problem is that there is something wrong with the electrical circuit.

With the application built, you’re now ready to create the Arduino code to test everything out. At the end of the article, I have provided the download page for the Arduino software development environment (often called “Arduino Software”) (referred to here as the “Arduino Sketchpad”) and there are specific instructions for installing the software. It can be loaded into Windows PCs, Macs or Linux systems, and just takes a few minutes to install.

The Arduino Sketchpad’s many options can be somewhat overwhelming to new users, and for that reason, I suggest that beginners focus on the five icons that are labeled in Figure 3; these are the only controls that will be required for quite a while.

When you have your Arduino Sketchpad up and running, cut and paste in the following program:

// flash - Flash LED on Pin 3
//
// myke predko


void setup() {
 pinMode(3, OUTPUT); // Make Pin 3 an Output
}


void loop() {
 digitalWrite(3, HIGH); // Pin 3 is high voltage (LED off)
 delay(250); // Wait 1/4s
 digitalWrite(3, LOW); // Pin 3 is low voltage (LED ON)
 delay(250); // Wait 1/4s
}

Then, click the “Save Sketch” icon to save the Sketch (which is what the Arduino application is called), and then click on the “Transfer to Arduino” (aka “Upload”). After a few seconds, you will get the “Done uploading” message and the LED should start flashing (if it doesn’t then use the hint above for debugging the application – chances are you have the LED orientated the wrong way or the resistor connected to the wrong power rail).

Now, you have a working Arduino development station. I know it doesn’t seem like much right now, but in the coming weeks, we’ll look at using this as a base for learning more about Arduino and creating your own robots.

Further Reading:

• http://arduino.cc/en/main/software Arduino Software Download Page
• http://forum.arduino.cc/index.php?board=2.0 Arduino “Installation & Troubleshoot” Forum
• http://www.ladyada.net/learn/arduino/lesson1.html First project tutorial
• http://electronicsclub.info/leds.htm Introduction to Light Emitting Diodes (LEDs)
• http://www.electronics-tutorials.ws/resistor/res_9.html Resistor Tutorial and Summary

Parts:

• https://www.sparkfun.com/ for parts:
  • https://www.sparkfun.com/products/11021 Arduino Uno – R3
  • https://www.sparkfun.com/products/9590 LED – Basic Red 5mm
  • https://www.sparkfun.com/products/10969 1/4W Resistor Kit
  • https://www.sparkfun.com/products/9567 Breadboard – Translucent
  • https://www.sparkfun.com/products/124 Jumper Wire Kit

Previous Article: Arduino for Makers #0: Introduction to the series
Next Article: Arduino Programing deconstructed

Arduinio Pinouts

In this new tutorial series, robotics educator and author Myke Predko will introduce you to the basics of Arduino with simple projects that can be created in just a few minutes with inexpensive and easy-to-obtain parts. Along the way, you will learn how to get the most out of electronics, how to create software that is easy to understand and debug, and you will develop the toolset you need to determine whether or not the Arduino is the right choice for your own project, and if so, how to implement it efficiently.

The series is for anyone interested in Arduino, from high school students to professional engineers. In this introduction, Myke gives an overview of the benefits – and limitations – of using Arduino for your project. Look for new tutorials every 2-3 weeks. 

People who know me know that I have a love-hate relationship with Arduino.

The Arduino concept is brilliant: it’s a very low-cost open source and open hardware platform that is quick and easy to connect to. Arduino is very flexible: software applications use “C” syntax for commonality and are easy to enhance with “libraries” for specific interfaces and Input/Output (IO) devices. The development tools are available for just about every system out there and they do provide extension paths for the development tools. There are a number of different Arduino devices, each with different features that optimize them for different applications as well as a plethora of “shields” that allow users to hook up various devices quickly and (for the most part) easily.

These core features and philosophies have resulted in Arduino becoming the de facto standard for intelligent projects – there are so many well-documented Arduino projects out there that if you’re not comfortable with programming, chances are you will be able to find a project that uses the exact same (or at least very similar and easily changeable) devices as the ones you would like to use. Nobody could ever fault you for starting your project with an Arduino.

On the other side of the equation, there are some things I dislike about Arduino, however: its 8-bit processor, its schizophrenic design tools, its inability to do meaningful application debug, and the expectation on the part of many new developers that using Arduino means they are 80% of the way towards having a product ready for market.

To expand on these issues:

1. In 2015, nothing should be controlled by an 8-bit processor. If you take a quick look at Digi-Key, you will find 32-bit Cortex M series processors from a variety of manufacturers that have more memory and peripherals while running a considerably faster speeds for the same cost (or less) than the ATmega used in the Arduino. I’m pointing out the Cortex processors (that, I should point out, are being used in the Arduino Duo board) because code can be passed between devices, giving a lot more freedom when choosing devices for a given application (which would extend the “open source”, “open hardware” concept even further).
2. The standard Arduino development tool was designed for both the new user as well as the experienced one, and I don’t think it is well suited for anybody. I believe that a new developer should have as simple a development tool as possible, with only the required controls in front of them. As an experienced programmer, I revel in using Eclipsed-based development tools where I have 500+ options at my disposal.
3. Going with my comment regarding the widespread availability of 32-bit processors, I also feel that the lack of a source code level debugger with stepping and breakpoints is a serious deficiency in the Arduino. These are features that I have been working with for more than thirty years, and I consider this to be a major oversight. In this tutorial series, I will share techniques that will help you understand and debug your Arduino applications.
4. Just about every Arduino presentation I have ever seen has stated that one of its advantages is that it can be used in commercial products. To test out this assertion, I googled “Arduino used in commercial products,” and much to my surprise, I discovered that almost all the top ranked websites focused on why Arduino isn’t used in commercial products.
   
   There is one notable exception to Arduino’s not being used in commercial products “as is” – and that is 3D printers. There are many shields available that make the interfacing to the different components of a 3D printer (the extruder, filament feed and movement motors) very easy, and it is the mechanical components where the primary differentiators lie (most use the same types of electrical components and standard, open source software). Along with the large (and generally boxy) shape of 3D printers, it doesn’t make sense to use anything else to control them.

There are currently 24 Arduino boards to choose from, each with a different processor running at a different speed, having varying memory and unique input/output (IO) pin configurations. The range is quite remarkable, with many boards providing the basic socket connections of the original Arduino “Uno” layout shown in the image at the start of this article. Other Arduino boards provide different built-in IO connections or physical layout (the LilyPad Arduino is designed to be stitched into clothing). In the list of reference websites below, I’ve included the Arduino page listing all the different types of “standard” Arduinos that are available.

Arduino shields

One aspect that makes Arduino very exciting for me is the many different “shields” that are available for it. An Arduino “shield” is simply a PCB that is designed to plug into the Arduino Uno sockets and access specific pins for specific purposes. The different shields enhance the IO capabilities of the Arduino, and make creating an application a lot easier and faster. Unfortunately there is a downside: the need to allocate the IO pins used in order to ensure that multiple shields don’t use the same IO pins for the same functions. I’ll discuss this issue more in future posts.

I’ve numbered this first tutorial #0 for a reason: I want to set the stage (and some boundaries) for this series and share my own personal philosophies that will guide the materials and projects we will cover together. The Arduino is a great product with a large mass of resources and people behind it, but I want to get you to think about the Arduino as a part of your introduction to programming, electronics and robotics, so that you can understand its limitations and, hopefully, some day look beyond it create your own “big idea”.

One thing that has always really annoyed me are projects that require specialized parts that are limited in availability (usually because the author has a bunch of them he wants to sell). All the projects here will use standard parts available from reputable distributors. While I know I’ll be doing some junkbox applications, I’ll make sure that the descriptions of the parts that I use will be sufficient that you will be able to go out and find your own sources for the components and assemblies that I reference.

In the end, however, my goal is to have fun and to get you to try things with Arduino that haven’t been done before. And since a big part of having fun is to be able to do things quickly, the projects that we will undertake together will take just a few minutes to wire and program.

I hope that you will share your suggestions for tutorials and projects in comments section below. Don’t be afraid of being too outlandish; while I probably won’t go do a tutorial on building a remote trigger pull on a 12-gauge shotgun as part of a home-grown burglar deterrent/elimination system, your crazy idea could spur me onto something interesting. Let’s get some of those ideas going and see where they lead.

Next Article: Setting up your own Arduino development station.

Resources & Further Reading:

• https://www.youtube.com/watch?v=UoBUXOOdLXY Massimo Banzi: How Arduino is open-sourcing imagination
• http://arduino.cc/en/Products.Compare Different Arduino Boards
• http://shieldlist.org/ Arduino Shield List
• http://www.instructables.com/id/Intro-to-Arduino/
• https://learn.sparkfun.com/tutorials/what-is-an-arduino

Myke welcomes feedback, and you can email him at myke.predko@mimetics.ca or leave a comment below.