Arduino in action - Jacek Janczyk

Discover the possibilities of the Arduino platform!

Arduino is an amazing platform that opened the world of electronics to everyone. Thanks to it, you can build an advanced electronic system without the need for time-consuming projects and tedious calculations. Arduino quickly gained enormous popularity, followed by numerous additional modules. They let you build any device - only your imagination limits you!

This unique book was entirely devoted to the Arduino platform. You will find a detailed discussion of the platform's possibilities, numerous examples and descriptions. During the reading you will learn how to prepare the work environment and start creating simple projects using digital input-output ports. In the following chapters you will learn more and more advanced Arduino capabilities. You will use DC motors and servos, apply ultrasonic sensors and display information on the LCD display. In addition, you'll find that you can integrate Arduino with iOS and other software. This book is an excellent reading for all electronics enthusiasts.

Thanks to this book:

• You will learn the secrets of the Arduino platform
• you will use sensors and motors
• you communicate with the system via the network
• you will discover for yourself the potential hidden in this platform!

Your pass to the world of electronics!

Table of Contents
Introduction (11) Acknowledgments (13) About the book (15) PART I. I START (19) Chapter 1. Welcome, Arduino (21)

• 1.1. Brief history of Arduino (22)
• 1.2. Arduino (23)
  • 1.2.1. Arduino Uno (23)
  • 1.2.2. Arduino Duemilanove (24)
  • 1.2.3. Arduino Ethernet (24)
  • 1.2.4. Arduino Mega (25)
  • 1.2.5. Other versions of Arduino (25)
  • 1.2.6. Clone attack (27)
  • 1.2.7. We start work with Arduino (28)
• 1.3. Preparing the work environment (28)
  • 1.3.1. Software for Arduino (28)
  • 1.3.2. Basic hardware configuration (29)
  • 1.3.3. Your Arduino Essentials (29)
• 1.4. Let something happen! (thirty)
  • 1.4.1. Your first blinking LED (30)
  • 1.4.2. Sketch flashing with a light-emitting diode (30)
  • 1.4.3. We combine everything together (31)
  • 1.4.4. Loading and testing the program (32)
• 1.5. We get to know the integrated development environment (33)
  • 1.5.1. Code editor (34)
  • 1.5.2. Serial port monitor (34)
  • 1.5.3. Fault finding (36)
  • 1.5.4. Code processing (36)
• 1.6. Sketch construction (37)
  • 1.6.1. The "setup" procedure (37)
  • 1.6.2. Infinite loop (37)
• 1.7. Commenting on the code (38)
• 1.8. Summary (39)

Chapter 2. Digital inputs and outputs (41)

• 2.1. We start (41)
  • 2.1.1. Using the contact plate (42)
  • 2.1.2. Circuit diagram (42)
  • 2.1.3. Light-emitting diodes (44)
  • 2.1.4. Connections (44)
  • 2.1.5. Sketch flashing with five LEDs (44)
  • 2.1.6. Download and test (47)
• 2.2. Taking control (47)
  • 2.2.1. Circuit diagram (47)
  • 2.2.2. Connections (47)
  • 2.2.3. Interrupting interruptions (49)
  • 2.2.4. Sketch allowing to control diodes by means of the button (49)
  • 2.2.5. Download and test (52)
  • 2.2.6. Time for a break (52)
  • 2.2.7. Upload and test (53)
• 2.3. Reflex meter (53)
  • 2.3.1. Circuit diagram (53)
  • 2.3.2. Connections (53)
  • 2.3.3. Sketch for measuring reflexes (53)
  • 2.3.4. Download and test (56)
• 2.4. Reflex meter - who really is the fastest? (56)
  • 2.4.1. Sketch for measuring reflexes (57)
  • 2.4.2. Upload and test (58)
• 2.5. Summary (58)

Chapter 3. Simple projects: input and output (61)

• 3.1. Time for the analog world (62)
  • 3.1.1. What is the difference between an analog and digital signal? (62)
  • 3.1.2. Reading the signal from the potentiometer (63)
  • 3.1.3. Connecting elements (64)
  • 3.1.4. Sketch for reading potentiometer settings (64)
  • 3.1.5. Load and test (66)
• 3.2. Piezoelectric transducer (67)
  • 3.2.1. Circuit diagram (68)
  • 3.2.2. Connections (69)
  • 3.2.3. Sketch to measure impulses from a piezoelectric transducer (70)
  • 3.2.4. Upload and test (72)
  • 3.2.5. Circuit with added speaker (72)
  • 3.2.6. Connections (72)
  • 3.2.7. Sound generating sketch (74)
  • 3.2.8. Upload and test (74)
