(Ebook PDF) Arduino Home Automation Projects Automate your Home using the powerful Arduino Platform 1st edition by Marco Schwartz 1783986077 9781783986071 full chapters pdf download https://ebookball.com/product/ebook-pdf-arduino-home-automationprojects-automate-your-home-using-the-powerful-arduinoplatform-1st-edition-by-marcoschwartz-1783986077-9781783986071-full-chapters-25458/
Explore and download more ebooks or textbooks at ebookball.com
Get Your Digital Files Instantly: PDF, ePub, MOBI and More Quick Digital Downloads: PDF, ePub, MOBI and Other Formats
Arduino Home Automation 1st edition by Marco Schwartz 9781783986071 1783986077
https://ebookball.com/product/arduino-home-automation-1stedition-by-marco-schwartz-9781783986071-1783986077-18422/
DIY Solar Projects Updated Edition Small Projects to Whole Home Systems Tap Into the Sun 1st edition by Eric Smith, Philip Schmidt ISBN 1591866642 978-1591866640 https://ebookball.com/product/diy-solar-projects-updated-editionsmall-projects-to-whole-home-systems-tap-into-the-sun-1stedition-by-eric-smith-philip-schmidtisbn-1591866642-978-1591866640-17662/
Intel Galileo and Intel Galileo Gen 2 API Features and Arduino Projects for Linux Programmers 1st edition by Manoel Ramon ISBN 1430268395 978-1430268390 https://ebookball.com/product/intel-galileo-and-intel-galileogen-2-api-features-and-arduino-projects-for-linuxprogrammers-1st-edition-by-manoel-ramonisbn-1430268395-978-1430268390-20336/
Caring for the Older Person Practical Care in Hospital Care Home or at Home 1st Edition by Ann Bradshaw, Clair Merriman 0470025638 9780470025635 https://ebookball.com/product/caring-for-the-older-personpractical-care-in-hospital-care-home-or-at-home-1st-edition-byann-bradshaw-clair-merriman-0470025638-9780470025635-1386/
No Place Like Home A History of Nursing and Home Care in the United States 1st Edition by Karen Buhler Wilkerson 0801873185 978-0801873188
https://ebookball.com/product/no-place-like-home-a-history-ofnursing-and-home-care-in-the-united-states-1st-edition-by-karenbuhler-wilkerson-0801873185-978-0801873188-1214/
Arduino Robotics 1st edition by John David Warren, Josh Adams, Harald Molle 9781430231844 143023184X
https://ebookball.com/product/arduino-robotics-1st-edition-byjohn-david-warren-josh-adams-haraldmolle-9781430231844-143023184x-18420/
Psychiatry in the Nursing Home 2nd edition by Peter Birkett 9781135187477 1135187479
https://ebookball.com/product/psychiatry-in-the-nursing-home-2ndedition-by-peter-birkett-9781135187477-1135187479-1270/
(Ebook PDF) SFML Blueprints Sharpen your game development skills and improve your C and SFML knowledge and five exciting projects 1st edition by Maxime Barbier 1784398470Â 978-1784398477 full chapters https://ebookball.com/product/ebook-pdf-sfml-blueprints-sharpenyour-game-development-skills-and-improve-your-c-and-sfmlknowledge-and-five-exciting-projects-1st-edition-by-maximebarbier-1784398470-978-1784398477-full-chapters-22/
Home Computer Magazine Issue 3 1st Edition by Cranberry Publishing Ltd ISBN
https://ebookball.com/product/home-computer-magazine-issue-3-1stedition-by-cranberry-publishing-ltd-isbn-11612/
Arduino Home Automation Projects
Automate your home using the powerful Arduino platform
Marco Schwartz
BIRMINGHAM - MUMBAI
Arduino Home Automation Projects Copyright © 2014 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews. Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing, and its dealers and distributors will be held liable for any damages caused or alleged to be caused directly or indirectly by this book. Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.
First published: July 2014
Production reference: 1160714
Published by Packt Publishing Ltd. Livery Place 35 Livery Street Birmingham B3 2PB, UK. ISBN 978-1-78398-606-4 www.packtpub.com
Cover image by Pratyush Mohanta (tysoncinematics@gmail.com)
Credits Author Marco Schwartz Reviewers
Project Coordinator Neha Thakur Proofreaders
Santiago Reig Chiva
Simran Bhogal
Charalampos Doukas
Paul Hindle
Francis Perea Indexers Commissioning Editor Edward Gordon Acquisition Editor Harsha Bharwani
Hemangini Bari Tejal Soni Production Coordinators Aparna Bhagat Manu Joseph
Content Development Editor Akashdeep Kundu Technical Editor Edwin Moses Copy Editors Gladson Monteiro Adithi Shetty
Conidon Miranda Cover Work Conidon Miranda
About the Author Marco Schwartz is an electrical engineer, entrepreneur, and blogger. He has
a Master's degree in Electrical Engineering and Computer Science from Supélec, France, and a Master's degree in Micro Engineering from EPFL, Switzerland. He has more than 5 years of experience working in the domain of electrical engineering. His interests gravitate around electronics, home automation, the Arduino and Raspberry Pi platforms, open source hardware projects, and 3D printing. He runs several websites based on Arduino, including the Open Home Automation website that is dedicated to building home automation systems using open source hardware. He has written another book on home automation and Arduino called Home Automation with Arduino, CreateSpace. He has also published a book on how to build Internet of Things projects with Arduino called Internet of Things with the Arduino Yun, Packt Publishing.
About the Reviewers Santiago Reig Chiva received his BEng degree in Electronics Engineering
from Universidad de La Rioja (Spain). He is currently finishing his MEng degree in Industrial Engineering from Universidad de Talca (Chile), thanks to a merit-based scholarship. He has been interested in technology ever since he was a child. He had his first contact with Arduino just before he started university; this got him involved in open source software and hardware. In his free time, he develops open source projects with Arduino and Python, which he publishes at his personal website, http://kungfulabs.com. He also introduces kids to technology and programming through extracurricular activities and summer camps.
Charalampos Doukas is a researcher and IoT Maker. He started playing with
sensors and Arduinos in 2008 while trying to capture and transmit vital signs. He is passionate about combining different hardware systems with software and services using the Internet. He helps in spreading the knowledge about open source software and hardware by organizing sessions at workshops and conferences. He has built many projects around home monitoring and automation. He is currently contributing hardware nodes for Node-RED and has also authored the book Building Internet of Things with the Arduino, CreateSpace. When he is not playing with sensors and actuators, he manages European research projects at CREATE-NET in Trento, Italy.
Francis Perea is a Professional Education Professor at Consejería de Educación de la Junta de Andalucía in Spain with more than 14 years of experience.
He specializes in system administration, web development, and content management systems. In his spare time, he works as a freelancer and collaborates, among others, with ñ multimedia, a little design studio in Córdoba where he works as a system administrator and the main web developer. He was also a technical reviewer for SketchUp 2014 for Architectural Visualization, Thomas Bleicher and Robin de Jongh, and Internet of Things with the Arduino Yún, Marco Schwartz, both by Packt Publishing. When not sitting in front of a computer or tinkering at his workshop, he can be found running or riding his bike through the tracks and hills or, as a beekeeper, taking care of his bees in Axarquía County where he lives. I would like to thank my wife, Salomé, and our three kids—Paula, Álvaro, and Javi—for all the support they give me, even though we are all busy. There are no words to express my gratitude to them. I would also like to thank my colleagues at ñ multimedia and patient students. The need to be at the level they demand is what keeps me going forward.
www.PacktPub.com Support files, eBooks, discount offers, and more
You might want to visit www.PacktPub.com for support files and downloads related to your book. Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.PacktPub.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at service@packtpub.com for more details. At www.PacktPub.com, you can also read a collection of free technical articles, sign up for a range of free newsletters and receive exclusive discounts and offers on Packt books and eBooks. TM
http://PacktLib.PacktPub.com Do you need instant solutions to your IT questions? PacktLib is Packt's online digital book library. Here, you can access, read and search across Packt's entire library of books.
Why subscribe? •
Fully searchable across every book published by Packt
•
Copy and paste, print and bookmark content
•
On demand and accessible via web browser
Free access for Packt account holders
If you have an account with Packt at www.PacktPub.com, you can use this to access PacktLib today and view nine entirely free books. Simply use your login credentials for immediate access.
Table of Contents Preface Chapter 1: Building Wireless XBee Motion Detectors
Hardware and software requirements Hardware configuration Interfacing the PIR sensor with Arduino Programming an XBee motion detector Building a graphical interface for your XBee motion detectors Summary
1 7
8 9 11 13 15 19
Chapter 2: Control Lights from Your Phone or Tablet
21
Chapter 3: Measuring the Temperature Using Bluetooth
37
Chapter 4: Weather Station in the Cloud with Xively
53
Hardware and software requirements Hardware configuration Testing the relays and Wi-Fi connection Building a graphical interface to control the relays Testing the graphical interface Summary Hardware and software requirements Hardware configuration Creating the Arduino sketch Testing the temperature and humidity sensor Measuring the temperature and humidity remotely Summary Hardware and software requirements Connecting the different components Testing the sensors Setting up your Xively account
21 24 27 32 33 35
38 40 44 46 47 50 54 55 56 58
Table of Contents
Building the Arduino sketch Log in and display data on Xively Summary
61 64 66
Chapter 5: Monitor Your Energy Consumption in the Cloud
67
Chapter 6: Hack a Commercial Home Automation Device
81
Chapter 7: Build Your Own Home Automation System
95
Hardware and software requirements Making hardware connections Testing the project Configuring your Xively account Sending power consumption data to Xively Summary Hardware and software requirements Hardware configuration Controlling the device from your computer Building a graphical interface Summary
Hardware and software requirements Building an Arduino system from scratch Testing the Arduino system Designing a PCB for your home automation system Fabricating the board Designing and 3D printing a case for your home automation project Summary
Index
[ ii ]
68 70 73 75 77 80 82 85 87 89 93
96 98 100 101 107 108 113
115
Preface Home automation is a topic that has been around for many years. It includes everything that you can imagine to control and automate your home. The most widely spread example is the alarm system of your home. Motion sensors, contact sensors, and the central device that orchestrates your alarm system are generally the main components of any home automation system. There are countless devices that are available for home automation. You can buy complete home automation devices from a lot of stores, and even get them installed in your home. However, many of these systems are very expensive, impossible to be customized for your own needs, and have outdated user interfaces. On the other hand, we have the Arduino platform. Arduino is a platform that you can use to quickly prototype electronic systems. It is now used by millions of people around the world to build more complex systems. It is actually the perfect platform to build home automation systems. Because of the flexibility of the Arduino platform, we are going to see that it is easy to interface with various sensors and actuators that are usually found in many home automation systems. It can also be interfaced with many wireless systems, such as Wi-Fi, Bluetooth, or XBee. In this book, we are going to see how to build home automation systems with Arduino. We will first build systems based on commercially available Arduino boards. For example, we are going to build a temperature sensor based on Arduino and Bluetooth. We are also going to integrate some of these systems in an Internet of Things perspective, by sending some data directly to a cloud service. Finally, we are also going to see how to hack commercially available devices and build your own home automation systems from scratch.
Preface
What this book covers
Chapter 1, Building Wireless XBee Motion Detectors, covers a very common topic in home automation: motion detectors. We are going to build a swarm of motion detectors based on the well-known XBee protocol and Arduino. We are also going to build a server-side interface to monitor the state of the XBee motion detectors. Chapter 2, Control Lights from Your Phone or Tablet, covers another popular topic in home automation systems: controlling lights remotely. We are going to interface a relay with Arduino and a Wi-Fi chip so that you can control lights in your home not only from your computer, but also from your phone or tablet. Chapter 3, Measuring the Temperature Using Bluetooth, focuses on measuring temperature and humidity with Arduino, and transmitting the result back to your computer using Bluetooth. We are also going to build a simple interface using Python so that you can access the measurements made by the Arduino and Bluetooth system. Chapter 4, Weather Station in the Cloud with Xively, teaches you to tackle a very trendy topic: the Internet of Things. We are going to make basic weather measurements on our Arduino board, and then transmit this data via Wi-Fi to the cloud using a service called Xively. Using this service, we'll be able to monitor our data remotely from anywhere in the world. Chapter 5, Monitor Your Energy Consumption in the Cloud, starts with the use of the same cloud service that was used in Chapter 4, Weather Station in the Cloud with Xively. However, in this case, we are going to send energy consumption data to the cloud. This way, you will be able to monitor data directly from the Xively interface. Chapter 6, Hack a Commercial Home Automation Device, explores the idea of doing things differently. Instead of creating a new home automation system based on Arduino, we are going to hack an existing device so that you can control it from your computer. We are going to build a USB-controlled power switch, so you can control any device right from an interface running on your computer. Chapter 7, Build Your Own Home Automation System, goes one step further and shows you how to build your own home automation system based on Arduino. We'll cover how to build an Arduino system from scratch, how to design your own PCB, and finally how to design and 3D print a custom case for your project.
[2]
Preface
What you need for this book
You will need several hardware and software components to create all the projects found in this book. Of course, you can just read the description of the projects and learn this way. However, I really recommend actually doing the projects to really learn about building your own home automation systems based on Arduino. The hardware components required are detailed at the beginning of each chapter. However, what you will really need for all the projects is an Arduino board. All the projects of the book are based on the Arduino Uno board, which is described in the following URL: http://arduino.cc/en/Main/arduinoBoardUno
On the software part, there are some software that we will use in all chapters of the book. These are as follows: •
Arduino IDE (http://arduino.cc/en/main/software).
•
You will need several libraries. These are detailed in each chapter where they are necessary.
•
You will also need a web server running on your computer for some of the projects. I recommend using some software that integrates a web server and a database and that handles all the details for you. If you are using Windows, I recommend using EasyPHP. You can download it from the following URL: http://www.easyphp.org/
For OS X, I recommend using MAMP. You can download it from the following URL: http://www.mamp.info/
For Linux, you can follow the instructions given in the following URL to install a web server: http://doc.ubuntu-fr.org/lamp
Make sure that the server is running at this point. We are going to use it in several of the projects of this book.
[3]
Preface
Who this book is for
This book is for all those who are willing to build their own home automation systems based on Arduino. You actually don't need to know anything about the Arduino platform beforehand, since all the projects will be explained step-by-step with clear instructions. The only thing you need in order to follow the projects found in this book is basic knowledge of electronics and programming. This book is also for electronics hobbyists who want to learn more about doing projects with the Arduino platform. By doing these projects around home automation, you will learn about every aspect of the Arduino platform: how to interface sensors and actuators with Arduino, how to use wireless modules, and even how to build your own Arduino system from scratch. Finally, this book is also for people willing to learn more about the Internet of Things using Arduino. Nearly all the chapters of the book include wireless communications, and two chapters of the book are dedicated to sending some data to the cloud so that it can be monitored from anywhere.
Conventions
In this book, you will find a number of styles of text that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning. Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "What we are interested in is the return_value field, which contains the result of the digitalRead() function." A block of code is set as follows: String data = ""; data = data + timeString + "," + String(temperature) + "," + String(humidity) + "," + String(lightLevel);
When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold: [default] if (client) { // Process request process(client); // Close connection and free resources. client.stop(); } [4]
Preface
Any command-line input or output is written as follows: # /digital/7/1
New terms and important words are shown in bold. Words that you see on the screen, in menus or dialog boxes for example, appear in the text like this: "On Windows, you can find it by navigating to Control Panel | Network and Internet | View network status and sharing options." Warnings or important notes appear in a box like this.
Tips and tricks appear like this.
Reader feedback
Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or may have disliked. Reader feedback is important for us to develop titles that you really get the most out of. To send us general feedback, simply send an e-mail to feedback@packtpub.com, and mention the book title via the subject of your message. If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide on www.packtpub.com/authors.
Customer support
Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.
Downloading the example code
You can download the example code files for all Packt books you have purchased from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.
[5]
Preface
Errata
Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books—maybe a mistake in the text or the code—we would be grateful if you would report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub. com/submit-errata, selecting your book, clicking on the errata submission form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded on our website, or added to any list of existing errata, under the Errata section of that title. Any existing errata can be viewed by selecting your title from http://www.packtpub.com/support.
Piracy
Piracy of copyright material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works, in any form, on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy. Please contact us at copyright@packtpub.com with a link to the suspected pirated material. We appreciate your help in protecting our authors, and our ability to bring you valuable content.
Questions
You can contact us at questions@packtpub.com if you are having a problem with any aspect of the book, and we will do our best to address it.
[6]
Building Wireless XBee Motion Detectors In this chapter, we are going to build a project around a very common home automation sensor: a motion sensor. Ever noticed those small modules in white plastic that are in the upper corners in some rooms of people's houses, modules that turn red when you walk in front of them? That's exactly the same thing we are going to do in this project. However, instead of using proprietary technologies, which is usually the case for these modules, we are going to base our system on Arduino. And for the communication part, we are going to use XBee modules, which are low-power radio modules that are widely used with the Arduino platform. These modules are based on the ZigBee protocol, which is also used in many commercial home automation systems. Here are the major takeaways that we will see in this chapter: •
First of all, we will list all the hardware and software components that we need for this project. With these components, we will build one motion sensor module composed of an Arduino board, a motion sensor, and one XBee module.
•
Then, we will test this first module; the motion sensor will be tested on its own, and we will also test the communication part by sending commands via the serial monitor of the Arduino software.
•
Finally, we are going to build a web-based graphical interface that centralizes all the data of our XBee sensors. With a simple interface built on web technologies, you'll be able to instantly see if some motion is detected in your home.
Building Wireless XBee Motion Detectors
Hardware and software requirements
For this first project, we will need Arduino boards, PIR motion sensors, and some XBee modules and XBee shields, depending on the number of sensors you want to have in your system. For just one sensor, you will need the following components: •
Arduino R3 board (https://www.sparkfun.com/products/11021)
•
PIR sensor (http://www.adafruit.com/products/189)
•
Series 1 XBee module (https://www.sparkfun.com/products/11215)
•
Arduino XBee shield (https://www.sparkfun.com/products/10854)
Note that I added the link to the components I used for this project as a reference, but you can also choose to use other components. The motion sensor needs to have three pins: two for the power supply and one signal pin. It should also use a 5V voltage level to be compatible with the Arduino Uno board that also operates at 5V. For the XBee module, I used a Series 1 XBee module, 1mW, with a trace antenna (which means it doesn't require any external antenna). You could also use a module with an external antenna, but you would then have to connect the antenna to the module. I used Series 1 XBee modules for this project as they are easier to use than Series 2, which have functionalities we do not need for this simple project. This module has a range of about 100 meters without obstacles. You will also need to connect your XBee module to your Arduino board. For that, each of my motion sensor modules will use an Arduino XBee shield from Sparkfun, but you can use other brands as well. It just needs to make the connections between the XBee module and the Arduino board. Finally, you will need a way to communicate with these XBee modules from your computer. I used another XBee module (also Series 1, 1mW, with a trace antenna) connected to an XBee explorer board from Sparkfun, which is basically a USB interface board where you can plug any XBee module. I used the following components for the module connected to the computer: •
XBee explorer USB (https://www.sparkfun.com/products/8687)
•
Series 1 XBee module (https://www.sparkfun.com/products/11215)
On the software side, you need to have the latest version of the Arduino IDE installed on your computer. For this project, the Arduino IDE 1.0.5 was used.
[8]
Chapter 1
You will also need the aREST library for Arduino. You can find this library at the following link: https://github.com/marcoschwartz/aREST
To install the library, extract all the files in a folder named aREST (or create this folder if it doesn't exist yet). Then, place this folder in your /libraries folder inside your main Arduino folder. You will also need to have a web server installed and running on your computer so that you can use the web interface that we are going to develop at the end of this chapter. To configure your XBee modules, you will also need to have the XCTU software installed. You can find it at the following URL: http://www.digi.com/products/wireless-wired-embedded-solutions/ zigbee-rf-modules/xctu
Hardware configuration
The hardware configuration of this project is not really complex. For each motion sensor module you want to build, you'll need to do the following steps. The first one is to plug an XBee module on the XBee shield. Then, you need to plug the shield into your Arduino board, as shown in the following image:
[9]
Building Wireless XBee Motion Detectors
Now, you can connect the motion sensor. It has three pins: VCC (for the positive power supply), GND (which corresponds to the reference voltage level), and SIG (which will turn to a digital HIGH state in case any motion is detected). Connect VCC to the Arduino 5V pin, GND to Arduino GND, and SIG to Arduino pin number 8 (the example code uses pin 8, but you could also use any digital pin). You should end up with something similar to this image:
You will also need to set a jumper correctly on the board so we can upload a sketch. On the XBee shield, you have a little switch close to the XBee module to choose between the XBee module being connected directly to the Arduino board serial interface (which means you can't upload any sketches anymore) or leaving it disconnected. As we need to upload the Arduino sketch first, you need to put this switch to DLINE, as shown in this image:
[ 10 ]
Chapter 1
You will also need to connect the XBee explorer board to your computer at this point. Simply insert one XBee module to the board as shown in the following image:
Now that this is done, you can power up everything by connecting the Arduino board and explorer module to your computer via USB cables. If you want to use several XBee motion sensors, you will need to repeat the beginning of the procedure for each of them: assemble one Arduino board with an XBee shield, one XBee module, and one motion sensor. However, you only need one USB XBee module connected to your computer if you have many sensors.
Interfacing the PIR sensor with Arduino
First off, you are going to leave XBee aside and simply check if the motion sensor is working correctly. What you will do in the first sketch is print out the readings from the motion sensor on the serial port. This is the complete code for this part that you can just copy and paste in the Arduino IDE: // Simple motion sensor int sensor_pin = 8; void setup() {
[ 11 ]
Building Wireless XBee Motion Detectors Serial.begin(9600); } void loop() { // Read sensor data int sensor_state = digitalRead(sensor_pin); // Print data Serial.print("Motion sensor state: "); Serial.println(sensor_state); delay(100); }
Downloading the example code and colored images You can download the example code files and colored images for this Packt book that you have purchased from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.
Let's see what this code does. It starts by declaring the pin on which the sensor is connected, in our case 8. In the setup() function of the sketch, we initialize the serial connection with the computer, so we can print out the results on the serial monitor. Then, in the loop() part of the sketch, we read out the state of the motion sensor using a simple digitalRead() command, and store that result into a variable. This state is then simply printed out on the serial port every 100 ms. You can now upload the sketch to your Arduino board and open the serial monitor. This is what you should see: Motion sensor state:0 Motion sensor state:1 Motion sensor state:1 Motion sensor state:1 Motion sensor state:0 Motion sensor state:0
If you can see the state of the sensor changing when you wave your hand in front of it, it means that the sensor is working correctly and that you can proceed to the rest of the project.
[ 12 ]
Chapter 1
Programming an XBee motion detector
You are now going to modify the sketch slightly so that it can transmit the state of the sensor to a central interface running on your computer. However, you not only want to transmit the state of the motion sensor, but also an ID identifying the sensor that is detecting the motion. Programming the detector starts by importing the right libraries: // Libraries #include <aREST.h> #include <SPI.h>
The aREST library implements a REST API for Arduino. REST stands for REpresentational State Transfer, and is widely used in web applications such as Software as a Service (SaaS) applications. In our case, we will use this library to standardize the communication with the central interface that will run on the computer. In this project, the REST commands will be sent over the XBee connection that acts as a serial port from the Arduino point of view. After importing the libraries, you need to declare the sensor pin and the ID of the module as follows: // Motion sensor pin and ID int sensor_pin = 8; String xbee_id = "2";
After this, you can create the instance of the aREST library that will handle the requests coming from the graphical interface: // Create aREST instance aREST rest = aREST();
In the setup() function of the sketch, the first step is to start the serial communication. Be careful here, as the speed of the serial object has to be the same as the speed of your XBee modules, which is 9600 bauds by default: // Start Serial Serial.begin(9600);
You can also set the ID of the module: // Give name and ID to device rest.set_id(xbee_id);
[ 13 ]
Building Wireless XBee Motion Detectors
Note that if you are configuring more than one sensor, you need to change the ID of each sensor you are configuring. Now, thanks to the aREST library, the loop() part of the sketch is pretty simple. We simply have to handle the incoming requests from the computer that will come via the XBee serial interface: void loop() { // Handle REST calls rest.handle(Serial); }
Now, the sketch is ready to be used. All the code is available on the GitHub repository of the project: https://github.com/openhomeautomation/arduino-homeautomation/tree/master/chapter1
You can upload the sketch to your Arduino board by making sure that the switch is still set on DLINE. Once this is done, you can test the code locally via the serial monitor of the Arduino IDE. Open the serial monitor, make sure that the serial speed is set to 9600, and type the following: /digital/8/r
This is the REST command to read a digital value from pin number 8 and return the value, which is exactly what we want to achieve. You should see the following data being returned, depending on the current state of the sensor: {"return_value": 0, "id": "2", "name": "", "connected": true}
What we are interested in is the return_value field, which contains the result of the digitalRead() function. Try to wave your hand in front of the sensor to see if the return value changes accordingly. Note that the returned data is in the JSON format, which will be really important later when we are going to process this information and display it. Now that you are sure that the code is working, you can switch over to XBee communication. For that, simply put the switch next to the XBee module to UART. Now, the serial port of the Arduino board is directly wired to the XBee module.
[ 14 ]
Chapter 1
By default, all the XBee modules sold are configured on the same Personal Area Network (PAN) ID, which is 3332. This means that all the modules will receive data from other modules on the same PAN ID. For experimentation, you can leave it at its default value. However, you might want to change this later, in case your neighbor is, for example, using XBee devices as well.
To continue further, insert the XBee module you want to modify in the USB XBee explorer and open the XCTU XBee tool. Click on the top-left button to add a new device and select the USB explorer serial port. You should get the following screen:
You will then be able to change the PAN ID of your device. To configure all the modules in your network, just repeat the procedure for each XBee module.
Building a graphical interface for your XBee motion detectors
Now that the hardware is completely configured, you can build the server-side code to read data from all your motion sensor modules. For this project, I used two modules only, but you can use more modules for the project. As for many web applications, our control center for the XBee motion detectors will be built using four different languages: HTML, CSS, JavaScript, and PHP. We are going to use HTML and CSS to design the interface itself, JavaScript to handle the different elements of the interface and make the link with PHP, and finally use PHP to communicate directly with the XBee modules.
[ 15 ]
Building Wireless XBee Motion Detectors
The first step is to design the interface. We'll basically have several blocks on our page, one block corresponding to one XBee module. For example, this is the HTML code for the first block: <div class="sensorBlock"><span class="sensorTitle">Sensor 1</span> <span class="display" id="display_1"></span> </div>
Now, you can have a look at the JavaScript code that will handle the different elements of the interface. Note that all this code is included inside a dedicated JavaScript file. What we are going to do here is check the value of the sensor at regular intervals via a digitalRead() command. To do this, we have to call a PHP file with the correct command as an argument: $.get( "xbee.php", {command: "/digital/8/r"}, function( data ) {
The result from the PHP file is some string data formatted in the JSON format. To actually create a usable object from this string, we can use the parseJSON() function of jQuery: json_data = jQuery.parseJSON(data);
Now, we have a JavaScript object that has the same properties as the data fields inside the JSON container. For example, to get the ID of the sensor module, you can just type: var sensorID = json_data.id;
Now that we know which sensor returned some data, we can read the return_value field inside the JSON object to know the status of the motion sensor on this module. If this value is equal to 0, we set the background color of the display block of this sensor to gray. If it is equal to 1, it means that some motion was detected. If this is the case, we change the background color to orange as follows: if (json_data.return_value == 0){ $("#display_" + sensorID).css("background-color","gray"); } else { $("#display_" + sensorID).css("background-color","orange"); }
Let's now see the details of this PHP file that is called every time. We saw in the JavaScript code that the PHP file also receives an argument called command. This variable is retrieved inside the PHP file by: $command = $_GET['command'];
[ 16 ]
Chapter 1
Inside this file, we also need to include the php_serial class: include "php_serial.class.php";
We also need to declare the right serial port for your XBee explorer device: $serial_port = "/dev/cu.usbserial-A702LF8B";
You will have to change this according to your own settings. To know which serial port the XBee explorer board is using, simply search for devices starting with cu inside your /dev folder if you are using Linux or OS X. If you are using Windows, you will see the list of the serial ports in your Configuration Panel.
You now need to configure the different settings of the serial connection we are about to open with the board: $serial = new phpSerial; $serial->deviceSet($serial_port); $serial->confBaudRate(9600); $serial->confParity("none"); $serial->confCharacterLength(8); $serial->confStopBits(1);
Now, you can actually open the connection: $serial->deviceOpen();
We can now send the command and read the answer: $serial->sendMessage($command . "\r"); $answer = $serial->readPort();
Now, we close the serial connection: $serial->deviceClose();
Finally, we send back the data that was read: echo $answer;
We are now ready to test our project. You can of course find all the code for this part on the GitHub repository of the project at the following website: https://github.com/openhomeautomation/arduino-home-automation/tree/ master/chapter1
[ 17 ]
Building Wireless XBee Motion Detectors
Make sure that your web server is running, and that all the files of the project are placed inside a folder in your web server's main folder. You can now head over to this folder, usually accessible by typing localhost in your favorite web browser. Open the HTML file, and you should see something similar to the following screenshot:
Note that on this example screenshot, the second sensor I had in my system already detected some motion. Now try with your sensors by waving your hand in front of them; you should instantly see that the state of the sensor changes on the interface. Of course, by modifying the HTML and JavaScript code, you can easily modify this interface to adapt it for more sensors. Also, be aware that these modules don't need to be connected to your computer directly once the code is loaded onto them. You can just disconnect them from your computer and power them using a simple battery pack (the Arduino Uno board, for example, accepts up to 12 V of power on its jack input). Note that you can also access this interface from a mobile phone or tablet, just by accessing the localhost folder on your computer. Of course, your computer has to be powered (and the web server running) to access the interface.
[ 18 ]
Chapter 1
Summary
Let's now summarize what we did in this first project of the book. We built XBee motion sensors that are based on Arduino, and learned that you can put them wherever you want in your home. They communicate with a central interface where you can see the status of every sensor live. Of course, we could have used other wireless communication devices for this project, such as Wi-Fi. However, XBee modules are very energy efficient compared to Wi-Fi modules, so it completely makes sense to use XBee for this project, as you might want to power these motion sensors from batteries. Let's see what the major takeaways of this chapter were. We first chose the components for our project, and built our fist XBee-based motion sensor using Arduino and a PIR motion sensor. We also connected an XBee module to our computer via a USB so it can communicate with the other modules. Then, we tested our motion sensor module by first testing the PIR sensor connected to the Arduino Uno board. We also tested the sketch at this point that we used to access the board via XBee. Finally, we built a web-based interface to visualize the information coming from the different XBee motion sensors live. This interface was tested with two modules, but it is made to easily extend to many more XBee modules. In the next chapter, we are going to tackle another huge field of home automation: controlling lights. And for this project, we won't be using XBee, but we are going to interface Arduino with a Wi-Fi chip to control lights from any mobile device.
[ 19 ]
Control Lights from Your Phone or Tablet In this chapter, we are going to tackle another very common project in any home automation project: controlling lights. There are many devices that you can buy off the shelves that will give you the ability to control devices in your home, but these devices usually have a high price point. And even if they are wireless, they usually come with a remote control. In this project, we are going to take another approach and control lights directly from your computer, phone, or tablet, all via Wi-Fi. The following will be the major takeaways from this chapter: •
First, we are going to build the hardware part of our project by connecting a Wi-Fi chip to Arduino and the device we want to control (here, a simple lamp) to a relay module. We'll actually use two relay modules in this project, but this can, of course, be extended to any number you want.
•
Then, we are going to write some basic code to test the different parts of the project. We will check that the relay module is functioning properly and that the Wi-Fi chip can indeed be connected to the Wi-Fi network of your home.
•
Finally, we'll build a basic graphical interface so that you can control your devices not only from your computer, but also from a mobile device, such as a smartphone or a tablet.
Hardware and software requirements
Let's first see what you will need to create this project. Similar to many other projects of this book, this project is based on the Arduino platform, and we will once again use an Arduino Uno board. Note that an Arduino Mega board will work as well.
Control Lights from Your Phone or Tablet
Then, you also need some relay modules so that you can control the lamps. A relay is basically an electromechanical switch. They are usually used when you want to command a high voltage device (for example, a lamp plugged into a wall socket) with a much smaller command voltage (for example, the 5V of the Arduino board). For more information on relays, you can visit the following web page: http://en.wikipedia.org/wiki/Relay
For this project, I used a 5V relay module from Polulu that can handle up to 250V (thus supporting 110V and 230V devices) and a maximum of 10 A. The following image displays the relay module:
I used two of them, as I want to command two lamps from my Arduino board. Of course, the project will work perfectly fine if you want to add more relays, or just use a single one. You don't have to get this specific relay module, and you can get one from any of your favorite brands. It just has to have similar characteristics: being compatible with 5V for the command part (so it works with Arduino) and being able to handle the voltage and current of the device you want to control. For example, the module you will see in this project can handle up to 230 V and 10 A, which means the module can handle a device that consumes up to 2300 W of power.
[ 22 ]
Chapter 2
Since we will be using 110 V or 230 V devices with these relays, you will have to take special precautions. Never touch or even go near the relay when it is plugged into the wall power socket via a cable. If possible, hide the relay where other people cannot access it, for example, in a plastic enclosure.
Now, you need a Wi-Fi module. The code of this project is specific for the CC3000 Wi-Fi chip. This chip is widely used in the Arduino community, and you will find a lot of tutorials and resources on the Web that use this specific chip. I used a breakout board from Adafruit that contains this chip. A breakout board is basically a printed circuit board (PCB) that integrates the chip you are interested in, plus all the extra components that are necessary for the correct operation of the chip. This is an image of the board I used:
Again, you have quite a lot of options when choosing this board. You can pick one from any of your favorite manufacturers. It just needs to integrate the CC3000 Wi-Fi chip and be compatible with 5V voltage levels (which is the case for most CC3000 boards). You can also use an Arduino shield that integrates the CC3000 chip, like the one from Adafruit. To get more information about this board and how the CC3000 Wi-Fi chip works in general, you can check out the documentation and example of the Adafruit CC3000 library at the following link: https://github.com/adafruit/Adafruit_CC3000_Library
[ 23 ]
Control Lights from Your Phone or Tablet
You will also need a breadboard and some jumper wires to make all the required hardware connections. The following is a list of the components that were used in this chapter: •
Arduino Uno R3 (http://www.adafruit.com/products/50)
•
Polulu 5V relay (http://www.pololu.com/product/2480)
•
CC3000 Wi-Fi module (http://www.adafruit.com/products/1469)
•
Breadboard (http://www.adafruit.com/product/64)
•
Jumper wires (http://www.adafruit.com/product/759)
To actually plug the lamp into your relays, you will need some bare male and female power cables. See the hardware configuration section for more details. On the software side, you need to have the latest version of the Arduino IDE installed on your computer. You will also need to install the aREST library for Arduino, which you can find at the following link: https://github.com/marcoschwartz/aREST
To download a repository from GitHub, you can simply click on the Download ZIP button. Using the aREST library also requires having the CC3000 chip library, which we will use later in the book. You can find this at the following location on the Web: https://github.com/adafruit/Adafruit_CC3000_Library
You can find the CC3000 mDNS library at the following website: https://github.com/adafruit/CC3000_MDNS
To install a given library, extract all the files in a folder named aREST. Then, place this folder in your /libraries folder inside your main Arduino folder (or create this folder if it doesn't exist yet). You will also need to have a web server installed and running on your computer so that you can use the web interface that we are going to develop at the end of this chapter.
Hardware configuration
Let's now see how to connect the different parts of the project. We are first going to take care of connecting all the components to the Arduino board, basically the relay module and the CC3000 Wi-Fi chip. To give you an idea, this is what you should end up with: [ 24 ]
Chapter 2
To know exactly which wires and pins you have to connect, the following image describes all the connections of the project:
Note that this schematic only displays the connections for one relay module. Let's first see how to connect a single relay module. To get started on the hardware connection, first place the different components next to each other and plug the CC3000 module on the breadboard. We are first going to take care of the power supply part. Connect the ground (GND) pin of the Arduino board to the GND pin of the CC3000 board. Then, connect the Arduino Uno board 5V pin to the Vin pin of the CC3000 board.
[ 25 ]
Control Lights from Your Phone or Tablet
Now, let's look at the CC3000 chip. There are quite a few pins to connect to the module, so please be sure to follow the instructions carefully or the module might not work properly. Connect the IRQ pin of the CC3000 board to pin number 3 of the Arduino board, VBAT to pin 5, and CS to pin 10. Then, you need to connect the SPI pins to the Arduino board: MOSI, MISO, and CLK go to pins 11, 12, and 13, respectively. Then, we'll finish up with the relay module. A relay module has three input pins: VCC, GND, and SIG, which is the signal pin. Simply connect pin number 6 of the Arduino board to the SIG pin of the relay module. Finally, connect GND to the Arduino GND, and the VCC pin to the Arduino 5V. Now we'll make the connections between the lamp and the relay module. You should have two different cables for that: a male power plug and a female power plug. The following image illustrates the final result you should get:
A relay module basically has three output pins: COM (for common pin), NC (for normally closed), and NO (for normally open). What we want is to have the COM pin connected directly to one pin of the power plug, NC not connected, and NO connected to another pin of the power plug. To connect the relay module to the power cables, take the following steps: 1. First, connect one pin of the female power plug to the COM pin. 2. Then, connect one pin of the male power plug to the NO pin. 3. Finally, connect the two remaining cables together, for example, by using a typical electrical screw terminal.
[ 26 ]
Chapter 2
4. Once this is done, you can go on and connect the project to your lamp. The following schematic summarizes the connections between the relay module and the lamp:
5. Connect the lamp to the female power socket and then connect the male power plug to the power socket in the wall. Of course, you need to repeat this operation for every relay you have in your project. You can simply connect the power supply of each new relay module to the +5V and GND lines on the breadboard, and the SIG pin of the new relay to a free digital pin on the Arduino board.
Testing the relays and Wi-Fi connection
Now that the hardware configuration is complete, we can start writing some code to test our project. We'll first write a simple sketch to test a given relay. Go over to your Arduino IDE and you can start writing some code. The most important parts of the code will be detailed below, and you can find the complete code on the GitHub repository of the project at https://github.com/openhomeautomation/arduinohome-automation/tree/master/chapter2. The first step is to declare which pin the relay you want to test is connected to: const int relay_pin = 6;
We use a const int variable here, which is similar to #define but better, since we are sure the constant is of the right type. In the setup() function of the sketch, we need to specify that this pin is a digital output with the pinMode() function: pinMode(relay_pin,OUTPUT);
[ 27 ]
Control Lights from Your Phone or Tablet
Then, inside the loop() function, we are basically going to activate the relay, wait for 5 seconds, switch it off again, wait for 5 seconds again, and repeat the process. This is done with the following piece of code: // Activate relay digitalWrite(relay_pin, HIGH); // Wait for 5 seconds delay(5000); // Deactivate relay digitalWrite(relay_pin, LOW); // Wait for 5 seconds delay(5000);
You can now upload the code to the Arduino board. If you made the right hardware connections, you should now see your lamp switching on and off every 5 seconds. If that's not the case, you need to check your hardware connections, especially between the relay module and Arduino. You should hear the relay click whenever the state of the relay is changing. Make sure that whenever you touch any part of the project, the power plug is disconnected from the wall socket. There could be a bare cable exposed on your project and it can become very dangerous if you work on your project while it's on. Of course, all the code for this first test sketch is available on the GitHub repository of the project at https://github.com/ openhomeautomation/arduino-home-automation/tree/ master/chapter2, inside the relay_test folder.
We can now work on the next step, which is actually building the final sketch for our project. At this point, we are simply going to test if the CC3000 Wi-Fi chip is working, and check if we can command the relay wirelessly. We start by declaring the correct libraries for our project: #include <Adafruit_CC3000.h> #include <SPI.h> #include <CC3000_MDNS.h> #include <aREST.h>
[ 28 ]
Chapter 2
We also need to specify which pins the CC3000 chip is connected to. If you followed the hardware configuration section, you should have nothing to change here: #define ADAFRUIT_CC3000_IRQ #define ADAFRUIT_CC3000_VBAT #define ADAFRUIT_CC3000_CS
3 5 10
Then, we have to declare the CC3000 chip instance from the CC3000 library, along with the right pins that we just defined: Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT, SPI_CLOCK_DIV2);
Then, there are some parameters you actually need to modify so the chip knows which Wi-Fi network to connect to. You have to enter your Wi-Fi network SSID and password: #define WLAN_SSID #define WLAN_PASS #define WLAN_SECURITY
"yourSSID" "yourPassword" WLAN_SEC_WPA2
Note that you will also have to change your security settings if you are not using WPA2. To get a list of all the possible security settings, you can have a look at the example sketches inside the CC3000 library: // Security can be WLAN_SEC_UNSEC, WLAN_SEC_WEP, WLAN_SEC_WPA or WLAN_SEC_WPA2
You also need to define a port on which we are going to listen for incoming connections. I used 80, which is quite convenient because you can directly type commands in your browser to access the board: #define LISTEN_PORT
80
We'll also need to define the server that will run on the Arduino board and accept incoming connections: Adafruit_CC3000_Server restServer(LISTEN_PORT);
We also need to make an instance of the mDNS service, which will be quite useful to access the board without having the IP address of the board: MDNSResponder mdns;
Finally, you have to make an instance of the aREST library, so we can handle the requests coming from the outside world: aREST rest = aREST();
[ 29 ]
Control Lights from Your Phone or Tablet
Inside the setup() function, after initializing the board and connecting to the local Wi-Fi network, you can start the mDNS service. This is where you actually give a name to your Arduino board. Here, we simply call it arduino, which means it will be accessible later using the name arduino.local in your browser: if (!mdns.begin("arduino", cc3000)) { while(1); }
However, it can be that the mDNS server is not working on your computer. I invite you to check the page of the CC3000 mDNS library for more details. If your computer is not compatible, you will have to know the exact IP address of the CC3000 board. This is done with the following function that will print the IP address whenever the board starts: while (! displayConnectionDetails()) { delay(1000); }
Before the end of the setup, we still need to start our server running on the Arduino board. This is done with the following piece of code: restServer.begin(); Serial.println(F("Listening for connections..."));
Now, in the loop() function of the sketch, we first have to update the mDNS service: mdns.update();
And finally, check if any client wants to connect to the Arduino web server, and handle this client using the aREST library if that's the case: Adafruit_CC3000_ClientRef client = restServer.available(); rest.handle(client);
And thanks to the aREST library, that's all we have to do! You can now upload the code to the board (make sure that you changed the code with your own SSID and password). When that's done, open the serial monitor, wait for a few seconds, and you should see the following output at the end: Listening for connections...
If you can see this message, it means your board is connected to the Wi-Fi network. You should also see the IP address of the board being printed. Write it down, you might need it soon.
[ 30 ]
Chapter 2
You can now close the serial monitor and open your favorite web browser. What we will do first is set the relay pins as outputs, starting with pin number 6. Just type the following command in the URL field of your browser: http://arduino.local/mode/6/o
If everything is working fine, you should see the confirmation being printed in your browser: Setting pin D6 to output
If that's not the case, don't panic. It could simply be that the mDNS library is not compatible with your computer. Try the same command again with the IP address of your CC3000 board in place of the arduino.local alias. For example, type the following command: http://192.168.0.103/mode/6/o
You can now do the same for pin number 7, where I connected the second relay when building the project. Now, we'll try to activate the first relay via Wi-Fi. Still present in your browser, type: http://arduino.local/digital/6/1
You should instantly hear the relay switching and the lamp being switched on if it's still connected to your Arduino project. You will also have the immediate confirmation inside your browser: Pin D6 set to 1
You can also do the same for pin number 7, just to check that the other relay can also be commanded via Wi-Fi. Of course, if you are using more relays or have connected your relays differently, you can test them all at this point just by repeating the procedure we saw in this section. Of course, all the code for this section is available on the GitHub repository of the project at the following web page: https://github.com/openhomeautomation/arduinohome-automation/tree/master/chapter2
[ 31 ]