For your convenience Apress has placed some of the front
matter material after the index. Please use the Bookmarks
v
Contents at a Glance
About the Author ...
xix
About the Technical Reviewers ...
xxi
Acknowledgments ...
xxiii
Introduction ...
xxv
Chapter 1: Getting Started
■
...
1
Chapter 2: Light ‘Em Up
■
...
21
Chapter 3: LED Effects
■
...
49
Chapter 4: Simple Sounders and Sensors
■
...
79
Chapter 5: Driving a DC Motor
■
...
97
Chapter 6: Binary Counters and Shift Register I/O
■
...
111
Chapter 7: LED Displays
■
...
127
Chapter 8: Liquid Crystal Displays
■
...
165
Chapter 9: Servos
■
...
183
Chapter 10: Steppers and Robots
■
...
199
Chapter 11: Pressure Sensors
■
...
223
Chapter 12: Touch Screens
■
...
251
Chapter 13: Temperature Sensors
■
...
271
Chapter 15: Reading and Writing to an SD Card
■
...
305
Chapter 16: Making an RFID Reader
■
...
325
Chapter 17: Communicating over Ethernet
■
...
341
xxv
Introduction
I first discovered the Arduino in 2008 when I was looking for ways to connect temperature sensors to my PC so I could make a cloud detector. I wanted to try out a cloud detection concept I’d read about on a weather forum, and as it was experimental, I didn’t want to spend a lot of money on it in case it failed. There were many solutions on the market, but the Arduino appealed to me the most. Not only did it seem to be an easy and cheap way to connect the sensors I required, but it could be used for other cool things. Thousands of projects in blogs, video sites, and forums showed the amazing things people were doing with their Arduinos. There seemed to be a huge sense of community with everyone trying to help one another.
It was obvious that I could have a lot of fun with an Arduino. However, I didn’t want to be trawling through websites for information. I wanted to buy a book on the subject, something I could hold in my hand and read on the train to work. After looking around, I found one book. Unfortunately, it was very basic and out of date. Worse, it didn’t give me anything practical to do with the Arduino, and I didn’t warm to the teaching style, either. What I wanted was a hands-on book that taught me both programming and electronics as I built things instead of having to wade through pages of theory first. Such a book just didn’t exist at the time.
Then I started Earthshine Electronics to sell kits based on the Arduino. To go with the kit, I produced a small tutorial booklet to get people started. This little booklet ended up being extremely popular, and I got hundreds of queries from people asking when I would be adding more projects or if I sold a printed version. In fact, I had already thought that it would be great to produce a comprehensive beginner’s book, crammed with projects and written in an easy-to-follow style. That is how this book came about. This book has proven so successful at teaching people about the Arduino that it has since been updated to this second edition with improvements and updated sections relevant to the changes in the Arduino world since I began.
I have written this book with the presumption that you have never done either computer programming or electronics before. I also presume you’re not interested in reading lots of theory before you actually get down to making something with your Arduino. Hence, right from the start of the book, you will be diving right into making a simple project. From there, you will work through a total of 50 projects until you become confident and proficient at Arduino development. I believe that the best way to learn anything is by learning as you go and getting your hands dirty.
The book works like this: the first project introduces basic concepts about programming the Arduino and also about electronics. The next project builds on that knowledge to introduce a little bit more. Each project after that builds on the previous projects. By the time you have finished all 50 projects, you will be confident and proficient at making your own projects. You’ll be able to adapt your new skills and knowledge to connect just about anything to your Arduino and make great projects for fun or to make your life easier.
Each project starts off with a list of required parts. I have chosen common parts that are easy to source. I also provide a circuit diagram showing exactly how to connect the Arduino and parts together using jumper wires and a breadboard. To create the parts images and breadboard diagrams for the book, I used the excellent open-source program Fritzing. The program allows designers to document their prototypes and then go on to create PCB layouts for manufacture. It is an excellent program and a brilliant way of demonstrating a breadboard circuit to others. Pop on over to http://fritzing.org and check it out.
The code will then be explained to you step by step so you understand exactly what each section of the code does. By dissecting the circuit and the code, you will understand how the whole project works and can then apply the skills and knowledge to later projects and then to your own projects in the future.
The style of teaching in this book is very easy to follow. Even if you have absolutely no experience of either programming or electronics, you will be able to follow along easily and understand the concepts as you go. More importantly, you will have fun. The Arduino is a great and fun open source product. With the help of this book, you’ll discover just how easy it is to get involved in physical computing to make your own devices that interact with their environment.
—Mike McRoberts
Downloading the Code
The code for the examples shown in this book is available on the Apress web site, www.apress.com. A link can be found on the book’s information page under the Source Code/Downloads tab. This tab is located underneath the Related Titles section of the page.
Contacting the Author
1
Getting Started
Since the Arduino Project started in 2005, over 500,000 boards have been sold worldwide to date. The number of unofficial clone boards sold no doubt outweighs the number of official boards, and it’s likely that over a million Arduino boards or its variants are out in the wild. Its popularity is ever increasing as more and more people realize the amazing potential of this incredible open source project and its ability to create cool projects quickly and easily with a relatively shallow learning curve.
The biggest advantage of the Arduino over other microcontroller development platforms is the ease of use in which non-“techie” people can pick up the basics and create their own projects in a relatively short amount of time. Artists in particular seem to find it the ideal way to create interactive works of art quickly and without specialist knowledge of electronics. There is a huge community of people using Arduinos and sharing their code and circuit diagrams for others to copy and modify. Most of this community is also very willing to help others and to provide guidance and the Arduino Forum is the place to go if you want answers quickly.
However, despite the huge amount of information available on the Internet for beginners, most of this information is spread across various sources, making it tricky for beginners to obtain the information they want. This is where this book fits in. Within the pages you are about to read are 50 projects that are all designed to take you step by step through the world of electronics and programming your Arduino in an easy to follow manner. I believe that the best way to learn anything is to jump in and just do it. That is why this book will not bore you with pages and pages of theory before you start to use your Arduino. I know what it is like when you first get an Arduino, or any new gadget: you want to plug it in, connect an LED, and get it flashing right away, not read through pages of manuals first. This author understands that excitement to get going and that is why we will dive right into connecting things to our Arduino, uploading code, and getting started right away. This is, I believe, the best way to learn a subject and especially a subject like physical computing, which is what the Arduino is all about.
How to Use This Book
The book starts with an introduction to the Arduino, how to set up the hardware, install the software, upload your first sketch, and ensure that your Arduino and the software are working correctly. We then explain the Arduino IDE (integrated development environment) and how to use it before we dive right into some projects, progressing from very basic stuff through to advanced topics. Each project will start with a description of how to set up the hardware and what code is needed to get it working. We will then separately describe the code and the hardware and explain in some detail how it works. Everything will be explained in clear and easy-to-follow steps. The book contains a lot of diagrams and photographs to make it as easy as possible to check that you are following along with the project correctly.
What You Will Need
In order to follow along with the projects in this book, you will need various components. To carry out all of the projects will require purchasing a lot of parts first. This could be expensive, so I suggest that you start by purchasing the components for the projects in the first few chapters and obtain the parts listed at the start of the project pages. As you progress through the book, you can obtain the parts needed for subsequent projects.
There are a handful of other items you will need or may find useful. Of course, you will need to obtain an Arduino board or one of the many clone boards on the market such as the Freeduino, Seeeduino (yes, there really are three eees), Boarduino, Sanguino, Roboduino or any of the other “duino” variants. These are all fully compatible with the Arduino IDE, Arduino Shields and everything else that you can use with an official Arduino Board. Remember that the Arduino is an Open Source project; therefore anyone is free to make a clone or other variant of the Arduino. However, if you wish to support the development team of the original Arduino board, get an official board from one of the recognized distributors. For the projects in this book, we will be using an Arduino Uno, although any of the available Arduino boards will work just as well.
You will need access to the Internet to download the Arduino IDE, the software used to write your Arduino code and upload it to the board, and also to download the Code Samples within this book (if you don’t want to type them out yourself ), as well as any code libraries that may be necessary to get your project working.
You will also need a well-lit table or other flat surface to lay out your components; this will need to be next to your desktop or laptop PC to enable you to upload the code to the Arduino. Remember that you are working with electricity (although it is low voltage DC), and therefore metal tables or surfaces will need to be covered in a non-conductive material such as a tablecloth or paper before laying out your materials. Also of some benefit, although not essential, may be a pair of wire cutters, a pair of long-nosed pliers, and a wire stripper. A notepad and pen will also come in handy for drawing out rough schematics and working out concepts and designs.
Finally, the most important thing you will need is enthusiasm and a willingness to learn. The Arduino is designed as a simple and cheap way to get involved in microcontroller electronics and nothing is too hard to learn if you are willing to give it a go. This book will help you on that journey, and introduce you to this exciting and creative hobby.
What Exactly Is an Arduino?
Wikipedia states “Arduino is a single-board microcontroller designed to make the process of using electronics in multidisciplinary projects more accessible. The hardware consists of a simple open-source hardware board designed around an 8-bit Atmel AVRmicrocontroller, though a new model has been designed around a 32-bit Atmel ARM. The software consists of a standard programming language compiler and a boot loader that executes on the microcontroller.”
3
To put the above definition in layman’s terms, an Arduino is a tiny computer that you can program to process inputs and outputs between the device and external components you connect to it. The Arduino is what is known as a physical or embedded computing platform. For example, a simple use of an Arduino would be to turn a light on for a set period of time, let’s say for 30 seconds, after a button has been pressed. In this example, the Arduino would have a lamp connected to it as well as a button. The Arduino would sit patiently waiting for the button to be pressed. When you press the button, the Arduino would turn the lamp on and start counting. Once it had counted for 30 seconds, it would turn the lamp off, and then continue to wait for another button press. You could use this setup to control a lamp in a cupboard, for example.You could extend this concept so that the device detects when the cupboard door has been opened or some other event has occurred, and automatically turns the lamp on, turning it off after a set period. You could go even further and connect a passive infrared (PIR) sensor to detect movement and to turn the lamp on when it has been triggered. These are some simple examples of how you could use an Arduino.
The Arduino can be used to develop stand-alone interactive objects or it can be connected to a computer, a network, or even the Internet to retrieve and send data to and from the Arduino, and then act on that data. For example, it could be used to send a set of data received from sensors to a website to be displayed in the form of a graph.
The Arduino can be connected to LEDs, dot-matrix displays (see Figure 1-2), buttons, switches, motors, temperature sensors, pressure sensors, distance sensors, GPS receivers, Ethernet or WiFi modules, or just about anything that outputs data or can be controlled. A look around the Internet will bring up a wealth of projects in which an Arduino has been used to read data from or control an amazing array of devices.
Figure 1-2. A dot-matrix display controlled by an Arduino (image courtesy of Bruno Soares)
The Arduino board is made up of an Atmel AVR microprocessor, a crystal or oscillator (a crude clock that sends time pulses at a specified frequency to enable it to operate at the correct speed) and a 5V voltage regulator. (Some Arduinos may use a switching regulator, and some, like the Due, are not 5 volt). Depending on what type of Arduino you have, it may also have a USB socket to enable it to be connected to a PC or Mac to upload or retrieve data. The board exposes the microcontroller’s I/O (input/output) pins to enable you to connect those pins to other circuits or to sensors, etc.
The Arduino hardware and software are both Open Source, which means that the code, schematics, design, etc., are all open for anyone to take freely and do with what they like. Hence, there are many clone boards and other Arduino-based boards available to purchase or to make from a schematic. Indeed, there is nothing stopping you from purchasing the appropriate components and making your own Arduino on a breadboard or on your own homemade PCB (printed circuit board). The only caveat that the Arduino team makes to this is that you cannot use the word Arduino, as this is reserved for the official board. Hence, the clone boards all have names such as Freeduino, Roboduino, etc.
The Arduino can also be extended with the use of “shields,” which are circuit boards containing other devices (for example, GPS receivers, LCD displays, Ethernet modules, etc.) that you can simply connect to the top of your Arduino to get extra functionality. Shields also extend the pins (the places on your Arduino where you can output or input data) to the top of their own circuit board, so you still have access to all of them. You don’t have to use a shield if you don’t want to, as you can make the exact same circuitry using a breadboard, some Stripboard or Veroboard (boards made up of strips of copper in a grid for home-soldered projects), or by making your own PCB. Most of the projects in this book are made using circuits on a breadboard.
As the designs are open source, a clone board, such as the Freeduino, can be 100 percent compatible with the Arduino and therefore any software, hardware, shields, etc. Some clones are compatible in most respects but may have intentional differences to support special features. Also, the Due (which is genuine Arduino) does have some issues such as its 3 volt operation, which may not work with all shields.
There are many different variants of the Arduino available. The most common one is Uno, released in 2010 (currently on Revision 3) and this is the board you will most likely see being used in the vast majority of Arduino projects across the Internet. You can also get the Due Leonardo, Duemilanove, Mega 2560, Mega ADK, Fio, Arduino Ethernet, Mini, Nano, Lilypad, and Bluetooth Arduinos. The latest additions to the product line are the Arduino Leonardo and the Arduino Due, which is the Arduino team’s first incursion into using ARM processors instead of AVR architecture processors The Due has a 32-bit processor instead of the usual 8-bit processor in the other Arduino variants, runs at 84MHz, and has 512KB of flash memory.
Probably the most versatile Arduino, and hence the reason it is so popular, is the Uno (prior to the Uno, the Duemilanove was the most popular). This is because they use a standard 28 pin chip attached to an IC (integrated circuit) socket. The beauty of this system is that if you make something neat with an Arduino and then want to turn it into something permanent, instead of using a relatively expensive Arduino board, you can simply use the Arduino to develop your device and program the chip, then pop the chip out of the board and place it into your own circuit board in your custom device. You would then have made a custom-embedded device, which is really cool. Then for a couple of quid or bucks, you can replace the AVR chip in your Arduino with a new one. The chip must be pre-programmed with the Arduino Bootloader (software programmed onto the chip to enable it to be used with the Arduino IDE), but you can either purchase an AVR Programmer to burn the bootloader yourself or you can buy a chip ready programmed, and most of the Arduino parts suppliers will provide these.
The newer Arduino Uno has the advantage over the previous Arduino, the Duemilanove, in that it has a programmable USB chip on board which enables you to flash the chip in such a way that when you plug the device into your PC it will show up as any USB device you like, such as a keyboard, mouse, or joystick. This enables you to use the Arduino as an interface for creating your own USB devices. This is, however, an advanced feature and not for the faint hearted.
5
This book will give you the necessary skills needed to make a start in this exciting and creative hobby. So now that you know what an Arduino is, let’s get one hooked up to our computer and start using it.Setting Up Your Arduino
This section will explain how to set up your Arduino and the IDE for the first time. The instructions for both Windows and Macs are given. If you use Linux, then refer to the Getting Started instructions on the Arduino website at
http://playground.arduino.cc/learning/linux. I will also presume you are using an Arduino Uno (see Figure 1-4), Duemilanove, Nano, Diecimila or Mega 2560 (or their equivalent clone) and are installing on either Windows 7 or a recent version of OSX (Lion or Mountain Lion). If you have a different type of board, then refer to the corresponding page in the Getting Started guide of the Arduino website.
Figure 1-3. Anthros art installation by Richard V. Gilbank controlled using an Arduino
You will also need a USB cable (A to B plug type) which is the same kind of cable used for most modern USB printers. If you have an Arduino Nano, you will need a USB A to Mini-B cable instead.
Next, you need to download the Arduino IDE. This is the software you will use to write your programs (or sketches) and upload them to your board. For the latest IDE go to the Arduino download page at
http://arduino.cc/en/Main/Software and obtain appropriate the version for your operating system.
If you have a Mac, once the Zip file has downloaded, unzip it and then you will see the Arduino icon. Drag it across to the Applications folder and drop it in there to install the program. You simply double-click the icon to start it. For Windows, download the ZIP file and, once complete, unzip it. Then put the unzipped folder in a place that suits you, keeping the directory structure in place.
Now you need to connect your Arduino board before installing the drivers and software. Connect the USB cable to the Arduino and plug the other end into a USB socket on your computer. You will see the green Power LED (marked PWR) light up on your board to show you it has power. If you are on a Mac, then there are no drivers to install. If you are on Windows, then it will now attempt to install the drivers for the Arduino. This auto attempt will fail and you will get a message that the “Device driver software was not successfully installed” (Figure 1-5); do not worry about this.
Figure 1-5. The automatic attempt by Windows to install the drivers will fail. This is normal
7
Right click on the Arduino Uno icon in the list and choose “Update Driver Software” (Figure 1-7).Figure 1-6. The Windows Device Manager
Figure 1-8. Click on “Browse my computer for driver software” Now choose “Browse my computer for driver software”.
Next, browse to the driver folder of the Arduino installation, and then click the Next button. Windows will now finish the driver installation. If you get a message that says “Windows can’t verify the publisher of this driver software” then click the “Install this driver software anyway.” If you have a Mac, then there are no drivers to install.
Now that the drivers are installed, you are ready to open up the Arduino IDE. For Windows, double-click the
9
Next, open up an example sketch to test out the IDE and the Arduino. Click File, then Examples, then 01.Basics, and finally, Blink (see Figure 1-10).This will load the Blink example sketch into the IDE and will look something like Figure 1-11.
11
Next, you will need to select your board from the list (see Figure 1-12) in Tools➤Board. For an Arduino Uno, select this from the top of the list. If you have an older Arduino Duemilanove or clone with an Atmega328 chip, you will need to select Arduino Duemilanove or Nano w/ Atmega328. If you have an even older board with an Atmega168 chip, select Arduino Diecimila, Duemilanove, or Nano w/ ATmega168, or you may even have aLeonardo, Mega or a DUE. Choose whichever board matches yours.
Select the serial device of the Arduino board from Tools➤Serial Port (see Figure 1-13). If you are not sure what your port is, disconnect the Arduino and check the ports available, then reconnect the Arduino and see which port has now appeared (you may need to close and reopen the menu to get it to show).
13
Upload Your First Sketch
Now that you have installed the drivers and the IDE and have the correct board and ports selected, you can upload an example Blink sketch to the Arduino to test everything is working properly before moving on to the first project. Once you have loaded the Blink sketch into the Arduino IDE, you can upload it to the Arduino by simply clicking the Upload button (the second button from the left that is a right-facing arrow) and look at your Arduino (if you have an Arduino Mini, NG, or other board, you may need to press the reset button on the board prior to pressing the Upload button). The IDE will say “Compiling sketch . . .”, which will then change to “Uploading . . . .” Next, the RX and TX lights should start to flash to show that data is being transmitted from your computer to the board. Once the sketch has successfully uploaded, the words “Done uploading” will appear in the IDE status bar and the RX and TX lights will stop flashing.
After a few seconds, you should see the Pin 13 LED (the tiny LED above the TX and RX LEDs) start to flash on and off at one second intervals. If it does, then you have just successfully connected your Arduino, installed the drivers and software, and uploaded an example sketch. The Blink sketch is a very simple sketch that blinks the LED 13, which is a tiny orange LED soldered to the board and also connected to digital pin 13 from the microcontroller (see Figure 1-14).
Figure 1-13. Select the port
Figure 1-14. LED 13 blinking
Figure 1-15. What the IDE looks like when the application opens
The Arduino IDE
The Arduino IDE (Integrated Development Environment) is what you will use to write the code for your Arduino, verify it, and upload it to your board. The current IDE version 1.x was released in November 2011. Previously, the Beta version numbers ran from 0001 to 0023 and version 1.0 was the first release candidate of the software. In version 1.0, the file extensions for the sketches changed from .pde to .ino to avoid conflicts with the Processing software (Processing is a project that the original IDE was based on). There were also some major changes to the Arduino language. If you want to port older Arduino code to the new IDE, you should read up on the Arduino website in the reference section about how the commands work if you get any errors with the older code.
When you open up the Arduino IDE, it will look very similar to the Windows version in the image below
15
The IDE is split into four parts: the File Menu across the top of the program (or at the top of your screen in OSX), the Toolbar below this, the code or Sketch Window in the center, and the message window in the bottom. The Toolbar consists of six buttons, and underneath the Toolbar is a tab, or set of tabs, with the filename of the sketch within the tab. There is also one further button on the far right hand side which brings up the Serial Monitor window.Along the top is the file menu with drop down menus headed under Arduino, File, Edit, Sketch, Tools, and
Help. The buttons in the Toolbar (see Figure 1-16) provide convenient access to the most commonly used functions within this file menu.
Verify Upload New Open Save Serial Monitor
Figure 1-16. The Toolbar
The Toolbar buttons are listed in Figure 1-16. The functions of each of the buttons are as
follows:-Table 1-1. The Toolbar Button Functions
Verify Checks the code for errors
Upload Uploads the current sketch to the Arduino
New Creates a new blank sketch
Open Shows a list of sketches in your Sketchbook to open
Save Saves the current Sketch to your Sketchbook
Serial Monitor Displays serial data being sent from the Arduino
The Verify button is used to check that your code is correct and error-free before you upload it to your Arduino board.
The Upload button will upload the code within the current sketch window to your Arduino. You need to make sure that you have the correct board and port selected (in the Tools menu) before uploading. It is essential that you save your sketch before you upload it to your board in case a strange error causes your system to hang or the IDE to crash. It is also advisable to verify the code before you upload to ensure there are no errors that need to be debugged first.
The New button will create a completely new and blank sketch ready for you to enter your code into. The IDE will ask you to enter a name and a location for your sketch (try to use the default location if possible) and will then give you a blank sketch ready to be coded. The tab at the top of the sketch will now contain the name you have given to your new sketch.
The Open button will present you with a list of sketches stored within your sketchbook as well as a list of example sketches that you can try out with various peripherals once connected. The example sketches are invaluable for beginners to use as a foundation for your own sketch. Open the appropriate sketch for the device you are connecting and then modify the code to your own needs.
On the bottom right hand side you can select the Baud Rate that the serial data is to be sent to/from the Arduino. The Baud Rate is the rate, per second, that state changes or bits (data) are sent to/from the board. The default setting is 9600 baud, which means that if you were to send a text novel over the serial communications line (in this case your USB cable), then 1200 letters, or symbols, of the novel, would be sent per second (9600 bits/8 bits per character = 1200 bytes or characters – bits and bytes will be explained later on).
At the top is a blank text box for you to enter text to send back to the Arduino and a Send button to send the text within that field. Note that the Serial Monitor will not receive any serial data unless you have set up the code inside your sketch to send serial data from the Arduino. Similarly, the Arduino will not receive any data sent unless you have coded it to do so.
There is a tick box on the bottom left where you can choose if you want the data in the serial monitor window to autoscroll or not.
The box to the left of the baud rate menu will affect the data sent from the serial monitor back to the Arduino. The default setting is “no line ending,” meaning when you enter data into the text box on the serial monitor and press “send,” the data will be sent as is. If you click the drop down menu, there are three other options for Newline, Carriage return. and Both NL+ Cr. By selecting one of these, the serial monitor will append an ascii code for a Newline, Carriage Return, or both on the end of any data entered into the serial monitor window when you click send. Bear this in mind when processing data sent from the serial monitor back to the Arduino.
Finally, the main area is where your serial data will be displayed. In the image above, the Arduino is running the ASCIITable sketch that can be found in the Communications examples. This program outputs ASCII characters, from the Arduino via serial (the USB cable) to the PC where the Serial Monitor then displays them.
Once you are proficient at communicating via serial to and from the Arduino, you can use other programs such as Processing, Flash, MaxMSP, etc. to communicate between the Arduino and your PC.
We will make use of the Serial Monitor later on in our projects when we read data from sensors and get the Arduino to send that data to the Serial Monitor, in human readable form for us to see.
The Message Window at the bottom of the IDE is where you will see error messages that the IDE will display to you when trying to connect to your board, upload code, or verify code.
Figure 1-17. The Serial Monitor in use
17
Below the Message Window at the bottom left you will see a number. This is the current line that the cursor, within the code window, is at. If you have code in your window and you move down the lines of code (using the ↓ key on your keyboard) you will see the number increase as you move down the lines of code. This is useful for finding bugs highlighted by error messages.Across the top of the IDE window (or across the top of your screen if you are using a Mac), you will see the various menus that you can click on to access more menu items (see Figure 1-18).
Figure 1-18. The IDE menus (Top: OSX, Bottom: Windows)
The first menu (on OSX) is the Arduino menu (see Figure 1-19). Within this is the About Arduino option, which when pressed will show you the current version number, a list of the people involved in making this amazing device, and some further information. On Windows PCs, the About Arduino item is on the Help menu.
Figure 1-19. The About Arduino menu
Near the bottom is the Preferences option. This will bring up the Preferences window where you can change various IDE options, such as where your default Sketchbook is stored, etc. Finally, there is the Quit option, which will quit the program.
Next is the Edit menu (see Figure 1-21) Here, you get options to enable you to cut, copy and paste sections of code. Select all of your code as well as find certain words or phrases within the code. Comment your code (adding comments to explain how it works), as well as increasing or decreasing indents. Also included are the useful Undo and Redo options, which come in handy when you make a mistake.
Figure 1-20. The File Menu
19
Our next menu is the Sketch menu (see Figure 1-22) which gives us access to the Verify/Compile functions and some other useful functions you will use later on. These include the Import Library option, which when clicked will bring up a list of the available libraries, stored within your libraries folder.Figure 1-22. The Sketch Menu
A library is a collection of code that you can include in your sketch to enhance the functionality of your project. It is a way of preventing you from reinventing the wheel by reusing code already made by someone else for various pieces of common hardware you may encounter whilst using the Arduino.
For example, one of the libraries you will find is Stepper, which is a set of functions you can use within your code to control a stepper motor. Somebody else has kindly already created all of the necessary functions necessary to control a stepper motor, and by including the Stepper library into our sketch, we can use those functions to control the motor as we wish. By storing commonly used code in a library, you can reuse that code over and over in different projects and also hide the complicated parts of the code from the user. We will go into greater detail concerning the use of libraries later on.
Finally, within the Sketch menu is the Show Sketch Folder option, which will open up the folder were your sketch is stored. Also, there is the Add File option, which will enable you to add another source file to your sketch. This functionality allows you to split larger sketches into smaller files and then add them to the main Sketch.
The next menu in the IDE is the Tools menu (see Figure 1-23). Within this are the options to select the board and serial port we are using, as we did when setting up the Arduino for the first time. Also we have the Auto Format function that formats your code to make it look nicer.
The Copy for Forum option will copy the code within the Sketch window, but in a format that when pasted into the Arduino forum (or most other Forums for that matter) will show up the same as it is in the IDE, along with syntax coloring, etc.
The Archive Sketch option will enable you to compress your sketch into a ZIP file and will ask you where you want to store it. The Fix Encoding & Reload option is to convert code created in older versions of the IDE into the newer format.
The programmer button will enable you to choose a programmer, in case you are using an external device to upload code to your Arduino or wish to burn code to a chip in your own project. We will simply be using the USB cable we purchased with our Arduino.
Finally, the Burn Bootloader option can be used to burn the Arduino Bootloader (piece of code on the chip to make it compatible with the Arduino IDE) to the chip. This option can only be used if you have an AVR programmer and have replaced the chip in your Arduino or have bought blank chips to use in your own embedded project. Unless you plan on burning lots of chips, it is usually cheaper and easier to just buy an ATmega chip (see Figure 1-24) with the Arduino Bootloader already pre-programmed. Many online stores stock pre-programmed chips and these can be purchased pretty cheaply. The chip used in the Arduino Uno is an Atmel ATmega328.
Figure 1-24. An Atmel ATmega chip. The heart of your Arduino. (image courtesy of Earthshine Electronics)
The final menu is the Help menu were you can find help menus for finding out more information about the IDE or links to the reference pages of the Arduino website and other useful pages.
The Arduino IDE is pretty basic and you will learn how to use it quickly and easily as we work through the projects. As you become more proficient at using an Arduino and programming in C (the programming language we use to code on the Arduino) you may find the Arduino IDE is too basic and wish to use something with better functionality. Indeed, many expert Arduino programmers do not use the IDE at all and instead use professional IDE programs (some of which are free) such as Eclipse, ArduIDE, GNU/Emacs, AVR-GCC, AVR Studio, and even Apple’s XCode.
So, now that you have your Arduino software installed, the board connected and working, and you have a basic understanding of how to use the IDE, let’s jump right in with Project 1 — LED Flasher.
Summary
In this chapter you have learnt what an Arduino is, a little bit about the different Arduino variants, what you can do with it, and what the basic components are that make up the Arduino board. Then you learnt how to install and set up the software and drivers for the Arduino, how to select the correct serial port, and upload a test sketch to your Arduino to make sure everything is working correctly.
21
Light ‘Em Up
You are now going to work your way through the first four projects. These projects all use LED lights in various ways. You will learn about controlling outputs from the Arduino as well as simple inputs such as button presses. On the hardware side, you will learn about LEDs, buttons, and resistors, including pull-up and pull-down resistors, which are important in ensuring that input devices are read correctly. Along the way, you will pick up the concepts of programming in the Arduino language. Let’s start with a “Hello World” project that makes your Arduino flash an external LED.
Project 1 — LED Flasher
For the very first project, we are going to repeat the LED blink sketch that we used during our testing stage in Chapter 1. Except this time, we are going to connect an LED to one of the digital pins rather than use LED13 which is soldered to the board. We will also learn exactly how the hardware and the software for this project works as we go, learning a bit about electronics and coding in the Arduino language (which is a variant of C) at the same time.
Table 2-1 below shows the parts required for our very first project.
Table 2-1. Parts Required for Project 1
Breadboard
5mm LED
100W Resistor*
Jumper Wires
*This value may differ depending on what LED you use. The text will explain how to work it out.
Parts Required
The LED should be a 5mm one of any color. You will need to know the current and voltage (sometimes called forward current and forward voltage) of the LED as this will enable you to calculate the resistor value needed. We will work out this value later in the project.
The jumper wires can either be commercially available jumper wires (usually with molded ends to make insertion into the breadboard easier) or you can make your own by cutting short strips of stiff single core wire and stripping away about 6mm from the end.
Connect It Up
First, make sure your Arduino is powered off by unplugging it from the USB cable. Next, take your breadboard, LED, resistor, and wires, and connect everything up as in Figure 2-1.
Figure 2-1. The circuit for Project 1 — LED Flasher
It doesn’t matter if you use different colored wires or use different holes on the breadboard as long as the components and wires are connected in the same order as the picture. Be careful when inserting components into the breadboard. Your breadboard may be brand new and the grips in the holes will be stiff to begin with. Failure to insert components carefully could result in damage.
Make sure that your LED is connected the right way. Make sure the anode (positive) leg of the LED (usually the leg with the longer lead) is connected to digital pin 10. Make sure the anode of the LED (usually the lead with the longer leg) is connected to the resistor, and the cathode (usually the short leg) to ground. LEDs only light up when the anode is at a more positive voltage than the cathode. If you connect it backwards, it won’t light, but won’t damage the LED either in this circuit.
23
Enter the Code
Open up your Arduino IDE and type in the code from listing 2-1:
Listing 2-1. Code for Project 1 // Project 1 - LED Flasher int ledPin = 10;
Now press the Verify button at the top of the IDE to make sure there are no errors in your code. If this is successful, you can now click the Upload button to upload the code to your Arduino. If you have done everything correctly, you should now see the LED on the breadboard flashing on and off every second.
Now let’s take a look at the code and the hardware and find out how they both work.
Project 1 — LED Flasher – Code Overview
Let’s take a look at the code for this project. Our first line is// Project 1 - LED Flasher
This is simply a comment in your code and is ignored by the compiler (the part of the IDE that turns your code into instructions the Arduino can understand before uploading it). Everything following // (double slashes) on a line is ignored by the compiler. This allows you to add notes to yourself and others who may read the code explaining how the code works.
Comments are essential in your code to help you understand what is going on and how your code works. Later on as your projects get more complex and your code expands into hundreds or maybe thousands of lines, comments will be vital in making it easy for you to see how it works. You may come up with an amazing piece of code, but if you go back and look at that code days, weeks or months later, you may forget how it all works. Comments will help you understand it easily. Also, if your code is meant to be seen by other people—and as the whole ethos of the Arduino, and indeed the whole Open Source community is to share code and schematics—I hope when you start making your own cool stuff with the Arduino, you will be willing to share it with the world. Comments will enable others to understand what is going on in your code.
You can also put comments into a block by using the /* and */ delimiters, for example:
/* All of the text within the slash and the asterisks is a comment and will be ignored by the compiler */
The IDE will automatically turn the color of any commented text to grey. The next line of the program is
This is what is known as a variable. A variable is a place to store data. Imagine a variable as a small box where you can keep things. A variable is called a variable because you can change its contents. Later on, we will carry out mathematical calculations on variables to make our program do more advanced things. In this case, you are setting up a variable of type int or integer. An integer is a number within the range of -32,768 to 32,767. Next, you have assigned that integer the name of ledPin and have given it a value of 10. We didn’t have to call it ledPin; we could have called it anything we wanted to. But, as we want our variable name to be descriptive, we call it ledPin to show that the use of this variable is to set which pin on the Arduino we are going to use to connect our LED. In this case, we are using digital pin 10. At the end of this statement is a semicolon. This is a symbol to tell the compiler that this statement is now complete.
Although we can call our variables anything we want, every variable name in C must start with a letter; the rest of the name can consist of letters, numbers, and underscore characters. C recognizes upper and lower case characters as being different. Finally, you cannot use any of C’s keywords such as main, while, switch, etc. as variable names. Keywords are constants, variables, and function names that are defined as part of the Arduino language.
Don’t use a variable name that is the same as a keyword. All keywords within the sketch will appear in red. So, you have set up an area in memory to store a number of type integer and have stored in that area the number 10.
Next we have our setup() function
void setup() {
pinMode(ledPin, OUTPUT); }
An Arduino sketch must have a setup() and loop() function, otherwise it will not work. The setup() function runs once and once only at the start of the program and is where you will issue general instructions to prepare the program before the main loop runs, such as setting up pin modes, setting serial baud rates, etc. Basically, a function is a block of code assembled into one convenient block. For example, if we created our own function to carry out a whole series of complicated mathematics that had many lines of code, we could run that code as many times as we liked simply by calling the function name instead of writing out the code again each time. Later on, we will go into functions in more detail when we start to create our own. In the case of our program, the setup() function only has one statement to carry out. The function starts with
void setup()
Here, we are telling the compiler that our function is called setup, that it returns no data (void) and that we pass no parameters to it (empty parenthesis). If our function returned an integer value and we also had integer values to pass to it (e.g. for the function to process), then it would look something like this
int myFunc(int x, int y)
In this case, we have created a function (or a block of code) called myFunc. This function has been passed two integers called x and y Once the function has finished, it will then return an integer value to the point after our function was called in the program (hence int before the function name).
All of the code within the function is contained within the curly braces. A { symbol starts the block of code and a } symbol ends the block. Anything in between those two symbols is code that belongs to the function. We will go into greater detail about functions later on in Project 4 in this chapter, so don’t worry about them for now. All you need to know is that in this program, we have two functions, and the first function is called setup; its purpose is to setup anything necessary for our program to work before the main program loop runs.
void setup() {
25
Our setup function only has one statement and that is pinMode. Here we are telling the Arduino that we want to set the mode of one of our digital pins to be output mode, rather than input. Within the parenthesis, we put the pin number and the mode (OUTPUT or INPUT). Our pin number is ledPin, which has been previously set to the value 10 in our program. Therefore, this statement is simply telling the Arduino that the digital pin 10 is to be set to OUTPUT mode. As the setup() function runs only once, we now move onto the main function loop.void loop() {
The loop() function is the main program function and is called continuously as long as our Arduino is turned on. Every statement within the loop() function (within the curly braces) is carried out, one by one, step by step, until the bottom of the function is reached; then, the Arduino starts the loop again at the top of the function, and so on forever, or until you turn the Arduino off or press the Reset switch.
In this project, we want the LED to turn on, stay on for one second, turn off and remain off for one second, and then repeat. Therefore, the commands to tell the Arduino to do that are contained within the loop() function, as we wish them to repeat over and over. The first statement is
digitalWrite(ledPin, HIGH);
This writes a HIGH or a LOW value to the digital pin within the statement (in this case ledPin, which is digital pin 10). When you set a digital pin to HIGH, you are sending out 5 volts to that pin. When you set it to LOW, the pin becomes 0 volts, or ground. This statement therefore sends out 5v to digital pin 10 and turns the LED on. After that is
delay(1000);
This statement simply tells the Arduino to wait for 1,000 milliseconds (there are 1,000 milliseconds in a second) before carrying out the next statement which is
digitalWrite(ledPin, LOW);
This will turn off the power going to digital pin 10, and therefore turn the LED off. There is then another delay statement for another 1,000 milliseconds and then the function ends. However, as this is our main loop() function, the function will now start again at the beginning.
By following the program structure step by step again, we can see that it is very simple.
We start off by assigning a variable called ledPin, giving that variable a value of 10. Then we move onto the setup() function where we simply set the mode for digital pin 10 as an output. In the main program loop, we set digital pin 10 to high, sending out 5v. Then we wait for a second and then turn off the 5v to pin 10, before waiting another second. The loop then starts again at the beginning, and the LED will turn on and off continuously for as long as the Arduino has power.
Now that you know this, you can modify the code to turn the LED on for a different period of time and also turn it off for a different time period. For example, if we wanted the LED to stay on for two seconds, then go off for half a second, we could do
this:-void loop() {
digitalWrite(ledPin, HIGH); delay(2000);
digitalWrite(ledPin, LOW); delay(500);
}
Maybe you would like the LED to stay off for five seconds and then flash briefly (250ms), like the LED indicator on a car alarm; then, you could do
this:-void loop() {
digitalWrite(ledPin, HIGH); delay(250);
digitalWrite(ledPin, LOW); delay(5000);
}
Or, to make the LED flash on and off very fast
void loop() {
digitalWrite(ledPin, HIGH); delay(50);
digitalWrite(ledPin, LOW); delay(50);
}
27
Project 1 — LED Flasher – Hardware Overview
The hardware used in Project 1 was:
Breadboard
5mm LED
100W Resistor*
Jumper Wires
* or whatever value you worked out that was appropriate for your LED
The breadboard is a reusable solderless device generally used to prototype an electronic circuit, or for experimenting with circuit designs. The board consists of a series of holes in grid patterns. Underneath the board, these holes are connected by strips of conductive metal. The way those strips are laid out is typically something like in Figure 2-2.
Figure 2-2. How the metal strips in a breadboard are laid out
The next component we have is a resistor. A resistor is a device designed to cause resistance to an electric current and therefore cause a drop in voltage across its terminals. You can imagine a resistor to be like a water pipe that is a lot thinner than the pipe connected to it. As the water (the electric current) comes into the resistor, the pipe gets thinner and the current coming out of the other end is therefore reduced. We use resistors to decrease voltage or current to other devices.
Resistance is measured in units called ohms. The symbol for ohms is the Greek omega symbol W. In this case, digital pin 10 is outputting 5 volts DC at 40mA (milliamps), according to the Atmega datasheet, and our LEDs require a voltage of 2v and a current of 35mA, according to their datasheet. We therefore need to put in a resistor that will reduce the 5V to 2V, and the current from 40mA to 35mA if we want to display the LED at its maximum brightness. If we want the LED to be dimmer, we could use a higher value of resistance.
Note
■
NEVER use a value of resistor that is LOWER than needed. You will put too much current through the LED and
damage it permanently. You could also damage other parts of your circuit.
The formula to work out which resistor we need is:
R = (VS – VL) / I
Where VS is the supply voltage, VL is the LED voltage and I is the LED current. So, for our example LED, we have an LED with an LED voltage of 2 volts and a current of 35mA (milliamps) connected to a digital pin from an Arduino which gives out 5 volts; therefore, the resistor value needed would be:
R = (5 – 2) / 0.035
which gives a value of 85.71.
Resistors come in standard values and the closest common value would be 100 ohms. Always choose the next standard value resistor that is higher than the value needed. If you choose a lower value, too much current will flow through the resistor and the resistor and/or the components connected with it may be damaged.
So, how do we find a 100W resistor? A resistor is too small to be written upon that could be readable by most people, so instead, resistors use a color code. Around the resistor, you will typically find four colored bands, and by using the color code in Table 2-2 you can find out the value of a resistor or which color codes a particular resistance will be.
Figure 2-3. An integrated circuit (or chip) plugged across the gap in a breadboard
parts of your board. If you are using just one voltage, a short piece of jumper wire can be placed across this gap to make sure that the same voltage is applied along the whole length of the rail.
29
Table 2-2. Resistor Color Codes
Color 1st Band 2nd Band
We need a 100W resistor, so if you look at the color table, you will see that we need 1 in the first band, which is brown, followed by a 0 in the next band, which is black, and we then need to multiply this by 101 (in other words add 1 zero) which is brown in the 3rd band. The final band indicates the tolerance of the resistor. If your resistor had a gold band, it would therefore have a tolerance of ±5%, which means the actual value of the resistor can vary between 95W and 105W. Therefore, if you had an LED that required two volts and 35mA, you would need a resistor with a brown, black, brown band combination.
Figure 2-4. A 10KW resistor with a 5% tolerance
If you needed a 10K (or 10 kilo-ohm) resistor (see Figure 2-4), you would need a brown, black, orange combination (1, 0, +3 zeros). If you needed a 570K resistor, the colors would be green, violet, and yellow, and so on.
resistor storage box, you could look at the table to see it has a value of 220W. Choose the correct resistance value for the LED you have purchased to complete this project.
The final component is an LED (I’m sure you can figure out what the jumper wires do for yourself ), which stands for Light Emitting Diode. A diode is a device that permits current to flow in only one direction. So, it is just like a check valve in a water system. In this case, however, it is letting electrical current go in one direction; if the current tried to reverse and go back in the opposite direction, the diode would stop it from doing so. Diodes can be useful to prevent you from accidently connecting the power and ground to the wrong terminals in a circuit and damaging the components.
An LED is a diode that also emits light. LEDs come in different colors and brightnesses, and can also emit light in the ultraviolet and infrared parts of the spectrum (as in the LEDs in your TV remote control).
If you look carefully at an LED, you will notice two things. One is that the legs are of different lengths, and also, that on one side of the LED it is flattened rather than cylindrical (see Figure 2-5). These are indicators to show you which leg is the anode (positive) and which is the cathode (negative). The longer leg (anode) gets connected to the positive supply (3.3V) and the leg with the flattened side (cathode) goes to ground. However, LEDs also come
Figure 2-5. The parts of an LED (image courtesy of Inductiveload from Wikimedia Commons)
in rectangular shapes, surface mount style, or other forms. Always refer to the datasheet for your LED to check the correct anode/cathode orientation.
If you connect the LED the wrong way, it will not be damaged (unless you put very high currents through it). It is essential that you always put a resistor in series with the LED to ensure that the correct current gets to the LED. You can permanently damage the LED if you fail to do this. As well as single color LEDs, you can also obtain bicolor and tricolor LEDs. These will have several legs coming out of them with one common leg (that is, a common anode or common cathode).
31
Now that you know how the components work and how the code in this project works, let’s try something a bit more interesting.Project 2 – S.O.S. Morse Code Signaler
For this project, we are going to leave the exact same circuit set up as in Project 1 (so no need for a hardware overview), but will use some different code to make the LED display a message in Morse code. In this case, we are going to get the LED to signal the letters S.O.S., which is the international Morse code distress signal. Morse code is a type of character encoding that transmits letters and numbers using patterns of on and off. It is therefore nicely suited to our digital system as we can turn an LED on and off in the necessary pattern to spell out a word or a series of characters. In this case we will be signaling S.O.S., which in the Morse code alphabet is three dits (short flashes), followed by three dahs (long flashes), followed by three dits again.
We can therefore now code our sketch to flash the LED on and off in this pattern, signaling SOS.
Enter the code
Listing 2-2. Code for Project 2
// LED connected to digital pin 10 int ledPin = 10;
// run once, when the sketch starts void setup()
{
// sets the digital pin as output pinMode(ledPin, OUTPUT);
}
// run over and over again void loop()
// 100ms delay to cause slight gap between letters
Create a new sketch and then type in the code from listing 2-2. Verify your code is error free and then upload it to your Arduino. If all goes well, you will now see the LED flash the Morse Code SOS signal, pause 5 seconds, then repeat.
If you were to rig up a battery-operated Arduino to a very bright light and then place the whole assembly into a waterproof and handheld box, this code could be used to control an SOS emergency strobe light to be used on boats, while mountain climbing, etc.
So, let’s take a look at this code and work out how it works.
Project 2 – S.O.S. Morse Code Signaler – Code Overview
Thus, the first part of the code is identical to the last project where we initialize a variable and then set pin 10 to be an output. In the main code loop, we can see the same kind of statements to turn the LEDs on and off for a set period of time, but this time, the statements are within three separate code blocks.
The first block is what outputs the three dits
for (int x=0; x<3; x++) {
We can see that the LED is turned on for 150ms and then off for 100ms and we can see that those statements are within a set of curly braces and are therefore in a separate code block. A block is a set of one or more statements enclosed within curly braces. But, when we run the sketch, we can see the light flashes three times, not just once.
This is done using the for loop.
for (int x=0; x<3; x++) {
This statement is what makes the code within its code block execute three times. There are three expressions we can supply to the for loop. These are initialization, condition, increment. The initialization expression is evaluated first, and only once. Each time through the loop, the condition is tested; if it’s true, the statement block is executed, and then the increment expression (if present) is executed. Then control goes back to the condition test and the process repeats until the condition is false when tested; the loop then ends.
33
int x=0;We then set a condition to decide how many times the code in the loop will execute.
x<3;
In this case, the code will loop if x is smaller than (<) 3. The initialization expression is always executed, but if the condition is false going into the for loop, the loop body and increment expression are not executed. The < symbol is what is known as a comparison operator. These operators are used to make decisions within your code and to compare two values. The symbols used
are:-== (equal to)
!= (not equal to)
< (less than)
> (greater than)
<= (less than or equal to)
>= (greater than or equal to)
In our code, we are comparing x with the value of 3 to see if it is smaller than 3. If x is smaller than 3, then the code in the block will be executed. Otherwise, the loop will exit.
The final statement is
x++
This is a statement to increase the value of x by 1. We could also have typed in x = x + 1, which would assign to x the value of x + 1. Note there is no need to put a semicolon after this final Page: 1expression in the for loop statement.
You can do simple mathematics using the symbols +, -, * and / (addition, subtraction, multiplication and division). For example,
1 + 1 = 2
3 − 2 = 1
2 * 4 = 8
8 / 2 = 4
So, our for loop initializes the value of x to 0, then checks that the condition is met, which is that x is smaller than 3; if it is, it runs the code within the body of the for loop. It then increments x by the value of the increment expression. As long as the condition of the loop is met, the loop will keep on repeating.
So, now we know how the for loop works, we can see in our code that there are three for loops, one that loops three times and displays the dits. The next one repeats three times and displays the dahs. Then there is a repeat of the dits again.
It must be noted that the variable x has a local “scope,” which means it can only be seen by the code within its own code block. A variable defined within a function, for(), or block is accessible within that function, for(), or block. Variables defined outside of any function are globally visible within the remainder of the file in which they are defined. They are not visible to separately compiled parts of the program unless declared there with the extern command. If you try to access x outside the for loop, you will get an error.
In between each for loop there is a small delay to make a tiny visible pause between the letters of S.O.S. Finally, the code waits for five seconds before the main program loop starts again.
Project 3 – Traffic Lights
We are now going to create a set of traffic lights based on the system that will change from green to red, via amber, and back again, after a set length of time using the four-state system. We will use the parts listed in Table 2-3. This project could be used on a model railway to make a set of working traffic lights or for a child’s toy town.
Table 2-3. Parts Required for Project 3
Breadboard
Red Diffused LED
Yellow Diffused LED
Green Diffused LED
3 x 150W Resistor*
Jumper Wires
*or whatever value you require for your type of LED
Parts Required
In the parts list of Table 2-3, you will find all you need for this project. We will be using three LEDs and therefore, three current-limiting resistors.
Connect It Up
35
Figure 2-6. The circuit for Project 3
We have taken a jumper wire from the ground of the Arduino to the ground rail at the top of the breadboard. A ground wire goes from the cathode leg of each LED to the common ground rail via a current-limiting resistor (this time, connected to the cathode). For this simple circuit, it doesn’t matter if the resistor is connected between the digital pin and the anode, or between the cathode and ground, as long as it is in series with the LED.
Enter the Code
Enter the code from listing 2-3, check it, and upload to your Arduino. The LEDs will now move through four states that simulate a traffic light system, as seen in Figure 2-7. If you have followed projects 1 and 2, then both the code and the hardware for Project 3 will be self-explanatory. I shall leave you to examine the code and figure out how it works.
Listing 2-3. Code for Project 3 // Project 3 - Traffic Lights
int ledDelay = 10000; // delay in between changes int redPin = 10;
int yellowPin = 9; int greenPin = 8;
void setup() {
pinMode(redPin, OUTPUT); pinMode(yellowPin, OUTPUT); pinMode(greenPin, OUTPUT); }
void loop() {
digitalWrite(redPin, HIGH); // turn the red light on delay(ledDelay); // wait 5 seconds
digitalWrite(yellowPin, HIGH); // turn on yellow delay(2000); // wait 2 seconds
digitalWrite(greenPin, HIGH); // turn green on digitalWrite(redPin, LOW); // turn red off digitalWrite(yellowPin, LOW); // turn yellow off delay(ledDelay); // wait ledDelay milliseconds
digitalWrite(yellowPin, HIGH); // turn yellow on digitalWrite(greenPin, LOW); // turn green off delay(2000); // wait 2 seconds
digitalWrite(yellowPin, LOW); // turn yellow off // now our loop repeats
}
Figure 2-7. The four states of a traffic light system (image by Alex43223 from WikiMedia)
In the next project, we are going to build on project 3 by including a set of pedestrian lights and adding a push button to make the lights interactive. In doing so, you will learn about detecting an input.
Project 4 – Interactive Traffic Lights
This time, we are going to extend the previous project to include a set of pedestrian lights and a pedestrian push button used for requests to cross the road. The Arduino will react when the button is pressed by changing the state of the lights to make the cars stop and allow the pedestrian to cross safely.
For the first time, we will be able to interact with the Arduino and cause it to do something when we change the state of a button that the Arduino is watching (i.e., press the button to change the state from open to closed). In this project, we will also learn how to create our own functions in code.
From now on, when listing the parts required, we will no longer list the breadboard and jumper wires. Just assume that you will always need both of those.
Parts Required
37
Table 2-4. Parts Required for Project 4 2 x Red Diffused LEDs
Yellow Diffused LED
2 x Green Diffused LEDs
10KW Resistor
5 x Current-Limiting Resistors
Pushbutton
The five resistors for the LEDs are there to limit the current (and are thus called current limiting) going to the LED to prevent damage. Choose the appropriate value resistor for your project (see Chapter 1).
You will need a 10KΩ resistor for the pushbutton. This is what is known as a “pull-down resistor.” We will cover pull-down and pull-up resistors later in the chapter. The pushbutton in Table 2-4 is sometimes referred to by suppliers as a “tactile switch,” and is ideal for breadboard use.
Connect It Up
Enter the Code
Enter the code in Listing 2-4 and verify and upload it.
When you run the program, you will see that the car traffic light starts on green to allow cars to pass and the pedestrian light is on red.
When you press the button, the program checks that at least five seconds have gone by since the last time the lights were changed (to allow traffic to get moving), and if they have, passes code execution to the function we have created called changeLights(). In this function, the car lights go from green to amber then red, and then the pedestrian lights go green. After a period of time set in the variable crossTime (time enough to allow the pedestrians to cross), the green pedestrian light will flash on and off as a warning to the pedestrians to hurry up as the lights are about to change back to red. Then the pedestrian light changes back to red and the vehicle lights go from red to amber to green and the traffic can resume.
Listing 2-4. Code for Project 4
// Project 4 - Interactive Traffic Lights
int carRed = 12; // assign the car lights int carYellow = 11;
int carGreen = 10;
int pedRed = 9; // assign the pedestrian lights int pedGreen = 8;
int button = 2; // button pin
int crossTime = 5000; // time allowed to cross
unsigned long changeTime = 0; // time last pedestrian cycle completed