• 3.3. Construction of the pentatonic music keyboard (75)
  • 3.3.1. Circuit diagram (75)
  • 3.3.2. Connections (75)
  • 3.3.3. Sketch supporting the pentatonic keyboard (77)
  • 3.3.4. Download and test (78)
• 3.4. Summary (79)

PART II. WE ABLE TO ARDUINO TO WORK (81) Chapter 4. Expanding Arduino (83)

• 4.1. Increasing Arduino's capabilities through additional programming libraries (84)
• 4.2. Basic library (84)
• 4.3. Standard libraries (85)
  • 4.3.1. Design controlled by tests using the ArduinoTestSuite library (85)
  • 4.3.2. Saving values in the EEPROM memory (86)
  • 4.3.3. Saving larger amounts of data on SD cards (87)
  • 4.3.4. Connecting to an Ethernet network (89)
  • 4.3.5. Serial communication using the Firmata protocol (90)
  • 4.3.6. Displaying information using the LiquidCrystal library (91)
  • 4.3.7. Servo control (92)
  • 4.3.8. Stepper motor control (92)
  • 4.3.9. Communication with devices on the SPI bus (93)
  • 4.3.10. Communication using a two-wire bus (95)
  • 4.3.11. Getting more serial ports using the SoftwareSerial library (95)
• 4.4. Libraries shared by users (98)
  • 4.4.1. Installing a new library (98)
• 4.5. Arduino expansion using overlays (99)
  • 4.5.1. Popular overlays (99)
  • 4.5.2. Trap: will it work with my Arduino? (102)
• 4.6. Summary (103)

Chapter 5. Arduino in motion (105)

• 5.1. Speed acquisition with DC motors (106)
  • 5.1.1. Starting and stopping the engine (107)
  • 5.1.2. Sketch of starting and stopping a small DC motor (108)
  • 5.1.3. Connecting components (108)
  • 5.1.4. Load and sketch test (110)
• 5.2. Speed control and rotation of the motor in the opposite direction (111)
  • 5.2.1. PWM modulation arrives to the rescue (112)
  • 5.2.2. Bridge H for motor control (112)
  • 5.2.3. The L293D system (114)
  • 5.2.4. Joining elements (115)
  • 5.2.5. L293D control sketch (116)
  • 5.2.6. Load and sketch test (117)
  • 5.2.7. Changing the engine speed (117)
  • 5.2.8. Load and sketch test (118)
• 5.3. Stepper motors: one step at a time (119)
  • 5.3.1. Bipolar and unipolar engines (119)
  • 5.3.2. Connecting components (122)
  • 5.3.3. Step motor library functions (123)
  • 5.3.4. Control sketch of the stepping motor (125)
  • 5.3.5. Load and sketch test (126)
• 5.4. Servomechanisms are not so scary (126)
  • 5.4.1. Servo control (126)
  • 5.4.2. Functions and methods controlling the servo (127)
  • 5.4.3. Servo control sketch (128)
  • 5.4.4. Connecting components (129)
  • 5.4.5. Download and test sketch (129)
• 5.5. The great power of a small brushless motor (130)
  • 5.5.1. Why without brushes (130)
  • 5.5.2. Control (131)
  • 5.5.3. Brushless motor control sketch (132)
  • 5.5.4. Connecting components (134)
  • 5.5.5. Download and test sketch (134)
  • 5.5.6. Revs in the opposite direction (135)
  • 5.5.7. Sketch changing the direction of rotation of the brushless motor (135)
  • 5.5.8. Connecting components (136)
  • 5.5.9. Load and sketch test (136)
• 5.6. Several-engine control pad (136)
• 5.7. Summary (137)

Chapter 6. Detecting items (139)

• 6.1. Ultrasonic detection of objects (139)
  • 6.1.1. Choosing an ultrasonic sensor (140)
  • 6.1.2. Three or four wires (141)
  • 6.1.3. Sketches for ultrasonic detection of objects (142)
  • 6.1.4. Joining elements (144)
  • 6.1.5. Load and sketch test (145)
• 6.2. Distance measurement by means of infrared (145)
  • 6.2.1. Connecting infrared and ultrasonic sensors (146)
  • 6.2.2. Sharp Sensor GP2D12 (146)
  • 6.2.3. Nonlinear distance calculation algorithm (146)
  • 6.2.4. Sketch for distance measurement (147)
  • 6.2.5. Joining elements (149)
  • 6.2.6. Load and sketch test (149)
