Arduino Cookbook

Arduino Cookbook

Michael Margolis

Beijing • Cambridge • Farnham • Köln • Sebastopol • Tokyo

Arduino Cookbook by Michael Margolis
Copyright © 2011 Michael Margolis and Nicholas Weldin. All rights reserved.
Printed in the United States of America.
Published by O’Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472.
O’Reilly books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://my.safaribooksonline.com). For more information, contact our corporate/institutional sales department: (800) 998-9938 or corporate@oreilly.com.

Editors: Simon St. Laurent and Brian Jepson
Production Editor: Teresa Elsey
Copyeditor: Audrey Doyle
Proofreader: Teresa Elsey

Indexer: Lucie Haskins
Cover Designer: Karen Montgomery
Interior Designer: David Futato
Illustrator: Robert Romano

Printing History:
March 2011:

First Edition.

Nutshell Handbook, the Nutshell Handbook logo, and the O’Reilly logo are registered trademarks of
O’Reilly Media, Inc. Arduino Cookbook, the image of a toy rabbit, and related trade dress are trademarks of O’Reilly Media, Inc.
Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O’Reilly Media, Inc., was aware of a trademark claim, the designations have been printed in caps or initial caps.
While every precaution has been taken in the preparation of this book, the publisher and authors assume no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein.

ISBN: 978-0-596-80247-9
[LSI]
1299267108

Table of Contents

Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xiii
1. Getting Started . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1 Installing the Integrated Development Environment (IDE)
1.2 Setting Up the Arduino Board
1.3 Using the Integrated Development Environment (IDE) to Prepare an Arduino Sketch
1.4 Uploading and Running the Blink Sketch
1.5 Creating and Saving a Sketch
1.6 Using Arduino

4
6
8
11
13
15

2. Making the Sketch Do Your Bidding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16
2.17
2.18
2.19

Structuring an Arduino Program
Using Simple Primitive Types (Variables)
Using Floating-Point Numbers
Working with Groups of Values
Using Arduino String Functionality
Using C Character Strings
Splitting Comma-Separated Text into Groups
Converting a Number to a String
Converting a String to a Number
Structuring Your Code into Functional Blocks
Returning More Than One Value from a Function
Taking Actions Based on Conditions
Repeating a Sequence of Statements
Repeating Statements with a Counter
Breaking Out of Loops
Taking a Variety of Actions Based on a Single Variable
Comparing Character and Numeric Values
Comparing Strings
Performing Logical Comparisons

20
21
23
25
28
30
32
34
36
38
41
44
45
47
49
50
52
54
55

v

2.20 Performing Bitwise Operations
2.21 Combining Operations and Assignment

56
58

3. Using Mathematical Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15

Adding, Subtracting, Multiplying, and Dividing
Incrementing and Decrementing Values
Finding the Remainder After Dividing Two Values
Determining the Absolute Value
Constraining a Number to a Range of Values
Finding the Minimum or Maximum of Some Values
Raising a Number to a Power
Taking the Square Root
Rounding Floating-Point Numbers Up and Down
Using Trigonometric Functions
Generating Random Numbers
Setting and Reading Bits
Shifting Bits
Extracting High and Low Bytes in an int or long
Forming an int or long from High and Low Bytes

61
62
63
64
65
66
67
68
68
69
70
72
75
77
78

4. Serial Communications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15

Sending Debug Information from Arduino to Your Computer
Sending Formatted Text and Numeric Data from Arduino
Receiving Serial Data in Arduino
Sending Multiple Text Fields from Arduino in a Single Message
Receiving Multiple Text Fields in a Single Message in Arduino
Sending Binary Data from Arduino
Receiving Binary Data from Arduino on a Computer
Sending Binary Values from Processing to Arduino
Sending the Value of Multiple Arduino Pins
How to Move the Mouse Cursor on a PC or Mac
Controlling Google Earth Using Arduino
Logging Arduino Data to a File on Your Computer
Sending Data to Two Serial Devices at the Same Time
Receiving Serial Data from Two Devices at the Same Time
Setting Up Processing on Your Computer to Send and Receive Serial Data

86
89
92
95
98
101
105
107
109
112
115
121
124
128
131

5. Simple Digital and Analog Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
5.1
5.2
5.3
5.4

Using a Switch
Using a Switch Without External Resistors
Reliably Detecting the Closing of a Switch
Determining How Long a Switch Is Pressed

vi | Table of Contents

136
139
141
144

5.5
5.6
5.7
5.8
5.9
5.10
5.11

Reading a Keypad
Reading Analog Values
Changing the Range of Values
Reading More Than Six Analog Inputs
Displaying Voltages Up to 5V
Responding to Changes in Voltage
Measuring Voltages More Than 5V (Voltage Dividers)

149
152
154
155
158
161
162

6. Getting Input from Sensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
6.1
6.2
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
6.12
6.13
6.14
6.15
6.16
6.17
6.18

Detecting Movement
Detecting Light
Detecting Motion (Integrating Passive Infrared Detectors)
Measuring Distance
Measuring Distance Accurately
Detecting Vibration
Detecting Sound
Measuring Temperature
Reading RFID Tags
Tracking the Movement of a Dial
Tracking the Movement of More Than One Rotary Encoder
Tracking the Movement of a Dial in a Busy Sketch
Using a Mouse
Getting Location from a GPS
Detecting Rotation Using a Gyroscope
Detecting Direction
Getting Input from a Game Control Pad (PlayStation)
Reading Acceleration

167
170
171
173
176
180
181
185
187
190
193
195
197
201
206
208
211
213

7. Visual Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
7.1
7.2
7.3
7.4
7.5
7.6
7.7
7.8
7.9
7.10
7.11
7.12

Connecting and Using LEDs
Adjusting the Brightness of an LED
Driving High-Power LEDs
Adjusting the Color of an LED
Sequencing Multiple LEDs: Creating a Bar Graph
Sequencing Multiple LEDs: Making a Chase Sequence (Knight
Rider)
Controlling an LED Matrix Using Multiplexing
Displaying Images on an LED Matrix
Controlling a Matrix of LEDs: Charlieplexing
Driving a 7-Segment LED Display
Driving Multidigit, 7-Segment LED Displays: Multiplexing
Driving Multidigit, 7-Segment LED Displays Using MAX7221 Shift
Registers

220
223
224
226
229
232
234
236
239
245
248
250

Table of Contents | vii

7.13 Controlling an Array of LEDs by Using MAX72xx Shift Registers
7.14 Increasing the Number of Analog Outputs Using PWM Extender
Chips (TLC5940)
7.15 Using an Analog Panel Meter As a Display

253
255
259

8. Physical Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
8.1 Controlling the Position of a Servo
8.2 Controlling One or Two Servos with a Potentiometer or Sensor
8.3 Controlling the Speed of Continuous Rotation Servos
8.4 Controlling Servos from the Serial Port
8.5 Driving a Brushless Motor (Using a Hobby Speed Controller)
8.6 Controlling Solenoids and Relays
8.7 Making an Object Vibrate
8.8 Driving a Brushed Motor Using a Transistor
8.9 Controlling the Direction of a Brushed Motor with an H-Bridge
8.10 Controlling the Direction and Speed of a Brushed Motor with an
H-Bridge
8.11 Using Sensors to Control the Direction and Speed of Brushed
Motors (L293 H-Bridge)
8.12 Driving a Bipolar Stepper Motor
8.13 Driving a Bipolar Stepper Motor (Using the EasyDriver Board)
8.14 Driving a Unipolar Stepper Motor (ULN2003A)

264
266
267
269
271
272
273
276
277
280
282
287
290
293

9. Audio Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
9.1
9.2
9.3
9.4
9.5
9.6
9.7

Playing Tones
Playing a Simple Melody
Generating More Than One Simultaneous Tone
Generating Audio Tones and Fading an LED
Playing a WAV File
Controlling MIDI
Making an Audio Synthesizer

299
301
303
305
308
311
314

10. Remotely Controlling External Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
10.1
10.2
10.3
10.4
10.5

Responding to an Infrared Remote Control
Decoding Infrared Remote Control Signals
Imitating Remote Control Signals
Controlling a Digital Camera
Controlling AC Devices by Hacking a Remote Controlled Switch

318
321
324
327
330

11. Using Displays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
11.1 Connecting and Using a Text LCD Display viii | Table of Contents

334

11.2
11.3
11.4
11.5
11.6
11.7
11.8
11.9
11.10
11.11

Formatting Text
Turning the Cursor and Display On or Off
Scrolling Text
Displaying Special Symbols
Creating Custom Characters
Displaying Symbols Larger Than a Single Character
Displaying Pixels Smaller Than a Single Character
Connecting and Using a Graphical LCD Display
Creating Bitmaps for Use with a Graphical Display
Displaying Text on a TV

337
340
342
345
347
349
352
355
359
361

12. Using Time and Dates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
12.1
12.2
12.3
12.4
12.5
12.6

Creating Delays
Using millis to Determine Duration
More Precisely Measuring the Duration of a Pulse
Using Arduino As a Clock
Creating an Alarm to Periodically Call a Function
Using a Real-Time Clock

367
368
372
373
380
384

13. Communicating Using I2C and SPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
13.1
13.2
13.3
13.4
13.5
13.6
13.7
13.8
13.9

Controlling an RGB LED Using the BlinkM Module
Using the Wii Nunchuck Accelerometer
Interfacing to an External Real-Time Clock
Adding External EEPROM Memory
Reading Temperature with a Digital Thermometer
Driving Four 7-Segment LEDs Using Only Two Wires
Integrating an I2C Port Expander
Driving Multidigit, 7-Segment Displays Using SPI
Communicating Between Two or More Arduino Boards

392
397
401
404
408
412
416
418
421

14. Wireless Communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
14.1
14.2
14.3
14.4
14.5

Sending Messages Using Low-Cost Wireless Modules
Connecting Arduino to a ZigBee or 802.15.4 Network
Sending a Message to a Particular XBee
Sending Sensor Data Between XBees
Activating an Actuator Connected to an XBee

425
431
438
440
446

15. Ethernet and Networking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
15.1
15.2
15.3
15.4
15.5

Setting Up the Ethernet Shield
Obtaining Your IP Address Automatically
Resolving Hostnames to IP Addresses (DNS)
Requesting Data from a Web Server
Requesting Data from a Web Server Using XML

453
455
458
462
466
Table of Contents | ix

15.6
15.7
15.8
15.9
15.10
15.11
15.12
15.13
15.14
15.15
15.16

Setting Up an Arduino to Be a Web Server
Handling Incoming Web Requests
Handling Incoming Requests for Specific Pages
Using HTML to Format Web Server Responses
Serving Web Pages Using Forms (POST)
Serving Web Pages Containing Large Amounts of Data
Sending Twitter Messages
Sending and Receiving Simple Messages (UDP)
Getting the Time from an Internet Time Server
Monitoring Pachube Feeds
Sending Information to Pachube

469
471
474
479
483
486
493
496
502
507
510

16. Using, Modifying, and Creating Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
16.1
16.2
16.3
16.4
16.5

Using the Built-in Libraries
Installing Third-Party Libraries
Modifying a Library
Creating Your Own Library
Creating a Library That Uses Other Libraries

515
517
518
522
527

17. Advanced Coding and Memory Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
17.1
17.2
17.3
17.4
17.5
17.6

Understanding the Arduino Build Process
Determining the Amount of Free and Used RAM
Storing and Retrieving Numeric Values in Program Memory
Storing and Retrieving Strings in Program Memory
Using #define and const Instead of Integers
Using Conditional Compilations

532
535
537
540
542
543

18. Using the Controller Chip Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
18.1
18.2
18.3
18.4
18.5
18.6
18.7
18.8
18.9
18.10
18.11

Storing Data in Permanent EEPROM Memory
Using Hardware Interrupts
Setting Timer Duration
Setting Timer Pulse Width and Duration
Creating a Pulse Generator
Changing a Timer’s PWM Frequency
Counting Pulses
Measuring Pulses More Accurately
Measuring Analog Values Quickly
Reducing Battery Drain
Setting Digital Pins Quickly

551
554
557
559
562
565
567
569
571
572
574

A. Electronic Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
B. Using Schematic Diagrams and Data Sheets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585 x | Table of Contents

C. Building and Connecting the Circuit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591
D. Tips on Troubleshooting Software Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
E. Tips on Troubleshooting Hardware Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
F. Digital and Analog Pins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
G. ASCII and Extended Character Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611

Table of Contents | xi

Preface

This book was written by Michael Margolis with Nick Weldin to help you explore the amazing things you can do with Arduino.
Arduino is a family of microcontrollers (tiny computers) and a software creation environment that makes it easy for you to create programs (called sketches) that can interact with the physical world. Things you make with Arduino can sense and respond to touch, sound, position, heat, and light. This type of technology, often referred to as physical computing, is used in all kinds of things, from the iPhone to automobile electronics systems. Arduino makes it possible for anyone—even people with no programming or electronics experience—to use this rich and complex technology.

Who This Book Is For
Unlike in most technical cookbooks, experience with software and hardware is not assumed. This book is aimed at a broad range of readers interested in using computer technology to interact with the environment. It is for people who want to quickly find the solution to hardware and software problems.
You may have no programming experience—perhaps you have a great idea for an interactive project but don’t have the skills to develop it. This book will help you learn what you need to know to write code that works, using examples that cover the kinds of tasks you want to perform.
If you have some programming experience but are new to Arduino, the book will help you become productive quickly by demonstrating how to implement specific Arduino capabilities for your project.
People already using Arduino should find the content helpful for quickly learning new techniques, which are explained using practical examples. This will help you to embark on more complex projects by showing how to solve problems and use capabilities that may be new to you.
Experienced C/C++ programmers will find examples of how to use the low-level AVR resources (interrupts, timers, I2C, Ethernet, etc.) to build applications using the
Arduino environment. xiii How This Book Is Organized
The book contains information that covers the broad range of the Arduino’s capabilities, from basic concepts and common tasks to advanced technology. Each technique is explained in a recipe that shows you how to implement a specific capability. You do not need to read the content in sequence.
Chapter 1, Getting Started, introduces the Arduino environment and provides help on getting the Arduino development environment and hardware installed and working.
The next couple of chapters introduce Arduino software development. Chapter 2,
Making the Sketch Do Your Bidding, covers essential software concepts and tasks, and
Chapter 3, Using Mathematical Operators, shows how to make use of the most common mathematical functions.
Chapter 4, Serial Communications, describes how to get Arduino to connect and communicate with your computer and other devices. Serial is the most common method for Arduino input and output, and this capability is used in many of the recipes throughout the book.
Chapter 5, Simple Digital and Analog Input, introduces a range of basic techniques for reading digital and analog signals. Chapter 6, Getting Input from Sensors, builds on this with recipes that explain how to use devices that enable Arduino to sense touch, sound, position, heat, and light.
Chapter 7, Visual Output, covers controlling light. Recipes cover switching on one or many LEDs and controlling brightness and color. This chapter explains how you can drive bar graphs and numeric LED displays, as well as create patterns and animations with LED arrays. In addition, the chapter provides a general introduction to digital and analog output for those who are new to this.
Chapter 8, Physical Output, explains how you can make things move by controlling motors with Arduino. A wide range of motor types are covered: solenoids, servo motors,
DC motors, and stepper motors.
Chapter 9, Audio Output, shows how to generate sound with Arduino through an output device such as a speaker. It covers playing simple tones and melodies and playing
WAV files and MIDI.
Chapter 10, Remotely Controlling External Devices, describes techniques that can be used to interact with almost any device that uses some form of remote controller, including TV, audio equipment, cameras, garage doors, appliances, and toys. It builds on techniques used in previous chapters for connecting Arduino to devices and modules. Chapter 11, Using Displays, covers interfacing text and graphical LCD displays. The chapter shows how you can connect these devices to display text, scroll or highlight words, and create special symbols and characters.

xiv | Preface

Chapter 12, Using Time and Dates, covers built-in Arduino time-related functions and introduces many additional techniques for handling time delays, time measurement, and real-world times and dates.
Chapter 13, Communicating Using I2C and SPI, covers the Inter-Integrated Circuit
(I2C) and Serial Peripheral Interface (SPI) standards. These standards provide simple ways for digital information to be transferred between sensors and Arduino. This chapter shows how to use I2C and SPI to connect to common devices. It also shows how to connect two or more Arduino boards, using I2C for multiboard applications.
Chapter 14, Wireless Communication, covers wireless communication with XBee. This chapter provides examples ranging from simple wireless serial port replacements to mesh networks connecting multiple boards to multiple sensors.
Chapter 15, Ethernet and Networking, describes the many ways you can use Arduino with the Internet. It has examples that demonstrate how to build and use web clients and servers and shows how to use the most common Internet communication protocols with Arduino.
Arduino software libraries are a standard way of adding functionality to the Arduino environment. Chapter 16, Using, Modifying, and Creating Libraries, explains how to use and modify software libraries. It also provides guidance on how to create your own libraries. Chapter 17, Advanced Coding and Memory Handling, covers advanced programming techniques, and the topics here are more technical than the other recipes in this book because they cover things that are usually concealed by the friendly Arduino wrapper.
The techniques in this chapter can be used to make a sketch more efficient—they can help improve performance and reduce the code size of your sketches.
Chapter 18, Using the Controller Chip Hardware, shows how to access and use hardware functions that are not fully exposed through the documented Arduino language.
It covers low-level usage of the hardware input/output registers, timers, and interrupts.
Appendix A, Electronic Components, provides an overview of the components used throughout the book.
Appendix B, Using Schematic Diagrams and Data Sheets, explains how to use schematic diagrams and data sheets.
Appendix C, Building and Connecting the Circuit, provides a brief introduction to using a breadboard, connecting and using external power supplies and batteries, and using capacitors for decoupling.
Appendix D, Tips on Troubleshooting Software Problems, provides tips on fixing compile and runtime problems.
Appendix E, Tips on Troubleshooting Hardware Problems, covers problems with electronic circuits.

Preface | xv

Appendix F, Digital and Analog Pins, provides tables indicating functionality provided by the pins on standard Arduino boards.
Appendix G, ASCII and Extended Character Sets, provides tables showing ASCII characters. What Was Left Out
There isn’t room in this book to cover electronics theory and practice, although guidance is provided for building the circuits used in the recipes. For more detail, readers may want to refer to material that is widely available on the Internet or to books such as the following:
•
•
•
•

Make: Electronics by Charles Platt (O’Reilly)
Getting Started in Electronics by Forrest Mims (Master Publishing)
Physical Computing by Tom Igoe (Cengage)
Practical Electronics for Inventors by Paul Scherz (McGraw-Hill)

This cookbook explains how to write code to accomplish specific tasks, but it is not an introduction to programming. Relevant programming concepts are briefly explained, but there is insufficient room to cover the details. If you want to learn more about programming, you may want to refer to the Internet or to one of the following books:
• Practical C Programming by Steve Oualline (O’Reilly)
• A Book on C by Al Kelley and Ira Pohl (Addison-Wesley)
My favorite, although not really a beginner’s book, is the book I used to learn
C programming:
• The C Programming Language by Brian W. Kernighan and Dennis M. Ritchie
(Prentice Hall)

Code Style (About the Code)
The code used throughout this book has been tailored to clearly illustrate the topic covered in each recipe. As a consequence, some common coding shortcuts have been avoided, particularly in the early chapters. Experienced C programmers often use rich but terse expressions that are efficient but can be a little difficult for beginners to read.
For example, the early chapters increment variables using explicit expressions that are easy for nonprogrammers to read: result = result + 1; // increment the count

Rather than the following, commonly used by experienced programmers, that does the same thing: result++; xvi | Preface

// increment using the post increment operator

Feel free to substitute your preferred style. Beginners should be reassured that there is no benefit in performance or code size in using the terse form.
Some programming expressions are so common that they are used in their terse form.
For example, the loop expressions are written as follows: for(int i=0; i < 4; i++)

This is equivalent to the following: int i; for(i=0; i < 4; i = i+1)

See Chapter 2 for more details on these and other expressions used throughout the book. Good programming practice involves ensuring that values used are valid (garbage in equals garbage out) by checking them before using them in calculations. However, to keep the code focused on the recipe topic, very little error-checking code has been included. Arduino Platform Release Notes
The code has been tested using Arduino releases from version 0018 through version
0020. This book was written before Arduino v1.0 was finalized, and although almost all of the examples should still work, small changes required for running with v1.0 will be published on the site for the book: http://www.oreilly.com/catalog/9780596802479/ There’s also a link to errata there. Errata give readers a way to let us know about typos, errors, and other problems with the book. Errata will be visible on the page immediately, and we’ll confirm them after checking them out. O’Reilly can also fix errata in future printings of the book and on Safari, making for a better reader experience pretty quickly. If you have problems making examples work, check the web link to see if the code has been updated. If that doesn’t fix the problem, see Appendix D, which covers troubleshooting software problems. The Arduino forum is a good place to post a question if you need more help: http://www.arduino.cc.
We hope to keep this book updated for future Arduino versions, and we will also incorporate suggestions and complaints into future editions.
If you like—or don’t like—this book, by all means, please let people know. Amazon reviews are one popular way to share your happiness (or lack of happiness), or you can leave reviews at the site for the book.

Preface | xvii

Conventions Used in This Book
The following font conventions are used in this book:
Italic
Indicates pathnames, filenames, and program names; Internet addresses, such as domain names and URLs; and new items where they are defined
Constant width

Indicates command lines and options that should be typed verbatim; names and keywords in programs, including method names, variable names, and class names; and HTML element tags
Constant width bold

Indicates emphasis in program code lines
Constant width italic

Indicates text that should be replaced with user-supplied values
This icon signifies a tip, suggestion, or general note.

This icon indicates a warning or caution.

Using Code Examples
This book is here to help you make things with Arduino. In general, you may use the code in this book in your programs and documentation. You do not need to contact us for permission unless you’re reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from this book does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product’s documentation does require permission.
We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: “Arduino Cookbook by Michael Margolis with Nick Weldin (O’Reilly). Copyright 2011 Michael Margolis and Nicholas Weldin,
9780596802479.”
If you feel your use of code examples falls outside fair use or the permission given here, feel free to contact us at permissions@oreilly.com.

xviii | Preface

Safari® Books Online
Safari Books Online is an on-demand digital library that lets you easily search over 7,500 technology and creative reference books and videos to find the answers you need quickly.
With a subscription, you can read any page and watch any video from our library online.
Read books on your cell phone and mobile devices. Access new titles before they are available for print, and get exclusive access to manuscripts in development and post feedback for the authors. Copy and paste code samples, organize your favorites, download chapters, bookmark key sections, create notes, print out pages, and benefit from tons of other time-saving features.
O’Reilly Media has uploaded this book to the Safari Books Online service. To have full digital access to this book and others on similar topics from O’Reilly and other publishers, sign up for free at http://my.safaribooksonline.com.

How to Contact Us
We have tested and verified the information in this book to the best of our ability, but you may find that features have changed (or even that we have made a few mistakes!).
Please let us know about any errors you find, as well as your suggestions for future editions, by writing to:
O’Reilly Media, Inc.
1005 Gravenstein Highway North
Sebastopol, CA 95472
800-998-9938 (in the United States or Canada)
707-829-0515 (international/local)
707-829-0104 (fax)
We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at: http://www.oreilly.com/catalog/9780596802479 To comment or ask technical questions about this book, send email to: bookquestions@oreilly.com For more information about our books, courses, conferences, and news, see our website at http://www.oreilly.com.
Find us on Facebook: http://facebook.com/oreilly
Follow us on Twitter: http://twitter.com/oreillymedia
Watch us on YouTube: http://www.youtube.com/oreillymedia

Preface | xix

Acknowledgments
Nick Weldin’s contribution was invaluable for the completion of this book. It was
90 percent written when Nick came on board—and without his skill and enthusiasm, it would still be 90 percent written. His hands-on experience running Arduino workshops for all levels of users enabled us to make the advice in this book practical for our broad range of readers. Thank you, Nick, for your knowledge and genial collaborative nature. Simon St. Laurent was the editor at O’Reilly who first expressed interest in this book.
And in the end, he is the man who pulled it together. His support and encouragement kept us inspired as we sifted our way through the volumes of material necessary to do the subject justice.
Brian Jepson helped me get started with the writing of this book. His vast knowledge of things Arduino and his concern and expertise for communicating about technology in plain English set a high standard. He was an ideal guiding hand for shaping the book and making technology readily accessible for readers. We also have Brian to thank for the XBee content in Chapter 14.
Audrey Doyle worked tirelessly to stamp out typos and grammatical errors in the manuscript and untangle some of the more convoluted expressions.
Philip Lindsay collaborated on Chapter 15, and his combination of deep technical knowledge and clear understanding of the needs of nontechnical people was essential in making the complex subject of Ethernet accessible.
Mikal Hart wrote recipes covering GPS and software serial. Mikal was the natural choice for this—not only because he wrote the libraries, but also because he is a fluent communicator, an Arduino enthusiast, and a pleasure to collaborate with.
Arduino is possible because of the creativity of the core Arduino development team:
Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis. On behalf of all Arduino users, I wish to express our appreciation for their efforts in making this fascinating technology simple and their generosity in making it free.
Special thanks to Alexandra Deschamps-Sonsino, CEO of Tinker London, whose workshops provided important understanding of the needs of users. Thanks also to
Peter Knight, who has provided all kinds of clever Arduino solutions as well as the basis of a number of recipes in this book.
On behalf of everyone who has downloaded user-contributed Arduino libraries, I would like to thank the authors who have generously shared their knowledge.
The availability of a wide range of hardware is a large part of what makes Arduino exciting—thanks to the suppliers for stocking and supporting a broad range of great devices. The following were helpful in providing hardware used in the book: SparkFun,
Maker Store, Gravitech, and NKC Electronics. Other suppliers that have been helpful

xx | Preface

include Modern Device, Liquidware, Adafruit, Makerbot Industries, Mindkits,
Oomlout, and SK Pang.
Nick would like to thank Alexandra and Peter at Tinker London, as well as Brock Craft, and especially Daniel Soltis for all the workshops we have done together.
Nick would also like to thank everyone who has assisted at workshops, and participants who asked a “silly” question, as there are no silly questions. Many of those have led to clarifications and corrections in this book.
Nick’s final thanks go to his family, Jeanie, Emily, and Finn, who agreed to let him do this over their summer holiday, and of course, much longer after that than they originally thought, and to his parents, Frank and Eva, for bringing him up to take things apart. Last but not least, I express thanks to the following people:
Joshua Noble for introducing me to O’Reilly. His book, Programming Interactivity, is highly recommended for those interested in broadening their knowledge in interactive computing. Robert Lacy-Thompson for offering advice early on with the book.
Mark Margolis for his support and help as a sounding board in the book’s conception and development.
I thank my parents for helping me to see that the creative arts and technology were not distinctive entities and that, when combined, they can lead to extraordinary results.
And finally, this book would not have been started or finished without the support of my wife, Barbara Faden. My grateful appreciation to her for keeping me motivated and for her careful reading and contributions to the manuscript.

Preface | xxi

CHAPTER 1

Getting Started

1.0 Introduction
The Arduino environment has been designed to be easy to use for beginners who have no software or electronics experience. With Arduino, you can build objects that can respond to and/or control light, sound, touch, and movement. Arduino has been used to create an amazing variety of things, including musical instruments, robots, light sculptures, games, interactive furniture, and even interactive clothing.
If you’re not a beginner, please feel free to skip ahead to recipes that interest you.

Arduino is used in many educational programs around the world, particularly by designers and artists who want to easily create prototypes but do not need a deep understanding of the technical details behind their creations. Because it is designed to be used by nontechnical people, the software includes plenty of example code to demonstrate how to use the Arduino board’s various facilities.
Though it is easy to use, Arduino’s underlying hardware works at the same level of sophistication that engineers employ to build embedded devices. People already working with microcontrollers are also attracted to Arduino because of its agile development capabilities and its facility for quick implementation of ideas.
Arduino is best known for its hardware, but you also need software to program that hardware. Both the hardware and the software are called “Arduino.” The combination enables you to create projects that sense and control the physical world. The software is free, open source, and cross-platform. The boards are inexpensive to buy, or you can build your own (the hardware designs are also open source). In addition, there is an active and supportive Arduino community that is accessible worldwide through the
Arduino forums and the wiki (known as the Arduino Playground). The forums and the

1

wiki offer project development examples and solutions to problems that can provide inspiration and assistance as you pursue your own projects.
The recipes in this chapter will get you started by explaining how to set up the development environment and how to compile and run an example sketch.
Source code containing computer instructions for controlling Arduino functionality is usually referred to as a sketch in the Arduino community.
The word sketch will be used throughout this book to refer to Arduino program code.

The Blink sketch, which comes with Arduino, is used as an example for recipes in this chapter, though the last recipe in the chapter goes further by adding sound and collecting input through some additional hardware, not just blinking the light built into the board. Chapter 2 covers how to structure a sketch for Arduino and provides an introduction to programming.
If you already know your way around Arduino basics, feel free to jump forward to later chapters. If you’re a first-time Arduino user, patience in these early recipes will pay off with smoother results later.

Arduino Software
Software programs, called sketches, are created on a computer using the Arduino integrated development environment (IDE). The IDE enables you to write and edit code and convert this code into instructions that Arduino hardware understands. The IDE also transfers those instructions to the Arduino board (a process called uploading).

Arduino Hardware
The Arduino board is where the code you write is executed. The board can only control and respond to electricity, so specific components are attached to it to enable it to interact with the real world. These components can be sensors, which convert some aspect of the physical world to electricity so that the board can sense it, or actuators, which get electricity from the board and convert it into something that changes the world. Examples of sensors include switches, accelerometers, and ultrasound distance sensors. Actuators are things like lights and LEDs, speakers, motors, and displays.
There are a variety of official boards that you can use with Arduino software and a wide range of Arduino-compatible boards produced by members of the community.
The most popular boards contain a USB connector that is used to provide power and connectivity for uploading your software onto the board. Figure 1-1 shows a basic board, the Arduino Uno.

2 | Chapter 1: Getting Started

Figure 1-1. Basic board: the Arduino Uno

You can get boards as small as a postage stamp, such as the Arduino Mini and Pro Mini; larger boards that have more connection options and more powerful processors, such as the Arduino Mega; and boards tailored for specific applications, such as the LilyPad for wearable applications, the Fio for wireless projects, and the Arduino Pro for embedded applications (standalone projects that are often battery-operated). Many other
Arduino-compatible boards are also available, including the following:
• Arduino Nano, a tiny board with USB capability, from Gravitech (http://store.grav itech.us/arna30wiatn.html) • Bare Bones Board, a low-cost board available with or without USB capability, from
Modern Device (http://www.moderndevice.com/products/bbb-kit)
• Boarduino, a low-cost breadboard-compatible board, from Adafruit Industries
(http://www.adafruit.com/)
• Seeeduino, a flexible variation of the standard USB board, from Seeed Studio
Bazaar (http://www.seeedstudio.com/)
• Teensy and Teensy++, tiny but extremely versatile boards, from PJRC (http://www
.pjrc.com/teensy/)
A comprehensive list of Arduino-compatible boards is available at http://www.freeduino
.org/.

See Also
An overview of Arduino boards: http://www.arduino.cc/en/Main/Hardware.
Online guides for getting started with Arduino are available at http://arduino.cc/en/
Guide/Windows for Windows, http://arduino.cc/en/Guide/MacOSX for Mac OS X, and http://www.arduino.cc/playground/Learning/Linux for Linux.

1.0 Introduction | 3

1.1 Installing the Integrated Development Environment (IDE)
Problem
You want to install the Arduino development environment on your computer.

Solution
The Arduino software for Windows, Mac, and Linux can be downloaded from http:// arduino.cc/en/Main/Software. The Windows download is a ZIP file. Unzip the file to any convenient directory—
Program Files/Arduino is a sensible place.
A free utility for unzipping files, called 7-Zip, can be downloaded from http://www.7-zip.org/. Unzipping the file will create a folder named Arduino-00 (where is the version number of the Arduino release you downloaded). The directory contains the executable file (named Arduino.exe), along with various other files and folders. Doubleclick the Arduino.exe file and the splash screen should appear (see Figure 1-2), followed by the main program window (see Figure 1-3). Be patient, as it can take some time for the software to load.

Figure 1-2. Arduino splash screen (version 0019 in Windows 7)

4 | Chapter 1: Getting Started

Figure 1-3. Arduino IDE main window (version 0019 in Windows 7)

The Arduino download for the Mac is a disk image (.dmg); double-click the file when the download is complete. The image will mount (it will appear like a memory stick on the desktop). Inside the disk image is the Arduino application. Copy this to somewhere convenient—the Applications folder is a sensible place. Double-click the application once you have copied it over (it is not a good idea to run it from the disk image).
The splash screen will appear, followed by the main program window.
Linux installation varies depending on the Linux distribution you are using. See the
Arduino wiki for information (http://www.arduino.cc/playground/Learning/Linux).
To enable the Arduino development environment to communicate with the board, you need to install drivers.

1.1 Installing the Integrated Development Environment (IDE) | 5

On Windows, use the USB cable to connect your PC and the Arduino board and wait for the Found New Hardware Wizard to appear. If you are using Windows Vista or
Windows 7 and are online, you can let the wizard search for drivers and they will install automatically. On Windows XP, you should specify the location of the drivers. Use the file selector to navigate to the drivers directory, located in the directory where you unzipped the Arduino files. When the driver has installed, the Found New Hardware
Wizard will appear again, saying a new serial port has been found. Follow the same process as before.
It is important that you go through the sequence of steps to install the drivers two times, or the software will not be able to communicate with the board.

On the Mac, the latest Arduino boards, such as the Uno, can be used without additional drivers, but if you are using earlier boards, you will need to install driver software. There is a package named FTDIUSBSerialDriver, with a range of numbers after it, inside the disk image. Double-click this and the installer will take you through the process. You will need to know an administrator password to complete the process.
On Linux, most distributions have the driver already installed, but follow the Linux link given in this chapter’s introduction for specific information for your distribution.

Discussion
If the software fails to start, check the troubleshooting section of the Arduino website, http://arduino.cc/en/Guide/Troubleshooting, for help solving installation problems.

See Also
Online guides for getting started with Arduino are available at http://arduino.cc/en/
Guide/Windows for Windows, http://arduino.cc/en/Guide/MacOSX for Mac OS X, and http://www.arduino.cc/playground/Learning/Linux for Linux.

1.2 Setting Up the Arduino Board
Problem
You want to power up a new board and verify that it is working.

Solution
Plug the board into a USB port on your computer and check that the green LED power indicator on the board illuminates. Standard Arduino boards (Uno, Duemilanove, and
Mega) have a green LED power indicator located near the reset switch.

6 | Chapter 1: Getting Started

An orange LED near the center of the board (labeled “Pin 13 LED” in Figure 1-4) should flash on and off when the board is powered up (boards come from the factory preloaded with software to flash the LED as a simple check that the board is working).

Figure 1-4. Basic Arduino board (Uno and Duemilanove)

Discussion
If the power LED does not illuminate when the board is connected to your computer, the board is probably not receiving power.
The flashing LED (connected to digital output pin 13) is being controlled by code running on the board (new boards are preloaded with the Blink example sketch). If the pin 13 LED is flashing, the sketch is running correctly, which means the chip on the board is working. If the green power LED is on but the pin 13 LED is not flashing, it could be that the factory code is not on the chip; follow the instructions in Recipe 1.3 to load the Blink sketch onto the board to verify that the board is working. If you are not using a standard board, it may not have a built-in LED on pin 13, so check the documentation for details of your board.

See Also
Online guides for getting started with Arduino are available at http://arduino.cc/en/
Guide/Windows for Windows, http://arduino.cc/en/Guide/MacOSX for Mac OS X, and http://www.arduino.cc/playground/Learning/Linux for Linux.
A troubleshooting guide can be found at http://arduino.cc/en/Guide/Troubleshooting.
1.2 Setting Up the Arduino Board | 7

1.3 Using the Integrated Development Environment (IDE) to
Prepare an Arduino Sketch
Problem
You want to get a sketch and prepare it for uploading to the board.

Solution
Use the Arduino IDE to create, open, and modify sketches that define what the board will do. You can use buttons along the top of the IDE to perform these actions (shown in Figure 1-5), or you can use the menus or keyboard shortcuts (shown in Figure 1-6).
The Sketch Editor area is where you view and edit code for a sketch. It supports common text editing keys such as Ctrl-F (⌘+F on a Mac) for find, Ctrl-Z (⌘+Z on a Mac) for undo, Ctrl-C (⌘+C on a Mac) to copy highlighted text, and Ctrl-V (⌘+V on a Mac) to paste highlighted text.
Figure 1-6 shows how to load the Blink sketch (the sketch that comes preloaded on a new Arduino board).
After you’ve started the IDE, go to the File→Examples menu and select 1.Basics→Blink, as shown in Figure 1-6. The code for blinking the built-in LED will be displayed in the
Sketch Editor window (refer to Figure 1-5).
Before the code can be sent to the board, it needs to be converted into instructions that can be read and executed by the Arduino controller chip; this is called compiling. To do this, click the compile button (the top-left button with a triangle inside), or select
Sketch→Verify/Compile.
You should see a message that reads “Compiling...” in the message area below the text editing window. After a second or two, a message that reads “Done Compiling” will appear. The black console area will contain the following additional message:
Binary sketch size: 1008 bytes (of a 32256 byte maximum)

The exact message may differ depending on the Arduino version; it is telling you the size of the sketch and the maximum size that your board can accept.

8 | Chapter 1: Getting Started

Figure 1-5. Arduino IDE

Discussion
Source code for Arduino is called a sketch. The process that takes a sketch and converts it into a form that will work on the board is called compilation. The IDE uses a number of command-line tools behind the scenes to compile a sketch. For more information on this, see Recipe 17.1.

1.3 Using the Integrated Development Environment (IDE) to Prepare an Arduino Sketch | 9

Figure 1-6. IDE menu (selecting the Blink example sketch)

The final message telling you the size of the sketch indicates how much program space is needed to store the controller instructions on the board. If the size of the compiled sketch is greater than the available memory on the board, the following error message is displayed:
Sketch too big; see http://www.arduino.cc/en/Guide/Troubleshooting#size for tips on reducing it.

If this happens, you need to make your sketch smaller to be able to put it on the board, or get a board with higher capacity.

10 | Chapter 1: Getting Started

If there are errors in the code, the compiler will print one or more error messages in the console window. These messages can help identify the error—see Appendix D on software errors for troubleshooting tips.
To prevent accidental overwriting of the examples, the Arduino IDE does not allow you to save changes to the provided example sketches.
You must rename them using the Save As menu option. You can save sketches you write yourself with the Save button (see Recipe 1.5).

As you develop and modify a sketch, you should also consider using the File→Save As menu option and using a different name or version number regularly so that as you implement each bit, you can go back to an older version if you need to.
Code uploaded onto the board cannot be downloaded back onto your computer. Make sure you save your sketch code on your computer. You cannot save changes back to the example files; you need to use Save As and give the changed file another name.

See Also
Recipe 1.5 shows an example sketch. Appendix D has tips on troubleshooting software problems. 1.4 Uploading and Running the Blink Sketch
Problem
You want to transfer your compiled sketch to the Arduino board and see it working.

Solution
Connect your Arduino board to your computer using the USB cable. Load the Blink sketch into the IDE as described in Recipe 1.3.
Next, select Tools→Board from the drop-down menu and select the name of the board you have connected (if it is the standard Uno board, it is probably the first entry in the board list).
Now select Tools→Serial Port. You will get a drop-down list of available serial ports on your computer. Each machine will have a different combination of serial ports, depending on what other devices you have used with your computer.
On Windows, they will be listed as numbered COM entries. If there is only one entry, select it. If there are multiple entries, your board will probably be the last entry.

1.4 Uploading and Running the Blink Sketch | 11

On the Mac, your board will be listed twice if it is an Uno board:
/dev/tty.usbmodem-XXXXXXX
/dev/cu.usbmodem-XXXXXXX

If you have an older board, it will be listed as follows:
/dev/tty.usbserial-XXXXXXX
/dev/cu.usbserial-XXXXXXX

Each board will have different values for XXXXXXX. Select either entry.
Click on the upload button (in Figure 1-5, it’s the fifth button from the left), or choose
File→Upload to I/O board.
The software will compile the code, as in Recipe 1.3. After the software is compiled, it is uploaded to the board. If you look at your board, you will see the LED stop flashing, and two lights (labeled as Serial LEDs in Figure 1-4) just below the previously flashing
LED should flicker for a couple of seconds as the code uploads. The original light should then start flashing again as the code runs.

Discussion
For the IDE to send the compiled code to the board, the board needs to be plugged into the computer, and you need to tell the IDE which board and serial port you are using. When an upload starts, whatever sketch is running on the board is stopped (if you were running the Blink sketch, the LED will stop flashing). The new sketch is uploaded to the board, replacing the previous sketch. The new sketch will start running when the upload has successfully completed.
Older Arduino boards and some compatibles do not automatically interrupt the running sketch to initiate upload. In this case, you need to press the Reset button on the board just after the software reports that it is done compiling (when you see the message about the size of the sketch). It may take a few attempts to get the timing right between the end of the compilation and pressing the Reset button.

The IDE will display an error message if the upload is not successful. Problems are usually due to the wrong board or serial port being selected or the board not being plugged in.
If you have trouble identifying the correct port on Windows, try unplugging the board and then selecting Tools→Serial Port to see which COM port is no longer on the display list. Another approach is to select the ports, one by one, until you see the lights on the board flicker to indicate that the code is uploading.

12 | Chapter 1: Getting Started

See Also
The Arduino troubleshooting page: http://www.arduino.cc/en/Guide/Troubleshooting

1.5 Creating and Saving a Sketch
Problem
You want to create a sketch and save it to your computer.

Solution
To open an editor window ready for a new sketch, launch the IDE (see Recipe 1.3), go to the File menu, and select New. Paste the following code into the Sketch Editor window (it’s similar to the Blink sketch, but the blinks last twice as long): const int ledPin =

13;

// LED connected to digital pin 13

void setup()
{
pinMode(ledPin, OUTPUT);
}
void loop()
{
digitalWrite(ledPin, HIGH); delay(2000); digitalWrite(ledPin, LOW); delay(2000); }

//
//
//
//

set the LED on wait for two seconds set the LED off wait for two seconds

Compile the code by clicking the compile button (the top-left button with a triangle inside), or select Sketch→Verify/Compile (see Recipe 1.3).
Upload the code by clicking on the upload button, or choose File→Upload to I/O board
(see Recipe 1.4). After uploading, the LED should blink, with each flash lasting two seconds. You can save this sketch to your computer by clicking the Save button, or select
File→Save.
You can save the sketch using a new name by selecting the Save As menu option. A dialog box will open where you can enter the filename.

Discussion
When you save a file in the IDE, a standard dialog box for the operating system will open. It suggests that you save the sketch to a folder called Arduino in your My Documents folder (or your Documents folder on a Mac). You can replace the default sketch

1.5 Creating and Saving a Sketch | 13

name with a meaningful name that reflects the purpose of your sketch. Click Save to save the file.
The default name is the word sketch followed by the current date. Sequential letters starting from a are used to distinguish sketches created on the same day. Replacing the default name with something meaningful helps you to identify the purpose of a sketch when you come back to it later.

If you use characters that the IDE does not allow (e.g., the space character), the IDE will automatically replace these with valid characters.
Arduino sketches are saved as plain text files with the extension .pde. They are automatically saved in a folder with the same name as the sketch.
You can save your sketches to any folder on your computer, but if you use the default folder (the Arduino folder in your Documents folder) your sketches will automatically appear in the Sketchbook menu of the Arduino software and be easier to locate.
If you have edited one of the examples from the Arduino download, you will not be able to save the changed file using the same filename. This preserves the standard examples intact. If you want to save a modified example, you will need to select another location for the sketch.

After you have made changes, you will see a dialog box asking if you want to save the sketch when a sketch is closed.
The § symbol following the name of the sketch in the top bar of the IDE window indicates that the sketch code has changes that have not yet been saved on the computer. This symbol is removed when you save the sketch. The Arduino software does not provide any kind of version control, so if you want to be able to revert to older versions of a sketch, you can use Save As regularly and give each revision of the sketch a slightly different name.
Frequent compiling as you modify or add code is a good way to check for errors as you write your code. It will be easier to find and fix any errors because they will usually be associated with what you have just written.
Once a sketch has been uploaded onto the board there is no way to download it back to your computer. Make sure you save any changes to your sketches that you want to keep.

14 | Chapter 1: Getting Started

If you open sketches you get from other people that are not in a folder with the same name as the sketch, the IDE will tell you and you can click OK to put them in a folder with the same name.
Sketches must be located in a folder with the same name as the sketch.
The IDE will create the folder automatically when you save a new sketch.

1.6 Using Arduino
Problem
You want to get started with a project that is easy to build and fun to use.

Solution
This recipe provides a taste of some of the techniques that are covered in detail in later chapters. The sketch is based on the LED blinking code from the previous recipe, but instead of using a fixed delay, the rate is determined by a light-sensitive sensor called a light dependent resistor or LDR (see Recipe 6.2). Wire the LDR as shown in Figure 1-7.

Figure 1-7. Arduino with light dependent resistor

The following sketch reads the light level of an LDR connected to analog pin 0. The light level striking the LDR will change the blink rate of the internal LED connected to pin 13:
1.6 Using Arduino | 15

const int ledPin = 13; const int sensorPin = 0;

// LED connected to digital pin 13
// connect sensor to analog input 0

void setup()
{
pinMode(ledPin, OUTPUT); // enable output on the led pin
}
void loop()
{
int rate = analogRead(sensorPin);
// read the analog input
Serial.println(rate);
rate = map(rate, 200,800,minDuration, maxDuration); // convert to blink rate digitalWrite(ledPin, HIGH);
// set the LED on delay(rate); // wait duration dependent on light level digitalWrite(ledPin, LOW);
// set the LED off delay(rate); }

Discussion
The value of the 4.7K resistor is not critical. Anything from 1K to 10K can be used. The light level on the LDR will change the voltage level on analog pin 0. The analogRead command (see Chapter 6) provides a value that ranges from around 200 when the LDR is dark to 800 or so when it is very bright. This value determines the duration of the
LED on and off times, so the blink rate increases with light intensity.
You can scale the blink rate by using the Arduino map function as follows: const int ledPin = 13; const int sensorPin = 0;

// LED connected to digital pin 13
// connect sensor to analog input 0

// the next two lines set the min and max delay between blinks const int minDuration = 100; // minimum wait between blinks const int maxDuration = 1000; // maximum wait between blinks void setup()
{
pinMode(ledPin, OUTPUT);
}

// enable output on the led pin

void loop()
{
int rate = analogRead(sensorPin);
// read the analog input
// the next line scales the blink rate between the min and max values rate = map(rate, 200,800,minDuration, maxDuration); // convert to blink rate digitalWrite(ledPin, HIGH);
// set the LED on delay(rate); // wait duration dependent on light level digitalWrite(ledPin, LOW);
// set the LED off delay(rate); }

Recipe 5.7 provides more details on using the map function to scale values.

16 | Chapter 1: Getting Started

If you want to view the value of the rate variable on your computer, you can print this to the Arduino Serial Monitor as shown in the revised loop code that follows. The sketch will display the blink rate in the Serial Monitor. You open the Serial Monitor window in the Arduino IDE (see Chapter 4 for more on using the Serial Monitor): const int ledPin = 13; const int sensorPin = 0;

// LED connected to digital pin 13
// connect sensor to analog input 0

// the next two lines set the min and max delay between blinks const int minDuration = 100; // minimum wait between blinks const int maxDuration = 1000; // maximum wait between blinks void setup()
{
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}

// enable output on the led pin
// initialize Serial

void loop()
{
int rate = analogRead(sensorPin);
// read the analog input
// the next line scales the blink rate between the min and max values rate = map(rate, 200,800,minDuration, maxDuration); // convert to blink rate
Serial.println(rate);
// print rate to serial monitor digitalWrite(ledPin, HIGH);
// set the LED on delay(rate); // wait duration dependent on light level digitalWrite(ledPin, LOW);
// set the LED off delay(rate); }

You can use the LDR to control the pitch of a sound by connecting a small speaker to the pin, as shown in Figure 1-8.

Figure 1-8. Connections for a speaker with the LDR circuit

1.6 Using Arduino | 17

You will need to increase the on/off rate on the pin to a frequency in the audio spectrum.
This is achieved, as shown in the following code, by dividing the rate by 100 in the line after the map function: const int ledPin = 13; const int sensorPin = 0;

// LED connected to digital pin 13
// connect sensor to analog input 0

const int minDuration = 100; // minimum wait between blinks const int maxDuration = 1000; // maximum wait between blinks void setup()
{
pinMode(ledPin, OUTPUT); // enable output on the led pin
}
void loop()
{
int sensorReading = analogRead(sensorPin);
// read the analog input int rate = map(sensorReading, 200,800,minDuration, maxDuration); rate = rate / 100;
// add this line for audio frequency digitalWrite(ledPin, HIGH);
// set the LED on delay(rate); // wait duration dependent on light level digitalWrite(ledPin, LOW);
// set the LED off delay(rate); }

See Also
See Chapter 9 for more on creating sound with Arduino.

18 | Chapter 1: Getting Started

Download from Wow! eBook

CHAPTER 2

Making the Sketch Do Your Bidding

2.0 Introduction
Though much of an Arduino project will involve integrating the Arduino board with supporting hardware, you need to be able to tell the board what to do with the rest of your project. This chapter introduces core elements of Arduino programming, showing nonprogrammers how to use common language constructs and providing an overview of the language syntax for readers who are not familiar with C or C++, the language being used.
Since making the examples interesting requires making Arduino do something, the recipes use physical capabilities of the board that are explained in detail in later chapters. If any of the code in this chapter is not clear, feel free to jump forward, particularly to Chapter 4 for more on serial output and Chapter 5 for more on using digital and analog pins. You don’t need to understand all the code in the examples, though, to see how to perform the specific capabilities that are the focus of the recipes. Here are some of the more common functions used in the examples that are covered in the next few chapters: Serial.println(value);

Prints the value to the Serial Monitor on your computer; see Recipe 4.1 pinMode(pin, mode);

Configures a digital pin to read (input) or write (output) a digital value; see the introduction to Chapter 5 digitalRead(pin); Reads a digital value (HIGH or LOW) on a pin set for input; see Recipe 5.1 digitalWrite(pin, value);

Writes the digital value (HIGH or LOW) to a pin set for output; see Recipe 5.1

19

2.1 Structuring an Arduino Program
Problem
You are new to programming and want to understand the building blocks of an Arduino program. Solution
Programs for Arduino are usually referred to as sketches, to emphasize the agile nature of development. The terms sketch and program are interchangeable. Sketches contain code—the instructions the board will carry out. Code that needs to run only once (such as to set up the board for your application) should be placed in the setup function.
Code to be run continuously after the initial setup has finished goes into the loop function. Here is a typical sketch: const int ledPin =

13;

// LED connected to digital pin 13

// The setup() method runs once, when the sketch starts void setup()
{
pinMode(ledPin, OUTPUT);
// initialize the digital pin as an output
}
// the loop() method runs over and over again, void loop()
{
digitalWrite(ledPin, HIGH);
// turn the LED on delay(1000); // wait a second digitalWrite(ledPin, LOW);
// turn the LED off delay(1000); // wait a second
}

When the board finishes uploading the code, or is turned on once it contains this code, it starts at the top of the sketch and carries out the instructions sequentially. It runs the code in setup once and then goes through the code in loop. When it gets to the end of loop (marked by the closing bracket, }) it goes back to the beginning of loop.

Discussion
This example continuously flashes an LED by writing HIGH and LOW outputs to a pin.
See Chapter 5 to learn more about using Arduino pins. When the sketch begins, the code in setup sets the pin mode (so it’s capable of lighting an LED). After the code in setup is completed, the code in loop is repeatedly called (to flash the LED) for as long as the Arduino board is powered on.
You don’t need to know this to write Arduino sketches, but experienced C/C++ programmers may wonder where the expected main() entry point function has gone. It’s there, but it’s hidden under the covers by the Arduino build environment. The build

20 | Chapter 2: Making the Sketch Do Your Bidding

process creates an intermediate file that includes the sketch code and the following additional statements: int main(void)
{
init(); setup(); for (;;) loop(); return 0;
}

The first thing that happens is a call to an init() function that initializes the Arduino hardware. Next, the sketch’s setup() function is called. Finally, the loop() function is called over and over. Because the for loop never terminates, the return statement is never executed.

See Also
Chapter 17 and http://www.arduino.cc/en/Hacking/BuildProcess provide more on the build process.

2.2 Using Simple Primitive Types (Variables)
Problem
Arduino has different types of variables to efficiently represent values. You want to know how to select and use these Arduino data types.

Solution
Although the int (short for integer, a 16-bit value in Arduino) data type is the most common choice for the numeric values encountered in Arduino applications, you can use Table 2-1 to determine the data type that fits the range of values your application expects. Table 2-1. Arduino data types
Numeric types

Bytes

Range

Use

int

2

-32768 to 32767

Represents positive and negative integer values.

unsigned int

2

0 to 65535

Represents only positive values; otherwise, similar to int.

long

4

-2147483648 to
2147483647

Represents a very large range of positive and negative values.

unsigned long 4

4294967295

Represents a very large range of positive values.

2.2 Using Simple Primitive Types (Variables) | 21

Numeric types

Bytes

Range

Use

float

4

3.4028235E+38 to
-3.4028235E+38

Represents numbers with fractions; use to approximate realworld measurements.

double

4

Same as float

In Arduino, double is just another name for float.

boolean

1

false (0) or true (1)

Represents true and false values.

char

1

-128 to 127

Represents a single character. Can also represent a signed value between -128 and 127.

byte

1

0 to 255

Similar to char, but for unsigned values.

Other types string Represents arrays of chars (characters) typically used to contain text.

void

Used only in function declarations where no value is returned.

Discussion
Except in situations where maximum performance or memory efficiency is required, variables declared using int will be suitable for numeric values if the values do not exceed the range (shown in the first row in Table 2-1) and if you don’t need to work with fractional values. Most of the official Arduino example code declares numeric variables as int. But sometimes you do need to choose a type that specifically suits your application. Sometimes you need negative numbers and sometimes you don’t, so numeric types come in two varieties: signed and unsigned. unsigned values are always positive. Variables without the keyword unsigned in front are signed so that they can represent negative and positive values. One reason to use unsigned values is when the range of signed values will not fit the range of the variable (an unsigned variable has twice the capacity of a signed variable). Another reason programmers choose to use unsigned types is to clearly indicate to people reading the code that the value expected will never be a negative number. boolean types have two possible values: true or false. They are commonly used for things like checking the state of a switch (if it’s pressed or not). You can also use HIGH and LOW as equivalents to true and false where this makes more sense; digital
Write(pin, HIGH) is a more expressive way to turn on an LED than digitalWrite(pin, true) or digitalWrite(pin,1), although all of these are treated identically when the

sketch actually runs, and you are likely to come across all of these forms in code posted on the Web.

See Also
The Arduino reference at http://www.arduino.cc/en/Reference/HomePage provides details on data types.

22 | Chapter 2: Making the Sketch Do Your Bidding

2.3 Using Floating-Point Numbers
Problem
Floating-point numbers are used for values expressed with decimal points (this is the way to represent fractional values). You want to calculate and compare these values in your sketch.

Solution
The following code shows how to declare floating-point variables, illustrates problems you can encounter when comparing floating-point values, and demonstrates how to overcome them:
/*
* Floating-point example
* This sketch initialized a float value to 1.1
* It repeatedly reduces the value by 0.1 until the value is 0
*/
float

value = 1.1;

void setup()
{
Serial.begin(9600);
}
void loop()
{
value = value - 0.1;
// reduce value by 0.1 each time through the loop if( value == 0)
Serial.println("The value is exactly zero"); else if(fabs(value) < .0001) // function to take the absolute value of a float
Serial.println("The value is close enough to zero"); else Serial.println(value);
}

delay(100);

Discussion
Floating-point math is not exact, and values returned can have a small approximation error. The error occurs because floating-point values cover a huge range, so the internal representation of the value can only hold an approximation. Because of this, you need to test if the values are within a range of tolerance rather than exactly equal.
The output from this sketch is as follows:
1.00
0.90

2.3 Using Floating-Point Numbers | 23

0.80
0.70
0.60
0.50
0.40
0.30
0.20
0.10
The value is close enough to zero
-0.10
-0.20

The output continues to produce negative numbers.
You may expect the loop to stop after value is 0.1 and then 0.1 is subtracted from this.
But value never equals zero; it gets very close, but that is not good enough to pass the test if (value == 0). This is because the only memory-efficient way that floating-point numbers can contain the huge range in values they can represent is by storing an approximation of the number.
The solution to this is to check if a variable is close to the desired value, as shown in the code in this recipe’s Solution: else if(fabs(value) < .0001) // function to take absolute value of a float
Serial.println("The value is close enough to zero");

This tests if the variable value is within 0.0001 of the desired target and prints a message if so. The function named fabs (short for floating-point absolute value) returns the absolute value of a floating-point variable. The function returns the magnitude of the value, and if this is within 0.0001 of 0, the code will print the message that the values are close enough.
Floating point approximates numbers because it only uses 32 bits to hold all values within a huge range. Eight bits are used for the decimal multiplier (the exponent), and that leaves 24 bits for the sign and value—only enough for seven significant decimal digits.
Although float and double are exactly the same on Arduino, doubles do have a higher precision on many other platforms. If you are importing code that uses float and double from another platform, check that there is sufficient precision for your application.

See Also
The Arduino reference for float: http://www.arduino.cc/en/Reference/Float

24 | Chapter 2: Making the Sketch Do Your Bidding

2.4 Working with Groups of Values
Problem
You want to create and use a group of values (called arrays). The arrays may be a simple list or they could have two or more dimensions. You want to know how to determine the size of the array and how to access the elements in the array.

Solution
This sketch creates two arrays: an array of integers for pins connected to switches and an array of pins connected to LEDs, as shown in Figure 2-1:
/*
array sketch an array of switches controls an array of LEDs see Chapter 5 for more on using switches see Chapter 7 for information on LEDs
*/
int inputPins[] = {2,3,4,5}; // create an array of pins for switch inputs int ledPins[] = {10,11,12,13};

// create array of output pins for LEDs

void setup()
{
for(int index = 0; index < 4; index++)
{
pinMode(ledPins[index], OUTPUT); pinMode(inputPins[index], INPUT); digitalWrite(inputPins[index],HIGH); }

} void loop(){ for(int index = 0; index < 4; index++)
{
int val = digitalRead(inputPins[i]); if (val == LOW)
{
digitalWrite(ledPins[index], HIGH);
}
else
{
digitalWrite(ledPins[i], LOW);
}
}
}

// declare LED as output
// declare pushbutton as input
// enable pull-up resistors
//(see Recipe 5.2)

// read input value
// check if the switch is pressed
// turn LED on if switch is pressed

// turn LED off

2.4 Working with Groups of Values | 25

Figure 2-1. Connections for LEDs and switches

Discussion
Arrays are collections of consecutive variables of the same type. Each variable in the collection is called an element. The number of elements is called the dimension of the array. The preceding example demonstrates a common use of arrays in Arduino code: storing a collection of pins. Here the pins connect to switches and LEDs (a topic covered in more detail in Chapter 5). The important parts of this example are the declaration of the array and access to the array elements.
The following line of code declares (creates) an array of integers with four elements and initializes each element. The first element is set equal to 2, the second to 3, and so on: int inputPins[] = {2,3,4,5};

26 | Chapter 2: Making the Sketch Do Your Bidding

If you don’t need to initialize the values when you declare an array (perhaps the values will only be available when the sketch is running) you can declare the array as follows: int array[4];

This declares an array of four elements with the initial value of each element set to zero.
The number within the square brackets ([]) is the dimension, and this sets the number of elements. This array has a dimension of four and can hold, at most, four integer values. The dimension can be omitted if array declaration contains initializers (as shown in the first example) because the compiler figures out how big to make the array by counting the number of initializers.
The first element of the array is element[0]: int firstElement = inputPin[0];

// this is the first element

The last element is one less than the dimension, so in the preceding example, with a dimension of four, the last element is element 3:
Int lastElement = inputPin[3]; // this is the last element

It may seem odd that an array with a dimension of four has the last element accessed using array[3], but because the first element is array[0], the four elements are: array[0],array[1],array[2],array[3] In the previous sketch, the four elements are accessed using a for loop: for(int index = 0; index < 4; index++)
{
//get the pin number by accessing each element in the pin arrays pinMode(ledPins[index], OUTPUT);
// declare LED as output pinMode(inputPins[index], INPUT);
// declare pushbutton as input
}

This loop will step through the variable index with values starting at 0 and ending at
3. It is a common mistake to accidentally access an element that is beyond the actual dimension of the array. This is a bug that can have many different symptoms and care must be taken to avoid it. One way to keep your loops under control is to set the dimension of an array by using a constant as follows: const int PIN_COUNT = 4; // define a constant for the number of elements int inputPins[PIN_COUNT] = {2,3,4,5}; for(int index = 0; index < PIN_COUNT; index++) pinMode(inputPins[index], INPUT);

The compiler will not report an error if you accidentally try to store or read beyond the size of the array. You must be careful that you only access elements that are within the bounds you have set. Using a constant to set the dimension of an array and in code referring to its elements helps your code stay within the bounds of the array.

2.4 Working with Groups of Values | 27

Another common use of arrays is to hold a string of text characters. In Arduino code, these are called character strings (strings for short). A character string consists of one or more characters, followed by the null character (the value 0) to indicate the end of the string.
The null at the end of a character string is not the same as the character
0. The null has an ASCII value of 0, whereas 0 has an ASCII value of 48.

Methods to use strings are covered in Recipes 2.5 and 2.6.

See Also
Recipe 5.2; Recipe 7.1

2.5 Using Arduino String Functionality
Problem
You want to manipulate text. You need to copy it, add bits together, and determine the number of characters.

Solution
Recipe 2.4 describes Arduino arrays in general. Text is stored in arrays of characters.
They are usually called strings. Arduino has an added capability for using an array of characters called String that can store and manipulate text strings.
The word String with an uppercase S refers to the Arduino text capability provided by the Arduino String library. The word string with a lowercase s refers to the group of characters rather than the Arduino String functionality. This recipe demonstrates how to use Arduino strings.
The String capability was introduced in version 19 of Arduino. If you are using an older version, you can use the TextString library; see the link at the end of this recipe.

Load the following sketch onto your board, and open the Serial Monitor to view the results: 28 | Chapter 2: Making the Sketch Do Your Bidding

/*
Basic_Strings sketch
*/
String text1 = "This string";
String text2 = " has more text";
String text3; // to be assigned within the sketch void setup()
{
Serial.begin(9600);
Serial.print( text1);
Serial.print(" is ");
Serial.print(text1.length());
Serial.println(" characters long.");
Serial.print("text2 is ");
Serial.print(text2.length());
Serial.println(" characters long."); text1.concat(text2); Serial.println("text1 now contains: ");
Serial.println(text1);
} void loop()
{
}

Discussion
This sketch creates two variables of type String, called message and anotherMessage.
Variables of type String have built-in capabilities for manipulating text. The statement message.length() returns (provides the value of) the length (number of characters) in the string message. message.concat(anotherMessage) combines the contents of strings; in this case, it appends the contents of anotherMessage to the end of message (concat is short for

concatenate).
The Serial Monitor will display the following:
This string is 11 characters long. text2 is 14 characters long. text1 now contains:
This string has more text

Another way to combine strings is to use the string addition operator. Add these two lines to the end of the setup code: text3 = text1 + " and more";
Serial.println(text3);

2.5 Using Arduino String Functionality | 29

The new code will result in the Serial Monitor adding the following line to the end of the display:
This is a string with more text and more

You can use the indexOf and lastIndexOf functions to find an instance of a particular character in a string.
Because the String class is a new addition to Arduino, you will come across a lot of code that uses arrays of characters rather than the
String type. See Recipe 2.6 for more on using arrays of characters without the help of the Arduino String functionality.

If you see a line such as the following: char oldString[] = "this is a character array";

the code is using C-style character arrays (see Recipe 2.6). If the declaration looks like this: String newString = "this is a string object";

the code uses Arduino Strings. To convert a C-style character array to an Arduino
String, just assign the contents of the array to the String object: char oldString[] = "I want this character array in a String object";
String newsString = oldString;

See Also
The Arduino distribution provides String example sketches.
Tutorials for the new String library are available at http://arduino.cc/en/Tutorial/Home
Page, and a tutorial for the original String library is available at http://www.arduino.cc/ en/Tutorial/TextString. 2.6 Using C Character Strings
Problem
You want to understand how to use raw character strings: you want to know how to create a string, find its length, and compare, copy, or append strings. The C language does not support the Arduino-style String capability, so you want to understand code written to operate with primitive character arrays.

30 | Chapter 2: Making the Sketch Do Your Bidding

Solution
Arrays of characters are sometimes called character strings (or simply strings for short).
Recipe 2.5 describes Arduino arrays in general. This recipe describes functions that operate on character strings.
You declare strings like this: char StringA[8]; // declare a char StringB[8] = "Arduino";
"Arduino";
char StringC[16] = "Arduino"; char StringD[ ] = "Arduino"; and calculates size

string of up to 7 chars plus terminating null
// as above and init(ialize) the string to
// as above, but string has room to grow
// the compiler inits the string

Use strlen (short for string length) to determine the number of characters before the null: int length = strlen(string);

// return the number of characters in the string

length will be 0 for StringA and 7 for the other strings shown in the preceding code.
The null that indicates the end of the string is not counted by strlen.

Use strcpy (short for string copy) to copy one string to another: strcpy(destination, source);

// copy string source to destination

Use strncpy to limit the number of characters to copy (useful to prevent writing more characters than the destination string can hold). You can see this used in Recipe 2.7: strncpy(destination, source, 6); destination // copy up to 6 characters from source to

Use strcat (short for string concatenate) to append one string to the end of another: strcat(destination, source); destination string

// append source string to the end of the

Always make sure there is enough room in the destination when copying or concatenating strings. Don’t forget to allow room for the terminating null. Use strcmp (short for string compare) to compare two strings. You can see this used in
Recipe 2.7: if(strcmp(str, "Arduino") == 0)
// do something if the variable str is equal to "Arduino"

Discussion
Text is represented in the Arduino environment using an array of characters called strings. A string consists of a number of characters followed by a null (the value 0). The null is not displayed, but it is needed to indicate the end of the string to the software.
2.6 Using C Character Strings | 31

See Also
See one of the many online C/C++ reference pages, such as http://www.cplusplus.com/ reference/clibrary/cstring/ and http://www.cppreference.com/wiki/string/c/start.

2.7 Splitting Comma-Separated Text into Groups
Problem
You have a string that contains two or more pieces of data separated by commas (or any other separator). You want to split the string so that you can use each individual part. Solution
This sketch prints the text found between each comma:
/*
* SplitSplit sketch
* split a comma-separated string
*/
String int message= "Peter,Paul,Mary"; // an example string commaPosition; // the position of the next comma in the string

void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.println(message);
// show the source string do { commaPosition = message.indexOf(','); if(commaPosition != -1)
{
Serial.println( message.substring(0,commaPosition)); message = message.substring(commaPosition+1, message.length());
}
else
{ // here after the last comma is found if(message.length() > 0)
Serial.println(message); // if there is text after the last comma, print it
}
} while(commaPosition >=0); delay(5000); }

32 | Chapter 2: Making the Sketch Do Your Bidding

The Serial Monitor will display the following:
Peter,Paul,Mary
Peter
Paul

Discussion
This sketch uses String functions to extract text from between commas. The following code: commaPosition = message.indexOf(',');

sets the variable commaPosition with the position of the first comma in the String named message (it will be set to -1 if no comma is found). If there is a comma, the substring function is used to print the text from the beginning of the string to the position of the comma. The text that was printed is removed from message in this line: message = message.substring(commaPosition+1, message.length());

substring returns a string starting from commaPosition+1 (the position just after the first

comma) up to the length of the message. This results in that message containing only the text following the first comma. This is repeated until no more commas are found
(commaIndex will be equal to -1).
If you are an experienced programmer, you can also use the low-level functions that are part of the standard C library. The following sketch has similar functionality to the preceding one using Arduino strings:
/*
* SplitSplit sketch
* split a comma-separated string
*/
const int MAX_STRING_LEN = 20; // set this to the largest string you'll process char stringList[] = "Peter,Paul,Mary"; // an example string char stringBuffer[MAX_STRING_LEN+1]; output // a static buffer for computation and

void setup()
{
Serial.begin(9600);
}
void loop()
{
char *str; char *p; strncpy(stringBuffer, stringList, MAX_STRING_LEN);
Serial.println(stringBuffer);
for( str = strtok_r(stringBuffer, ",", &p); str; str = strtok_r(NULL, ",", &p)
)

//
//
//
//
//

copy source string show the source string split using comma loop while str is not null get subsequent tokens

2.7 Splitting Comma-Separated Text into Groups | 33

{

}
}

Serial.println(str); if(strcmp(str, "Paul") == 0)
Serial.println("found Paul"); delay(5000); The core functionality comes from the function named strtok_r (the name of the version of strtok that comes with the Arduino compiler). The first time you call strtok_r you pass it the string you want to tokenize (separate into individual values).
But strtok_r overwrites the characters in this string each time it finds a new token, so it’s best to pass a copy of the string as shown in this example. Each call that follows uses a NULL to tell the function that it should move on to the next token. In this example, each token is printed to the serial port and also compared to a target string ("Paul").
If your tokens consist only of numbers, see Recipe 4.5. This shows how to extract numeric values separated by commas in a stream of serial characters.

See Also
Recipe 2.5; online references to the C/C++ functions strtok_r and strcmp

2.8 Converting a Number to a String
Problem
You need to convert a number to a string, perhaps to show the number on an LCD or other display.

Solution
The String variable will convert numbers to strings of characters automatically. You can use literal values, or the contents of a variable. For example, the following code will work:
String myNumber = 1234;

As will this: int value = 127
String myReadout = "The reading was "; myReadout.concat(value); Or this: int value = 127;
String myReadout = "The reading was "; myReadout += value;

34 | Chapter 2: Making the Sketch Do Your Bidding

Discussion
If you are converting a number to display as text on an LCD or serial device, the simplest solution is to use the conversion capability built into the LCD and Serial libraries (see
Recipe 4.2). But perhaps you are using a device that does not have this built-in support
(see Chapter 13) or you want to manipulate the number as a string in your sketch.
The Arduino String class automatically converts numerical values when they are assigned to a String variable. You can combine (concatenate) numeric values at the end of a string using the concat function or the string + operator.
The + operator is used with number types as well as strings, but it behaves differently with each.

The following code results in number having a value of 13: int number = 12; number += 1;

With a String, as shown here:
String textNumber = 12 textNumber += 1;

textNumber is the text string "121".

Prior to the introduction of the String class, it was common to find Arduino code using the itoa or ltoa function. The names come from “integer to ASCII” (itoa) and “long to ASCII” (ltoa). The String version described earlier is easier to use, but the following will help if you want to understand code that uses itoa or ltoa.
These functions take three parameters: the value to convert, the buffer that will hold the output string, and the number base (10 for a decimal number, 16 for hex, and 2 for binary). The following sketch illustrates how to convert numeric values using ltoa:
/*
* NumberToString
* Creates a string from a given number
*/
void setup()
{
Serial.begin(9600);
}
char buffer[12];

// long data type has 11 characters (including the
// minus sign) and a terminating null

2.8 Converting a Number to a String | 35

void loop()
{
long value = 12345; ltoa(value, buffer, 10);
Serial.print( value);
Serial.print(" has ");
Serial.print(strlen(buffer));
Serial.println(" digits"); value = 123456789; ltoa(value, buffer, 10);
Serial.print( value);
Serial.print(" has ");
Serial.print(strlen(buffer));
Serial.println(" digits"); delay(1000); }

Your buffer must be large enough to hold the maximum number of characters in the string. For 16-bit integers, that is seven characters (five digits, a possible minus sign, and a terminating 0 that always signifies the end of a string); 32-bit long integers need
12 character buffers (10 digits, the minus sign, and the terminating 0). No warning is given if you exceed the buffer size; this is a bug that can cause all kinds of strange symptoms, because the overflow will corrupt some other part of memory that may be used by your program. The easiest way to handle this is to always use a 12-character buffer and always use ltoa because this will work on both 16-bit and 32-bit values.

2.9 Converting a String to a Number
Problem
You need to convert a string to a number. Perhaps you have received a value as a string over a communication link and you need to use this as an integer or floating-point value.

Solution
There are a number of ways to solve this. If the string is received as serial data, it can be converted on the fly as each character is received. See Recipe 4.3 for an example of how to do this using the serial port.
Another approach to converting text strings representing numbers is to use the C language conversion function called atoi (for int variables) or atol (for long variables).
This code fragment terminates the incoming digits on any character that is not a digit
(or if the buffer is full): int blinkRate; char strValue[6]; int index = 0;

//
//
//
//

blink rate stored in this variable must be big enough to hold all the digits and the
0 that terminates the string the index into the array storing the received digits

36 | Chapter 2: Making the Sketch Do Your Bidding

void loop()
{
if( Serial.available())
{
char ch = Serial.read(); if(index < 5 && ch >= '0' && ch 0 ) // repeat until count is no longer greater than zero
{
digitalWrite(13,HIGH); delay(500); digitalWrite(13,LOW); delay(500); count = count -1; // decrement count
}
}

That version checks to see if the value of count is 0. If not, it blinks the LED and then reduces the value of count by one. This will be repeated until count is no longer greater than 0.

38 | Chapter 2: Making the Sketch Do Your Bidding

A parameter is sometimes referred to as an argument in some documentation. For practical purposes, you can treat these terms as meaning the same thing.

Here is an example sketch that takes a parameter and returns a value. The parameter determines the LED on and off times (in milliseconds). The function continues to flash the LED until a button is pressed, and the number of times the LED flashed is returned from the function:
/*
blink3 sketch demonstrates calling a function with a parameter and returning a value uses the same wiring as the pull-up sketch from Recipe 5.2
The LED flashes when the program starts and stops when a switch connected to pin 2 is pressed the program prints the number of times the LED flashes.
*/
const int ledPin = 13; const int inputPin = 2;

// output pin for the LED
// input pin for the switch

void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin, INPUT); digitalWrite(inputPin,HIGH); // use internal pull-up resistor (Recipe 5.2)
Serial.begin(9600);
} void loop(){
Serial.println("Press and hold the switch to stop blinking"); int count = blink3(250); // blink the LED 250ms on and 250ms off
Serial.print("The number of times the switch blinked was ");
Serial.println(count);
}
// blink an LED using the given delay period
// return the number of times the LED flashed int blink3(int period)
{
int result = 0; int switchVal = HIGH; //with pull-ups, this will be high when switch is up while(switchVal == HIGH) // repeat this loop until switch is pressed
// (it will go low when pressed)
{
digitalWrite(13,HIGH); delay(period); digitalWrite(13,LOW); delay(period); result = result + 1; // increment the count switchVal = digitalRead(inputPin); // read input value
}

2.10 Structuring Your Code into Functional Blocks | 39

}

// here when switchVal is no longer HIGH because the switch is pressed return result; // this value will be returned

Discussion
The code in this recipe’s Solution illustrates the three forms of function call that you will come across. blink1 has no parameter and no return value. Its form is: void blink1()
{
// implementation code goes here...
}

blink2 takes a single parameter but does not return a value: void blink2(int count)
{
// implementation code goes here...
}

blink3 has a single parameter and returns a value: int blink3(int period)
{
// implementation code goes here...
}

The data type that precedes the function name indicates the return type (or no return type if void). When declaring the function (writing out the code that defines the function and its action), you do not put a semicolon following the parenthesis at the end. When you use (call) the function, you do need a semicolon at the end.
Most of the functions you come across will be some variation on these forms. For example, here is a function that takes a parameter and returns a value: int sensorPercent(int pin)
{
int percent;

}

val = analogRead(pin); // read the sensor (ranges from 0 to 1023) percent = map(val,0,1023,0,100); // percent will range from 0 to 100. return percent;

The function name is sensorPercent. It is given an analog pin number to read and returns the value as a percent (see Recipe 5.7 for more on analogRead and map). The int in front of the declaration tells the compiler (and reminds the programmer) that the function will return an integer. When creating functions, choose the return type appropriate to the action the function performs. This function returns an integer value from 0 to 100, so a return type of int is appropriate.

40 | Chapter 2: Making the Sketch Do Your Bidding

It is recommended that you give your functions meaningful names, and it is a common practice to combine words by capitalizing the first letter of each word, except for the first word. Use whatever style you prefer, but it helps others who read your code if you keep your naming style consistent. sensorPercent has a parameter called pin (when the function is called, pin is given the

value that is passed to the function).
The body of the function (the code within the brackets) performs the action you want— here it reads a value from an analog input pin and maps it to a percentage. In the preceding example, the percentage is temporarily held in a variable called percent. The following statement causes the value held in the temporary variable percent to be returned to the calling application: return percent;

The same functionality can be achieved without using a temporary variable: int sensorPercent(int pin)
{
val = analogRead(pin); // read the sensor (ranges from 0 to 1023) return map(val,0,1023,0,100); // percent will ranges from 0 to 100.
}

Here is how the function can be called:
// print the percent value of 6 analog pins for(int sensorPin = 0; sensorPin < 6; sensorPin++)
{
Serial.print("Percent of sensor on pin ");
Serial.print(sensorPin);
Serial.print(" is "); int val = sensorPercent(sensorPin);
Serial.print(val);
}

See Also
The Arduino function reference page: http://www.arduino.cc/en/Reference/FunctionDe claration 2.11 Returning More Than One Value from a Function
Problem
You want to return two or more values from a function. Recipe 2.10 provided examples for the most common form of a function, one that returns just one value or none at all.
But sometimes you need to modify or return more than one value.

2.11 Returning More Than One Value from a Function | 41

Download from Wow! eBook

Solution
There are various ways to solve this. The easiest to understand is to have the function change some global variables and not actually return anything from the function:
/*

swap sketch demonstrates changing two values using global variables
*/

int x; // x and y are global variables int y; void setup() {
Serial.begin(9600);
} void loop(){ x = random(10); // pick some random numbers y = random(10);
Serial.print("The value of x and y before swapping are: ");
Serial.print(x); Serial.print(","); Serial.println(y); swap(); Serial.print("The value of x and y after swapping are: ");
Serial.print(x); Serial.print(","); Serial.println(y);Serial.println(); delay(1000); }

// swap the two global values void swap()
{
int temp; temp = x; x = y; y = temp;
}

The swap function changes two values by using global variables. Global variables are easy to understand (global variables are values that are accessible everywhere and anything can change them), but they are avoided by experienced programmers because it’s easy to inadvertently modify the value of a variable or to have a function stop working because you changed the name or type of a global variable elsewhere in the sketch.
A safer and more elegant solution is to pass references to the values you want to change and let the function use the references to modify the values. This is done as follows:
/*

functionReferences sketch demonstrates returning more than one value by passing references
*/

42 | Chapter 2: Making the Sketch Do Your Bidding

void swap(int &value1, int &value2); // functions with references must be declared before use void setup() {
Serial.begin(9600);
} void loop(){ int x = random(10); // pick some random numbers int y = random(10);
Serial.print("The value of x and y before swapping are: ");
Serial.print(x); Serial.print(","); Serial.println(y); swap(x,y); Serial.print("The value of x and y after swapping are: ");
Serial.print(x); Serial.print(","); Serial.println(y);Serial.println();

}

delay(1000);

// swap the two given values void swap(int &value1, int &value2)
{
int temp; temp = value1; value1 = value2; value2 = temp;
}

Discussion
The swap function is similar to the functions with parameters described in Recipe 2.10, but the ampersand (&) symbol indicates that the parameters are references.
This means changes in values within the function will also change the value of the variable that is given when the function is called. You can see how this works by first running the code in this recipe’s Solution and verifying that the parameters are swapped. Then modify the code by removing all four ampersands (the two in the declaration at the top and the two in the definition at the bottom).
The two changed lines should look like this: void swap(int value1, int value2); // functions with references must be declared before use
...
void swap(int value1, int value2)

Running the code shows that the values are not swapped—changes made within the function are local to the function and are lost when the function returns.

2.11 Returning More Than One Value from a Function | 43

A function declaration is a prototype—a specification of the name, the types of values that may be passed to the function, and the function’s return type. The Arduino build process usually creates the declarations for you under the covers. But when you use nonstandard (for Arduino) syntax, the build process will not create the declaration and you need to add it to your code yourself, as done here with the line just before setup. A function definition is the function header and the function body. The function header is similar to the declaration except it does not have a semicolon at the end. The function body is the code within the brackets that is run to perform some action when the function is called.

2.12 Taking Actions Based on Conditions
Problem
You want to execute a block of code only if a particular condition is true. For example, you may want to light an LED if a switch is pressed or if an analog value is greater than some threshold.

Solution
The following code uses the wiring shown in Recipe 5.1:
/*
*/

Pushbutton sketch a switch connected to pin 2 lights the LED on pin 13 const int ledPin = 13; const int inputPin = 2; void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin, INPUT);
}

// choose the pin for the LED
// choose the input pin (for a pushbutton)
// declare LED pin as output
// declare pushbutton pin as input

void loop(){ int val = digitalRead(inputPin); if (val == HIGH)
{
digitalWrite(ledPin, HIGH);
}
}

// read input value
// check if the input is HIGH
// turn LED on if switch is pressed

Discussion
The if statement is used to test the value of digitalRead. An if statement must have a test within the parentheses that can only be true or false. In the example in this recipe’s

44 | Chapter 2: Making the Sketch Do Your Bidding

Solution, it’s val == HIGH, and the code block following the if statement is only executed if the expression is true. A code block consists of all code within the brackets (or if you don’t use brackets, the block is just the next executable statement terminated by a semicolon).
If you want to do one thing if a statement is true and another if it is false, use the if...else statement:
/*
Pushbutton sketch a switch connected to pin 2 lights the LED on pin 13
*/
const int ledPin = 13; const int inputPin = 2; void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin, INPUT);
}

// choose the pin for the LED
// choose the input pin (for a pushbutton)
// declare LED pin as output
// declare pushbutton pin as input

void loop(){ int val = digitalRead(inputPin); // if (val == HIGH)
//
{
// do this if val is HIGH digitalWrite(ledPin, HIGH);
//
} else {
// else do this if val is not HIGH digitalWrite(ledPin, LOW);
//
}
}

read input value check if the input is HIGH turn LED on if switch is pressed

turn LED off

See Also
See the discussion on Boolean types in Recipe 2.2.

2.13 Repeating a Sequence of Statements
Problem
You want to repeat a block of statements while an expression is true.

2.13 Repeating a Sequence of Statements | 45

Solution
A while loop repeats one or more instructions while an expression is true: while(analogRead(sensorPin) > 100)
{
flashLED();
// call a function to turn an LED on and off
}

This code will execute the statements in the block within the brackets, {}, while the value from analogRead is greater than 100. This could be used to flash an LED as a visible warning that some value exceeded a threshold. The LED is off when the sensor value is 100 or less; it flashes continuously when the value is greater than 100.
The {} symbols that define a block of code are given various names, including brackets, curly braces, and braces. This book refers to them as brackets.

Discussion
Brackets define the extent of the code block to be executed in a loop. If brackets are not used, only the first line of code will be repeated in the loop: while(analogRead(sensorPin) > 100) flashLED(); // line immediately following the loop expression is executed
Serial.print(analogRead(sensorPin)); // this is not executed until after
// the while loop finishes!!!

Loops without brackets can behave unexpectedly if you have more than one line of code.

The do...while loop is similar to the while loop, but the instructions in the code block are executed before the condition is checked. Use this form when you must have the code executed at least once, even if the expression is false: do { flashLED(); // call a function to turn an LED on and off
}
while (analogRead(sensorPin) > 100);

The preceding code will flash the LED at least once and will keep flashing as long as the value read from a sensor is greater than 100. If the value is not greater than 100, the
LED will only flash once. This code could be used in a battery-charging circuit, if it were called once every 10 seconds or so: a single flash shows that the circuit is active, whereas continuous flashing indicates the battery is charged.

46 | Chapter 2: Making the Sketch Do Your Bidding

See Also
Chapters 4 and 5

2.14 Repeating Statements with a Counter
Problem
You want to repeat one or more statements a certain number of times. The for loop is similar to the while loop, but you have more control over the starting and ending conditions. Solution
This sketch counts from zero to four by printing the value of the variable i in a for loop:
/*
*/

ForLoop sketch demonstrates for loop

void setup() {
Serial.begin(9600);}
void loop(){
Serial.println("for(int i=0; i < 4; i++)"); for(int i=0; i < 4; i++)
{
Serial.println(i);
}
}

The output from this is as follows: for(int i=0; i < 4; i++)
0
1
2
3

Discussion
A for loop consists of three parts: initialization, conditional test, and iteration (a statement that is executed at the end of every pass through the loop). Each part is separated by a semicolon. In the code in this recipe’s Solution, int i=0; initializes the variable i to 0; i < 4; tests the variable to see if it’s less than 4; and i++ increments i.

2.14 Repeating Statements with a Counter | 47

A for loop can use an existing variable, or it can create a variable for exclusive use in the loop. This version uses the value of the variable j created earlier in the sketch: int j;
Serial.println("for(j=0; j < 4; j++ )"); for(j=0; j < 4; j++ )
{
Serial.println(j);
}

This is almost the same as the earlier example, but it does not have the int keyword in the initialization part because the variable j was already defined. The output of this version is similar to the output of the earlier version: for(j=0; i < 4; i++)
0
1
2
3

You can leave out the initialization part completely if you want the loop to use the value of a variable defined earlier. This code starts the loop with j equal to 1: int j = 1;
Serial.println("for(
for( ; j < 4; j++ )
{
Serial.println(j);
}

; j < 4; j++ )");

The preceding code prints the following: for( 1
2
3

; j < 4; j++)

You control when the loop stops in the conditional test. The previous examples test if the loop variable is less than 4 and will terminate when the condition is no longer true.
If your loop variable starts at 0 and you want it to repeat four times, your conditional statement should test for a value less than 4. The loop repeats while the condition is true and there are four values that are less than 4 with a loop starting at 0.

The following code tests if the value of the loop variable is less than or equal to 4. It will print the digits from 0 to 4:
Serial.println("for(int i=0; i = 0 ; i--)"); for(int i=3; i > = 0 ; i--)
{
Serial.println(i);
}

Like the other parts of a for loop, the iterator expression can be left blank (you must always have the two semicolons separating the three parts even if they are blank).
This version only increments i when an input pin is high. The for loop does not change the value of i; it is only changed by the if statement after Serial.print:
Serial.println("for(int i=0; i < 4; )"); for(int i=0; i < 4; )
{
Serial.println(i); if(digitalRead(inPin) == HIGH); i++; // only increment the value if the input is high
}

See Also
Arduino reference for the for statement: http://www.arduino.cc/en/Reference/For

2.15 Breaking Out of Loops
Problem
You want to terminate a loop early based on some condition you are testing.

Solution
Use the following code: while(analogRead(sensorPin) > 100)
{

2.15 Breaking Out of Loops | 49

}

if(digitalRead(switchPin) == HIGH)
{
break;
//exit the loop if the switch is pressed
}
flashLED();
// call a function to turn an LED on and off

Discussion
This code is similar to the one using while loops, but it uses the break statement to exit the loop if a digital pin goes high. For example, if a switch is connected on the pin as shown in Recipe 5.1, the loop will be exited and the LED will stop flashing even if the condition in the while loop is true.

See Also
Arduino reference for the break statement: http://www.arduino.cc/en/Reference/Break

2.16 Taking a Variety of Actions Based on a Single Variable
Problem
You need to do different things depending on some value. You could use multiple if and else if statements, but the code soon gets complex and difficult to understand or modify. Additionally, you may want to test for a range of values.

Solution
The switch statement provides for selection of a number of alternatives. It is functionally similar to multiple if/else if statements but is more concise:
/*
* SwitchCase sketch
* example showing switch statement by switching on chars from the serial port
*
* sending the character 1 blinks the LED once, sending 2 blinks twice
* sending + turns the LED on, sending - turns it off
* any other character prints a message to the Serial Monitor
*/
const int ledPin = 13; // the pin the LED is connected to void setup()
{
Serial.begin(9600); // Initialize serial port to send and receive at 9600 baud pinMode(13, OUTPUT);
}
void loop()
{
if ( Serial.available()) // Check to see if at least one character is available
{

50 | Chapter 2: Making the Sketch Do Your Bidding

}

}

char ch = Serial.read(); switch(ch) { case '1': blink(); break; case '2': blink(); blink(); break; case '+': digitalWrite(ledPin,HIGH); break; case '-': digitalWrite(ledPin,LOW); break; default :
Serial.print(ch);
Serial.println(" was received but not expected"); break; }

void blink()
{
digitalWrite(ledPin,HIGH); delay(500); digitalWrite(ledPin,LOW); delay(500); }

Discussion
The switch statement evaluates the variable ch received from the serial port and branches to the label that matches its value. The labels must be numeric constants (you can use strings in a case statement) and no two labels can have the same value. If you don’t have a break statement following each expression, the execution will fall through into the statement: case '1': blink(); case '2': blink(); blink(); break; // no break statement before the next label
// case '1' will continue here
// break statement will exit the switch expression

If the break statement at the end of case '1': was removed (as shown in the preceding code), when ch is equal to the character 1 the blink function will be called three times.
Accidentally forgetting the break is a common mistake. Intentionally leaving out the break is sometimes handy; it can be confusing to others reading your code, so it’s a good practice to clearly indicate your intentions with comments in the code.

2.16 Taking a Variety of Actions Based on a Single Variable | 51

If your switch statement is misbehaving, check to ensure that you have not forgotten the break statements.

The default: label is used to catch values that don’t match any of the case labels. If there is no default label, the switch expression will not do anything if there is no match.

See Also
Arduino reference for the switch and case statements: http://www.arduino.cc/en/Refer ence/SwitchCase 2.17 Comparing Character and Numeric Values
Problem
You want to determine the relationship between values.

Solution
Compare integer values using the relational operators shown in Table 2-2.
Table 2-2. Relational and equality operators
Operator

Test for

Example

==

Equal to

2 == 3 // evaluates to false

!=

Not equal to

2 != 3 // evaluates to true

>

Greater than

2 > 3 // evaluates to false

<

Less than

2 < 3 // evaluates to true

>=

Greater than or equal to

2 >= 3 // evaluates to false

j + 1) delay(10000); // long delay after i is no longer close to j

Here is the output: i = 1 i is i is i is

and j = 2 less than j less than or equal to j not equal to j

i = 2 i is i is i is

and j = 2 less than or equal to j equal to j greater than or equal to j

i = 3 i is i is i is

and j = 2 not equal to j greater than or equal to j greater than j

Discussion
Note that the equality operator is the double equals sign, ==. One of the most common programming mistakes is to confuse this with the assignment operator, which uses a single equals sign.
The following expression will compare the value of i to 3. The programmer intended this: if(i == 3)

// test if i equals 3

But he put this in the sketch: if(i = 3)

// single equals sign used by mistake!!!!

2.17 Comparing Character and Numeric Values | 53

This will always return true, because i will be set to 3, so they will be equal when compared. A tip to help avoid that trap when comparing variables to constants (fixed values) is to put the constant on the left side of the expression: if(3 = i)

// single equals sign used by mistake!!!!

The compiler will tell you about this error because it knows that you can’t assign a different value to a constant.
The error message is the somewhat unfriendly “value required as left operand of assignment”. If you see this message, the compiler is telling you that you are trying to assign a value to something that cannot be changed. See Also
Arduino reference for conditional and comparison operators: http://www.arduino.cc/ en/Reference/If 2.18 Comparing Strings
Problem
You want to see if two character strings are identical.

Solution
There is a function to compare strings, called strcmp (short for string compare). Here is a fragment showing its use: char String1[ ] = "left"; char String2[ ] = "right"; if(strcmp(String1, String2) == 0)
Serial.print("strings are equal)

Discussion strcmp returns the value 0 if the strings are equal and a value greater than zero if the

first character that does not match has a greater value in the first string than in the second. It returns a value less than zero if the first nonmatching character in the first string is less than in the second. Usually you only want to know if they are equal, and although the test for zero may seem unintuitive at first, you’ll soon get used to it.

54 | Chapter 2: Making the Sketch Do Your Bidding

Bear in mind that strings of unequal length will not be evaluated as equal even if the shorter string is contained in the longer one. So: strcmp("left", "leftcenter") == 0)

// this will evaluate to false

You can compare strings up to a given number of characters by using the strncmp function. You give strncmp the maximum number of characters to compare and it will stop comparing after that many characters: strncmp("left", "leftcenter", 4) == 0)

// this will evaluate to true

See Also
More information on strcmp is available at http://www.cplusplus.com/reference/clibrary/ cstring/strcmp/. 2.19 Performing Logical Comparisons
Problem
You want to evaluate the logical relationship between two or more expressions. For example, you want to take a different action depending on the conditions of an if statement. Solution
Use the logical operators as outlined in Table 2-3.
Table 2-3. Logical operators
Symbol

Function

Comments

&&

Logical And

Evaluates as true if the condition on both sides of the && operator are true

||

Logical Or

Evaluates as true if the condition on at least one side of the || operator is true

!

Not

Evaluates as true if the expression is false, and false if the expression is true

Discussion
Logical operators return true or false values based on the logical relationship.
The logical And operator && will return true if both its two operands are true, and false otherwise. The logical Or operator || will return true if either of its two operands are true, and false if both operands are false. The Not operator ! has only one operand, whose value is inverted—it results in false if its operand is true and true if its operand is false.

2.19 Performing Logical Comparisons | 55

2.20 Performing Bitwise Operations
Problem
You want to set or clear certain bits in a value.

Solution
Use the bit operators as outlined in Table 2-4.
Table 2-4. Bit operators
Symbol

Function

Comment

Example

&

Bitwise And

Sets bits in each place to 1 if both bits are 1; otherwise, bits are set to 0.

3 & 1 equals 1

Sets bits in each place to 1 if either bit is 1.

3 | 1 equals 3

|

Bitwise Or

(11 & 01 equals 01)
(11 | 01 equals 11)

^

Bitwise Exclusive
Or

Sets bits in each place to 1 only if one of the two bits is 1.

3 ^ 1 equals 2

~

Bitwise Negation

Inverts the value of each bit. The result depends on the number of bits in the data type.

~1 equals 254

(11 ^ 01 equals 10)
(~00000001 equals 11111110)

Here is a sketch that demonstrates the example values shown in Table 2-4:
/*
* bits sketch
* demonstrates bitwise operators
*/
void setup() {
Serial.begin(9600);
} void loop(){
Serial.print("3 & 1 equals "); // bitwise And 3 and 1
Serial.print(3 & 1);
// print the result
Serial.print(" decimal, or in binary: ");
Serial.println(3 & 1 , BIN);
// print the binary representation of the result
Serial.print("3 | 1 equals "); // bitwise Or 3 and 1
Serial.print(3 | 1 );
Serial.print(" decimal, or in binary: ");
Serial.println(3 | 1 , BIN);
// print the binary representation of the result
Serial.print("3 ^ 1 equals "); // bitwise exclusive or 3 and 1
Serial.print(3 ^ 1);

56 | Chapter 2: Making the Sketch Do Your Bidding

Serial.print(" decimal, or in binary: ");
Serial.println(3 ^ 1 , BIN);
// print the binary representation of the result byte byteVal = 1; int intVal = 1; byteVal = ~byteVal; intVal = ~intVal;

// do the bitwise negate

Serial.print("~byteVal (1) equals "); // bitwise negate an 8 bit value
Serial.println(byteVal, BIN); // print the binary representation of the result
Serial.print("~intVal (1) equals "); // bitwise negate a 16 bit value
Serial.println(intVal, BIN);
// print the binary representation of the result
}

delay(10000);

This is what is displayed on the Serial Monitor:
3 & 1 equals 1 decimal, or in binary: 1
3 | 1 equals 3 decimal, or in binary: 11
3 ^ 1 equals 2 decimal, or in binary: 10
~byteVal (1) equals 11111110
~intVal (1) equals 11111111111111111111111111111110

Discussion
Bitwise operators are used to set or test bits. When you “And” or “Or” two values, the operator works on each individual bit. It is easier to see how this works by looking at the binary representation of the values.
Decimal 3 is binary 00000011, and decimal 1 is 00000001. Bitwise And operates on each bit. The rightmost bits are both 1, so the result of And-ing these is 1. Moving to the left, the next bits are 1 and 0; And-ing these results in 0. All the remaining bits are
0, so the bitwise result of these will be 0. In other words, for each bit position where there is a 1 in both places, the result will have a 1; otherwise, it will have a 0. So, 11 &
01 equals 1.
Tables 2-5, 2-6, and 2-7 should help to clarify the bitwise And, Or, and Exclusive Or values. Table 2-5. Bitwise And
Bit 1

Bit 2

Bit 1 and Bit 2

0

0

0

0

1

0

1

0

0

1

1

1

2.20 Performing Bitwise Operations | 57

Table 2-6. Bitwise Or
Bit 1

Bit 2

Bit 1 or Bit 2

0

0

0

0

1

1

1

0

1

1

1

1

Table 2-7. Bitwise Exclusive Or
Bit 1

Bit 2

Bit 1 ^ Bit 2

0

0

0

0

1

1

1

0

1

1

1

0

All the bitwise expressions operate on two values, except for the negation operator.
This simply flips each bit, so 0 becomes 1 and 1 becomes 0. In the example, the byte
(8-bit) value 00000001 becomes 11111110. The int value has 16 bits, so when each is flipped, the result is 15 ones followed by a single zero.

See Also
Arduino reference for the bitwise And, Or, and Exclusive Or operators: http://www
.arduino.cc/en/Reference/Bitwise

2.21 Combining Operations and Assignment
Problem
You want to understand and use compound operators. It is not uncommon to see published code that uses expressions that do more than one thing in a single statement.
You want to understand a += b, a >>= b, and a &= b.

Solution
Table 2-8 shows the compound assignment operators and their equivalent full expression. 58 | Chapter 2: Making the Sketch Do Your Bidding

Table 2-8. Compound operators
Operator

Example

Equivalent expression

+=

Value += 5;

Value = Value + 5; // add 5 to Value

-=

Value -= 4;

Value = Value - 4; // subtract 4 from Value

*=

Value *= 3;

Value = Value * 3; // multiply Value by 3

/=

Value /= 2;

Value = Value / 2; // divide Value by 2

>>=

Value >>= 2;

Value = Value >> 2; // shift Value right two places

> 3 is the same as x / 8.

The Arduino controller chip can shift bits more efficiently than it can multiply and divide, and you may come across code that uses the bit shift to multiply and divide: int c = (a > 2); //add (a times 2) plus ( b divided by 4)

The expression (a > 2); does not look much like (a * 2) + (b / 4);, but both expressions do the same thing. Indeed, the Arduino compiler is smart enough to recognize that shifting an integer by a constant that is a power of two is identical to a shift and will produce the same machine code as the version using shift. The source code using arithmetic operators is easier for humans to read, so it is preferred when the intent is to multiply and divide.

See Also
Arduino references for bit and byte functions: lowByte, highByte, bitRead, bitWrite, bitSet, bitClear, and bit (see Recipe 3.12)

76 | Chapter 3: Using Mathematical Operators

3.14 Extracting High and Low Bytes in an int or long
Problem
You want to extract the high byte or low byte of an integer; for example, when sending integer values as bytes on a serial or other communication line.

Solution
Use lowByte(i) to get the least significant byte from an integer. Use highByte(i) to get the most significant byte from an integer.
The following sketch converts an integer value into low and high bytes:
//ByteOperators
int intValue = 258; // 258 in hexadecimal notation is 0x102 void setup()
{
Serial.begin(9600);
}
void loop()
{
int loWord,hiWord; byte loByte, hiByte; hiByte = highByte(intValue); loByte = lowByte(intValue);
Serial.println(intValue,DEC);
Serial.println(intValue,HEX);
Serial.println(loByte,DEC);
Serial.println(hiByte,DEC);
}

delay(10000); // wait a very long time

Discussion
The example sketch prints intValue followed by the low byte and high byte:
258
102
2
1

//
//
//
//

the the the the integer value to be converted value in hexadecimal notation low byte high byte

To extract the byte values from a long, the 32-bit long value first gets broken into two
16-bit words which can then be converted into bytes as shown in the earlier code. At the time of this writing, the standard Arduino library did not have a function to perform

3.14 Extracting High and Low Bytes in an int or long | 77

this operation on a long, but you can add the following lines to your sketch to provide this: #define highWord(w) ((w) >> 16)
#define lowWord(w) ((w) & 0xffff)

These are macro expressions: hiWord performs a 16-bit shift operation to produce a 16bit value, and lowWord masks the lower 16 bits using the bitwise And operator (see
Recipe 2.20).
The number of bits in an int varies on different platforms. On Arduino it is 16 bits, but in other environments it is 32 bits. The term word as used here refers to a 16-bit value.

This code converts the 32-bit hex value 0x1020304 to its 16-bit constituent high and low values: loword = lowWord(longValue); hiword = highWord(longValue);
Serial.println(loword,DEC);
Serial.println(hiword,DEC);

This prints the following values:
772
258

// 772 is 0x0304 in hexadecimal
// 258 is 0x0102 in hexadecimal

Note that 772 in decimal is 0x0304 in hexadecimal, which is the low-order word (16 bits) of the longValue 0x1020304. You may recognize 258 from the first part of this recipe as the value produced by combining a high byte of 1 and a low byte of 2 (0x0102 in hexadecimal). See Also
Arduino references for bit and byte functions: lowByte, highByte, bitRead, bitWrite, bitSet, bitClear, and bit (see Recipe 3.12)

3.15 Forming an int or long from High and Low Bytes
Problem
You want to create a 16-bit (int) or 32-bit (long) integer value from individual bytes; for example, when receiving integers as individual bytes over a serial communication link. This is the inverse operation of Recipe 3.14.

78 | Chapter 3: Using Mathematical Operators

Solution
Use the word(h,l) function to convert two bytes into a single Arduino integer. Here is the code from Recipe 3.14 expanded to convert the individual high and low bytes back into an integer:
//ByteOperators
int intValue = 0x102;

// 258

void setup()
{
Serial.begin(9600);
}
void loop()
{
int loWord,hiWord; byte loByte, hiByte; hiByte = highByte(intValue); loByte = lowByte(intValue);
Serial.println(intValue,DEC);
Serial.println(loByte,DEC);
Serial.println(hiByte,DEC);

}

loWord = word(hiByte, loByte);
// convert the bytes back into a word
Serial.println(loWord,DEC);
delay(10000); // wait a very long time

Discussion
The word(high,low) expression assembles a high and low byte into a 16-bit value. The code in this recipe’s Solution takes the low and high bytes formed as shown in Recipe 3.14, and assembles them back into a word. The output is the integer value, the low byte, the high byte, and the bytes converted back to an integer value:
258
2
1
258

Arduino does not have a function to make a 32-bit long value two 16-bit words (at the time of this writing), but you can add your own makeLong() capability by adding the following line to the top of your sketch:
#define makeLong(hi, low)

((hi) 16)
#define lowWord(w) ((w) & 0xffff)
// declare a value to test long longValue = 0x1020304; // in decimal: 16909060
// in binary : 00000001 00000010 00000011 00000100 void setup()
{
Serial.begin(9600);
}
void loop()
{
int loWord,hiWord;
Serial.println(longValue,DEC); // this prints 16909060 loWord = lowWord(longValue);
// convert long to two words hiWord = highWord(longValue);
Serial.println(loWord,DEC);
// print the value 772
Serial.println(hiWord,DEC);
// print the value 258 longValue = makeLong( hiWord, loWord); // convert the words back to a long
Serial.println(longValue,DEC); // this again prints 16909060
}

delay(10000); // wait a very long time

The output is:
16909060
772
258
16909060

See Also
Arduino references for bit and byte functions: lowByte, highByte, bitRead, bitWrite, bitSet, bitClear, and bit (see Recipe 3.12)

80 | Chapter 3: Using Mathematical Operators

CHAPTER 4

Serial Communications

4.0 Introduction
Serial communications provide an easy and flexible way for your Arduino board to interact with your computer and other devices. This chapter explains how to send and receive information using this capability.
Chapter 1 described how to connect the Arduino serial port to your computer to upload sketches. The upload process sends data from your computer to Arduino and Arduino sends status messages back to the computer to confirm the transfer is working. The recipes here show how you can use this communication link to send and receive any information between Arduino and your computer or another serial device.
Serial communications are also a handy tool for debugging. You can send debug messages from Arduino to the computer and display them on your computer screen.

The Arduino IDE (described in Recipe 1.3) provides a Serial Monitor (shown in Figure 4-1) to display serial data received by Arduino.
You can also send data from the Serial Monitor to Arduino by entering text in the text box to the left of the Send button. Baud rate is selected using the drop-down box on the bottom right. You can use the drop down labeled “No line ending” to automatically send a carriage return or a combination of a carriage return and a line at the end of each message sent when clicking the Send button.
Your Arduino sketch can use the serial port to indirectly access (usually via a proxy program written in a language like Processing) all the resources (memory, screen, keyboard, mouse, network connectivity, etc.) that your computer has. Your computer can also use the serial link to interact with sensors or other devices connected to Arduino.
Implementing serial communications involves hardware and software. The hardware provides the electrical signaling between Arduino and the device it is talking to. The
81

Figure 4-1. Arduino Serial Monitor screen

software uses the hardware to send bytes or bits that the connected hardware understands. The Arduino serial libraries insulate you from most of the hardware complexity, but it is helpful for you to understand the basics, especially if you need to troubleshoot any difficulties with serial communications in your projects.

Serial Hardware
Serial hardware sends and receives data as electrical pulses that represent sequential bits. The zeros and ones that carry the information that makes up a byte can be represented in various ways. The scheme used by Arduino is 0 volts to represent a bit value of 0, and 5 volts (or 3.3 volts) to represent a bit value of 1.
Using 0 volts (for 0) and 5 volts (for 1) is very common. This is referred to as the TTL level because that was how signals were represented in one of the first implementations of digital logic, called TransistorTransistor Logic (TTL).

Boards including the Uno, Duemilanove, Diecimila, Nano, and Mega have a chip to convert the hardware serial port on the Arduino chip to Universal Serial Bus (USB) for connection to the hardware serial port. Other boards, such as the Mini, Pro, Pro Mini,
Boarduino, Sanguino, and Modern Device Bare Bones Board, do not have USB support and require an adapter for connecting to your computer that converts TTL to USB. See http://www.arduino.cc/en/Main/Hardware for more details on these boards.

82 | Chapter 4: Serial Communications

Some popular USB adapters include:
• Mini USB Adapter (http://arduino.cc/en/Main/MiniUSB)
• FTDI USB TTL Adapter (http://www.ftdichip.com/Products/FT232R.htm)
• Modern Device USB BUB board (http://shop.moderndevice.com/products/usb-bub)
Some serial devices use the RS-232 standard for serial connection. These usually have a nine-pin connector, and an adapter is required to use them with the Arduino. RS-232 is an old and venerated communications protocol that uses voltage levels not compatible with Arduino digital pins.
You can buy Arduino boards that are built for RS-232 signal levels, such as the Freeduino Serial v2.0 (http://www.nkcelectronics.com/freeduino-serial-v20-board-kit-ardui no-diecimila-compatib20.html). RS-232 adapters that connect RS-232 signals to Arduino 5V (or 3.3V) pins include the following: • RS-232 to TTL 3V-5.5V adapter (http://www.nkcelectronics.com/rs232-to-ttl-con verter-board-33v232335.html) • P4 RS232 to TTL Serial Adapter Kits (http://shop.moderndevice.com/products/p4)
• RS232 Shifter SMD (http://www.sparkfun.com/commerce/product_info.php?prod ucts_id=449) A standard Arduino has a single hardware serial port, but serial communication is also possible using software libraries to emulate additional ports (communication channels) to provide connectivity to more than one device. Software serial requires a lot of help from the Arduino controller to send and receive data, so it’s not as fast or efficient as hardware serial.
The Arduino Mega has four hardware serial ports that can communicate with up to four different serial devices. Only one of these has a USB adapter built in (you could wire a USB-TTL adapter to any of the other serial ports). Table 4-1 shows the port names and pins used for all of the Mega serial ports.
Table 4-1. Arduino Mega serial ports
Port name

Transmit pin

Receive pin

Serial

1 (also USB)

0 (also USB)

Serial1

18

19

Serial2

16

17

Serial3

14

15

4.0 Introduction | 83

Software Serial
You will usually use the built-in Arduino serial library to communicate with the hardware serial ports. Serial libraries simplify the use of the serial ports by insulating you from hardware complexities.
Sometimes you need more serial ports than the number of hardware serial ports available. If this is the case, you can use an additional library that uses software to emulate serial hardware. Recipes 4.13 and 4.14 show how to use a software serial library to communicate with multiple devices.

Serial Message Protocol
The hardware or software serial libraries handle sending and receiving information.
This information often consists of groups of variables that need to be sent together. For the information to be interpreted correctly, the receiving side needs to recognize where each message begins and ends. Meaningful serial communication, or any kind of machine-to-machine communication, can only be achieved if the sending and receiving sides fully agree how information is organized in the message. The formal organization of information in a message and the range of appropriate responses to requests is called a communications protocol.
Messages can contain one or more special characters that identify the start of the message—this is called the header. One or more characters can also be used to identify the end of a message—this is called the footer. The recipes in this chapter show examples of messages in which the values that make up the body of a message can be sent in either text or binary format.
Sending and receiving messages in text format involves sending commands and numeric values as human-readable letters and words. Numbers are sent as the string of digits that represent the value. For example, if the value is 1234, the characters 1, 2, 3, and 4 are sent as individual characters.
Binary messages comprise the bytes that the computer uses to represent values. Binary data is usually more efficient (requiring fewer bytes to be sent), but the data is not as human-readable as text, which makes it more difficult to debug. For example, Arduino represents 1234 as the bytes 4 and 210 (4 * 256 + 210 = 1234). If the device you are connecting to sends or receives only binary data, that is what you will have to use, but if you have the choice, text messages are easier to implement and debug.

84 | Chapter 4: Serial Communications

There are many ways to approach software problems, and some of the recipes in this chapter show two or three different ways to achieve a similar result. The differences
(e.g., sending text instead of raw binary data) may offer a different balance between simplicity and efficiency. Where choices are offered, pick the solution that you find easiest to understand and adapt—this will probably be the first solution covered. Alternatives may be a little more efficient, or they may be more appropriate for a specific protocol that you want to connect to, but the “right way” is the one you find easiest to get working in your project.

The Processing Development Environment
Some of the examples in this chapter use the Processing language to send and receive serial messages on a computer talking to Arduino.
Processing is a free open source tool that uses a similar development environment to
Arduino. You can read more about Processing and download everything you need at the Processing website.
Processing is based on the Java language, but the Processing code samples in this book should be easy to translate into other environments that support serial communications. Processing comes with some example sketches illustrating communication between Arduino and Processing. SimpleRead is a Processing example that includes
Arduino code. In Processing, select File→Examples→Libraries→Serial→SimpleRead to see an example that reads data from the serial port and changes the color of a rectangle when a switch connected to Arduino is pressed and released.

See Also
An Arduino RS-232 tutorial is available at http://www.arduino.cc/en/Tutorial/Arduino
SoftwareRS232. Lots of information and links are available at the Serial Port Central website, http://www.lvr.com/serport.htm.
In addition, a number of books on Processing are also available:
• Getting Started with Processing: A Quick, Hands-on Introduction by Casey Reas and
Ben Fry (Make).
• Processing: A Programming Handbook for Visual Designers and Artists by Casey
Reas and Ben Fry (MIT Press).
• Visualizing Data by Ben Fry (O’Reilly).
• Processing: Creative Coding and Computational Art by Ira Greenberg (Apress).
• Making Things Talk by Tom Igoe (Make). This book covers Processing and Arduino and provides many examples of communication code.

4.0 Introduction | 85

4.1 Sending Debug Information from Arduino to
Your Computer
Problem
You want to send text and data to be displayed on your PC or Mac using the Arduino
IDE or the serial terminal program of your choice.

Solution
This sketch prints sequential numbers on the Serial Monitor:
/*
* SerialOutput sketch
* Print numbers to the serial port
*/
void setup()
{
Serial.begin(9600); // send and receive at 9600 baud
}
int number = 0; void loop()
{
Serial.print("The number is ");
Serial.println(number);
// print the number

}

delay(500); // delay half second between numbers number++; // to the next number

Connect Arduino to your computer just as you did in Chapter 1 and upload this sketch.
Click the Serial Monitor icon in the IDE and you should see the output displayed as follows: The number is 0
The number is 1
The number is 2

Discussion
To print text and numbers from your sketch, put the Serial.begin(9600) statement in setup(), and then use Serial.print() statements to print the text and values you want to see.
The Arduino Serial Monitor function can display serial data sent from Arduino. To start the Serial Monitor, click the Serial Monitor toolbar icon as shown in Figure 4-2.
A new window will open for displaying output from Arduino.

86 | Chapter 4: Serial Communications

Figure 4-2. Clicking the Serial Monitor icon to see serial output

Your sketch must call the Serial.begin() function before it can use serial input or output. The function takes a single parameter: the desired communication speed. You must use the same speed for the sending side and the receiving side, or you will see gobbledygook (or nothing at all) on the screen. This example and most of the others in this book use a speed of 9,600 baud (baud is a measure of the number of bits transmitted per second). The 9,600 baud rate is approximately 1,000 characters per second.
You can send at lower or higher rates (the range is 300 to 115,200), but make sure both sides use the same speed. The Serial Monitor sets the speed using the baud rate drop down (at the bottom right of the Serial Monitor window in Figure 4-2). If your output looks something like this:
`3??f 3)
{
int x = Integer.parseInt(data[1]); int y = Integer.parseInt(data[2]); print("x= " + x); println(", y= " + y); myRobot.mouseMove(x,y); // move mouse to received x and y position
}
}

114 | Chapter 4: Serial Communications

}

}

The Processing code splits the message containing the x and y coordinates and sends them to the mouseMove method of the Java Robot class.

Discussion
This technique for controlling applications running on your computer is easy to implement and should work with any operating system that can run the Processing application. Some platforms require special privileges or extensions to access lowlevel input control. If you can’t get control of the mouse, check the documentation for your operating system.

If you require Arduino to actually appear as though it were a mouse to the computer, you have to emulate the actual USB protocol real mice use. This protocol, for Human
Interface Devices (HID), is complex, but Phillip Lindsay has some useful information and code at http://code.google.com/p/vusb-for-arduino/.
A runaway Robot object has the ability to remove your control over the mouse and keyboard if used in an endless loop.

See Also
Go to http://java.sun.com/j2se/1.3/docs/api/java/awt/Robot.html for more information on the Java Robot class.
An article on using the Robot class is available at http://www.developer.com/java/other/ article.php/10936_2212401_1. If you prefer to use a Windows programming language, the low-level Windows API function to insert keyboard and mouse events into the input stream is called
SendInput. You can visit http://msdn.microsoft.com/en-us/library/ms646310(VS.85)
.aspx for more information.

4.11 Controlling Google Earth Using Arduino
Problem
You want to control movement in an application such as Google Earth using sensors attached to Arduino. For example, you want sensors to detect hand movements to act

4.11 Controlling Google Earth Using Arduino | 115

as the control stick for the flight simulator in Google Earth. The sensors could use a joystick (see Recipe 6.17) or a Wii nunchuck (see Recipe 13.2).

Solution
Google Earth lets you “fly” anywhere on Earth to view satellite imagery, maps, terrain, and 3D buildings (see Figure 4-4). It contains a flight simulator that can be controlled by a mouse, and this recipe uses techniques described in Recipe 4.10 combined with a sensor connected to Arduino to provide the joystick input.

Figure 4-4. Google Earth flight simulator

This recipe’s Solution is based on the method used in Recipe 4.10 for emulating a mouse by sending Arduino data to Processing. The Arduino code sends the horizontal and vertical positions determined by reading the joystick values (the joystick code is discussed in Recipe 6.17) from a PlayStation game controller:
*
* GoogleEarthPSX
*
* Send joystick data from PSX to Processing
* uses PSX library discussed in Recipe 6.17
*/
#include

// Includes the Psx Library

Psx Psx; const int dataPin = 5;

// Create an instance of the Psx library

116 | Chapter 4: Serial Communications

const const const const int int int int cmndPin = 4; attPin = 3; clockPin = 2; psxDelay = 10; // this determines the clock delay in microseconds

const byte nudge = 64;
// the amount of movement to be sent when stick is pushed const byte HEADER = 255; // this value is sent as the header unsigned int data; byte x,y, buttons; void setup()
{
Serial.begin(9600);
Psx.setupPins(dataPin, cmndPin, attPin, clockPin, psxDelay);
}

// initialize Psx

void loop()
{
data = Psx.read(); x = y = 127; buttons = 0;

// get the psx controller button data
// center x & y values, offsets are added if buttons pressed

if(data & psxLeft || data & psxSqu) x = x - nudge; if(data & psxDown ||data & psxX) y = y + nudge; if(data & psxRight ||data & psxO) x = x + nudge; if(data & psxUp ||data & psxTri) y = y - nudge; if(data & psxStrt) // (Z button) buttons = buttons + 2; if(data & psxSlct) // (C button) buttons = buttons + 1;
Serial.print(HEADER);
Serial.print(x);
Serial.print(y);
Serial.print(buttons); delay(20); // send position 50 times a second
}

The Processing sketch reads the header byte and three data bytes for x and y mouse position and button state. The technique for handling binary data is discussed in
Recipe 4.7:
/**
* GoogleEarthFS_P
*
* Read Arduino Serial packets
* and send mouse position to Google Earth

4.11 Controlling Google Earth Using Arduino | 117

*
*/
import processing.serial.*;
Serial myPort; int portIndex = 1; int HEADER = 255; int val;

// Create object from Serial class
// select the com port, 0 is the first port
// Data received from the serial port

GoogleFS myGoogle; void setup()
{
size(256, 256); println(Serial.list()); println(" Connecting to -> " + Serial.list()[portIndex]); myPort = new Serial(this,Serial.list()[portIndex], 9600); myGoogle = new GoogleFS(); smooth(); fill(255); background(255); println("Start Google FS in the center of your screen"); println("center the mouse pointer in google earth and press Z button to start"); do{ getData();
}
while(buttons != 2 ); // wait for data and Z button to start

}

println("started"); myGoogle.mousePress(InputEvent.BUTTON1_MASK); // starts the FS int accx,accy,buttons; int xOffset, yOffset = 0; boolean getData(){ if ( myPort.available() >= 4) { // If a data packet is available, if(myPort.read() == HEADER){ // check for header
// erase the old markers stroke(255); ellipse(accx, accy,4,4); accx = myPort.read(); accy = myPort.read(); buttons = myPort.read(); if(xOffset == 0){
// here if first time xOffset = accx; yOffset = accy;
}
if( buttons == 1) { println("tbutton: c");

118 | Chapter 4: Serial Communications

xOffset = accx; yOffset = accy;
}
if(buttons == 3 ){ exit(); } return true; // data available
}
} return false;
}
void draw()
{
if(getData()){ if(buttons != 2 ){
// only activate the mouse when the Z button is not pressed myGoogle.move(accx- xOffset, accy - yOffset);
}
print("accx: "); print("\taccy: "); println(); }

}

print(accx); print(accy); stroke(255,0,0);

ellipse(accx, accy,4,4);

class GoogleFS {
Robot myRobot;
// create object from Robot class; int centerX,centerY;
GoogleFS(){
try { myRobot = new Robot();
}
catch (AWTException e) {
e.printStackTrace();
}
Dimension screen = java.awt.Toolkit.getDefaultToolkit().getScreenSize(); centerY = (int)screen.getHeight() / 2 ; centerX = (int)screen.getWidth() / 2;
}
// moves mouse from center of screen by given offset void move(int offsetX, int offsetY){ myRobot.mouseMove(centerX + 4 * offsetX,centerY + -4 * offsetY);
}
void mousePress( int button){ myRobot.mousePress(button) ;
}
}

Discussion
Arduino determines the horizontal and vertical positions by reading the joystick value from the PSX (PlayStation game controller). This control does not actually provide a
4.11 Controlling Google Earth Using Arduino | 119

value proportional to the stick position, so the Arduino code sends an offset from the center when the stick is moved—this is the nudge variable and it determines the value of this offset, and therefore the sensitivity of the control. The state of the Select and
Start switches is also sent (when pressed, Select has a value of 2 and Start has a value of 1; when both are pressed the value is 3, and when no button is pressed the value is 0).
Follow the instructions for connecting the PSX in Recipe 6.17.
Google Earth is a free download; you can get it from the Google website, http://earth
.google.com/download-earth.html. Download and run the version for your operating system to install it on your computer. Start Google Earth, and from the Tools menu, select Enter Flight Simulator. Select an aircraft (the SR22 is easier to fly than the F16) and an airport. The Joystick support should be left unchecked—you will be using the mouse to control the aircraft. Click the Start Flight button and immediately press the space bar to pause the simulator so that you can get the Processing sketch running.
Run the GoogleEarthFS_P sketch and press the Start button on the PSX controller. You will see a dot in the Processing draw window showing the joystick position, and you should see this move as you press the PSX controller joystick buttons. At this point, the mouse position is under the control of Arduino, but control returns to your computer mouse when you hold the PSX Start button. Make Google Earth the Active window by holding the PSX Start button and clicking on Google Earth.
You are now ready to fly. Release the PSX Start button, press Page Up on your keyboard a few times to increase the throttle, and then press the space bar on your keyboard to unpause the simulator. When the SR22 reaches an air speed that is a little over 100 knots, you can “pull back” on the stick and fly. Information explaining the simulator controls is available in the Help menu.
Here is another variation that sends a similar message to the Processing sketch. This one uses the Wii nunchuck code from Recipe 13.2:
/*
* WiichuckSerial
*
* based on code from Tod E. Kurt, http://thingm.com/
* Modified to send serial packets to Processing
*
*/
#include
#include "nunchuck_funcs.h" int loop_cnt=0; const byte header = 254;

// a value to indicate start of message

byte accx,accy,joyx,joyy,buttons;
// set the current coordinates as the center points

120 | Chapter 4: Serial Communications

void setup()
{
Serial.begin(9600); nunchuck_setpowerpins(); nunchuck_init(); // send the initialization handshake nunchuck_get_data(); // ignore the first time delay(50); } void loop()
{
if( loop_cnt > 50 ) { // every 50 msecs get new data loop_cnt = 0; nunchuck_get_data(); accx = accy = buttons buttons

nunchuck_accelx(); nunchuck_accely(); = nunchuck_zbutton() * 2;
= buttons + nunchuck_cbutton(); // cbutton is least significant bit

Serial.print((byte)HEADER);
Serial.print((byte)accx);
Serial.print((byte)accy);
Serial.print((byte)buttons);

}

// value indicating start of message

} loop_cnt++; delay(1);

The connections are shown in Recipe 13.2. Operation is similar to the PSX version, except you use the Z button on the nunchuck instead of the Start button.

See Also
The Google Earth website contains the downloadable code and instructions needed to get this going on your computer: http://earth.google.com/.

4.12 Logging Arduino Data to a File on Your Computer
Problem
You want to create a file containing information received over the serial port from
Arduino. For example, you want to save the values of the digital and analog pins at regular intervals to a logfile.

Solution
We covered sending information from Arduino to your computer in previous recipes.
This solution uses the same Arduino code explained in Recipe 4.9. The Processing
4.12 Logging Arduino Data to a File on Your Computer | 121

sketch that handles file logging is based on the Processing sketch also described in that recipe. This Processing sketch creates a file (using the current date and time as the filename) in a directory called Arduino. Messages received from Arduino are added to the file.
Pressing any key saves the file and exits the program:
/*
* ReceiveMultipleFieldsBinaryToFile_P
*
* portIndex must be set to the port connected to the Arduino
* based on ReceiveMultipleFieldsBinary, this version saves data to file
* Press any key to stop logging and save file
*/
import processing.serial.*;
PrintWriter output;
DateFormat fnameFormat= new SimpleDateFormat("yyMMdd_HHmm");
DateFormat timeFormat = new SimpleDateFormat("hh:mm:ss");
String fileName;
Serial myPort; short portIndex = 0; char HEADER = 'H';

// Create object from Serial class
// select the com port, 0 is the first port

void setup()
{
size(200, 200);
// Open whatever serial port is connected to Arduino.
String portName = Serial.list()[portIndex]; println(Serial.list()); println(" Connecting to -> " + Serial.list()[portIndex]); myPort = new Serial(this, portName, 9600);
Date now = new Date(); fileName = fnameFormat.format(now); output = createWriter(fileName + ".txt"); // save the file in the sketch folder
}
void draw()
{
int val;
String time; if ( myPort.available() >= 15) // wait for the entire message to arrive
{
if( myPort.read() == HEADER) // is this the header
{
String timeString = timeFormat.format(new Date()); println("Message received at " + timeString); output.println(timeString); // header found
// get the integer containing the bit values val = readArduinoInt();

122 | Chapter 4: Serial Communications

}

}

}

// print the value of each bit for(int pin=2, bit=1; pin = 15) // wait for the entire message to arrive
{
if( myPort.read() == HEADER) // is this the header
{
String timeString = timeFormat.format(new Date()); output.print(timeString); val = readArduinoInt(); // read but don't output the digital values

}

}

}

// output the six analog values delimited by a comma for(int i=0; i < 6; i ++){ val = readArduinoInt(); output.print("," + val);
}
output.println();

See Also
For more on createWriter, see http://processing.org/reference/createWriter_.html.

4.13 Sending Data to Two Serial Devices at the Same Time
Problem
You want to send data to a serial device such as a serial LCD, but you are already using the built-in serial port to communicate with your computer.

Solution
On a Mega this is not a problem, as it has four hardware serial ports; just create two serial objects and use one for the LCD and one for the computer:

124 | Chapter 4: Serial Communications

void setup() {
// initialize two serial ports on a megaL
Serial.begin(9600);
Serial1.begin(9600);
}

On a standard Arduino board (such as the Uno or Duemilanove) that only has one hardware serial port, you will need to create an emulated or “soft” serial port.
You can use Mikal Hart’s NewSoftSerial, a serial port emulation library, available at http://arduiniana.org/libraries/newsoftserial. Download and install NewSoftSerial.
The Arduino team is planning to provide NewSoftSerial with future
Arduino downloads. Check the release notes for your Arduino version to see if this software is already included.

Select two available digital pins, one each for transmit and receive, and connect your serial device to them. It is convenient to use the hardware serial port for communication with the computer because this has a USB adapter on the board. Connect the device’s transmit line to the receive pin and the receive line to the transmit pin. In Figure 4-5, we have selected pin 2 as the receive pin and pin 3 as the transmit pin.

Figure 4-5. Connecting a serial device to a “soft” serial port

In your sketch, create a NewSoftSerial object and tell it which pins you chose as your emulated serial port. In this example, we’re creating an object named serial_lcd, which we instruct to use pins 2 and 3:
/*
* NewSoftSerialOutput sketch
* Output data to a software serial port
*/

4.13 Sending Data to Two Serial Devices at the Same Time | 125

#include
...
const int rxpin = 2;
// pin used to receive from LCD const int txpin = 3;
// pin used to send to LCD
NewSoftSerial serial_lcd(txpin, rxpin); // new serial port on pins 2 and 3 void setup()
{
Serial.begin(9600); // 9600 baud for the built-in serial port serial_lcd.begin(9600); //initialize the software serial port also for 9600
}
int number = 0; void loop()
{
serial_lcd.print("The number is "); // send text to the LCD serial_lcd.println(number); // print the number on the LCD
Serial.print("The number is ");
Serial.println(number);
// print the number on the PC console

}

delay(500); // delay half second between numbers number++; // to the next number

This sketch assumes that a serial LCD has been connected to pins 2 and 3 as shown in
Figure 4-5, and that a serial console is connected to the built-in port. The loop will repeatedly display the same message on each:
The number is 0
The number is 1
...

Discussion
Every Arduino microcontroller contains at least one built-in serial port. This special piece of hardware is responsible for generating the series of precisely timed pulses its partner device sees as data and for interpreting the similar stream that it receives in return. Although the Mega has four such ports, most Arduino flavors have only one.
For projects that require connections to two or more serial devices, you’ll need a software library that emulates the additional ports. A “software serial” library effectively turns an arbitrary pair of digital I/O pins into a new serial port.
Although one such library, SoftwareSerial, is included in every Arduino distribution, most programmers prefer to use the more powerful and feature-laden NewSoftSerial library. NewSoftSerial supports a wider range of baud rates and uses some advanced features of the Arduino processor to ensure more reliable data reception. It also supports multiple simultaneous emulated ports. You can read more about NewSoftSerial on Mikal Hart’s website.
Table 4-3 compares the features of the NewSoftSerial and SoftwareSerial libraries.

126 | Chapter 4: Serial Communications

Table 4-3. Feature comparison of two emulation libraries
Feature

SoftwareSerial

Distributed with Arduino software

Noa

Yes

Max transmit baud rate

115.2K

To about 9,600

Max receive baud rate

38.4K

To about 9,600

Supports 8 MHz processors

Yes

No

Reliable interrupt-driven receives

Yes

No

Supports multiple emulated ports

Yes

No

.available() and .overflow() methods a NewSoftSerial

Yes

N/A

Note that as of Arduino release 22, NewSoftSerial was available only as a third-party library, but future releases may include it with the base distribution.

To build your software serial port, you select a pair of pins that will act as the port’s transmit and receive lines in much the same way that pins 1 and 0 are controlled by
Arduino’s built-in port. In Figure 4-5, pins 3 and 2 are shown, but any available digital pins can be used. It’s wise to avoid using 0 and 1, because these are already being driven by the built-in port.
The syntax for writing to the soft port is identical to that for the hardware port. In the example sketch, data is sent to both the “real” and emulated ports using print() and println(): serial_lcd.print("The number is "); serial_lcd.println(number); // send text to the LCD
// send the number on the LCD

Serial.print("The number is ");
Serial.println(number);

// send text to the hardware port
// to output on Arduino Serial Monitor

If you are using a unidirectional serial device—that is, one that only sends or receives— you can conserve resources by specifying a nonexistent pin number in the
NewSoftSerial constructor for the line you don’t need. For example, a serial LCD is fundamentally an output-only device. If you don’t expect (or want) to receive data from it, you can tell NewSoftSerial using this syntax:
#include
... const int no_such_pin = 255; const int txpin = 3;
NewSoftSerial serial_lcd(txpin, no_such_pin); // TX-only on pin 3

In this case, we would only physically connect a single pin (3) to the serial LCD’s “input” or “RX” line.

4.13 Sending Data to Two Serial Devices at the Same Time | 127

4.14 Receiving Serial Data from Two Devices at the Same Time
Problem
You want to receive data from a serial device such as a serial GPS, but you are already using the built-in serial port to communicate with your computer.

Solution
This problem is similar to the preceding one, and indeed the solution is much the same.
If your Arduino’s serial port is connected to the console and you want to attach a second serial device, you must create an emulated port using a software serial library such as
NewSoftSerial. In this case, we will be receiving data from the emulated port instead of writing to it, but the basic solution is very similar.
Download NewSoftSerial from Mikal Hart’s website. Select two pins to use as your transmit and receive lines.
Connect your GPS as shown in Figure 4-6. Rx (receive) is not used in this example, so you can ignore the Rx connection to pin 3 if your GPS does not have a receive pin.

Figure 4-6. Connecting a serial GPS device to a “soft” serial port

As you did in Recipe 4.13, create a NewSoftSerial object in your sketch and tell it which pins to control. In the following example, we define a soft serial port called serial_gps, using pins 2 and 3 for receive and transmit, respectively:
/*
* NewSoftSerialInput sketch
* Read data from a software serial port
*/

128 | Chapter 4: Serial Communications

#include const int rxpin = 2;
// pin used to receive from GPS const int txpin = 3;
// pin used to send to GPS
NewSoftSerial serial_gps(txpin, rxpin); // new serial port on pins 2 and 3 void setup()
{
Serial.begin(9600); // 9600 baud for the built-in serial port serial_gps.begin(4800); // initialize the port, most GPS devices use 4800 baud
}
void loop()
{
if (serial_gps.available() > 0) // any character arrived yet?
{
char c = serial_gps.read();
// if so, read it from the GPS
Serial.print(c, BYTE);
// and echo it to the serial console
}
}

This short sketch simply forwards all incoming data from the GPS to the Arduino Serial
Monitor. If the GPS is functioning and your wiring is correct, you should see GPS data displayed on the Serial Monitor.

Discussion
You initialize an emulated NewSoftSerial port by providing pin numbers for transmit and receive. The following code will set up the port to send on pin 2 and receive on pin 3: const int rxpin = 2;
// pin used to receive from GPS const int txpin = 3;
// pin used to send to GPS
NewSoftSerial serial_gps(txpin, rxpin); // new serial port on pins 2 and 3

The syntax for reading an emulated port is very similar to that for reading from a builtin port. First check to make sure a character has arrived from the GPS with available(), and then read it with read().
It’s important to remember that software serial ports consume time and resources. An emulated serial port must do everything that a hardware port does, using the same processor your sketch is trying to do “real work” with. Whenever a new character arrives, the processor must interrupt whatever it was doing to handle it. This can be time-consuming. At 4,800 baud, for example, it takes the Arduino about two milliseconds to process a single character. While two milliseconds may not sound like much, consider that if your peer device—say, the GPS unit shown earlier—transmits
200 to 250 characters per second, your sketch is spending 40 to 50 percent of its time trying to keep up with the serial input. This leaves very little time to actually process all that data. The lesson is that if you have two serial devices, when possible connect the one with the higher bandwidth consumption to the built-in (hardware) port. If you must connect a high-bandwidth device to a software serial port, make sure the rest of your sketch’s loop is very efficient.
4.14 Receiving Serial Data from Two Devices at the Same Time | 129

Download from Wow! eBook

Receiving data from multiple NewSoftSerial ports
With NewSoftSerial (but not SoftwareSerial), it is possible to create multiple “soft” serial ports in the same sketch. This is a useful way to control, say, several XBee radios in the same project. The caveat is that at any given time, only one of these ports can actively receive data. Reliable reception on a software port requires the processor’s undivided attention. That’s why NewSoftSerial can only activate one port for data reception at a given time. (This restriction does not apply to sending data, only receiving it. See the NewSoftSerial documentation for specifics.)
It is possible to receive on two different NewSoftSerial ports in the same sketch. You just have to take some care that you aren’t trying to receive from both at the same time.
There are many successful designs which, say, monitor a serial GPS device for a while, then later in the sketch accept input from an XBee. The key is to alternate between them. NewSoftSerial considers the “active” port to be whichever port you have most recently accessed using the read, print, println, or available method. The following code fragment illustrates how you design a sketch to read first from one port and then from another:
/*
* MultiRX sketch
* Receive data from two software serial ports
*/
#include const int rxpin1 = 2; const int txpin1 = 3; const int rxpin2 = 4; const int txpin2 = 5;
NewSoftSerial gps(txpin1, rxpin1); // gps device connected to pins 2 and 3
NewSoftSerial xbee(txpin2, rxpin2); // gps device connected to pins 2 and 3 void setup()
{
gps.begin(4800); xbee.begin(9600); } void loop()
{
if (xbee.available() > 0) // xbee is active. Any characters available?
{
if (xbee.read() == 'y') // if xbee received a 'y' character
{
unsigned long start = millis(); // begin listening to the GPS while (start + 100000 > millis())
// listen for 10 seconds

130 | Chapter 4: Serial Communications

{

}

if (gps.available() > 0) // now gps device is active
{
char c = gps.read();
// *** process gps data here
}

}
}
}

This sketch is designed to treat the XBee radio as the active port until it receives a y character, at which point the GPS becomes active. After processing GPS data for
10 seconds, the sketch once again returns to listening to the XBee port. Data that arrives on an inactive port is simply discarded.
Note that the “active port” restriction only applies to multiple soft ports. If your design really must receive data from more than one serial device simultaneously, consider attaching one of these to the built-in hardware port. Alternatively, it is perfectly possible to add additional hardware ports to your projects using external chips, devices called
UARTs.

4.15 Setting Up Processing on Your Computer to Send and Receive Serial Data
Problem
You want to use the Processing development environment to send and receive serial data. Solution
You can get the Processing application from the Downloads section of the Processing website, http://processing.org. Files are available for each major operating system.
Download the appropriate one for your operating system and unzip the file to somewhere that you normally store applications. On a Windows computer, this might be a location like C:\Program Files\Processing\. On a Mac, it might be something like /Applications/Processing/.
If you installed Processing on the same computer that is running the Arduino IDE, the only other thing you need to do is identify the serial port in Processing. The following
Processing sketch prints the serial ports available:
/**
* GettingStarted
*
* A sketch to list the available serial ports
* and display characters received
*/

4.15 Setting Up Processing on Your Computer to Send and Receive Serial Data | 131

import processing.serial.*;
Serial myPort; int portIndex = 0; int val;

// Create object from Serial class
// set this to the port connected to Arduino
// Data received from the serial port

void setup()
{
size(200, 200); println(Serial.list()); // print the list of all the ports println(" Connecting to -> " + Serial.list()[portIndex]); myPort = new Serial(this, Serial.list()[portIndex], 9600);
}
void draw()
{
if ( myPort.available() > 0) // If data is available,
{
val = myPort.read();
// read it and store it in val print(val); }
}

If you are running Processing on a computer that is not running the Arduino development environment, you need to install the Arduino USB drivers (Chapter 1 describes how to do this).
Set the variable portIndex to match the port used by Arduino. You can see the port numbers printed in the Processing text window (the area below the source code, not the separate Display window; see http://processing.org/reference/environment).
Recipe 1.4 describes how to find out which serial port your Arduino board is using.

132 | Chapter 4: Serial Communications

CHAPTER 5

Simple Digital and Analog Input

5.0 Introduction
The Arduino’s ability to sense digital and analog inputs allows it to respond to you and to the world around you. This chapter introduces techniques you can use to do useful things with these inputs. This is the first of many chapters to come that cover electrical connections to Arduino. If you don’t have an electronics background, you may want to look through Appendix A on electronic components, Appendix B on schematic diagrams and data sheets, Appendix C on building and connecting circuits, and Appendix E on hardware troubleshooting. In addition, many good introductory tutorials are available covering electronics. Two that are particularly relevant to Arduino are Getting
Started with Arduino by Massimo Banzi (O’Reilly) and Making Things Talk by Tom
Igoe (O’Reilly). Other books offering a background on electronics topics covered in this and the following chapters include Getting Started in Electronics by Forrest Mims
(Master Publishing) and Physical Computing by Tom Igoe (Cengage).
If wiring components to your Arduino is new to you, be careful about how you connect and power the things you attach. Arduino uses a robust controller chip that can take a fair amount of abuse, but you can damage the chip if you connect the wrong voltages or short-circuit an output pin. Most Arduino controller chips are powered by 5 volts, and you must not connect external power to Arduino pins with a higher voltage than this (or 3.3 volts if your Arduino controller runs on this voltage). Arduino boards that are aimed at beginners have the main chip in a socket that can be removed and replaced, so you don’t need to replace the whole board if you damage the chip.

Figure 5-1 shows the arrangement of pins on a standard Arduino board. See http://www
.arduino.cc/en/Main/Hardware for a list of all the official boards along with links to connection information for each. If your board is not on that list, check your board supplier’s website for connection information.
133

Figure 5-1. Standard Arduino board

This chapter covers the Arduino pins that can sense digital and analog inputs. Digital input pins sense the presence and absence of voltage on a pin. Analog input pins measure a range of voltages on a pin.
The Arduino function to detect digital input is digitalRead and it tells your sketch if a voltage on a pin is HIGH (5 volts) or LOW (0 volts). The Arduino function to configure a pin for reading input is pinMode(pin, INPUT).
On a typical board, there are 14 digital pins (numbered 0 to 13) as shown at the top of
Figure 5-1. Pins 0 and 1 (marked RX and TX) are used for the USB serial connection and should be avoided for other uses. If you need more digital pins on a standard board, you can use the analog pins as digital pins (analog pins 0 through 5 can be used as digital pins 14 through 19).
The Mega board has many more digital and analog pins. Digital pins 0 through 13 and analog pins 0 through 5 are located in the same place as on the standard board so that hardware shields designed for the standard board can fit onto a Mega. As with the standard board, you can use analog pins as digital pins, but with the Mega, analog pins
0 through 15 are digital pin numbers 54 through 69. Figure 5-2 shows the Mega pin layout. Most boards have an LED connected to pin 13, and some of the recipes use this as an output indicator. If your board does not have an LED on pin 13, skip ahead to Recipe 7.1 if you need help connecting an LED to a digital pin.
Recipes covering digital input sometimes use external resistors to provide the voltage that is sensed by digitalRead. These resistors are called pull-up resistors (so named because the voltage is “pulled up” to the 5V line that the resistor is connected to) or

134 | Chapter 5: Simple Digital and Analog Input

Figure 5-2. Arduino Mega board

pull-down resistors (the voltage is “pulled down” to 0 volts). Although 10K ohms is a commonly used value, anything between 4.7K and 20K or more will work; see Appendix A for more information about the components used in this chapter.
Unlike a digital value, which is only on or off, analog values are continuously variable.
The volume setting of a device is a good example; it is not just on or off, but it can have a range of values in between. Many sensors provide information by varying the voltage to correspond to the sensor measurement. Arduino code uses a function called analogRead to get a value proportional to the voltage it sees on one of its analog pins.
The value will be 0 if there are 0 volts on the pin and 1,023 for 5 volts. The value in between will be proportional to the voltage on the pin, so 2.5 volts (half of 5 volts) will result in a value of roughly 511 (half of 1,023). You can see the six analog input pins
(marked 0 to 5) at the bottom of Figure 5-1 (these pins can also be used as digital pins
14 to 19 if they are not needed for analog). Some of the analog recipes use a potentiometer (pot for short, also called a variable resistor) to vary the voltage on a pin. When choosing a potentiometer, a value of 10K is the best option for connecting to analog pins. Although most of the circuits in this chapter are relatively easy to connect, you may want to consider getting a solderless breadboard to simplify your wiring to external components: some choices are the Jameco 20723 (two bus rows per side); RadioShack
276-174 (one bus row per side); Digi-Key 438-1045-ND; and SparkFun PRT-00137.
Another handy item is an inexpensive multimeter. Almost any will do, as long as it can measure voltage and resistance. Continuity checking and current measurement are nice additional features to have. (The Jameco 220812, RadioShack 22-810, and SparkFun
TOL-00078 offer these features.)

5.0 Introduction | 135

5.1 Using a Switch
Problem
You want your sketch to respond to the closing of an electrical contact; for example, a pushbutton or other switch or an external device that makes an electrical connection.

Solution
Use digitalRead to determine the state of a switch connected to an Arduino digital pin set as input. The following code lights an LED when a switch is pressed (Figure 5-3 shows how it should be wired up):
/*
*/

Pushbutton sketch a switch connected to pin 2 lights the LED on pin 13

const int ledPin = 13; const int inputPin = 2;

// choose the pin for the LED
// choose the input pin (for a pushbutton)

void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin, INPUT);
}
void loop(){ int val = digitalRead(inputPin); if (val == HIGH)
{
digitalWrite(ledPin, HIGH);
}
else
{
digitalWrite(ledPin, LOW);
}
}

// declare LED as output
// declare pushbutton as input

// read input value
// check if the input is HIGH
// turn LED on if switch is pressed

// turn LED off

Standard Arduino boards have a built-in LED connected to pin 13. If your board does not, see Recipe 7.1 for information on connecting an
LED to an Arduino pin.

Discussion
The setup function configures the LED pin as OUTPUT and the switch pin as INPUT.

136 | Chapter 5: Simple Digital and Analog Input

Figure 5-3. Switch connected using pull-down resistor
A pin must be set to OUTPUT mode for digitalWrite to control the pin’s output voltage. It must be in INPUT mode to read the digital input.

The digitalRead function monitors the voltage on the input pin (inputPin), and it returns a value of HIGH if the voltage is high (5 volts) and LOW if the voltage is low (0 volts).
Actually, any voltage that is greater than 2.5 volts (half of the voltage powering the chip) is considered HIGH and less than this is treated as LOW. If the pin is left unconnected
(known as floating) the value returned from digitalRead is indeterminate (it may be
HIGH or LOW, and it cannot be reliably used). The resistor shown in Figure 5-3 ensures that the voltage on the pin will be low when the switch is not pressed, because the resistor “pulls down” the voltage to ground. When the switch is pushed, a connection is made between the pin and +5 volts, so the value on the pin interpreted by digital
Read changes from LOW to HIGH.
Do not connect a digital or analog pin to a voltage higher than 5 volts
(or 3.3 volts on a 3.3V board). This can damage the pin and possibly destroy the entire chip. Also, make sure you don’t wire the switch so that it shorts the 5 volts to ground (without a resistor). Although this may not damage the Arduino chip, it is not good for the power supply.

5.1 Using a Switch | 137

In this example, the value from digitalRead is stored in the variable val. This will be
HIGH if the button is pressed, LOW otherwise.
The switch used in this example (and almost everywhere else in this book) makes electrical contact when pressed and breaks contact when not pressed. These switches are called Normally Open (NO); see this book’s website for part numbers. The other kind of momentary switch is called Normally Closed (NC).

The output pin connected to the LED is turned on when you set val to HIGH, illuminating the LED.
Although Arduino sets all digital pins as inputs by default, it is a good practice to set this explicitly in your sketch to remind yourself about the pins you are using.
You may see similar code that uses true instead of HIGH; these can be used interchangeably (they are also sometimes represented as 1). Likewise, false is the same as LOW and
0. Use the form that best expresses the meaning of the logic in your application.
Almost any switch can be used, although the ones called momentary tactile switches are popular because they are inexpensive and can plug directly into a breadboard. See the website for this book for some supplier part numbers.
Here is another way to implement the logic in the preceding sketch: void loop()
{
digitalWrite(ledPin, digitalRead(inputPin));
HIGH, else turn OFF
}

// turn LED ON if input pin is

This doesn’t store the button state into a variable. Instead, it sets the LED on or off directly from the value obtained from digitalRead. It is a handy shortcut, but if you find it overly terse, there is no practical difference in performance, so pick whichever form you find easier to understand.
The pull-up code is similar to the pull-down version, but the logic is reversed: the value on the pin goes LOW when the button is pressed (see Figure 5-4 for a schematic diagram of this). It may help to think of this as pressing the switch DOWN, causing the output to go LOW: void loop()
{
int val = digitalRead(inputPin); if (val == HIGH)
{
digitalWrite(ledPin, LOW);
}

138 | Chapter 5: Simple Digital and Analog Input

// read input value
// check if the input is HIGH
// turn LED OFF

}

else
{
digitalWrite(ledPin, HIGH);
}

// turn LED ON

Figure 5-4. Switch connected using pull-up resistor

See Also
The Arduino reference for digitalRead: http://arduino.cc/en/Reference/DigitalRead
The Arduino reference for digitalWrite: http://arduino.cc/en/Reference/DigitalWrite
The Arduino reference for pinMode: http://arduino.cc/en/Reference/PinMode
The Arduino references for constants (HIGH, LOW, etc.): http://arduino.cc/en/Reference/
Constants
Arduino tutorial on digital pins: http://arduino.cc/en/Tutorial/DigitalPins

5.2 Using a Switch Without External Resistors
Problem
You want to simplify your wiring by eliminating external pull-up resistors when connecting switches.
5.2 Using a Switch Without External Resistors | 139

Solution
As explained in Recipe 5.1, digital inputs must have a resistor to hold the pin to a known value when the switch is not pressed. Arduino has internal pull-up resistors that can be enabled by writing a HIGH value to a pin that is in INPUT mode (the code for this is shown in Recipe 5.1).
For this example, the switch is wired as shown in Figure 5-5. This is almost exactly the same as Figure 5-4, but without an external resistor.

Figure 5-5. Switch wired for use with internal pull-up resistor

The switch is only connected between pin 2 and Gnd. Gnd is short for ground and is at 0 volts by definition:
/*
Pullup sketch a switch connected to pin 2 lights the LED on pin 13
*/
const int ledPin = 13; const int inputPin = 2;

// output pin for the LED
// input pin for the switch

void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin, INPUT); digitalWrite(inputPin,HIGH); // turn on internal pull-up on the inputPin

140 | Chapter 5: Simple Digital and Analog Input

Download from Wow! eBook

} void loop(){ int val = digitalRead(inputPin); if (val == HIGH)
{
digitalWrite(ledPin, HIGH);
}
else
{
digitalWrite(ledPin, LOW);
}
}

// read input value
// check if the input is HIGH
// turn LED OFF

// turn LED ON

There are a few Gnd pins on an Arduino board; they are all connected, so pick whichever is convenient.

Discussion
You enable internal pull-up resistors by writing a HIGH value to a pin in input mode.
Using digitalWrite(pin, HIGH) on a pin in input mode may not be intuitive at first, but you’ll soon get used to it. You can turn the pull-up off by writing a LOW value to the pin. If your application switches the pin mode back and forth between input and output, bear in mind that the state of the pin will remain HIGH or LOW when you change modes.
In other words, if you have set an output pin HIGH and then change to input mode, the pull-up will be on, and reading the pin will produce a HIGH. If you set the pin LOW in output mode with digitalWrite(pin, LOW) and then change to input mode with pin
Mode(pin, INPUT), the pull-up will be off. If you turn a pull-up on, changing to output mode will set the pin HIGH, which could, for example, unintentionally light an LED connected to it.
The internal pull-up resistors are 20K ohms. This is suitable for most applications, but some devices may require lower-value resistors—see the data sheet for external devices you want to connect to Arduino to see if the internal pull-ups are suitable or not.

5.3 Reliably Detecting the Closing of a Switch
Problem
You want to avoid false readings due to contact bounce (contact bounce produces spurious signals at the moment the switch contacts close or open). The process of eliminating spurious readings is called debouncing.

5.3 Reliably Detecting the Closing of a Switch | 141

Solution
There are many ways to solve this problem; here is one using the wiring shown in
Figure 5-3 from Recipe 5.1:
/*

Debounce sketch a switch connected to pin 2 lights the LED on pin 13 debounce logic prevents misreading of the switch state

*/ const int inputPin = 2; const int ledPin = 13; const int debounceDelay = 10;

// the number of the input pin
// the number of the output pin
// milliseconds to wait until stable

// debounce returns true if the switch in the given pin is closed and stable boolean debounce(int pin)
{
boolean state; boolean previousState; previousState = digitalRead(pin);
// store switch state for(int counter=0; counter < debounceDelay; counter++)
{
delay(1);
// wait for 1 millisecond state = digitalRead(pin); // read the pin if( state != previousState)
{
counter = 0; // reset the counter if the state changes previousState = state; // and save the current state
}
}
// here when the switch state has been stable longer than the debounce period
}

return state; void setup()
{
pinMode(inputPin, INPUT); pinMode(ledPin, OUTPUT);
}
void loop()
{
if(debounce(inPin))
{
digitalWrite(outPin, HIGH);
}
}

The debounce function is called (used) with the pin number of the switch you want to debounce; the function returns true if the switch is pressed and stable. It returns false if it is not pressed or not yet stable.

142 | Chapter 5: Simple Digital and Analog Input

Discussion
The debounce method checks to see if it gets the same reading from the switch after a delay that needs to be long enough for the switch contacts to stop bouncing. You may require longer intervals for “bouncier” switches (some switches can require as much as
50 ms or more). The function works by repeatedly checking the state of the switch for as many milliseconds as defined in the debounce time. If the switch remains stable for this time, the state of the switch will be returned (true if pressed and false if not). If the switch state changes within the debounce period, the counter is reset so that the checks start over until the switch state does not change within the debounce time.
If your wiring uses pull-up resistors instead of pull-down resistors (see Recipe 5.2) you need to invert the value returned from the debounce function, because the state goes
LOW when the switch is pressed using pull-ups, but the function should return true
(true is the same as HIGH) when the switch is pressed. The debounce code using pullups is as follows; only the last four lines (highlighted) are changed from the previous version: boolean debounce(int pin)
{
boolean state; boolean previousState;

}

previousState = digitalRead(pin);
// store switch state for(int counter=0; counter < debounceDelay; counter++)
{
delay(1);
// wait for 1 millisecond state = digitalRead(pin); // read the pin if( state != previousState)
{
counter = 0; // reset the counter if the state changes previousState = state; // and save the current state
}
}
// here when the switch state has been stable longer than the debounce period if(state == LOW) // LOW means pressed (because pull-ups are used) return true; else return false;

For testing, you can add a count variable to display the number of presses. If you view this on the Serial Monitor (see Chapter 4), you can see whether it increments once per press. Increase the value of debounceDelay until the count keeps step with the presses.
The following fragment prints the value of count when used with the debounce function shown earlier: int count;

// add this variable to store the number of presses

void setup()
{
pinMode(inPin, INPUT);

5.3 Reliably Detecting the Closing of a Switch | 143

}

pinMode(outPin, OUTPUT);
Serial.begin(9600); // add this to the setup function void loop()
{
if(debounce(inPin))
{
digitalWrite(outPin, HIGH); count++; // increment count
Serial.println(count); // display the count on the Serial Monitor
}
}

This debounce() function will work for any number of switches, but you must ensure that the pins used are in input mode.
A potential disadvantage of this method for some applications is that from the time the debounce function is called, everything waits until the switch is stable. In most cases this doesn’t matter, but your sketch may need to be attending to other things while waiting for your switch to stabilize. You can use the code shown in Recipe 5.4 to overcome this problem.

See Also
See the Debounce example sketch distributed with Arduino. From the File menu, select
Examples→Digital→Debounce.

5.4 Determining How Long a Switch Is Pressed
Problem
Your application wants to detect the length of time a switch has been in its current state. Or you want to increment a value while a switch is pushed and you want the rate to increase the longer the switch is held (the way many electronic clocks are set). Or you want to know if a switch has been pressed long enough for the reading to be stable
(see Recipe 5.3).

Solution
The following sketch demonstrates the setting of a countdown timer. The wiring is the same as in Figure 5-5 from Recipe 5.2. Pressing a switch sets the timer by incrementing the timer count; releasing the switch starts the countdown. The code debounces the switch and accelerates the rate at which the counter increases when the switch is held for longer periods. The timer count is incremented by one when the switch is initially pressed (after debouncing). Holding the switch for more than one second increases the increment rate by four; holding the switch for four seconds increases the rate by ten.

144 | Chapter 5: Simple Digital and Analog Input

Releasing the switch starts the countdown, and when the count reaches zero, a pin is set HIGH (in this example, lighting an LED):
/*
SwitchTime sketch
Countdown timer that decrements every tenth of a second lights an LED when 0
Pressing button increments count, holding button down increases rate of increment
*/
const int ledPin = 13; const int inPin = 2; const int debounceTime = 20; for the switch to be stable const int fastIncrement = 1000; milliseconds const int veryFastIncrement = 4000; this many milliseconds int count = 0; second until reaches 0

// the number of the output pin
// the number of the input pin
// the time in milliseconds required
// increment faster after this many
// and increment even faster after
// count decrements every tenth of a

void setup()
{
pinMode(inPin, INPUT); digitalWrite(inPin, HIGH); // turn on pull-up resistor pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}

void loop()
{
int duration = switchTime(); if( duration > veryFastIncrement) count = count + 10; else if ( duration > fastIncrement) count = count + 4; else if ( duration > debounceTime) count = count + 1; else {
// switch not pressed so service the timer if( count == 0) digitalWrite(ledPin, HIGH); // turn the LED on if the count is 0 else { digitalWrite(ledPin, LOW);
// turn the LED off if the count is not 0 count = count - 1;
// and decrement the count
}
}

5.4 Determining How Long a Switch Is Pressed | 145

}

Serial.println(count); delay(100); // return the time in milliseconds that the switch has been in pressed (LOW) long switchTime()
{
// these variables are static - see Discussion for an explanation static unsigned long startTime = 0; // the time the switch state change was first detected static boolean state;
// the current state of the switch

}

if(digitalRead(inPin) != state) // check to see if the switch has changed state
{
state = ! state;
// yes, invert the state startTime = millis(); // store the time
}
if( state == LOW) return millis() - startTime;
// switch pushed, return time in milliseconds else return 0; // return 0 if the switch is not pushed (in the HIGH state);

Discussion
The heart of this recipe is the switchTime function. This returns the number of milliseconds that the switch has been pressed. Because this recipe uses internal pull-up resistors (see Recipe 5.2), the digitalRead of the switch pin will return LOW when the switch is pressed.
The loop checks the value returned from switchTime to see what should happen. If the time the switch has been held down is long enough for the fastest increment, the counter is incremented by that amount; if not, it checks the fast value to see if that should be used; if not, it checks if the switch has been held down long enough to stop bouncing and if so, it increments a small amount. At most, one of those will happen. If none of them are true, the switch is not being pressed, or it has not been pressed long enough to have stopped bouncing. The counter value is checked and an LED is turned on if it is zero; if it’s not zero, the counter is decremented and the LED is turned off.
You can use the switchTime function just for debouncing a switch. The following code handles debounce logic by calling the switchTime function: const int debounceTime = 20; needs to be stable

// the time in milliseconds that the switch

if( switchTime() > debounceTime);
Serial.print("switch is debounced");

This approach to debouncing can be handy if you have more than one switch, because you can peek in and look at the amount of time a switch has been pressed and process other tasks while waiting for a switch to become stable. To implement this, you need to store the current state of the switch (pressed or not) and the time the state last
146 | Chapter 5: Simple Digital and Analog Input

changed. There are many ways to do this—in this example, you will use a separate function for each switch. You could store the variables associated with all the switches at the top of your sketch as global variables (called “global” because they are accessible everywhere). But it is more convenient to have the variables for each switch contained with the function.
Retaining values of variables defined in a function is achieved by using static variables. Static variables within a function provide permanent storage for values that must be maintained between function calls. A value assigned to a static variable is retained even after the function returns. The last value set will be available the next time the function is called. In that sense, static variables are similar to the global variables (variables declared outside a function, usually at the beginning of a sketch) that you saw in the other recipes. But unlike global variables, static variables declared in a function are only accessible within that function. The benefit of static variables is that they cannot be accidentally modified by some other function.
This sketch shows an example of how you can add separate functions for different switches. The wiring for this is similar to Recipe 5.2, with the second switch wired similarly to the first (as shown in Figure 5-5) but connected between pin 3 and Gnd:
/*
SwitchTimeMultiple sketch
Prints how long more than one switch has been pressed
*/
const int switchAPin = 2; const int switchBPin = 3;

// the pin for switch A
// the pin for switch B

// functions with references must be explicitly declared unsigned long switchTime(int pin, boolean &state, unsigned long

&startTime);

void setup()
{
pinMode(switchAPin, INPUT); digitalWrite(switchAPin, HIGH); // turn on pull-up resistors pinMode(switchBPin, INPUT); digitalWrite(switchBPin, HIGH); // turn on pull-up resistors
Serial.begin(9600);
} void loop()
{
unsigned long time;
Serial.print("switch A time ="); time = switchATime();
Serial.print(time);
Serial.print(", switch B time ="); time = switchBTime();
Serial.println(time);
delay(1000);

5.4 Determining How Long a Switch Is Pressed | 147

} unsigned long switchTime(int pin, boolean &state, unsigned long &startTime)
{
if(digitalRead(pin) != state) // check to see if the switch has changed state
{
state = ! state;
//yes, invert the state startTime = millis(); // store the time
}
if( state == LOW) return millis() - startTime;
// return the time in milliseconds else return 0; // return 0 if the switch is not pushed (in the HIGH state);
}
long switchATime()
{
// these variables are static - see text for an explanation static unsigned long startTime = 0;
// the time the switch state change was first detected static boolean state;
// the current state of the switch return switchTime(switchAPin, state, startTime);
}
long switchBTime()
{
// these variables are static - see text for an explanation static unsigned long startTime = 0;
// the time the switch state change was first detected static boolean state;
// the current state of the switch return switchTime(switchBPin, state, startTime);
}

The time calculation is performed in a function called switchTime(). This function examines and updates the switch state and duration. The function uses references to handle the parameters—references were covered in Recipe 2.11. A function for each switch (switchATime() and switchBTime()) is used to retain the start time and state for each switch. Because the variables holding the values are declared as static, the values will be retained when the functions exit. Holding the variables within the function ensures that the wrong variable will not be used. The pins used by the switches are declared as global variables because the values are needed by setup to configure the pins. But because these variables are declared with the const keyword, the compiler will not allow the values to be modified, so there is no chance that these will be accidentally changed by the sketch code.
Limiting the exposure of a variable becomes more important as projects become more complex. The Arduino environment provides a more elegant way to handle this; see
Recipe 16.4 for a discussion on how to implement this using classes.

148 | Chapter 5: Simple Digital and Analog Input

5.5 Reading a Keypad
Problem
You have a matrix keypad and want to read the key presses in your sketch. For example, you have a telephone-style keypad similar to the SparkFun 12-button keypad (SparkFun COM-08653).

Solution
Wire the rows and columns from the keypad connector to the Arduino, as shown in
Figure 5-6.

Figure 5-6. Connecting the SparkFun keyboard matrix

If you’ve wired your Arduino and keypad as shown in Figure 5-6, the following sketch will print key presses to the Serial Monitor:
/*

Keypad sketch prints the key pressed on a keypad to the serial port

*/ const int numRows = 4;
// number of rows in the keypad const int numCols = 3;
// number of columns const int debounceTime = 20; // number of milliseconds for switch to be stable

5.5 Reading a Keypad | 149

// keymap defines the character returned when the corresponding key is pressed const char keymap[numRows][numCols] = {
{ '1', '2', '3' } ,
{ '4', '5', '6' } ,
{ '7', '8', '9' } ,
{ '*', '0', '#' }
};
// this array determines the pins used for rows and columns const int rowPins[numRows] = { 7, 2, 3, 6 }; // Rows 0 through 3 const int colPins[numCols] = { 5, 8, 4 };
// Columns 0 through 2 void setup()
{
Serial.begin(9600); for (int row = 0; row < numRows; row++)
{
pinMode(rowPins[row],INPUT);
// Set row pins as input digitalWrite(rowPins[row],HIGH); // turn on Pull-ups
}
for (int column = 0; column < numCols; column++)
{
pinMode(colPins[column],OUTPUT);
// Set column pins as outputs for writing digitalWrite(colPins[column],HIGH); // Make all columns inactive
}
} void loop()
{
char key = getKey(); if( key != 0) {
// if the character is not 0 then it's a valid key press
Serial.print("Got key ");
Serial.println(key);
}
}
// returns with the key pressed, or 0 if no key is pressed char getKey()
{
char key = 0;
// 0 indicates no key pressed for(int column = 0; column < numCols; column++)
{
digitalWrite(colPins[column],LOW);
//
for(int row = 0; row < numRows; row++)
//
{ if(digitalRead(rowPins[row]) == LOW)
//
{ delay(debounceTime); // while(digitalRead(rowPins[row]) == LOW)
;
// key = keymap[row][column];
//
}
}

150 | Chapter 5: Simple Digital and Analog Input

Activate the current column.
Scan all rows for a key press.
Is a key pressed? debounce wait for key to be released
Remember which key was pressed.

digitalWrite(colPins[column],HIGH);
// De-activate the current column.
}
return key; // returns the key pressed or 0 if none
}

This sketch will only work correctly if the wiring agrees with the code. Table 5-1 shows how the rows and columns should be connected to Arduino pins. If you are using a different keypad, check your data sheet to determine the row and column connections.
Check carefully, as incorrect wiring can short out the pins, and that could damage your controller chip.
Table 5-1. Mapping of Arduino pins to SparkFun connector and keypad rows and columns
Arduino pin

Keypad connector

Keypad row/column

2

7

Row 1

3

6

Row 2

4

5

Column 2

5

4

Column 0

6

3

Row 3

7

2

Row 0

8

1

Column 1

Discussion
Matrix keypads typically consist of Normally Open switches that connect a row with a column when pressed. (A Normally Open switch only makes electrical connection when pushed.) Figure 5-6 shows how the internal conductors connect the button rows and columns to the keyboard connector. Each of the four rows is connected to an input pin and each column is connected to an output pin. The setup function sets the pin modes and enables pull-up resistors on the input pins (see the pull-up recipes in the beginning of this chapter).
The getkey function sequentially sets the pin for each column LOW and then checks to see if any of the row pins are LOW. Because pull-up resistors are used, the rows will be high (pulled up) unless a switch is closed (closing a switch produces a LOW signal on the input pin). If they are LOW, this indicates that the switch for that row and column is closed. A delay is used to ensure that the switch is not bouncing (see Recipe 5.3); the code waits for the switch to be released, and the character associated with the switch is found in the keymap array and returned from the function. A 0 is returned if no switch is pressed.
A library in the Arduino Playground that is similar to the preceding example provides more functionality. The library makes it easier to handle different numbers of keys and it can be made to work while sharing some of the pins with an LCD. You can find the library at http://www.arduino.cc/playground/Main/KeypadTutorial.

5.5 Reading a Keypad | 151

See Also
For more information on the SparkFun 12-button keypad, go to http://www.sparkfun
.com/commerce/product_info.php?products_id=8653.

5.6 Reading Analog Values
Problem
You want to read the voltage on an analog pin. Perhaps you want a reading from a potentiometer (pot) or a device or sensor that provides a voltage between 0 and 5 volts.

Solution
This sketch reads the voltage on an analog pin and flashes an LED in a proportional rate to the value returned from the analogRead function. The voltage is adjusted by a potentiometer connected as shown in Figure 5-7:
/*
Pot sketch blink an LED at a rate set by the position of a potentiometer
*/
const int potPin = 0; const int ledPin = 13; int val = 0;

// select the input pin for the potentiometer
// select the pin for the LED
// variable to store the value coming from the sensor

void setup()
{
pinMode(ledPin, OUTPUT);
}

// declare the ledPin as an OUTPUT

void loop() { val = analogRead(potPin); digitalWrite(ledPin, HIGH); delay(val); digitalWrite(ledPin, LOW); delay(val); }

// read the voltage on the pot
// turn the ledPin on
// blink rate set by pot value (in milliseconds)
// turn the ledPin off
// turn led off for same period as it was turned on

Discussion
This sketch uses the analogRead function to read the voltage on the potentiometer’s wiper (the center pin). A pot has three pins; two are connected to a resistive material and the third pin (usually in the middle) is connected to a wiper that can be rotated to make contact anywhere on the resistive material. As the potentiometer rotates, the resistance between the wiper and one of the pins increases, while the other decreases.
The schematic diagram for this recipe (Figure 5-7) may help you visualize how a potentiometer works; as the wiper moves toward the bottom end, the wiper (the line with
152 | Chapter 5: Simple Digital and Analog Input

Figure 5-7. Connecting a potentiometer to Arduino

the arrow) will have lower resistance connecting to Gnd and higher resistance connecting to 5 volts. As the wiper moves down, the voltage on the analog pin will decrease
(to a minimum of 0 volts). Moving the wiper upward will have the opposite effect, and the voltage on the pin will increase (up to a maximum of 5 volts).
If the voltage on the pin decreases, rather than increases, as you increase the rotation of the potentiometer, you can reverse the connections to the +5 volts and Gnd pins.

The voltage is measured using analogRead, which provides a value proportional to the actual voltage on the analog pin. The value will be 0 when there are 0 volts on the pin and 1,023 when there are 5 volts. A value in between will be proportional to the ratio of the voltage on the pin to 5 volts.
Potentiometers with a value of 10K ohms are the best choice for connecting to analog pins. See this book’s website for recommended part numbers. potPin does not need to be set as input. (This is done for you automatically each time you call analogRead.)

See Also
Appendix B, for tips on reading schematic diagrams
Arduino reference for analogRead: http://www.arduino.cc/en/Reference/AnalogRead

5.6 Reading Analog Values | 153

Getting Started with Arduino by Massimo Banzi (Make)

5.7 Changing the Range of Values
Problem
You want to change the range of a value, such as the value from analogRead obtained by connecting a potentiometer or other device that provides a variable voltage. For example, suppose you want to display the position of a potentiometer knob as a percentage from 0 percent to 100 percent.

Solution
Use the Arduino map function to scale values to the range you want. This sketch reads the voltage on a pot into the variable val and scales this from 0 to 100 as the pot is rotated from one end to the other. It blinks an LED with a rate proportional to the voltage on the pin and prints the scaled range to the serial port (see Recipe 4.2 for instructions on monitoring the serial port). Recipe 5.6 (see Figure 5-7) shows how the pot is connected:
/*
*
*
*
*
*/

Map sketch map the range of analog values from a pot to scale from 0 to 100 resulting in an LED blink rate ranging from 0 to 100 milliseconds. and Pot rotation percent is written to the serial port

const int potPin = 0; int ledPin = 13;

// select the input pin for the potentiometer
// select the pin for the LED

void setup()
{
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}

// declare the ledPin as an OUTPUT

void loop() { int val; int percent;

// The value coming from the sensor
// The mapped value

val = analogRead(potPin);

}

//
//
percent = map(val,0,1023,0,100); // digitalWrite(ledPin, HIGH);
//
delay(percent);
//
digitalWrite(ledPin, LOW);
//
delay(100 - percent);
//
Serial.println(percent);
//

154 | Chapter 5: Simple Digital and Analog Input

read the voltage on the pot (val ranges from 0 to 1023) percent will range from 0 to 100. turn the ledPin on
On time given by percent value turn the ledPin off
Off time is 100 minus On time show the % of pot rotation on Serial Monitor

Discussion
Recipe 5.6 describes how the position of a pot is converted to a value. Here you use this value with the map function to scale the value to your desired range. In this example, the value provided by analogRead (0 to 1023) is mapped to a percentage (0 to 100). The values from analogRead will range from 0 to 1023 if the voltage ranges from 0 to 5 volts, but you can use any appropriate values for the source and target ranges. For example, a typical pot only rotates 270 degrees from end to end, and if you wanted to display the angle of the knob on your pot, you could use this code: angle = map(val,0,1023,0,270); // angle of pot derived from analogRead val

Range values can also be negative. If you want to display 0 when the pot is centered and negative values when the pot is rotated left and positive values when it is rotated right, you can do this: angle = map(val,0,1023,-135,135); // show angle of 270 degree pot with center as 0

The map function can be handy where the input range you are concerned with does not start at zero. For example, if you have a battery where the available capacity is proportional to a voltage that ranges from 1.1 volts (1,100 millivolts) to 1.5 volts (1,500 millivolts), you can do the following: const int empty const int full

= 5000 / 1100; // the voltage is 1.1 volts (1100mv) when empty
= 5000 / 1500; // the voltage is 1.5 volts (1500mv) when full

int val = analogRead(potPin);
// read the analog voltage int percent = map(val, empty, full, 0,100); // map the actual range of voltage to a percent
Serial.println(percent);

(See Recipe 5.9 for more details on how analogRead values relate to actual voltage.)

See Also
The Arduino reference for map: http://www.arduino.cc/en/Reference/Map

5.8 Reading More Than Six Analog Inputs
Problem
You have more analog inputs to monitor than you have available analog pins. A standard Arduino board has six analog inputs (the Mega has 16) and there may not be enough analog inputs available for your application. Perhaps you want to adjust eight parameters in your application by turning knobs on eight potentiometers.

5.8 Reading More Than Six Analog Inputs | 155

Solution
Use a multiplexer chip to select and connect multiple voltage sources to one analog input. By sequentially selecting from multiple sources, you can read each source in turn.
This recipe uses the popular 4051 chip connected to Arduino as shown in Figure 5-8.
Your analog inputs get connected to the 4051 pins marked Ch 0 to Ch 7. Make sure the voltage on the channel input pins is never higher than 5 volts:
/*
multiplexer sketch read 1 of 8 analog values into single analog input pin with 4051 multiplexer
*/
// array of pins used to select 1 of 8 inputs on multiplexer const int select[] = {2,3,4}; // array of the pins connected to the 4051 input select lines const int analogPin = 0;
// the analog pin connected to the multiplexer output // this function returns the analog value for the given channel int getValue( int channel)
{
// the following sets the selector pins HIGH and LOW to match the binary value of channel for(int bit = 0; bit < 3; bit++)
{
int pin = select[bit]; // the pin wired to the multiplexer select bit int isBitSet = bitRead(channel, bit); // true if given bit set in channel digitalWrite(pin, isBitSet);
}
return analogRead(analogPin);
}
void setup()
{
for(int bit = 0; bit < 3; bit++) pinMode(select[bit], OUTPUT); // set the three select pins to output
Serial.begin(9600);
} void loop () {
// print the values for each channel once per second for(int channel = 0; channel < 8; channel++)
{
int value = getValue(channel);
Serial.print("Channel ");
Serial.print(channel);
Serial.print(" = ");
Serial.println(value);
} delay (1000);
}

156 | Chapter 5: Simple Digital and Analog Input

Figure 5-8. The 4051 multiplexer connected to Arduino

Discussion
Analog multiplexers are digitally controlled analog switches. The 4051 selects one of eight inputs through three selector pins (S0, S1, and S2). There are eight different combinations of values for the three selector pins, and the sketch sequentially selects each of the possible bit patterns; see Table 5-2.
Table 5-2. Truth table for 4051 multiplexer
Selector pins

Selected input

S2

S1

S0

0

0

0

0

0

0

1

1

0

1

0

2

0

1

1

3

1

0

0

4

1

0

1

5

1

1

0

6

1

1

1

7

You may recognize the pattern in Table 5-2 as the binary representation of the decimal values from 0 to 7.
In the preceding sketch, getValue() is the function that sets the correct selector bits for the given channel using digitalWrite(pin, isBitSet) and reads the analog value from
5.8 Reading More Than Six Analog Inputs | 157

Download from Wow! eBook

the selected 4051 input with analogRead(analogPin). The code to produce the bit patterns uses the built-in bitRead function (see Recipe 3.12).
Don’t forget to connect the ground from the devices you are measuring to the ground on the 4051 and Arduino, as shown in Figure 5-8.

Bear in mind that this technique selects and monitors the eight inputs sequentially, so it requires more time between the readings on a given input compared to using analog
Read directly. If you are reading eight inputs, it will take eight times longer for each input to be read. This may make this method unsuitable for inputs that change value quickly. See Also
Arduino Playground tutorial for the 4051: http://www.arduino.cc/playground/Learning/
4051
CD4051 data sheet: http://www.fairchildsemi.com/ds/CD%2FCD4052BC.pdf
Analog/digital MUX breakout board data sheet: http://www.nkcelectronics.com/analog digital-mux-breakout.html 5.9 Displaying Voltages Up to 5V
Problem
You want to monitor and display the value of a voltage between 0 and 5 volts. For example, suppose you want to display the voltage of a single 1.5V cell on the Serial
Monitor.

Solution
Use AnalogRead to measure the voltage on an analog pin. Convert the reading to a voltage by using the ratio of the reading to the reference voltage (5 volts), as shown in
Figure 5-9.

158 | Chapter 5: Simple Digital and Analog Input

Figure 5-9. Measuring voltages up to 5 volts using 5V board

The simplest solution uses a floating-point calculation to print the voltage; this example sketch calculates and prints the ratio as a voltage:
/*

Display5vOrless sketch prints the voltage on analog pin to the serial port
Warning - do not connect more than 5 volts directly to an Arduino pin.

*/ const int referenceVolts = 5; const int batteryPin = 0;

// the default reference on a 5-volt board
// battery is connected to analog pin 0

void setup()
{
Serial.begin(9600);
}
void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor float volts = (val / 1023) * referenceVolts; // calculate the ratio
Serial.println(volts); // print the value in volts
}

The formula is: Volts = (analog reading / analog steps) × Reference voltage
Printing a floating-point value to the serial port with println will format the value to two decimal places.

5.9 Displaying Voltages Up to 5V | 159

Make the following change if you are using a 3.3V board: const int referenceVolts = 3.3;

Floating-point numbers consume lots of memory, so unless you are already using floating point elsewhere in your sketch, it is more efficient to use integer values. The following code looks a little strange at first, but because analogRead returns a value of
1023 for 5 volts, each step in value will be 5 divided by 1,023. In units of millivolts, this is 5,000 divided by 1,023.
This code prints the value in millivolts: const int

batteryPin = 0;

void setup()
{
Serial.begin(9600);
}
void loop()
{
long val = analogRead(batteryPin);
// read the value from the sensor - note val is a long int
Serial.println( (val * (500000/1023)) / 100); // print the value in millivolts
}

The following code prints the value using decimal points. It prints 1.5 if the voltage is
1.5 volts. const int

batteryPin 0;

void setup()
{
Serial.begin(9600);
}
void loop()
{
int val = analogRead(batteryPin);
Serial.println(val/(1023/5));
Serial.print('.');
Serial.println(val % (1023/5));
}

// read the value from the sensor
// print the integer value of the voltage
// print the fraction

If you are using a 3.3V board, change (1023/5) to (int)(1023/3.3).

160 | Chapter 5: Simple Digital and Analog Input

Discussion
The analogRead() function returns a value that is proportional to the ratio of the measured voltage to the reference voltage (5 volts). To avoid the use of floating point, yet maintain precision, the code operates on values as millivolts instead of volts (there are
1,000 millivolts in 1 volt). Because a value of 1023 indicates 5,000 millivolts, each unit represents 5,000 divided by 1,023 millivolts (that is, 4.89 millivolts). To eliminate the decimal point, the values are multiplied by 100. In other words, 5,000 millivolts times
100 divided by 1,023 gives the number of millivolts times 100. Dividing this by 100 yields the value in millivolts. If multiplying fractional numbers by 100 to enable the compiler to perform the calculation using fixed-point arithmetic seems convoluted, you can stick to the slower and more memory-hungry floating-point method.
This solution assumes you are using a standard Arduino powered from 5 volts. If you are using a 3.3V board, the maximum voltage you can measure is 3.3 volts without using a voltage divider—see Recipe 5.11.

5.10 Responding to Changes in Voltage
Problem
You want to monitor one or more voltages and take some action when the voltage rises or falls below a threshold. For example, you want to flash an LED to indicate a low battery level—perhaps to start flashing when the voltage drops below a warning threshold and increasing in urgency as the voltage drops further.

Solution
You can use the connections shown in Figure 5-7 in Recipe 5.9, but here we’ll compare the value from analogRead to see if it drops below a threshold. This example starts flashing an LED at 1.2 volts and increases the on-to-off time as the voltage decreases below the threshold. If the voltage drops below a second threshold, the LED stays lit:
/*
RespondingToChanges sketch flash an LED to indicate low voltage levels
*/
long warningThreshold = 1200; long criticalThreshold = 1000;

// Warning level in millivolts - LED flashes
// Critical voltage level - LED stays on

const int batteryPin = 0; const int ledPin = 13; void setup()
{
pinMode(ledPin, OUTPUT);
}

5.10 Responding to Changes in Voltage | 161

void loop()
{
int val = analogRead(batteryPin);
// read the value from the sensor if( val < (warningThreshold * 1023L)/5000) {
// in the line above, L following a number makes it a 32 bit value flash(val) ;
}
}
// function to flash an led with on/off time determined by value passed as percent void flash(int percent)
{
digitalWrite(ledPin, HIGH); delay(percent + 1); digitalWrite(ledPin, LOW); delay(100 - percent ); // check delay == 0?
}

Discussion
The highlighted line in this sketch calculates the ratio of the value read from the analog port to the value of the threshold voltage. For example, with a warning threshold of
1 volt and a reference voltage of 5 volts, you want to know when the analog reading is one-fifth of the reference voltage. The expression 1023L tells the compiler that this is a long integer (a 32-bit integer; see Recipe 2.2), so the compiler will promote all the variables in this expression to long integers to prevent overflowing the capacity of an int (a normal 16-bit integer).
When reading analog values, you can work in the units that are returned from analog
Read—ranging from 0 to 1023—or you can work in the actual voltages they represent
(see Recipe 5.7). As in this recipe, if you are not displaying voltage, it’s simpler and more efficient to use the output of analogRead directly.

5.11 Measuring Voltages More Than 5V (Voltage Dividers)
Problem
You want to measure voltages greater than 5 volts. For example, you want to display the voltage of a 9V battery and trigger an alarm LED when the voltage falls below a certain level.

Solution
Use a solution similar to Recipe 5.9, but connect the voltage through a voltage divider
(see Figure 5-10). For voltages up to 10 volts, you can use two 4.7K ohm resistors. For higher voltages, you can determine the required resistors using Table 5-3.

162 | Chapter 5: Simple Digital and Analog Input

Figure 5-10. Voltage divider for measuring voltages greater than 5 volts
Table 5-3. Resistor values
Calculation
Max voltage

R1

R2

R2(R1 + R2)

value of resistorFactor

5

Short (+V connected to analog pin)

None (Gnd connected to
Gnd)

None

1023

10

1K

1K

1(1 + 1)

511

15

2K

1K

1(2 + 1)

341

20

3K

1K

1(3 + 1)

255

30

4K (3.9K)

1K

1(4 + 1)

170

Select the row with the highest voltage you need to measure to find the values for the two resistors:
/*
DisplayMoreThan5V sketch prints the voltage on analog pin to the serial port
Do not connect more than 5 volts directly to an Arduino pin.
*/
const int referenceVolts = 5;
//const float referenceVolts = 3.3;

// the default reference on a 5-volt board
// use this for a 3.3-volt board

const int R1 = 1000; // value for a maximum voltage of 10 volts const int R2 = 1000;
// determine by voltage divider resistors, see text const int resistorFactor = 1023.0 / (R2/(R1 + R2)); const int batteryPin = 0;
// +V from battery is connected to analog pin 0

5.11 Measuring Voltages More Than 5V (Voltage Dividers) | 163

Download from Wow! eBook

void setup()
{
Serial.begin(9600);
}
void loop()
{
int val = analogRead(batteryPin); // read the value from the sensor float volts = (val / resistorFactor) * referenceVolts ; // calculate the ratio
Serial.println(volts); // print the value in volts
}

Discussion
Like the previous analog recipes, this recipe relies on the fact that the analogRead value is a ratio of the measured voltage to the reference. But because the measured voltage is divided by the two dropping resistors, the analogRead value needs to be multiplied to get the actual voltage. This code is similar to Recipe 5.7, but the value of resistorFactor is selected based on the voltage divider resistors as shown in Table 5-3: const int resistorFactor = 511; see Table 5-3

// determine by voltage divider resistors,

The value read from the analog pin is divided not by 1,023, but by a value determined by the dropping resistors: float volts = (val / resistorFactor) * referenceVolts ; // calculate the ratio

The calculation used to produce the table is based on the following formula: the output voltage is equal to the input voltage times R2 divided by the sum of R1 and R2. In the example where two equal-value resistors are used to drop the voltage from a 9V battery by half, resistorFactor is 511 (half of 1,023), so the value of the volts variable will be twice the voltage that appears on the input pin. With resistors selected for 10 volts, the analog reading from a 9V battery will be approximately 920.
More than 5 volts on the pin can damage the pin and possibly destroy the chip; double-check that you have chosen the right value resistors and wired them correctly before connecting them to an Arduino input pin. If you have a multimeter, measure the voltage before connecting anything that could possibly carry voltages higher than 5 volts.

164 | Chapter 5: Simple Digital and Analog Input

CHAPTER 6

Getting Input from Sensors

6.0 Introduction
Getting and using input from sensors enables Arduino to respond to or report on the world around it. This is one of the most common tasks you will encounter. This chapter provides simple and practical examples of how to use the most popular input devices and sensors. Wiring diagrams show how to connect and power the devices, and code examples demonstrate how to use data derived from the sensors.
Sensors respond to input from the physical world and convert this into an electrical signal that Arduino can read on an input pin. The nature of the electrical signal provided by a sensor depends on the kind of sensor and how much information it needs to transmit. Some sensors (such as photoresistors and Piezo knock sensors) are constructed from a substance that alters their electrical properties in response to physical change. Others are sophisticated electronic modules that use their own microcontroller to process information before passing a signal on for the Arduino.
Sensors use the following methods to provide information:
Digital on/off
Some devices, such as the tilt sensor in Recipe 6.1 and the motion sensor in Recipe 6.3, simply switch a voltage on and off. These can be treated like the switch recipes shown in Chapter 5.
Analog
Other sensors provide an analog signal (a voltage that is proportional to what is being sensed, such as temperature or light level). The recipes for detecting light
(Recipe 6.2), motion (Recipes 6.1 and 6.3), vibration (Recipe 6.6), sound (Recipe 6.7), and acceleration (Recipe 6.18) demonstrate how analog sensors can be used. All of them use the analogRead command that is discussed in Chapter 5.
Pulse width
Distance sensors, such as the PING))) in Recipe 6.4, provide data using pulse duration proportional to the distance value. These sensors measure the duration of a pulse using the pulseIn command.
165

Serial
Some sensors provide values using a serial protocol. For example, the RFID reader in Recipe 6.9 and the GPS in Recipe 6.14 communicate through the Arduino serial port (see Chapter 4 for more on serial). Most Arduino boards only have one hardware serial port, so read Recipe 6.14 for an example of how you can add additional software serial ports if you have multiple serial sensors or the hardware serial port is occupied for some other task.
Synchronous protocols: I2C and SPI
The I2C and SPI digital standards were created for microcontrollers like Arduino to talk to external sensors and modules. Recipe 6.16 shows how a compass module is connected using synchronous digital signaling. These protocols are used extensively for sensors, actuators, and peripherals, and they are covered in detail in
Chapter 13.
There is another generic class of sensing devices that you may make use of. These are consumer devices that contain sensors but are sold as devices in their own right, rather than as sensors. Examples of these in this chapter include a PS2 mouse and a PlayStation game controller. These devices can be very useful; they provide sensors already incorporated into robust and ergonomic devices. They are also inexpensive (often less expensive than buying the raw sensors that they contain), as they are mass-produced.
You may have some of these lying around.
If you are using a device that is not specifically covered in a recipe, you may be able to adapt a recipe for a device that produces a similar type of output. Information about a sensor’s output signal is usually available from the company from which you bought the device or from a data sheet for your device (which you can find through a Google search of the device part number or description).
Data sheets are aimed at engineers designing products to be manufactured, and they usually provide more detail than you need to just get the product up and running. The information on output signal will usually be in a section referring to data format, interface, output signal, or something similar. Don’t forget to check the maximum voltage
(usually in a section labeled “Absolute Maximum Ratings”) to ensure that you don’t damage the component.
Sensors designed for a maximum of 3.3 volts can be destroyed by connecting them to 5 volts. Check the absolute maximum rating for your device before connecting.

Reading sensors from the messy analog world is a mixture of science, art, and perseverance. You may need to use ingenuity and trial and error to get a successful result. A common problem is that the sensor just tells you a physical condition has occurred, not what caused it. Putting the sensor in the right context (location, range, orientation) and limiting its exposure to things that you don’t want to activate it are skills you will acquire with experience.
166 | Chapter 6: Getting Input from Sensors

Another issue concerns separating the desired signal from background noise; Recipe 6.6 shows how you can use a threshold to detect when a signal is above a certain level, and Recipe 6.7 shows how you can take the average of a number of readings to smooth out noise spikes.

See Also
For information on connecting electronic components, see Make: Electronics by
Charles Platt (Make).
See the introduction to Chapter 5 and Recipe 5.6 for more on reading analog values from sensors.

6.1 Detecting Movement
Problem
You want to detect when something is moved, tilted, or shaken.

Solution
This sketch uses a switch that closes a circuit when tilted, called a tilt sensor. The switch recipes in Chapter 5 (Recipes 5.1 and 5.2) will work with a tilt sensor substituted for the switch.
The sketch below (circuit shown in Figure 6-1) will switch on the LED attached to pin
11 when the tilt sensor is tilted one way, and the LED connected to pin 12 when it is tilted the other way:
/*
tilt sketch a tilt sensor attached to pin 2, lights one of the LEDs connected to pins 11 and 12 depending on which way the sensor is tilted
*/
const int tiltSensorPin = 2; const int firstLEDPin = 11; const int secondLEDPin = 12;

//pin the tilt sensor is connected to
//pin for one LED
//pin for the other

void setup()
{
pinMode (tiltSensorPin, INPUT); digitalWrite (tiltSensorPin, HIGH);

//the code will read this pin
// and use a pull-up resistor

pinMode (firstLEDPin, OUTPUT); pinMode (secondLEDPin, OUTPUT);

//the code will control this pin
//and this one

}

6.1 Detecting Movement | 167

void loop()
{
if (digitalRead(tiltSensorPin)){ digitalWrite(firstLEDPin, HIGH); digitalWrite(secondLEDPin, LOW);
}
else{ digitalWrite(firstLEDPin, LOW); digitalWrite(secondLEDPin, HIGH);
}
}

//check if the pin is high
//if it is high turn on firstLED
//and turn off secondLED
//if it isn't
//do the opposite

Figure 6-1. Tilt sensor and LEDs

Discussion
The most common tilt sensor is a ball bearing in a box with contacts at one end. When the box is tilted the ball rolls away from the contacts and the connection is broken.
When the box is tilted to roll the other way the ball touches the contacts and completes a circuit. Markings, or pin configurations, show which way the sensor should be oriented. Tilt sensors are sensitive to small movements of around 5 to 10 degrees when oriented with the ball just touching the contacts. If you position the sensor so that the ball bearing is directly above (or below) the contacts, the LED state will only change if it is turned right over. This can be used to tell if something is upright or upside down.
To determine if something is being shaken, you need to check how long it’s been since the state of the tilt sensor changed (this recipe’s Solution just checks if the switch was open or closed). If it hasn’t changed for a time you consider significant, the object is not shaking. Changing the orientation of the tilt sensor will change how vigorous the shaking needs to be to trigger it. The following code lights an LED when the sensor is shaken: 168 | Chapter 6: Getting Input from Sensors

/* shaken sketch tilt sensor connected to pin 2 led connected to pin 13

*/

const int tiltSensorPin = 2; const int ledPin = 13; int tiltSensorPreviousValue = 0; int tiltSensorCurrentValue = 0; long lastTimeMoved = 0; int shakeTime=50; void setup()
{
pinMode (tiltSensorPin, INPUT); digitalWrite (tiltSensorPin, HIGH); pinMode (ledPin, OUTPUT);
}
void loop()
{
tiltSensorCurrentValue=digitalRead(tiltSensorPin); if (tiltSensorPreviousValue != tiltSensorCurrentValue){ lastTimeMoved = millis(); tiltSensorPreviousValue = tiltSensorCurrentValue;
}

}

if (millis() - lastTimeMoved < shakeTime){ digitalWrite(ledPin, HIGH);
}
else{ digitalWrite(ledPin, LOW);
}

Many mechanical switch sensors can be used in similar ways. A float switch can turn on when the water level in a container rises to a certain level (similar to the way a ball cock works in a toilet cistern). A pressure pad such as the one used in shop entrances can be used to detect when someone stands on it. If your sensor turns a digital signal on and off, something similar to this recipe’s sketch should be suitable.

See Also
Chapter 5 contains background information on using switches with Arduino.
Recipe 12.2 has more on using the millis function to determine delay.

6.1 Detecting Movement | 169

6.2 Detecting Light
Problem
You want to detect changes in light levels. You may want to detect a change when something passes in front of a light detector or to measure the light level—for example, detecting when a room is getting too dark.

Solution
The easiest way to detect light levels is to use a light dependent resistor (LDR). This changes resistance with changing light levels, and when connected in the circuit shown in Figure 6-2 it produces a change in voltage that the Arduino analog input pins can sense. Figure 6-2. Connecting a light dependent resistor

Discussion
The circuit for this recipe is the standard way to use any sensor that changes its resistance based on some physical phenomenon (see Chapter 5 for background information on responding to analog signals). The circuit in Figure 6-2 will change the voltage on analog pin 0 when the resistance of the LDR changes with varying light levels.
A circuit such as this will not give the full range of possible values from the analog input—0 to 1,023—as the voltage will not be swinging from 0 volts to 5 volts. This is because there will always be a voltage drop across each resistance, so the voltage where they meet will never reach the limits of the power supply. When using sensors such as these, it is important to check the actual values the device returns in the situation you
170 | Chapter 6: Getting Input from Sensors

will be using it. Then you have to determine how to convert them to the values you need to control whatever you are going to control. See Recipe 5.7 for more details on changing the range of values.
The LDR is a simple kind of sensor called a resistive sensor. A range of resistive sensors respond to changes in different physical characteristics. The same circuit will work for any kind of simple resistive sensor.

6.3 Detecting Motion (Integrating Passive Infrared Detectors)
Problem
You want to detect when people are moving near a sensor.

Solution
Use a motion sensor such as a Passive Infrared (PIR) sensor to change values on a digital pin when someone moves nearby.
Sensors such as the SparkFun PIR Motion Sensor (SEN-08630) and the Parallax PIR
Sensor (555-28027) can be easily connected to Arduino pins, as shown in Figure 6-3.

Figure 6-3. Connecting a PIR motion sensor

Check the data sheet for your sensor to identify the correct pins. The Parallax sensor has pins marked “OUT”, “-”, and “+” (for Output, Gnd, and +5V). The SparkFun sensor is marked with “Alarm”, “GND”, and “DC” (for Output, Gnd, and +5V).

6.3 Detecting Motion (Integrating Passive Infrared Detectors) | 171

The following sketch will light the LED on Arduino pin 13 when the sensor detects motion: /*

PIR sketch a Passive Infrared motion sensor connected to pin 2 lights the LED on pin 13

*/ const int ledPin = 13; const int inputPin = 2; void setup() { pinMode(ledPin, OUTPUT); pinMode(inputPin, INPUT);
}

// choose the pin for the LED
// choose the input pin (for the PIR sensor)

void loop(){ int val = digitalRead(inputPin); if (val == HIGH)
{
digitalWrite(ledPin, HIGH); delay(500); digitalWrite(ledPin, LOW);
}
}

// declare LED as output
// declare pushbutton as input

// read input value
// check if the input is HIGH
// turn LED on if motion detected
// turn LED off

Discussion
This code is similar to the pushbutton examples shown in Chapter 5. That’s because the sensor acts like a switch when motion is detected. Different kinds of PIR sensors are available, and you should check the information for the one you have connected.
Some sensors, such as the Parallax, have a jumper that determines how the output behaves when motion is detected. In one mode, the output remains HIGH while motion is detected, or it can be set so that the output goes HIGH briefly and then LOW when triggered. The example sketch in this recipe’s Solution will work in either mode.
Other sensors may go LOW on detecting motion. If your sensor’s output pin goes LOW when motion is detected, change the line that checks the input value so that the LED is turned on when LOW: if (val == LOW)

// motion when the input is LOW

PIR sensors come in a variety of styles and are sensitive over different distances and angles. Careful choice and positioning can make them respond to movement in part of a room, rather than all of it.
PIR sensors respond to heat and can be triggered by animals such as cats and dogs, as well as by people and other heat sources.

172 | Chapter 6: Getting Input from Sensors

6.4 Measuring Distance
Problem
You want to measure the distance to something, such as a wall or someone walking toward the Arduino.

Solution
This recipe uses the popular Parallax PING))) ultrasonic distance sensor to measure the distance of an object ranging from 2 cm to around 3 m. It displays the distance on the Serial Monitor and flashes an LED faster as objects get closer (Figure 6-4 shows the connections): /* Ping))) Sensor
* prints distance and changes LED flash rate
* depending on distance from the Ping))) sensor
*/
const int pingPin = 5; const int ledPin = 13; // pin connected to LED void setup()
{
Serial.begin(9600); pinMode(ledPin, OUTPUT);
}
void loop()
{
int cm = ping(pingPin) ;
Serial.println(cm);
digitalWrite(ledPin, HIGH); delay(cm * 10 ); // each centimeter adds 10 milliseconds delay digitalWrite(ledPin, LOW); delay( cm * 10);
}
// following code based on http://www.arduino.cc/en/Tutorial/Ping
// returns the distance in cm int ping(int pingPin)
{
// establish variables for duration of the ping,
// and the distance result in inches and centimeters: long duration, cm;
// The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
// Give a short LOW pulse beforehand to ensure a clean HIGH pulse: pinMode(pingPin, OUTPUT); digitalWrite(pingPin, LOW); delayMicroseconds(2); digitalWrite(pingPin, HIGH);

6.4 Measuring Distance | 173

delayMicroseconds(5); digitalWrite(pingPin, LOW); pinMode(pingPin, INPUT); duration = pulseIn(pingPin, HIGH);
// convert the time into a distance cm = microsecondsToCentimeters(duration); return cm ;
}
long microsecondsToCentimeters(long microseconds)
{
// The speed of sound is 340 m/s or 29 microseconds per centimeter.
// The ping travels out and back, so to find the distance of the
// object we take half of the distance travelled. return microseconds / 29 / 2;
}

Figure 6-4. Ping))) sensor connections

Discussion
Ultrasonic sensors provide a measurement of the time it takes for sound to bounce off an object and return to the sensor.
The “ping” sound pulse is generated when the pingPin level goes HIGH for two microseconds. The sensor will then generate a pulse that terminates when the sound returns.
The width of the pulse is proportional to the distance the sound traveled and the sketch then uses the pulseIn function to measure that duration. The speed of sound is 340 meters per second, which is 29 microseconds per centimeter. The formula for the distance of the round trip is: RoundTrip = microseconds / 29
174 | Chapter 6: Getting Input from Sensors

So, the formula for the one-way distance in centimeters is: microseconds / 29 / 2
The MaxBotix EZ1 is another ultrasonic sensor that can be used to measure distance.
It is easier to integrate than the Ping))) because it does not need to be “pinged.” It can provide continuous distance information, either as an analog voltage or proportional to pulse width. Figure 6-5 shows the connections.

Figure 6-5. Connecting EZ1 PW output to a digital input pin

The sketch that follows uses the EZ1 pulse width output to produce output similar to that of the previous sketch:
/*
* EZ1Rangefinder Distance Sensor
* prints distance and changes LED flash rate
* depending on distance from the Ping))) sensor
*/
const int sensorPin = 5; const int ledPin = 13; // pin connected to LED long value = 0; int cm = 0; int inches = 0; void setup()
{
Serial.begin(9600); pinMode(ledPin, OUTPUT);
}
void loop()
{
value = pulseIn(sensorPin, HIGH) ; cm = value / 58;
// pulse width is 58 microseconds per cm inches = value / 147;
// which is 147 microseconds per inch

6.4 Measuring Distance | 175

Serial.print(cm);
Serial.print(',');
Serial.println(inches); digitalWrite(ledPin, HIGH); delay(cm * 10 ); // each centimeter adds 10 milliseconds delay digitalWrite(ledPin, LOW); delay( cm * 10); delay(20); }

The EZ1 is powered through +5V and ground pins and these are connected to the respective Arduino pins. Connect the EZ1 PW pin (PW is the Pulse Width output) to
Arduino digital pin 5. The sketch measures the width of the pulse with the pulseIn command. The width of the pulse is 58 microseconds per centimeter, or 147 microseconds per inch.
You can also obtain a distance reading from the EZ1 through its analog output— connect the AN pin to an analog input and read the value with analogRead. The following code prints the analog input converted to inches: value = analogRead(0); inches = value / 2;
// each digit of analog read is around 5mv
Serial.println(inches);

The analog output is around 9.8 mV per inch. The value from analogRead is around
4.8 mV per unit (see Recipe 5.6 for more on analogRead) and the preceding code rounds these so that each group of two units is one inch. The rounding error is small compared to the accuracy of the device, but if you want a more precise calculation you can use floating point as follows: value = analogRead(0); float mv = (value /1024.0) * 5000 ; float Inches = mv / 9.8; // 9.8mv per inch
Serial.println(Inches) ;

See Also
Recipe 5.6 explains how to convert readings from analogInput into voltage values.
The Arduino reference for pulseIn: http://www.arduino.cc/en/Reference/PulseIn

6.5 Measuring Distance Accurately
Problem
You want to measure how far objects are from the Arduino with more accuracy than in Recipe 6.4.

176 | Chapter 6: Getting Input from Sensors

Solution
Infrared (IR) sensors generally provide an analog output that can be measured using analogRead. They can have greater accuracy than ultrasonic sensors, albeit with a smaller range (a range of 10 cm to 1 m or 2 m is typical for IR sensors). This sketch provides similar functionality to Recipe 6.4, but it uses an infrared sensor—the Sharp
GP2Y0A02YK0F (Figure 6-6 shows the connections):
/* ir-distance sketch
* prints distance and changes LED flash rate based on distance from IR sensor
*/
const int ledPin
= 13; // the pin connected to the LED to flash const int sensorPin = 0; // the analog pin connected to the sensor const long referenceMv = 5000; // long int to prevent overflow when multiplied void setup()
{
Serial.begin(9600); pinMode(ledPin, OUTPUT);
}
void loop()
{
int val = analogRead(sensorPin); int mV = (val * referenceMv) / 1023;
Serial.print(mV);
Serial.print(","); int cm = getDistance(mV);
Serial.println(cm);
digitalWrite(ledPin, HIGH); delay(cm * 10 ); // each centimeter adds 10 milliseconds delay digitalWrite(ledPin, LOW); delay( cm * 10);
}

delay(100);
// the following is used to interpolate the distance from a table
// table entries are distances in steps of 250 millivolts const int NBR_ELEMS = 10; const int firstElement = 250; // first entry is 250 mV const int interval = 250; // millivolts between each element static int distance[TABLE_ENTRIES] = {150,140,130,100,60,50,40,35,30,25,20,15}; int getDistance(int mV)
{
if( mV > INTERVAL * TABLE_ENTRIES ) return distance[TABLE_ENTRIES-1]; else {

6.5 Measuring Distance Accurately | 177

int index = mV / INTERVAL; float frac = (mV % 250) / (float)INTERVAL; return distance[index] - ((distance[index] - distance[index+1]) * frac);
}

}

Figure 6-6. Connecting the Sharp IR distance sensor

Discussion
The output from the IR sensor is not linear—in other words, the value read from analogRead is not proportional to distance. So, the calculation is more complicated than the one used in Recipe 6.4. The sketch in this recipe’s Solution uses a table to interpolate the actual distance by finding the nearest entry in the table and adjusting it based on the ratio of the measured value to the next table entry (this technique is called interpolating). You may need to adjust the table values for your sensor—you can do this with information from your data sheet or through trial and error.
As values for the table can be found by trial and error (measuring the voltage until it changes by the required amount, and then measuring the distance), this technique can also be used when you don’t have an equation to interpret the values—for example, when you don’t have a part data sheet for the device you are using.

The conversion from voltage to distance is done in this function: int getDistance(int mV)

178 | Chapter 6: Getting Input from Sensors

The function first checks if the value is within the range given in the table. The shortest valid distance is returned if the value is not within range: if( mV > INTERVAL * TABLE_ENTRIES ) return distance[TABLE_ENTRIES-1]; //TABLE_ENTRIES-1 is last valid entry

If the value is within the table range, integer division calculates which entry is closest but is lower than the reading: int index = mV / INTERVAL ;

The modulo operator (see Chapter 3) is used to calculate a fractional value when a reading falls between two entries: float frac = (mV % 250) / (float)INTERVAL; return distance[index] + (distance[index]* (frac / interval));

The last line in the getDistance function uses the index and fraction to calculate and return a distance value. It reads the value from the table, and then adds a proportion of that value based on the frac value. This final element is an approximation, but as it is for a small range of the result, it gives acceptable results. If it is not accurate enough for you, you need to produce a table with more values closer together.
A table can also be used to improve performance if the calculation takes significant time to complete, or is done repeatedly with a limited number of values. Calculations, particularly with floating point, can be slow. Replacing the calculation with a table can speed things up.
The values can either be hardcoded into the sketch, like this one, or be calculated in setup(). This may make the sketch take longer to start, but as this only happens once each time the Arduino gets power, you will then get a speed gain every time around the main loop(). The trade-off for the speed is that the table consumes memory—the bigger the table, the more RAM memory used. See Chapter 17 for help using Progmem to store data in program memory.
You may need to add a capacitor across the +5V and Gnd lines to stabilize the power supply to the sensor so that the connecting leads are not kept short. If you get erratic readings, connect a 10 uF capacitor at the sensor (see Appendix C for more on using decoupling capacitors).

See Also
A detailed explanation of the Sharp IR sensor is available at http://www.societyofrobots
.com/sensors_sharpirrange.shtml.

6.5 Measuring Distance Accurately | 179

6.6 Detecting Vibration
Problem
You want to respond to vibration; for example, when a door is knocked.

Solution
A Piezo sensor responds to vibration. It works best when connected to a larger surface that vibrates. Figure 6-7 shows the connections:
/* piezo sketch
* lights and LED when the Piezo is tapped
*/
const int sensorPin = 0; // the analog pin connected to the sensor const int ledPin = 13;
// pin connected to LED const int THRESHOLD = 100; void setup()
{
pinMode(ledPin, OUTPUT);
}
void loop()
{
int val = analogRead(sensorPin); if (val >= THRESHOLD)
{
digitalWrite(ledPin, HIGH); delay(100); // to make the LED visible
}
else digitalWrite(ledPin, LOW);
}

Discussion
A Piezo sensor, also known as a knock sensor, produces a voltage in response to physical stress. The more it is stressed, the higher the voltage. The Piezo is polarized and the positive side (usually a red wire or a wire marked with a “+”) is connected to the analog input; the negative wire (usually black or marked with a “-”) is connected to ground.
A high-value resistor (1 megohm) is connected across the sensor.

180 | Chapter 6: Getting Input from Sensors

Figure 6-7. Knock sensor connections

The voltage is detected by Arduino analogRead to turn on an LED (see Chapter 5 for more about the analogRead function). The THRESHOLD value determines the level from the sensor that will turn on the LED, and you can decrease or increase this value to make the sketch more or less sensitive.
Piezo sensors can be bought in plastic cases or as bare metal disks with two wires attached. The components are the same; use whichever fits your project best.
Some sensors, such as the Piezo, can be driven by the Arduino to produce the thing that they can sense. Chapter 9 has more about using a Piezo to generate sound.

6.7 Detecting Sound
Problem
You want to detect sounds such as clapping, talking, or shouting.

Solution
This recipe uses the BOB-08669 breakout board for the Electret Microphone (SparkFun). Connect the board as shown in Figure 6-8 and load the code to the board.

6.7 Detecting Sound | 181

Figure 6-8. Microphone board connections

The built-in LED on Arduino pin 13 will turn on when you clap, shout, or play loud music near the microphone. You may need to adjust the threshold—use the Serial
Monitor to view the high and low values, and change the threshold value so that it is between the high values you get when noise is present and the low values when there is little or no noise. Upload the changed code to the board and try again:
/*
microphone sketch
SparkFun breakout board for Electret Microphone is connected to analog pin 0
*/
const int ledPin = 13; const int middleValue = 512; const int numberOfSamples = 128;

//the code will flash the LED in pin 13
//the middle of the range of analog values
//how many readings will be taken each time

int sample; long signal; long averageReading;

//the value read from microphone each time
//the reading once you have removed DC offset
//the average of that loop of readings

long runningAverage=0; const int averagedOver= 16;

//the running average of calculated values
//how quickly new values affect running average
//bigger numbers mean slower

const int threshold=400;

//at what level the light turns on

void setup() { pinMode(ledPin, OUTPUT);
Serial.begin(9600);
} void loop() { long sumOfSquares = 0; for (int i=0; ithreshold){ digitalWrite(ledPin, HIGH);
}else{
digitalWrite(ledPin, LOW);
}
Serial.println(runningAverage);

//is average more than the threshold ?
//if it is turn on the LED
//if it isn't turn the LED off
//print the value so you can check it

}

Discussion
A microphone produces very small electrical signals. If you connected it straight to the pin of an Arduino, you would not get any detectable change. The signal needs to be amplified first to make it usable by Arduino. The SparkFun board has the microphone with an amplifier circuit built in to amplify the signal to a level readable by Arduino.
Because you are reading an audio signal in this recipe, you will need to do some additional calculations to get useful information. An audio signal is changing fairly quickly, and the value returned by analogRead will depend on what point in the undulating signal you take a reading. If you are unfamiliar with using analogRead, see Chapter 5 and
Recipe 6.2. An example waveform for an audio tone is shown in Figure 6-9. As time changes from left to right, the voltage goes up and down in a regular pattern. If you take readings at the three different times marked on it, you will get three different values.
If you used this to make decisions, you might incorrectly conclude that the signal got louder in the middle.
An accurate measurement requires multiple readings taken close together. The peaks and troughs increase as the signal gets bigger. The difference between the bottom of a trough and the top of a peak is called the amplitude of the signal, and this increases as the signal gets louder.

6.7 Detecting Sound | 183

Figure 6-9. Audio signal measured in three places

To measure the size of the peaks and troughs, you measure the difference between the midpoint voltage and the levels of the peaks and troughs. You can visualize this midpoint value as a line running midway between the highest peak and the lowest trough, as shown in Figure 6-10. The line represents the DC offset of the signal (it’s the DC value when there are no peaks or troughs). If you subtract the DC offset value from your analogRead values, you get the correct reading for the signal amplitude.

Figure 6-10. Audio signal showing DC offset (signal midpoint)

As the signal gets louder, the average size of these values will increase, but as some of them are negative (where the signal has dropped below the DC offset), they will cancel each other out, and the average will tend to be zero. To fix that, we square each value
(multiply it by itself). This will make all the values positive, and it will increase the difference between small changes, which helps you evaluate changes as well. The average value will now go up and down as the signal amplitude does.
184 | Chapter 6: Getting Input from Sensors

To do the calculation, we need to know what value to use for the DC offset. To get a clean signal, the amplifier circuit for the microphone will have been designed to have a DC offset as close as possible to the middle of the possible range of voltage so that the signal can get as big as possible without distorting. The code assumes this and uses the value 512 (right in the middle of the analog input range of 0 to 1,023).
The values of variables at the top of the sketch can be varied if the sketch does not trigger well for the level of sound you want.
The numberOfSamples is set at 128—if it is set too small, the average may not adequately cover complete cycles of the waveform and you will get erratic readings. If the value is set too high, you will be averaging over too long a time, and a very short sound might be missed as it does not produce enough change once a large number of readings are averaged. It could also start to introduce a noticeable delay between a sound and the light going on. Constants used in calculations, such as numberOfSamples and averaged
Over, are set to powers of 2 (128 and 16, respectively). Try to use values evenly divisible by two for these to give you the fastest performance (see Chapter 3 for more on math functions). 6.8 Measuring Temperature
Problem
You want to display the temperature or use the value to control a device; for example, to switch something on when the temperature reaches a threshold.

Solution
This recipe displays the temperature in Fahrenheit and Celsius (Centigrade) using the popular LM35 heat detection sensor. The sensor looks similar to a transistor and is connected as shown in Figure 6-11:
/*
lm35 sketch prints the temperature to the Serial Monitor
*/
const int inPin = 0; // analog pin void setup()
{
Serial.begin(9600);
}
void loop()
{
int value = analogRead(inPin);

6.8 Measuring Temperature | 185

Serial.print(value); Serial.print(" > "); float millivolts = (value / 1024.0) * 5000; float celsius = millivolts / 10; // sensor output is 10mV per degree Celsius
Serial.print(celsius);
Serial.print(" degrees Celsius, ");
Serial.print( (celsius * 9)/ 5 + 32 );
Serial.println(" degrees Fahrenheit");

//

converts to fahrenheit

delay(1000); // wait for one second
}

Figure 6-11. Connecting the LM35 temperature sensor

Discussion
The LM35 temperature sensor produces an analog voltage directly proportional to temperature with an output of 1 millivolt per 0.1°C (10 mV per degree).
The sketch converts the analogRead values into millivolts (see Chapter 5) and divides this by 10 to get degrees.
The sensor accuracy is around 0.5°C, and in many cases you can use integer math instead of floating point.
The following sketch turns on pin 2 when the temperature is above a threshold: const int inPin = 0; // sensor connected to this analog pin const int outPin = 13; //2; // digital output pin const int threshold = 25; // the degrees celsius that will trigger the output pin

186 | Chapter 6: Getting Input from Sensors

void setup()
{
Serial.begin(9600); pinMode(outPin, OUTPUT);
}
void loop()
{
int value = analogRead(inPin); long celsius = (value * 500L) /1024;
Serial.print(celsius);
Serial.print(" degrees Celsius: "); if(celsius > threshold)
{
digitalWrite(outPin, HIGH);
Serial.println("pin is on");
}
else
{
digitalWrite(outPin, LOW);
Serial.println("pin is off");
}
delay(1000); // wait for one second
}

// 10 mV per degree c, see text

The sketch uses long (32-bit) integers to calculate the value. The letter L after the number causes the calculation to be performed using long integer math, so the multiplication of the maximum temperature (500 on a 5V Arduino) and the value read from the analog input does not overflow. See the recipes in Chapter 5 for more about converting analog levels into voltage values.
If you need the values in Fahrenheit, you could use the LM34 sensor, as this produces an output in Fahrenheit, or you can convert the values in this recipe using the following formula: float

f = (celsius * 9)/ 5 + 32 );

6.9 Reading RFID Tags
Problem
You want to read an RFID tag and respond to specific IDs.

Solution
Figure 6-12 shows a Parallax RFID (radio frequency identification) reader connected to the Arduino serial port. (You may need to disconnect the reader from the serial port when uploading the sketch.)

6.9 Reading RFID Tags | 187

Figure 6-12. Serial RFID reader connected to Arduino

The sketch reads and displays the value of an RFID tag:
/*
RFID sketch
Displays the value read from an RFID tag
*/
const const const const int int int int startByte
= 10; // ASCII line feed precedes each tag endByte = 13; // ASCII carriage return terminates each tag tagLength = 10; // the number of digits in tag totalLength = tagLength + 2; //tag length + start and end bytes

char tag[tagLength + 1];

// holds the tag and a terminating null

int bytesread = 0; void setup()
{
Serial.begin(2400); pinMode(2,OUTPUT); digitalWrite(2, LOW);
}

// set this to the baud rate of your RFID reader
// connected to the RFID ENABLE pin
// enable the RFID reader

void loop()
{
if(Serial.available() >= totalLength) // check if there's enough data
{
if(Serial.read() == startByte)
{
bytesread = 0;
// start of tag so reset count to 0

188 | Chapter 6: Getting Input from Sensors

while(bytesread < tagLength) // read 10 digit code
{
int val = Serial.read(); if((val == startByte)||(val == endByte)) // check for end of code break; tag[bytesread] = val; bytesread = bytesread + 1; // ready to read next digit
}
if( Serial.read() == endByte) // check for the correct end character
{
tag[bytesread] = 0; // terminate the string
Serial.print("RFID tag is: ");
Serial.println(tag);
}
}

}

}

Discussion
A tag consists of a start character followed by a 10-digit tag and is terminated by an end character. The sketch waits for a complete tag message to be available and displays the tag if it is valid. The tag is received as ASCII digits (see Recipe 4.4 for more on receiving ASCII digits). You may want to convert this into a number if you want to store or compare the values received. To do this, change the last few lines as follows: if( Serial.read() == endByte) // check for the correct end character
{
tag[bytesread] = 0; // terminate the string long tagValue = atol(tag); // convert the ASCII tag to a long integer
Serial.print("RFID tag is: ");
Serial.println(tagValue);
}

RFID stands for radio frequency identification, and as the name implies, it is sensitive to radio frequencies and can be prone to interference. The code in this recipe’s Solution will only use code of the correct length that contains the correct start and end bits, which should eliminate most errors. But you can make the code more resilient by reading the tag more than once and only using the data if it’s the same each time. (RFID readers such as the Parallax will repeat the code while a valid card is near the reader.)
To do this, add the following lines to the last few lines in the preceding code snippet: if( Serial.read() == endByte) // check for the correct end character
{
tag[bytesread] = 0; // terminate the string long tagValue = atol(tag); // convert the ASCII tag to a long integer if (tagValue == lastTagValue)
{
Serial.print("RFID tag is: ");
Serial.println(tagValue);
lasTagValue = tagValue;
}
}

6.9 Reading RFID Tags | 189

You will need to add the declaration for lastTagValue at the top of the sketch:
Long lastTagValue=0;

This approach is similar to the code from Recipe 5.3. It means you will only get confirmation of a card if it is presented long enough for two readings to be taken, but false readings will be less likely. You can avoid accidental triggering by making it necessary for the card to be present for a certain amount of time before the number is reported.

6.10 Tracking the Movement of a Dial
Problem
You want to measure and display the rotation of something to track its speed and/or direction. Solution
To sense this kind of movement you could use a rotary encoder. Connect the encoder as shown in Figure 6-13:
/*
Read a rotary encoder
This simple version polls the encoder pins
The position is displayed on the Serial Monitor
*/
const int const int const int int angle

encoderPinA = 4; encoderPinB = 2; encoderStepsPerRevolution=16; = 0;

int val; int encoderPos = 0; boolean encoderALast = LOW;

// remembers the previous pin state

void setup()
{
pinMode(encoderPinA, INPUT); pinMode(encoderPinB, INPUT); digitalWrite(encoderPinA, HIGH); digitalWrite(encoderPinB, HIGH);
Serial.begin (9600);
}
void loop()
{
boolean encoderA = digitalRead(encoderPinA);

190 | Chapter 6: Getting Input from Sensors

Download from Wow! eBook

if ((encoderALast == HIGH) && (encoderA == LOW))
{
if (digitalRead(encoderPinB) == LOW)
{
encoderPos--;
}
else
{
encoderPos++;
}
angle=(encoderPos % encoderStepsPerRevolution)*360/encoderStepsPerRevolution;
Serial.print (encoderPos);
Serial.print (" ");
Serial.println (angle);
}
}

encoderALast = encoderA;

Figure 6-13. Rotary encoder

Discussion
A rotary encoder produces two signals as it is turned. Both signals alternate between
HIGH and LOW as the shaft is turned, but the signals are slightly out of phase with each other. If you detect the point where one of the signals changes from HIGH to LOW, the state of the other pin (whether it is HIGH or LOW) will tell you which way the shaft is rotating. 6.10 Tracking the Movement of a Dial | 191

Download from Wow! eBook

So, the first line of code in the loop function reads one of the encoder pins: int encoderA = digitalRead(encoderPinA);

Then it checks this value and the previous one to see if the value has just changed to LOW: if ((encoderALast == HIGH) && (encoderA == LOW))

If it has not, the code doesn’t execute the following block; it goes to the bottom of loop, saves the value it has just read in encoderALast, and goes back around to take a fresh reading.
When the following expression is true: if ((encoderALast == HIGH) && (encoderA == LOW))

the code reads the other encoder pin and increments or decrements encoderPos depending on the value returned. It calculates the angle of the shaft (taking 0 to be the point the shaft was at when the code started running). It then sends the values down the serial port so that you can see it in the Serial Monitor.
Encoders come in different resolutions, quoted as steps per revolution. This indicates how many times the signals alternate between HIGH and LOW for one revolution of the shaft. Values can vary from 16 to 1,000. The higher values can detect smaller movements, and these encoders cost much more money. The value for the encoder is hardcoded in the code in the following line: const int encoderStepsPerRevolution=16;

If your encoder is different, you need to change that to get the correct angle values.
If you get values out that don’t go up and down, but increase regardless of the direction you turn the encoder, try changing the test to look for a rising edge rather than a falling one. Swap the LOW and HIGH values in the line that checks the values so that it looks like this: if ((encoderALast == LOW) && (encoderA == HIGH))

Rotary encoders just produce an increment/decrement signal; they cannot directly tell you the shaft angle. The code calculates this, but it will be relative to the start position each time the code runs. The code monitors the pins by polling (continuously checking the value of) them. There is no guarantee that the pins have not changed a few times since the last time the code looked, so if the code does lots of other things as well, and the encoder is turned very quickly, it is possible that some of the steps will be missed.
For high-resolution encoders this is more likely, as they will send signals much more often as they are turned.
To work out the speed, you need to count how many steps are registered in one direction in a set time.

192 | Chapter 6: Getting Input from Sensors

6.11 Tracking the Movement of More Than One Rotary Encoder
Problem
You have two or more rotary encoders and you want to measure and display rotation.

Solution
The circuit uses two encoders, connected as shown in Figure 6-14. You can read more about rotary encoders in Recipe 6.10:
/*

RotaryEncoderMultiPoll
This sketch has two encoders connected.
One is connected to pins 2 and 3
The other is connected to pins 4 and 5
*/

const int

ENCODERS = 2; // the number of encoders

const int encoderPinA[ENCODERS] = {2,4}; const int encoderPinB[ENCODERS] = {3,5}; int encoderPos[ ENCODERS] = { 0,0}; boolean encoderALast[ENCODERS] = { LOW,LOW};

//
//
//
//

encoderA pins on 2 and 4 encoderB pins on 3 and 5 initialize the positions to 0 holds last state of encoderA pin

void setup()
{
for (int i=2; i 2000)
Serial.println("Data is getting STALE!"); else Serial.println("Latitude and longitude valid!");

See Also
TinyGPS and NewSoftSerial are available for download at http://arduiniana.org/libra ries/newsoftserial. For a deeper understanding of the NMEA protocol, read the Wikipedia article at http:
//en.wikipedia.org/wiki/NMEA.
Several shops sell GPS modules that interface well with TinyGPS and Arduino. These differ mostly in power consumption, voltage, accuracy, physical interface, and whether they support serial NMEA. SparkFun (http://www.sparkfun.com) carries a large range of GPS modules and has an excellent buyer’s guide.
GPS technology has inspired lots of creative Arduino projects. A very popular example is the GPS data logger, in which a moving device records location data at regular intervals to the Arduino EEPROM or other on-board storage. See the breadcrumbs project at http://code.google.com/p/breadcrumbs/wiki/UserDocument for an example.
Ladyada makes a popular GPS data logging shield; see http://www.ladyada.net/make/ gpsshield/. 6.14 Getting Location from a GPS | 205

Other interesting GPS projects include hobby airplanes and helicopters that maneuver themselves to preprogrammed destinations under Arduino software control. Mikal
Hart built a GPS-enabled “treasure chest” with an internal latch that cannot be opened until the box is physically moved to a certain location. See http://arduiniana.org.

6.15 Detecting Rotation Using a Gyroscope
Problem
You want to respond to the rate of rotation. This can be used to keep a vehicle moving in a straight line or turning at a desired rate.

Solution
Most low-cost gyroscopes use an analog voltage proportional to rotation rate, although some also provide output using I2C (see Chapter 13 for more on using I2C to communicate with devices). This recipe works with a gyro with an analog output proportional to rotation rate. Figure 6-16 shows an LISY300AL breakout board from
SparkFun. Many low-cost gyros, such as the one used here, are 3.3V devices and must not be plugged into the 5V power pin.
Check the maximum voltage of your gyro before connecting power.
Plugging a 3.3V gyro into 5 volts can permanently damage the device.

Figure 6-16. LISY300AL gyro connected using 3.3V pin

The Gyro OUT connection is the analog output and is connected to Arduino analog input 0. The PD connection enables the gyro to be switched into low power mode and
206 | Chapter 6: Getting Input from Sensors

is connected to analog pin 1 (in this sketch, it is used as a digital output pin). You can connect PD to any digital pin; the pin used here was chosen to keep the wiring neater.
If you don’t need to switch the gyro into low-power mode, you can connect the PD line to Gnd.
Analog pins can also be used as digital pins 14 to 19 if they are not needed for reading analog values. See the introduction to Chapter 5 for more on using Arduino analog and digital pins.

The ST (self-test) line is for testing and can be left unconnected:
/*

gyro sketch displays the rotation rate on the Serial Monitor
*/

const int inputPin = 0;
// analog input 0 const int powerDownPin = 15; // analog input 1 is digital input 15 int rotationRate = 0; void setup()
{
Serial.begin(9600);
// sets the serial port to 9600 pinMode(powerDownPin, OUTPUT); digitalWrite(powerDown, LOW); // gyro not in power down mode
}
void loop()
{
rotationRate = analogRead(inputPin);
// read the gyro output
Serial.print("rotation rate is ");
Serial.println(rotation rate); delay(100); // wait 100ms for next reading
}

Discussion
This sketch sets the powerDownPin to LOW to get the gyro running in normal mode (you can eliminate this code from setup if you have wired the PD pin to Gnd).
Analog input pins can be used as digital pins (but not the other way around). Analog input 0 is digital pin 14; analog input 1 is digital pin
15, and so on.

The loop code reads the gyro value on analog pin 0 and displays this on the Serial
Monitor.
6.15 Detecting Rotation Using a Gyroscope | 207

6.16 Detecting Direction
Problem
You want your sketch to determine direction from an electronic compass.

Solution
This recipe uses the HM55B compass module from Parallax (#29123). Figure 6-17 shows the connections:
/*

HM55bCompass sketch uses 'software SPI' serial protocol implemented using Arduino bit functions
(see Chapter 3) prints compass angle to Serial Monitor
*/

const int enablePin = 2; const int clockPin = 3; const int dataPin
= 4;
// command const byte const byte const byte const byte const byte

codes (from HM55B data sheet)
COMMAND_LENGTH = 4;
//
RESET_COMMAND = B0000;
//
MEASURE_COMMAND = B1000;
//
READ_DATA_COMMAND = B1100; //
MEASUREMENT_READY = B1100; //

the number of bits in a command reset the chip start a measurement read data and end flag value returned when measurement complete

int angle; void setup()
{
Serial.begin(9600); pinMode(enablePin, OUTPUT); pinMode(clockPin, OUTPUT); pinMode(dataPin, INPUT); reset(); // reset the compass module
}
void loop()
{
startMeasurement(); delay(40); // wait for the data to be ready if (readStatus()==MEASUREMENT_READY); // check if the data is ready
{
angle = readMeasurement();
//read measurement and calculate angle
Serial.print("Angle = ");
Serial.println(angle); // print angle
}
delay(100);
}

208 | Chapter 6: Getting Input from Sensors

void reset()
{
pinMode(dataPin, OUTPUT); digitalWrite(enablePin, LOW); serialOut(RESET_COMMAND, COMMAND_LENGTH); digitalWrite(enablePin, HIGH);
}
void startMeasurement()
{
pinMode(dataPin, OUTPUT); digitalWrite(enablePin, LOW); serialOut(MEASURE_COMMAND, COMMAND_LENGTH); digitalWrite(enablePin, HIGH);
}
int readStatus()
{
int result = 0; pinMode(dataPin, OUTPUT); digitalWrite(enablePin, LOW); serialOut(READ_DATA_COMMAND, COMMAND_LENGTH); result = serialIn(4); return result;
// returns the status
}
int readMeasurement()
{
int X_Data = 0; int Y_Data = 0; int calcAngle = 0;
X_Data = serialIn(11); // Field strength in X
Y_Data = serialIn(11); // and Y direction digitalWrite(enablePin, HIGH); // deselect chip calcAngle = atan2(-Y_Data , X_Data) / M_PI * 180; // angle is atan(-y/x) if(calcAngle < 0) calcAngle = calcAngle + 360; // angle from 0 to 259 instead of plus/minus 180 return calcAngle;
}
void serialOut(int value, int numberOfBits)
{
for(int i = numberOfBits; i > 0; i--) // shift the MSB first
{
digitalWrite(clockPin, LOW); if(bitRead(value, i-1) == 1) digitalWrite(dataPin, HIGH); else digitalWrite(dataPin, LOW); digitalWrite(clockPin, HIGH);
}
} int serialIn(int numberOfBits)
{

6.16 Detecting Direction | 209

int result = 0; pinMode(dataPin, INPUT); for(int i = numberOfBits; i > 0; i--) // get the MSB first
{
digitalWrite(clockPin, HIGH); if (digitalRead(dataPin) == HIGH) result = (result 0; led--) { digitalWrite(ledPins[led], HIGH); delay(wait); digitalWrite(ledPins[led - 1], HIGH); delay(wait); digitalWrite(ledPins[led], LOW); delay(wait*2); }
}

Discussion
This code is similar to the code in Recipe 7.5, except the pins are turned on and off in a fixed sequence rather than depending on a sensor level. There are two for loops; the first produces the left-to-right pattern by lighting up LEDs from left to right. This loop starts with the first (leftmost) LED and steps through adjacent LEDs until it reaches and illuminates the rightmost LED. The second for loop lights the LEDs from right to left by starting at the rightmost LED and decrementing (decreasing by one) the LED that is lit until it gets to the first (rightmost) LED. The delay period is set by the wait variable and can be chosen to provide the most pleasing appearance.

7.6 Sequencing Multiple LEDs: Making a Chase Sequence (Knight Rider) | 233

7.7 Controlling an LED Matrix Using Multiplexing
Problem
You have a matrix of LEDs and want to minimize the number of Arduino pins needed to turn LEDs on and off.

Solution
This sketch uses an LED matrix of 64 LEDs with anodes connected in rows and cathodes in columns (as in the Futurlec LEDM88R). Dual-color LED displays may be easier to obtain, and you can drive just one of the colors if that is all you need. Figure 7-6 shows the connections:
/*
matrixMpx sketch
Sequence LEDs starting from first column and row until all LEDS are lit
Multiplexing is used to control 64 LEDs with 16 pins
*/
const int columnPins[] = { 2, 3, 4, 5, 6, 7, 8, 9}; const int rowPins[]
= { 10,11,12,15,16,17,18,19}; int pixel
= 0; int columnLevel = 0; int rowLevel
= 0;

// 0 to 63 LEDs in the matrix
// pixel value converted into LED column
// pixel value converted into LED row

void setup() { for (int i = 0; i < 8; i++)
{
pinMode(columnPins[i], OUTPUT); pinMode(rowPins[i], OUTPUT);
}
}

// make all the LED pins outputs

void loop() { pixel = pixel + 1; if(pixel > 63) pixel = 0; columnLevel = pixel / 8;
// map to the number of columns rowLevel = pixel % 8;
// get the fractional value for (int column = 0; column < 8; column++)
{
digitalWrite(columnPins[column], LOW);
// connect this column to Ground for(int row = 0; row < 8; row++)
{
if (columnLevel > column)
{
digitalWrite(rowPins[row], HIGH); // connect all LEDs in row to +5 volts
}
else if (columnLevel == column && rowLevel >= row)

234 | Chapter 7: Visual Output

{ digitalWrite(rowPins[row], HIGH);
}
else
{
digitalWrite(columnPins[column], LOW); // turn off all LEDs in this row
}
delayMicroseconds(300);
// delay gives frame time of 20ms for 64 LEDs digitalWrite(rowPins[row], LOW);
// turn off LED
}
digitalWrite(columnPins[column], HIGH); from Ground
}
}

// disconnect this column

Figure 7-6. An LED matrix connected to 16 digital pins
LED matrix displays do not have a standard pinout, so you must check the data sheet for your display. Wire the rows of anodes and columns of cathodes as shown in Figure 7-13 or Figure 7-14, but use the LED pin numbers shown in your data sheet.

7.7 Controlling an LED Matrix Using Multiplexing | 235

Discussion
The resistor’s value must be chosen to ensure that the maximum current through a pin does not exceed 40 mA. Because the current for up to eight LEDs can flow through each column pin, the maximum current for each LED must be one-eighth of 40 mA, or 5 mA. Each LED in a typical small red matrix has a forward voltage of around 1.8 volts. Calculating the resistor that results in 5 mA with a forward voltage of 1.8 volts gives a value of 680 ohms. Check your data sheet to find the forward voltage of the matrix you want to use. Each column of the matrix is connected through the series resistor to a digital pin. When the column pin goes low and a row pin goes high, the corresponding LED will light. For all LEDs where the column pin is high or its row pin is low, no current will flow through the LED and it will not light.
The for loop scans through each row and column and turns on sequential LEDs until all LEDs are lit. The loop starts with the first column and row and increments the row counter until all LEDs in that row are lit; it then moves to the next column, and so on, lighting another LED with each pass through the loop until all the LEDs are lit.
You can control the number of lit LEDs in proportion to the value from a sensor (see
Recipe 5.6 for connecting a sensor to the analog port) by making the following changes to the sketch.
Comment out or remove these three lines from the beginning of the loop: pixel = pixel + 1; if(pixel > 63) pixel = 0;

Replace them with the following lines that read the value of a sensor on pin 0 and map this to a number of pixels ranging from zero to 63: int sensorValue = analogRead(0); pixel = map(sensorValue, 0, 1023, 0, 63);
(LED)

// read the analog in value
// map sensor value to pixel

You can test this with a variable resistor connected to analog input pin 0 connected as shown in Figure 5-7 in Chapter 5. The number of LEDs lit will be proportional to the value of the sensor.

7.8 Displaying Images on an LED Matrix
Problem
You want to display one or more images on an LED matrix, perhaps creating an animation effect by quickly alternating multiple images.

236 | Chapter 7: Visual Output

Solution
This Solution can use the same wiring as in Recipe 7.7. The sketch creates the effect of a heart beating by briefly lighting LEDs arranged in the shape of a heart. A small heart followed by a larger heart is flashed for each heartbeat (the images look like Figure 7-7):
/*
* matrixMpxAnimation sketch
* animates two heart images to show a beating heart
*/
// the heart images are stored as bitmaps - each bit corresponds to an LED
// a 0 indicates the LED is off, 1 is on byte bigHeart[] = {
B01100110,
B11111111,
B11111111,
B11111111,
B01111110,
B00111100,
B00011000,
B00000000}; byte smallHeart[] = {
B00000000,
B00000000,
B00010100,
B00111110,
B00111110,
B00011100,
B00001000,
B00000000}; const int columnPins[] = { 2, 3, 4, 5, 6, 7, 8, 9}; const int rowPins[]
= { 10,11,12,15,16,17,18,19}; void setup() { for (int i = 0; i < 8; i++)
{
pinMode(rowPins[i], OUTPUT); pinMode(columnPins[i], OUTPUT); digitalWrite(columnPins[i], HIGH);
}
} void loop() { int pulseDelay = 800 ;

}

show(smallHeart, 80); show(bigHeart, 160); delay(pulseDelay); // make all the LED pins outputs
// disconnect column pins from Ground

// milliseconds to wait between beats
// show the small heart image for 100 ms
// followed by the big heart for 200ms
// show nothing between beats

7.8 Displaying Images on an LED Matrix | 237

// routine to show a frame of an image stored in the array pointed to by the image parameter.
// the frame is repeated for the given duration in milliseconds void show( byte * image, unsigned long duration)
{
unsigned long start = millis();
// begin timing the animation while (start + duration > millis())
// loop until the duration period has passed
{
for(int row = 0; row < 8; row++)
{
digitalWrite(rowPins[row], HIGH);
// connect row to +5 volts for(int column = 0; column < 8; column++)
{
boolean pixel = bitRead(image[row],column); if(pixel == 1)
{
digitalWrite(columnPins[column], LOW); // connect column to Gnd
}
delayMicroseconds(300);
// a small delay for each LED digitalWrite(columnPins[column], HIGH);
// disconnect column from Gnd
}
digitalWrite(rowPins[row], LOW);
// disconnect LEDs
}
}
}

Figure 7-7. The two heart images displayed on each beat

Discussion
Columns and rows are multiplexed (switched) similar to Recipe 7.7, but here the value written to the LED is based on images stored in the bigHeart and smallHeart arrays.
Each element in the array represents a pixel (a single LED) and each array row represents
238 | Chapter 7: Visual Output

a row in the matrix. A row consists of eight bits represented using binary format (as designated by the capital B at the start of each row). A bit with a value of 1 indicates that the corresponding LED should be on; a 0 means off. The animation effect is created by rapidly switching between the arrays.
The loop function waits a short time (800 milliseconds) between beats and then calls the show function, first with the smallheart array and then followed by the bigHeart array. The show function steps through each element in all the rows and columns, lighting the LED if the corresponding bit is 1. The bitRead function (see Recipe 2.20) is used to determine the value of each bit.
A short delay of 300 microseconds between each pixel allows the eye time to perceive the LED. The timing is chosen to allow each image to repeat quickly enough (50 times per second) so that blinking is not visible.
Here is a variation that changes the rate at which the heart beats, based on the value from a sensor. You can test this using a variable resistor connected to analog input pin
0, as shown in Recipe 5.6. Use the wiring and code shown earlier, except replace the loop function with this code: void loop() { sensorValue = analogRead(analogInPin);
// read the analog in value int pulseRate = map(sensorValue,0,1023,40,240); // convert to beats / minute int pulseDelay = (60000 / pulseRate ); // milliseconds to wait between beats

}

show(smallHeart, 80); show(bigHeart, 160); delay(pulseDelay); // show the small heart image for 100 ms
// followed by the big heart for 200ms
// show nothing between beats

This version calculates the delay between pulses using the map function (see Recipe 5.7) to convert the sensor value into beats per minute. The calculation does not account for the time it takes to display the heart, but you can subtract 240 milliseconds
(80 ms plus 160 ms for the two images) if you want more accurate timing.

See Also
Recipes 12.1 and 12.2 provide more information on how to manage time using the millis function.
See Recipes 7.12 and 7.13 for information on how to use shift registers to drive LEDs if you want to reduce the number of Arduino pins needed for driving an LED matrix.

7.9 Controlling a Matrix of LEDs: Charlieplexing
Problem
You have a matrix of LEDs and you want to minimize the number of pins needed to turn any of them on and off.
7.9 Controlling a Matrix of LEDs: Charlieplexing | 239

Solution
Charlieplexing is a special kind of multiplexing that increases the number of LEDs that can be driven by a group of pins. This sketch sequences through six LEDs using just three pins (Figure 7-8 shows the connections):
/*
* Charlieplexing sketch
* light six LEDs in sequence that are connected to pins 2, 3, and 4
*/
byte pins[] = {2,3,4};

// the pins that are connected to LEDs

// the next two lines infer number of pins and LEDs from the above array const int NUMBER_OF_PINS = sizeof(pins)/ sizeof(pins[0]); const int NUMBER_OF_LEDS = NUMBER_OF_PINS * (NUMBER_OF_PINS-1); byte pairs[NUMBER_OF_LEDS/2][2] = { {0,1}, {1,2}, {0,2} }; // maps pins to LEDs void setup()
{
// nothing needed here
}
void loop(){ for(int i=0; i < NUMBER_OF_LEDS; i++)
{
lightLed(i); // light each LED in turn delay(1000); }
}
// this function lights the given LED, the first LED is 0 void lightLed(int led)
{
// the following four lines convert LED number to pin numbers int indexA = pairs[led/2][0]; int indexB = pairs[led/2][1]; int pinA = pins[indexA]; int pinB = pins[indexB];
// turn off all pins not connected to the given LED for(int i=0; i < NUMBER_OF_PINS; i++) if( pins[i] != pinA && pins[i] != pinB)
{ // if this pin is not one of our pins pinMode(pins[i], INPUT);
// set the mode to input digitalWrite(pins[i],LOW); // make sure pull-up is off
}
// now turn on the pins for the given LED pinMode(pinA, OUTPUT); pinMode(pinB, OUTPUT); if( led % 2 == 0)
{

240 | Chapter 7: Visual Output

digitalWrite(pinA,LOW); digitalWrite(pinB,HIGH); } else { digitalWrite(pinB,LOW); digitalWrite(pinA,HIGH);
}
}

Figure 7-8. Six LEDs driven through three pins using Charlieplexing

Discussion
The term Charlieplexing comes from Charlie Allen (of Microchip Technology, Inc.), who published the method. The technique is based on the fact that LEDs only turn on when connected the “right way” around (with the anode more positive than the cathode). Here is the table showing the LED number (see Figure 7-6) that is lit for the valid combinations of the three pins. L is LOW, H is HIGH, and i is INPUT mode. Setting a pin in
INPUT mode effectively disconnects it from the circuit:
2
L
L
H i i
L
H

Pins
3 4
L L
H i
L i
L H
H L i H i L

1
0
1
0
0
0
0
0

LEDs
2 3
0 0
0 0
1 0
0 1
0 0
0 0
0 0

4
0
0
0
0
1
0
0

5
0
0
0
0
0
1
0

6
0
0
0
0
0
0
1

7.9 Controlling a Matrix of LEDs: Charlieplexing | 241

You can double the number of LEDs to 12 using just one more pin. The first six LEDs are connected in the same way as in the preceding example; add the additional six LEDs so that the connections look like Figure 7-9.

Figure 7-9. Charlieplexing using four pins to drive 12 LEDs

Modify the preceding sketch by adding the extra pin to the pins array: byte pins[] = {2,3,4,5};

// the pins that are connected to LEDs

Add the extra entries to the pairs array so that it reads as follows: byte pairs[NUMBER_OF_LEDS/2][2] = { {0,1}, {1,2}, {0,2}, {2,3}, {1,3}, {0,3} };

Everything else can remain the same, so the loop will sequence through all 12 LEDs because the code determines the number of LEDs from the number of entries in the pins array.
Because Charlieplexing works by controlling the Arduino pins so that only a single LED is turned on at a time, it is more complicated to create the impression of lighting multiple LEDs. But you can light multiple LEDs using a multiplexing technique modified for Charlieplexing.
This sketch creates a bar graph by lighting a sequence of LEDs based on the value of a sensor connected to analog pin 0: byte pins[] = {2,3,4}; const int NUMBER_OF_PINS = sizeof(pins)/ sizeof(pins[0]); const int NUMBER_OF_LEDS = NUMBER_OF_PINS * (NUMBER_OF_PINS-1); byte pairs[NUMBER_OF_LEDS/2][2] = { {0,1}, {1,2}, {0,2} }; int ledStates = 0; //holds states for up to 15 LEDs int refreshedLed; // the LED that gets refreshed void setup()
{
// nothing here
}

242 | Chapter 7: Visual Output

void loop()
{
const int analogInPin = 0; // Analog input pin connected to the variable resistor
// here is the code from the bargraph recipe int sensorValue = analogRead(analogInPin);
// read the analog in value int ledLevel = map(sensorValue, 0, 1023, 0, NUMBER_OF_LEDS);
// map to the number of LEDs for (int led = 0; led < NUMBER_OF_LEDS; led++)
{
if (led < ledLevel ) { setState(led, HIGH);
// turn on pins less than the level
}
else { setState(led, LOW);
// turn off pins higher than the level
}
} ledRefresh(); } void setState( int led, boolean state)
{
bitWrite(ledStates,led, state);
}
void ledRefresh()
{
// refresh a different LED each time this is called. if( refreshedLed++ > NUMBER_OF_LEDS) // increment to the next LED refreshedLed = 0; // repeat from the first LED if all have been refreshed

}

if( bitRead(ledStates, refreshedLed ) == HIGH) lightLed( refreshedLed );
// this function is identical to the sketch above
// it lights the given LED, the first LED is 0 void lightLed(int led)
{
// the following four lines convert LED number to pin numbers int indexA = pairs[led/2][0]; int indexB = pairs[led/2][1]; int pinA = pins[indexA]; int pinB = pins[indexB];
// turn off all pins not connected to the given LED for(int i=0; i < NUMBER_OF_PINS; i++) if( pins[i] != pinA && pins[i] != pinB)
{ // if this pin is not one of our pins pinMode(pins[i], INPUT);
// set the mode to input digitalWrite(pins[i],LOW); // make sure pull-up is off
}
// now turn on the pins for the given LED pinMode(pinA, OUTPUT);

7.9 Controlling a Matrix of LEDs: Charlieplexing | 243

pinMode(pinB, OUTPUT); if( led % 2 == 0)
{
digitalWrite(pinA,LOW); digitalWrite(pinB,HIGH); } else { digitalWrite(pinB,LOW); digitalWrite(pinA,HIGH);
}
}

This sketch uses the value of the bits in the variable ledStates to represent the state of the LEDs (0 if off, 1 if on). The refresh function checks each bit and lights the LEDs for each bit that is set to 1. The refresh function must be called quickly and repeatedly, or the LEDs will appear to blink.
Adding delays into your code can interfere with the “persistence of vision” effect that creates the illusion that hides the flashing of the LEDs.

You can use an interrupt to service the refresh function in the background (without needing to explicitly call the function in loop). Timer interrupts are covered in Chapter 18, but here is a preview of one approach for using an interrupt to service your LED refreshes. This uses a third-party library called FrequencyTimer2 (available from the
Arduino Playground) to create the interrupt:
#include
byte pins[] = {2,3,4,5}; const int NUMBER_OF_PINS = sizeof(pins)/ sizeof(pins[0]); const int NUMBER_OF_LEDS = NUMBER_OF_PINS * (NUMBER_OF_PINS-1); byte pairs[NUMBER_OF_LEDS/2][2] = { {0,1}, {1,2}, {0,2} }; int ledStates = 0; //holds states for up to 15 LEDs int refreshedLed; // the LED that gets refreshed
--#include // include this library to handle the refresh byte pins[] = {2,3,4}; const int NUMBER_OF_PINS = sizeof(pins)/ sizeof(pins[0]); const int NUMBER_OF_LEDS = NUMBER_OF_PINS * (NUMBER_OF_PINS-1); byte pairs[NUMBER_OF_LEDS/2][2] = { {0,1}, {1,2}, {0,2} }; int ledStates = 0; //holds states for up to 15 LEDs int refreshedLed; // the LED that gets refreshed

244 | Chapter 7: Visual Output

void setup()
{
FrequencyTimer2::setPeriod(20000/ NUMBER_OF_LEDS); // set the period
// the next line tells FrequencyTimer2 the function to call (ledRefresh)
FrequencyTimer2::setOnOverflow(ledRefresh);
FrequencyTimer2::enable();
}
void loop()
{
const int analogInPin = 0; // Analog input pin connected to the variable resistor
// here is the code from the bargraph recipe int sensorValue = analogRead(analogInPin);
// read the analog in value int ledLevel = map(sensorValue, 0, 1023, 0, NUMBER_OF_LEDS);
// map to the number of LEDs for (int led = 0; led < NUMBER_OF_LEDS; led++)
{
if (led < ledLevel ) { setState(led, HIGH);
// turn on pins less than the level
}
else { setState(led, LOW);
// turn off pins higher than the level
}
}
// the LED is no longer refreshed in loop, it's handled by FrequencyTimer2
}
// the remaining code is the same as the previous example

The FrequencyTimer2 library has the period set to 1,666 microseconds (20 ms divided by 12, the number of LEDs). The FrequencyTimer2setOnOverflow method gets the function to call (ledRefresh) each time the timer “triggers.”

See Also
Chapter 18 provides more information on timer interrupts.

7.10 Driving a 7-Segment LED Display
Problem
You want to display numerals using a 7-segment numeric display.

Solution
The following sketch displays numerals from zero to nine on a single-digit, 7-segment display. Figure 7-10 shows the connections. The output is produced by turning on combinations of segments that represent the numerals:
/*
* SevenSegment sketch

7.10 Driving a 7-Segment LED Display | 245

* Shows numerals ranging from 0 through 9 on a single-digit display
* This example counts seconds from 0 to 9
*/
// bits representing segments A through G (and decimal point) for numerals 0-9 const byte numeral[10] = {
//ABCDEFG /dp
B11111100, // 0
B01100000, // 1
B11011010, // 2
B11110010, // 3
B01100110, // 4
B10110110, // 5
B00111110, // 6
B11100000, // 7
B11111110, // 8
B11100110, // 9
};
// pins for decimal point and each segment
//
dp,G,F,E,D,C,B,A const int segmentPins[8] = { 5,9,8,7,6,4,3,2}; void setup()
{
for(int i=0; i < 8; i++)
{
pinMode(segmentPins[i], OUTPUT); // set segment and DP pins to output
}
} void loop()
{
for(int i=0; i 9){ isBitSet = 0;
// turn off all segments
}
else{

246 | Chapter 7: Visual Output

// isBitSet will be true if given bit is 1 isBitSet = bitRead(numeral[number], segment);

}

} isBitSet = ! isBitSet; // remove this line if common cathode display digitalWrite( segmentPins[segment], isBitSet);

}

Figure 7-10. Connecting a 7-segment display

Discussion
The segments to be lit for each numeral are held in the array called numeral. There is one byte per numeral where each bit in the byte represents one of seven segments (or the decimal point).
The array called segmentPins holds the pins associated with each segment. The showDigit function checks that the number ranges from zero to 9, and if valid, looks at each segment bit and turns on the segment if the bit is set (equal to 1). See Recipe 3.12 for more on the bitRead function.

7.10 Driving a 7-Segment LED Display | 247

As mentioned in Recipe 7.4, a pin is set HIGH when turning on a segment on a common cathode display, and it’s set LOW when turning on a segment on a common anode display. The code here is for a common anode display, so it inverts the value (sets 0 to
1 and 1 to 0) as follows: isBitSet = ! isBitSet; // remove this line if common cathode display

The ! is the negation operator—see Recipe 2.20. If your display is a common cathode display (all the cathodes are connected together; see the data sheet if you are not sure), you can remove that line.

7.11 Driving Multidigit, 7-Segment LED Displays: Multiplexing
Problem
You want to display numbers using a 7-segment display that shows two or more digits.

Solution
Multidigit, 7-segment displays usually use multiplexing. In earlier recipes, multiplexed rows and columns of LEDs were connected together to form an array; here, corresponding segments from each digit are connected together (see Figure 7-11):
/*
* SevenSegmentMpx sketch
* Shows numbers ranging from 0 through 9999 on a four-digit display
* This example displays the value of a sensor connected to an analog input
*/
// bits representing segments A through G (and decimal point) for numerals 0-9 const int numeral[10] = {
//ABCDEFG /dp
B11111100, // 0
B01100000, // 1
B11011010, // 2
B11110010, // 3
B01100110, // 4
B10110110, // 5
B00111110, // 6
B11100000, // 7
B11111110, // 8
B11100110, // 9
};
// pins for decimal point and each segment
// dp,G,F,E,D,C,B,A const int segmentPins[] = { 4,7,8,6,5,3,2,9}; const int nbrDigits= 4;

// the number of digits in the LED display

//dig 1 2 3 4 const int digitPins[nbrDigits] = { 10,11,12,13};

248 | Chapter 7: Visual Output

void setup()
{
for(int i=0; i < 8; i++) pinMode(segmentPins[i], OUTPUT); // set segment and DP pins to output for(int i=0; i < nbrDigits; i++) pinMode(digitPins[i], OUTPUT);
}
void loop()
{
int value = analogRead(0); showNumber(value); } void showNumber( int number)
{
if(number == 0) showDigit( 0, nbrDigits-1) ; // display 0 in the rightmost digit else {
// display the value corresponding to each digit
// leftmost digit is 0, rightmost is one less than the number of places for( int digit = nbrDigits-1; digit >= 0; digit--)
{
if(number > 0)
{
showDigit( number % 10, digit) ; number = number / 10;
}
}
}
}
// Displays given number on a 7-segment display at the given digit position void showDigit( int number, int digit)
{
digitalWrite( digitPins[digit], HIGH ); for(int segment = 1; segment < 8; segment++)
{
boolean isBitSet = bitRead(numeral[number], segment);
// isBitSet will be true if given bit is 1 isBitSet = ! isBitSet; // remove this line if common cathode display digitalWrite( segmentPins[segment], isBitSet);
}
delay(5); digitalWrite( digitPins[digit], LOW );
}

7.11 Driving Multidigit, 7-Segment LED Displays: Multiplexing | 249

Figure 7-11. Connecting a multidigit, 7-segment display (LTC-2623)

Discussion
This sketch has a showDigit function similar to that discussed in Recipe 7.10. Here the function is given the numeral and the digit place. The logic to light the segments to correspond to the numeral is the same, but in addition, the code sets the pin corresponding to the digit place HIGH, so only that digit will be written (see the earlier multiplexing explanations).

7.12 Driving Multidigit, 7-Segment LED Displays Using
MAX7221 Shift Registers
Problem
You want to control multiple 7-segment displays, but you want to minimize the number of required Arduino pins.

Solution
This Solution uses the popular MAX7221 LED driver chip to control four-digit common cathode displays, such as the Lite-On LTC-4727JR (Digi-Key 160-1551-5-ND).
The MAX7221 provides a simpler solution than Recipe 7.11, because it handles multiplexing and digit decoding in hardware.
This sketch will display a number between zero and 9,999 (Figure 7-12 shows the connections): 250 | Chapter 7: Visual Output

/*
Max7221_digits
*/
#include

// Arduino SPI library introduced in Arduino version 0019

const int slaveSelect = 10; //pin used to enable the active slave const int numberOfDigits = 2; // change these to match the number of digits wired up const int maxCount
= 99; int number = 0; void setup()
{
Serial.begin(9600);
SPI.begin();
// initialize SPI pinMode(slaveSelect, OUTPUT); digitalWrite(slaveSelect,LOW); //select slave
// prepare the 7221 to display 7-segment data - see data sheet sendCommand(12,1); // normal mode (default is shutdown mode); sendCommand(15,0); // Display test off sendCommand(10,8); // set medium intensity (range is 0-15) sendCommand(11,numberOfDigits); // 7221 digit scan limit command sendCommand(9,255); // decode command, use standard 7-segment digits digitalWrite(slaveSelect,HIGH); //deselect slave
}
void loop()
{
// display a number from the serial port terminated by the end of line character if(Serial.available())
{
char ch = Serial.read(); if( ch == '\n')
{
displayNumber(number); number = 0;
}
else number = (number * 10) + ch - '0'; // see Chapter 4 for details
}
}
// function to display up to four digits on a 7-segment display void displayNumber( int number)
{
for(int i = 0; i < numberOfDigits; i++)
{
byte character = number % 10; // get the value of the rightmost decade if(number == 0 && i > 0) character = 0xf; // the 7221 will blank the segments when receiving value
// send digit number as command, first digit is command 1

7.12 Driving Multidigit, 7-Segment LED Displays Using MAX7221 Shift Registers | 251

}

sendCommand(numberOfDigits-i, character); number = number / 10;
}
void sendCommand( int command, int value)
{
digitalWrite(slaveSelect,LOW); //chip select is active low
//2-byte data transfer to the 7221
SPI.transfer(command);
SPI.transfer(value); digitalWrite(slaveSelect,HIGH); //release chip, signal end transfer
}

Figure 7-12. MAX7221 driving a multidigit common cathode 7-segment display

Solution
This recipe uses Arduino SPI communication to talk to the MAX7221 chip. Chapter 13 covers SPI in more detail, and Recipe 13.8 explains the SPI-specific code used.
This sketch displays a number if up to four digits are received on the serial port—see
Chapter 4 for an explanation of the serial code in loop. The displayNumber function extracts the value of each digit, starting from the rightmost digit, to the MAX7221 using the sendCommand function that sends the values to the MAX7221.
The wiring shown uses a four-digit, 7-segment display, but you can use single- or dual-digit displays for up to eight digits. When combining multiple displays, each corresponding segment pin should be connected together. (Recipe 13.8 shows the connections for a common dual-digit display.)
252 | Chapter 7: Visual Output

The MAX72xx chips are designed for common cathode displays. The anode of each segment is available on a separate pin, and the cathodes of all the segments for each digit are connected together.

7.13 Controlling an Array of LEDs by Using MAX72xx Shift
Registers
Problem
You have an 8x8 array of LEDs to control, and you want to minimize the number of required Arduino pins.

Solution
As in Recipe 7.12, you can use a shift register to reduce the number of pins needed to control an LED matrix. This solution uses the popular MAX7219 or MAX7221 LED driver chip to provide this capability. The sketch uses the matrix library distributed with Arduino, but it uses different Arduino pins than the Arduino example sketch. To run the following code, connect your Arduino, matrix, and MAX72xx as shown in
Figure 7-13.

Figure 7-13. MAX72xx driving an 8x8 LED array

7.13 Controlling an Array of LEDs by Using MAX72xx Shift Registers | 253

This sketch is based on the Arduino hello_matrix library by Nicholas Zambetti, with only the pin number changed to be consistent with the wiring used elsewhere in this chapter: #include
#include
// Hello Matrix
// by Nicholas Zambetti
// Demonstrates the use of the Matrix library
// For MAX7219 LED Matrix Controllers
// Blinks welcoming face on screen const int loadPin = 2; const int clockPin = 3; const int dataPin = 4;
Matrix myMatrix = Matrix(dataPin, clockPin, loadPin); // create a new Matrix instance void setup()
{
} void loop()
{
myMatrix.clear(); // clear display delay(1000); // turn some pixels on myMatrix.write(1, 5, HIGH); myMatrix.write(2, 2, HIGH); myMatrix.write(2, 6, HIGH); myMatrix.write(3, 6, HIGH); myMatrix.write(4, 6, HIGH); myMatrix.write(5, 2, HIGH); myMatrix.write(5, 6, HIGH); myMatrix.write(6, 5, HIGH);
}

delay(1000);

Discussion
A matrix is created by passing pin numbers for the data, load, and clock pins. loop uses the write method to turn pixels on; the clar method turns the pixels off. write has three parameters: the first two identify the column and row (x and y) of an LED and the third parameter (HIGH or LOW) turns the LED on or off.

254 | Chapter 7: Visual Output

The pin numbers shown here are for the green LEDs in the dual-color 8x8 matrix available from these suppliers:
SparkFun: COM-00681
NKC Electronics Item #: COM-0006
The resistor (marked R1 in Figure 7-13) is used to control the maximum current that will be used to drive an LED. The MAX72xx data sheet has a table that shows a range of values (see Table 7-3).
Table 7-3. Table of resistor values (from MAX72xx data sheet)
LED forward voltage
Current

1.5V

2.0V

2.5V

3.0V

3.5V

40 mA

12 kΩ

12 kΩ

11 kΩ

10 kΩ

10 kΩ

30 mA

18 kΩ

17 kΩ

16 kΩ

15 kΩ

14 kΩ

20 mA

30 kΩ

28 kΩ

26 kΩ

24 kΩ

22 kΩ

10 mA

68 kΩ

64 kΩ

60 kΩ

56 kΩ

51 kΩ

The green LED in the LED matrix shown in Figure 7-13 has a forward voltage of 2.0 volts and a forward current of 20 mA. Table 7-3 indicates 28K ohms, but to add a little safety margin, a resistor of 30K or 33K would be a suitable choice. The capacitors
(0.1 uf and 10 uf) are required to prevent noise spikes from being generated when the
LEDs are switched on and off—see “Using Capacitors for Decoupling” on page 593 in Appendix C if you are not familiar with connecting decoupling capacitors.

See Also
MAX72xx data sheet: http://pdfserv.maxim-ic.com/en/ds/MAX7219-MAX7221.pdf

7.14 Increasing the Number of Analog Outputs Using PWM
Extender Chips (TLC5940)
Problem
You want to have individual control of the intensity of more LEDs than Arduino can support (6 on a standard board and 12 on the Mega).

Solution
The TLC5940 chip drives up to 16 LEDs using only five data pins. Figure 7-14 shows the connections. This sketch is based on the excellent Tlc5940 library written by Alex
Leone (acleone@gmail.com). You can download the library from http://code.google
.com/p/tlc5940arduino/:

7.14 Increasing the Number of Analog Outputs Using PWM Extender Chips (TLC5940) | 255

/*
* TLC sketch
* Create a Knight Rider-like effect on LEDs plugged into all the TLC outputs
* this version assumes one TLC with 16 LEDs
*/
#include "Tlc5940.h" void setup()
{
Tlc.init();
}

// initialize the TLC library

void loop()
{
int direction = 1; int intensity = 4095; // an intensity from 0 to 4095, full brightness is 4095 int dim = intensity / 4; // 1/4 the value dims the LED for (int channel = 0; channel < 16; channel += direction) {
// the following TLC commands set values to be written by the update method
Tlc.clear(); // turn off all LEDs if (channel == 0) { direction = 1;
}
else {
Tlc.set(channel - 1, dim); // set intensity for prev LED
}
Tlc.set(channel, intensity); // full intensity on this LED if (channel < 16){
Tlc.set(channel + 1, dim); // set the next LED to dim
}
else { direction = -1;
}

}

}

Tlc.update(); delay(75); // this method sends data to the TLC chips to change the LEDs

Discussion
This sketch loops through each channel (LED), setting the previous LED to dim, the current channel to full intensity, and the next channel to dim. The LEDs are controlled through a few core methods.
The Tlc.init method initializes Tlc functions prior to any other function.

256 | Chapter 7: Visual Output

Download from Wow! eBook

Figure 7-14. Sixteen LEDs driven using external PWM

The following functions only take effect after calling the update() method:
Tlc.clear

Turns off all channels
Tlc.set

Sets the intensity for the given channel to a given value
Tlc.setAll

Sets all channels to a given value
Tlc.update

Sends the changes from any of the preceding commands to the TLC chip
More functions are available in the library; see the link to the reference at the end of this recipe.
The 2K resistor between TLC pin 20 (Iref) and Gnd will let around 20 mA through each
LED. You can calculate the resistor value R for a different current (in milliamperes) using the formula R = 40,000 / mA. R is 1 ohm, and the calculation does not depend on the LED driving voltage.
If you want the LEDs to turn off when the Arduino is reset, put a pull-up resistor (10K) between +5V and BLANK (pin 23 of the TLC and Arduino pin 10).

7.14 Increasing the Number of Analog Outputs Using PWM Extender Chips (TLC5940) | 257

Here is a variation that uses a sensor value to set the maximum LED intensity. You can test this using a variable resistor connected as shown in Figure 7-11 or Figure 7-15:
#include "Tlc5940.h" const int sensorPin = 0; // connect sensor to analog input 0 void setup()
{
Tlc.init();
}

// initialize the TLC library

void loop()
{
int direction = 1; int sensorValue = analogRead(0); // get the sensor value int intensity = map(sensorValue, 0,1023, 0, 4095); // map to TLC range int dim = intensity / 4; // 1/4 the value dims the LED for (int channel = 0; channel < NUM_TLCS * 16; channel += direction) {
// the following TLC commands set values to be written by the update method
Tlc.clear(); // turn off all LEDs if (channel == 0) { direction = 1;
}
else {
Tlc.set(channel - 1, dim); // set intensity for prev LED
}
Tlc.set(channel, intensity); // full intensity on this LED if (channel != NUM_TLCS * 16 - 1) {
Tlc.set(channel + 1, dim); // set the next LED to dim
}
else { direction = -1;
}

}

}

Tlc.update(); delay(75); // this method sends data to the TLC chips to change the LEDs

This version also allows for multiple TLC chips if you want to drive more than 16 LEDs.
You do this by “daisy-chaining” the TLC chips—connect the Sout (pin 17) of the first
TLC to the Sin (pin 26) of the next. The Sin (pin 26) of the first TLC chip is connected to Arduino pin 11, as shown in Figure 7-14.
The following pins should be connected together when daisy-chaining TLC chips:
• Arduino pin 9 to XLAT (pin 24) of each TLC
• Arduino pin 10 to BLANK (pin 23) of each TLC
• Arduino pin 13 to SCLK (pin 25) of each TLC
Each TLC needs its own resistor between Iref (pin 20) and Gnd.

258 | Chapter 7: Visual Output

You must change the value of the NUM_TLCS constant defined in the Tlc5940 library to match the number of chips you have wired.

See Also
Go to http://code.google.com/p/tlc5940arduino/ to download this library and access its documentation. 7.15 Using an Analog Panel Meter As a Display
Problem
You would like to control the pointer of an analog panel meter from your sketch. Fluctuating readings are easier to interpret on an analog meter, and analog meters add a cool retro look to a project.

Solution
Connect the meter through a series resistor (5K ohms for the typical 1 mA meter) and connect to an analog (PWM) output (see Figure 7-15).

Figure 7-15. Driving an analog meter

7.15 Using an Analog Panel Meter As a Display | 259

The pointer movement corresponds to the position of a pot (variable resistor):
/*
* AnalogMeter sketch
* Drives an analog meter through an Arduino PWM pin
* The meter level is controlled by a variable resistor on an analog input pin
*/
const int analogInPin = 0; // Analog input pin connected to the variable resistor const int analogMeterPin = 9; // Analog output pin connecting to the meter int sensorValue = 0; int outputValue = 0;

// value read from the pot
// value output to the PWM (analog out)

void setup()
{
// nothing in setup
}
void loop()
{
sensorValue = analogRead(analogInPin); outputValue = map(sensorValue, 0, 1023, 0, 255); analog out analogWrite(analogMeterPin, outputValue);
}

// read the analog in value
// map to the range of the
// write the analog out value

Discussion
In this variation on Recipe 7.2, the Arduino analogWrite output drives a panel meter.
Panel meters are usually much more sensitive than LEDs; a resistor must be connected between the Arduino output and the meter to drop the current to the level for the meter.
The value of the series resistor depends on the sensitivity of the meter; 5K ohms give full-scale deflection with a 1 mA meter. You can use 4.7K resistors, as they are easier to obtain than 5K, although you will probably need to reduce the maximum value given to analogWrite to 240 or so. Here is how you can change the range in the map function if you use a 4.7K ohm resistor with a 1 mA meter: outputValue = map(sensorValue, 0, 1023, 0, 240);

// map to meter's range

If your meter has a different sensitivity than 1 mA, you will need to use a different value series resistor. The resistor value in ohms is: Resistor = 5,000 / mA
So, a 500 microamp meter (0.5 mA) is 5,000 / 0.5, which is 10,000 (10K) ohms.
Some surplus meters already have an internal series resistor—you may need to experiment to determine the correct value of the resistor, but be careful not to apply too much voltage to your meter.

See Also
Recipe 7.2

260 | Chapter 7: Visual Output

CHAPTER 8

Physical Output

8.0 Introduction
You can make things move by controlling motors with Arduino. Different types of motors suit different applications, and this chapter shows how Arduino can drive many different kinds of motors.

Motion Control Using Servos
Servos enable you to accurately control physical movement because they generally move to a position instead of continuously rotating. They are ideal for making something rotate over a range of 0 to 180 degrees. Servos are easy to connect and control because the motor driver is built into the servo.
Servos contain a small motor connected through gears to an output shaft. The output shaft drives a servo arm and is also connected to a potentiometer to provide position feedback to an internal control circuit (see Figure 8-1).
You can get continuous rotation servos that have the positional feedback disconnected so that you can instruct the servo to rotate continuously clockwise and counterclockwise with some control over the speed. These function a little like the brushed motors covered in Recipe 8.3, except that continuous rotation servos use the servo library code instead of analogWrite.
Servos respond to changes in the duration of a pulse. A short pulse of 1 ms or less will cause the servo to rotate to one extreme; a pulse duration of 2 ms or so will rotate the servo to the other extreme (see Figure 8-2). Pulses ranging between these values will rotate the servo to a position proportional to the pulse width. There is no standard for the exact relationship between pulses and position, and you may need to tinker with the commands in your sketch to adjust for the range of your servos.

261

Figure 8-1. Elements inside a hobby servo
Although the duration of the pulse is modulated (controlled), servos require pulses that are different from the Pulse Width Modulation
(PWM) output from analogWrite. You can damage a hobby servo by connecting it to the output from analogWrite—use the Servo library instead. Solenoids and Relays
Although most motors produce rotary motion, a solenoid produces linear movement when powered. A solenoid has a metallic core that is moved by a magnetic field that is created when current is passed through a coil. A mechanical relay is a type of solenoid that connects or disconnects electrical contacts (it’s a solenoid operating a switch).
Relays are controlled just like solenoids. Relays and solenoids, like most motors, require more current than an Arduino pin can safely provide, and the recipes in this chapter show how you can use a transistor or external circuit to drive these devices.

Brushed and Brushless Motors
Most low-cost direct current (DC) motors are simple devices with two leads connected to brushes (contacts) that control the magnetic field of the coils that drives a metallic core (armature). The direction of rotation can be reversed by reversing the polarity of the voltage on the contacts. DC motors are available in many different sizes, but even the smallest (such as vibration motors used in cell phones) require a transistor or other external control to provide adequate current. The recipes that follow show how to control motors using a transistor or an external control circuit called an H-Bridge.

262 | Chapter 8: Physical Output

Figure 8-2. Relationship between the pulse width and the servo angle; the servo output arm moves proportionally as the pulse width increases from 1 ms to 2 ms

The primary characteristic in selecting a motor is torque. Torque determines how much work the motor can do. Typically, higher torque motors are larger and heavier and draw more current than lower torque motors.
Brushless motors usually are more powerful and efficient for a given size than brushed motors, but they require more complicated electronic control. Where the performance benefit of a brushless motor is desired, components called electronics speed controllers intended for hobby radio control use can be easily controlled by Arduino because they are controlled much like a servo motor.

Stepper Motors
Steppers are motors that rotate a specific number of degrees in response to control pulses. The number of degrees in each step is motor-dependent, ranging from one or two degrees per step to 30 degrees or more.
Two types of steppers are commonly used with Arduino: bipolar (typically with four leads attached to two coils) and unipolar (five or six leads attached to two coils). The additional wires in a unipolar stepper are internally connected to the center of the coils
(in the five-lead version, each coil has a center tap and both center taps are connected together). The recipes covering bipolar and unipolar steppers have diagrams illustrating these connections.

8.0 Introduction | 263

Troubleshooting Sidebar
The most common cause of problems when connecting devices that require external power is neglecting to connect all the grounds together. Your Arduino ground must be connected to the external power supply ground and the grounds of external devices being powered.

8.1 Controlling the Position of a Servo
Problem
You want to control the position of a servo using an angle calculated in your sketch.
For example, you want a sensor on a robot to swing through an arc or move to a position you select.

Solution
Use the Servo library distributed with Arduino. Connect the servo power and ground to a suitable power supply (a single hobby servo can usually be powered from the
Arduino 5V line). Recent versions of the library enable you to connect the servo signal leads to any Arduino digital pin.
Here is the example Sweep sketch distributed with Arduino; Figure 8-3 shows the connections: #include
Servo myservo;

// create servo object to control a servo

int angle = 0;

// variable to store the servo position

void setup()
{
myservo.attach(9);
}

// attaches the servo on pin 10 to the servo object

void loop()
{
for(angle = 0; angle < 180; angle += 1) // goes from 0 degrees to 180 degrees
{
// in steps of 1 degree myservo.write(angle); // tell servo to go to position in variable 'angle' delay(20); // waits 20ms between servo commands
}
for(angle = 180; angle >= 1; angle -= 1) // goes from 180 degrees to 0 degrees
{
myservo.write(pos);
// tell servo to go to position in variable 'pos' delay(20); // waits 20ms between servo commands
}
}

264 | Chapter 8: Physical Output

Figure 8-3. Connecting a servo for testing with the example Sweep sketch

Discussion
This example sweeps the servo between 0 and 180 degrees. You may need to tell the library to adjust the minimum and maximum positions so that you get the range of movement you want. Calling Servo.attach with optional arguments for minimum and maximum positions will adjust the movement: myservo.attach(9,1000,2000 );

// use pin 9, set min to 1000us, max to 2000us

Because typical servos respond to pulses measured in microseconds and not degrees, the arguments following the pin number inform the Servo library how many microseconds to use when 0 degrees or 180 degrees are requested. Not all servos will move over a full 180-degree range, so you may need to experiment with yours to get the range you want.
The parameters for servo.attach(pin, min, max) are the following: pin The pin number that the servo is attached to (must be 9 or 10) min (optional)
The pulse width, in microseconds, corresponding to the minimum (0-degree) angle on the servo (defaults to 544) max (optional)
The pulse width, in microseconds, corresponding to the maximum (180-degree) angle on the servo (defaults to 2,400)
Power requirements vary depending on the servo and how much torque is needed to rotate the shaft.

8.1 Controlling the Position of a Servo | 265

Download from Wow! eBook

You may need an external source of 5 or 6 volts when connecting multiple servos. Four AA cells work well if you want to use battery power.
Remember that you must connect the ground of the external power source to Arduino ground.

8.2 Controlling One or Two Servos with a Potentiometer or Sensor
Problem
You want to control the rotational direction and speed of one or two servos with a potentiometer. For example, you want to control the pan and tilt of a camera or sensor connected to the servos. This recipe can work with any variable voltage from a sensor that can be read from an analog input.

Solution
The same library can be used as in Recipe 8.1, with the addition of code to read the voltage on a potentiometer. This value is scaled so that the position of the pot (from
0 to 1023) is mapped to a value between 0 and 180 degrees. The only difference in the wiring is the addition of the potentiometer; see Figure 8-4:
#include
Servo myservo;

// create servo object to control a servo

int potpin = 0; // analog pin used to connect the potentiometer int val;
// variable to read the value from the analog pin void setup()
{
myservo.attach(9);
}

// attaches the servo on pin 9 to the servo object

void loop()
{
val = analogRead(potpin); val = map(val, 0, 1023, 0, 179); myservo.write(val); delay(15);
}

266 | Chapter 8: Physical Output

//
//
//
//

reads the value of the potentiometer scale it to use it with the servo sets position to the scaled value waits for the servo to get there

Figure 8-4. Controlling a servo with a potentiometer

Discussion
Anything that can be read from analogRead (see Chapter 5 and Chapter 6) can be used— for example, the gyro and accelerometer recipes in Chapter 6 can be used so that the angle of the servo is controlled by the yaw of the gyro or angle of the accelerometer.

8.3 Controlling the Speed of Continuous Rotation Servos
Problem
You want to control the rotational direction and speed of servos modified for continuous rotation. For example, you are using two continuous rotation servos to power a robot and you want the speed and direction to be controlled by your sketch.

Solution
Continuous rotation servos are a form of gear reduced motor with forward and backward speed adjustment. Control of continuous rotation servos is similar to normal servos. The servo rotates in one direction as the angle is increased from 90 degrees; it rotates in the other direction when the angle is decreased from 90 degrees. The actual direction forward or backward depends on how you have the servos attached. Figure 8-5 shows the connections for controlling two servos.
This example sweeps the servos from 90 to 180 degrees, so if the servos were connected to wheels, the vehicle would move forward at a slowly increasing pace and then slow
8.3 Controlling the Speed of Continuous Rotation Servos | 267

Figure 8-5. Controlling two servos

down to a stop. Because the servo control code is in loop, this will continue for as long as there is power:
#include
Servo myservoLeft;
Servo myservoRight; int pos = 0;

// create servo object to control a servo
// create servo object to control a servo

// variable to store the servo position

void setup()
{
myservoLeft.attach(9);
// attaches left servo on pin 9 to servo object myservoRight.attach(10); // attaches right servo on pin 10 to servo object
}
void loop()
{
for(angle = 90; angle < 180; angle +=
{
//
//
myservoLeft.write(angle);
//
myservoRight.write(180-angle);
//

}

1) // goes from 90 to 180 degrees in steps of 1 degree
90 degrees is stopped rotate servo at speed given by 'angle' go in the opposite direction

delay(20);
// waits 20ms between servo commands
}
for(angle = 180; angle >= 90; angle -= 1) // goes from 180 to 90 degrees
{
myservoLeft.write(angle);
// rotate at a speed given by 'angle' myservoRight.write(180-angle); // other servo goes in opposite direction
}

268 | Chapter 8: Physical Output

Discussion
You can use similar code for continuous rotation and normal servos, but be aware that continuous rotation servos may not stop rotating when writing exactly 90 degrees.
Some servos have a small potentiometer you can trim to adjust for this, or you can add or subtract a few degrees to stop the servo. For example, if the left servo stops rotating at 92 degrees, you can change the lines that write to the servos as follows: myservoLeft.write(angle+TRIM); // declare int TRIM=2; at beginning of sketch

8.4 Controlling Servos from the Serial Port
Problem
You want to provide commands to control servos from the serial port. Perhaps you want to control servos from a program running on your computer.

Solution
You can use software to control the servos. This has the advantage that any number of servos can be supported. However, your sketch needs to constantly attend to refreshing the servo position, so the logic can get complicated as the number of servos increases if your project needs to perform a lot of other tasks.
This recipe drives four servos according to commands received on the serial port. The commands are of the following form:
•
•
•
•

180a writes 180 to servo a
90b writes 90 to servo b
0c writes 0 to servo c
17d writes 17 to servo d

Here is the sketch that drives four servos connected on pins 7 through 10:
#include

// the servo library

#define SERVOS 4 // the number of servos int servoPins[SERVOS] = {7,8,9,10}; // servos on pins 7 through 10
Servo myservo[SERVOS]; void setup()
{
Serial.begin(9600); for(int i=0; i < SERVOS; i++) myservo[i].attach(servoPins[i]); } void loop()

8.4 Controlling Servos from the Serial Port | 269

{
}

serviceSerial();
// serviceSerial checks the serial port and updates position with received data
// it expects servo data in the form:
// "180a" writes 180 to servo a
// "90b writes 90 to servo b void serviceSerial()
{
static int pos = 0; if ( Serial.available()) { char ch = Serial.read();

}

}

if(ch >= '0' && ch = 'a' && ch sensorAmbient + thresholdMargin)
{
digitalWrite(motorPin, HIGH); //vibrate
}
else
{
digitalWrite(motorPin, LOW);
// stop vibrating
}
}

Here the output pin is turned on when a light shines on the photocell. When the sketch starts, the background light level on the sensor is read and stored in the variable sensorAmbient. Light levels read in loop that are higher than this will turn on the vibration motor.

8.7 Making an Object Vibrate | 275

8.8 Driving a Brushed Motor Using a Transistor
Problem
You want to turn a motor on and off. You may want to control its speed. The motor only needs to turn in one direction.

Solution
This sketch turns the motor on and off and controls its speed from commands received on the serial port (Figure 8-9 shows the connections):
/*
* SimpleBrushed sketch
* commands from serial port control motor speed
* digits '0' through '9' are valid where '0' is off, '9' is max speed
*/
const int motorPins = 3; // motor driver is connected to pin 3 void setup()
{
Serial.begin(9600);
}
void loop()
{
if ( Serial.available()) { char ch = Serial.read();

}

}

if(ch >= '0' && ch = '0' && ch = '0' && ch = 0; brightness--) { analogWrite(ledPin, brightness); delay(2); }

} void loop()
{
// a note with period of 15289 is deep C (second lowest C note on piano) for(int period=15289; period >= 477; period=period / 2) // play 6 octaves
{
playTone( period, 200); // play tone for 200 milliseconds
}
fadeLED();
}

Discussion
Two values are used by playTone: period and duration. The variable period represents the time for one cycle of the tone to play. The speaker is pulsed high and then low for

306 | Chapter 9: Audio Output

Figure 9-4. Connections for speaker and LED

the number of microseconds given by period. The for loop repeats the pulsing for the number of milliseconds given in the duration argument.
If you prefer to work in frequency rather than period, you can use the reciprocal relationship between frequency and period; period is equal to 1 divided by frequency. You need the period value in microseconds; because there are 1 million microseconds in one second, the period is calculated as 1000000L / frequency (the “L” at the end of that number tells the compiler that it should calculate using long integer math to prevent the calculation from exceeding the range of a normal integer—see the explanation of long integers in Recipe 2.2): void playFrequency(int frequency, int duration)
{
int period = 1000000L / frequency; int pulse = period / 2;

The rest of the code is the same as playTone:

}

for (long i = 0; i < duration * 1000L; i += period )
{
digitalWrite(speakerPin, HIGH); delayMicroseconds(pulse); digitalWrite(speakerPin, LOW); delayMicroseconds(pulse); }

The code in this recipe stops and waits until a tone has completed before it can do any other processing. It is possible to produce the sound in the background (without waiting for the sound to finish) by putting the sound generation code in an interrupt handler.
The source code for the tone function that comes with the Arduino distribution shows how this is done.

See Also
Recipe 9.7

9.4 Generating Audio Tones and Fading an LED | 307

Here are some examples of more complex audio synthesis that can be accomplished with the Arduino:
Pulse-Code Modulation
PCM allows you to approximate analog audio using digital signaling. An Arduino wiki article that explains how to produce 8-bit PCM using a timer is available at http://www.arduino.cc/playground/Code/PCMAudio. Pocket Piano shield
Critter and Guitari’s Pocket Piano shield gives you a piano-like keyboard, wave table synthesis, FM synthesis, and more; see http://www.critterandguitari.com/ home/store/arduino-piano.php. 9.5 Playing a WAV File
Problem
Under program control, you want Arduino to trigger the playing of a WAV file.

Solution
This sketch uses the Adafruit wave shield and is based on one of the example sketches linked from the product page at http://www.adafruit.com/index.php?main_page=prod uct_info&products_id=94. This sketch will play one of nine files depending on readings taken from a variable resistor connected to analog input 0 when pressing a button connected to pin 15 (analog input 1):
/*
* WaveShieldPlaySelection sketch
*
* play a selected WAV file
*
* Position of variable resistor slider when button pressed selects file to play
*
*/
#include
#include
//#include
#include "WaveHC.h"
#include "WaveUtil.h"
SdReader card;
FatVolume vol;
FatReader root;
FatReader file;
WaveHC wave;

//
//
//
//
//

308 | Chapter 9: Audio Output

This
This
This
This
Only

object holds the information for the card holds the information for the partition on the card holds the information for the volumes root directory object represents the WAV file wave (audio) object - only one file played at a time

const int buttonPin = 15; const int potPin = 0; // analog input pin 0 char * wavFiles[] = {
"1.WAV","2.WAV","3.WAV","4.WAV","5.WAV","6.WAV","7.WAV","8.WAV","9.WAV"};
void setup()
{
Serial.begin(9600); pinMode(buttonPin, INPUT); digitalWrite(buttonPin, HIGH); // turn on pull-up resistor if (!card.init())
{
// Something went wrong, sdErrorCheck prints an error number putstring_nl("Card init. failed!"); sdErrorCheck(); while(1);
// then 'halt' - do nothing!
}
// enable optimized read - some cards may time out card.partialBlockRead(true); // find a FAT partition! uint8_t part; for (part = 0; part < 5; part++)
// we have up to 5 slots to look in
{
if (vol.init(card, part)) break; // found one so break out of this for loop
}
if (part == 5)
// valid parts are 0 to 4, more not valid
{
putstring_nl("No valid FAT partition!"); sdErrorCheck(); // Something went wrong, print the error while(1); // then 'halt' - do nothing!
}
// tell the user about what we found putstring("Using partition ");
Serial.print(part, DEC); putstring(", type is FAT");
Serial.println(vol.fatType(),DEC);

// FAT16 or FAT32?

// Try to open the root directory if (!root.openRoot(vol))
{
putstring_nl("Can't open root dir!"); // Something went wrong, while(1); // then 'halt' - do nothing!
}
// if here then all the file prep succeeded. putstring_nl("Ready!"); }

9.5 Playing a WAV File | 309

void loop()
{
if(digitalRead(buttonPin) == LOW)
{
int value = analogRead(potPin); int index = map(value,0,1023,0,8); // index into one of the 9 files playcomplete(wavFiles[index]); Serial.println(value);
}
}
// Plays a full file from beginning to end with no pause. void playcomplete(char *name)
{
// call playfile find and play this name playfile(name); while (wave.isplaying) {
// do nothing while it's playing
}
// now it's done playing
}
void
//
if
//

playfile(char *name) { see if the wave object is currently doing something
(wave.isplaying) { already playing something, so stop it! wave.stop(); // stop it

}

}
// look in the root directory and open the file if (!file.open(root, name)) { putstring("Couldn't open file ");
Serial.print(name);
return;
}
// read the file and turn it into a wave object if (!wave.create(file)) { putstring_nl("Not a valid WAV"); return; }
// start playback wave.play(); void sdErrorCheck(void)
{
if (!card.errorCode()) return; putstring("\n\rSD I/O error: ");

310 | Chapter 9: Audio Output

}

Serial.print(card.errorCode(), HEX); putstring(", ");
Serial.println(card.errorData(), HEX); while(1) ; // stay here if there is an error

Discussion
The wave shield reads data stored on an SD card. It uses its own library that is available from the Ladyada website (http://www.ladyada.net/make/waveshield/). The WAV files to be played need to be put on the memory card using a computer. They must be
22 KHz, 12-bit uncompressed mono files, and the filenames must be in 8.3 format. The open source audio utility Audacity can be used to edit or convert audio files to the correct format. The wave shield accesses the audio file from the SD card, so the length of the audio is only limited by the size of the memory card.

See Also
The Ladyada wave shield library and documentation: http://www.ladyada.net/make/ waveshield/ Audacity audio editing and conversion software: http://audacity.sourceforge.net/
SparkFun offers a range of audio modules, including an Audio-Sound Module (http:// www.sparkfun.com/products/9534) and MP3 breakout board (http://www.sparkfun
.com/products/8954).

9.6 Controlling MIDI
Problem
You want to get a MIDI synthesizer to play music using Arduino.

Solution
To connect to a MIDI device, you need a five-pin DIN plug or socket. If you use a socket, you will also need a lead to connect to the device. Connect the MIDI connector to Arduino using a 220-ohm resistor, as shown in Figure 9-5.

9.6 Controlling MIDI | 311

Figure 9-5. MIDI connections

To upload the code onto Arduino, you should disconnect the MIDI device as it may interfere with the upload. After the sketch is uploaded, connect a MIDI sound device to the Arduino output. A musical scale will play each time you press the button connected to pin 2:
/*
midiOut sketch sends MIDI messages to play a scale on a MIDI instrument each time the switch on pin 2 is pressed
*/
//these numbers specify which note const byte notes[8] = {60, 62, 64, 65, 67, 69, 71, 72};
//they are part of the MIDI specification const int length = 8; const int switchPin = 2; const int ledPin = 13; void setup() {
Serial.begin(31250);
pinMode(switchPin, INPUT); digitalWrite(switchPin, HIGH); pinMode(ledPin, OUTPUT);
}
void loop() { if (digitalRead(switchPin == LOW))
{
for (byte noteNumber = 0; noteNumber < 8; noteNumber++)

312 | Chapter 9: Audio Output

{ playMidiNote(1, notes[noteNumber], 127); digitalWrite(ledPin, HIGH); delay(70); playMidiNote(1, notes[noteNumber], 0); digitalWrite(ledPin, HIGH); delay(30); }
}
} void playMidiNote(byte channel, byte note, byte velocity)
{
byte midiMessage= 0x90 + (channel - 1);
Serial.print(midiMessage, BYTE);
Serial.print(note, BYTE);
Serial.print(velocity, BYTE);
}

Discussion
This sketch uses the serial port to send MIDI information. The circuit connected to pin 1 may interfere with uploading code to the board. Remove the wire from pin 1 while you upload, and plug it back in afterward.
MIDI was originally used to connect digital musical instruments together so that one could control another. The MIDI specification describes the electrical connections and the messages you need to send.
MIDI is actually a serial connection (at a nonstandard serial speed, 31,250 baud), so
Arduino can send MIDI messages using its serial port hardware from pins 0 and 1.
Because the serial port is occupied by MIDI messages, you can’t print messages to the
Serial Monitor, so the sketch flashes the LED on pin 13 each time it sends a note.
Each MIDI message consists of at least one byte. This byte specifies what is to be done.
Some commands need no other information, but other commands need data to make sense. The message in this sketch is note on, which needs two pieces of information: which note and how loud. Both of these bits of data are in the range of zero to 127.
The sketch initializes the serial port to a speed of 31,250 baud; the other MIDI-specific code is in the function playMidiNote: void playMidiNote(byte channel, byte note, byte velocity)
{
byte midiMessage= 0x90 + (channel - 1);
Serial.print(midiMessage, BYTE);
Serial.print(note, BYTE);
Serial.print(velocity, BYTE);
}

This function takes three parameters and calculates the first byte to send using the channel information.
9.6 Controlling MIDI | 313

MIDI information is sent on different channels between 1 and 16. Each channel can be set to be a different instrument, so multichannel music can be played. The command for note on (to play a sound) is a combination of 0x90 (the top four bits at b1001), with the bottom four bits set to the numbers between b0000 and b1111 to represent the
MIDI channels. The byte represents channels using zero to 15 for channels 1 to 16, so
1 is subtracted first.
Then the note value and the volume (referred to as velocity in MIDI, as it originally related to how fast the key was moving on a keyboard) are sent.
The serial print statements specify that the values must be sent as bytes (rather than a series of ASCII characters) spelling out the numerals. println is not used because a line return character would insert additional bytes into the signal that are not wanted.
The sound is turned off by sending a similar message, but with velocity set to 0.
This recipe works with MIDI devices having five-pin DIN MIDI in connectors. If your
MIDI device only has a USB connector, this will not work. It will not enable the Arduino to control MIDI music programs running on your computer without additional hardware (a MIDI to USB adapter). Although Arduino has a USB connector, your computer recognizes it as a serial device, not a MIDI device.

See Also
To send and receive MIDI, have a look at the MIDI library available at http://www
.arduino.cc/playground/Main/MIDILibrary.
MIDI messages are described in detail at http://www.midi.org/techspecs/midimessages
.php.
For more information on the SparkFun MIDI breakout shield (BOB-09598), see http:
//www.sparkfun.com/products/9598.

9.7 Making an Audio Synthesizer
Problem
You want to generate complex sounds similar to those used to produce electronic music. Solution
The simulation of audio oscillators used in a sound synthesizer is complex, but Tinker
London engineer Peter Knight has created a sketch called Auduino that enables Arduino to produce more complex and interesting sounds.
Download the sketch by following the link on http://code.google.com/p/tinkerit/wiki/
Auduino.

314 | Chapter 9: Audio Output

Connect five 4.7K-ohm linear potentiometers to analog pins 0 through 4, as shown in
Figure 9-6. Potentiometers with full-size shafts are better than small presets because you can easily twiddle the settings. Pin 5 is used for audio output and is connected to an amplifier using a jack plug.

Figure 9-6. Auduino

Discussion
The Sketch code is complex because it is directly manipulating hardware timers to generate the desired frequencies, which are transformed in software to produce the audio effects. It is not included in the text because you do not need to understand the code to use Auduino.
Auduino uses a technique called granular synthesis to generate the sound. It uses two electronically produced sound sources (called grains). The variable resistors control the frequency and decay of each grain (inputs 0 and 2 for one grain and inputs 3 and 1 for the other). Input 4 controls the synchronization between the grains.
If you want to tweak the code, you can change the scale used to calculate the frequency.
The default setting is pentatonic, but you can comment that out and uncomment another option to use a different scale.
Be careful when adding code to the main loop, because the sketch is highly optimized and additional code could slow things down too much, causing the audio synthesis to not work well.
9.7 Making an Audio Synthesizer | 315

You can replace any of the pots with sensors that can produce an analog voltage signal
(see Chapter 6). For example, a light dependent resistor (see Recipe 6.2) or a distance sensor (the analog output described toward the end of Recipe 6.4) connected to one of the frequency inputs (pin 0 or 3) would enable you to control the pitch by moving your hand closer to or farther from the sensor (look up “theremin” in Wikipedia or Google to read more about this musical instrument that is played by sensing hand movement).

See Also
Video demonstration of Auduino: http://www.vimeo.com/2266458
Wikipedia article explaining granular synthesis: http://en.wikipedia.org/wiki/Granular
_synthesis
Wikipedia article on the theremin: http://en.wikipedia.org/wiki/Theremin

316 | Chapter 9: Audio Output

CHAPTER 10

Remotely Controlling External Devices

10.0 Introduction
The Arduino can interact with almost any device that uses some form of remote control, including TVs, audio equipment, cameras, garage doors, appliances, and toys. Most remote controls work by sending digital data from a transmitter to a receiver using infrared light (IR) or wireless radio technology. Different protocols (signal patterns) are used to translate key presses into a digital signal, and the recipes in this chapter show you how to use commonly found remote controls and protocols.
An IR remote works by turning an LED on and off in patterns to produce unique codes.
The codes are typically 12 to 32 bits (pieces of data). Each key on the remote is associated with a specific code that is transmitted when the key is pressed. If the key is held down, the remote usually sends the same code repeatedly, although some remotes (e.g.,
NEC) send a special repeat code when a key is held down. For Philips RC-5 or RC-6 remotes, a bit in the code is toggled each time a key is pressed; the receiver uses this toggle bit to determine when a key is pressed a second time. You can read more about the technologies used in IR remote controls at http://www.sbprojects.com/knowledge/ ir/ir.htm. The recipes here use a low-cost IR receiver module to detect the signal and provide a digital output that the Arduino can read. The digital output is then decoded by a library called IRremote, which was written by Ken Shirriff and can be downloaded from http:
//www.arcfn.com/2009/08/multi-protocol-infrared-remote-library.html.
The same library is used in the recipes in which Arduino sends commands to act like a remote control.
To install the library, place it in the folder named libraries in your Arduino sketch folder.
If you need help installing libraries, see Chapter 16.
Remote controls using wireless radio technology are more difficult to emulate than IR controls. However, the button contacts on these controls can be activated by Arduino.
The recipes using wireless remotes simulate button presses by closing the button

317

contacts circuit inside the remote control. With wireless remotes, you may need to take apart the remote control and connect wires from the contacts to Arduino to be able to use these devices. Components called optocouplers are used to provide electrical separation between Arduino and the remote control. This isolation prevents voltages from
Arduino from harming the remote control, and vice versa.
Optocouplers (also called optoisolators) enable you to safely control another circuit that may be operating at different voltage levels from Arduino. As the “isolator” part of the name implies, optoisolators provide a way to keep things electrically separated.
These devices contain an LED, which can be controlled by an Arduino digital pin. The light from the LED in the optocoupler shines onto a light-sensitive transistor. Turning on the LED causes the transistor to conduct, closing the circuit between its two connections—the equivalent of pressing a switch.

10.1 Responding to an Infrared Remote Control
Problem
You want to respond to any key pressed on a TV or other remote control.

Solution
Arduino responds to IR remote signals using a device called an IR receiver module.
Common devices are the TSOP4838, PNA4602, and TSOP2438. The first two have the same connections, so the circuit is the same; the TSOP2438 has the +5V and Gnd pins reversed. Check the data sheet for your device to ensure that you connect it correctly.
This recipe uses the IRremote library from http://www.arcfn.com/2009/08/multi-proto col-infrared-remote-library.html. Connect the IR receiver module according to your data sheet. The Arduino wiring in Figure 10-1 is for the TSOP4838/PNA4602 devices.
This sketch will toggle an LED when any button on an infrared remote control is pressed: /*
IR_remote_detector sketch
An IR remote receiver is connected to pin 2.
The LED on pin 13 toggles each time a button on the remote is pressed.
*/
#include

//adds the library code to the sketch

const int irReceiverPin = 2; const int ledPin = 13;

//pin the receiver is connected to

IRrecv irrecv(irReceiverPin); decode_results decodedSignal;

//create an IRrecv object
//stores results from IR detector

318 | Chapter 10: Remotely Controlling External Devices

Figure 10-1. Connecting an infrared receiver module void setup()
{
pinMode(ledPin, OUTPUT); irrecv.enableIRIn(); } boolean lightState = false; unsigned long last = millis(); message // Start the receiver object
//keep track of whether the LED is on
//remember when we last received an IR

void loop()
{
if (irrecv.decode(&decodedSignal) == true) //this is true if a message has been received

10.1 Responding to an Infrared Remote Control | 319

{ if (millis() - last > 250) {
//has it been 1/4 sec since last message lightState = !lightState;
//toggle the LED digitalWrite(ledPin, lightState);
}
last = millis(); irrecv.resume(); // watch out for another message
}
}

Discussion
The IR receiver converts the IR signal to digital pulses. These are a sequence of ones and zeros that correspond to buttons on the remote. The IRremote library decodes these pulses and provides a numeric value for each key (the actual values that your sketch will receive are dependent on the specific remote control you use).
#include at the top of the sketch makes the library code available to your sketch, and the line IRrecv irrecv(irReceiverPin); creates an IRrecv object named irrecv to receive signals from an IR receiver module connected to irReceiverPin (pin

2 in the sketch). Chapter 16 has more on using libraries.
You use the irrecv object to access the signal from the IR receiver. You can give it commands to look for and decode signals. The decoded responses provided by the library are stored in a variable named decode_results. The receiver object is started in setup with the line irrecv.enableIRIn();. The results are checked in loop by calling the function irrecv.decode(&decodedSignal).
The decode function returns true if there is data, which will be placed in the decoded
Signal variable. Recipe 2.11 explains how the ampersand symbol is used in function calls where parameters are modified so that information can be passed back.
If a remote message has been received, the code toggles the LED (flips its state) if it is more than one-quarter of a second since the last time it was toggled (otherwise, the
LED will get turned on and off quickly by remotes that send codes more than once when you press the button, and may appear to be flashing randomly).
The decodedSignal variable will contain a value associated with a key. This value is ignored in this recipe (although it is used in the next recipe)—you can print the value by adding to the sketch the Serial.println line highlighted in the following code: if (irrecv.decode(&decodedSignal) == true) //this is true if a message has been received Serial.println(results.value); // add this line to see decoded results

The library needs to be told to continue monitoring for signals, and this is achieved with the line irrecv.resume();.
This sketch flashes an LED when any button on the remote control is pressed, but you can control other things—for example, you can use a servo motor to dim a lamp (for more on controlling physical devices, see Chapter 8).

320 | Chapter 10: Remotely Controlling External Devices

10.2 Decoding Infrared Remote Control Signals
Problem
You want to detect a specific key pressed on a TV or other remote control.

Solution
This sketch uses remote control key presses to adjust the brightness of an LED. The code prompts for remote control keys 0 through 4 when the sketch starts. These codes are stored in Arduino memory (RAM), and the sketch then responds to these keys by setting the brightness of an LED to correspond with the button pressed, with 0 turning the LED off and 1 through 4 providing increased brightness:
/*

RemoteDecode sketch
Infrared remote control signals are decoded to control LED brightness
The values for keys 0 through 4 are detected and stored when the sketch starts key 0 turns the LED off, the brightness increases in steps with keys 1 through 4
*/

#include

// IR remote control library

const int irReceivePin = 2; detector const int ledPin
= 9;

// pin connected to the output of the IR

const int numberOfKeys = 5; long irKeyCodes[numberOfKeys];

// 5 keys are learned (0 through 4)
// holds the codes for each key

IRrecv irrecv(irReceivePin); decode_results results;

// create the IR library
// IR data goes here

// LED is connected to a PWM pin

void setup()
{
Serial.begin(9600); pinMode(irReceivePin, INPUT); pinMode(ledPin, OUTPUT); irrecv.enableIRIn(); // Start the IR receiver learnKeycodes(); // learn remote control key
Serial.println("Press a remote key");
}

codes

void loop()
{
long key; int brightness; if (irrecv.decode(&results))
{
// here if data is received irrecv.resume(); key = convertCodeToKey(results.value);

10.2 Decoding Infrared Remote Control Signals | 321

if(key >= 0)
{
Serial.print("Got key ");
Serial.println(key);
brightness = map(key, 0,numberOfKeys-1, 0, 255); analogWrite(ledPin, brightness);
}
}
}
/*
* get remote control codes
*/
void learnKeycodes()
{
while(irrecv.decode(&results))
// empty the buffer irrecv.resume(); Serial.println("Ready to learn remote codes"); long prevValue = -1; int i=0; while( i < numberOfKeys)
{
Serial.print("press remote key ");
Serial.print(i);
while(true)
{
if( irrecv.decode(&results) )
{
if(results.value != -1 && results.value != prevValue)
{
showReceivedData(); irKeyCodes[i] = results.value; i = i + 1; prevValue = results.value; irrecv.resume(); // Receive the next value break; } irrecv.resume(); // Receive the next value
}
}
}
Serial.println("Learning complete");
}
/*
* converts a remote protocol code to a logical key code (or -1 if no digit received) */ int convertCodeToKey(long code)
{
for( int i=0; i < numberOfKeys; i++)
{
if( code == irKeyCodes[i])
{
return i; // found the key so return it

322 | Chapter 10: Remotely Controlling External Devices

Download from Wow! eBook

}

}
}
return -1;

/*
* display the protocol type and value
*/
void showReceivedData()
{
if (results.decode_type == UNKNOWN)
{
Serial.println("-Could not decode message");
}
else
{
if (results.decode_type == NEC) {
Serial.print("- decoded NEC: ");
}
else if (results.decode_type == SONY) {
Serial.print("- decoded SONY: ");
}
else if (results.decode_type == RC5) {
Serial.print("- decoded RC5: ");
}
else if (results.decode_type == RC6) {
Serial.print("- decoded RC6: ");
}
Serial.print("hex value = ");
Serial.println( results.value, HEX);
}
}

Discussion
This solution is based on the IRremote library; see this chapter’s introduction for details. The sketch starts the remote control library with the following code: irrecv.enableIRIn(); // Start the IR receiver

It then calls the learnKeyCodes function to prompt the user to press keys 0 through 4.
The code for each key is stored in an array named irKeyCodes. After all the keys are detected and stored, the loop code waits for a key press and checks if this was one of the digits stored in the irKeyCodes array. If so, the value is used to control the brightness of an LED using analogWrite.
See Recipe 5.7 for more on using the map function and analogWrite to control the brightness of an LED.

10.2 Decoding Infrared Remote Control Signals | 323

The library should be capable of working with most any IR remote control; it can discover and remember the timings and repeat the signal on command.
You can permanently store the key code values so that you don’t need to learn them each time you start the sketch. Replace the declaration of irKeyCodes with the following lines to initialize the values for each key. Change the values to coincide with the ones for your remote (these will be displayed in the Serial Monitor when you press keys in the learnKeycodes function): long irKeyCodes[numberOfKeys] = {
0x18E758A7, //0 key
0x18E708F7, //1 key
0x18E78877, //2 key
0x18E748B7, //3 key
0x18E7C837, //4 key
};

See Also
Recipe 18.1 explains how you can store learned data in EEPROM (nonvolatile memory). 10.3 Imitating Remote Control Signals
Problem
You want to use Arduino to control a TV or other remotely controlled appliance by emulating the infrared signal. This is the inverse of Recipe 10.2—it sends commands instead of receiving them.

Solution
This sketch uses the remote control codes from Recipe 10.2 to control a device. Five buttons select and send one of five codes. Connect an infrared LED to send the signal as shown in Figure 10-2:
/*
irSend sketch this code needs an IR LED connected to pin 3 and 5 switches connected to pins 4 - 8
*/
#include

// IR remote control library

const int numberOfKeys = 5; const int firstKey = 4;
// the first pin of the 5 sequential pins connected to buttons boolean buttonState[numberOfKeys]; boolean lastButtonState[numberOfKeys];

324 | Chapter 10: Remotely Controlling External Devices

long irKeyCodes[numberOfKeys] = {
0x18E758A7, //0 key
0x18E708F7, //1 key
0x18E78877, //2 key
0x18E748B7, //3 key
0x18E7C837, //4 key
};
IRsend irsend; void setup()
{
for (int i = 0; i < numberOfKeys; i++){ buttonState[i]=true; lastButtonState[i]=true; int physicalPin=i + firstKey; pinMode(physicalPin, INPUT); digitalWrite(physicalPin, HIGH); // turn on pull-ups
}
Serial.begin(9600);
}
void loop() { for (int keyNumber=0; keyNumber interval)
{
// save the last time you blinked the LED

If the interval has passed, the current millis value is saved in the variable previousMillis: previousMillis = millis();
// if the LED is off turn it on and vice versa: if (ledState == LOW) ledState = HIGH; else ledState = LOW;
// set the LED with the ledState of the variable: digitalWrite(ledPin, ledState);
}

}

Here is a way to package this logic into a function named myDelay that will delay the code in loop but can perform some action during the delay period. You can customize the functionality for your application, but in this example, an LED is flashed five times per second even while the print statement in loop is delayed for four-second intervals:
// blink an LED for a set amount of time const int ledPin = 13;
// the number of the LED pin int ledState = LOW; long previousMillis = 0;

// ledState used to set the LED
// will store last time LED was updated

void setup()
{
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
} void loop()
{
Serial.println(millis() / 1000); // print the number of elapsed seconds every four seconds
// wait four seconds (but at the same time, quickly blink an LED) myDelay(4000); }
// duration is delay time in milliseconds void myDelay(unsigned long duration)
{
unsigned long start = millis();

370 | Chapter 12: Using Time and Dates

}

while (millis() - start interval)
{
// save the last time you blinked the LED previousMillis = millis();
// if the LED is off turn it on and vice versa: if (ledState == LOW) ledState = HIGH; else ledState = LOW; digitalWrite(ledPin, ledState);
}
}

You can put code in the myDelay function for an action that you want to happen repeatedly while the function waits for the specified time to elapse.
Another approach is to use a third-party library available from the Arduino Playground, called TimedAction (http://www.arduino.cc/playground/Code/TimedAction):
#include
//this initializes a TimedAction class that will change the state of an LED every second.
TimedAction timedAction = TimedAction(NO_PREDELAY,1000,blink); const int ledPin = 13; boolean ledState = false;

// the number of the LED pin

void setup()
{
pinMode(ledPin,OUTPUT); digitalWrite(ledPin,ledState); } void loop()
{
timedAction.check();
}
void blink()
{
if (ledState == LOW) ledState = HIGH; else 12.2 Using millis to Determine Duration | 371

ledState = LOW;

}

ledState ? ledState=false : ledState=true; digitalWrite(ledPin,ledState); See Also
The Arduino reference for millis: http://www.arduino.cc/en/Reference/Millis

12.3 More Precisely Measuring the Duration of a Pulse
Problem
You want to determine the duration of a pulse with microsecond accuracy; for example, to measure the exact time between two button presses.

Solution
The pulseIn function returns the duration in microseconds for a changing signal on a digital pin. This sketch prints the time that the voltage on a digital pin is held LOW by a button press. As in Recipe 12.2, this uses the wiring shown in Recipe 5.2:
/*
PulseIn sketch uses pulseIn to display how long a switch is pressed and released
*/
const int inputPin = 2;

// input pin for the switch

long val; void setup()
{
pinMode(inputPin, INPUT); digitalWrite(inputPin,HIGH); // turn on internal pull-up on the inputPin
Serial.begin(9600);
Serial.println("Press and release switch");
}
void loop()
{
val = pulseIn(inputPin, LOW); if( val != 0) // timeout returns 0
{
Serial.print("switch pressed for ");
Serial.print(val);
Serial.println(" microseconds");
}
}

372 | Chapter 12: Using Time and Dates

Discussion pulseIn can measure how long a pulse is either HIGH or LOW: pulseIn(pin, HIGH); // returns microseconds that pulse is HIGH pulseIn(pin, LOW)
// returns microseconds that pulse is LOW

The pulseIn function waits for the pulse to start (or for a timeout if there is no pulse).
By default, it will stop waiting after one second, but you can change that by specifying the time to wait in microseconds as a third parameter (note that 1,000 microseconds equals 1 millisecond): pulseIn(pin, HIGH, 5000); // wait 5 milliseconds for the pulse to start

The timeout value only matters if the pulse does not start within the given period. Once the start of a pulse is detected, the function will start timing and will not return until the pulse ends.

pulseIn can measure values between around 10 microseconds to three minutes in du-

ration, but the value of long pulses may not be very accurate.

See Also
The Arduino reference for pulseIn: http://www.arduino.cc/en/Reference/PulseIn
Recipe 6.4 shows pulseIn used to measure the pulse width of an ultrasonic distance sensor. Recipe 18.2 provides more information on using hardware interrupts.

12.4 Using Arduino As a Clock
Problem
You want to use the time of day (hours, minutes, and seconds) in a sketch, and you don’t want to connect external hardware.

Solution
This sketch uses the Time library to display the time of day:
/*
* Time sketch
*
*/
#include

12.4 Using Arduino As a Clock | 373

void setup()
{
Serial.begin(9600); setTime(12,0,0,1,1,11); // set time to noon Jan 1 2011
}
void loop()
{
digitalClockDisplay(); delay(1000); } void digitalClockDisplay(){
// digital clock display of the time
Serial.print(hour());
printDigits(minute()); printDigits(second()); Serial.print(" ");
Serial.print(day());
Serial.print(" ");
Serial.print(month());
Serial.print(" ");
Serial.print(year());
Serial.println();
}
void printDigits(int digits){
// utility function for clock display: prints preceding colon and leading 0
Serial.print(":");
if(digits < 10)
Serial.print('0');
Serial.print(digits);
}

Discussion
The Time library enables you to keep track of the date and time. A standard Arduino board uses a quartz crystal for timing, and this is accurate to a couple of seconds per day, but it does not have a battery to remember the time when power is switched off.
Therefore, time will restart from 0 each time a sketch starts, so you need to set the time using the setTime function. The sketch sets the time to noon on January 1 each time it starts. The Time library uses a standard known as Unix (also called POSIX) time. The values represent the number of elapsed seconds since January
1, 1970. Experienced C programmers may recognize that this is the same as the time_t used in the ISO standard C library for storing time values.

Of course, it’s more useful to set the time to your current local time instead of a fixed value. The following sketch gets the numerical time value (the number of elapsed seconds since January 1, 1970) from the serial port to set the time. You can enter a
374 | Chapter 12: Using Time and Dates

value using the Serial Monitor (the current Unix time can be found on a number of websites using the Google search terms “Unix time convert”):
/*
* TimeSerial sketch
* example code illustrating Time library set through serial port messages.
*
* Messages consist of the letter T followed by ten digit time (as seconds since
Jan 1 1970)
* You can send the text on the next line using Serial Monitor to set the clock to noon Jan 1 2011
T 1293883200
*
* A Processing example sketch to automatically send the messages is included in the download
*/
#include
#define TIME_MSG_LEN 11 ascii digits
#define TIME_HEADER 'T'

// time sync consists of a HEADER followed by ten
// Header tag for serial time sync message

void setup() {
Serial.begin(9600);
Serial.println("Waiting for time sync message");
}
void loop(){ if(Serial.available() )
{
processSyncMessage();
}
if(timeStatus()!= timeNotSet)
{
// here if the time has been set digitalClockDisplay(); } delay(1000); } void digitalClockDisplay(){
// digital clock display of the time
Serial.print(hour());
printDigits(minute()); printDigits(second()); Serial.print(" ");
Serial.print(day());
Serial.print(" ");
Serial.print(month());
Serial.print(" ");
Serial.print(year());
Serial.println();
}

12.4 Using Arduino As a Clock | 375

void printDigits(int digits){
// utility function for digital clock display: prints preceding colon and leading 0
Serial.print(":");
if(digits < 10)
Serial.print('0');
Serial.print(digits);
}
void processSyncMessage() {
// if time sync available from serial port, update time and return true
// time message consists of a header and ten ascii digits while(Serial.available() >= TIME_MSG_LEN ){ char c = Serial.read() ;
Serial.print(c);
if( c == TIME_HEADER ) { time_t pctime = 0; for(int i=0; i < TIME_MSG_LEN -1; i++){ c = Serial.read(); if( c >= '0' && c 0)
{
RTC.set(t);
// set the RTC and the system time to the received value setTime(t); }
}
digitalClockDisplay(); delay(1000); } void digitalClockDisplay(){
// digital clock display of the time
Serial.print(hour());
printDigits(minute()); printDigits(second()); Serial.print(" ");
Serial.print(day());
Serial.print(" ");
Serial.print(month());
Serial.print(" ");

386 | Chapter 12: Using Time and Dates

}

Serial.print(year());
Serial.println();
void printDigits(int digits){
// utility function for digital clock display: prints preceding colon and leading 0
Serial.print(":");
if(digits < 10)
Serial.print('0');
Serial.print(digits);
}
/* code to process time sync messages from the serial port */
#define TIME_MSG_LEN 11
// time sync to PC is HEADER followed by unix time_t as ten ascii digits
#define TIME_HEADER 'T'
// Header tag for serial time sync message time_t processSyncMessage() {
// return the time if a valid sync message is received on the serial port.
// time message consists of a header and ten ascii digits while(Serial.available() >= TIME_MSG_LEN ){ char c = Serial.read() ;
Serial.print(c);
if( c == TIME_HEADER ) { time_t pctime = 0; for(int i=0; i < TIME_MSG_LEN -1; i++){ c = Serial.read(); if( c >= '0' && c 255) color = 0; delay(10); // increment the color
//

The following sketch uses a function named hueToRGB that was introduced in Chapter 7 to convert an integer value into its red, green, and blue components:
// function to convert a color to its Red, Green, and Blue components. void hueToRGB( int hue, int brightness)
{
unsigned int scaledHue = (hue * 6); unsigned int segment = scaledHue / 256; // segment 0 to 5 around color wheel unsigned int segmentOffset = scaledHue - (segment * 256); // position within the segment unsigned int complement = 0; unsigned int prev = (brightness * ( 255 - segmentOffset)) / 256; unsigned int next = (brightness * segmentOffset) / 256; switch(segment ) { case 0:
// red
R = brightness;
G = next;
B = complement; break; 13.1 Controlling an RGB LED Using the BlinkM Module | 393

}

case 1:
// yellow
R = prev;
G = brightness;
B = complement; break; case 2:
// green
R = complement;
G = brightness;
B = next; break; case 3:
// cyan
R = complement;
G = prev;
B = brightness; break; case 4:
// blue
R = next;
G = complement;
B = brightness; break; case 5:
// magenta default: R = brightness;
G = complement;
B = prev; break; }

Discussion
The Wire library is added to the sketch using the following:
#include

For more details about using libraries, see Chapter 16.
The code in setup initializes the Wire library and the hardware in the Arduino to drive
SCA and SDL on analog pins 4 and 5 and turns on the pins used to power the BlinkM module. The loop code calls the function hueToRGB to calculate the red, green, and blue values for the color.
The R, G, and B values are sent to BlinkM using this sequence:
Wire.beginTransmission(address); // start an I2C message to the BlinkM address
Wire.send('c');
// 'c' is a command to fade to the color that follows
Wire.send(R);
// value for red
Wire.send(B);
// value for blue
Wire.send(G);
// value for green
Wire.endTransmission();
// complete the I2C message

All data transmission to I2C devices follows this pattern: beginTransmission, a number of send messages, and endTransmission.

394 | Chapter 13: Communicating Using I2C and SPI

I2C supports up to 127 devices connected to the clock and data pins, and the address determines which device will respond. The default address for BlinkM is 0, but this can be altered by sending a command to change the address—see the BlinkM user manual for information on all commands.
To connect multiple BlinkMs, connect all the clock pins (marked “c” on BlinkM, analog pin 5 on Arduino) and all the data pins (marked “d” on BlinkM, analog pin 4 on Arduino), as shown in Figure 13-4. The power pins should be connected to +5V and Gnd on Arduino or an external power source, as the analog pins cannot provide enough current for more than a couple of modules.

Figure 13-4. Multiple BlinkM modules connected together

Each BlinkM can draw up to 60 mA, so if you’re using more than a handful, they should be powered using an external supply.

You need to set each BlinkM to a different I2C address, and you can use the BlinkMTester sketch that comes with the BlinkM examples downloadable from http://thingm
.com/fileadmin/thingm/downloads/BlinkM_Examples.zip.
Compile and upload the BlinkMTester sketch. Plug each BlinkM module into Arduino one at a time (switch off power when connecting and disconnecting the modules). Use the BlinkMTester scan command, s, to display the current address, and use the A command to set each module to a different address.

13.1 Controlling an RGB LED Using the BlinkM Module | 395

BlinkMTester uses 19,200 baud, so you may need to set the baud rate in the Serial Monitor to this speed to get a readable display.

After all the BlinkMs have a unique address, you can set the address variable in the preceding sketch to the address of the BlinkM you want to control. This example assumes addresses from 9 to 11:
#include
int addressA = 9; //I2C address for BlinkM int addressB = 10; int addressC = 11; int color = 0; // a value from 0 to 255 representing the hue byte R, G, B; // the red, green, and blue color components void setup()
{
Wire.begin(); // set up Arduino I2C support

}

// turn on power pins for BlinkM pinMode(17, OUTPUT);
// pin 17 (analog out 4) provides +5V to BlinkM digitalWrite(17, HIGH); pinMode(16, OUTPUT); // pin 16 (analog out 3) provides Ground digitalWrite(16, LOW);

void loop()
{
int brightness = 255; // 255 is maximum brightness hueToRGB( color, brightness); // call function to convert hue to RGB
// write the RGB values to each BlinkM setColor(addressA, R,G,B); setColor(addressB, G,B,R); setColor(addressA, B,R,G);

}

color++; if(color > 255) color = 0; delay(10); // increment the color
// ensure valid value

void setColor(int address, byte R, byte G, byte B)
{
Wire.beginTransmission(address);// join I2C, talk to BlinkM
Wire.send('c');
// 'c' == fade to color
Wire.send(R);
// value for red channel
Wire.send(B);
// value for blue channel
Wire.send(G);
// value for green channel
Wire.endTransmission();
// leave I2C bus
}

396 | Chapter 13: Communicating Using I2C and SPI

The setColor function writes the given RGB values to the BlinkM at the given address.
The code uses the hueToRGB function from earlier in this recipe to convert an integer value into its red, green, and blue components.

See Also
The BlinkM User Manual: http://thingm.com/fileadmin/thingm/downloads/BlinkM_da tasheet.pdf Example Arduino sketches: http://thingm.com/fileadmin/thingm/downloads/BlinkM_Ex amples.zip 13.2 Using the Wii Nunchuck Accelerometer
Problem
You want to connect a Wii nunchuck to your Arduino as an inexpensive way to use accelerometers. The nunchuck is a popular low-cost game device that can be used to indicate the orientation of the device by measuring the effects of gravity.

Solution
The nunchuck uses a proprietary plug. If you don’t want to use your nunchuck with your Wii again, you can cut the lead to connect it. Alternatively, it is possible to use a small piece of matrix board to make the connections in the plug if you are careful (the pinouts are shown in Figure 13-5) or you can buy an adapter made by Todbot (http:// todbot.com/blog/2008/02/18/wiichuck-wii-nunchuck-adapter-available/). Figure 13-5. Connecting a nunchuck to Arduino

13.2 Using the Wii Nunchuck Accelerometer | 397

The library supporting the nunchuck functions is available from http://todbot.com/blog/
2008/02/18/wiichuck-wii-nunchuck-adapter-available/:
/*
* nunchuck_lines sketch
* sends data to Processing to draw line that follows nunchuk movement
*/
#include // initialize wire
#include "nunchuck_funcs.h" byte accx; void setup()
{
Serial.begin(9600); nunchuck_setpowerpins(); nunchuck_init();
}
void loop()
{
nunchuck_get_data(); accx = nunchuck_accelx(); if( accx >= 75 && accx = 5) { return 1;
// success
}
return 0;
//failure
}

This uses the Wire library requestFrom function to get six bytes of data from device
0x52 (the nunchuck).

400 | Chapter 13: Communicating Using I2C and SPI

The nunchuck returns its data using six bytes as follows:
Byte number

Description

Byte 1

X-axis analog joystick value

Byte 2

Y-axis analog joystick value

Byte 3

X-axis acceleration value

Byte 4

Y-axis acceleration value

Byte 5

Z-axis acceleration value

Byte 6

Button states and least significant bits of acceleration

Wire.available works like Serial.available (see Chapter 4) to indicate how many bytes have been received, but over the I2C interface rather than the serial interface.
If data is available, it is read using Wire.receive and then decoded using nunchuck_decode_byte. Decoding is required to convert the values sent into numbers that are usable by your sketch, and these are stored in a buffer (named nunchuck_buf).
A request is sent for the next six bytes of data so that it will be ready and waiting for the next call to get data: accx = nunchuck_accelx();

The function nunchuck_accelx is used to get the value of acceleration in the x-axis from the nunchuck and store it in the variable accx.

13.3 Interfacing to an External Real-Time Clock
Problem
You want to use the time of day provided by an external real-time clock (RTC).

Solution
This solution uses the Wire library to access an RTC. It uses the same hardware as in
Recipe 12.6. Figure 13-7 shows the connections:
/*
* I2C_RTC sketch
* example code for using Wire library to access real-time clock
*
*/
#include
const byte DS1307_CTRL_ID = 0x68; // address of the DS1307 real-time clock const byte NumberOfFields = 7; // the number of fields (bytes) to request from the RTC

13.3 Interfacing to an External Real-Time Clock | 401

int int int int int int int

Second ;
Minute;
Hour;
Day;
Wday;
Month;
Year;

void setup() {
Serial.begin(9600);
Wire.begin();
}
void loop()
{
Wire.beginTransmission(DS1307_CTRL_ID);
Wire.send(0x00);
Wire.endTransmission();
// request the 7 data fields
(secs, min, hr, dow, date, mth, yr)
Wire.requestFrom(DS1307_CTRL_ID, NumberOfFields);
Second
Minute
Hour
Wday
Day
Month
Year
Year

}

=
=
=
=
=
=
=
=

bcd2dec(Wire.receive() & 0x7f); bcd2dec(Wire.receive() ); bcd2dec(Wire.receive() & 0x3f); // mask assumes 24hr clock bcd2dec(Wire.receive() ); bcd2dec(Wire.receive() ); bcd2dec(Wire.receive() ); bcd2dec(Wire.receive() );
Year + 2000; // RTC year 0 is year 2000

digitalClockDisplay(); // display the time delay(1000); // Convert Binary Coded Decimal (BCD) to Decimal byte bcd2dec(byte num)
{
return ((num/16 * 10) + (num % 16));
}
void digitalClockDisplay(){
// digital clock display of the time
Serial.print(Hour);
printDigits(Minute); printDigits(Second); Serial.print(" ");
Serial.print(Day);
Serial.print(" ");
Serial.print(Month);
Serial.print(" ");
Serial.print(Year);
Serial.println();

402 | Chapter 13: Communicating Using I2C and SPI

}
// utility function for clock display: prints preceding colon and leading 0 void printDigits(int digits){
Serial.print(":");
if(digits < 10)
Serial.print('0');
Serial.print(digits);
}

Figure 13-7. Connecting a real-time clock

Discussion
Although this recipe uses the same hardware as in Recipe 12.6, it accesses the hardware through explicit I2C calls, instead of through a library, so that the interaction between
Arduino and the I2C clock can be clearly seen.
The following line initializes the RTC:
Wire.beginTransmission(DS1307_CTRL_ID);
Wire.send(0x00);
Wire.endTransmission();

The requestFrom method of the Wire library is used to request seven time fields from the clock (DS1307_CTRL_ID is the address identifier of the clock):
Wire.requestFrom(DS1307_CTRL_ID, NumberOfFields);

The date and time values are obtained by making seven calls to the Wire.receive method: bcd2dec(Wire.receive()

13.3 Interfacing to an External Real-Time Clock | 403

The values returned by the module are Binary Coded Decimal (BCD) values, so the function bcd2dec is used to convert each value as it is received. (BCD is a method for storing decimal values in four bits of data.)

See Also
Recipe 12.6 provides details on how to set the time on the clock.

13.4 Adding External EEPROM Memory
Problem
You need more permanent data storage than Arduino has onboard, and you want to use an external memory chip to increase the capacity.

Solution
This recipe uses the 24LC128 I2C-enabled serial EEPROM from Microchip. Figure 13-8 shows the connections.

Figure 13-8. I2C EEPROM connections

This recipe provides functionality similar to the Arduino EEPROM library (see Recipe 18.1), but it uses an external EEPROM connected using I2C to provide greatly increased storage capacity:
404 | Chapter 13: Communicating Using I2C and SPI

/*
* I2C EEPROM sketch
* this version for 24LC128
*/
#include const byte EEPROM_ID = 0x50;

// I2C address for 24LC128 EEPROM

// first visible ASCII character '!' is number 33: int thisByte = 33; void setup()
{
Serial.begin(9600);
Wire.begin();
Serial.println("Writing 1024 bytes to EEPROM"); for(int i=0; i < 1024; i++)
{
I2CEEPROM_Write(i, thisByte);
// go on to the next character thisByte++; if(thisByte == 126)
// you could also use if (thisByte == '~') thisByte = 33;
// start over
}

}

Serial.println("Reading 1024 bytes from EEPROM"); int thisByte = 33; for(int i=0; i < 1024; i++)
{
char c = I2CEEPROM_Read(i); if( c != thisByte)
{
Serial.println("read error"); break; } else {
Serial.print(c);
} thisByte++; if(thisByte == 126)
{
Serial.println(); thisByte = 33;
// start over on a new line
}
}
Serial.println();

void loop()
{
}

13.4 Adding External EEPROM Memory | 405

// This function is similar to EEPROM.write() void I2CEEPROM_Write( unsigned int address, byte data )
{
Wire.beginTransmission(EEPROM_ID);
Wire.send((int)highByte(address) );
Wire.send((int)lowByte(address) );
Wire.send(data);
Wire.endTransmission(); delay(5); // wait for the I2C EEPROM to complete the write cycle
}
// This function is similar to EEPROM.read() byte I2CEEPROM_Read(unsigned int address )
{
byte data;
Wire.beginTransmission(EEPROM_ID);
Wire.send((int)highByte(address) );
Wire.send((int)lowByte(address) );
Wire.endTransmission();
Wire.requestFrom(EEPROM_ID,(byte)1); while(Wire.available() == 0) // wait for data
;
data = Wire.receive(); return data;
}

Discussion
This recipe shows the 24LC128, which has 128K of memory; although there are similar chips with higher and lower capacities (the microchip link in this recipe’s See Also section has a cross-reference). The chip’s address is set using the three pins marked
“A0” through “A2” and is in the range 0x50 to 0x57, as shown in Table 13-2.
Table 13-2. Address values for 24LC128
A0

A1

A2

Address

Gnd

Gnd

Gnd

0x50

+5V

Gnd

Gnd

0x51

Gnd

+5V

Gnd

0x52

+5V

+5V

Gnd

0x53

Gnd

Gnd

+5V

0x54

+5V

Gnd

+5V

0x55

+5V

+5V

Gnd

0x56

+5V

+5V

+5V

0x57

Use of the Wire library in this recipe is similar to its use in Recipes 13.1 and 13.2, so read through those for an explanation of the code that initializes and requests data from an I2C device.
406 | Chapter 13: Communicating Using I2C and SPI

The write and read operations that are specific to the EEPROM are contained in the functions i2cEEPROM_Write and i2cEEPROM_Read. These operations start with a
Wire.beginTransmission to the device’s I2C address. This is followed by a 2-byte value indicating the memory location for the read or write operation. In the write function, the address is followed by the data to be written—in this example, one byte is written to the memory location.
The read operation sends a memory location to the EEPROM followed by
Wire.requestFrom(EEPROM_ID,(byte)1);. This returns one byte of data from the memory at the address just set.
If you need to speed up writes, you can replace the 5 ms delay with a status check to determine if the EEPROM is ready to write a new byte. See the “Acknowledge Polling” technique described in Section 7 of the data sheet. You can also write data in pages of
64 bytes rather than individually; details are in Section 6 of the data sheet.
The chip remembers the address it is given and will move to the next sequential address each time a read or write is performed. If you are reading more than a single byte, you can set the start address and then perform multiple requests and receives.
The Wire library can read or write up to 32 bytes in a single request.
Attempting to read or write more than this can result in bytes being discarded. The pin marked “WP” is for setting write protection. It is connected to ground in the circuit here to enable the Arduino to write to memory. Connecting it to 5V prevents any writes from taking place. This could be used to write persistent data to memory and then prevent it from being overwritten accidentally.

See Also
The 24LC128 data sheet: http://ww1.microchip.com/downloads/en/devicedoc/21191n
.pdf
If you need to speed up writes, you can replace the 5 ms delay with a status check to determine if the EEPROM is ready to write a new byte. See the “Acknowledge Polling” technique described in Section 7 of the data sheet.
A cross-reference of similar I2C EEPROMs with a wide range of capacities is available at http://ww1.microchip.com/downloads/en/DeviceDoc/21621d.pdf.
A shield is available that combines reading temperature, storing in EEPROM, and 7segment display: http://store.gravitech.us/7segmentshield.html

13.4 Adding External EEPROM Memory | 407

13.5 Reading Temperature with a Digital Thermometer
Problem
You want to measure temperature, perhaps using more than one device, so you can take readings in different locations.

Solution
This recipe uses the TMP75 temperature sensor from Texas Instruments. You connect a single TMP75 as shown in Figure 13-9:
/*
* I2C_Temperature sketch
* I2C access the TMP75 digital Thermometer
*
*/
#include
const byte TMP75_ID = 0x49; // address of the TMP75 const byte NumberOfFields = 2; // the number of fields (bytes) to request
// high byte of temperature (this is the signed integer value in degrees c) char tempHighByte;
// low byte of temperature (this is the fractional temperature) char tempLowByte; float temperature;

// this will hold the floating-point temperature

void setup() {
Serial.begin(9600);
Wire.begin();
Wire.beginTransmission(TMP75_ID);
Wire.send(1);
// 1 is the configuration register
// set default configuration, see data sheet for significance of config bits
Wire.send(0);
Wire.endTransmission();
Wire.beginTransmission(TMP75_ID);
Wire.send(0);
// set pointer register to 0 (this is the 12-bit temperature)
Wire.endTransmission();
} void loop()
{
Wire.requestFrom(TMP75_ID, NumberOfFields); tempHighByte = Wire.receive(); tempLowByte = Wire.receive();
Serial.print("Integer temperature is ");

408 | Chapter 13: Communicating Using I2C and SPI

Download from Wow! eBook

Serial.print(tempHighByte, DEC);
Serial.print(",");

}

// least significant 4 bits of LowByte is the fractional temperature int t = word( tempHighByte, tempLowByte) / 16 ; temperature = t / 16.0; // convert the value to a float
Serial.println(temperature);
delay(1000);

Figure 13-9. TMP75 I2C thermometer

Discussion
As with all the I2C devices in this chapter, signaling is through the two-wire SCL and
SDA pins. Power and ground need to be connected to the device, as well, to power it.
Setup sends data to configure the device for normal operation—there are a number of

options for specialized applications (interrupts, power down, etc.), but the value used here is for normal mode with a precision of .5°C.
To get the device to send the temperature, with the Arduino (as the master), the code in loop tells the slave (at the address given by the constant TMP75_ID) that it wants two bytes of data:
Wire.requestFrom(TMP75_ID, NumberOfFields);

13.5 Reading Temperature with a Digital Thermometer | 409

Wire.receive gets the two bytes of information (the data sheet has more detail on how data is requested from this device): tempHighByte = Wire.receive(); tempLowByte = Wire.receive();

The first byte is the integer value of the temperature in degrees Celsius. The second byte contains four significant bits indicating the fractional temperature.
The two bytes are converted to a 16-bit word (see Chapter 3) and then shifted by four to form the 12-bit number. As the first four bits are the fractional temperature, the value is again shifted by four to get the floating-point value.
The TNP75 can be configured for eight different addresses, allowing eight devices to be connected to the same bus (see Figure 13-10). This sketch uses I2C address 0x48
(the TMP75 address pins labeled “A”) connected to +5V, and A1 and A2 connected to
Gnd). Table 13-3 shows the connections for the eight addresses.

Figure 13-10. Multiple devices with SDA and SCL connected in parallel with different addresses
Table 13-3. Address values for TMP75
A0

A1

A2

Address

Gnd

Gnd

Gnd

0x48

+5V

Gnd

Gnd

0x49

Gnd

+5V

Gnd

0x4A

+5V

+5V

Gnd

0x4B

Gnd

Gnd

+5V

0x4C

+5V

Gnd

+5V

0x4D

+5V

+5V

Gnd

0x4E

+5V

+5V

+5V

0x4F

410 | Chapter 13: Communicating Using I2C and SPI

When connecting more than one I2C device, you wire all the SDA lines together and all the SCL lines together. Each device connects to power and should have 0.1 bypass capacitors. The Gnd lines must be connected together, even if the devices use separate power supplies (e.g., batteries).
This sketch prints the temperature of two devices with consecutive addresses starting from 0x49:
#include
const byte TMP75_ID = 0x49; // address of the first TMP75 const byte NumberOfFields = 2; // the number of fields (bytes) to request const byte NumberOfDevices = 2; // the number of TMP75 devices (with consecutive addresses) char tempHighByte; // high byte of temperature (this is the signed integer value in degrees c) char tempLowByte;
// low byte of temperature (this is the fractional temperature) float temperature;

// this will hold the floating-point temperature

void setup() {
Serial.begin(9600);
Wire.begin(); for(int i=0; i < NumberOfDevices; i++)
{
Wire.beginTransmission(TMP75_ID+i);
Wire.send(1);
// set default configuration, see data sheet for significance of config bits
Wire.send(0);
Wire.endTransmission();

}

}

Wire.beginTransmission(TMP75_ID+i);
Wire.send(0);
// set pointer register to 0 (this is the 12-bit temperature)
Wire.endTransmission();

void loop()
{
for(int i=0; i < NumberOfDevices; i++)
{
byte id = TMP75_ID + i; // address IDs are consecutive
Wire.requestFrom(id, NumberOfFields); tempHighByte = Wire.receive(); tempLowByte = Wire.receive();
Serial.print(id,HEX); // print the device address
Serial.print(": integer temperature is ");
Serial.print(tempHighByte, DEC);

13.5 Reading Temperature with a Digital Thermometer | 411

Serial.print(",");
// least significant 4 bits of LowByte is the fractional temperature int t = word( tempHighByte, tempLowByte) / 16 ; temperature = t / 16.0; // convert the value to a float
Serial.println(temperature);
} delay(1000); }

You can add more devices by changing the constant NumberOfDevices and wiring the devices to use addresses that are consecutive, in this example starting from 0x49.
The Alert line (pin 3) can be programmed to provide a signal when the temperature reaches a threshold. See the data sheet for details if you want to use this feature.

See Also
The TMP75 data sheet: http://focus.ti.com/docs/prod/folders/print/tmp75.html
See Recipe 3.15 for more on the word function.

13.6 Driving Four 7-Segment LEDs Using Only Two Wires
Problem
You want to use a multidigit, 7-segment display, and you need to minimize the number of Arduino pins required for the connections.

Solution
This recipe uses the Gravitech 7-segment display shield that has the SAA1064 I2C to
7-segment driver from Philips (see Figure 13-11).

Figure 13-11. Gravitech I2C shield

412 | Chapter 13: Communicating Using I2C and SPI

This simple sketch lights each segment in sequence on all the digits:
/*
* I2C_7Segment sketch
*/
#include const byte LedDrive = 0x38;

/* I2C address for 7-Segment */

int segment,decade; void setup() {
Serial.begin(9600);
Wire.begin();

}

/* Join I2C bus */

Wire.beginTransmission(LedDrive);
Wire.send(0);
Wire.send(B01000111); // show digits 1 through 4, use maximum drive current
Wire.endTransmission();

void loop()
{
for (segment = 0; segment < 8; segment++)
{
Wire.beginTransmission(LedDrive);
Wire.send(1);
for (decade = 0 ; decade < 4; decade++)
{
byte bitValue = bit(segment);
Wire.send(bitValue);
}
Wire.endTransmission();
delay (250);
}
}

Discussion
The SAA1064 chip (using address 0x38) is initialized in setup. The value used configures the chip to display four digits using maximum drive current (see the data sheet section on control bits for configuration details).
The loop code lights each segment in sequence on all the digits. The Wire.send(1); command tells the chip that the next received byte will drive the first digit and subsequent bytes will drive sequential digits.
Initially, a value of 1 is sent four times and the chip lights the “A” (top) segment on all four digits. (See Chapter 2 for more on using the bit function.)
The value of segment is incremented in the for loop, and this shifts the bitValue to light the next LED segment in sequence.

13.6 Driving Four 7-Segment LEDs Using Only Two Wires | 413

Each bit position corresponds to a segment of the digit. These bit position values can be combined to create a number that will turn on more than one segment.
The following sketch will display a count from 0 to 9999. The array called lookup[10] contains the values needed to create the numerals from 0 to 9 in a segment:
#include
const byte LedDrive = 0x38;

/* I2C address for 7-Segment */

// lookup array containing segments to light for each digit const int lookup[10] = {0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F}; int count; void setup()
{
Wire.begin();
// delay(500);
}

// join I2C bus (address optional for master)

void loop()
{
Wire.beginTransmission(LedDrive);
Wire.send(0);
Wire.send(B01000111); // init the 7-segment driver - see data sheet
Wire.endTransmission();

}

// show numbers from 0 to 9999 for (count = 0; count 0)
{
Wire.send(0); // this suppresses leading zeros, it turns off all segments
}
else
{
Wire.send(lookup[digit]);
}
number = number / 10;
}
Wire.endTransmission();
}

The following statement checks if the value is 0 and it’s not the first (least significant) digit: if(number == 0 && i > 0)

If so, it sends a value of 0, which turns off all segments for that digit. This suppresses leading zeros, but it displays a single zero if the number passed to the function was 0.

See Also
SAA1064 data sheet: http://www.nxp.com/documents/data_sheet/SAA1064_CNV.pdf
A shield is available that combines reading temperature, storing in EEPROM, and 7segment display: http://store.gravitech.us/7segmentshield.html

13.6 Driving Four 7-Segment LEDs Using Only Two Wires | 415

13.7 Integrating an I2C Port Expander
Problem
You want to use more input/output ports than your board provides.

Solution
You can use an external port expander, such as the PCF8574A, which has eight input/ output pins that can be controlled using I2C. The sketch creates a bar graph with eight
LEDs. Figure 13-12 shows the connections.

Figure 13-12. PCF8574A port expander driving eight LEDs

The sketch has the same functionality as described in Recipe 7.5, but it uses the I2C port expander to drive the LEDs so that only two pins are required:
/*
* I2C_7segment
* Uses I2C port to drive a bar graph
* Turns on a series of LEDs proportional to a value of an analog sensor.
* see Recipe 7.5
*/
#include
//address for PCF8574 with pins connected as shown in Figure 13-12 const int address = 0x38; const int NbrLEDs = 8;

416 | Chapter 13: Communicating Using I2C and SPI

const int analogInPin = 0; resistor int sensorValue = 0; int ledLevel = 0; int ledBits = 0;

// Analog input pin connected to the variable

// value read from the sensor
// sensor value converted into LED 'bars'
// bits for each LED will be set to 1 to turn on LED

void setup()
{
Wire.begin(); // set up Arduino I2C support
Serial.begin(9600);
}

void loop() { sensorValue = analogRead(analogInPin); ledLevel = map(sensorValue, 0, 1023, 0, NbrLEDs); for (int led = 0; led < NbrLEDs; led++)
{
if (led < ledLevel ) { bitWrite(ledBits,led, HIGH);
// turn on LED
}
else { bitWrite(ledBits,led, LOW);
// turn off LED
}
// send the value to I2C
Wire.beginTransmission(address);
Wire.send(ledBits);
Wire.endTransmission();
} delay(100); }

// read the analog in value
// map to number of LEDs

if less than the level if higher than the level

Discussion
The resistors should be 220 ohms or more (see Chapter 7 for information on selecting resistors). The PCF8574A has a lower capacity for driving LEDs than Arduino. If you need more capacity (refer to the data sheet for details) see Recipe 13.8 for a more appropriate device.

You can change the address by changing the connections of the pins marked “A0”,
“A1”, and “A2”, as shown in Table 13-4.

13.7 Integrating an I2C Port Expander | 417

Table 13-4. Address values for PCF8574A
A0

A1

A2

Address

Gnd

Gnd

Gnd

0x38

+5V

Gnd

Gnd

0x39

Gnd

+5V

Gnd

0x3A

+5V

+5V

Gnd

0x3B

Gnd

Gnd

+5V

0x3C

+5V

Gnd

+5V

0x3D

+5V

+5V

Gnd

0x3E

+5V

+5V

+5V

0x3F

To use the port expander for input, read a byte from the expander as follows:
Wire.requestFrom(address, 1); if(Wire.available()) { data = Wire.receive();
Serial.println(data,BIN);
}

See Also
PCF8574 data sheet: http://www.nxp.com/documents/data_sheet/PCF8574.pdf

13.8 Driving Multidigit, 7-Segment Displays Using SPI
Problem
You want to control 7-segment displays, but you don’t want to use many pins.

Solution
This recipe provides similar functionality to Recipe 7.12, but it only requires three output pins. The text here explains the SPI commands used to communicate with the
MAX7221 device. Figure 13-13 shows the connections:
*
SPI_Max7221_0019
*/
#include const int slaveSelect = 10; //pin used to enable the active slave

418 | Chapter 13: Communicating Using I2C and SPI

const int numberOfDigits = 2; // change to match the number of digits wired up const int maxCount
= 99; int count = 0; void setup()
{
SPI.begin();
// initialize SPI pinMode(slaveSelect, OUTPUT); digitalWrite(slaveSelect,LOW); //select slave
// prepare the 7221 to display 7-segment data - see data sheet sendCommand(12,1); // normal mode (default is shutdown mode); sendCommand(15,0); // Display test off sendCommand(10,8); // set medium intensity (range is 0-15) sendCommand(11,numberOfDigits); // 7221 digit scan limit command sendCommand(9,255); // decode command, use standard 7-segment digits digitalWrite(slaveSelect,HIGH); //deselect slave
}
void loop()
{
displayNumber(count); count = count + 1; if( count > maxCount) count = 0; delay(100); }
// function to display up to four digits on a 7-segment display void displayNumber( int number)
{
for(int i = 0; i < numberOfDigits; i++)
{
byte character = number % 10; // get the value of the rightmost decade
// send digit number as command, first digit is command 1 sendCommand(numberOfDigits-i, character); number = number / 10;
}
} void sendCommand( int command, int value)
{
digitalWrite(slaveSelect,LOW); //chip select is active low
//2 byte data transfer to the 7221
SPI.transfer(command);
SPI.transfer(value); digitalWrite(slaveSelect,HIGH); //release chip, signal end transfer
}

13.8 Driving Multidigit, 7-Segment Displays Using SPI | 419

Figure 13-13. Connections for MAX7221 with Lite-On LTD-6440G

Discussion
The MAX7221 needs a common cathode LED. The pinouts in Figure 13-13 are for a
Lite-On LTD-6440G (Jameco 2005366). This is a two-digit, 7-segment LED and the corresponding segments for each digit must be connected together. For example, the decimal point is on pin 4 for digit 1 and pin 9 for digit 2. The figure indicates that pins
4 and 9 are connected together and wired to the MAX7221 pin 22.
The MAX7221 can display up to eight digits (or an 8x8 matrix) and is controlled by sending commands that determine which LED segment is lit.
After initializing the library, the SPI code is contained within the sendCommand function.
Because SPI uses the select slave wire connected to the chip, the chip is selected by setting that pin LOW. All SPI commands are then received by that chip until it is set HIGH.
SPI.transfer is the library function for sending an SPI message. This consists of two parts: a numerical code to specify which register should receive the message, followed by the actual data. The details for each SPI device can be found in the data sheet.
Setup initializes the 7221 by sending commands to wake up the chip (it starts up in a

low-power mode), adjust the display intensity, set the number of digits, and enable decoding for 7-segment displays. Each command consists of a command identifier (referred to as a register in the data sheet) and a value for that command.

420 | Chapter 13: Communicating Using I2C and SPI

Download from Wow! eBook

For example, command (register) 10 is for intensity, so it sets medium intensity (the intensity range is from 0 to 15): sendCommand(10,8); // set medium intensity (range is 0-15)

Command numbers 1 through 8 are used to control the digits. The following code would light the segments to display the number 5 in the first (leftmost) digit. Note that digit numbers shown in the data sheet (and Figure 13-13) start from 0, so you must remember that you control digit 0 with command 1, digit 1 with command 2, and so on: sendCommand(1, 5); // display 5 on the first digit

You can suppress leading zeros by adding two lines of code in displayNumber that send
0xf to the 7221 to blank the segments if the residual value is 0: void displayNumber( int number)
{
for(int i = 0; i < numberOfDigits; i++)
{
byte character = number % 10;

The next two lines are added to suppress leading zeros:

}

}

if(number == 0 && i > 0) character = 0xf; // value to blank the 7221 segments sendCommand(numberOfDigits-i, character); number = number / 10;

13.9 Communicating Between Two or More Arduino Boards
Problem
You want to have two or more Arduino boards working together. You may want to increase the I/O capability or perform more processing than can be achieved on a single board. You can use I2C to pass data between boards so that they can share the workload. Solution
The two sketches in this recipe show how I2C can be used as a communications link between two or more Arduino boards. Figure 13-14 shows the connections.

13.9 Communicating Between Two or More Arduino Boards | 421

Download from Wow! eBook

Figure 13-14. Arduino as I2C master and slave

The master sends characters received on the serial port to an Arduino slave using I2C:
/*
* I2C_Master
* Echo Serial data to an I2C slave
*/
#include const int address = 4;

//the address to be used by the communicating devices

void setup()
{
Wire.begin();
}
void loop()
{
char c;

}

if(Serial.available() > 0 )
{
// send the data
Wire.beginTransmission(address); // transmit to device
Wire.send(c);
Wire.endTransmission();
}

The slave prints characters received over I2C to its serial port:
/*
* I2C_Slave
* monitors I2C requests and echoes these to the serial port
*
*/

422 | Chapter 13: Communicating Using I2C and SPI

#include const int address = 4;

//the address to be used by the communicating devices

void setup()
{
Wire.begin(address); // join I2C bus using this address
Wire.onReceive(receiveEvent); // register event to handle requests
}
void loop()
{
// nothing here, all the work is done in receiveEvent
}
void receiveEvent(int howMany)
{
while(Wire.available() > 0)
{
char c = Wire.receive(); // receive byte as a character
Serial.print(c); // echo
}
}

Discussion
This chapter focused on Arduino as the I2C master accessing various I2C slaves. Here a second Arduino acts as an I2C slave that responds to requests from another Arduino.
Techniques covered in Chapter 4 for sending bytes of data can be applied here. The
Wire library does not have a print method, but it’s not difficult to add this.
The following sketch creates an object named I2CDebug that sends its output over I2C.
Using this with the I2C slave sketch shown previously enables you to print data on the master without using the serial port (the slave’s serial port is used to display the output):
/*
* I2C_Master
* Sends serial data to an I2C slave
*/
#include const int address = 4; const int sensorPin = 0; int val;

//the address to be used by the communicating devices
// select the analog input pin for the sensor
// variable to store the sensor value

class I2CDebugClass : public Print
{
private: int I2CAddress; byte count; void write(byte c);

13.9 Communicating Between Two or More Arduino Boards | 423

public:
I2CDebugClass();
boolean begin(int id);
};
I2CDebugClass::I2CDebugClass()
{
} boolean I2CDebugClass::begin(int id)
{
I2CAddress = id; // save the slave's address
Wire.begin(); // join I2C bus (address optional for master) return true;
}
void I2CDebugClass::write(byte c)
{
if( count == 0)
{
// here if the first char in the transmission
Wire.beginTransmission(I2CAddress); // transmit to device
}
Wire.send(c);
// if the I2C buffer is full or an end of line is reached, send the data
// BUFFER_LENGTH is defined in the Wire library if(++count >= BUFFER_LENGTH || c == '\n')
{
// send data if buffer full or newline character
Wire.endTransmission();
count = 0;
}
}
I2CDebugClass I2CDebug;

// the I2C print object

void setup()
{
Wire.begin();
Serial.begin(9600);
} void loop()
{
val = analogRead(sensorPin); from 0 to 1023)
Serial.println(val);
I2CDebug.println(val);
}

// read the voltage on the pot (val ranges

See Also
Chapter 4 has more information on using the Arduino print functionality.

424 | Chapter 13: Communicating Using I2C and SPI

CHAPTER 14

Wireless Communication

14.0 Introduction
Arduino’s ability to interact with the world is fantastic, but sometimes you might want to communicate with your Arduino from a distance, without wires, and without the overhead of a full TCP/IP network connection. This chapter begins with a recipe for simple wireless modules for applications where low cost is the primary requirement, but most of the recipes focus on the versatile XBee wireless modules.
XBee provides flexible wireless capability to the Arduino, but that very flexibility can be confusing. This chapter provides examples ranging from simple “wireless serial port replacements” through to mesh networks connecting multiple boards to multiple sensors. A number of different XBee modules are available. The most popular are the XBee
802.15.4 (also known as XBee Series 1) and XBee ZB Series 2. Series 1 is easier to use than Series 2, but it does not support mesh networks. See http://www.digi.com/support/ kbase/kbaseresultdetl.jsp?id=2213. 14.1 Sending Messages Using Low-Cost Wireless Modules
Problem
You want to transmit data between two Arduino boards using simple, low-cost wireless modules. Solution
This recipe uses simple transmit and receive modules such as the SparkFun
WRL-08946 and WRL-08770.
Wire the transmitter as shown in Figure 14-1 and the receiver as in Figure 14-2.

425

Figure 14-1. Simple wireless transmitter using VirtualWire

Figure 14-2. Simple wireless receiver using VirtualWire

426 | Chapter 14: Wireless Communication

The transmit sketch sends a simple text message to the receive sketch, which echoes the text to the Serial Monitor. The transmit and receive sketches use the VirtualWire library written by Mike McCauley to provide the interface to the wireless hardware.
The library can be downloaded from http://www.open.com.au/mikem/arduino/Virtual
Wire-1.5.zip:
/*
SimpleSend
This sketch transmits a short text message using the VirtualWire library connect the Transmitter data pin to Arduino pin 12
*/
#include void setup()
{
// Initialize the IO and ISR vw_setup(2000); // Bits per sec
}
void loop()
{
send("hello"); delay(1000); } void send (char *message)
{
vw_send((uint8_t *)message, strlen(message)); vw_wait_tx(); // Wait until the whole message is gone
}

The receive sketch also uses the VirtualWire library:
/*
SimpleReceive
This sketch displays text strings received using VirtualWire
Connect the Receiver data pin to Arduino pin 11
*/
#include byte message[VW_MAX_MESSAGE_LEN];
// a buffer to hold the incoming messages byte msgLength = VW_MAX_MESSAGE_LEN; // the size of the message void setup()
{
Serial.begin(9600);
Serial.println("Ready");
// Initialize the IO and ISR vw_setup(2000); // Bits per sec vw_rx_start(); // Start the receiver
}

14.1 Sending Messages Using Low-Cost Wireless Modules | 427

void loop()
{
if (vw_get_message(message, &msgLength)) // Non-blocking
{
Serial.print("Got: "); for (int i = 0; i < msgLength; i++)
{
Serial.write(message[i]);
}
Serial.println();
}
}

Discussion
The VirtualWire library defaults to pin 12 for transmit and pin 11 for receive, but see the documentation link at the end of this recipe if you want to use different pins.
Setup initializes the library. The loop code simply calls a send function that calls the library vw_send and waits for the message to be transmitted.
The receive side initializes the library receive logic and then waits in loop for the message. vw_get_message will return true if a message is available, and if so, each character in the message is printed to the Serial Monitor.
The VirtualWire library handles the assembly of multiple bytes into packets, so sending binary data consists of passing the address of the data and the number of bytes to send.
The sending sketch that follows is similar to the transmit sketch in this recipe’s Solution, but it fills the message buffer with binary values from reading the analog input ports using analogRead. The size of the buffer is the number of integers to be sent multiplied by the number of bytes in an integer (the six analog integer values take 12 bytes because each int is two bytes):
/*
SendBinary
Sends digital and analog pin values as binary data using VirtualWire library
See SendBinary in Chapter 4
*/
#include const int numberOfAnalogPins = 6; // how many analog pins to read int data[numberOfAnalogPins];

// the data buffer

const int dataBytes = numberOfAnalogPins * sizeof(int); // the number of bytes in the data buffer void setup()
{
// Initialize the IO and ISR vw_setup(2000); // Bits per sec
}

428 | Chapter 14: Wireless Communication

void loop()
{
int values = 0; for(int i=0; i 0) { response += (char) Serial.read();
}
}

}

// If we got the right response, configure the radio and return true. if (response.equals(ok_response)) {
Serial.print("ATDH0013A200\r"); // destination high-REPLACE THIS
Serial.print("ATDL403B9E1E\r"); // destination low-REPLACE THIS
Serial.print("ATCN\r");
// back to data mode return true;
} else { return false; // This indicates the response was incorrect.
}
void setup () {
Serial.begin(9600); // Begin serial configured = configureRadio();
}
void loop () {

438 | Chapter 14: Wireless Communication

if (configured) {
Serial.print("Hello!");
delay(3000);
}
else { delay(30000); // Wait 30 seconds configureRadio(); // try again
}
}

Discussion
Although the configurations in Recipe 14.2 work for two XBees, they are not as flexible when used with more than two.
For example, consider a three-node network of Series 2 XBees, with one XBee configured with the COORDINATOR AT firmware and the other two with the ROUTER
AT firmware. Messages you send from the coordinator will be broadcast to the two routers. Messages you send from each router are sent to the coordinator.
The Series 1 configuration in that recipe is a bit more flexible, in that it specifies explicit destinations. But by configuring the devices with AT commands and then writing the configuration, you effectively hardcode the destination addresses in the firmware.
This solution instead lets the Arduino code send the AT commands to configure the
XBees on the fly. The heart of the solution is the configureRadio() function. It sends the +++ escape sequence to put the XBee in command mode, just as the Series 1 configuration did at the end of Recipe 14.2. After sending this escape sequence, the Arduino sketch waits for the OK response before sending these AT commands:
ATDH0013A200
ATDL403B9E1E
ATCN

In your code, you must replace 0013A200 and 403B9E1E with the high and low addresses of the destination radio.

The first two commands are similar to what is shown in the Series 1 configuration at the end of Recipe 14.2, but the numbers are longer. That’s because the example shown in that recipe’s Solution uses Series 2–style addresses. As you saw in Recipe 14.2, you can specify the address of a Series 1 XBee with the ATMY command, but in a Series 2
XBee, each module has a unique address that is embedded in each chip. You can look up the high (ATDH) and low (ATDL) portions of the serial number using X-CTU, as shown in Figure 14-6. The numbers are also printed on the label underneath the XBee.
The ATCN command exits command mode; think of it as the reverse of what the +++ sequence accomplishes.

14.3 Sending a Message to a Particular XBee | 439

Figure 14-6. Looking up the high and low serial numbers in X-CTU

See Also
Recipe 14.2

14.4 Sending Sensor Data Between XBees
Problem
You want to send the status of digital and analog pins or control pins based on commands received from XBee.
440 | Chapter 14: Wireless Communication

Solution
Hook one of the XBees (the transmitting XBee) up to an analog sensor and configure it to read the sensor and transmit the value periodically. Connect the Arduino to an
XBee (the receiving XBee) configured in API mode and read the value of the API frames that it receives from the other XBee.

Discussion
XBees have a built-in analog-to-digital converter (ADC) that can be polled on a regular basis. The XBee can be configured to transmit the values (between 0 and 1023) to other
XBees in the network. The configuration and code differ quite a bit between Series 2 and Series 1 XBees.

Series 2 XBees
Using X-CTU (see “Series 2 configuration” on page 433 in Recipe 14.2), configure the transmitting XBee with the ZIGBEE ROUTER AT (not API) function set and the following settings:
PAN ID: 1234 (or a number you pick, as long as you use the same one for both
XBees)
Channel Verification (JV): 1 (this makes sure the router will confirm that it’s on the right channel when talking to the coordinator)
Destination Address High (DH): the high address (SH) of the other XBee, usually
13A200
Destination Address Low (DL): the low address (SL) of the other XBee
Under I/O Settings, AD0/DIO0 Configuration (D0): 2
Under I/O Settings→Sampling Rate (IR): 64 (100 milliseconds in hex)
You can look up the high (ATDH) and low (ATDL) portions of the serial number using X-CTU, as shown earlier in Figure 14-6. The numbers are also printed on the label underneath the XBee.

Configure the receiving XBee with the ZIGBEE COORDINATOR API (not AT) function set with the following settings:
PAN ID: 1234 (or a number you pick, as long as you use the same one for both
XBees)
Destination Address High (DH): the high address (SH) of the other XBee, usually
13A200
Destination Address Low (DL): the low address (SL) of the other XBee
Wire up the transmitting XBee to the sensor, as shown in Figure 14-7. The value of R1 should be double whatever your potentiometer is (if you are using a 10K pot, use a 20K

14.4 Sending Sensor Data Between XBees | 441

resistor). This is because the Series 2 XBees’ analog-to-digital converters read a range of 0 to 1.2 volts, and R1 reduces the 3.3V to stay below 1.2 volts.

Figure 14-7. Connecting a Series 2 XBee to an analog sensor

Next, load the following sketch onto the Arduino, and wire the transmitting XBee to the Arduino as shown in Recipe 14.2. If you need to reprogram the Arduino, remember to disconnect it from the XBee first:
/*
XBeeAnalogReceive
Read an analog value from an XBee API frame and set the brightness of an LED accordingly.
*/
#define LEDPIN 9 void setup() {
Serial.begin(9600);
pinMode(LEDPIN, OUTPUT);
}
void loop() { if (Serial.available() >= 21) { // Wait until we have a mouthful of data if (Serial.read() == 0x7E) { // Start delimiter of a frame
// Skip over the bytes in the API frame we don't care about for (int i = 0; i < 18; i++) {
Serial.read();

442 | Chapter 14: Wireless Communication

}
// The next two bytes are the high and low bytes of the sensor reading int analogHigh = Serial.read(); int analogLow = Serial.read(); int analogValue = analogLow + (analogHigh * 256);
// Scale the brightness to the Arduino PWM range int brightness = map(analogValue, 0, 1023, 0, 255);
// Light the LED analogWrite(LEDPIN, brightness);
}
}
}

Series 1 XBees
Using a terminal program as described in “Series 1 configuration” on page 435 in
Recipe 14.2, send the following configuration commands to the transmitting XBee:
ATRE
ATMY1234
ATDL5678
ATDH0
ATID0
ATD02
ATIR64
ATWR

Next, send the following configuration commands to the receiving XBee:
ATRE
ATMY5678
ATDL1234
ATDH0
ATID0
ATWR

Both XBees
ATRE resets the XBee to factory defaults. The ATMY command sets the identifier for an XBee. ATDL and ATDH set the low byte and the high byte of the destination XBee.
ATID sets the network ID (it needs to be the same for XBees to talk to one another).
ATWR saves the settings into the XBee so that it remembers the settings even if you power it down and back up.
Transmitting XBee
ATD02 configures pin 20 (analog or digital input 0) as an analog input; ATIR64 tells the XBee to sample every 100 (64 hex) milliseconds and send the value to the XBee specified by ATDL and ATDH.

14.4 Sending Sensor Data Between XBees | 443

Wire up the transmitting XBee to the sensor, as shown in Figure 14-8.

Figure 14-8. Series 1 XBee connected to an analog sensor

Next, load the following sketch onto the Arduino, and wire the transmitting XBee to the Arduino as shown in Recipe 14.2. If you need to reprogram the Arduino, disconnect it from the XBee first:
/*
XBeeAnalogReceiveSeries1
Read an analog value from an XBee API frame and set the brightness of an LED accordingly.
*/
const int ledPin = 9; void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT); configureRadio(); // check the return value if you need error handling
}
boolean configureRadio() {
// put the radio in command mode:
Serial.flush();
Serial.print("+++");

444 | Chapter 14: Wireless Communication

delay(100);
String ok_response = "OK\r"; // the response we expect.
// Read the text of the response into the response variable
String response = String(""); while (response.length() < ok_response.length()) { if (Serial.available() > 0) { response += (char) Serial.read();
}
}

}

// If we got the right response, configure the radio and return true. if (response.equals(ok_response)) {
Serial.print("ATAP1\r"); // Enter API mode delay(100); Serial.print("ATCN\r"); // back to data mode return true;
} else { return false; // This indicates the response was incorrect.
}

void loop() { if (Serial.available() >= 14) { // Wait until we have a mouthful of data if (Serial.read() == 0x7E) { // Start delimiter of a frame
// Skip over the bytes in the API frame we don't care about for (int i = 0; i < 10; i++) {
Serial.read();
}
// The next two bytes are the high and low bytes of the sensor reading int analogHigh = Serial.read(); int analogLow = Serial.read(); int analogValue = analogLow + (analogHigh * 256);
// Scale the brightness to the Arduino PWM range int brightness = map(analogValue, 0, 1023, 0, 255);

}

}

}

// Light the LED analogWrite(ledPin, brightness);

See Also
Recipe 14.2

14.4 Sending Sensor Data Between XBees | 445

14.5 Activating an Actuator Connected to an XBee
Problem
You want to tell an XBee to activate a pin, which could be used to turn on an actuator connected to it, such as a relay or LED.

Solution
Configure the XBee connected to the actuator so that it will accept instructions from another XBee. Connect the other XBee to an Arduino to send the commands needed to activate the digital I/O pin that the actuator is connected to.

Discussion
The XBee digital/analog I/O pins can be configured for digital output. Additionally,
XBees can be configured to accept instructions from other XBees to take those pins high or low. In Series 2 XBees, you’ll be using the Remote AT Command feature. In
Series 1 XBees, you can use the direct I/O, which creates a virtual wire between XBees.

Series 2 XBees
Using X-CTU (see “Series 2 configuration” on page 433), configure the receiving XBee with the ZIGBEE ROUTER AT (not API) function set and the following settings:
PAN ID: 1234 (or a number you pick, as long as you use the same one for both
XBees)
Channel Verification (JV): 1 (this makes sure the router will confirm that it’s on the right channel when talking to the coordinator)
Destination Address High (DH): the high address (SH) of the other XBee, usually
13A200
Destination Address Low (DL): the low address (SL) of the other XBee
Under I/O Settings, AD1/DIO1 Configuration (D1): 4 (digital output, low)
You can look up the high (ATDH) and low (ATDL) portions of the serial number using X-CTU, as shown earlier in Figure 14-6. The numbers are also printed on the label underneath the XBee.

Configure the transmitting XBee with the ZIGBEE COORDINATOR API (not AT) function set with the following settings:
PAN ID: 1234 (or a number you pick, as long as you use the same one for both
XBees)
Destination Address High (DH): the high address (SH) of the other XBee, usually
13A200

446 | Chapter 14: Wireless Communication

Destination Address Low (DL): the low address (SL) of the other XBee
Wire up the receiving XBee to an LED, as shown in Figure 14-9.

Figure 14-9. Connecting an LED to an XBee’s digital I/O pin 1

Next, load the following sketch onto the Arduino, and wire the transmitting XBee to the Arduino as shown in Recipe 14.2. If you need to reprogram the Arduino, remember to disconnect it from the XBee first. This sketch sends a Remote AT command (ATD14 or ATD15) that sets the state of pin 1 (ATD1) alternatingly on (digital out high, 5) and off
(digital out low, 4):
/*
XBeeActuate
Send a Remote AT command to activate a digital pin on another XBee.
*/
const byte frameStartByte = 0x7E; const byte frameTypeRemoteAT = 0x17; const byte remoteATOptionApplyChanges = 0x02; void setup() {
Serial.begin(9600);
} void loop()
{

}

toggleRemotePin(1); delay(3000); toggleRemotePin(0); delay(2000); 14.5 Activating an Actuator Connected to an XBee | 447

byte sendByte(byte value) {
Serial.print(value, BYTE); return value;
}
void toggleRemotePin(int value) {

// 0 = off, nonzero = on

byte pin_state; if (value) { pin_state = 0x5;
} else { pin_state = 0x4;
}
sendByte(frameStartByte); // Begin the API frame
// High and low parts of the frame length (not counting checksum) sendByte(0x0); sendByte(0x10); long sum = 0; // Accumulate the checksum sum += sendByte(frameTypeRemoteAT); // Indicate this frame contains a
Remote AT command sum += sendByte(0x0);

// frame ID set to zero for no reply

// The
// Use sum += sum += sum += sum += sum += sum += sum += sum +=

following 8 bytes indicate the ID of the recipient.
0xFFFF to broadcast to all nodes. sendByte(0x0); sendByte(0x0); sendByte(0x0); sendByte(0x0); sendByte(0x0); sendByte(0x0); sendByte(0xFF); sendByte(0xFF);

// The
// Use sum += sum +=

following 2 bytes indicate the 16-bit address of the recipient.
0xFFFE to broadcast to all nodes. sendByte(0xFF); sendByte(0xFF);

sum += sendByte(remoteATOptionApplyChanges); // send Remote AT options
// The text of the AT command sum += sendByte('D'); sum += sendByte('1');
// The value (0x4 for off, 0x5 for on) sum += sendByte(pin_state);
// Send the checksum sendByte( 0xFF - ( sum & 0xFF));

448 | Chapter 14: Wireless Communication

}

delay(10); // Pause to let the microcontroller settle down if needed

Series 1 XBees
Using a terminal program as described in “Series 1 configuration” on page 435, send the following configuration commands to the transmitting XBee (the one you’ll connect to the Arduino):
ATRE
ATMY1234
ATDL5678
ATDH0
ATID0
ATD13
ATICFF
ATWR

Next, send the following configuration commands to the receiving XBee:
ATRE
ATMY5678
ATDL1234
ATDH0
ATID0
ATD14
ATIU0
ATIA1234
ATWR

Both XBees
ATRE resets the XBee to factory defaults. The ATMY command sets the identifier for an XBee. ATDL and ATDH set the low byte and the high byte of the destination XBee.
ATID sets the network ID (it needs to be the same for XBees to talk to one another).
ATWR saves the settings into the XBee so that it remembers the settings even if you power it down and back up.
Transmitting XBee
ATICFF tells the XBee to check every digital input pin and send their values to the
XBee specified by ATDL and ATDH. ATD13 configures pin 19 (analog or digital input
1) to be in digital input mode. The state of this pin will be relayed from the transmitting XBee to the receiving XBee.
Receiving XBee
ATIU1 tells the XBee to not send the frames it receives to the serial port. ATIA1234 tells it to accept commands from the other XBee (whose MY address is 1234).
ATD14 configures pin 19 (analog or digital input 1) to be in low digital output mode
(off by default).
Wire up the transmitting XBee to the Arduino, as shown in Figure 14-10.
Next, wire the receiving XBee to an Arduino, as shown in Recipe 14.2. Note that instead of sending AT commands over the serial port, we’re using an electrical connection to
14.5 Activating an Actuator Connected to an XBee | 449

take the XBee’s pin high. The two 10K resistors form a voltage divider that drops the
Arduino’s 5V logic to about 2.5 volts (high enough for the XBee to recognize, but low enough to avoid damaging the XBee’s 3.3V logic pins).

Figure 14-10. Connecting the Arduino to XBee’s digital I/O pin 1

Next, load the following sketch onto the Arduino. This sketch takes the XBee’s digital
I/O pin 1 alternatingly on (digital out high, 5) and off (digital out low, 4). Because the transmitting XBee is configured to relay its pin states to the receiving XBee, when its pin 1 changes state the receiving XBee’s pin 1 changes as well:
/*
XBeeActuateSeries1
Activate a digital pin on another XBee.
*/
const int ledPin = 9; const int xbeePin = 2; void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT); pinMode(xbeePin, OUTPUT);
}
void loop()
{

}

digitalWrite(xbeePin, HIGH); delay(3000); digitalWrite(xbeePin, LOW); delay(3000); See Also
Recipe 14.2
450 | Chapter 14: Wireless Communication

CHAPTER 15

Ethernet and Networking

15.0 Introduction
Want to share your sensor data? Let other people take control of your Arduino’s actions? Your Arduino can communicate with a broader world over Ethernet and networks. This chapter describes the many ways you can use Arduino with the Internet.
It has examples that demonstrate how to build and use web clients and servers and it shows how to use the most common Internet communication protocols with
Arduino.
The Internet allows a client (e.g., your web browser) to request information from a server (a web server or other Internet service provider). This chapter contains recipes showing how to make an Internet client that retrieves information from a service such as Google or Yahoo! Other recipes in this chapter show how Arduino can be an Internet server that provides information to clients using Internet protocols and act as a web server that creates pages for viewing in web browsers.
The Arduino Ethernet library supports a range of methods (protocols) that enable your sketches to be an Internet client or a server. The Ethernet library uses the suite of standard Internet protocols, and most of the low-level plumbing is hidden. Getting your clients or servers up and running and doing useful tasks will require some understanding of the basics of network addressing and protocols, and you may want to consult one of the many references available online or one of these introductory books:
• Head First Networking by Al Anderson and Ryan Benedetti (O’Reilly)
• Network Know-How: An Essential Guide for the Accidental Admin by John Ross
(No Starch Press)
• Windows NT TCP/IP Network Administration by Craig Hunt and Robert Bruce
Thompson (O’Reilly)
• Making Things Talk by Tom Igoe (O’Reilly)

451

Download from Wow! eBook

Here are some of the key concepts in this chapter. You may want to explore them in more depth than is possible here:
Ethernet
This is the low-level signaling layer providing basic physical message-passing capability. Source and destination addresses for these messages are identified by a
Media Access Control (MAC) address. Your Arduino sketch defines a MAC address value that must be unique on your network.
TCP and IP
Transmission Control Protocol (TCP) and Internet Protocol (IP) are core Internet protocols built above Ethernet. They provide a message-passing capability that operates over the global Internet. TCP/IP messages are delivered through unique
IP addresses for the sender and receiver. A server on the Internet uses a numeric label (address) that no other server will have so that it can be uniquely identified.
This address consists of four bytes, usually represented with dots separating the bytes (e.g., 64.233.187.64 is an IP address used by Google). The Internet uses the
Directory Name System (DNS) service to translate the common service name (http:
//www.google.com) to the numeric IP address, but the standard Arduino Ethernet library does not include the DNS capability. Recipe 15.3 shows how to use a thirdparty DNS library to add this capability to your sketches.
Local IP addresses
If you have more than one computer connected to the Internet on your home network using a broadband router or gateway, each computer probably uses a local
IP address that is provided by your router. The local address is created using a
Dynamic Host Configuration Protocol (DHCP) service in your router. The Arduino
Ethernet library does not include a DHCP service, so you either need to select a local IP address or use a third-party library that adds DHCP. Most of the recipes in this chapter show a user-selected IP address that you may need to modify to suit your network. Recipe 15.2 shows how the IP address can be obtained automatically using DHCP.
Web requests from a web browser and the resultant responses use Hypertext Transfer
Protocol (HTTP) messages. For a web client or server to respond correctly, it must understand and respond to HTTP requests and responses. Many of the recipes in this chapter use this protocol, and referring to one of the references listed earlier for more details will help with understanding how these recipes work in detail.
Web pages are usually formatted using Hypertext Markup Language (HTML). Although it’s not essential to use HTML if you are making an Arduino web server, as
Recipe 15.9 illustrates, the web pages you serve can use this capability.
Extracting data from a web server page intended to be viewed by people using a web browser can be a little like finding a needle in a haystack because of all the extraneous text, images, and formatting tags used on a typical page. This task is simplified in the recipes here with a library written for this book, called TextFinder. It is available from

452 | Chapter 15: Ethernet and Networking

the Arduino Playground and on the website for this book. TextFinder extracts information from a stream of data. It is used with the Arduino Ethernet library to find particular sequences of characters and to get strings and numeric values.
Web interchange formats have been developed to enable reliable extraction of web data by computer software. XML and JSON are two of the most popular formats, and
Recipe 15.5 shows an example of how to do this using Arduino.

15.1 Setting Up the Ethernet Shield
Problem
You want to set up the Ethernet shield to use a hardcoded IP address.

Solution
This sketch is based on the Ethernet client example sketch distributed with Arduino.
Check the documentation for your network to ensure that the Arduino IP address (the value of the ip variable) is valid for your network:
#if ARDUINO > 18
#include
#endif

// needed for Arduino versions later than 0018

#include byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; byte ip[] = { 192, 168 1, 177 };
// change to a valid address for your network byte server[] = { 64, 233, 187, 99 }; // Google
// see text for more on IP addressing

Client client(server, 80); void setup()
{
Ethernet.begin(mac, ip); // start ethernet using the mac and IP address
Serial.begin(9600);
// start the serial library: delay(1000); // give the ethernet hardware a second to initialize
Serial.println("connecting...");
if (client.connect()) {
Serial.println("connected");
client.println("GET /search?q=arduino HTTP/1.0"); // the HTTP request client.println(); } else {
Serial.println("connection failed");
}
}

15.1 Setting Up the Ethernet Shield | 453

void loop()
{
if (client.available()) { char c = client.read();
Serial.print(c); // echo all data received to the Serial Monitor
}

}

if (!client.connected()) {
Serial.println();
Serial.println("disconnecting."); client.stop(); for(;;)
;
}

Discussion
This sketch performs a Google search using the word “arduino”. Its purpose is to provide working code that you can use to verify that your network configuration is suitable for the Arduino Ethernet shield.
There are four addresses that must be set up correctly for the sketch to successfully connect and display the results of the search on the Serial Monitor: byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

The MAC address uniquely identifies your Ethernet shield. Every network device must have a different MAC address, and if you use more than one Arduino shield on your network, each must use a different address. If you have a single Ethernet shield, you don’t need to change this: byte ip[] = { 192, 168 1, 177 }; network // change this to a valid address for your

The IP address is used to identify something that is communicating on the Internet and must also be unique on your network. The address consists of four bytes, and the range of valid values for each byte depends on how your network is configured. IP addresses are usually expressed with dots separating the bytes—for example, 192.168.1.177. In all the Arduino sketches, commas are used instead of dots because the bytes are stored in an array (see Recipe 2.4).
If your network is connected to the Internet using a router or gateway, you may need to provide the IP address of the gateway when you call the ethernet.begin function.
You can find the address of the gateway in the documentation for your router/gateway.
Add a line after the IP and server addresses at the top of the sketch with the address of your gateway: byte gateway[] ={ 192, 168, 1, 254 }; gateway 454 | Chapter 15: Ethernet and Networking

// add this if needed by your router or

And change the first line in setup to include the gateway address in the startup values for Ethernet:
Ethernet.begin(mac, ip, gateway);

The server address consists of the 4-byte IP address of the server you want to connect to—in this case, Google. Server IP addresses change from time to time, so you may need to use the ping utility of your operating system to find a current IP address for the server you wish to connect to: byte server[] = { 64, 233, 187, 99 }; // Google

The line at the top of the sketch that includes is required for
Arduino releases starting at 0019, but not for earlier versions. The code in the sketch here uses a conditional check to enable it to work in any version. See Recipe 17.6 for more on conditional defines.

See Also
The web reference for getting started with the Arduino Ethernet shield is at http:// arduino.cc/en/Guide/ArduinoEthernetShield. 15.2 Obtaining Your IP Address Automatically
Problem
The IP address you use for the Ethernet shield must be unique on your network and you would like this to be allocated automatically. You want the Ethernet shield to obtain an IP address from a DHCP server.

Solution
This is the sketch from Recipe 15.1 with the bolded lines added to use the DHCP library:
#if ARDUINO > 18
#include
#endif

// needed for Arduino versions later than 0018

#include
#include "Dhcp.h"

// add this for the DHCP library

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
// IP addressing lines removed byte server[] = { 209,85,229,104 }; // Google
Client client(server, 80);

15.2 Obtaining Your IP Address Automatically | 455

void setup()
{
Serial.begin(9600); if(Dhcp.beginWithDHCP(mac) == 1)
// begin method returns 1 if successful
{
Serial.println("got IP address, connecting..."); delay(5000); } else {
Serial.println("unable to acquire ip address!"); while(true) ; // do nothing
}

}

if (client.connect()) {
Serial.println("connected");
client.println("GET /search?q=arduino HTTP/1.0"); client.println(); } else {
Serial.println("connection failed");
}
void loop()
{
if (client.available()) { char c = client.read();
Serial.print(c);
}

}

if (!client.connected()) {
Serial.println();
Serial.println("disconnecting."); client.stop(); for(;;)
;
}

Discussion
The library distributed with the Arduino release does not support DHCP (at the time of this writing), but you can obtain a third-party library from this book’s website or from http://blog.jordanterrell.com/post/Arduino-DHCP-Library-Version-04.aspx. Copy the contents of the download into the Arduino\hardware\libraries\Ethernet folder.
The highlighted lines show the differences from the sketch in Recipe 15.1. There is no
IP or gateway address variable; these are acquired from your DHCP server when the sketch starts.

456 | Chapter 15: Ethernet and Networking

If you want to see the values returned from the DHCP server on the Serial Monitor, use the following setup function: void setup()
{
Serial.begin(9600); if(Dhcp.beginWithDHCP(mac) == 1)
// begin method returns 1 if successful
{
byte buffer[6];
Serial.println("ip acquired...");
// show the values returned from the DHCP server
Dhcp.getLocalIp(buffer);
Serial.print("ip address: "); printArray(&Serial, ".", buffer, 4, 10);
Dhcp.getSubnetMask(buffer);
Serial.print("subnet mask: "); printArray(&Serial, ".", buffer, 4, 10);
Dhcp.getGatewayIp(buffer);
Serial.print("gateway ip: "); printArray(&Serial, ".", buffer, 4, 10);
Dhcp.getDhcpServerIp(buffer);
Serial.print("dhcp server ip: "); printArray(&Serial, ".", buffer, 4, 10);
Dhcp.getDnsServerIp(buffer);
Serial.print("dns server ip: "); printArray(&Serial, ".", buffer, 4, 10);

}

delay(5000);
}
else
{
Serial.println("unable to acquire ip address!"); while(true) ; // do nothing
}
if (client.connect()) {
Serial.println("connected");
client.println("GET /search?q=arduino HTTP/1.0"); client.println(); } else {
Serial.println("connection failed");
}

And add this function to the end of the sketch to produce the formatted output that is sent to the Serial Monitor: void printArray(Print *output, char* delimeter, byte* data, int len, int base)
{
char buf[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

15.2 Obtaining Your IP Address Automatically | 457

Download from Wow! eBook

for(int i = 0; i < len; i++)
{
if(i != 0) output->print(delimeter); }
}

output->print(itoa(data[i], buf, base));

output->println();

Running this sketch will display the IP configuration information received from your
DHCP server on the Serial Monitor:
IP address: 192.168.1.177 subnet mask: 255.255.255.0 gateway IP: 192.168.1.254
DHCP server IP: 192.168.1.254
DNS server IP: 192.168.1.254

15.3 Resolving Hostnames to IP Addresses (DNS)
Problem
You want to use a server name—for example, yahoo.com—rather than a specific IP address. Web providers often have a range of IP addresses used for their servers and a specific address may not be in service when you need to connect.

Solution
You can use DNS to look up a valid IP address for the name you provide. This example uses DNS code from Matt Robertson at http://kegger.googlecode.com/files/Ethernet.zip:
/*
* WebClientDNS sketch
*/
#if ARDUINO > 18
#include
#endif

// needed for Arduino versions later than 0018

#include "Ethernet_dns.h"
#include "Dns.h"
// uses DNS library from Matt Robertson byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; byte ip[] = {192, 168, 1, 177 };
// change to a valid address for your network byte gateway[] ={192, 168, 1, 254 }; // add this if you use a router or gateway
// see text for more on IP addressing byte subnet[] ={255, 255, 255, 0 };
// this defines the subnet address

458 | Chapter 15: Ethernet and Networking

byte ipBuffer[6];

// this will get the server IP address from DNS

Client client(ipBuffer, 80);
DnsClass Dns;
//Client client(ipBuffer, server, 80); void setup()
{
Serial.begin(9600);
Ethernet.begin(mac, ip, gateway, subnet);
//// Do DNS Lookup
Serial.println("getting server address");
Dns.init("google.com", ipBuffer); //Buffer has IP address of the DNS server
Dns.resolve();
int results; while(!(results=Dns.finished())) ;

//wait for DNS to resolve the name

if(results != 1){
Serial.print("DNS Error code: ");
Serial.print(results,DEC);
while(true)
; // do nothing
}
delay(5000);

}

if (client.connect()) {
Serial.println("connected");
client.println("GET /search?q=arduino HTTP/1.0"); client.println(); } else {
Serial.println("connection failed");
}
void loop()
{
if (client.available()) { char c = client.read();
Serial.print(c);
} if (!client.connected()) {
Serial.println();
Serial.println("disconnecting."); client.stop(); for(;;)
;
}
}

15.3 Resolving Hostnames to IP Addresses (DNS) | 459

Discussion
This code is similar to the code in Recipe 15.1; it does a Google search for “arduino”.
But in this version it is not necessary to provide the Google IP address—it is obtained through a request to the Internet DNS service.
The request is achieved through these function calls:
Dns.init("google.com", ipBuffer); //Buffer contains the IP address of the DNS server Dns.resolve(); while(!(results=Dns.finished())) ; //wait for DNS to resolve the name

The Dns.Init function is called with two parameters: the server (host) name to look up and the character array to hold the IP address if the lookup is successful. Dns.resolve sends the request, and Dns.finished returns the status of the reply. Here are the values that can be returned from Dns.finished:
1 = success
2 = No DNS records found
3 = timeout greater than 16 is an error code provided by the DNS server

The sketch checks the value returned from Dns.finished—if it is 1, the variable ipBuffer will contain a valid IP address; otherwise, it is an error that is printed to the
Serial Monitor.
You can view the IP address using the following code:
Dns.getIP(ipBuffer); //buffer now contains the IP address for server given in
Dns.Init()
Serial.print("Google address: "); printIp(ipBuffer); The printIp function is: void printIp(byte *rawData)
{
for(int i=0; i < 4; i++){
Serial.print(rawData[i],DEC);
if(i < 3)
Serial.print('.');
}
Serial.println();
}

You can use DNS and DHCP together. Here is the sketch with DHCP functionality added (see Recipe 15.2):
/*
* WebClientDHCP_DNS sketch
*/
#if ARDUINO > 18
#include
// needed for Arduino versions later than 0018
#endif

460 | Chapter 15: Ethernet and Networking

#include "Ethernet_dns.h"
#include "Dhcp.h"
// add this for the DHCP library
#include "Dns.h"
// uses DNS library from Matt Robertson byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; byte ipBuffer[6];
Client client(ipBuffer, 80);
DnsClass Dns;
//Client client(ipBuffer, server, 80); void setup()
{
Serial.begin(9600); if(Dhcp.beginWithDHCP(mac) == 1)
// begin method returns 1 if successful
{
Serial.println("got IP address");
//// Do DNS Lookup
Serial.println("getting server address");
Dns.init("google.com", ipBuffer); //Buffer has IP address of the DNS server
Dns.resolve();
int results; while(!(results=Dns.finished())) ;

//wait for DNS to resolve the name

if(results != 1){
Serial.print("DNS Error code: ");
Serial.print(results,DEC);
while(true)
; // do nothing
}
delay(5000);

}

} else {
Serial.println("unable to acquire ip address!"); while(true) ; // do nothing
}
if (client.connect()) {
Serial.println("connected");
client.println("GET /search?q=arduino HTTP/1.0"); client.println(); } else {
Serial.println("connection failed");
}
void loop()
{
if (client.available()) { char c = client.read();
Serial.print(c);
}

15.3 Resolving Hostnames to IP Addresses (DNS) | 461

if (!client.connected()) {
Serial.println();
Serial.println("disconnecting."); client.stop(); for(;;)
;
}
}

15.4 Requesting Data from a Web Server
Problem
You want Arduino to get data from a web server. For example, you want to find and use specific values returned from a web server.

Solution
This sketch uses Google Calculator to convert 50 kilometers to miles. It sends the query
“what+is+50+km+in+mi” and prints the result to the Serial Monitor:
/*
* SimpleClientwFinder sketch
*
*/
#if ARDUINO > 18
#include
#endif

// needed for Arduino versions later than 0018

#include
#include
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; byte ip[] = { 192,168,1,177 };
//byte gateway[] ={ 192, 168, 1, 254 };
//byte subnet[] ={ 255, 255, 255, 0 }; byte server[] = { 173,194,33,104 }; // Google
Client client(server, 80);
TextFinder finder( client); int result; // the result of the google calculation void setup()
{
Ethernet.begin(mac, ip);
Serial.begin(9600);
delay(2000);
Serial.println("connecting...");

462 | Chapter 15: Ethernet and Networking

} void loop()
{
if (client.connect()) {
Serial.print("connected... "); client.println("GET /search?hl=en&q=what+is+50+km+in+mi HTTP/1.1"); client.println(); } else {
Serial.println("connection failed");
}
if (client.connected()) { if(finder.find("50 kilometers")){ if(finder.find("=")){ result = finder.getValue();
Serial.println(result);
}
}
else
Serial.println("result not found"); client.stop(); delay(10000); // check again in 10 seconds
}
else {
Serial.println();
Serial.println("not connected"); client.stop(); delay(1000);
}
}

Discussion
The sketch assumes the results will be returned in bold (using the HTML tag) followed by the value given in the query and the word kilometers.
The searching is done using the TextFinder library described in this chapter’s introduction. The find method searches through the received data and returns true if it finds the target string. The code looks for text associated with the reply. In this example, it tries to find “50 kilometers” using this line: if(finder.find("50 kilometers")){

finder is used again to find the equals sign (=) that precedes the numerical value of the

result.
The result is obtained using the getvalue method and is printed to the Serial Monitor. getValue returns an integer value; if you want to get a floating-point value, use get
Float instead:
Float floatResult = finder.getFloat();
Serial.println(floatResult);

15.4 Requesting Data from a Web Server | 463

If you want your searches to be robust, you need to look for a unique tag that will only be found preceding the data you want. This is easier to achieve on pages that use unique tags for each field, such as this example that gets the Google stock price from Google
Finance and writes the value to analog output pin 0 and to the Serial Monitor:
/*
* WebClientGoogleFinance sketch
* get the stock value for google and write to analog pin.
*/
#if ARDUINO > 18
#include
// needed for Arduino versions later than 0018
#endif
#include
#include
byte byte byte byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; ip[] = { 192, 168,1,177 }; gateway[] ={ 192, 168, 1, 254 }; subnet[] ={ 255, 255, 255, 0 };

byte server[] = {209,85,229,147 };
Client client(server, 80);

// google

TextFinder finder( client ); float value; void setup()
{
Ethernet.begin(mac, ip, gateway, subnet);
Serial.begin(9600);
delay(2000);
}
void loop()
{
Serial.print("Connecting..."); if (client.connect()) { client.println("GET //finance?q=google HTTP/1.0"); // todo client.println("User-Agent: AVR ethernet"); client.println(); } else {
Serial.println("connection failed");
}
if (client.connected()) { if(finder.find("")) { finder.find(">"); // seek past the next '>' value = finder.getFloat();
Serial.println(value);
analogWrite(0, value);
}

464 | Chapter 15: Ethernet and Networking

else
Serial.print("Could not find field");
}
else {
Serial.println("Disconnected");
} client.stop(); client.flush(); delay(5000); // 5 seconds between each connect attempt
}

These examples use the GET command to request a specific page. Some web requests need data to be sent to the server within the body of the message, because there is more data to be sent than can be handled by the GET command. These requests are handled using the POST command. Here is an example of POST that uses the Babel Fish language translation service to translate text from Italian into English:
/*
* WebClient_Babelfish sketch
* Uses Post to get data from a web server
*
*/
#if ARDUINO > 18
#include
// needed for Arduino versions later than 0018
#endif
#include
#include
byte byte byte byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; ip[] = { 192, 168,1,177 }; gateway[] ={ 192, 168, 1, 254 }; subnet[] ={ 255, 255, 255, 0 };

byte server[] = {66,196,80,202 }; //babelfish.yahoo.com
Client client(server, 80);
// the text to translate char * transText = "trtext=Ciao+mondo+da+Arduino.&lp=it_en"; char buffer [31];
TextFinder

// room for 30 characters and the terminating null

finder(client);

void setup()
{
Ethernet.begin(mac, ip, gateway, subnet);
Serial.begin(9600);
delay(3000);
}
void loop()
{
postPage( "/translate_txt", transText);

15.4 Requesting Data from a Web Server | 465

}

delay(5000); void postPage(char *webPage, char *parameter){ if (client.connect()) { client.print("POST "); client.print(webPage); client.println(" HTTP/1.0"); client.println("Content-Type: application/x-www-form-urlencoded"); client.println("Host: babelfish.yahoo.com"); client.print("Content-Length: "); client.println(strlen(parameter)); client.println(); client.println(parameter); } else {
Serial.println(" connection failed");
}
if (client.connected()) { finder.find(""); finder.getString( ">", " 18
#include
#endif

// needed for Arduino versions later than 0018

#include
#include
byte byte byte byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; ip[] = { 192, 168, 1, 177 }; gateway[] = { 192, 168, 1, 254 }; subnet[] = { 255, 255, 255, 0 };

Twitter twitter("YourID:Password"); char frontOpen[] = "The front door was opened"; char backOpen[] = "The back door was opened"; const int frontSensor = 2; const int backSensor = 3; boolean frontMsgSent = false; boolean backMsgSent = false; void setup()
{
Ethernet.begin(mac, ip, gateway, subnet);
Serial.begin(9600);
pinMode(frontSensor, INPUT); pinMode(backSensor, INPUT); digitalWrite(frontSensor, HIGH); digitalWrite(backSensor, HIGH);
}

// pull-ups

delay(1000); void loop()
{
if(digitalRead(frontSensor) == LOW)
{ // here if door is open if(frontMsgSent == false){ // check if message already sent frontMsgSent = sendMessage(frontOpen);
}
} else{ frontMsgSent = false; // door closed so reset the state
}
if(digitalRead(backSensor) == LOW)
{

15.12 Sending Twitter Messages | 495

if(frontMsgSent == false) { backMsgSent = sendMessage(backOpen);
}
} else { backMsgSent = false;
}
delay(100);
}
// add in the sendMessage function from the sketch above

The code that communicates with Twitter is the same, but the message string here is constructed from the values read from sensors connected to two Arduino digital pins.

15.13 Sending and Receiving Simple Messages (UDP)
Problem
You want to send and receive simple messages over the Internet.

Solution
This sketch uses the Arduino UDP (User Datagram Protocol) library to send and receive strings. In this simple example, Arduino prints the received string to the Serial Monitor and a string is sent back to the sender saying “acknowledged”:
*
* UDPSendReceiveStrings
* This sketch receives UDP message strings, prints them to the serial port
* and sends an "acknowledge" string back to the sender
*
*/
#if ARDUINO > 18
#include
#endif

// needed for Arduino versions later than 0018

#include
#include // UDP library from: bjoern@cs.stanford.edu 12/30/2008 byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // MAC address to use byte ip[] = {192, 168, 1, 177 };
// Arduino's IP address unsigned int localPort = 8888;

// local port to listen on

// the next two variables are set when a packet is received byte remoteIp[4];
// holds received packet's originating IP unsigned int remotePort; // holds received packet's originating port
// buffers for receiving and sending data byte packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet, char replyBuffer[] = "acknowledged";
// a string to send back

496 | Chapter 15: Ethernet and Networking

void setup() {
// start the Ethernet and UDP:
Ethernet.begin(mac,ip);
Udp.begin(localPort);
Serial.begin(9600);
} void loop() {
// if there's data available, read a packet int packetSize = Udp.available(); // note that this includes the UDP header if(packetSize) { packetSize = packetSize - 8;
// subtract the 8 byte header
Serial.print("Received packet of size ");
Serial.println(packetSize);
// read packet into packetBuffer and get sender's IP addr and port number
Udp.readPacket(packetBuffer,UDP_TX_PACKET_MAX_SIZE, remoteIp, &remotePort);
Serial.println("Contents:");
Serial.println((char*)packetBuffer);
// send a string back to the sender
Udp.sendPacket((byte*)replyBuffer,strlen(replyBuffer),remoteIp,remotePort);

}

} delay(10); You can test this by running the following Processing sketch on your computer (see
Chapter 4 for guidance on installing and running Processing):
// Processing UDP example to send and receive string data from Arduino
// press any key to send the "Hello Arduino" message import hypermedia.net.*;
UDP udp;

// define the UDP object

void setup() { udp = new UDP( this, 6000 );
//udp.log( true ); udp.listen( true );
}

// create a new datagram connection on port 6000
// "); currentSeconds = second();
Alarm.delay(1); //Alarm.delay must be called to service the alarms
}
}

Open the Serial Monitor and watch the output being printed. After nine seconds of output, you should see this:
1->task
2->task
3->task
4->task
5->task
6->task
7->task
8->task
9->task

1
1
1
1
1
1
1
1
1

task task task task task

2
3
2
5
2

task 2 task 3

task 4 task 3

task 6

task 4

The task scheduled for seven seconds did not trigger because the library only provides six timer “objects” that you can use.
You can increase this by modifying the library. Go to the libraries folder in your Arduino
Documents folder.
You can locate the directory containing the sketchbook folder by clicking on the menu item File→Preferences in the IDE. A dialog box will open, showing the sketchbook location.

If you have installed the Time and TimeAlarms libraries (both libraries are in the file you downloaded), navigate to the Libraries\TimeAlarms folder. Open the
TimeAlarms.h header file (for more details about header files, see Recipe 16.4). You can edit the file with any text editor; for example, Notepad on Windows or TextEdit on a Mac.

520 | Chapter 16: Using, Modifying, and Creating Libraries

You should see the following at the top of the TimeAlarms.h file:
#ifndef TimeAlarms_h
#define TimeAlarms_h
#include
#include "Time.h"
#define dtNBR_ALARMS 6

The maximum number of alarms is specified by the value defined for dtNbr_ALARMS.
Change:
#define dtNBR_ALARMS 6

to:
#define dtNMBR_ALARMS 7

and save the file.
Upload the sketch to your Arduino again, and this time the serial output should read:
1->task
2->task
3->task
4->task
5->task
6->task
7->task
8->task
9->task

1
1
1
1
1
1
1
1
1

task task task task task task task task 2
3
2
5
2
7
2
3

task 4 task 3

task 6

task 4

You can see that task 7 now activates after seven seconds.

Discussion
Capabilities offered by a library are a trade-off between the resources used by the library and the resources available to the rest of your sketch, and it is often possible to change these capabilities if required. For example, you may need to decrease the amount of memory used for a serial library so that other code in the sketch has more RAM. Or you may need to increase the memory usage by a library for your application. The library writer generally creates the library to meet typical scenarios, but if your application needs capabilities not catered to by the library writer, you may be able to modify the library to accommodate them.
In this example, the TimeAlarms library allocates room (in RAM) for six alarms. Each of these consumes around a dozen bytes and the space is reserved even if only a few are used. The number of alarms is set in the library header file (the header is a file named
TimeAlarms.h in the TimeAlarms folder). Here are the first few lines of TimeAlarms.h:
#ifndef TimeAlarms_h
#define TimeAlarms_h
#include

16.3 Modifying a Library | 521

#include "Time.h"
#define dtNBR_ALARMS 6

In the TimeAlarms library, the maximum number of alarms is set using a #define statement. Because you changed it and saved the header file when you recompiled the sketch to upload it, it uses the new upper limit.
Sometimes constants are used to define characteristics such as the clock speed of the board, and when used with a board that runs at a different speed, you will get unexpected results. Editing this value in the header file to the correct one for the board you are using will fix this problem.
If you edit the header file and the library stops working, you can always download the library again and replace the whole library to return to the original state.

See Also
Recipe 16.4 has more details on how you can add functionality to libraries.

16.4 Creating Your Own Library
Problem
You want to create your own library. Libraries are a convenient way to reuse code across multiple sketches and are a good way to share with other users.

Solution
A library is a collection of methods and variables that are combined in a format that enables users to access functions and variables in a standardized way.
Most Arduino libraries are written as a class. If you are familiar with C++ or Java, you will be familiar with classes. However, you can create a library without using a class, and this recipe shows you how.
This recipe explains how you can transform the sketch from Recipe 7.1 to move the
BlinkLED function into a library.
See Recipe 7.1 for the wiring diagram and an explanation of the circuit. Here is the sketch that will be the starting point for the library:
/*
* blinkLibTest
*/
const int firstLedPin = 3; const int secondLedPin = 5; const int thirdLedPin = 6;

// choose the pin for each of the LEDs

522 | Chapter 16: Using, Modifying, and Creating Libraries

void setup()
{
pinMode(firstLedPin, OUTPUT); pinMode(secondLedPin, OUTPUT); pinMode(thirdLedPin, OUTPUT);
}

// declare LED pins as output
// declare LED pins as output
// declare LED pins as output

void loop()
{
// flash each of the LEDs for 1000 milliseconds (1 second) blinkLED(firstLedPin, 1000); blinkLED(secondLedPin, 1000); blinkLED(thirdLedPin, 1000);
}

The blinkLED function from Recipe 7.1 should be removed from the sketch and moved into a separate file named blinkLED.cpp (see the Discussion for more details about .cpp files):
/* blinkLED.cpp
* simple library to light an LED for a duration given in milliseconds
*/
#include // Arduino includes
#include "blinkLED.h"
// blink the LED on the given pin for the duration in milliseconds void blinkLED(int pin, int duration)
{
digitalWrite(pin, HIGH);
// turn LED on delay(duration); digitalWrite(pin, LOW);
// turn LED off delay(duration); }

Create the blinkLED.h header file as follows:
/*
* blinkLED.h
* Library header file for BlinkLED library
*/
void blinkLED(int pin, int duration);

// function prototype

Discussion
The library will be named blinkLED and will be located in the libraries folder (see
Recipe 16.2).
The blinkLED function from Recipe 7.1 is moved out of the sketch and into a library file named blinkLED.cpp (the .cpp extension stands for “C plus plus” and contains the executable code).

16.4 Creating Your Own Library | 523

The terms functions and methods are used in Arduino library documentation to refer to blocks of code such as blinkLED. The term method was introduced to refer to the functional blocks in a class. Both terms refer to the named functional blocks that are made accessible by a library.

The blinkLED.cpp file contains a blinkLED function that is identical to the code from
Recipe 7.1 with the following two lines added at the top:
#include // Arduino includes
#include "blinkLED.h"

The #include line is needed by a library that uses any Arduino functions or constants. Without this, the compiler will report errors for all the Arduino functions used in your sketch.
The next line, #include "blinkLED.h", contains the function definitions (also known as prototypes) for your library. The Arduino build process creates prototypes for all the functions within a sketch automatically when a sketch is compiled—but it does not create any prototypes for library code, so if you make a library, you must create a header with these prototypes. It is this header file that is added to a sketch when you import a library from the IDE (see Recipe 16.1).
Every library must have a file that declares the names of the functions to be exposed. This file is called a header file (also known as an include file) and has the form .h (where is the name for your library). In this example, the header file is named blinkLED.h and is in the same folder as blinkLED.cpp.

The header file for this library is simple. It declares the one function: void blinkLED(int pin, int duration);

// function prototype

This looks similar to the function definition in the blinkLED.cpp file: void blinkLED(int pin, int duration)

The difference is subtle but vital. The header file prototype contains a trailing semicolon. This tells the compiler that this is just a declaration of the form for the function but not the code. The source file, blinkLED.cpp, does not contain the trailing semicolon and this informs the compiler that this is the actual source code for the function. Libraries can have more than one header file and more than one implementation file. But there must be at least one header and that must match the library name. It is this file that is included at the top of the sketch when you import a library.

524 | Chapter 16: Using, Modifying, and Creating Libraries

A good book on C++ can provide more details on using header and .cpp files to create code modules. This recipe’s See Also section lists some popular choices.
With the blinkLED.cpp and blinkLED.h files in the correct place within the libraries folder, close the IDE and reopen it.
The Arduino IDE updates its list of available libraries only when the IDE is first started on your computer. If you create a library after the IDE is running, you need to close the IDE and restart for that library to be recognized. Upload the blinkLibTest sketch and you should see the three LEDs blinking.
It’s easy to add additional functionality to the library. For example, you can add some constant values for common delays so that users of your libraries can use the descriptive constants instead of millisecond values.
Add the three lines with constant values to your header file as follows:
// constants for duration const int BLINK_SHORT = 250; const int BLINK_MEDIUM = 500; const int BLINK_LONG = 1000; void blinkLED(int pin, int duration);

// function prototype

Change the code in loop as follows and upload the sketch to see the different blink rates: void loop()
{
blinkLED(firstLedPin, BLINK_SHORT); blinkLED(secondLedPin, BLINK_MEDIUM); blinkLED(thirdLedPin, BLINK_LONG);
}

You need to close and restart the IDE when you first add the library to the libraries folder, but not after subsequent changes to the library. Libraries included in Arduino release 0017 and later are recompiled each time the sketch is compiled. Arduino releases earlier than 0017 required the deletion of the library object files to make the library recompile and for changes to be included.

New functions can be easily added. This example adds a function that continues blinking for the number of times given by the sketch. Here is the loop code: void loop()
{
blinkLED(firstLedPin,BLINK_SHORT,5 ); blinkLED(secondLedPin,BLINK_MEDIUM,3 ); blinkLED(thirdLedPin, BLINK_LONG);
}

// blink 5 times
// blink 3 times
// blink once

16.4 Creating Your Own Library | 525

To add this functionality to the library, add the prototype to blinkLED.h as follows:
/*
* BlinkLED.h
* Header file for BlinkLED library
*/
const int BLINK_SHORT = 250; const int BLINK_MEDIUM = 500; const int BLINK_LONG = 1000; void blinkLED(int pin, int duration);
// new function for repeat count void blinkLED(int pin, int duration, int repeats);

Add the function into blinkLED.cpp:
/*
* BlinkLED.cpp
*/
#include // Arduino includes
#include "BlinkLED.h"
// blink the LED on the given pin for the duration in milliseconds void blinkLED(int pin, int duration)
{
digitalWrite(pin, HIGH);
// turn LED on delay(duration); digitalWrite(pin, LOW);
// turn LED off delay(duration); }
/* function to repeat blinking void blinkLED(int pin, int duration, int repeats)
{
while(repeats)
{
blinkLED(pin, duration); repeats = repeats -1;
}
}

You can create a keywords.txt file if you want to add syntax highlighting (coloring the keywords used in your library when viewing a sketch in the IDE). This is a text file that contains the name of the keyword and the keyword type—each type uses a different color. The keyword and type must be separated by a tab (not a space). For example, save the following file as keywords.txt in the blinkLED folder:
#######################################
# Methods and Functions (KEYWORD2)
#######################################
blinkLED KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################

526 | Chapter 16: Using, Modifying, and Creating Libraries

Download from Wow! eBook

BLINK_SHORT
BLINK_MEDIUM
BLINK_LONG

LITERAL1
LITERAL1
LITERAL1

See Also
“Writing a Library for Arduino” reference document: http://www.arduino.cc/en/Hack ing/LibraryTutorial Also see the following books on C++:
• Practical C++ Programming by Steve Oualline (O’Reilly)
• C++ Primer Plus by Stephen Prata (Sams)
• C++ Primer by Stanley B. Lippman, Josée Lajoie, and Barbara E. Moo (AddisonWesley Professional)

16.5 Creating a Library That Uses Other Libraries
Problem
You want to create a library that uses functionality from one or more existing libraries.
For example, you want to create a library to aid debugging that sends print output to a second Arduino board using the Wire library.

Solution
This recipe uses the Wire library discussed in Chapter 13 and the core Arduino print functionality to create a new library that sends printed output to another Arduino board connected using I2C. The connections and code are covered in Recipe 13.9. This recipe describes how that code can be converted into a library.
Create a folder named i2cDebug in the libraries directory (see Recipe 16.4 for details on the file structure for a library). Create a file named i2cDebug.h with the following code: /*
* i2cDebug.h
*/
#include
#include
// the Arduino print class class I2CDebugClass : public Print
{
private: int I2CAddress; byte count; void write(byte c); public: I2CDebugClass();

16.5 Creating a Library That Uses Other Libraries | 527

};

boolean begin(int id); extern I2CDebugClass i2cDebug;

// the i2c debug object

Create a file named i2cDebug.cpp in the i2cDebug folder as follows:
/*
* i2cDebug.cpp
*/
#include
#include

// the Arduino I2C library

I2CDebugClass::I2CDebugClass()
{
} boolean I2CDebugClass::begin(int id)
{
I2CAddress = id; // save the slave's address
Wire.begin(); // join I2C bus (address optional for master) return true;
}
void I2CDebugClass::write(byte c)
{
if( count == 0)
{
// here if the first char in the transmission
Wire.beginTransmission(I2CAddress); // transmit to device
}
Wire.send(c);
// if the I2C buffer is full or an end of line is reached, send the data
// BUFFER_LENGTH is defined in the Wire library if(++count >= BUFFER_LENGTH || c == '\n')
{
// send data if buffer full or newline character
Wire.endTransmission();
count = 0;
}
}
I2CDebugClass i2cDebug;

// Create an I2C debug object

Load this example sketch into the IDE:
/*
* i2cDebug
* example sketch for i2cDebug library
*/
#include
// the Arduino I2C library
#include

528 | Chapter 16: Using, Modifying, and Creating Libraries

const int address = 4; const int sensorPin = 0; int val;

//the address to be used by the communicating devices
// select the analog input pin for the sensor
// variable to store the sensor value

void setup()
{
Serial.begin(9600); i2cDebug.begin(address); } void loop()
{
// read the voltage on the pot(val ranges from 0 to 1023) val = analogRead(sensorPin);
Serial.println(val);
i2cDebug.println(val);
}

Remember that you need to restart the IDE after creating the library folder. See Recipe 16.4 for more detail on creating a library.
Upload the slave I2C sketch onto another Arduino board as described in Recipe 13.9, and you should see the output from the Arduino board running your library displayed on the second board.

Discussion
To include another library, use its include statement in your code as you would in a sketch. It is sensible to include information about any additional libraries that your library needs in documentation if you make it available for others to use, especially if it requires a library that is not distributed with Arduino.
This recipe provides an example of how to use a class when creating a library. A class is a programming technique for grouping functions and variables together. The following references provide an introduction to classes:
• Programming Interactivity by Joshua Noble (O’Reilly)
• C++ Primer by Stanley B. Lippman, Josée Lajoie, and Barbara E. Moo (AddisonWesley Professional)

16.5 Creating a Library That Uses Other Libraries | 529

CHAPTER 17

Advanced Coding and
Memory Handling

17.0 Introduction
As you do more with your Arduino, your sketches need to become more efficient. The techniques in this chapter can help you improve the performance and reduce the code size of your sketches. If you need to make your sketch run faster or use less RAM, the recipes here can help. The recipes here are more technical than most of the other recipes in this book because they cover things that are usually concealed by the friendly Arduino wrapper. The Arduino build process was designed to hide complex aspects of C and C++ as well as the tools used to convert a sketch into the bytes that are uploaded and run on an
Arduino board. But if your project has performance and resource requirements beyond the capability of the standard Arduino environment, you should find the recipes here useful. The Arduino board uses memory to store information. It has three kinds of memory: program memory, random access memory (RAM), and EEPROM. Each has different characteristics and uses. Many of the techniques in this chapter cover what to do if you do not have enough of one kind of memory.
Program memory (also known as flash) is where the executable sketch code is stored.
The contents of program memory can only be changed by the bootloader in the upload process initiated by the Arduino software running on your computer. After the upload process is completed, the memory cannot be changed until the next upload. There is far more program memory on an Arduino board than RAM, so it can be beneficial to store values that don’t change while the code runs (e.g., constants) in program memory.
The bootloader takes up some space in program memory. If all other attempts to minimize the code to fit in program memory have failed, the bootloader can be removed to free up space, but an additional hardware programmer is then needed to get code onto the board.
531

If your code is larger than the program memory space available on the chip, the upload will not work and the IDE will warn you that the sketch is too big when you compile.
RAM is used by the code as it runs to store the values for the variables used by your sketch (including variables in the libraries used by your sketch). RAM is volatile, which means it can be changed by code in your sketch. It also means anything stored in this memory is lost when power is switched off. Arduino has much less RAM than program memory. If you run out of RAM while your sketch runs on the board (as variables are created and destroyed while the code runs) the board will misbehave (crash).
EEPROM (Electrically Erasable Programmable Read-Only Memory) is memory that code running on Arduino can read and write, but it is nonvolatile memory that retains values even when power is switched off. EEPROM access is significantly slower than for RAM, so EEPROM is usually used to store configuration or other data that is read at startup to restore information from the previous session.
To understand these issues, it is helpful to understand how the Arduino IDE prepares your code to go onto the chip and how you can inspect the results it produces.

Preprocessor
Some of the recipes here use the preprocessor to achieve the desired result. Preprocessing is a step in the first stage of the build process in which the source code (your sketch) is prepared for compiling. Various find and replace functions can be performed. Preprocessor commands are identified by lines that start with #. You have already seen them in sketches that use a library—#include tells the preprocessor to insert the code from the named library file. Sometimes the preprocessor is the only way to achieve what is needed, but its syntax is different from C and C++ code, and it can introduce bugs that are subtle and hard to track down, so use it with care.

See Also
AVRfreaks is a website for software engineers that is a good source for technical detail on the controller chips used by Arduino: http://www.avrfreaks.net
Technical details on the C preprocessor are available at http://gcc.gnu.org/onlinedocs/ gcc-2.95.3/cpp_1.html. 17.1 Understanding the Arduino Build Process
Problem
You want to see what is happening under the covers when you compile and upload a sketch. 532 | Chapter 17: Advanced Coding and Memory Handling

Solution
To see all the command-line activity that takes place, hold down the Shift key when you click on Compile or Upload. The console area at the bottom of the IDE will display details of the compile process.
To have this detail always visible, you can change a value in the Arduino preferences.txt file. This file should be in the following locations:
Mac
/Users//Library/Arduino/preferences.txt
Windows XP
C:\Documents and Settings\\Application Data\Arduino\preferences.txt
Windows Vista c:\Users\\AppData\Roaming\Arduino\preferences.txt Linux
~/.arduino/preferences.txt
Make sure the Arduino IDE is not running (changes made to preferences.txt will not be saved if the IDE is running). Open the file and find the line build.verbose=false (it is near the bottom of the file). Change false to true and save the file.

Discussion
When you click on Compile or Upload, a lot of activity happens that is not usually displayed on-screen. The command-line tools that the Arduino IDE was built to hide are used to compile, link, and upload your code to the board.
First your sketch file(s) are transformed into a file suitable for the compiler (AVRGCC) to process. All source files in the sketch folder that have no file extension are joined together to make one file. All files that end in .c or .cpp are compiled separately.
Header files (with an .h extension) are ignored unless they are explicitly included in the files that are being joined.
#include "WProgram.h" is added at the top of the file to include the header file with all the Arduino-specific code definitions, such as digitalWrite() and analogRead(). If you

want to examine its contents, you can find the file on Windows under the directory where Arduino was installed; from there, you can navigate to
Hardware→Arduino→Cores→Arduino.
On the Mac, Ctrl+click the Arduino application icon and select Show Package Contents from the drop-down menu. A folder will open; from the folder, navigate to Contents→Resources→Java→Hardware→Arduino→Cores→Arduino.

17.1 Understanding the Arduino Build Process | 533

The Arduino directory structure may change in new releases, so check the documentation for the release you are using.

To make the code valid C++, the prototypes of any functions declared in your code are generated next and inserted.
Finally, the setting of the board menu is used to insert values (obtained from the boards.txt file) that define various constants used for the controller chips on the selected board. This file is then compiled by AVR-GCC, which is included within the Arduino main download (it is in the tools folder).
The compiler produces a number of object files (files with an extension of .o that will be combined by the link tool). These files are stored in /tmp on Mac and Linux. On
Windows, they are in the applet directory (a folder below the Arduino install directory).
The object files are then linked together to make a HEX file to upload to the board.
Avrdude, a utility for transferring files to the Arduino controller, is used to upload to the board.
The tools used to implement the build process can be found in the hardware\tools directory. Another useful tool for experienced programmers is avr-objdump, also in the tools folder. It lets you see how the compiler turns the sketch into code that the controller chip runs. This tool produces a disassembly listing of your sketch which shows the object code intermixed with the source code. It can also display a memory map of all the variables used in your sketch. To use the tool, compile the sketch and navigate to the folder containing the Arduino distribution. Then, navigate to the folder with all the intermediate files used in the build process (as explained earlier). The file used by avr-objdump is the one with the extension .elf. For example, if you compile the Blink sketch you could view the compiled output (the machine code) by executing the following on the command line:
..\hardware\tools\avr\bin\avr-objdump.exe -S blink.cpp.elf

It is convenient to direct the output to a file that can be read in a text editor. You can do this as follows:
..\hardware\tools\avr\bin\avr-objdump.exe -S blink.cpp.elf > blink.txt

This version adds a list of section headers (helpful for determining memory usage):
..\hardware\tools\avr\bin\avr-objdump.exe -S -h blink.cpp.elf > blink.txt

534 | Chapter 17: Advanced Coding and Memory Handling

You can create a batch file to dump the listing into a file. Add the path of your Arduino installation to the following line and save it to a batch file: hardware\tools\avr\bin\avr-objdump.exe -S -h -Tdata %1 > %1%.txt

See Also
For information on the Arduino build process, see http://code.google.com/p/arduino/ wiki/BuildProcess. The AVRfreaks website: http://www.avrfreaks.net/wiki/index.php/Documentation:AVR
_GCC

17.2 Determining the Amount of Free and Used RAM
Problem
You want to be sure you have not run out of RAM. A sketch will not run correctly if there is insufficient memory, and this can be difficult to detect.

Solution
This recipe shows you how you can determine the amount of free memory available to your sketch. This sketch contains a function called memoryFree that reports the amount of available RAM: void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print(memoryFree());
Serial.print(' '); delay(1000); }

// print the free memory
// print a space

// variables created by the build process when compiling the sketch extern int __bss_end; extern void *__brkval;
// function to return the amount of free RAM int memoryFree()
{
int freeValue;

17.2 Determining the Amount of Free and Used RAM | 535

if((int)__brkval == 0) freeValue = ((int)&freeValue) - ((int)&__bss_end); else freeValue = ((int)&freeValue) - ((int)__brkval);
}

return freeValue;

Discussion
The memoryFree function uses system variables to calculate the amount of RAM. System variables are not normally visible (they are created by the compiler to manage internal resources). It is not necessary to understand how the function works to use its output.
The function returns the number of bytes of free memory.
The number of bytes your code uses changes as the code runs. The important thing is to ensure that you don’t consume more memory than you have.
Here are the main ways RAM memory is consumed:
• When you initialize constants:
#define ERROR_MESSAGE "an error has occurred"

• When you declare global variables: char myMessage[] = "Hello World";

• When you make a function call: void myFunction(int value)
{
int result; result = value * 2; return result;
}

• When you dynamically allocate memory:
String stringOne = "Arduino String";

The Arduino String class uses dynamic memory to allocate space for strings. You can see this by adding the following line to the very top of the code in the Solution:
String s = "\n";

and the following lines just before the delay in the loop code: s = s + "Hello I am Arduino \n";
Serial.println(s);
// print the string value

You will see the memory value reduce as the size of the string is increased each time through the loop. If you run the sketch long enough, the memory will run out—don’t endlessly try to increase the size of a string in anything other than a test application.
Writing code like this that creates a constantly expanding value is a sure way to run out of memory. You should also be careful not to create code that dynamically creates

536 | Chapter 17: Advanced Coding and Memory Handling

different numbers of variables based on some parameter while the code runs, as it will be very difficult to be sure you will not exceed the memory capabilities of the board when the code runs.
Constants and global variables are often declared in libraries as well, so you may not be aware of them, but they still use up RAM. The Serial library, for example, has a 128byte global array that it uses for incoming serial data. This alone consumes one-eighth of the total memory of an old Arduino 168 chip.

See Also
A technical overview of memory usage is available at http://www.gnu.org/savannah
-checkouts/non-gnu/avr-libc/user-manual/malloc.html.

17.3 Storing and Retrieving Numeric Values in
Program Memory
Problem
You have a lot of constant numeric data and don’t want to allocate this to RAM.

Solution
Store numeric variables in program memory (the flash memory used to store Arduino programs). This sketch adjusts a fading LED for the nonlinear sensitivity of human vision. It stores the values to use in a table of 256 values in program memory rather than RAM.
The sketch is based on Recipe 7.2; see Chapter 7 for a wiring diagram and discussion on driving LEDs. Running this sketch results in a smooth change in brightness with the
LED on pin 5 compared to the LED on pin 3:
/* ProgmemCurve sketch
* uses table in Progmem to convert linear to exponential output
* See Recipe 7.2 and Figure 7-2
*/
#include

// needed for PROGMEM

// table of exponential values
// generated for values of i from 0 to 255 -> x=round( pow( 2.0, i/32.0) - 1); const byte table[]PROGMEM = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
1,
1,
2,
2,
2,
2,
2,
2,
3,
3,
3,
3,
3,
3,

0,
1,
1,
2,
4,

0,
1,
1,
2,
4,

0,
1,
1,
2,
4,

0,
1,
1,
2,
4,

0,
1,
1,
3,
4,

0,
1,
2,
3,
4,

0,
1,
2,
3,
4,

0,
1,
2,
3,
4,

0,
1,
2,
3,
4,

0,
1,
2,
3,
5,

17.3 Storing and Retrieving Numeric Values in Program Memory | 537

5,
5,
5,
5,
5, 5,
5,
6, 6,
6,
6,
7,
7,
7,
8,
8, 8,
8,
8, 9,
9,
9,
10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13,
15, 15, 16, 16, 16, 17, 17, 18, 18, 18, 19,
22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27,
31, 32, 32, 33, 34, 35, 35, 36, 37, 38, 39,
44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55,
63, 64, 66, 67, 69, 70, 72, 73, 75, 77, 78,
90, 91, 94, 96, 98, 100, 102, 104, 107, 109, 111,
127, 130, 133, 136, 139, 142, 145, 148, 151, 155, 158,
180, 184, 188, 192, 196, 201, 205, 210, 214, 219, 224,
};
const int rawLedPin = 3; const int adjustedLedPin = 5;

6,
6,
6,
7,
7,
9,
9, 10, 10, 10,
13, 14, 14, 14, 15,
19, 20, 20, 21, 21,
28, 28, 29, 30, 30,
40, 40, 41, 42, 43,
56, 58, 59, 60, 62,
80, 82, 84, 86, 88,
114, 116, 119, 122, 124,
161, 165, 169, 172, 176,
229, 234, 239, 244, 250

// this LED is fed with raw values
// this LED is driven from table

int brightness = 0; int increment = 1; void setup()
{
// pins driven by analogWrite do not need to be declared as outputs
}
void loop()
{
if(brightness > 255)
{
increment = -1; // count down after reaching 255
}
else if(brightness < 1)
{
increment = 1; // count up after dropping back down to 0
}
brightness = brightness + increment; // increment (or decrement sign is minus)
// write the brightness value to the LEDs analogWrite(rawLedPin, brightness); // this is the raw value int adjustedBrightness = pgm_read_byte(&table[brightness]); // adjusted value analogWrite(adjustedLedPin, adjustedBrightness);
}

delay(10); // 10ms for each step change means 2.55 secs to fade up or down

Discussion
When you need to use a complex expression to calculate a range of values that regularly repeat, it is often better to precalculate the values and include them in a table of values
(usually as an array) in the code. This saves the time needed to calculate the values repeatedly when the code runs. The disadvantage concerns the memory needed to place these values in RAM. RAM is limited on Arduino and the much larger program memory space can be used to store constant values. This is particularly helpful for sketches that have large arrays of numbers.

538 | Chapter 17: Advanced Coding and Memory Handling

At the top of the sketch, the table is defined with the following expression: const byte table[]PROGMEM = {
0, . . .

PROGMEM tells the compiler that the values are to be stored in program memory rather

than RAM. The remainder of the expression is similar to defining a conventional array
(see Chapter 2).
The low-level definitions needed to use PROGMEM are contained in a file named pgmspace.h and the sketch includes this as follows:
#include

To adjust the brightness to make the fade look uniform, this recipe adds the following lines to the LED output code used in Recipe 7.2: int adjustedBrightness = pgm_read_byte(&table[brightness]); analogWrite(adjustedLedPin, adjustedBrightness);

The variable adjustedBrightness is set from a value read from program memory. The expression pgm_read_byte(&table[brightness]); means to return the address of the entry in the table array at the index position given by brightness. Each entry in the table is one byte, so another way to write this expression is: pgm_read_byte(table + brightness);

If it is not clear why &table[brightness] is equivalent to table + brightness, don’t worry; use whichever expression makes more sense to you.
Another example is from Recipe 6.5, which used a table for converting an infrared sensor reading into distance. Here is the sketch from that recipe converted to use a table in program memory instead of RAM:
/* ir-distance_Progmem sketch
* prints distance & changes LED flash rate depending on distance from IR sensor
* uses progmem for table
*/
#include // needed when using Progmem
// table entries are distances in steps of 250 millivolts const int TABLE_ENTRIES = 12; const int firstElement = 250; // first entry is 250 mV const int interval = 250; // millivolts between each element
// the following is the definition of the table in Program Memory const int distanceP[TABLE_ENTRIES] PROGMEM = { 150,140,130,100,60,50,
40,35,30,25,20,15 };
// This function reads from Program Memory at the given index int getTableEntry(int index)
{
int value = pgm_read_word(&distanceP[index]); return value;
}

17.3 Storing and Retrieving Numeric Values in Program Memory | 539

The remaining code is similar to Recipe 6.5, except that the getTableEntry function is used to get the value from program memory instead of accessing a table in RAM. Here is the revised getDistance function from that recipe: int getDistance(int mV)
{
if( mV > interval * TABLE_ENTRIES ) return getTableEntry(TABLE_ENTRIES-1); // the minimum distance else { int index = mV / interval; float frac = (mV % 250) / (float)interval; return getTableEntry(index) - ((getTableEntry(index) getTableEntry(index+1)) * frac);
}
}

17.4 Storing and Retrieving Strings in Program Memory
Problem
You have lots of strings and they are consuming too much RAM. You want to move string constants, such as menu prompts or debugging statements, out of RAM and into program memory.

Solution
This sketch creates a string in program memory and prints its value to the Serial Monitor. The amount of free RAM is printed using the function described in Recipe 17.2:
#include // for progmem
//create a string of 20 characters in progmem const prog_uchar myText[] = "arduino duemilanove "; void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print(memoryFree());
Serial.print(' ');

}

printP(myText); delay(1000); // print the free memory
// print a space
// print the string

// function to print a PROGMEM string void printP(const prog_uchar *str)

540 | Chapter 17: Advanced Coding and Memory Handling

{ char c;

}

while((c = pgm_read_byte(str++)))
Serial.print(c,BYTE);

// variables created by the build process when compiling the sketch extern int __bss_end; extern void *__brkval;
// function to return the amount of free RAM int memoryFree()
{
int freeValue; if((int)__brkval == 0) freeValue = ((int)&freeValue) - ((int)&__bss_end); else freeValue = ((int)&freeValue) - ((int)__brkval);
}

return freeValue;

Discussion
Strings are particularly hungry when it comes to RAM. Each character uses a byte, so it is easy to consume large chunks of RAM if you have lots of words in strings in your sketch. The #include at the top is required for the code needed to access program memory:
#include // for progmem

Program memory string declarations begin with const prog_uchar followed by the name of the string variable and then the string characters: const prog_uchar myText[] = "arduino duemilanove "; //a string of 20 characters in progmem

You can use the following expression to create a preprocessor macro that makes your string declarations easier to write. Add the following line to the top of the sketch:
#define P(name)

const prog_uchar name[] PROGMEM // declare a PROGMEM string

Wherever you use P(name), the expression will be replaced with the full expansion. So, the following code would declare the same string as in the earlier sketch:
P(myTextP) = "arduino duemilanove "; //a string of 20 characters in progmem

(This uses a preprocessing macro, a subject not covered in this book, but you can find links to more information on the preprocessor in this chapter’s introduction section.)

17.4 Storing and Retrieving Strings in Program Memory | 541

If you change the sketch to use a conventional RAM string, you will see that the free
RAM increases by at least 20 bytes: char myText[] = "arduino duemilanove "; //a string of 20 characters void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print(memoryFree());
Serial.print(' ');

}

Serial.print(myText); delay(1000); // print the free memory
// print a space
// print the string

17.5 Using #define and const Instead of Integers
Problem
You want to minimize RAM usage by telling the compiler that the value is constant and can be optimized.

Solution
Use const to declare values that are constant throughout the sketch.
For example, instead of: int ledPin=13;

use: const int ledPin=13;

Discussion
We often want to use a constant value in different areas of code. Just writing the number is a really bad idea. If you later want to change the value used, it’s difficult to work out which numbers scattered throughout the code also need to be changed. It is best to use named references.
Here are three different ways to define a value that is a constant: int ledPin = 13; const int ledPin =
#define ledPin 13

13;

//
//
//
//

a variable, but this wastes RAM a const does not use RAM using a #define the preprocessor replaces ledPin with 13

pinMode(ledPin, OUTPUT);

542 | Chapter 17: Advanced Coding and Memory Handling

Although the first two expressions look similar, the term const tells the compiler not to treat ledPin as an ordinary variable. Unlike the ordinary int, no RAM is reserved to hold the value for the const, as it is guaranteed not to change. The compiler will produce exactly the same code as if you had written: pinMode(13, OUTPUT);

You will sometimes see #define used to define constants in older Arduino code, but const is a better choice than #define. This is because a const variable has a type, which enables the compiler to verify and report if the variable is being used in ways not appropriate for that type. The compiler will also respect C rules for the scope of a const variable. A #define value will affect all the code in the sketch, which may be more than you intended. Another benefit of const is that it uses familiar syntax—#define does not use the equals sign, and no semicolon is used at the end.

See Also
See this chapter’s introduction section for more on the preprocessor.

17.6 Using Conditional Compilations
Problem
You want to have different versions of your code that can be selectively compiled. For example, you may need code to work differently when debugging or when running with different boards.

Solution
You can use the conditional statements aimed at the preprocessor to control how your sketch is built.
This example from sketches in Chapter 15 includes the SPI.h library file that is only available for and needed with Arduino versions released after 0018:
#if ARDUINO > 18
#include
#endif

// needed for Arduino versions later than 0018

This example, using the sketch from Recipe 5.6, displays some debug statements only if DEBUG is defined:
/*
Pot_Debug sketch blink an LED at a rate set by the position of a potentiometer
Uses Serial port for debug if DEBUG is defined
*/
const int potPin = 0; const int ledPin = 13;

// select the input pin for the potentiometer
// select the pin for the LED

17.6 Using Conditional Compilations | 543

int val = 0;

// variable to store the value coming from the sensor

#define DEBUG void setup()
{
Serial.begin(9600); pinMode(ledPin, OUTPUT);
}

// declare the ledPin as an OUTPUT

void loop() { val = analogRead(potPin); digitalWrite(ledPin, HIGH); delay(val); digitalWrite(ledPin, LOW); delay(val); #if defined DEBUG
Serial.println(val);
#endif
}

//
//
//
//
//

read the voltage on the pot turn the ledPin on blink rate set by pot value turn the ledPin off turn LED off for same period as it was turned on

Discussion
This recipe uses the preprocessor used at the beginning of the compile process to change what code is compiled. The first example tests if the value of the constant ARDUINO is greater than 18, and if so, the file SPI.h is included. The value of the ARDUINO constant is defined in the build process and corresponds to the Arduino release version. The syntax for this expression is not the same as that used for writing a sketch. Expressions that begin with the # symbol are processed before the code is compiled—see this chapter’s introduction section for more on the preprocessor.
You have already come across #include:
#include

The < > brackets tell the compiler to look for the file in the location for standard libraries: #include "header.h"

The compiler will also look in the sketch folder.
You can have a conditional compile based on the controller chip selected in the IDE.
For example, the following code will produce different code when compiled for a Mega board that reads the additional analog pins that it has:
/*
* ConditionalCompile sketch
* This sketch recognizes the controller chip using conditional defines
*/
int numberOfSensors; int val = 0;

// variable to store the value coming from the sensor

544 | Chapter 17: Advanced Coding and Memory Handling

Download from Wow! eBook

void setup()
{
Serial.begin(9600);
#if defined(__AVR_ATmega1280__) numberOfSensors = 16;
#else
numberOfSensors = 6;
#endif

//
//
//
//

defined when selecting Mega in the IDE the number of analog inputs on the Mega if not Mega then assume a standard board analog inputs on a standard Arduino board

Serial.print("The number of sensors is ");
Serial.println(numberOfSensors);

}

void loop() { for(int sensor = 0; sensor < numberOfSensors; sensor++)
{
val = analogRead(sensor);
// read the sensor value
Serial.println(val);
// display the value
}
Serial.println(); delay(1000); // delay a second between readings
}

See Also
Technical details on the C preprocessor are available at http://gcc.gnu.org/onlinedocs/ gcc-2.95.3/cpp_1.html. 17.6 Using Conditional Compilations | 545

CHAPTER 18

Using the Controller Chip Hardware

18.0 Introduction
The Arduino platform simplifies programming by providing easy-to-use function calls to hide complex, low-level hardware functions. But some applications need to bypass the friendly access functions to get directly at hardware, either because that’s the only way to get the needed functionality or because higher performance is required. This chapter shows how to access and use hardware functions that are not fully exposed through the documented Arduino language.
Changing register values can change the behavior of some Arduino functions (e.g., millis). The low-level capabilities described in this chapter require care, attention, and testing if you want your code to function correctly.

Registers
Registers are variables that refer to hardware memory locations. They are used by the chip to configure hardware functions or for storing the results of hardware operations.
The contents of registers can be read and written by your sketch. Changing register values will change the way the hardware operates, or the state of something (such as the output of a pin). Some registers represent a numerical value (the number a timer will count to). Registers can control or report on hardware status; for example, the state of a pin or if an interrupt has occurred. Registers are referenced in code using their names—these are documented in the data sheet for the microcontrollers. Setting a register to a wrong value usually results in a sketch functioning incorrectly, so carefully check the documentation to ensure that you are using registers correctly.

547

Interrupts
Interrupts are signals that enable the controller chip to stop the normal flow of a sketch and handle a task that requires immediate attention before continuing with what it was doing. Arduino core software uses interrupts to handle incoming data from the serial port, to maintain the time for the delay and millis functions, and to trigger the attachInterrupt function. Libraries, such as Wire and Servo, use interrupts when an event occurs, so the code doesn’t have to constantly check to see if the event has happened. This constant checking, called polling, can complicate the logic of your sketch.
Interrupts can be a reliable way to detect signals of very short duration. Recipe 18.2 explains how to use interrupts to determine if a digital pin has changed state.
Two or more interrupts may occur before the handling of the first interrupt is completed; for example, if two switches are pressed at the same time and each generates a different interrupt. The interrupt handler for the first switch must be completed before the second interrupt can get started. Interrupts should be brief, because an interrupt routine that takes too much time can cause other interrupt handlers to be delayed or to miss events.
Arduino services one interrupt at a time. It suspends pending interrupts while it deals with an interrupt that has happened. Code to handle interrupts (called the interrupt handler, or interrupt service routine) should be brief to prevent undue delays to pending interrupts. An interrupt routine that takes too much time can cause other interrupt handlers to miss events. Activities that take a relatively long time, such as blinking an LED or even serial printing, should be avoided in an interrupt handler. Timers
A standard Arduino board has three hardware timers for managing time-based tasks
(the Mega has six). The timers are used in a number of Arduino functions:
Timer0
Used for millis and delay; also analogWrite on pins 5 and 6
Timer1
analogWrite functions on pins 9 and 10; also driving servos using the Servo library
Timer2
analogWrite functions on pins 3 and 11
The Servo library uses the same timer as analogWrite on pins 9 and 10, so you can’t use analogWrite with these pins when using the Servo library. 548 | Chapter 18: Using the Controller Chip Hardware

The Mega has three additional 16-bit timers and uses different pin numbers with analogWrite: Timer0 analogWrite functions on pins 4 and 13

Timer1 analogWrite functions on pins 11 and 12

Timer2 analogWrite functions on pins 9 and 10

Timer3 analogWrite functions on pins 2, 3, and 5

Timer4 analogWrite functions on pins 6, 7, and 8

Timer5 analogWrite functions on pins 45 and 46

Timers are counters that count pulses from a time source, called a timebase. The timer hardware consists of 8-bit or 16-bit digital counters that can be programmed to determine the mode the timer uses to count. The most common mode is to count pulses from the timebase on the Arduino board, usually 16 MHz derived from a crystal; 16
MHz pulses repeat every 62.5 nanoseconds, and this is too fast for many timing applications, so the timebase rate is reduced by a divider called a prescaler. Dividing the timebase by 8, for example, increases the duration of each count to half a microsecond.
For applications in which this is still too fast, other prescale values can be used (see
Table 18-1).
Timer operation is controlled by values held in registers that can be read and written by Arduino code. The values in these registers set the timer frequency (the number of system timebase pulses between each count) and the method of counting (up, down, up and down, or using an external signal).
Here is an overview of the timer registers (n is the timer number):
Timer Counter Control Register A (TCCRnA)
Determines the operating mode
Timer Counter Control Register B (TCCRnB)
Determines the prescale value
Timer Counter Register (TCNTn)
Contains the timer count
Output Compare Register A (OCRnA)
Interrupt can be triggered on this count
Output Compare Register B (OCRnB)
Interrupt can be triggered on this count

18.0 Introduction | 549

Timer/Counter Interrupt Mask Register (TIMSKn)
Sets the conditions for triggering an interrupt
Timer/Counter 0 Interrupt Flag Register (TIFRn)
Indicates if the trigger condition has occurred
Table 18-1 is an overview of the bit values used to set the timer precision. Details of the functions of the registers are explained in the recipes where they are used.
Table 18-1. Timer prescale values (16 MHz clock)
Prescale factor

CSx2, CSx1, CSx0

Precision

Time to overflow
8-bit timer

16-bit timer

1

B001

62.5 ns

16 µs

4.096 ms

8

B010

500 ns

128 µs

32.768 ms

64

B011

4 µs

1,024 µs

262.144 ms

256

B100

16 µs

4,096 µs

1048.576 ms

1,024

B101

64 µs

16,384 µs

4194.304 ms

B110

External clock, falling edge

B111

External clock, rising edge

All timers are initialized for a prescale of 64.
Precision in nanoseconds is equal to the CPU period (time for one CPU cycle) multiplied by the prescale.

Analog and Digital Pins
Chapter 5 described the standard Arduino functions to read and write (to/from) digital and analog pins. This chapter explains how you can control pins faster than using the
Arduino read and write functions and make changes to analog methods to improve performance. Some of the code in this chapter is more difficult to understand than the other recipes in this book, as it is moving beyond Arduino syntax and closer to the underlying hardware. These recipes work directly with the tersely named registers in the chip and use bit shifting and masking to manipulate bits in them. The benefit from this complexity is enhanced performance and functionality.

See Also
Overview of hardware resources: http://code.google.com/p/arduino/wiki/HardwareRe sourceMap Timer1 (and Timer3) library: http://www.arduino.cc/playground/Code/Timer1
Tutorial on timers and PWM: http://arduino.cc/en/Tutorial/SecretsOfArduinoPWM

550 | Chapter 18: Using the Controller Chip Hardware

The Atmel ATmega 168/328 data sheets: http://www.atmel.com/dyn/resources/prod
_documents/doc8271.pdf
Atmel application note on how to set up and use timers: http://www.atmel.com/dyn/ resources/prod_documents/DOC2505.PDF A thorough summary of information covering 8-bit timers: http://www.cs.mun.ca/~rod/
Winter2007/4723/notes/timer0/timer0.html
Diagrams showing register settings for timer modes: http://web.alfredstate.edu/wei mandn/miscellaneous/atmega168_subsystem/atmega168_subsystem_index.html Wikipedia article on interrupts: http://en.wikipedia.org/wiki/Interrupts

18.1 Storing Data in Permanent EEPROM Memory
Problem
You want to store values that will be retained even when power is switched off.

Solution
Use the EEPROM library to read and write values in EEPROM memory. This sketch blinks an LED using values read from EEPROM and allows the values to be changed using the Serial Monitor:
/*
based on Blink without Delay uses EEPROM to store blink values
*/
#include
// these values are saved in EEPROM const byte EEPROM_ID = 0x99; // used to identify if valid data in EEPROM byte ledPin = 13;
// the number of the LED pin int interval = 1000;
// interval at which to blink (milliseconds)
// variables that do not need to be saved int ledState = LOW;
// ledState used to set the LED long previousMillis = 0;
// will store last time LED was updated
//constants used to identify const int ID_ADDR = 0; const int PIN_ADDR = 1; const int INTERVAL_ADDR = 2;

EEPROM
// the
// the
// the

addresses
EEPROM address used to store the ID
EEPROM address used to store the pin
EEPROM address used to store the interval

void setup()
{
Serial.begin(9600); byte id = EEPROM.read(ID_ADDR); // read the first byte from the EEPROM if( id == EEPROM_ID)

18.1 Storing Data in Permanent EEPROM Memory | 551

{
// here if the id value read matches the value saved when writing eeprom
Serial.println("Using data from EEPROM"); ledPin = EEPROM.read(PIN_ADDR); byte hiByte = EEPROM.read(INTERVAL_ADDR); byte lowByte = EEPROM.read(INTERVAL_ADDR+1); interval = word(hiByte, lowByte); // see word function in Recipe 3.15
}
else
{
// here if the ID is not found, so write the default data
Serial.println("Writing default data to EEPROM");
EEPROM.write(ID_ADDR,EEPROM_ID); // write the ID to indicate valid data
EEPROM.write(PIN_ADDR, ledPin); // save the pin in eeprom byte hiByte = highByte(interval); byte loByte = lowByte(interval);
EEPROM.write(INTERVAL_ADDR, hiByte);
EEPROM.write(INTERVAL_ADDR+1, loByte);
}
Serial.print("Setting pin to ");
Serial.println(ledPin,DEC);
Serial.print("Setting interval to ");
Serial.println(interval);
}

pinMode(ledPin, OUTPUT); void loop()
{
// this is the same code as the BlinkWithoutDelay example sketch if (millis() - previousMillis > interval)
{
previousMillis = millis();
// save the last time you blinked the LED
// if the LED is off turn it on and vice versa: if (ledState == LOW) ledState = HIGH; else ledState = LOW; digitalWrite(ledPin, ledState);
// set LED using value of ledState
}
processSerial();
}
// function to get duration or pin values from Serial Monitor
// value followed by i is interval, p is pin number int value = 0; void processSerial()
{
if( Serial.available())
{
char ch = Serial.read(); if(ch >= '0' && ch = numberOfEntries)
{
Serial.println("Durations in Microseconds are:") ; for( byte i=0; i < numberOfEntries; i++)
{
Serial.println(results[i]);
}
while(1)
;
} delay(1000); } void analyze()
{
if(index < numberOfEntries )
{
if(index > 0)
{
results[index] = micros() - microseconds;
}
index = index + 1;
}
microseconds = micros();
}

18.2 Using Hardware Interrupts | 555

If you have an infrared receiver module, you can use the wiring in Recipe 10.1 to measure the pulse width from an infrared remote control. You could also use the wiring in
Recipe 6.12 to measure pulses from a rotary encoder or connect a switch to pin 2 (see
Recipe 5.1) to test with a pushbutton.

Discussion
In setup the attachInterrupt(0, analyze, CHANGE); call enables the sketch to handle interrupts. The first number in the call specifies which interrupt to initialize. On a standard Arduino board, two interrupts are available: number 0, which uses pin 2, and number 1 on pin 3. The Mega has four more: number 2, which uses pin 21, number 3 on pin 20, number 4 on pin 19, and number 5 on pin 18.
The next parameter specifies what function to call (sometimes called an interrupt handler) when the interrupt event happens; analyze in this sketch.
The final parameter specifies what should trigger the interrupt. CHANGE means whenever the pin level changes (goes from low to high, or high to low). The other options are:
LOW: when the pin is low
RISING: when the pin goes from low to high
FALLING: when the pin goes from high to low

When reading code that uses interrupts, bear in mind that it may not be obvious when values in the sketch change, because the sketch does not directly call the interrupt handler; it’s called when the interrupt conditions occur.
In this sketch, the main loop checks the index variable to see if all the entries have been set by the interrupt handler. Nothing in loop changes the value of index. index is changed inside the analyze function when the interrupt condition occurs (pin 2 changing state). The index value is used to store the time since the last state change into the next slot in the results array. The time is calculated by subtracting the last time the state changed from the current time in microseconds. The current time is then saved as the last time a change happened. (Chapter 12 describes this method for obtaining elapsed time using the millis function; here micros is used to get elapsed microseconds instead of milliseconds.)
The variables that are changed in an interrupt function are declared as volatile; this lets the compiler know that the values could change at any time (by an interrupt handler). Without using the volatile keyword, the compiler would think these variables are not being changed by any code getting called and would replace these variables with constant values.
Each time an interrupt is triggered, index is incremented and the current time is saved.
The time difference is calculated and saved in the array (except for the first time the interrupt is triggered, when index is 0). When the maximum number of entries has occurred, the inner block in loop runs, and it prints out all the values to the serial port.

556 | Chapter 18: Using the Controller Chip Hardware

The code stays in the while loop at the end of the inner block, so you need to reset the board when you want to do another run.

See Also
Recipe 6.12 has an example of external interrupts used to detect movement in a rotary encoder. 18.3 Setting Timer Duration
Problem
You want to do something at periodic intervals, and you don’t want to have your code constantly checking if the interval has elapsed. You would like to have a simple interface for setting the period.

Solution
The easiest way to use a timer is through a library. The following sketch uses the
MsTimer2 library (http://www.arduino.cc/playground/Main/MsTimer2) to generate a pulse with a period that can be set using the Serial Monitor. This sketch flashes pin 13 at a rate that can be set using the Serial Monitor:
/*
pulseTimer2 pulse a pin at a rate set from serial input
*/
#include const int pulsePin = 13; int period = 100; // 10 milliseconds boolean output = HIGH; // the state of the pulse pin void setup()
{
pinMode(pulsePin, OUTPUT);
Serial.begin(9600);
MsTimer2::set(period/2, flash);
MsTimer2::start();
}

period= 0; // reset to zero ready for serial input void loop()
{
if( Serial.available())
{
char ch = Serial.read();

18.3 Setting Timer Duration | 557

if(ch >= '0' && ch 0 && duty < RESOLUTION)
{
Timer1.pwm(outPin, duty); ret = true;
}
} return ret;

Discussion
You set the pulse period to a value from 1 to 1 million microseconds by setting the value of the period at the top of the sketch. You can set the pulse width to any value in microseconds that is less than the period by setting the value of pulseWidth.
The sketch uses the Timer1 library from http://www.arduino.cc/playground/Code/Tim er1. Timer1 is a 16-bit timer (it counts from zero to 65,535). It’s the same timer used by analogWrite to control pins 9 and 10 (so you can’t use this library and analogWrite on those pins at the same time). The sketch generates a pulse on pin 9 with a period and

560 | Chapter 18: Using the Controller Chip Hardware

pulse width given by the values of the variables named period and pulseWidth. If you want to use pin 10 instead of pin 9, you can make the following change:
#define pwmRegister OCR1B const int outPin = 10;

// the logical pin
// the physical pin - OCRIB is pin 10

OCR1A and OCR1B are constants that are defined in the code included by the Arduino core

software (OCR stands for Output Compare Register). Many different hardware registers in the Arduino hardware are not usually needed by a sketch (the friendly Arduino commands hide the actual register names). But when you need to access the hardware directly to get at functionality not provided by Arduino commands, these registers need to be accessed. Full details on the registers are in the Atmel data sheet for the chip.
The sketch in this recipe’s Solution uses the following registers:
ICR1 (Input Compare Register for Timer1) determines the period of the pulse. This

register contains a 16-bit value which is used as the maximum count for the timer.
When the timer count reaches this value it will be reset and start counting again from zero. In the sketch in this recipe’s Solution, if each count takes one microsecond and the ICR1 value is set to 1000, the duration of each count cycle is 1,000 microseconds.
OCR1A (or OCR1B depending on which pin you want to use) is the Output Compare

Register for Timer1. When the timer count reaches this value (and the timer is in PWM mode as it is here), the output pin will be set low—this determines the pulse width.
For example, if each count takes one microsecond and the ICR1 value is set to 1000 and
OCR1A is set to 100, the output pin will be HIGH for 100 microseconds and LOW for 900 microseconds (the total period is 1,000 microseconds).
The duration of each count is determined by the Arduino controller timebase frequency
(typically 16 MHz) and the prescale value. The prescale is the value that the timebase is divided by. For example, with a prescale of 64, the timebase will be four microseconds.
The Timer1 library has many useful capabilities—see the Playground article for details
—but it does not provide for the setting of a specific pulse width. This functionality is added by the function named setPulseWidth.
This function uses a value of ICR1 to determine the period: int prescaleValue = prescale[Timer1.clockSelectBits];

The prescale value is set by a variable in the library named clockSelectBits. This variable contains a value between 1 and 7—this is used as an index into the prescale array to get the current prescale factor.
The duration for each count (precision) is calculated by multiplying the prescale value by the duration of a timebase cycle: long precision = (F_CPU / 128000) counter tick in ns

* prescaleValue

;

// time per

18.4 Setting Timer Pulse Width and Duration | 561

The period is the precision times the value of the ICR1 register; it’s divided by 1,000 to give the duration in microseconds: period = precision * ICR1 / 1000; // period in microseconds

The Timer1 library has a function named pwm that expects the duty cycle to be entered as a ratio expressed by a value from 1 to 1,023 (where 1 is the shortest pulse and 1,023 is the longest). This value is calculated using the Arduino map function to scale the microseconds given for the period into a proportional value of the period that ranges from 1 to 1,023: int duty = map(microseconds, 0,period, 1,1023);

18.5 Creating a Pulse Generator
Problem
You want to generate pulses from Arduino and control the characteristics from the
Serial Monitor.

Solution
This is an enhanced version of Recipe 18.4 that enables the frequency, period, pulse width, and duty cycle to be set from the serial port:
#include
const const const const char char char char SET_PERIOD_HEADER
SET_FREQUENCY_HEADER
SET_PULSE_WIDTH_HEADER
SET_DUTY_CYCLE_HEADER

#define pwmRegister OCR1A const int outPin = 9; long period = 1000; int duty = 512;

=
=
=
=

'p';
'f';
'w';
'c';

// the logical pin, can be set to OCR1B
// the physical pin

// the period in microseconds
// duty as a range from 0 to 1024, 512 is 50% duty cycle

int prescale[] = {0,1,8,64,256,1024}; // the range of prescale values void setup()
{
Serial.begin(9600); pinMode(outPin, OUTPUT);
Timer1.initialize(period);
Timer1.pwm(9, duty);
}

// initialize timer1, 1000 microseconds
// setup pwm on pin 9, 50% duty cycle

void loop()
{

562 | Chapter 18: Using the Controller Chip Hardware

}

processSerial(); void processSerial()
{
static long val = 0; if ( Serial.available())
{
char ch = Serial.read(); if(ch >= '0' && ch 0 && val < 100)
{
Serial.print("Setting Duty Cycle to ");
Serial.println(val);

18.5 Creating a Pulse Generator | 563

duty = map(val,1,99, 1, ICR1); pwmRegister = duty; show(); } val = 0;
}

}

} bool setPulseWidth(long microseconds)
{
bool ret = false;

}

int prescaleValue = prescale[Timer1.clockSelectBits];
// calculate time per tick in ns long precision = (F_CPU / 128000) * prescaleValue ; period = precision * ICR1 / 1000; // period in microseconds if( microseconds < period)
{
duty = map(microseconds, 0,period, 0,1024); if( duty < 1) duty = 1; if(microseconds > 0 && duty < RESOLUTION)
{
Timer1.pwm(outPin, duty); ret = true;
}
} return ret;

void show()
{
Serial.print("The period is ");
Serial.println(period);
Serial.print("Duty cycle is ");
// pwmRegister is ICR1A or ICR1B
Serial.print( map( pwmRegister, 0,ICR1, 1,99));
Serial.println("%");
Serial.println();
}

Discussion
This sketch is based on Recipe 18.4, with the addition of serial code to interpret commands to receive and set the frequency, period, pulse width, and duty cycle percent.
Chapter 4 explains the technique used to accumulate the variable val that is then used for the desired parameter, based on the command letter.
You can add this function if you want to print instructions to the serial port: void instructions()
{

564 | Chapter 18: Using the Controller Chip Hardware

}

Serial.println("Send values followed by one of the following tags:");
Serial.println(" p - sets period in microseconds");
Serial.println(" f - sets frequency in Hz");
Serial.println(" w - sets pulse width in microseconds");
Serial.println(" c - sets duty cycle in %");
Serial.println("\n(duty cycle can have one decimal place)\n");

See Also
Recipe 18.4

18.6 Changing a Timer’s PWM Frequency
Problem
You need to increase or decrease the Pulse Width Modulation (PWM) frequency used with analogWrite (see Chapter 7). For example, you are using analogWrite to control a motor speed and there is an audible hum because the PWM frequency is too high, or you are multiplexing LEDs and the light is uneven because PWM frequency is too low.

Solution
You can adjust the PWM frequency by changing a register value. The register values and associated frequencies are shown in Table 18-2.
Table 18-2. Adjustment values for PWM
Timer0 (pins 5 and 6)
TCCR0B value

Prescale factor
(divisor)

Frequency

32 (1)

1

62500

33 (2)

8

7812.5

34

64

976.5625

35

256

244.140625

36

1,024

61.03515625

TCCR1B prescale

value

Prescale factor
(divisor)

Frequency

1

1

312500

2

8

3906.25

3

64

488.28125

4

256

122.0703125

5

1,024

30.517578125

Timer1 (pins 9 and 10)

18.6 Changing a Timer’s PWM Frequency | 565

Timer2 (pins 11 and 3)
TCCR2B value

Prescale factor
(divisor)

Frequency

1

1

312500

2

8

3906.25

3

64

488.28125

4

256

122.0703125

5

1,024

30.517578125

All frequencies are in hertz and assume a 16 MHz system timebase. The default prescale factor of 64 is shown in bold.
This sketch enables you to select a timer frequency from the Serial Monitor. Enter a digit from 1 to 7 using the value in the lefthand column of Table 18-2 and follow this with character a for Timer0, b for Timer1, and c for Timer2: const byte mask = B11111000; // mask bits that are not prescale values int prescale = 0; void setup()
{
Serial.begin(9600); analogWrite(3,128); analogWrite(5,128); analogWrite(6,128); analogWrite(9,128); analogWrite(10,128); analogWrite(11,128);
}
void loop()
{
if ( Serial.available())
{
char ch = Serial.read(); if(ch >= '0' && ch = numberOfEntries)
{
Serial.println("Durations in Microseconds are:") ; for( byte i=0; i < numberOfEntries; i++)
{
long duration; duration = results[i] * precision; // pulse duration in nanoseconds
Serial.println(duration / 1000);
// duration in microseconds
}
while(1)
// loop so the print statements are executed once only
;
}
}

Discussion
This sketch uses a timer facility called Input Capture to measure the duration of a pulse.
Only 16-bit timers support this capability and this only works with pin 8 on a standard
Arduino board.
Input Capture uses a pin that is internally wired within the hardware and cannot be changed. Use pin 8 on a standard Arduino board and pin
48 on a Mega (using Timer5).

Because Input Capture is implemented entirely in the controller chip hardware, no time is wasted in interrupt handling, so this technique is more accurate for very short pulses
(less than tens of microseconds).
If the count goes higher than the maximum value for the timer, you can monitor overflow to increment a variable to extend the counting range. The following code increments a variable named overflow each time the counter overflows: volatile int overflows = 0;
/* Overflow interrupt vector */
ISR(TIMER1_OVF_vect)
{ overflows++; }

// here if no input pulse detected
// increment overflow count

570 | Chapter 18: Using the Controller Chip Hardware

Download from Wow! eBook

Change the code in setup as follows:
TIMSK1 = _BV(ICIE1);
TIMSK1 |= _BV(TOIE1);

// enable input capture interrupt for timer 1
// Add this line to enable overflow interrupt

18.9 Measuring Analog Values Quickly
Problem
You want to read an analog value as quickly as possible without decreasing the accuracy. Solution
You can increase the analogRead sampling rate by changing register values that determine the sampling frequency: const int sensorPin = 0; const int numberOfEntries = 100;

//pin the receiver is connected to

unsigned long microseconds; unsigned long duration; int results[numberOfEntries]; void setup()
{
Serial.begin(9600);
// standard analogRead performance (prescale = 128) microseconds = micros(); for(int i = 0; i < numberOfEntries; i++)
{
results[i] = analogRead(sensorPin);
}
duration = micros() - microseconds;
Serial.print(numberOfEntries);
Serial.print(" readings took ");
Serial.println(duration);
// running with high speed clock (set prescale to 16) bitClear(ADCSRA,ADPS0) ; bitClear(ADCSRA,ADPS1) ; bitSet(ADCSRA,ADPS2) ; microseconds = micros(); for(int i = 0; i < numberOfEntries; i++)
{
results[i] = analogRead(sensorPin);
}
duration = micros() - microseconds;
Serial.print(numberOfEntries);
Serial.print(" readings took ");
Serial.println(duration);

18.9 Measuring Analog Values Quickly | 571

} void loop()
{
}

Running the sketch on a 16 MHz Arduino will produce output similar to the following:
100 readings took 11308
100 readings took 1704

Discussion analogRead takes around 110 microseconds to complete a reading. This may not be fast

enough for rapidly changing values, such as capturing the higher range of audio frequencies. The sketch measures the time in microseconds for the standard analogRead and then adjusts the timebase used by the analog-to-digital converter (ADC) to perform the conversion faster. With a 16 MHz board, the timebase rate is increased from
125 KHz to 1 MHz. The actual performance improvement is slightly less than eight times because there is some overhead in the Arduino analogRead function that is not improved by the timebase change. The reduction of time from 113 microseconds to 17 microseconds is a significant improvement.
The ADCSRA register is used to configure the ADC, and the bits set in the sketch
(ADPS0, ADPS1, and ADPS2) set the ADC clock divisor to 16.

See Also
Atmel has an application note that provides a detailed explanation of performance aspects of the ADC: http://www.atmel.com/dyn/resources/prod_documents/DOC2559
.PDF

18.10 Reducing Battery Drain
Problem
You want to reduce the power used by your application by shutting down Arduino until a period of time has elapsed or until an external event takes place.

Solution
This solution uses a library by Arduino guru Peter Knight. You can download the library from http://code.google.com/p/narcoleptic/:
#include
void setup() { pinMode(2,INPUT); digitalWrite(2,HIGH); pinMode(13,OUTPUT); 572 | Chapter 18: Using the Controller Chip Hardware

}

digitalWrite(13,LOW); void loop() { int a;
// Merlin the cat is snoozing... Connect digital pin 2 to ground to wake him up.
Narcoleptic.delay(500); // During this time power consumption is minimized while (digitalRead(2) == LOW) {
// Wake up CPU. Unfortunately, Merlin does not like waking up.
// Swipe claws left digitalWrite(13,HIGH); delay(50);

}
}

// Swipe claws right digitalWrite(13,LOW); delay(50);

// Merlin the cat goes to sleep...

Discussion
A standard Arduino board would run down a 9-volt alkaline battery in a few weeks
(the Duemilanove typically draws more than 25 milliamperes [mA], excluding any external devices that may be connected). You can reduce this consumption by half if you use a board that does not have a built-in USB interface chip, such as the Arduino Mini,
LilyPad, Fio, or one of the Modern Device Bare Bones Boards that require the use of an external USB interface for uploading sketches. Significantly greater power savings can be achieved if your application can suspend operation for a period of time—
Arduino hardware can be put to sleep for a preset period of time or until a pin changes state, and this reduces the power consumption of the chip to less than one onehundredth of 1 percent (from around 15 mA to around 0.001 mA) during sleep.
The library used in this recipe provides easy access to the hardware sleep function. The sleep time can range from 16 to 8,000 milliseconds (eight seconds). To sleep for longer periods you can repeat the delay intervals until you get the period you want: void longDelay(long milliseconds)
{
while(milliseconds > 0)
{
if(milliseconds > 8000)
{
milliseconds -= 8000;
Narcoleptic.delay(8000);
} else {
Narcoleptic.delay(milliseconds);

18.10 Reducing Battery Drain | 573

}
}

break;
}

Sleep mode can reduce the power consumption of the controller chip, but if you are looking to run for as long as possible on a battery, you should minimize current drain through external components such as inefficient voltage regulators, pull-up or pulldown resistors, LEDs, and other components that draw current when the chip is in sleep mode.

See Also
See the Arduino hardware page for links to information on the LilyPad and Fio boards: http://www.arduino.cc/en/Main/Hardware For an example of very low power operation, see http://interface.khm.de/index.php/lab/ experiments/sleep_watchdog_battery/. 18.11 Setting Digital Pins Quickly
Problem
You need to set or clear digital pins much faster than enabled by the Arduino digital
Write command.

Solution
Arduino digitalWrite provides a safe and easy-to-use method of setting and clearing pins, but it is more than 30 times slower than directly accessing the controller hardware.
You can set and clear pins by directly setting bits on the hardware registers that are controlling digital pins.
This sketch uses direct hardware I/O to send Morse code (the word arduino) to an AM radio tuned to approximately 1 MHz. The technique used here is 30 times faster than
Arduino digitalWrite:
/*
* Morse sketch
*
* Direct port I/O used to send AM radio carrier at 1MHz
*/
const int sendPin = 2; const byte WPM = 12;
// sending speed in words per minute const long repeatCount = 1200000 / WPM; // count used to determine the duration of dots and dashes const byte dot = 1;

574 | Chapter 18: Using the Controller Chip Hardware

const byte dash = 3; const byte gap = 3; const byte wordGap = 7; byte letter = 0; // the letter to send char *arduino = ".- .-. -.. ..- .. -. ---"; void setup()
{
pinMode(sendPin, OUTPUT);
Serial.begin(9600);
} void loop()
{
sendMorse(arduino); delay(2000); } void sendMorse(char * string)
{
letter = 0 ; while(string[letter]!= 0)
{
if(string[letter] == '.')
{
sendDot();
}
else if(string[letter] == '-')
{
sendDash();
}
else if(string[letter] == ' ')
{
sendGap();
}
else if(string[letter] == 0)
{
sendWordGap();
}
letter = letter+1;
}
} void sendDot()
{
transmitCarrier( dot * sendGap(); } void {

repeatCount);

sendDash()

18.11 Setting Digital Pins Quickly | 575

}

transmitCarrier( dash * sendGap(); repeatCount);

void sendGap()
{
transmitNoCarrier( gap * repeatCount);
}
void sendWordGap()
{
transmitNoCarrier( wordGap *
}

repeatCount);

void transmitCarrier(long count)
{
while(count--)
{
bitSet(PORTD, sendPin); bitSet(PORTD, sendPin); bitSet(PORTD, sendPin); bitSet(PORTD, sendPin); bitClear(PORTD, sendPin);
}
} void transmitNoCarrier(long count)
{
while(count--)
{
bitClear(PORTD, sendPin); bitClear(PORTD, sendPin); bitClear(PORTD, sendPin); bitClear(PORTD, sendPin); bitClear(PORTD, sendPin);
}
}

Connect one end of a piece of wire to pin 2 and place the other end near the antenna of a medium wave AM radio tuned to 1 MHz (1,000 KHz).

Discussion
The sketch generates a 1 MHz signal to produce dot and dash sounds that can be received by an AM radio tuned to this frequency. The frequency is determined by the duration of the bitSet and bitClear commands that set the pin HIGH and LOW to generate the radio signal. bitSet and bitClear are not functions, they are macros. Macros substitute an expression for executable code—in this case, code that changes a single bit in register PORTD given by the value of sendPin.
Digital pins 0 through 7 are controlled by the register named PORTD. Each bit in PORTD corresponds to a digital pin. Pins 8 through 13 are on register PORTB, and pins 14 through

576 | Chapter 18: Using the Controller Chip Hardware

19 are on PORTA. The sketch uses the bitSet and bitClear commands to set and clear bits on the port (see Recipe 3.12). Each register supports up to eight bits (although not all bits correspond to Arduino pins). If you want to use Arduino pin 13 instead of pin
2, you need to set and clear PORTB as follows: const int sendPin = 13; bitSet(PORTB, sendPin - 8); bitClear(PORTB, sendPin - 8);

You subtract 8 from the value of the pin because bit 0 of the PORTB register is pin 8, bit
1 is pin 9, and so on, to bit 5 controlling pin 13.
Setting and clearing bits using bitSet is done in a single instruction of the Arduino controller. On a 16 MHz Arduino, that is 62.5 nanoseconds. This is around 30 times faster than using digitalWrite.
The transmit functions in the sketch actually need more time updating and checking the count variable than it takes to set and clear the register bits, which is why the transmitCarrier function has four bitSet commands and only one bitClear command—the additional bitClear commands are not needed because of the time it takes to update and check the count variable.

18.11 Setting Digital Pins Quickly | 577

APPENDIX A

Electronic Components

If you are just starting out with electronic components, you may want to purchase a beginner’s starter kit that contains the basic components needed for many of the recipes in this book. These usually include the most common resistors, capacitors, transistors, diodes, LEDs, and switches.
Here are some popular choices:
Maker Shed Arduino starter kit http://www.makershed.com/ProductDetails.asp?ProductCode=MSGSA Starter Kit for Arduino-Flex (SKU: DEV-09952) http://www.sparkfun.com/commerce/product_info.php?products_id=9952 Adafruit Starter Pack for Arduino-1.0 (product ID #68) http://www.adafruit.com/index.php?main_page=product_info&products_id=68 Oomlout Starter Kit for Arduino (ARDX) http://oomlout.co.uk/arduino-experimentation-kit-ardx-p-183.html Seeeduino Catalyst Pack http://www.seeedstudio.com/depot/super-seeeduino-catalyst-pack-p-257.html You can also purchase the individual components for your project, as shown in Figure A-1. The following sections provide an overview of common electronic components—part numbers can be found on this book’s website.

Capacitor
Capacitors store an electrical charge for a short time and are used in digital circuits to filter (smooth out) dips and spikes in electrical signals. The most commonly used capacitor is the nonpolarized ceramic capacitor; for example, a 100nF disc capacitor used for decoupling (reducing noise spikes). Electrolytic capacitors can generally store more charge than ceramic caps and are used for higher current circuits, such as power supplies and motor circuits. Electrolytic capacitors are usually polarized, and the neg-

579

Figure A-1. Schematic representation of common components

ative leg (marked with a minus sign) must be connected to ground (or to a point with lower voltage than the positive leg). Chapter 8 contains examples showing how capacitors are used in motor circuits.

Diode
Diodes permit current to flow in one direction and block it in the other direction. Most diodes have a band (see Figure A-1) to indicate the cathode (negative) end.
Diodes such as the 1N4148 can be used for low-current applications such as the levels used on Arduino digital pins. The 1N4001 diode is a good choice for higher currents
(up to 1 amp).
580 | Appendix A: Electronic Components

Integrated Circuit
Integrated circuits contain electronic components packaged together in a convenient chip. These can be complex, like the Arduino controller chip that contains thousands of transistors, or as simple as the optical isolator component used in Chapter 10 that contains just two semiconductors. Some integrated circuits (such as the Arduino chip) are sensitive to static electricity and should be handled with care.

Keypad
A keypad is a matrix of switches used to provide input for numeric digits. See Chapter 5.

LED
An LED (light-emitting diode) is a diode that emits light when current flows through the device. As they are diodes, LEDs only conduct electricity in one direction. See
Chapter 7.

Motor (DC)
Motors convert electrical energy into physical movement. Most small direct current
(DC) motors have a speed proportional to the voltage, and you can reverse the direction they move by reversing the polarity of the voltage across the motor. Most motors need more current than the Arduino pins provide, and a component such as a transistor is required to drive the motor. See Chapter 8.

Optocoupler
Optocouplers (also called optoisolators) provide electrical separation between devices.
This isolation allows devices that operate with different voltage levels to work safely together. See Chapter 10.

Photocell (Photoresistor)
Photocells are variable resistors whose resistance changes with light. See Chapter 6.

Piezo
A small ceramic transducer that produces sound when pulsed, a Piezo is polarized and may have a red wire indicating the positive end and a black wire indicating the side to be connected to ground. See Chapter 9.

Piezo | 581

Pot (Potentiometer)
A potentiometer (pot for short) is a variable resistor. The two outside terminals act as a fixed resistor. A movable contact called a wiper (or slider) moves across the resistor, producing a variable resistance between the center terminal and the two sides. See
Chapter 5.

Relay
A relay is an electronic switch—circuits are opened or closed in response to a voltage on the relay coil, which is electrically isolated from the switch. Most relay coils require more current than Arduino pins provide, so they need a transistor to drive them. See
Chapter 8.

Resistor
Resistors resist the flow of electrical current. A voltage flowing through a resistor will limit the current proportional to the value of the resistor (see Ohm’s law). The bands on a resistor indicate the resistor’s value. Chapter 7 contains information on selecting a resistor for use with LEDs.

Solenoid
A solenoid produces linear movement when powered. Solenoids have a metallic core that is moved by a magnetic field created when passing current through a coil. See
Chapter 8.

Speaker
A speaker produces sound by moving a diaphragm (the speaker cone) to create sound waves. The diaphragm is driven by sending an audio frequency electrical signal to a coil of wire attached to the diaphragm. See Chapter 9.

Stepper Motor
A stepper motor rotates a specific number of degrees in response to control pulses. See
Chapter 8.

582 | Appendix A: Electronic Components

Download from Wow! eBook

Switch
A switch makes and breaks an electrical circuit. Many of the recipes in this book use a type of pushbutton switch known as a tactile switch. Tactile switches have two pairs of contacts that are connected together when the button is pushed. The pairs are wired together, so you can use either one of the pair. Switches that make contact when pressed are called Normally Open (NO) switches. See Chapter 5.

Transistor
Transistors are used to switch on high currents or high voltages in digital circuits. In analog circuits, transistors are used to amplify signals. A small current through the transistor base results in a larger current flowing through the collector and emitter.
For currents up to .5 amperes (500 mA) or so, the 2N2222 transistor is a widely available choice. For currents up to 5 amperes, you can use the TIP120 transistor.
See Chapters 7 and 8 for examples of transistors used with LEDs and motors.

See Also
For more comprehensive coverage of basic electronics, see the following:
•
•
•
•

Make: Electronics by Charles Platt (O’Reilly)
Getting Started in Electronics by Forrest Mims (Master Publishing)
Physical Computing by Tom Igoe (Cengage)
Practical Electronics for Inventors by Paul Scherz (McGraw-Hill)

See Also | 583

APPENDIX B

Using Schematic Diagrams and
Data Sheets

A schematic diagram, also called a circuit diagram, is the standard way of describing the components and connections in an electronic circuit. It uses iconic symbols to represent components, with lines representing the connections between the components. A circuit diagram represents the connections of a circuit, but it is not a drawing of the actual physical layout. Although you may initially find that drawings and photos of the physical wiring can be easier to understand than a schematic, in a complicated circuit it can be difficult to clearly see where each wire gets connected.
Circuit diagrams are like maps. They have conventions that help you to orient yourself once you become familiar with their style and symbols. For example, inputs are usually to the left, outputs to the right; 0V or ground connections are usually shown at the bottom of simple circuits, the power at the top.
Figure A-1 in Appendix A shows some of the most common components, and the symbols used for them in circuit diagrams. Figure B-1 is a schematic diagram from
Recipe 8.6 that illustrates the symbols used in a typical diagram.
Components such as the resistor and capacitor used here are not polarized—they can be connected either way around. Transistors, diodes, and integrated circuits are polarized, so it is important that you identify each lead and connect it according to the diagram. Figure B-2 shows how the wiring could look when connected using a breadboard. This drawing was produced using a tool called Fritzing that enables the drawing of electronic circuits. See http://fritzing.org/.

585

Figure B-1. Typical schematic diagram

Figure B-2. Physical layout of the circuit shown in Figure B-1

586 | Appendix B: Using Schematic Diagrams and Data Sheets

How to Read a Data Sheet
Data sheets are produced by the manufacturers of components to summarize the technical characteristics of a device. Data sheets contain definitive information about the performance and usage of the device; for example, the minimum voltage needed for the device to function and the maximum voltage that it can reliably tolerate. Data sheets contain information on the function of each pin and advice on how to use the device.
For more complicated devices, such as LCDs, the data sheet covers how to initialize and interact with the device. Very complex devices, such as the Arduino controller chip, require hundreds of pages to explain all the capabilities of the device.
Data sheets are written for design engineers, and they usually contain much more information than you need to get most devices working in an Arduino project. Don’t be intimidated by the volume of technical information; you will typically find the important information in the first couple of pages. There will usually be a circuit diagram symbol labeled to show how the connections on the device correspond to the symbols.
This page will typically have a general description of the device (or family of devices) and the kinds of uses they are suitable for.
After this, there is usually a table of the electrical characteristics of the device.
Look for information about the maximum voltage and the current the device is designed to handle to check that it is in the range you need. For components to connect directly to a standard Arduino board, devices need to operate at +5 volts. To be powered directly from the pin of the Arduino, they need to be able to operate with a current of 40 mA or less.
Some components are designed to operate on 3.3 volts and can be damaged if connected to a 5V Arduino board. Use these devices with a board designed to run from a 3.3V supply (e.g., the LilyPad, Fio, or 3.3V Mini
Pro), or use a logic level converter such as the SparkFun BOB-08745.
More information on logic level conversion is available at http://ics.nxp
.com/support/documents/interface/pdf/an97055.pdf.

Choosing and Using Transistors for Switching
The Arduino output pins are designed to handle currents up to 40 mA (milliamperes), which is only 1/25 of an amp. You can use a transistor to switch larger currents. This section provides guidance on transistor selection and use.
The most commonly used transistors with Arduino projects are bipolar transistors.
These can be of two types (named NPN and PNP) that determine the direction of current flow. NPN is more common for Arduino projects and is the type that is illustrated in the recipes in this book. For currents up to .5 amperes (500 mA) or so, the

Choosing and Using Transistors for Switching | 587

2N2222 transistor is a widely available choice; the TIP120 transistor is a popular choice for currents up to 5 amperes.
Figure B-1 shows an example of a transistor connected to an Arduino pin used to drive a motor.
Transistor data sheets are usually packed with information for the design engineer, and most of this is not relevant for choosing transistors for Arduino applications. Table B-1 shows the most important parameters you should look for (the values shown are for a typical general-purpose transistor). Manufacturing tolerances result in varying performance from different batches of the same part, so data sheets usually indicate the minimum, typical, and maximum values for parameters that can vary from part to part. Here’s what to look for:
Collector-emitter voltage
Make sure the transistor is rated to operate at a voltage higher than the voltage of the power supply for the circuit the transistor is controlling. There is no problem in choosing a transistor with a higher rating.
Collector current
This is the absolute maximum current the transistor is designed to handle. It is a good practice to choose a transistor that is rated at least 25 percent higher than what you need.
DC current gain
This determines the amount of current needed to flow through the base of the transistor to switch the output current. Dividing the output current (the maximum current that will flow through the load the transistor is switching) by the gain gives the amount of current that needs to flow through the base.
Collector-emitter saturation voltage
This is the voltage level on the collector when the transistor is fully conducting.
Although this is usually less than 1 volt, it can be significant when calculating a series resistor for LEDs or for driving high-current devices.

588 | Appendix B: Using Schematic Diagrams and Data Sheets

Table B-1. Example of key transistor data sheet specifications
Absolute maximum ratings
Parameter

Symbol

Rating

Units

Comment

Collector-emitter voltage

Vceo

40

Volts

The maximum voltage between the collector and emitter Collector current

Ic

600

mA or A

The maximum current that the transistor is designed to handle

Electrical characteristics
DC current gain

90 @ 10 mA

Gain with 10 mA current flowing

Ic
Collector-emitter
saturation voltage

Ic

50 @ 500 mA Gain with 500 mA current flowing

Vce

0.3 @ 100 mA (sat)

Volts
Volts

Voltage drop across collector and emitter at various currents 1.0 @ 500 mA Choosing and Using Transistors for Switching | 589

APPENDIX C

Building and Connecting the Circuit

Using a Breadboard
A breadboard enables you to prototype circuits quickly, without having to solder the connections. Figure C-1 shows an example of a breadboard.

Figure C-1. Breadboard for prototyping circuits

Breadboards come in various sizes and configurations. The simplest kind is just a grid of holes in a plastic block. Inside are strips of metal that provide electrical connection between holes in the shorter rows. Pushing the legs of two different components into the same row joins them together electrically. A deep channel running down the middle indicates that there is a break in connections there, meaning you can push a chip in with the legs at either side of the channel without connecting them together.
Some breadboards have two strips of holes running along the long edges of the board that are separated from the main grid. These have strips running down the length of the board inside, and provide a way to connect a common voltage. They are usually in pairs for +5 volts and ground. These strips are referred to as rails and they enable you to connect power to many components or points in the board.
591

Download from Wow! eBook

While breadboards are great for prototyping, they have some limitations. Because the connections are push-fit and temporary, they are not as reliable as soldered connections. If you are having intermittent problems with a circuit, it could be due to a poor connection on a breadboard.

Connecting and Using External Power Supplies and Batteries
The Arduino can be powered from an external power source rather than through the
USB lead. You may need more current than the USB connection can provide (the maximum USB current is 500 mA; some USB hubs only supply 100 mA), or you may want to run the board without connection to the computer after the sketch is uploaded.
The standard Arduino board has a socket for connecting external power. This can be an AC-powered power supply or a battery pack.
These details relate to the Uno, Duemilanove, and Mega boards. Other
Arduino and compatible boards may not protect the board from reverse connections, or they may automatically switch to use external power and may not accept higher voltages. If you are using a different board, check before you connect power or you may damage the board.

If you are using an AC power supply, you need one that produces a DC voltage between
7 and 12 volts. Choose a power supply that provides at least as much current as you need (there is no problem in using a power supply with a higher current than you need).
Wall wart–style power supplies come in two broad types: regulated and unregulated.
A regulated power supply has a circuit that maintains the specified voltage, and this is a good choice to use with Arduino. An unregulated power supply will produce a higher voltage when run at a lower current and can sometimes produce twice the rated voltage when driving low-current devices such as Arduino. Voltages higher than 12 volts can overheat the regulator on the Arduino, and this can cause intermittent operation or even damage the board.
Battery voltage should also be in the range of 7 to 12 volts. Battery current is rated in mAh (the amount of milliamperes the battery can supply in one hour). A battery with a rating of 500 mAh (a typical alkaline 9V battery) should last around 20 hours with an Arduino board drawing 25 mAh. If your project draws 50 mA, the battery life will be halved, to around 10 hours. How much current your board uses depends mostly on the devices (such as LEDs and other external components) that you use. Bear in mind that the Uno and Duemilanove boards are designed to be easy to use and robust, but they are not optimized for low power use with a battery. See Recipe 18.10 for advice on reducing battery drain.

592 | Appendix C: Building and Connecting the Circuit

The positive (+) connection from the power supply should be connected to the center pin of the Arduino power plug. If you connect it the wrong way around on an Uno,
Duemilanove, or Mega, the board will not break, but it will not work until the connection is reversed. These boards automatically detect that an external power supply is connected and use that to power the board. You can still have the USB lead plugged in, so serial communication and code uploading will still work.

Using Capacitors for Decoupling
Digital circuits switch signals on and off quickly, and this can cause fluctuations in the power supply voltage that can disrupt proper operation of the circuit. Properly designed digital circuits use decoupling capacitors to filter these fluctuations. Decoupling capacitors should be connected across the power pins of each IC in your circuit with the capacitor leads kept as short as possible. A ceramic capacitor of 0.1 uF is a good choice for decoupling—that value is not critical (20 percent tolerance is OK).

Using Snubber Diodes with Inductive Loads
Inductive loads are devices that have a coil of wire inside. This includes motors, solenoids, and relays. The interruption of current flow in a coil of wire generates a spike of electricity. This voltage can be higher than +5 volts and can damage sensitive electronic circuits such as Arduino pins. Snubber diodes are used to prevent that by conducting the voltage spikes to ground. Figure A-1 in Appendix A shows an example of a snubber diode used to suppress voltage spikes when driving a motor.

Working with AC Line Voltages
When working with an AC line voltage from a wall socket, the first thing you should consider is whether you can avoid working with it. Electricity at this voltage is dangerous enough to kill you, not just your circuit, if it is used incorrectly. It is also dangerous for people using whatever you have made if the AC line voltage is not isolated properly. Hacking controllers for devices that are manufactured to work with mains voltage, or using devices designed to be used with microcontrollers to control AC line voltages, is safer (and often easier) than working with mains voltage itself. See Chapter 10 for recipes on controlling external devices for examples of how to do this.

Working with AC Line Voltages | 593

APPENDIX D

Tips on Troubleshooting
Software Problems

As you write and modify code, you will get code that doesn’t work (usually referred to as a bug). There are two broad areas of software problems: code that won’t compile and code that compiles and uploads to the board but doesn’t behave as you want.

Code That Won’t Compile
Your code might fail to compile when you click on the “verify” triangle or the “upload” button (see Chapter 1). This is indicated by red error messages in the black console area at the bottom of the Arduino software window and a yellow highlight in the code if there is a specific point where the compilation failed. Often the problem in the code is in the line immediately before the highlighted line. The error messages in the console window are generated by the command-line programs used to compile and link the code (see Recipe 17.1 for details on the build process). This message may be difficult to understand when you first start.
One of the most common errors made by people new to Arduino programming is omission of the semicolon at the end of a line. This can produce various different error messages, depending on the next line. For example, this code fragment: void loop()
{
digitalWrite(ledPin, HIGH) delay(1000); }

//