Post on 31-Jan-2023
ATHABASCA UNIVERSITY
Smart Home and Garden System
BY
GUANG YEW
A project submitted in partial fulfillment
Of the requirements for the degree of
MASTER OF SCIENCE in INFORMATION SYSTEMS
Athabasca, Alberta
April 2017
© Guang Yew, 2017
ii
ABSTRACT Nowadays, we are seeing more and more sensors being integrated together in a
network in many places like automobiles and home appliances including climate
control and security cameras systems. The main reason for these systems are to
make our lives easier, however, the majority of these control/automation systems in
home and garden scenarios are either proprietary, difficult to implement, expensive,
or all of those reasons. Raspberry Pi 2 devices were developed in the UK by the
Raspberry Pi Foundation as affordable single board computers, which only require a
small amount of electrical power. They are equipped with GPIO interface pins, which
allow them to have different inputs or outputs assigned to them to handle various
functions such as turning on a circuit or communicating with sensors. Using
Raspberry Pi 2 devices, this project forms an affordable wireless sensor network in a
smart home and garden system that communicates with a central server to help
people be easily able to monitor a number of sensors through a web interface
hosted on the central server where the sensor data is collected, and will overall
reduce the amount of human effort required in a household. Together, these very
affordable networked Raspberry Pi 2 devices were used to implement a NFC sensor
controlled garage door opener, and an automatic watering system for a garden.
Feedback from the test subjects indicated that they liked the open source concept of
the system, the affordability, and the customizability, but noted that the setup
process could be even more streamlined and made even easier. This open source
project allows other interested people to develop the system further to expand the
functionality and future possibilities of the system.
iii
ACKNOWLEDGEMENTS I would like to thank my family for their constant support and encouragement. I
would also like to thank my professor Dr. Qing Tan for his guidance and support in
my studies.
iv
Table of Contents
CHAPTER 1 – INTRODUCTION ................................................................................................................. 1
1.1 Research Purpose ..................................................................................................................... 1
1.2 Research Objectives ................................................................................................................. 1
1.3 Research Methodology ............................................................................................................ 2
1.4 Research Contribution .............................................................................................................. 3
1.5 Research Limitations ................................................................................................................ 4
DEFINITION OF TERMS ....................................................................................................................... 6
CHAPTER 2 – LITERATURE REVIEW ......................................................................................................... 8
RELATED WORK .................................................................................................................................. 8
CURRENT RESEARCH ........................................................................................................................... 8
2.1 Closed Loop Control and Sensory Systems .............................................................................. 8
2.2 Sensors and Sensory Systems ................................................................................................... 9
2.3 The Control and Computation Unit - Raspberry Pi ................................................................ 11
2.4 The Communications Link – Wireless Sensor Network and the Internet .............................. 16
2.5 Internet of Things ................................................................................................................... 20
CHAPTER 3 – DESIGN OF THE SYSTEM ................................................................................................. 22
3.1 The System Overview ............................................................................................................. 22
3.2 The Sensor Based Sub-Systems .............................................................................................. 23
3.2 Programming Language, Development Environment, and Database .................................... 26
3.4 The Wireless Sensor Network and Raspberry Pi Configuration ............................................. 28
3.5 The System Cost ..................................................................................................................... 28
v
CHAPTER 4 – DISCUSSIONS .................................................................................................................. 30
STATEMENT OF THE CHARACTERISTICS, STRENGTHS, AND LIMITATIONS ....................................... 30
STATEMENT OF FUTURE DEVELOPMENT ......................................................................................... 31
CHAPTER 5 – CONCLUSIONS AND RECOMMENDATIONS..................................................................... 33
CONCLUSIONS .................................................................................................................................. 33
SUGGESTIONS FOR FURTHER RESEARCH ......................................................................................... 33
REFERENCES ......................................................................................................................................... 35
APPENDIX A – Setup Manual ................................................................................................................ 42
Preface Notes ................................................................................................................................... 42
Useful Links ....................................................................................................................................... 42
Useful Commands in Linux/Raspbian ............................................................................................... 43
Central Server Setup ......................................................................................................................... 44
Check for updates for Linux and other installed program packages............................................ 46
Install Emacs editor ...................................................................................................................... 47
Install LAMP (Linux Apache MySQL PHP) Server Packages .......................................................... 47
Setup SSL for Apache (HTTP Server) ............................................................................................. 48
Create MySQL Database in PHPMyAdmin .................................................................................... 49
Load Web Interface Files into Central Server VM ........................................................................ 51
Base Raspberry Pi Setup ................................................................................................................... 53
Things to do after flashing memory card ..................................................................................... 55
Garden/Watering Pi .......................................................................................................................... 58
Overview ...................................................................................................................................... 58
Parts Needed/Used ...................................................................................................................... 58
Instructions ................................................................................................................................... 58
vi
NFC Garage Door Opener ................................................................................................................. 67
Overview ...................................................................................................................................... 67
Parts Needed/Used ...................................................................................................................... 67
Instructions ................................................................................................................................... 68
APPENDIX B – Source Code .................................................................................................................. 76
nfc-read.py........................................................................................................................................ 76
check-and-water.py .......................................................................................................................... 80
report-status.py ................................................................................................................................ 83
homeautomation.sql ........................................................................................................................ 86
LIST OF TABLES
Page
Table 1. Comparison of Platforms, Size, Weight, and Cost ........................................................ 14
Table 2. Project Costs ....................................................................................................................... 29
vii
LIST OF FIGURES
Page
Figure 1. Closed Loop System ............................................................................................. 9
Figure 2. System Conceptual Diagram ................................................................................23
Figure 3. NFC Garage Door Opener Software Block Diagram .............................................24
Figure 4. Automatic Garden Watering System Software Block Diagram ..............................25
Figure 5. Database Design ..................................................................................................27
Figure 6. Historical Garden Temperature Chart ...................................................................28
CHAPTER 1 – INTRODUCTION 1.1 Research Purpose Traditionally, different sensors have been independent of each other and have
required different software or methods to retrieve or view the data from each sensor.
Currently available sensor networks for home and garden automation scenarios are
either time consuming to implement, very expensive, or not easy to use. They are also
often proprietary and not easily customizable. As a result, there are not many common
households that have smart home and garden systems installed or are fully utilizing
these systems to their potential.
The purpose of this research project was to implement a home and garden
automation system with an interface that is easy to use, affordable, and utilize open
source hardware/software so that other developers/users can customize it and
develop the system further.
1.2 Research Objectives This research project will have helped show that sensors can be affordably
integrated into a commonly used 802.11 home network to provide home and garden
automation with data logging. Currently available home automation systems are
proprietary, not generally customizable, and are not affordable. These reasons could
have the potential to dramatically affect the amount of households that will install home
and garden automation systems.
2
The opportunity from this project implementation is to show that an open source
smart home and garden automation system can be done using affordable components
that can be customized at any time to meet the various needs of the user.
1.3 Research Methodology The design of the system started with the basic idea of a home automation system
and the desired features. It then involved narrowing the project scope down to
something achievable in a reasonable amount of time.
A literature review was done to assess the different research that had already been
done on the topic. Google Scholar was utilized, where the period of the literature
searched was from 2005 to 2016. The terms used for the search included home
automation, sensor actuator, sensor network, raspberry pi, wireless sensor, internet
of things, and smart home security.
The implementation of the mock up system involved purchasing and acquiring all
the required parts, setup of the central server, electronic setup of the Raspberry Pi’s
so the sensors could interface with them, network connectivity, software setup of the
Raspberry Pi’s, and then testing/refining of the system.
Evaluation of the mock up system began with making sure the Raspberry Pi’s were
sending data to the central server for data logging. Once that was working properly,
the garden watering Pi was activated to periodically check the soil moisture sensor
and start a water pump to water some plants if the soil moisture sensor determined
the soil was dry. Different time durations that the water pump would be activated were
3
tested for optimal plant watering effectiveness. The NFC garage door opener was also
tested to make sure the garage door opened when an authorized NFC tag was in
proximity of the NFC reader attached to the NFC garage door opener Pi. Once the
sensor and activity data from the Raspberry Pi’s was being sent to the central server,
multiple devices were used to view the web interface on the central server to view the
system activity over time. Feedback from a sample user and myself was then used to
fine-tune the system for better usability.
1.4 Research Contribution The project work completed resulted in a working smart home and garden
automation system utilizing open source software that involved a central server, an
automatic garden watering system, and a NFC garage door opener. The central server
stored a log of system activity, authorized users, and was accessible from a web-
enabled device such as a smartphone or laptop computer. The Raspberry Pi nodes
on the WPA2 encrypted wireless network were set up with electronic sensors wired to
the GPIO pins on the Raspberry Pi devices to read sensor information, and power
cycle relays to perform actions such as turning on a water pump and open a garage
door.
The project scope and requirements were defined and laid out accordingly in a
diagram. One of the basic ideas of this project was to use open source hardware and
software that was easily available. Afterward, the system was developed using a
methodology similar to the incremental approach where the project is broken down
into smaller sections so the smaller increments could be completed before proceeding
4
to the next part of the project. The system was developed using open source hardware
and software so future development could be continued by other parties without
having to worry about possible intellectual property issues. Documentation for the
hardware and software setup, and source code for all parts of this project was
produced to allow others to recreate and improve on what was created in this project.
As the mock-up system was being built, many tests were done to see what
configurations worked best. For example, the automatic garden watering Pi had to be
adjusted multiple times so the pump would run long enough so that the plants would
be watered enough.
1.5 Research Limitations Due to the limited amount of time and resources available to this project, certain
limitations had to be in place so it could be completed in a reasonable amount of time.
For example, the types of Raspberry Pi devices and the features they provided in the
project had to be chosen so the project could be completed in time.
Two Raspberry Pi’s were implemented instead of the originally envisioned four, and
the central server was limited to only collecting and displaying data in a web interface.
The original database software on the central server was supposed to be PostgreSQL,
but MySQL was utilized instead because the data being stored was not complex and
large enough to require the more advanced PostgreSQL database management
system.
5
If there was more time available, more features could have be added to the project
system. For example, the web interface on the central server could be set up to be
able to trigger certain features on the Raspberry Pi nodes set up such as turning on
the garden water system for a certain amount of time or open a garage door. Two-
way communication between the server and Raspberry Pi devices would be an
additional feature that could be an improvement to the system so the Raspberry Pi
configurations could be altered without having to directly connect to each individual Pi
device. In addition, a larger audience could also have been chosen where the project
was implemented at more than one household to get more feedback to further improve
the automation system.
6
DEFINITION OF TERMS
NFC – Near Field Communication is a set of protocols that allows wireless devices in
close proximity (10cm or less) to communicate using radio communication. These
wireless devices could include smart phones, cards, fobs, or even stickers.
WLAN – Wireless Local Area Network. This is a network of two or more devices using
wireless radio communication commonly used in a home or office environment in the
2.4Ghz/5Ghz radio band.
IEEE – Institute of Electrical and Electronic Engineers. Organization with the goal of
technical innovation for humanity through publications, conferences, and setting
industry standards.
802.11 – Set of specifications by the IEEE standards committee for implementation of
wireless local networks (WLANs).
802.3 – Set of specifications by the IEEE standards committee for implementation
physical communication in a local area network (LAN).
ACID – Atomicity, Consistency, Isolation, Durability. There four terms are a set of
properties that are meant to guarantee database transactions are reliably processed.
Atomicity – Database property used to mean that transactions are processed
completely (affecting a change of the database) or not at all.
Consistency – Database property that means that any transactions will take the
database from one state to another while being valid based on the rules defined using
constraints or other methods.
7
Isolation – Database property used to describe how transaction integrity is visible to
other concurrent users/systems. This is to handle situations such as when a user is
updating data while others are pulling from the same database.
Durability – Database property which is mean to guarantee that committed
transactions will be permanent even in the event the system crashes. For example,
some database management systems write transactions to a log so that the system
state can be recreated to the point right before system failure.
8
CHAPTER 2 – LITERATURE REVIEW RELATED WORK
In recent years, there has been a visible increase in interest regarding networked
home automation systems for consumer use. An automated home can simply be a
grouping of controls or be heavily automated in which anything plugged into electrical
power can be controlled or monitored (Karu, 2010). According to Haghighi & Cliiff
(2013), “a wireless sensor network is a collection of small and embedded devices
scattered across an environment for monitoring environmental parameters or
observing phenomena of interest”.
CURRENT RESEARCH
2.1 Closed Loop Control and Sensory Systems General sensor based close loop control is a system where one or more behaviors
or states are sensed, and a controller uses those sensor readings to adjust/maintain
a system to a desired state. It involves a few components including a measuring
element, controller, and process. An diagram of a closed loop system is shown below
in Figure 1.
9
Figure 1. Closed Loop System
In Figure 1 above, a controller uses data from a measuring element to control a
repetitive process where a constant state is attempted to be achieved/maintained via
a process controlled by the controller with a signal. The measuring element/sensor is
used to provide an input to the controller and to measure the output of the process so
the controller can perhaps fine tune the process to help achieve the desired state of
the system.
The controls/sensors can be combined together with actuators to be used in a
variety of applications in the area of feedback control systems (Gauger, Minder,
Marron, Wacker, & Lachenmann, 2008). The feedback control systems can be then
used to perform actions resulting in being able to minimize resource or energy usage,
instead of earlier home and garden automation systems where sensor inputs were
available from the system but nothing could be done with that information
automatically since output/actuator options were minimal.
2.2 Sensors and Sensory Systems Energy, resource savings, or other benefits can be realized using information from
sensors that provide information regarding environmental factors such as occupancy,
10
time of day, temperature, and demand levels (Kailas, Cecchi, & Mukherjee, 2012). For
example, lights can be set to turn off if an occupancy sensor concludes there is no
one in the room after a pre-determined amount of time, or the temperature of the
climate controlled environment can be lowered if no one is present. User habits such
as what time they usually go to work and when they return can be used to
automatically turn on air conditioning or heating so that the user returns to a home
that is already at their preferred temperature. The lighting under the control of the
automation system can also be configured to turn the lights on and off automatically
when people in the house go on vacation (Woodruff, Augustin, & Foucault, 2007) to
give the illusion if there were people at home to help reduce the risk of break ins.
These home and garden automation systems can be used for other purposes other
than reducing energy usage and making daily life more convenient. They can also be
used for potentially lifesaving purposes. Patients, elderly, or disabled citizens could
utilize wearable wireless sensors that could monitor heart rate, temperature, or other
factors (Gomez & Paradells, 2010). If certain sensor thresholds are passed, the proper
medical assistance could be summoned to the home. The sensor data collected
periodically can also be used by doctors as a diagnostic aid (Sriskanthan, Tan, &
Karande, 2002). These wearable wireless sensors could also include a way for the
people wearing them to signal for help if they are unable to get up after a fall or are
even partially paralyzed.
In addition to medical sensors, smoke and carbon monoxide detectors installed
around the home could automatically alert the fire department if alarm levels are
triggered in the event that people in the home are not able to do so in a timely manner
11
such as if they are incapacitated. Intrusion sensors such as glass breakage or
door/window sensors could also alert the people in the house of possible intruders
and their location. Another possible sensor that could be very useful for people is a
sensor that is able to monitor if a stove is on. If the stove is left turned on exceeding a
certain period of time, notifications could be sent to all people living in the house via
email, text message, or some other method (Harmo, Taipalus, Knuuttila, Vallet, &
Halme, 2005). This could help prevent dangerous situations that could result from a
stove being left on for too long such a house fire.
Another great example of the benefits from the application of these automated
systems is that they can be used to increase production output rates of agricultural
products such as tea. Compared to traditional manual methods, by constantly
monitoring/maintaining the temperature, humidity, and pH when producing Pu’er tea,
they are able to halve the fermentation time and increase the stability of the product
quality (Yang, Tang, Shi, Ning, & Wang, 2013).
2.3 The Control and Computation Unit - Raspberry Pi Sensor/actuator nodes in a smart home and garden system will need computing
power to process and perform their functions. Instead of using custom designed
computers with proprietary operating systems, it may be better to use an already
widely available module. The Raspberry Pi is a revolutionary single board computing
device that may change the way education and technology are used in our society,
and is a cheap way to get access to cheap programmable computers (Dawson Jr, Al
Saeed, Wright, & Onyegbula, 2014). It has been proven to be a smart, economic, and
12
efficient platform for implementing home automation (Jain, Vaibhav, & Goyal, 2014).
This is partly due to its GPIO (General Purpose Input Output) pins, which allow for
automated data acquisition, producing of simple digital control systems, and
interfacing with general purpose electronics. Each GPIO pin can be programmed to
act as an input or output. The Raspberry Pi’s small size, relatively low power
requirements, and other built in interfaces also make it a good candidate for this
project. The product is now in its third generation with more computing power and
memory than its predecessors.
There are many different kinds of electronic sensors and actuators that are
compatible with the GPIO pins such as motion or infrared. As an example, when a
motion sensor detects someone intruding into an area, the sensor circuit could be
configured to launch a triggered signal to the GPIO. As a result of receiving the
interrupt signal from the sensor being triggered, the system can be configured to begin
capturing real-time images and initiate video streaming (Bai & Teng, 2008). Other
examples of electronic sensors compatible with GPIO pins include temperature, touch,
sound, and humidity. Input from these sensors can be used to trigger other GPIO pins
to control or trigger larger electronic circuits that could include LED lights, relays, or
even motors.
Python is the main programming language for Raspberry Pi’s (Jain, Vaibhav, &
Goyal, 2014). There are adapters to allow Python to interface with other systems such
as databases. For example, an adapter that allows Python to interface with the
PostgreSQL database system is called Psycopg. PostgreSQL is an object-relational
database management system that can be run on many different operating systems.
13
It is ACID compliant, open source, has multiple API’s, and is extensible among many
other features (Douglas & Douglas, 2003).
A potential solution to the problem of the currently available expensive or time
consuming to implement home and garden automation systems is to use affordable
single board computers that have input output capabilities. This could mean a cheaper
way of implementing wireless sensors on a common IP based network that is already
available in homes with an internet connection could be developed, along with
documentation on how to it was done so others can use the technology for their own
custom applications or even develop it further. Additionally, the use of the IP based
networks commonly installed in home networks with internet connections nowadays
should minimize the infrastructure required for a home automation system such as
wiring and network controllers (Gauger, Minder, Marron, Wacker, & Lachenmann,
2008).
Raspberry Pi 2 devices in a sensor network environment are a perfect platform for
interfacing with a wide variety of peripherals especially since they have the processing
power of a personal computer (Maksimović et al., 2014). Also, when comparing them
to other available single board computers as shown in Table 1, we see that it the
Raspberry Pi 2 is actually very affordable.
14
Name Size (mm) Weight (g) Cost per node US $*
Raspberry Pi 85.6 x 53.98 x 17
45 35
Arduino (Uno) 75 x 53 x 15 ~30 30
BeagleBone Black
86.3 x 53.3 39.68 45
Phidgets 81.3 x 53,3 60 50-200
Udoo 110 x 85 120-170 99-135
Table 1. Comparison of Platforms, Size, Weight, and Cost Note. From Raspberry as Internet of Things Hardware: Performances and
Constraints. Copyright 2014 by Maksimović et al. Reprinted with permission.
The Raspberry Pi 2 is able to run a number of different operating systems, including
a Debian based open source Linux operating system that is optimized for Raspberry
Pi 2 devices called Raspbian. They are equipped with multiple interface pins, which
allow them to have many different inputs/outputs assigned to them to handle various
functions such as turning on a circuit or communicating with sensors in a home and
garden smart home system scenario. These second generation single board
computers have a footprint of a credit card (Maksimović et al., 2014). They come
equipped with a 900Mhz quad core ARMv7 processor, 1GB of RAM, 4 USB ports, 40
GPIO pins, Ethernet, HDMI, as well as several other interfaces for items such as a
camera or touchscreen.
There is even the opportunity to implement these devices so they do not require
power from the main electrical grid to function. This can be likely achieved using solar
15
panels in combination with a small 5-volt battery, but further investigation is necessary
and most likely beyond the scope of this current project.
Using Raspberry Pi 2 devices, this project will create an affordable wireless sensor
network in a smart home and garden automation system that has the ability to
communicate with a central server to store information in a database. Users can
connect to this central server which has the Apache web server hosting a HTML web
interface, by using an internet browser on their computer or mobile device to be easily
able to monitor in real time a large number of sensors easily. They will also be able to
view previously archived information to see possible trends over time.
Having a centralized server design gives certain benefits. Since the web
application and database on the central server run on different service processes, they
can work independently of each other. In this case, the web application can be
updated without impeding the Raspberry Pi sensor nodes from uploading information
into the central database. This kind of design makes future revision or customization
of the system easier because overall system downtime is reduced (Ferdoush, & Li,
2014). Furthermore, the central server reduces the amount of functionality design
required for each Raspberry Pi so that each node does not need to store its own
sensor data or require their own web interface. Reducing duplicate functionality at
each node simplifies design so that troubleshooting problems is made easier.
Being able to easily monitor a large number of variables such as moisture levels in
soil, and then setting parameters for automatic watering for example, might allow us
to save water by only watering plants when absolutely necessary. Overall, the goal of
16
this kind of system is to make our lives more convenient by reducing the effort required
for various workflow processes that we may encounter in our everyday lives.
2.4 The Communications Link – Wireless Sensor Network and the Internet To reduce the number of standards and protocols required for such a system, many
consumer home automation systems utilize the already widely available 802.3 or
802.11 IP based wired/wireless networks and internet connections already installed in
many homes to help reduce costs. In doing so, this allows many of our IP based
devices to be able to easily integrate and communicate with the home automation
systems. For example, our smart phones and tablets can communicate using the IP
network to the sensors in a home network. Clients accessing the system can use the
HTTP/HTTPS web browsers that are installed on their computers or mobile devices.
Designing a home automation system to use these 802.3 wired and 802.11
wireless networks allows for easier placement of automation devices where network
cabling may not be feasible making it easier to relocate devices due to the fact that
relocation doesn’t always necessarily require additional cabling to be done (ElShafee,
& Hamed, 2012). Installation of additional access points or repeaters can be used to
provide more range and scalability for the network if required.
Even though there are more and more consumer available home automation
systems, there are four potential challenges to increasing adoption of these systems.
These four challenges include high cost of ownership in time and/or money,
inflexibility, poor manageability/ease or use, and difficulty achieving security (Brush et
al., 2011).
17
There are two causes that can result in high cost of ownership whether it is time
and/or money for home automation systems. One such cause is implementing closed
systems that provide a high level of integration and usability, but require a large cost
investment. The other cause is using cheaper devices in home automation that could
possibly be originally parts of separate disparate systems, and spending more time
attempting to integrate them together into a singular system. Costs for an installed
home automation system can range from a few hundred dollars for a basic lighting
system to hundreds of thousands depending on the level of automation required
(Robles, Kim, Cook, & Das, 2010). It should also be noted that the cost of installing
certain sensors or devices for a home automation system can be costly especially if it
is done after a house has already completed construction (Brush et al., 2011).
Ongoing monetary costs such as electricity and maintenance costs should also be
considered (Karu, 2010).
Inflexibility or Inoperability of the system is referring to the capability for different
device types from different manufacturers to communicate with each other (Delgado,
Picking, & Grout, 2006). It can be a challenge for home automation systems. Since
they are designed by different companies, compatibility between the different systems
can be very low if there is any at all. However, the use of IP networks with secure
HTTPS communication allows for reuse of components and interoperability with other
applications, while also allowing users to continue using their familiar devices instead
of having to create proprietary solutions (Kovatsch, Weiss, & Guinard, 2010). Devices
that are familiar to potential users can include computers or mobile devices such as
18
laptops or Android tablets. It is also very important to note that network security has
to be a considered during the design process.
The ease of use in a system is a key factor in whether home automation systems
have an increasing user base. If a user has to spend a large amount of time to learn
how to use a system that isn’t intuitive, this will obviously hinder the sales and further
development of these kinds of systems. Most homes will have more than one person
living in them, customizing the home automation for each user is a good way to
improve ease of use. An example of this is using NFC tags that would be attached to
keychains so the system could identity who is approaching the front door
(Maternaghan, & Turner, 2010). Their identification would be use to perform different
workflows such as having different lights turn on/off or vary in brightness, or even
change the temperature of the house among other possible parameters.
Security as always is a concern to any system being built. Home and garden
automation systems are no exception. If a large amount of sensors and actuators are
deployed, a hacker gaining access to all this data and being able to control parts or
all of a house would be very dangerous. User, network, and device security all have
to be considered in this kind of system especially since almost all of these automation
systems can be connected to the internet. IP networks including home networks as
well as the internet already have well established security schemes like firewalls and
SSL/TLS (Kovatsch, Weiss, & Guinard, 2010), so that can be used as a good baseline
to start building security models.
Wireless network security can be fortified by requiring at least WPA2 encryption
levels with a strong and appropriately lengthy security key, but wireless signal
19
coverage should be taken into account. Directional antennas can be used to limit the
size of the exposed wireless network and defend against wormhole attacks (Walters,
Liang, Shi, & Chaudhary, 2007). User security can be handled via strong password
requirements.
Device security is involved on a physical and software level. Physical device
security is basically making sure devices are not too easily accessible by nefarious
people. Software security is making sure the software running on the sensor/actuator
nodes cannot be easily circumvented. Linux is a popular option for this kind of
application because it is flexible, stable, network friendly, and has built in security
management features (Mishra, & Goyal, 2014). Software security updates for Linux
are constantly being released.
Further software security measures such as prevention of denial of service attacks
from both the internal and external network can be done using a package that can be
installed if not already called “fail2ban”. Using its own internal mechanism known as
“jails”, it essentially utilizes filters implemented based on obvious threats (brute force
over SSH, flooding over apache, etc.) and over a user-set period of time (default
period is several minutes long), bans offending IP addresses for the duration after it
gets caught by Fail2ban via IPTables directives packaged with the program (Adler et
al., 2014).
Despite the various difficulties in setting up such systems, they provide multiple
benefits to their users. These benefits include better ease of mind to their users, eco-
friendliness, lower energy/resource costs, and can contribute to the public good by
using less of the earth’s resources (Kailas, Cecchi, & Mukherjee, 2012).
20
2.5 Internet of Things While there is no universal definition for the Internet of Things (IoT), the core
concept is that everyday objects can be equipped with identifying, sensing,
networking, and processing capabilities that will allow them to communicate with one
another and with other devices and services over the Internet to achieve some useful
objective (Whitmore, Agarwal, & Da Xu, 2015). The applications for IoT devices are
diverse and new uses are continually being developed. In the smart home or building
area, intelligent thermostats and security systems are receiving a lot of attention, while
smart energy applications focus on smart electricity, gas and water meters (Wortmann
& Flüchter, 2015).
Smart home appliances of all varieties are emerging in the market, and CISCO VNI
predicts that Internet-Of-Things (IoT) connections will grow 43% each year, rising from
341 million globally in 2013 to 2 billion by 2018 (Sivaraman, Gharakheili, Vishwanath,
Boreli, & Mehani, 2015). Users of a home automation system can utilize these IoT
devices to control environmental settings such as light, heating, or sound. By using
IoT devices, these environmental settings can even be controlled remotely. The
automation of home settings to act according to the inhabitant requirements is termed
as an intelligent home automation system (Kelly, Suryadevara, & Mukhopadhyay,
2013).
There are small computer systems that have been developed to support IoT
prototyping such as the Raspberry Pi. These Raspberry Pi devices are used in
commercial products such as Ninja Blocks, and are available for purchase for building
21
smart environments. Furthermore, most electronic platforms such as Arduino can
successfully work with Raspberry Pi computers (Perera, Liu, Jayawardena, & Chen,
2014). The Raspberry Pi is useful for small application development because it can
be used to integrate many components such as speakers, LED lights, sensors,
cameras, and wireless communication units to develop smart applications (Zhao,
Jegatheesan, & Loon, 2015).
22
CHAPTER 3 – DESIGN OF THE SYSTEM
In this scenario, multiple Raspberry Pi 2 devices were set up that are able to
communicate sensor information on an IP based wired/wireless network to a central
server. These sensors were set up to be used at a home based farm with a medium
overall land size where monitoring would be useful. The farm in this scenario doesn’t
have internet access yet so the prototyping was done at my home.
3.1 The System Overview Due to the large number of possibilities for the different kinds of sensors that could
be done in this home and garden scenario, it was a good idea to limit the number
sensors/devices being implemented so this project could be completed in a timely
fashion. The Figure (2) below is the overall system layout that was implemented.
23
Figure 2. System Conceptual Diagram
3.2 The Sensor Based Sub-Systems The first sensor to be implemented was a NFC controlled garage door opener.
Users would be able to use an NFC tag that would be attached to their keychain to
open the garage door from the outside of the house. Each time a NFC tag was
detected by the sensor, a log entry containing the date and NFC tag ID would be sent
to the central server. The software block diagram for this sensor is shown below in the
Figure (3).
25
The second device implemented was an automatic garden watering system that
took a number of sensor readings into account. These sensors included temperature,
humidity, light, and soil moisture levels. The software block diagram for the sensor is
shown below in the Figure (4).
Figure 4. Automatic Garden Watering System Software Block Diagram
26
3.2 Programming Language, Development Environment, and Database The development environment for the Raspberry Pi 2 devices was in Linux and utilized
the Python or Perl programming languages (Pi, 2013). The Python adapter MySQLDB
was used to send sensor data from each Raspberry Pi node to a MySQL database
management system.
Sensor data collected from the different nodes would be stored on a central server
on the network. The central server to store current and historical sensor information
would require one computer. For this project, the Linux central server was hosted in a
virtual machine on an older laptop. The central server also hosted a website for easy
viewing of the sensor information. The sensor data was collected in a MySQL
database on the Ubuntu Linux central server virtual machine. The database tables
were organized as shown below in Figure (5).
27
Figure 5. Database Design
Data viewing/analysis was set up to be viewed via a web-based interface hosted on
the server so the information could be observed from a user’s computer or mobile
device. The HTML and PHP interface was hosted using the commonly used Apache
HTTP server. Having current and historical information from the sensors available
allowed for trend analysis or optimization of automation workflows as shown below in
the Figure (6).
28
Figure 6. Historical Garden Temperature Chart
3.4 The Wireless Sensor Network and Raspberry Pi Configuration Network security was a consideration of this project. Basic wireless network
security would require WPA2 encryption with a strong security key, but there are other
points where security had to be considered. Other points of consideration included
how to handle remote access from outside the local network. User security was
handled via strong password requirements. User access to the server would require
HTTPS network encryption so a SSL certificate was used on the Apache server.
Configuration of the central server and Raspberry Pi 2 devices would also require
application of the latest security updates as well as only opening ports on the local
firewall as required. The services set up to run on each Raspberry Pi 2 and the central
server would also have to be reduced to a minimum level. The database was set up
with users that have strong passwords as well and the passwords were encrypted.
3.5 The System Cost Since the software used for this project is open source, the monetary costs were only
for the hardware required. Below is a listing (Table 2) of the required hardware costs
in Canadian dollars at the time of project implementation.
29
Hardware Quantity Cost Per
Unit
Total Cost ($)
Raspberry Pi 2 Model B 2 44.95 89.90
NFC fob 2 2.95 5.90
Pi Starter Pack 1 65.95 65.95
Pi Workshop Kit 1 24.95 24.95
NFC Board 1 48.13 48.13
Weatherproof Enclosure 1 42.12 42.12
Lexar 16GB MicroSD Memory Card 2 22.39 44.78
Temperature/Humidity Sensor 1 8.57 8.57
Pi GPIO Expansion Board 2 3.80 7.60
Pi X300 Expansion Board 2 40.90 81.80
Pi Soil Moisture Sensor 1 2.16 2.16
Relay modules 2 7.99 15.98
Sales Tax (12%) 52.54
Grand Total $490.38
Table 2. Project Costs
Note: The costs listed above include shipping and sales tax. The sales tax applied is 5 percent Government Sales Tax (GST) and 7 percent Provincial Sales Tax (PST), for a total of 12 percent.
30
CHAPTER 4 – DISCUSSIONS STATEMENT OF THE CHARACTERISTICS, STRENGTHS, AND
LIMITATIONS
During the implementation phase of the project, multiple characteristics both good
and bad became apparent. The level of customizability of the Raspberry Pi’s is very
high, which allows for many different ways of implementing a feature. Utilizing open
source hardware and software also alleviated any worries about software licensing or
intellectual property issues. In addition, the low cost of the parts used for the project
did not require significant financial investment.
Despite the strengths of the project requirements, there are some limitations worth
noting. The first limitation of the high level of customizability of the Raspberry Pi’s is
that to develop new features, there is some learning involved both in the Python
programming aspect as well as having some basic knowledge on wiring electronic
parts together. There were other difficulties encountered during the implementation
phase to be aware of. There was one defective Raspberry Pi that had to be replaced,
a memory card that got corrupted and was also replaced, and an NFC tag electronic
board that wasn’t interfacing properly with a Raspberry Pi. The NFC board was
replaced with a completely different model and that resolved the issue.
Feedback from the project participants including myself, my dad, and my friend
Deven were similar and included several comments. We all found the initial set up of
the system straightforward with the documentation I created, but somewhat time
consuming. In the future, setup scripts or entire disk images for the Raspberry Pi’s
would greatly reduce the time required for setup. Assembling the electronic sensors
31
and components with the Raspberry Pi’s also needed some basic electronic
experience. There was plenty of documentation on how to do this online though.
Once the system was set up, they were able to access the central server using a
computer or their mobile device and view the collected information from the Raspberry
Pi’s. They found the information presented in the web interface with tables and graphs
beneficial, and the functionality of the Raspberry Pi’s useful as well.
We all noted that it would be great to be able to modify the parameters of the
functions of the different Pi’s without modifying the Python program source code
located on each Raspberry Pi. This could possibly be done on the central server in
the future. One of the test subjects in particular said it would be beneficial if he could
manually trigger the garden watering Pi so he could water the garden remotely
whenever he wanted to.
STATEMENT OF FUTURE DEVELOPMENT
Functionally speaking, the project implementation was finished. The Raspberry
Pi’s were set up and reading their sensor inputs and providing data to the central
server as needed. The central server web interface was also accessible to users on
their computers or mobile devices. There are however, some problems that could be
resolved in the future to further improve the system.
More documentation or premade setups should be created so beginners could
implement the design. This could include videos, diagrams, tutorials, and also having
32
interested people being able to purchase the Raspberry Pi devices preconfigured so
they are almost ready to go out of the box.
Another problem that could be resolved to further improve the system is to revise
the design so the user is able to manually trigger the actuators of the system. For
example, the user would be able to trigger the garage door opener so they can open
it from an interface on their mobile device instead of having to use a NFC tag.
33
CHAPTER 5 – CONCLUSIONS AND RECOMMENDATIONS CONCLUSIONS
The purpose of this project was to implement and home and garden automation
system with an interface that is easy to use, affordable, and utilize open source
hardware/software. In those terms, that purpose was fulfilled. Feedback from the
people testing the system indicated they had no problem using the system’s web
interface, it did not require significant financial investment, and it did utilize open
source hardware and software so further development of the system by others will not
infringe on any intellectual property issues. Their feedback also indicated that they
liked the functionality of the system and will keep using what was implemented.
SUGGESTIONS FOR FURTHER RESEARCH
Future research can expand the scope and functionality of this project. Further
improvements could be made to the design to allow for even easier installation and
use of the system. Opportunities to make it easier could include more detailed
instructions or videos on how to install the different parts of the system, or even making
preassembled parts available.
The system design could also be expanded to allow for customization of the
parameters before certain actions are taken. For example, instead of modifying the
python program file on the automatic watering Pi to determine when to start watering
of the garden based on certain sensor readings, the Pi could be configured to get that
information from the central server. There is also the opportunity in the future to set
34
up the Raspberry Pi computers so the parameters could be modified from a mobile
device application.
The system could also be expanded to include more Raspberry Pi’s that perform
even more functions so it can become even more of an integrated smart home system.
Suggestions for the expanded functions of the Raspberry Pi’s could include a video
doorbell answering system, automatic hallway lighting, ambient room lighting controls,
security camera monitoring, and many other possibilities. In addition, since the
Raspberry Pi’s have wireless capability, the combination of batteries and solar panels
could make them truly wireless both for network and power connections.
Overall, this project allows for several conclusions. There is definitely potential to
create and further develop an easy to use smart home and garden automation system
using open source hardware and software that is integrated together on a commonly
available home 802.11 wireless network. Further development of the system will
require people with at least some experience with electronics and the Raspberry Pi
Python programming language. However, after the initial development is done there
can be detailed documentation and other ways to make it easier for less experienced
people to implement the design at their own homes. In addition, the affordable cost
and high level of customization possible with the Raspberry Pi devices makes it
appealing for use in the automation computing tasks of these kinds of systems.
35
REFERENCES
1. Kaur, I. (2010). Microcontroller based home automation system with security.
International journal of advanced computer science and applications, 1(6), 60-
65
2. Brush, A. J., Lee, B., Mahajan, R., Agarwal, S., Saroiu, S., & Dixon, C. (2011,
May). Home automation in the wild: challenges and opportunities. In
Proceedings of the SIGCHI Conference on Human Factors in Computing
Systems (pp. 2115-2124). ACM.
3. Kovatsch, M., Weiss, M., & Guinard, D. (2010, September). Embedding internet
technology for home automation. In Emerging Technologies and Factory
Automation (ETFA), 2010 IEEE Conference on (pp. 1-8). IEEE.
4. Gauger, M., Minder, D., Marron, P. J., Wacker, A., & Lachenmann, A. (2008,
April). Prototyping sensor-actuator networks for home automation. In
Proceedings of the workshop on Real-world wireless sensor networks (pp. 56-
60). ACM.
36
5. Kailas, A., Cecchi, V., & Mukherjee, A. (2012). A survey of communications and
networking technologies for energy management in buildings and home
automation. Journal of Computer Networks and Communications, 2012.
6. Jango, J. (2015, February 3). It’s tooltime!: Secure your Raspberry Pi.
Retrieved May 8, 2015, from http://jjjjango.blogspot.co.at/2015/01/secure-your-
raspberry-pi.html
7. Pi, R. (2013). Raspberry Pi. Raspberry Pi 1 HDMI 13 Secure Digital 34
Universal Serial Bus 56 Python (programming language) 84, 1.
8. Bell, C. (2013). Beginning Sensor Networks with Arduino and Raspberry Pi.
Apress.
9. Walters, J. P., Liang, Z., Shi, W., & Chaudhary, V. (2007). Wireless sensor
network security: A survey. Security in distributed, grid, mobile, and pervasive
computing, 1, 367.
10. Maksimović, M., Vujović, V., Davidović, N., Milošević, V., & Perišić, B. (2014).
Raspberry Pi as Internet of Things hardware: Performances and Constraints.
design issues, 3, 8.
37
11. Calka, C. (2014). Ambient Home Server: Location Aware Home Automation.
12. Haghighi, M., & Cliff, D. (2013, July). Multi-Agent Support for Multiple
Concurrent Applications and Dynamic Data-Gathering in Wireless Sensor
Networks. In Innovative Mobile and Internet Services in Ubiquitous Computing
(IMIS), 2013 Seventh International Conference on (pp. 320-325). IEEE.
13. Yang, L. L., Tang, X. Y., Shi, J., Ning, W. Y., & Wang, Q. (2013, October).
Status and development trends of Pu'er tea industrial mechanization and
automation. In Advanced Materials Research (Vol. 756, pp. 4681-4684).
14. ElShafee, A., & Hamed, K. A. (2012). Design and Implementation of a WiFi
based home automation system. World academy of science, engineering and
technology, 68, 2177-2180.
15. Robles, R. J., Kim, T. H., Cook, D., & Das, S. (2010). A review on security in
smart home development. International Journal of Advanced Science and
Technology, 15.
38
16. Maternaghan, C., & Turner, K. J. (2010, January). A component framework for
telecare and home automation. In Consumer Communications and Networking
Conference (CCNC), 2010 7th IEEE (pp. 1-5). IEEE.
17. Mishra, M. K., & Goyal, D. (2014). Security Analysis in Open Source Linux
Network. International Journal of Computer Science and Network Security
(IJCSNS), 14(8), 63.
18. Dawson Jr, M. E., Al Saeed, I., Wright, J., & Onyegbula, F. (2014). Open
Source Software to Enhance the STEM Learning Environment.
19. Adler, J., Cuiffo, E., Desai, P., Rabinowitz, J., Red, V. A., & Parashar, M.
(2014). Capstone Senior Design Project.
20. Jain, S., Vaibhav, A., & Goyal, L. (2014, February). Raspberry pi based
interactive home automation system through e-mail. In Optimization, Reliabilty,
and Information Technology (ICROIT), 2014 International Conference on (pp.
277-280). IEEE
21. Bai, Y. W., & Teng, H. (2008, August). Enhancement of the sensing distance
of an embedded surveillance system with video streaming recording triggered
by an infrared sensor circuit. In SICE Annual Conference, 2008 (pp. 1657-
1662). IEEE.
39
22. Dargie, W. W., & Poellabauer, C. (2010). Fundamentals of wireless sensor
networks: theory and practice. John Wiley & Sons.
23. Douglas, K., & Douglas, S. (2003). PostgreSQL: a comprehensive guide to
building, programming, and administering PostgreSQL databases. SAMS
publishing.
24. Maksimović, M., Vujović, V., Davidović, N., Milošević, V., & Perišić, B. (2014)
[Table]. Raspberry Pi as Internet of Things hardware: Performances and
Constraints. design issues, 3, 8.
25. Gomez, C., & Paradells, J. (2010). Wireless home automation networks: A
survey of architectures and technologies. IEEE Communications Magazine,
48(6), 92-101.
26. Sriskanthan, N., Tan, F., & Karande, A. (2002). Bluetooth based home
automation system. Microprocessors and Microsystems, 26(6), 281-289.
27. Harmo, P., Taipalus, T., Knuuttila, J., Vallet, J., & Halme, A. (2005, August).
Needs and solutions-home automation and service robots for the elderly and
disabled. In Intelligent Robots and Systems, 2005.(IROS 2005). 2005
IEEE/RSJ International Conference on (pp. 3201-3206). IEEE.
28. Woodruff, A., Augustin, S., & Foucault, B. (2007, April). Sabbath day home
automation: it's like mixing technology and religion. In Proceedings of the
40
SIGCHI conference on Human factors in computing systems (pp. 527-536).
ACM.
29. Delgado, A. R., Picking, R., & Grout, V. (2006). Remote-controlled home
automation systems with different network technologies.
30. Ferdoush, S., & Li, X. (2014). Wireless sensor network system design using
Raspberry Pi and Arduino for environmental monitoring applications. Procedia
Computer Science, 34, 103-110.
31. Wortmann, F., & Flüchter, K. (2015). Internet of things. Business &
Information Systems Engineering, 57(3), 221-224.
32. Whitmore, A., Agarwal, A., & Da Xu, L. (2015). The Internet of Things—A
survey of topics and trends. Information Systems Frontiers, 17(2), 261-274.
33. Sivaraman, V., Gharakheili, H. H., Vishwanath, A., Boreli, R., & Mehani, O.
(2015, October). Network-level security and privacy control for smart-home
IoT devices. In Wireless and Mobile Computing, Networking and
Communications (WiMob), 2015 IEEE 11th International Conference on (pp.
163-167). IEEE.
34. Kelly, S. D. T., Suryadevara, N. K., & Mukhopadhyay, S. C. (2013). Towards
the implementation of IoT for environmental condition monitoring in homes.
IEEE Sensors Journal, 13(10), 3846-3853.
41
35. Perera, C., Liu, C. H., Jayawardena, S., & Chen, M. (2014). A survey on
internet of things from industrial market perspective. IEEE Access, 2, 1660-
1679.
36. Zhao, C. W., Jegatheesan, J., & Loon, S. C. (2015). Exploring IOT Application
Using Raspberry Pi. International Journal of Computer Networks and
Applications, 2(1), 27-34.
42
APPENDIX A – Setup Manual Preface Notes
1. You will need the files from the project repository which can be found at:
https://drive.google.com/open?id=0B2XHCkDOmP7Jb3U4MGhqZEJQd0E
OR download a compressed zip file with all the files included at this link:
2. https://drive.google.com/open?id=0B2XHCkDOmP7JemNpM1FtLVQtcGs
3. You will need to set the IP addresses on your network for the central server
VM and the Raspberry Pi’s to not change. This is achievable through
manually setting them through the VM and Pi settings but I chose to do this
through my home internet router by reserving IP addresses for them. Take
note of these IP addresses as you will need them throughout the project
setup process.
4. The SSL certificate used for secure HTTPS access to the central server VM is
self-signed, if this were a publicly accessible site, a signed certificate, which
would involve more setup should be utilized.
Useful Links • https://learn.adafruit.com/adafruit-raspberry-pi-lesson-1-preparing-and-sd-
card-for-your-raspberry-pi
• https://learn.adafruit.com/adafruits-raspberry-pi-lesson-2-first-time-
configuration
• https://learn.adafruit.com/adafruits-raspberry-pi-lesson-3-network-
setup/setting-up-wifi-with-occidentalis
43
• https://learn.adafruit.com/adafruits-raspberry-pi-lesson-4-gpio-setup/overview
• http://www.suptronics.com/xseries/x300.html
• https://www.digitalocean.com/community/tutorials/how-to-install-linux-apache-
mysql-php-lamp-stack-on-ubuntu-16-04
• https://www.digitalocean.com/community/tutorials/how-to-install-and-secure-
phpmyadmin-on-ubuntu-12-04
• https://atinkerersblog.wordpress.com/2014/01/15/updating-the-system-time-
on-a-raspberry-pi/comment-page-1/
• https://learn.adafruit.com/dht
• https://learn.adafruit.com/raspberry-pi-nfc-minecraft-blocks/hardware-wiring
• https://help.ubuntu.com/lts/serverguide/certificates-and-security.html
• http://www.instructables.com/id/Raspberry-Pi-Launch-Python-script-on-
startup/
Useful Commands in Linux/Raspbian
There are some terminal commands that can be useful when performing tasks in the
Raspbian operating system software on the Raspberry Pis.
1. gpio readall – Displays the current GPIO setup of all wiring pins
2. gpio mode 1 out – Sets GPIO 0 to an output
3. gpio write 1 0 – Sets GPIO 1 to 0
4. ls – Lists the current directory’s contents
44
5. cd – Changes the directory to the parameter immediately following this
command (eg. cd testfolder)
6. pwd – Shows the current working directory
7. sudo shutdown now – Shuts down the Raspbian operating system software
8. sudo reboot – Restarts the Raspberry Pi
9. passwd – Change the current user’s password
10. sudo apt-get update – Gets list of updates for currently installed software
packages
11. sudo apt-get upgrade – Updates currently installed software packages (this
is to be used after the sudo apt-get update command)
Central Server Setup
1. Using an old machine for this task is fine (I used a Lenovo X220)
2. Fresh install of Windows (Windows 10 Professional was used here)
3. Download and install the latest version of Virtual Box (www.virtualbox.org)
4. Download the Ubuntu Linux disk image (.ISO) from
http://www.ubuntu.com/download/desktop (I used the 14.04 LTS desktop
version because it’s easier to have a GUI (Graphical User Interface) if you are
new to this)
5. Open the Virtual Box application and click on the “New” button that has the
blue gear icon at the top left area of the application. Create a VM (Virtual
45
Machine) in VirtualBox with 1 or 2 processor cores, 2-4GB of RAM, with a
60GB virtual hard drive, and a bridged network adapter.
6. Start the VM with the Ubuntu Linux disk image (.ISO) mounted as a disc drive
(through VirtualBox) and start Ubuntu Setup.
7. Install with installation defaults and pick a username and secure password to
use. Secure passwords should have a mix of uppercase and lowercase
letters, numbers, symbols, and be longer than 7 characters.
8. Setup will restart the VM after completion.
9. Login to Ubuntu and open the “Terminal” program (accessible through top
icon at toolbar on the left side of the VM window)
46
Check for updates for Linux and other installed program packages 10. Type “sudo apt-get update”, and press “return” key on keyboard. You will
be prompted for your password. The sudo command ensures the command is
run with root privileges.
47
11. Type “sudo apt-get upgrade”, and press “return” on keyboard.
Install Emacs editor 12. Type “sudo apt-get install emacs”, and press “return” on keyboard. Note:
You don’t have to do this step if you don’t use emacs as a text file editor.
Install LAMP (Linux Apache MySQL PHP) Server Packages 13. Type “sudo apt-get install apache2”, and press “return” on keyboard. If
prompted, type “Y” to continue installation. This command installs the
apache2 web server.
14. Type “sudo apt-get install mysql-server” and press “return” on keyboard. If
prompted, type “Y” to continue installation. You will be prompted for a
password for the “root” mysql user. Choose a secure password for this. This
command installs the MySQL database server.
48
15. Type “sudo apt-get install php libapache2-mod-php php-mcrypt php-
mysql“, and press “return” on keyboard. This command installs PHP and the
libraries for connecting to MySQL.
16. Type “sudo apt-get install phpmyadmin apache2-utils“, and press “return”
on keyboard. This command installs PHPMyAdmin, which makes it easy to
create and manage MySQL databases in a GUI. If you plan on using this after
the system is running then you should follow the steps to lock it down at the
link https://www.digitalocean.com/community/tutorials/how-to-install-and-
secure-phpmyadmin-on-ubuntu-12-04. Otherwise, PHPMyAdmin should be
uninstalled after the system is running.
Setup SSL for Apache (HTTP Server) 17. For more information on this process, see the link
“https://help.ubuntu.com/lts/serverguide/certificates-and-security.html”
18. In a terminal window (via Putty program remotely or Terminal program on the
central server VM), type the following commands and follow any prompts
(You will need to create a passphrase for the SSL certificate):
sudo a2enmod ssl
sudo a2ensite default-ssl
openssl genrsa –des3 –out server.key 2048
openssl rsa –in server.key –out server.key. insecure
mv server.key server.key.secure
mv server.key.insecure server.key
openssl req –new –key server.key –out server.csr
49
openssl x509 –req –days 365 –in server.csr –signkey server.key –
out server.crt
sudo cp server.crt /etc/ssl/certs
sudo cp server.key /etc/ssl/private
sudo service apache2 reload
sudo service apache2 restart
19. SSL should be working now. Open a browser and navigate to the server
using “HTTPS”. In my project case, this project used https://192.168.1.247.
Note, you may receive a certificate warning in your web browser as we aren’t
using a signed certificate yet so you may want to use http://address-of-your-
server instead for now.
Create MySQL Database in PHPMyAdmin 20. Open a web browser such as Mozilla Firefox on either the server or on your
own computer and navigate to the central server VM. (In my case, the URL I
typed in was http://192.168.1.247/phpmyadmin)
21. Log in with the MySQL root user that you created when you installed MySQL.
22. Click on the “Users” tab at the top of the PHPMyAdmin interface, then click
on “Add User”
50
23. Create a user which the Raspberry Pi’s will use to upload data to the central
server with. For this project, a user “myautomationsql” with the password
“aut0Mat1on8” minus the quotes was created.
Scroll down the choose the following privileges for this database user:
Then click the “Go” button to create the user.
24. Click on the “Import” tab at the top of the PHPMyAdmin interface.
51
25. Click on the “Browse” button and choose the “Central
Server\Database\HomeAutomation.sql” file found in the “Database” folder
of the project repository files.
26. Click on the “Go” button to start the database import.
Load Web Interface Files into Central Server VM 27. Using a program such as WinSCP or Filezilla, copy the central server source
code from the project repository “Central Server\Web Interface” file folder to
the VM using SCP/SSH. The destination path should be “/var/www/html”.
28. Delete the “index.html” file at the “/var/www/html” path on the central server
VM.
52
29. Edit the chart-db.php and db.php file in the “/var/www/html/includes”
folder so the correct address, username, password, and database name of
the server are entered.
$con =
mysqli_connect("192.168.1.247","myautomationsql","aut0Mat1on8","Home
Automation");
30. The web interface on the central server should be ready to use now. Open a
web browser and navigate to the central server (In my example, the URL I
used was http://192.168.1.247). The default web interface username is
“admin”, and the password is “@dm1N#2016$” minus the quotes. It is best to
create another user for yourself as well.
53
Base Raspberry Pi Setup
1. Assemble X300 expansion board by placing it on top of the Raspberry Pi
board as shown on the website http://www.suptronics.com/xseries/x300.html.
2. Download and extract the latest Raspbian operating system for the Raspberry
Pi from https://www.raspberrypi.org/downloads/. (At the time of this writing, it
is Raspbian Jessie)
3. If you are using Windows, download Win32DiskImager from
https://sourceforge.net/projects/win32diskimager/ (There is more
documentation available at
https://www.raspberrypi.org/documentation/installation/installing-
images/README.md)
54
4. Insert memory card into computer. You should see it show up as a drive in
Windows Explorer. Take note of which drive letter the memory card is using.
5. Run the Win32DiskImager program after installation. Note: You will have to
right click on the program icon and choose “Run as Administrator”.
6. Choose the Raspbian image you downloaded in step 1 by click on the folder
icon in the “Image File” area of the program window.
55
7. Choose the drive which is used by the memory card you inserted in step 3 in
the “Device” drop down box of the Win32DiskImager program.
8. Click on the “Write” button to start writing the Raspbian operating system on
to the memory card.
9. After successful completion of the memory card write, unplug the memory
card and insert into the Raspberry Pi.
Things to do after flashing memory card 1. Attach network cable to Pi.
2. Plug power supply cable into Raspberry Pi.
3. Log into your internet router to find IP address of the Pi.
4. Set the IP address for the Pi so it is reserved and will always get the IP
address on the network. Every router is different.
5. Remotely log into the Pi using the Putty program on your computer. The
default username is “pi” the default password is “raspberry”.
6. Change the default password by typing “passwd” and pressing the “Enter”
key.
7. Install the Emacs editor to edit configuration files in later steps by typing the
command “sudo apt-get install emacs“. Note: You don’t need to do this
step if you use a different editor such as Nano or VI.
8. Change hostname on Pi’s
a. 2 files will have to be edited via the commands below:
Sudo emacs /etc/hostname
Sudo emacs /etc/hosts
56
Note: If you are using Emacs, to save the files after you edit them,
press the CTRL and X keys at the same time, release the keys, then
press the CTRL and S keys at the same time. To exit the Emacs
editor, press the CTRL and X keys at the same time, release the keys,
and then press the CTRL and C keys at the same time.
9. Set up wireless if needed (replace NETWORK and PASSWORDHERE with
your wireless network name and password):
a. Type the command “sudo emacs /etc/network/interfaces” minus the
quotes
Auto wlan0
iface wlan0 inet dhcp
wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf
sudo emacs /etc/wpa_supplicant/wpa_supplicant.conf
add network = {
ssid=”NETWORK”
psk=”PASSWORDHERE”
10. Run the command “sudo apt-get update” minus the quotes
11. Run the command “sudo apt-get upgrade” minus the quotes
12. Run the command “sudo apt-get install python” minus the quotes
13. Run the command “sudo apt-get install python-mysqldb” minus the quotes
57
14. Run the command “sudo apt-get install ntpdate” minus the quotes to start
setting up the network time protocol to keep the time and date synchronized
with an external source.
15. Run the command “sudo rm /etc/localtime” minus the quotes.
16. Run the command “ls /usr/share/zoneinfo” minus the quotes.
17. Run the command “ls /usr/share/zoneinfo/America” minus the quotes.
18. Run the command “sudo ln /usr/share/zoneinfo/America/Los_Angeles
/etc/localtime” minus the quotes.
19. Run the command “sudo service ntp restart” minus the quotes.
20. Run the command “date” minus the quotes to verify the date and time are
correct.
21. Run the command “sudo raspi-config”. Use the down/up arrows on the
keyboard to choose “expand_rootfs” and press the “return” key. A
confirmation will be shown after completion to tell the user the filesystem will
be resized after reboot. This step ensures the Raspbian software is able to
utilize the full size of the memory card being used.
22. Run the command “sudo reboot” to restart the Pi, then wait about 30
seconds. You will need to reconnect to the Pi after restart is complete.
23. After remotely connecting back to Pi, run the command “sudo shutdown
now” to shut down the Pi. Unplug the Pi after 20 – 30 seconds after running
this command.
58
Garden/Watering Pi
Overview This Raspberry Pi is supposed to read 3 sensor values (temperature, humidity, soil
moisture). Those sensor values are reported every hour to the central server
database. The soil moisture is checked every 6 hours and a pump to water the
plant/garden is turned on for 2 minutes if the soil is dry. These timing values can be
customized.
Parts Needed/Used 1.) Raspberry Pi 2 Model B
2.) 16GB Lexar 300x micro SD memory card
3.) Suptronics X300 expansion board
4.) SunFounder 2 channel 5v Relay Shield Module
5.) Power supply for Raspberry Pi (2 – 2.5 Amp)
6.) Water pump or water valve solenoid for tap water use (12v pump was used
here)
7.) Jumper Wires
8.) DHT22 AM2032 Digital Temperature Humidity Sensor
9.) 10k Ohm Resistor (brown black orange gold bands on resistor) for DHT22
Sensor
10.) Small size bread board
Instructions 1. Follow base Pi setup steps
59
Wire the Pi
2. Wire the Pi with the X300 expansion board, sensors, pump, and relay as
shown below. You will be using the GPIO pins located here (red rectangle) on
the top of the Raspberry Pi and X300 expansion board:
60
Download Sensor Libraries
3. Log into the Pi either using the Putty program or in the “Terminal” window in
the Raspbian operating system.
61
4. In either the Putty program or in the “Terminal” window in the Raspbian
operating system, run the command “git clone
https://github.com/adafruit/Adafruit_Python_DHT.git” to download the
library for the DHT22 sensor.
5. Run the command “cd Adafruit_Python_DHT”
6. Run the command “sudo python setup.py install” to start the install.
Set up Pi Module in Central Server Interface
7. Open a web browser on your computer and navigate to the central server
web interface (http://192.168.1.247). Log in to the site and click on the
“Modules”. Then click on the “Add Module” link.
8. Enter the information for the module you are setting up and click on the
“Submit” button.
62
You should now see the module you created in the list of modules for this
site. Take note of the module ID number as you will need it later on (In this
project, this module was module ID number 1.
9. Click on the “Sensors” tab at the top navigation bar of the web interface.
Then click on the “Add New Sensor” link to enter the sensor on the module
you just created, and then click on the “Submit” button.
In this instance, we will need to create the sensors Temperature (C), Humidity
(%), and Soil Moisture for Module ID 1. The final list of sensors should look
something like this:
63
You will need to know the sensor ID numbers in case they are different than
what is in the python source code files. It should be noted that the Chart File
Name field can be entered by clicking on the “Edit” icon for each of the
sensors and entering the file names as shown above. This field is used to tell
the interface where to find the pages to display the charts for the sensor data
later on.
Copy Source Program Files and Modify as Necessary
10. Using a program such as WinSCP or Filezilla, copy the .py files from the
project repository “Central Server\Garden Pi” file folder to the VM using
SCP/SSH. The destination path should be can be anywhere you decide (I
used the user home folder on the Pi).
11. Edit the Python .py files as shown in the next few steps, either before you
copy the files to the Pi or after copying. (I edited them using emacs on the Pi
using the command “emacs report-status.py” and “emacs check-and-
water.py”). You will need to make sure the host, user, passwd, and db fields
are filled in correctly.
db =
MySQLdb.connect(host="192.168.1.247",user="myautomationsql",
passwd="aut0Mat1on8",db="HomeAutomation")
64
12. The report-status.py file will need to be edited/checked to make sure the
module ID you obtained from the central server matches what is in the file
(shown in BOLD) at the lines shown below:
#Insert Temperature
c.execute("INSERT INTO tblSensorData (SensorID, TimeDate, Data)
VALUES ('1', NOW(), %s)", Temperature)
#Insert Humidity
c.execute("INSERT INTO tblSensorData (SensorID, TimeDate, Data)
VALUES ('2', NOW(), %s)", Humidity)
#Insert Soil Moisture
c.execute("INSERT INTO tblSensorData (SensorID, TimeDate, Data)
VALUES ('3', NOW(), %s)", SoilMoisture)
13. The check-and-water.py file will need to be edited/checked to make sure the
module ID you obtained from the central server matches what is in the file
(shown in BOLD) at the lines shown below:
#Change the number 1 to the module id as shown in the central server
interface
c.execute("INSERT INTO tblSystemActivity (ModuleID, TimeDate,
LoggedActivity) VALUES ('1'…
65
14. Edit the Crontab (background task scheduler) using the Putty program or in
the “Terminal” window to set the report-status.py and check-and-water.py to
be run periodically by typing the command “sudo crontab –e”. Go to the
bottom of the file and enter the following 2 lines:
@hourly sudo python /home/pi/report-status.py
0 */6 * * * sudo python /home/pi/check-and-water.py
15. Press the Ctrl and X key at the same time to exit the program, press the Y
key to save, and then press the Enter or Return key to finish the save. Note:
The first line we entered calls the report-status.py Python program hourly to
report back to the central server the current sensor readings. The second line
sets the check-and-water.py Python program to run every 6 hours to check
for a dry soil moisture reading and water if necessary.
16. Run the command “sudo reboot” to restart the Pi and sensor information
should start being entered into the central server database/interface
periodically.
17. Here are some installed pictures of the system. The Pi and water pump are
located inside a wooden cabinet. The water pump is drawing water from a
rain barrel.
67
NFC Garage Door Opener
Overview This Raspberry Pi is supposed to read NFC cards/tags, check with a central server
for authentication, and then power cycle a relay to open a garage door open if a
valid card/tag is used. Also, two LEDs are used to display whether a valid user’s
NFC tag is used or not.
Parts Needed/Used 1.) Raspberry Pi 2 Model B
2.) 16GB Lexar 300x micro SD memory card
3.) Suptronics X300 expansion board
4.) PN532 NFC/RFID Controller Breakout Board – v1.6
5.) SunFounder 2 channel 5v Relay Shield Module
6.) Power supply for Raspberry Pi (2 – 2.5 Amp)
7.) Red LED
8.) Blue or Green LED
9.) 2 x 330 Ohm Resistors (4 bands on Resistors should be orange, orange,
brown, and gold)
10.) Jumper Wires
11.) NFC Tag (This project used the Mifare NFC card that came with the
NFC board as well as a Mifare Classic (13.56Mhz RFID/NFC clear keychain
fob)
68
Instructions 1. Follow base Pi setup steps
Wire the Pi, NFC Card, and Relay Module
2. Wire the Pi, X300 expansion board, NFC card, and relay module as shown
below. You will be using the GPIO pins located here (red rectangle) on the
top of the Raspberry Pi and X300 expansion board:
69
Set up Pi to use SPI and NFC Card
3. Either use the Putty program to remotely connect to the Pi or open the
“Terminal” program in the GUI of the Raspberry Pi.
70
4. Enable SPI by running the command “sudo raspi-config”, press the up/down
arrow keys on the keyboard to choose “9 Advanced Options”.
5. Select “Yes” to enable SPI (Serial Peripheral Interface) for the NFC card to
work. You will most likely also have to choose “Yes” to automatically load the
kernel module. Use the right arrow key to select the “Finish” button and
choose “Yes” to reboot the Pi. You will have to remotely connect to the Pi or
use the GUI again after the reboot.
6. Run the command “sudo apt-get install build-essential python-dev git”.
7. Run the command “cd ~”.
8. Run the command “git clone
https://github.com/adafruit/Adafruit_Python_PN532.git”.
9. Run the command “cd Adafruit_Python_PN532”.
10. Run the command “sudo python setup.py install”.
71
Set up Pi Module in Central Server Interface
11. Open a web browser on your computer and navigate to the central server
web interface (http://192.168.1.247). Log in to the site and click on the
“Modules”. Then click on the “Add Module” link.
12. Enter the information for the module you are setting up and click on the
“Submit” button.
You should now see the module you created in the list of modules for this
site. Take note of the module ID number as you will need it later on (In this
project, this module was module ID number 5.
13. Click on the “Sensors” tab at the top navigation bar of the web interface.
Then click on the “Add New Sensor” link to enter the sensor on the module
you just created, and then click on the “Submit” button.
The final list of sensors should look something like this:
72
You will need to know the sensor ID number in case it is different than what is
in the python source code file.
14. Use an NFC tag and get its ID by using your terminal window and typing “cd
Adafruit_Python_PN532/examples”. Then run the command “sudo python
readmifare.py”. When you put the NFC tag over the NFC card, you should
see something like this:
Note: The UID value is the text you need to take down immediately following
the “0x”.
15. Navigate to the central server web interface (http://192.168.1.247) and go to
the “Users” tab. Click on the edit icon that looks like a pencil for the user you
are assigning this NFC tag/card to. In the “NFC Card ID” field, enter the UID
value from the last step without the “0x”.
73
16. Repeat as necessary.
Copy Source Program Files and Modify as Necessary
17. Using a program such as WinSCP or Filezilla, copy the nfc-read.py file from
the project repository “Central Server\NFC Pi” file folder to the VM using
SCP/SSH. The destination path should be can be anywhere you decide (I
used the user home folder on the Pi).
18. Edit the Python .py files, either before you copy the files to the Pi or after
copying. (I edited them using emacs on the Pi using the command “emacs
nfc-read.py”). You will need to make sure the host, user, passwd, and db
fields are filled in correctly.
db =
MySQLdb.connect(host="192.168.1.247",user="myautomationsql",
passwd="aut0Mat1on8",db="HomeAutomation")
74
19. The nfc-read.py file will need to be edited/checked to make sure the module
ID you obtained from the central server matches what is in the file (shown in
BOLD) at the lines as shown below:
c.execute("INSERT INTO tblSystemActivity (ModuleID, TimeDate,
LoggedActivity) VALUES ('5'…
Note: There are multiple instances of the line shown above. All instances
have to be checked to ensure the module ID number is correct.
20. Set up the Pi to automatically start the NFC reader Python program when the
Pi turns on. We will do this by first creating a launcher script by typing “emacs
launcher.sh” in a terminal window. Then enter the following:
#!/bin/sh
# launcher.sh
# Navigate to home directory, then execute python script
cd /
cd home/pi
sudo python nfc-read.py
21. Save the file by pressing the Ctrl and S keys, then the Ctrl and X keys to
close the emacs editor.
75
22. Type the command “chmod 755 launcher.sh” and press the Return key to
make the file executable. Also, create a log file folder by running the
command “mkdir logs”.
23. Edit the Crontab (background task schedule) to run the launcher.sh file on
start up by running the command “sudo crontab -e”. Go to the bottom of the
file and enter the following line:
@reboot sh /home/pi/launcher.sh >/home/pi/logs/cronlog 2>&1
Press the Ctrl and X key at the same time to exit the program, press the Y
key to save, and then press the Enter or Return key to finish the save.
24. Restarting the Pi by running the command “sudo reboot” should now start
the nfc-read.py Python program on startup. Data from sensor reads should
also be uploaded to the central server database/interface.
76
APPENDIX B – Source Code nfc-read.py
# Example of detecting and reading a block from a MiFare NFC card. # Author: Tony DiCola and Guang Yew # Copyright (c) 2015 Adafruit Industries # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import binascii import sys import RPi.GPIO as GPIO import Adafruit_PN532 as PN532 import time import MySQLdb # Configuration for a Raspberry Pi: CS = 18 MOSI = 23 MISO = 24
77
SCLK = 25 GARAGERLYBCM = 27 GOODLEDINDICATOR = 26 BADLEDINDICATOR = 20 INVALIDERRORCOUNT = 0 GPIO.setmode(GPIO.BCM) # Create an instance of the PN532 class. pn532 = PN532.PN532(cs=CS, sclk=SCLK, mosi=MOSI, miso=MISO) # Call begin to initialize communication with the PN532. Must be done before # any other calls to the PN532! pn532.begin() # Get the firmware version from the chip and print(it out.) ic, ver, rev, support = pn532.get_firmware_version() ###print('Found PN532 with firmware version: {0}.{1}'.format(ver, rev)) # Configure PN532 to communicate with MiFare cards. pn532.SAM_configuration() # Read NFC sensor loop to check for valid NFC tag and actuate garage door opener if valid along with logging activity to central server database # Main loop to detect cards and read a block. # print('Waiting for MiFare card...') while True: # Check if a card is available to read. uid = pn532.read_passive_target() # Try again if no card is available. if uid is None: continue # Set uid variable with NFC tag read uid = binascii.hexlify(uid) print(uid) try: # Database Connection db = MySQLdb.connect(host="192.168.1.247",user="myautomationsql",passwd="aut0Mat1on8",db="HomeAutomation") except: print("DB Connection error") try:
78
c = db.cursor() # Insert log activity entry into central automation server database c.execute("INSERT INTO tblSensorData (SensorID, TimeDate, Data) VALUES ('4', NOW(), %s)", uid) c.execute("INSERT INTO tblSystemActivity (ModuleID, TimeDate, LoggedActivity) VALUES ('5', NOW(), 'Garage door NFC reader has read card ID ' %s)", uid) # Check to see if NFC tag read is a valid user c.execute("SELECT id FROM tblUsers WHERE NFCCardID = %s", uid) data = c.fetchall() print("Selected ID from DB") # print the number of valid users found for NFC tag read count = c.rowcount print(count) if (count == 1): #light blue LED, trigger garage door opener and write to central server log print "Garage relay trigger and LED indicator on..." GPIO.setmode(GPIO.BCM) GPIO.setup(GOODLEDINDICATOR, GPIO.OUT) GPIO.output(GOODLEDINDICATOR, True) GPIO.setup(GARAGERLYBCM, GPIO.OUT) GPIO.output(GARAGERLYBCM, False) time.sleep(1) GPIO.output(GARAGERLYBCM, True) print "Garage relay finished and LED indicator off..." GPIO.output(GOODLEDINDICATOR, False) c.execute("INSERT INTO tblSystemActivity (ModuleID, TimeDate, LoggedActivity) VALUES ('5', NOW(), 'Garage door has been actuated by Card ID ' %s)", uid) else: # If there are more than 3 consecutive invalid NFC tags read, turn on red LED and don't read any more tags for 5 mins INVALIDERRORCOUNT += 1 print(INVALIDERRORCOUNT) if (INVALIDERRORCOUNT > 2): print('System disabled for 15 mins') c.execute("INSERT INTO tblSystemActivity (ModuleID, TimeDate, LoggedActivity) VALUES ('5', NOW(), 'Garage Door NFC Reader is disabled for 15 mins after 3 consecutive invalid attempts')") GPIO.setmode(GPIO.BCM) GPIO.setup(BADLEDINDICATOR, GPIO.OUT)
79
GPIO.output(BADLEDINDICATOR, True) time.sleep(10) # Reset error count to 0 INVALIDERRORCOUNT = 0 # Turn off red LED GPIO.output(BADLEDINDICATOR, False) else: # Light red LED due to invalid card and write to central server log GPIO.setmode(GPIO.BCM) GPIO.setup(BADLEDINDICATOR, GPIO.OUT) GPIO.output(BADLEDINDICATOR, True) time.sleep(3) GPIO.output(BADLEDINDICATOR, False) c.execute("INSERT INTO tblSystemActivity (ModuleID, TimeDate, LoggedActivity) VALUES ('5', NOW(), 'Invalid NFC card has been read with the ID ' %s)", uid) print('No valid user found.') c.close() time.sleep(3) db.commit() db.close() # print ("DBEnd") except: # db.rollback() print "Database Error..." time.sleep(2)
80
check-and-water.py
#!/usr/bin/python # Copyright (c) 2014 Adafruit Industries # Author: Tony DiCola and Guang Yew # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import Adafruit_DHT import MySQLdb import RPi.GPIO as GPIO import time # Sensor should be set to Adafruit_DHT.DHT11, # Adafruit_DHT.DHT22, or Adafruit_DHT.AM2302. sensor = Adafruit_DHT.DHT22 # Example using a Raspberry Pi with DHT sensor # connected to GPIO23. pin = 4
81
Rly1BGPIO = 23 Rly2BGPIO = 24 # Try to grab a sensor reading. Use the read_retry method which will retry up # to 15 times to get a sensor reading (waiting 2 seconds between each retry). Humidity, Temperature = Adafruit_DHT.read_retry(sensor, pin) if Humidity is not None and Temperature is not None: print 'Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(Temperature, Humidity) #Format Temperature for later use FormattedTemp = round(Temperature, 2) else: print 'Failed to get reading. Try again!' #Check Soil Moisture GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.IN) GPIO.setup(Rly1BGPIO, GPIO.OUT) GPIO.setup(Rly2BGPIO, GPIO.OUT) print "" print "soil moisture below:" print GPIO.input(17) soilMoisture = GPIO.input(17) GPIO.cleanup() GPIO.setmode(GPIO.BCM) GPIO.setup(Rly1BGPIO, GPIO.OUT) GPIO.setup(Rly2BGPIO, GPIO.OUT) if soilMoisture: #Soil is dry so start watering on relay 1 print "Soil is dry" #GPIO.setmode(GPIO.BCM) GPIO.output(Rly1BGPIO, False) #Connect to database try: db = MySQLdb.connect(host="192.168.1.247",user="myautomationsql",passwd="aut0Mat1on8",db="HomeAutomation") except: print "Unable to connect to the database."
82
c = db.cursor() c.execute("INSERT INTO tblSystemActivity (ModuleID, TimeDate, LoggedActivity) VALUES ('1', NOW(), 'Watering activated for 2 minutes when garden temperature was %s degrees Celcius')", FormattedTemp) db.commit() else: #GPIO.setmode(GPIO.BCM) GPIO.output(Rly1BGPIO, True) print "soil is moist already" #NOT USED-Turn off relays #GPIO.setmode(GPIO.BCM) #GPIO.setup(Rly1BGPIO, GPIO.OUT) #GPIO.setup(Rly2BGPIO, GPIO.OUT) #Start watering GPIO.output(Rly1BGPIO, False) #Not used yet until we wire another pump for additional watering capacity #GPIO.output(Rly2BGPIO, True) #Water for 2 minutes and stop relay/motor time.sleep(120) GPIO.output(Rly1BGPIO, True) db.close()
83
report-status.py
#!/usr/bin/python # Copyright (c) 2014 Adafruit Industries # Author: Tony DiCola and Guang Yew # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import Adafruit_DHT import MySQLdb import RPi.GPIO as GPIO import os # Sensor should be set to Adafruit_DHT.DHT11, # Adafruit_DHT.DHT22, or Adafruit_DHT.AM2302. sensor = Adafruit_DHT.DHT22 # Example using a Raspberry Pi with DHT sensor # connected to GPIO23. pin = 4
84
Rly1BGPIO = 23 Rly2BGPIO = 24 # Try to grab a sensor reading. Use the read_retry method which will retry up # to 15 times to get a sensor reading (waiting 2 seconds between each retry). Humidity, Temperature = Adafruit_DHT.read_retry(sensor, pin) if Humidity is not None and Temperature is not None: print 'Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(Temperature, Humidity) else: print 'Failed to get reading. Try again!' #Initiate Database Connection try: db = MySQLdb.connect(host="192.168.1.247",user="myautomationsql", passwd="aut0Mat1on8",db="HomeAutomation") except: print "Unable to connect to the database." #Get sensor readings and insert into database try: #GPIO.setWarnings(False) GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.IN) SoilMoisture = GPIO.input(17) c = db.cursor() #Insert Temperature c.execute("INSERT INTO tblSensorData (SensorID, TimeDate, Data) VALUES ('1', NOW(), %s)", Temperature) #Insert Humidity c.execute("INSERT INTO tblSensorData (SensorID, TimeDate, Data) VALUES ('2', NOW(), %s)", Humidity) #Insert Soil Moisture c.execute("INSERT INTO tblSensorData (SensorID, TimeDate, Data) VALUES ('3', NOW(), %s)", SoilMoisture) c.execute("""SELECT * from tblSensorData""") db.commit() except: db.rollback() print "Database Error..."
85
#dbdata = c.fetchall() #print "DB Data: " #print dbdata #GPIO.setmode(GPIO.BCM) #GPIO.setup(17, GPIO.IN) #print "" #print "soil moisture below:" #print GPIO.input(17) GPIO.cleanup() #Turn off relays GPIO.setmode(GPIO.BCM) GPIO.setup(Rly1BGPIO, GPIO.OUT) GPIO.setup(Rly2BGPIO, GPIO.OUT) GPIO.output(Rly1BGPIO, True) GPIO.output(Rly2BGPIO, True) #Start watering #os.system('start-watering.py') db.close()
86
homeautomation.sql -- phpMyAdmin SQL Dump -- version 4.0.10deb1 -- http://www.phpmyadmin.net -- -- Host: localhost -- Generation Time: Sep 04, 2016 at 12:08 PM -- Server version: 5.5.49-0ubuntu0.14.04.1 -- PHP Version: 5.5.9-1ubuntu4.16 SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO"; SET time_zone = "+00:00"; /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */; /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */; /*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */; /*!40101 SET NAMES utf8 */; -- -- Database: `HomeAutomation` -- CREATE DATABASE IF NOT EXISTS `HomeAutomation` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci; USE `HomeAutomation`; -- -------------------------------------------------------- -- -- Table structure for table `new_record` -- DROP TABLE IF EXISTS `new_record`; CREATE TABLE IF NOT EXISTS `new_record` ( `id` int(11) NOT NULL AUTO_INCREMENT, `trn_date` datetime NOT NULL, `name` varchar(50) NOT NULL, `age` int(11) NOT NULL, `submittedby` varchar(50) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ; -- --------------------------------------------------------
87
-- -- Table structure for table `tblModules` -- DROP TABLE IF EXISTS `tblModules`; CREATE TABLE IF NOT EXISTS `tblModules` ( `ID` int(11) NOT NULL AUTO_INCREMENT, `Name` varchar(255) NOT NULL, `Location` varchar(255) NOT NULL, `IP` varchar(255) NOT NULL, PRIMARY KEY (`ID`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=6 ; -- -------------------------------------------------------- -- -- Table structure for table `tblSensorData` -- DROP TABLE IF EXISTS `tblSensorData`; CREATE TABLE IF NOT EXISTS `tblSensorData` ( `ID` int(11) NOT NULL AUTO_INCREMENT, `SensorID` int(11) NOT NULL, `TimeDate` datetime NOT NULL, `Data` varchar(255) NOT NULL, PRIMARY KEY (`ID`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=5815 ; -- -------------------------------------------------------- -- -- Table structure for table `tblSensors` -- DROP TABLE IF EXISTS `tblSensors`; CREATE TABLE IF NOT EXISTS `tblSensors` ( `ID` int(11) NOT NULL AUTO_INCREMENT, `Name` varchar(255) NOT NULL, `ModuleID` int(11) NOT NULL, `chartFilename` varchar(255) NOT NULL, PRIMARY KEY (`ID`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ; -- --------------------------------------------------------
88
-- -- Table structure for table `tblSystemActivity` -- DROP TABLE IF EXISTS `tblSystemActivity`; CREATE TABLE IF NOT EXISTS `tblSystemActivity` ( `ActivityID` int(11) NOT NULL AUTO_INCREMENT, `ModuleID` int(11) NOT NULL, `LoggedActivity` varchar(255) NOT NULL, `TimeDate` datetime NOT NULL, PRIMARY KEY (`ActivityID`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=379 ; -- -------------------------------------------------------- -- -- Table structure for table `tblUsers` -- DROP TABLE IF EXISTS `tblUsers`; CREATE TABLE IF NOT EXISTS `tblUsers` ( `id` int(4) NOT NULL AUTO_INCREMENT, `username` varchar(65) NOT NULL DEFAULT '', `password` varchar(65) NOT NULL DEFAULT '', `accesslevel` varchar(65) NOT NULL, `NFCCardID` varchar(50) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ; -- -- Dumping data for table `tblUsers` -- INSERT INTO `tblUsers` (`id`, `username`, `password`, `accesslevel`, `NFCCardID`) VALUES (1, 'admin', 'e4a93e6d2ec6da13df4c42d500543352', 'admin', '31060f0b'), /*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */; /*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */; /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;