• 6.3. Motion detection by passive infrared (149)
  • 6.3.1. Using the Parallax sensor (151)
  • 6.3.2. Sketch for detecting motion using infrared (151)
  • 6.3.3. Joining elements (152)
  • 6.3.4. Download and test sketch (153)
• 6.4. Summary (154)

Chapter 7. LCD displays (155)

• 7.1. Introduction to LCD displays (156)
  • 7.1.1. Strings: String and char variables (156)
• 7.2. Parallel character display Hitachi HD44780 (158)
  • 7.2.1. 4-bit or 8-bit display? (159)
  • 7.2.2. Library and functions (159)
  • 7.2.3. Circuit diagram (159)
  • 7.2.4. Connecting components in 4-bit mode (160)
  • 7.2.5. Sketch control diagram Hitachi HD44780 (162)
  • 7.2.6. Load and sketch test (163)
• 7.3. Meteorological station with serial LCD display (164)
  • 7.3.1. Serial and parallel displays (164)
  • 7.3.2. SerLCD library and its functions (165)
  • 7.3.3. Maxim DS18B20 temperature sensor (166)
  • 7.3.4. OneWire and DallasTemperature libraries (167)
  • 7.3.5. Circuit diagram (167)
  • 7.3.6. Connecting all components (167)
  • 7.3.7. Sketch for weather station with LCD display (169)
  • 7.3.8. Download and test sketch (170)
• 7.4. Samsung KS0108 graphic display (171)
  • 7.4.1. Library and functions (171)
  • 7.4.2. Connection diagram (171)
  • 7.4.3. Connecting all components (172)
  • 7.4.4. Sketch for drawing on the graphic display (173)
  • 7.4.5. Load and sketch test (175)
• 7.5. Summary (176)

Chapter 8. Communication (177)

• 8.1. Ethernet technology (178)
  • 8.1.1. Ethernet Library (179)
  • 8.1.2. Ethernet overlay with SD card (180)
• 8.2. Arduino web server (181)
  • 8.2.1. Server configuration (181)
  • 8.2.2. Sketch configuring the web server (182)
  • 8.2.3. Load and sketch test (184)
  • 8.2.4. Troubleshooting (184)
• 8.3. Gravel, gravel - communication with Twitter (184)
  • 8.3.1. Twitter and tokens (185)
  • 8.3.2. Libraries and functions (185)
  • 8.3.3. Diagram of the layout and connection of components (185)
  • 8.3.4. Sketch to send a tweet at the touch of a button (186)
  • 8.3.5. Load and sketch test (187)
• 8.4. Wi-Fi connectivity (188)
  • 8.4.1. Arduino WiFi overlay (189)
  • 8.4.2. WiFi library and its functions (190)
  • 8.4.3. Body movements and wireless accelerometers (192)
  • 8.4.4. Connecting components (192)
  • 8.4.5. Sketch for Bluetooth communication (193)
  • 8.4.6. Load and sketch test (196)
• 8.5. Wireless Bluetooth connectivity (196)
  • 8.5.1. ArduinoBT board (196)
  • 8.5.2. Adding a Bluetooth module (198)
  • 8.5.3. Establishing a Bluetooth connection (198)
  • 8.5.4. Sketch for Bluetooth communication (199)
• 8.6. SPI interface (200)
  • 8.6.1. SPI library (200)
  • 8.6.2. SPI devices and digital potentiometers (201)
  • 8.6.3. Diagram of layout and connection of elements (202)
  • 8.6.4. Sketch of the digital LED driver (203)
• 8.7. Recording of data (204)
  • 8.7.1. Types of memory (205)
  • 8.7.2. SD cards and SD library (205)
  • 8.7.3. A sketch that records the sensor data on the SD card (206)
• 8.8. Xively service (207)
  • 8.8.1. Creating an account and downloading the API key (208)
  • 8.8.2. Creating a new data channel (208)
  • 8.8.3. Sketch for registering sensor data on Xively (209)
  • 8.8.4. Load and sketch test (211)
• 8.9. Summary (212)

Chapter 9. Time for games (213)

• 9.1. Nintendo Wii greets you (213)
  • 9.1.1. Controller Wii Nunchuk (214)
  • 9.1.2. Connection with the Nunchuk controller (216)
  • 9.1.3. Wii starts talking (218)
  • 9.1.4. Wii tests (226)
• 9.2. Xbox console entry (227)
  • 9.2.1. Connection (228)
  • 9.2.2. USB host library (229)
  • 9.2.3. Acquiring information about an Xbox controller using a USB host overlay (229)
  • 9.2.4. Reporting obligation by the Xbox controller (231)
  • 9.2.5. Time to start (233)
  • 9.2.6. Connecting with code (233)
  • 9.2.7. Sketch of Xboxhid.ino (235)
  • 9.2.8. Combining and testing circuits (239)
• 9.3. Summary (239)

Chapter 10. Arduino integration with iOS devices (241)

• 10.1. Connecting an iOS device to Arduino (243)
  • 10.1.1. Redpark serial cable (243)
  • 10.1.2. Final connection (244)
• 10.2. The iOS code (245)
  • 10.2.1. Creating a one-page application in the Xcode environment (245)
  • 10.2.2. Creating a code (250)
• 10.3. We are engaged in Arduino (253)
  • 10.3.1. Sketch for controlling the LED from an iOS device (253)
  • 10.3.2. Sketch testing (254)
• 10.4. Let's do something more in Xcode (255)
  • 10.4.1. Adding a Slider control (255)
• 10.5. Support for the slider in Arduino (259)
  • 10.5.1. Arduino system for operating the slider (260)
  • 10.5.2. System testing (261)
• 10.6. Sending data to an iOS device (262)
  • 10.6.1. Encoding in the Xcode environment (262)
  • 10.6.2. Infrared distance sensor GP2D12 (265)
  • 10.6.3. Test (267)
• 10.7. Summary (267)

Chapter 11. Electronic gadgets (269)

• 11.1. Introduction to LilyPad (270)
  • 11.1.1. LilyPad accessories (271)
  • 11.1.2. Conductive threads and fabrics (272)
• 11.2. Jacket with switches (274)
• 11.3. Personal piano (276)
• 11.4. Arduino Pro Mini (279)
• 11.5. Smart headphones (280)
• 11.6. Jacket with a compass (282)
• 11.7. Summary (286)

Chapter 12. Using overlays (287)

• 12.1. Basic overlay information (287)
• 12.2. Adafruit engine cover (288)
  • 12.2.1. AFMotor Library (289)
  • 12.2.2. Application of the stepper pad (290)
  • 12.2.3. Application of an overlay with a DC motor (292)
  • 12.2.4. Purchase of a motor overlay (294)
• 12.3. How to build your own overlay (295)
  • 12.3.1. Memory (295)
  • 12.3.2. Level shifter (296)
  • 12.3.3. SD card holder (296)
  • 12.3.4. Connecting an SD card to an Arduino disc (297)
  • 12.3.5. Preparing a perforated plate (299)
  • 12.3.6. Overlay test (302)
• 12.4. Summary (303)

Chapter 13. Software integration (305)

• 13.1. Serial communication channel (306)
• 13.2. Face tracking servo (307)
  • 13.2.1. Mounting the face tracking mechanism (308)
  • 13.2.2. Face tracking code (309)
• 13.3. The use of firmata software for building equalizer (313)
  • 13.3.1. The use of Firmata in your application (314)
  • 13.3.2. Sound analysis in the Processing environment (315)
  • 13.3.3. Assembly of equalizer elements (315)
  • 13.3.4. Equalizer code (316)
• 13.4. Pure Data application for synthesizer construction (319)
  • 13.4.1. Installation of synthesizer components (320)
  • 13.4.2. Synth code (320)
• 13.5. Using Python to measure temperature (324)
  • 13.5.1. Serial library in Python (324)
  • 13.5.2. Installation of thermometer components (325)
  • 13.5.3. Temperature monitoring code (326)
• 13.6. Summary (328)

Appendix A. Installation of the Arduino IDE environment (329)

• A.1. Windows (329)
  • A.1.1. Installation of drivers for Arduino (329)
• A.2. Mac OS X (332)
• A.3. Linux (333)

Appendix B. The coding manual (337)

• B.1. History of Arduino (337)
• B.2. Variables (338)
  • B.2.1. Variable types (339)
  • B.2.2. Tables (340)
  • B.2.3. Strings (341)
  • B.2.4. Permanent (341)
  • B.2.5. Reach of variables (342)
• B.3. Taking control (343)
  • B.3.1. If, else, else if instructions (344)
  • B.3.2. Switch-case instructions (346)
  • B.3.3. Logical operators (347)
• B.4. Looping (348)
  • B.4.1. For loop (348)
  • B.4.2. While loop (349)
  • B.4.3. While loop (350)
• B.5. Features (350)
• B.6. Summary (351)

Appendix C. Libraries (353)

• C.1. Anatomy of the library (353)
  • C.1.1. .H file (header) (353)
  • C.1.2. The .cpp file (354)
• C.2. Using the library (355)
  • C.2.1. Applying the library in the sketch (355)
  • C.2.2. Distributing the library (356)

Appendix D. Component list (357) Appendix E. Useful references (361) Index (363)