JavaScript-物联网编程-全-
JavaScript 物联网编程（全）
原文：
zh.annas-archive.org/md5/98FAEC66467881BC21EC8531C753D4EC译者：飞龙
前言
树莓派 Zero 是一款功能强大、价格低廉、信用卡大小的计算机，非常适合开始控制复杂的家庭自动化设备。使用可用的板载接口，树莓派 Zero 可以扩展，允许连接几乎无限数量的安全传感器和设备。
由于 Arduino 平台更加多功能和有用于制作项目，包括物联网的网络应用，这就是我们将在本书中看到的：连接到节点的设备的集成，使用令人惊叹和重要的 Arduino 板，以及如何集成树莓派 Zero 来控制和监控设备，从而形成一个作为中心界面工作的中心。通过软件编程，您将创建一个基于 JavaScript、HTML5 和 Node.js 等发展技术的物联网系统。
这正是我将在这本书中教给你的。您将学习如何在几个家庭自动化项目中使用树莓派 Zero 板，以便您自己建立。
这本书指导您，每一章的项目都从准备领域、硬件、传感器、通信和软件编程控制开始，以便拥有完整的控制和监控系统。
本书涵盖的内容
第一章，“开始使用树莓派 Zero”，描述了设置树莓派和 Arduino 板的过程，以及设备之间的通信。我们将安装和设置操作系统，将我们的 Pi 连接到网络，并远程访问它。我们还将保护我们的 Pi，并确保它能保持正确的时间。
第二章，“将东西连接到树莓派 Zero”，展示了如何将信号连接到树莓派 Zero 和 Arduino。它探讨了 GPIO 端口及其各种接口。我们将看看可以使用 GPIO 连接到树莓派的各种东西。
第三章，“连接传感器-测量真实的事物”，展示了如何实现用于检测不同类型信号的传感器，用于安全系统、能源消耗的流量电流、家庭中的一些风险检测、实现气体传感器、流量水传感器来测量水量，并且还将展示如何制作一个将使用指纹传感器控制家庭入口的安全系统。
第四章，“控制连接设备”，展示了如何使用通信模块在树莓派 Zero 的网络领域中控制您的 Arduino 板，以及如何在中央界面仪表板中显示。
第五章，“添加网络摄像头监控您的安全系统”，展示了如何配置连接到您的板的网络摄像头，以监控物联网安全系统。
第六章，“构建 Web 监视器并从仪表板控制设备”，展示了如何设置一个系统来监控您的安全系统使用网络服务。将树莓派 Zero 与 Arduino 集成，构建一个完整的系统连接设备和监控。
第七章，“使用物联网仪表板构建间谍警察”，展示了如何制作不同的迷你家庭自动化项目，以及如何使用物联网连接网络服务和监控您的安全系统。
Chapter 8, Monitor and Control your devices from a Smart Phone, explains how to develop an app for Smart Phone using Android Studio and APP inventor, and control your Arduino board and the Raspberry Pi Zero.
Chapter 9, Putting It All Together, shows how to put everything together, all the parts of the project, the electronics field, software configurations, and power supplies.
What you need for this book
You’ll need the following software:
-
Win32 Disk Imager 0.9.5 PuTTY
-
i2C-tools
-
WiringPi2 for Python
-
Node.js 4.5 or later
-
Node.js for Windows V7.3.0 or later
-
Python 2.7.x or Python 3.x
-
PHP MyAdmin Database
-
MySQL module
-
Create and account in Gmail so that you can get in APP Inventor
-
Android Studio and SDK modules
-
Arduino software
In the first chapters, we explain all the basics so you will have everything configured and will be able to use the Raspberry Pi Zero without any problems, so you can use it for the projects in this book. We will use some basic components, such as sensors, and move to more complex components in the rest of the book.
On the software side, it is good if you actually have some existing programming skills, especially in JavaScript and in the Node.js framework. However, I will explain all the parts of each software piece of this book, so even if you don't have good programming skills in JavaScript you will be able to follow along.
Who this book is for
This book is for all the people who want to automate their homes and make them smarter, while at the same time having complete control of what they are doing. If that's your case, you will learn everything there is to learn in this book about how to use the amazing Raspberry Pi Zero board to control your projects.
This book is also for makers who have played in the past with other development boards, such as Arduino. If that's the case, you will learn how to use the power of the Raspberry Pi platform to build smart homes. You will also learn how to create projects that can easily be done with other platforms, such as creating a wireless security camera with the Pi Zero.
Conventions
In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.
Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "Extract 2015-09-24-raspbian-jessie.img to your Home folder."
A block of code is set as follows:
# passwd
root@raspberrypi:/home/pi# passwd
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
root@raspberrypi:/home/pi#
When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:
[default]
exten => s,1,Dial(Zap/1|30)
exten => s,2,Voicemail(u100)
**exten => s,102,Voicemail(b100)**
exten => i,1,Voicemail(s0)
Any command-line input or output is written as follows:
** sudo npm install express request**
New terms and important words are shown in bold. Words that you see on the screen, for example, in menus or dialog boxes, appear in the text like this:
"You can now just click on Stream to access the live stream from the camera."
Note
Warnings or important notes appear in a box like this.
Tip
Tips and tricks appear like this.
第一章：使用 Raspberry Pi Zero 入门
在为家庭安全系统和通过电子控制系统控制家用电器构建几个项目之前，在本章中，我们将进行初始配置并准备我们的 Raspberry Pi Zero 在网络中工作，以便您可以在本书中看到的所有项目中使用它。
在我们进行项目、构建网络与设备并将传感器连接到板子之前，了解 Raspberry Pi 的配置是很重要的。本章的主要目的是解释如何设置您的 Raspberry Pi Zero；我们将涵盖以下主题：
-
设置 Raspberry Pi Zero
-
准备 SD 卡
-
安装 Raspbian 操作系统
-
使用串行控制台电缆配置您的 Raspberry Pi Zero
-
远程访问网络
-
通过远程桌面访问
-
配置 Web 服务器
设置 Raspberry Pi Zero
Raspberry Pi 是一个专门用于项目的低成本板。在这里，我们将使用 Raspberry Pi Zero 板。查看以下链接：www.adafruit.com/products/2816。我用了这块板。
为了使 Raspberry Pi 工作，我们需要一个充当硬件和用户之间桥梁的操作系统。本书使用 Raspbian Jessy，可以从www.raspberrypi.org/downloads/下载。在此链接中，您将找到下载所有必要软件的信息，以便与您的 Raspberry Pi 一起使用部署 Raspbian。您需要至少 4GB 的微型 SD 卡。
我用来测试 Raspberry Pi Zero 的套件包括安装所有必要的东西和准备好板子所需的一切：
准备 SD 卡
Raspberry Pi Zero 只能从 SD 卡启动，不能从外部驱动器或 USB 存储设备启动。对于本书，建议使用 4GB 的微型 SD 卡。
安装 Raspbian 操作系统
树莓派板上有许多可用的操作系统，其中大多数基于 Linux。然而，通常推荐的是 Raspbian，这是一个基于 Debian 的操作系统，专门为树莓派制作。
为了在您的 Pi 上安装 Raspbian 操作系统，请按照以下步骤：
-
从官方 Raspberry Pi 网站下载最新的 Raspbian 镜像：
www.raspberrypi.org/downloads/raspbian/ -
接下来，使用适配器将微型 SD 卡插入计算机。（适配器通常随 SD 卡一起提供。）
-
然后从
sourceforge.net/projects/win32diskimager/下载 Win32DiskImager。
在下载文件夹后，您将看到以下文件，如截图所示：
-
打开文件映像，选择您的微型 SD 卡路径，然后单击写按钮。
-
几秒钟后，您的 SD 卡上安装了 Raspbian；将其插入 Raspberry Pi 并通过微型 USB 端口将 Raspberry Pi 板连接到电源源。
在下面的截图中，您可以看到安装的进度：
使用串行控制台电缆调试您的 Raspberry Pi Zero
在这一部分，我们将看看如何使用 TTL 串行转换器从计算机与 Raspberry Pi Zero 进行通信。我们可以通过连接到计算机的 USB 端口的串行控制电缆进行调试。我们使用串行电缆与板子通信，因为如果我们想要从计算机向板子发送命令，就必须使用这根电缆进行通信。您可以在www.adafruit.com/products/954找到这根电缆：
重要的是要考虑到这根电缆使用 3.3 伏特，但我们不在乎，因为我们使用的是 Adafruit 的电缆。它经过测试可以在这个电压级别下工作。
您需要按照以下步骤安装和与您的 Raspberry Pi Zero 通信：
-
您的计算机上需要有一个空闲的 USB 端口。
-
我们需要安装串行控制电缆的驱动程序，以便系统可以识别硬件。我们建议您从
www.adafruit.com/images/product-files/954/PL2303_Prolific_DriverInstaller_v1_12_0.zip下载驱动程序。 -
我们使用一个名为 PuTTY 的接口（控制台软件），在 Windows 计算机上运行；这样我们就可以与我们的 Raspberry Pi 板进行通信。这个软件可以从
www.putty.org/下载和安装。 -
对于连接，我们需要将红色电缆连接到5伏特，黑色电缆连接到地面，白色电缆连接到TXD引脚，绿色电缆连接到 Raspberry Pi Zero 的 RXD 引脚。
-
电缆的另一端连接插头到 USB 端口。
这是连接的图像；这是硬件配置：
测试和访问串行 COM 接口
驱动程序安装完成后，我们已经安装了端口 COM：
提示
这个配置是为了 Windows 安装；如果你有不同的操作系统，你需要执行不同的步骤。
如何获得设备管理器屏幕：在您的 Windows PC 上，点击开始图标，转到控制面板，选择系统，然后点击设备管理器。
在下面的截图中，您可以看到 USB 串行端口的设备管理器：
-
在 PuTTY 中打开终端，并选择串行通信为
COM3，速度为115200，奇偶校验为无，流控制为无；点击打开：
-
当出现空白屏幕时，按下键盘上的Enter：
-
这将启动与您的 Pi 板的连接，并要求您输入用户名和密码；您将看到一个屏幕，类似于以下截图，带有认证登录：
-
Raspberry Pi Zero 的默认用户名是
pi，密码是raspberry：
连接到家庭网络并远程访问
我们的 Raspberry Pi 将在一个真实的网络中工作，因此它需要设置为与将一起使用的所有设备一起工作。因此，我们需要配置我们的家庭网络。我们将向您展示如何使用以太网适配器和可以用于 Raspberry Pi Zero 的 Wi-Fi 插头。
使用以太网适配器连接
如果您想将我们的树莓派 Zero 连接到本地网络，您需要使用来自 Adafruit 的 USB OTG 主机电缆-MicroB OTG 公对母。您可以在这里找到它：www.adafruit.com/products/1099。我们正在使用的板没有以太网连接器，因此有必要使用它与外部设备进行通信。
在下面的图像中，我们可以看到以太网适配器连接到树莓派 Zero：
这是您可以使用的连接器，用于连接您的以太网适配器并与网络建立链接：
现在我们需要按照以下步骤来配置以太网连接适配器：
-
将适配器连接到转换器；我使用了TRENDnet NETAdapter，但您也可以使用来自 Adafruit 的以太网集线器和 Micro USB OTG 连接器的 USB 集线器。您可以在这里找到它：
www.adafruit.com/products/2992m。这是一个集线器，可以连接到以太网电缆或 USB 设备。 -
验证路由器配置，两个 LED 都开始闪烁后，您可以在配置中看到 IP 地址。 DHCP 服务器将 IP 地址分配给树莓派。
这是您在主机名raspberrypi上看到的路由器配置：
通过 SSH 访问树莓派 Zero
因为我们知道了树莓派的 IP 地址，我们将使用 PuTTY 终端访问它，如下面的屏幕截图所示。您需要输入 IP 地址，默认端口是22；点击打开按钮：
之后，我们将看到如下的登录屏幕：
使用以下命令：
**sudo ifconfig -a**
现在我们可以看到以太网控制器适配器的配置信息。Eth0是以太网适配器：
连接到 Wi-Fi 网络
在本节中，我们将向您展示如何配置您的 Wi-Fi 网络连接，以便您的树莓派 Zero 可以与您的 Wi-Fi 网络进行交互。首先，我们需要使用 USB OTG 电缆将微型 Wi-Fi（802.11b/g/n）Wi-Fi dongle 连接到树莓派：
如何安装无线工具
使用以下命令配置无线网络：
**sudo apt-get install wireless-tools**
在下面的屏幕截图中，我们可以看到ifconfig命令的结果：
执行命令后，我们将看到安装wireless-tools的结果：
配置 IP 地址和无线网络
为了进行网络配置，我们需要为我们的设备分配一个 IP 地址，以便参与网络。
输入以下命令：
**sudo nano etc/network/interfaces**
在名为interface的配置文件中，我们解释了需要向文件添加什么内容，以便我们可以将树莓派 Zero 连接到 Wi-Fi 网络进行Wlan0连接。
我们启动文件配置；这意味着文件的开始：
auto lo
我们为本地主机配置以太网设备loopback并启动 DHCP 服务器：
iface lo inet loopback
iface eth0 inet dhcp
允许配置wlan0以进行 Wi-Fi 连接：
allow-hotplug wlan0
auto wlan0
我们启动 Wi-Fi 连接的 DHCP 服务器，并输入您的ssid和密码的名称。我们需要输入您的 Wi-Fi 网络的ssid和password参数：
iface wlan0 inet dhcp
wpa-ssid "ssid"
wpa-psk "password"
测试通信
我们需要测试设备是否响应其他主机。现在，如果一切配置正确，我们可以在 Wi-Fi 连接中看到以下 IP 地址：
我们可以在路由器配置中看到分配给无线网络的当前 IP 地址：
从计算机 ping
将计算机连接到与 Raspberry Pi 相同的网络：
您需要 ping Raspberry Pi 的 IP 地址。在我们对 Raspberry Pi 无线连接的 IP 地址进行 ping 后，我们看到结果：
更新软件包存储库
这将通过从官方 Raspberry Pi 存储库下载所有最新软件包来升级您的 Pi 板，因此这是确保您的板连接到互联网的绝佳方式。然后，从您的计算机上键入以下内容：
**sudo apt-get update**
以下屏幕截图显示了 Raspberry Pi 收集软件包数据的过程：
安装完成后，我们有以下结果：
远程桌面
在这一部分，我们需要具有 Raspbian 操作系统的RDP软件包。为此，首先需要执行以下命令：
**sudo apt-get install xrdp**
此命令执行并安装 RDP 进程并更新软件包：
使用 Windows 远程桌面
在本章结束时，您希望能够使用远程桌面从自己的计算机访问板；您需要输入您的 Raspberry Pi 的 IP 地址并单击连接按钮：
在我们输入 Raspberry Pi Zero 的 IP 地址后，我们将看到以下屏幕；需要输入您的用户名和密码：
您需要您的 Raspberry Pi 的登录信息，用户名和密码：
这是操作系统的主窗口；您已经正确地通过远程桌面访问了您的 Raspberry Pi：
配置 Web 服务器
有几个 Web 服务器可用，我们可以在 Raspberry Pi 上安装。我们将安装lighttpd网络服务器。此外，我们需要安装 PHP 支持，这将帮助我们在 Raspberry Pi 上运行网站并拥有动态网页。
要安装和配置，请通过 PuTTY 的终端控制台登录到 Raspberry Pi：
- 更新软件包安装程序：
**sudo apt-get update**
- 安装
lighttpd网络服务器：
**sudo apt-get install lighttpd**
安装后，它将自动作为后台服务启动；每次 Raspberry Pi 启动时都会这样做：
- 为了设置我们的 PHP 5 界面以使用 PHP 5 进行编程，我们需要使用以下命令安装
PHP5模块支持；这对于拥有我们的服务器并且可以执行 PHP 文件的必要性是必要的，这样我们就可以制作我们的网站：
**sudo apt-get install php5-cgi**
- 现在我们需要在我们的 Web 服务器上启用
PHP FastCGI模块：
**sudo lighty-enable-mod fastcgi-php**
- 最后一步，我们需要使用以下命令重新启动服务器：
**sudo /etc/init.d/lighttpd**
在下面的屏幕截图中，我们展示了配置 Web 服务器和 PHP 5 界面时将出现的页面内容。Web 服务器在位置/var/www安装了一个测试占位页面。在浏览器中输入您的 Raspberry Pi 的 IP 地址，例如http://192.168.1.105/，然后出现以下屏幕，打开配置服务器的活动页面：
测试 PHP 安装
在这一点上，我们需要用 PHP 测试我们的网站。这可以通过编写一个简单的 PHP 脚本页面来完成。如果 PHP 安装正确，它将返回有关其环境和配置的信息。
- 转到下一个文件夹，那里是根文档：
**cd /var/www/html**
- 创建一个名为
phpinfo.php的文件。
我们使用nano这个词，这样我们就可以以特权进入系统文件并执行以下命令：
**sudo nano phpinfo.php**
-
创建文件后，按照以下截图，按下CTRL-X，然后保存文件：
-
在浏览器中输入您的树莓派的 IP 地址，例如
http://192.168.1.105/phpinfo.php，您应该会看到以下屏幕：
总结
在本书的第一章中，我们看了如何配置树莓派 Zero 板，以便在后面的章节中使用。我们看了一下树莓派需要什么组件，以及如何安装 Raspbian，这样我们就可以在板上运行软件。
我们还安装了一个 Web 服务器，这将在本书的一些项目中使用。在下一章中，我们将深入探讨如何将设备连接到您的树莓派和 Arduino 板上。我们还将看看使用 GPIO 可以连接到树莓派的各种东西。
第二章：将东西连接到树莓派 Zero
您需要学习如何将东西连接到您的树莓派 Zero，并查看架构并区分我们可以用于我们定义目的的引脚。这就是我们有这一部分的原因-帮助您连接传感器并了解如何连接其他设备的基础知识。在本节中，我们将解释如何配置树莓派；现在您无法避免学习如何连接到您的树莓派传感器以读取连接到它的模拟输入。
我们将涵盖以下主题，以使我们的硬件与板通信：
-
连接数字输入：传感器 DS18B20
-
使用 MCP3008 ADC 转换器连接模拟输入
-
连接实时时钟（RTC）
连接数字输入-传感器 DS18B20
树莓派有数字引脚，因此在本节中，我们将看看如何将数字传感器连接到板上。我们将使用数字传感器 DS18B20，它具有数字输出，并且可以完美地连接到我们树莓派传感器的数字输入。主要思想是从传感器中获取温度读数并在屏幕上显示它们。
硬件要求
我们需要以下硬件来读取温度：
-
温度传感器 DS18B20（防水）
-
一个 4.7 千欧姆的电阻
-
一些跳线线
-
一个面包板
我们将使用防水传感器 DS18B20 和4.7千欧姆电阻：
这是我们在这个项目中使用的防水传感器。
硬件连接
以下图表显示了面包板上的电路，带有传感器和电阻：
在下图中，我们可以看到带有传感器的电路：
配置单线协议
在树莓派中打开一个终端，并输入以下内容：
**sudo nano /boot/config.txt**
您应该在页面底部输入以下行以配置协议并定义单线协议将进行通信的引脚：
**dtoverlay=w1-gpio**
下一步是重新启动树莓派。几分钟后，打开终端并输入以下行：
**sudo modprobew1-gpio**
**sudo modprobe w1-therm**
进入文件夹并选择要配置的设备：
**cd /sys/bus/w1/devices**
**ls**
选择要设置的设备。将xxxx更改为协议中将设置的设备的序列号：
**cd 28-xxxx**
**cat w1_slave**
您将看到以下内容：
之后，您将看到一行，上面写着如果出现温度读数，则为 Yes，如下所示：t=29.562。
软件配置
现在让我们看一下代码，每秒在屏幕上显示摄氏度和华氏度的温度。
在这里，我们导入了程序中使用的库：
import os1
import glob1
import time1
在这里，我们定义了协议中配置的设备：
os1.system('modprobew1-gpio')
os1.system('modprobew1-therm1')
在这里，我们定义了设备配置的文件夹：
directory = '/sys/bus/w1/devices/'
device_folder1 = glob1.glob(directory + '28*')[0]
device_file1 = device_folder1 + '/w1_slave'
然后我们定义读取温度和配置传感器的函数：
defread_temp():
f = open(device_file1, 'r')
readings = f.readlines()
f.close()
return readings
使用以下函数读取温度：
defread_temp():
readings = read_temp()
在这个函数中，我们比较了接收到消息YES时的时间，并获取了温度的值：
while readings[0].strip()[-3:] != 'YES':
time1.sleep(0.2)
readings = read_temp()
equals = lines[1].find('t=')
然后我们计算温度，temp以C和F返回值：
if equals != -1:
temp = readings[1][equals pos+2:]
tempc = float(temp) / 1000.0
tempf = temp * 9.0 / 5.0 + 32.0
returntempc, tempf
它每秒重复一次循环：
while True:
print(temp())
time1.sleep(1)
在屏幕上显示读数
现在我们需要执行thermometer.py。要显示 Python 中制作的脚本的结果，请打开您的 PuTTY 终端，并输入以下命令：
**sudo python thermometer.py**
该命令的意思是，当我们运行温度计文件时，如果一切正常运行，我们将看到以下结果：
使用 MCP3008 ADC 转换器连接模拟输入
如果我们想要连接模拟传感器到树莓派，我们需要使用模拟到数字转换器（ADC）。该板没有模拟输入；我们使用MCP3008连接模拟传感器。这是一个 10 位 ADC，有八个通道。这意味着您可以连接多达八个传感器，可以从树莓派 Zero 读取。我们不需要特殊的组件来连接它们。它们可以通过 SPI 连接到树莓派的 GPIO。
第一步是启用 SPI 通信：
- 访问树莓派终端并输入以下命令：
**sudo raspi-config**
-
如下截图所示选择高级选项：
-
通过选择SPI选项启用SPI通信：
-
选择
以启用 SPI 接口： 
-
当我们启用 SPI 接口时，最终屏幕看起来像下面的截图。选择
： 
树莓派 GPIO 引脚
以下截图是树莓派 Zero 的 GPIO 引脚图表。在这种情况下，我们将使用 SPI 配置接口（SPI_MOSI, SPI_MISO, SPI_CLK, SPI_CE0_N）：
以下图表显示了 MCP3008 芯片的引脚名称，您将其连接到树莓派：
以下图片显示了温度传感器：
您需要根据以下描述连接以下引脚：
-
VDD连接到3.3伏特
-
VREF连接到树莓派 Zero 的3.3伏特
-
将AGND引脚连接到GND
-
将CLK（时钟）引脚连接到树莓派的GPIO11
-
DOUT连接到GPIO9
-
将DIN引脚连接到GPIO10
-
将CS引脚连接到GPIO8和引脚
-
将 MCP3008D 的GND引脚连接到地面
这个连接在下图中表示：
以下图片显示了传感器连接到 ADC MCP3008 和树莓派的连接：
使用 Python 脚本读取数据
在下一节中，您将创建MCP3008.py文件；您需要按照以下步骤进行：
-
在您的树莓派 Zero 上打开终端。
-
在您的树莓派终端中输入界面。
-
在使用之前使用
nano非常重要。 -
输入
sudo nano MCP3008.py。
它将出现在屏幕上，我们将描述以下行：
- 导入库：
import spidev1
import os1
- 打开 SPI 总线：
spi1 = spidev1.SpiDev1()
spi1.open(0,0)
- 定义 ADC MCP2008 的通道：
def ReadChannel1(channel1):
adc1 = spi1.xfer2([1,(8+channel1)<<4,0])
data1 = ((adc1[1]&3) << 8) + adc1[2]
return data1
- 转换电压的函数如下：
def volts(data1,places1):
volts1 = (data1 * 3.3) / float(1023)
volts1 = round(volts1,places1)
return volts1
- 转换温度的函数如下：
def Temp(data1,places1):
temp1 = (data1 * 0.0032)*100
temp1 = round(temp1,places1)
return temp1
- 定义 ADC 的通道：
channels = 0
- 定义读取时间：
delay = 10
- 读取温度的函数如下：
while True:
temp = Channels(temp)
volts = Volts(temp1,2)
temp = Temp(temp1,2)
- 打印结果：
print"**********************************************"
print("Temp : {} ({}V) {} degC".format(temp1,volts,temp))
- 每 5 秒等待：
Time1.sleep(delay)
- 使用以下命令运行 Python 文件：
**sudo python MCP3008.py**
- 在下一个屏幕上，我们可以看到温度、ADC 测量值和根据温度的电压：
连接 RTC
要控制系统，拥有一个可以读取时间的电路非常重要；它可以帮助控制树莓派的输出或在特定时间检测动作。我们将使用RTC模块DS3231与树莓派进行接口。
I2C 设置
第一步是通过执行以下步骤启用I2C接口：
-
选择高级选项：
-
启用I2C选项，如下截图所示：
-
在下一个屏幕上选择
： 
-
选择
： 
-
然后选择
： 
-
接下来，选择
： 
DS3231 模块设置
DS3231 模块是一个实时时钟。它可以用于从集成电路获取时间和日期，因此可以与您的系统一起工作，以控制您想要从嵌入式芯片编程的特定事件。它可以与树莓派 Zero 完美配合，以实时获取时间和日期。
您需要确保您有最新的更新。为此，请在终端中输入以下命令：
**sudo apt-get update**
**sudo apt-get -y upgrade**
使用以下命令修改系统文件：
**sudo nano /etc/modules**
将以下行添加到modules.txt文件中：
**snd-bcm2835
i2c-bcm2835
i2c-dev
rtc-ds1307**
硬件设置
在本节中，我们将查看 RTC 模块的引脚：
DS3231 Pi GPIO
GNDP 1-06
VCC (3.3V)
SDA (I2CSDA)
SCL (I2CSCL)
这是 RTC 模块，我们可以看到芯片的引脚：
以下图表显示了电路连接：
以下图片显示了最终的连接：
测试 RTC
打开终端，输入以下内容：
**sudo i2cdetect -y 1**
您应该看到类似于以下截图的内容：
I2C 设备设置
下一步是检查时间时钟是否与 RTC 时间同步。在这里我们定义 RTC 本地：
**sudo nano /etc/rc.local**
将以下行添加到文件中，因为我们声明了新设备和我们配置的路径：
echo ds1307 0x68 > /sys/class/i2c-adapter/i2c-1/new_device
以下命令将启动 RTC：
**hwclock -s**
执行此命令后，重新启动 Pi。您将看到以下屏幕，这意味着 RTC 已配置并准备好工作：
将实时时钟进行最终测试
您可以使用以下命令读取 Pi 时间系统：
**date**
一旦 RTC 准备就绪，您可以使用以下命令进行测试；将时间写入 RTC：
**sudo hwclock -w**
您可以使用此处给出的命令从 RTC 读取时间：
**sudo hwclock -r**
现在进行最终命令。使用此命令，我们可以看到以下截图中显示的时间值：
总结
在本章中，您学习了如何使用 MCP3008 ADC 转换器，以及如何使用树莓派 Zero 使用温度传感器。我们探索了 GPIO 端口及其各种接口。我们看了看可以使用 GPIO 连接到树莓派的各种东西。
在下一章中，我们将深入研究更多的硬件采集，连接不同类型的传感器到我们的树莓派 Zero 和 Arduino 板。这将帮助您在项目中进行真实的测量。非常有趣 - 继续努力！
第三章：连接传感器-测量真实的事物
本书的目标是建立一个家庭安全系统，通过电子控制系统和传感器控制家用电器，并从仪表板监控它们。首先，我们需要考虑我们的传感器连接到一个可以读取信号并将其传输到网络的终端设备。
对于终端设备，我们将使用 Arduino 板从传感器中获取读数。我们可以看到树莓派没有模拟输入。因此，我们使用 Arduino 板来读取这些信号。
在上一章中，我们讨论了如何将设备连接到树莓派；在本节中，我们将看到如何将传感器与 Arduino 板进行接口，以了解如何从不同应用程序中读取真实信号进行实际测量。本章将涵盖以下主题：
-
使用流量传感器计算水的体积
-
使用传感器测量气体浓度
-
使用传感器测量酒精浓度
-
使用传感器检测火灾
-
为植物测量湿度
-
测量容器中的水位
-
测量温度、湿度和光，并在 LCD 中显示数据
-
使用 PIR 传感器检测运动
-
使用铁磁开关检测门是否打开
-
使用指纹传感器检测谁可以进入房屋
重要的是要考虑到我们需要将我们的系统与现实世界进行通信。由于我们正在建立一个家庭安全系统，我们需要学习如何连接和与一些必要的传感器进行交互，以在我们的系统中使用它们。
在下一节中，我们将介绍您在家居自动化和安全系统中需要读取的数据的传感器。
测量流量传感器以计算水的体积
我们需要对家中使用的水进行自动测量。为此项目，我们将使用传感器进行此读数，并使测量自动化。
要完成这个项目，我们需要以下材料：
流水传感器和 Arduino UNO 板：
硬件连接
现在我们有了流量传感器的连接。我们可以看到它有三个引脚--红色引脚连接到+VCC 5 伏特，黑色引脚连接到 GND，黄色引脚连接到 Arduino 板的引脚 2，如下图所示：
读取传感器信号
中断用于计算通过水流的脉冲，如下所示：
attachInterrupt(0, count_pulse, RISING);
中断类型为RISING，计算从低状态到高状态的脉冲：
**Function for counting pulses:**
voidcount_pulse()
{
pulse++;
}
使用 Arduino 读取和计数脉冲
在代码的这一部分中，我们解释了它如何使用中断来计算传感器的信号，我们已将其配置为RISING，因此它会计算从数字信号零到数字信号一的脉冲：
int pin = 2;
volatile unsigned int pulse;
constintpulses_per_litre = 450;
void setup()
{
Serial.begin(9600);
pinMode(pin, INPUT);
attachInterrupt(0, count_pulse, RISING);
}
void loop()
{
pulse=0;
interrupts();
delay(1000);
noInterrupts();
Serial.print("Pulses per second: ");
Serial.println(pulse);
}
voidcount_pulse()
{
pulse++;
}
打开 Arduino 串行监视器，并用嘴对水流传感器吹气。每个循环中每秒脉冲的数量将打印在 Arduino 串行监视器上，如下截图所示：
根据计数的脉冲计算水流速
在这部分中，我们测量脉冲并将其转换为水流，步骤如下：
-
打开新的 Arduino IDE，并复制以下草图。
-
验证并上传 Arduino 板上的草图。
int pin = 2;
volatile unsigned int pulse;
constintpulses_per_litre = 450;
void setup()
{
Serial.begin(9600);
pinMode(pin, INPUT);
attachInterrupt(0, count_pulse, RISING);
}
- 以下代码将计算从传感器读取的脉冲；我们将每秒计数的脉冲数除以脉冲数：
void loop()
{
pulse = 0;
interrupts();
delay(1000);
noInterrupts();
Serial.print("Pulses per second: ");
Serial.println(pulse);
Serial.print("Water flow rate: ");
Serial.print(pulse * 1000/pulses_per_litre);
Serial.println(" milliliters per second");
delay(1000);
}
void count_pulse()
{
pulse++;
}
- 打开 Arduino 串行监视器，并用嘴吹气通过水流传感器。每个循环中脉冲的数量和每秒的水流速将打印在 Arduino 串行监视器上，如下截图所示：
计算水流和水的体积：
现在你可以将代码复制到一个名为Flow_sensor_measure_volume.ino的文件中，或者直接从这个项目的文件夹中获取完整的代码。
在这部分中，我们从传感器计算流量和体积：
int pin = 2;
volatile unsigned int pulse;
float volume = 0;
floatflow_rate =0;
constintpulses_per_litre = 450;
我们设置中断：
void setup()
{
Serial.begin(9600);
pinMode(pin, INPUT);
attachInterrupt(0, count_pulse, RISING);
}
启动中断：
void loop()
{
pulse=0;
interrupts();
delay(1000);
noInterrupts();
然后我们显示传感器的流速：
Serial.print("Pulses per second: ");
Serial.println(pulse);
flow_rate = pulse * 1000/pulses_per_litre;
我们计算传感器的体积：
Serial.print("Water flow rate: ");
Serial.print(flow_rate);
Serial.println(" milliliters per second");
volume = volume + flow_rate * 0.1;
我们显示毫升的体积：
Serial.print("Volume: ");
Serial.print(volume);
Serial.println(" milliliters");
}
计算脉冲的函数如下：
Void count_pulse()
{
pulse++;
}
结果可以在下面的截图中看到：
在 LCD 上显示测量参数
您可以在新建的水表上添加 LCD 屏幕，以显示读数，而不是在 Arduino 串行监视器上显示它们。然后，在将草图上传到 Arduino 后，您可以将水表从计算机上断开连接。
首先，我们定义 LCD 库：
#include <LiquidCrystal.h>
然后我们定义程序中将使用的变量：
int pin = 2;
volatile unsigned int pulse;
float volume = 0;
floatflow_rate = 0;
constintpulses_per_litre = 450;
我们定义 LCD 引脚：
// initialize the library with the numbers of the interface pins
LiquidCrystallcd(12, 11, 6, 5, 4, 3);
我们定义传感的中断：
void setup()
{
Serial.begin(9600);
pinMode(pin, INPUT);
attachInterrupt(0, count_pulse, RISING);
现在我们在 LCD 上显示消息：
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
// Print a message to the LCD.
lcd.print("Welcome...");
delay(1000);
}
我们现在在主循环中定义中断：
void loop()
{
pulse = 0;
interrupts();
delay(1000);
noInterrupts();
我们在 LCD 上显示数值：
lcd.setCursor(0, 0);
lcd.print("Pulses/s: ");
lcd.print(pulse);
flow_rate = pulse*1000/pulses_per_litre;
然后我们显示传感器的流速：
lcd.setCursor(0, 1);
lcd.print(flow_rate,2);//display only 2 decimal places
lcd.print(" ml");
我们现在显示体积的值：
volume = volume + flow_rate * 0.1;
lcd.setCursor(8, 1);
lcd.print(volume, 2);//display only 2 decimal places
lcd.println(" ml ");
}
然后我们定义计算脉冲的函数：
void count_pulse()
{
pulse++;
}
水流的连接如下图所示：
以下图片显示了 LCD 上的测量结果：
您可以在 LCD 屏幕上看到一些信息，例如每秒脉冲、水流速和从时间开始的总水量。
测量气体浓度
在我们的系统中有一个检测气体的传感器是很重要的，这样我们就可以将其应用在家里，以便检测气体泄漏。现在我们将描述如何连接到 Arduino 板并读取气体浓度。
在这一部分，我们将使用一个气体传感器和甲烷 CH4。在这种情况下，我们将使用一个可以检测 200 到 10000ppm 浓度的 MQ-4 传感器。
该传感器在输出中具有模拟电阻，并可以连接到 ADC；它需要 5 伏的线圈激励。传感器的图像如下所示：
我们可以在www.sparkfun.com/products/9404找到 MQ-4 传感器的信息。
传感器和 Arduino 板的连接
根据前面的图表，我们现在将在下面的图像中看到所做的连接：
打开 Arduino IDE，并复制以下草图：
void setup(){
Serial.begin(9600);
}
void loop()
{
float vol;
int sensorValue = analogRead(A0);
vol=(float)sensorValue/1024*5.0;
Serial.println(vol,1);
Serial.print("Concentration of gas= ");
Serial.println(sensorValue);
delay(2000);
}
我们在屏幕上看到以下结果：
用传感器测量酒精的浓度
在这一部分，我们将构建一个非常酷的项目：您自己的酒精 呼吸分析仪。为此，我们将使用一个简单的 Arduino Uno 板以及一个乙醇气体传感器：
以下图表显示了传感器与 Arduino 的连接：
现在我们将为项目编写代码。在这里，我们将简单地介绍代码的最重要部分。
现在你可以将代码复制到名为Sensor_alcohol.ino的文件中，或者直接从该项目的文件夹中获取完整的代码：
int readings=0;
void setup(){
Serial.begin(9600);
}
void loop(){
lectura=analogRead(A1);
Serial.print("Level of alcohol= ");
Serial.println(readings);
delay(1000);
}
当它没有检测到酒精时，我们可以看到 Arduino 读取的数值：
如果检测到酒精，我们可以看到 Arduino 从模拟读取的数值，如下截图所示：
使用传感器检测火灾
如果我们家中有火灾，及时检测是至关重要的；因此，在下一节中，我们将创建一个使用传感器检测火灾的项目。
在下图中，我们看到了火灾传感器模块：
现在你可以将代码复制到名为Sensor_fire.ino的文件中，或者直接从该项目的文件夹中获取完整的代码。
我们在程序开始时为程序定义变量：
int ledPin = 13;
int inputPin= 2;
int val = 0;
我们定义输出信号和串行通信：
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(inputPin, INPUT);
Serial.begin(9600);
}
现在我们显示数字信号的值：
void loop(){
val = digitalRead(inputPin);
Serial.print("val : ");
Serial.println(val);
digitalWrite(ledPin, HIGH); // turn LED ON
然后我们进行比较：如果数值检测到高逻辑状态，它会关闭输出；如果读取相反的数值，它会打开数字信号；这意味着它已经检测到火灾：
if (val == HIGH) {
Serial.print("NO Fire detected ");
digitalWrite(ledPin, LOW); // turn LED OFF
}
else{
Serial.print("Fire DETECTED ");
digitalWrite(ledPin, HIGH);
}
}
当 Arduino 板检测到火灾时，它将在数字输入中读取*1*，这意味着没有检测到火灾：
如果检测到火灾，数字输入从数字输入读取*0*逻辑：
测量植物的湿度
在本节中，我们将看到使用传感器测试植物和土壤中的湿度：
我现在将介绍这段代码的主要部分。然后我们设置串行通信：
int value;
void setup() {
Serial.begin(9600);
}
在主循环中，我们将从传感器读取模拟信号：
void loop(){
Serial.print("Humidity sensor value:");
Value = analogRead(0);
Serial.print(value);
我们比较传感器的数值，并在串行接口上显示结果：
if (Value<= 300)
Serial.println(" Very wet");
if ((Value > 300) and (Value<= 700))
Serial.println(" Wet, do not water");
if (Value> 700)
Serial.println(" Dry, you need to water");
delay(1000);
}
这里，截图显示了读数的结果：
以下截图显示植物不需要水；因为土壤中已经有足够的湿度：
测量容器中的水位
有时，我们需要测量容器中的水位，或者如果你想看到水箱中的水位，测量它所含水量是必要的；因此，在本节中，我们将解释如何做到这一点。
传感器通常是打开的。当水超过限制时，接点打开，并向 Arduino 板发送信号。我们使用数字输入的引脚号2：
在程序中声明变量和const：
const int buttonPin = 2; // the number of the input sensor pin
const int ledPin = 13; // the number of the LED pin
我们还定义数字信号的状态：
// variables will change:
intbuttonState = 0; // variable for reading the pushbutton status
我们配置程序的信号、输入和输出：
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
Serial.begin(9600);
}
读取数字输入的状态：
void loop() {
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
我们对传感器进行比较：
if (buttonState == HIGH) {
Serial.println(buttonState);
Serial.println("The recipient is fulled");
digitalWrite(ledPin, HIGH);
delay(1000);
}
如果传感器检测到低水平，容器是空的：
else {
digitalWrite(ledPin, LOW);
Serial.println(buttonState);
Serial.println("The recipient is empty");
delay(1000);
}
}
以下截图显示了容器为空时的结果：
水超过限制：
测量温度、湿度和光线，并在 LCD 上显示数据
在本节中，我将教你如何在 LCD 屏幕上监测温度、湿度和光线检测。
硬件和软件要求
在这个项目中，你将使用 Arduino UNO 板；但你也可以使用 Arduino MEGA，它也可以完美地工作。
对于温度读数，我们需要一个 DHT11 传感器、一个 4.7k 电阻、一个光敏电阻（光传感器）和一个 10k 电阻。
还需要一个 16 x 2 的 LCD 屏幕，您可以在其中进行测试；我使用了一个 I2C 通信模块，用于与 Arduino 板接口的屏幕。我建议使用这种通信，因为只需要 Arduino 的两个引脚来发送数据：
最后，它需要一个面包板和公对公和母对公的电缆进行连接。
以下是项目的组件清单：
-
Arduino UNO
-
温湿度传感器 DHT11
-
LCD 屏幕 16 x 2
-
LCD 的 I2C 模块
-
一个面包板
-
电缆
我们连接不同的组件：
在这里，我们可以看到温湿度 DHT11 传感器的图像：
然后将DHT11 传感器（VCC）的引脚号1连接到面包板上的红线，引脚4（GND）连接到蓝线。还要将传感器的引脚号2连接到 Arduino 板的引脚号7。最后，将 4.7k 欧姆的电阻连接到传感器的引脚号1和2之间。
在面包板上串联一个 10k 欧姆的电阻。然后将光敏电阻的另一端连接到面包板上的红线，电阻的另一端连接到蓝线（地线）。最后，将光敏电阻和电阻之间的公共引脚连接到 Arduino 模拟引脚A0。
现在让我们连接 LCD 屏幕。由于我们使用的是带有 I2C 接口的 LCD 屏幕，因此只需要连接两根信号线和两根电源线。将 I2C 模块的引脚VDC连接到面包板上的红线，GND引脚连接到面包板上的蓝线。然后将SDA引脚模块连接到 Arduino 引脚A4，A5 SCL引脚连接到 Arduino 的引脚：
这是项目的完全组装图像，这样您就可以对整个项目有一个概念：
测试传感器
现在硬件项目已经完全组装好，我们将测试不同的传感器。为此，我们将在 Arduino 中编写一个简单的草图。我们只会读取传感器数据，并将这些数据打印在串行端口上。
您现在可以将代码复制到名为Testing_sensors_Temp_Hum.ino的文件中，或者只需从此项目的文件夹中获取完整的代码。
首先我们定义库：
#include "DHT.h"
#define DHTPIN 7
#define DHTTYPE DHT11
我们定义传感器的类型：
DHT dht(DHTPIN, DHTTYPE);
然后我们配置串行通信：
void setup()
{
Serial.begin(9600);
dht.begin();
}
我们读取传感器数值：
void loop()
{
float temp = dht.readTemperature();
float hum = dht.readHumidity();
float sensor = analogRead(0);
float light = sensor / 1024 * 100;
我们在串行接口上显示数值：
Serial.print("Temperature: ");
Serial.print(temp);
Serial.println(" C");
Serial.print("Humidity: ");
Serial.print(hum);
Serial.println("%");
Serial.print("Light: ");
Serial.print(light);
Serial.println("%");
delay(700);
}
将代码下载到 Arduino 板上，并打开串行监视器以显示发送的数据。重要的是要检查串行端口的传输速度，必须为 9600。您应该看到以下内容：
在 LCD 上显示数据
现在下一步是将我们的信息集成到 LCD 屏幕上显示。传感器读数部分将保持不变，只是在通信和在 LCD 上显示数据方面进行了详细说明。以下是这部分的完整代码，以及解释。
您现在可以将代码复制到名为LCD_sensors_temp_hum.ino的文件中，或者只需从此项目的文件夹中获取完整的代码。
我们为程序包括库：
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include "DHT.h"
#define DHTPIN 7
#define DHTTYPE DHT11
我们为 LCD 定义 LCD 地址：
LiquidCrystal_I2C lcd(0x3F,16,2);
DHT dht(DHTPIN, DHTTYPE);
我们启动 LCD 屏幕：
void setup()
{
lcd.init();
lcd.backlight();
lcd.setCursor(1,0);
lcd.print("Hello !!!");
lcd.setCursor(1,1);
lcd.print("Starting ...");
我们定义dht传感器的开始：
dht.begin();
delay(2000);
lcd.clear();
}
我们读取传感器并将数值保存在变量中：
void loop()
{
float temp = dht.readTemperature();
float hum = dht.readHumidity();
float sensor = analogRead(0);
float light = sensor / 1024 * 100;
我们在 LCD 屏幕上显示数值：
lcd.setCursor(0,0);
lcd.print("Temp:");
lcd.print(temp,1);
lcd.print((char)223);
lcd.print("C");
lcd.setCursor(0,1);
lcd.print("Hum:");
lcd.print(hum);
lcd.print("%");
lcd.setCursor(11,1);
//lcd.print("L:");
lcd.print(light);
lcd.print("%");
delay(700);
}
下一步是在 Arduino 板上下载示例；稍等片刻，您将在 LCD 上看到显示读数。以下是项目运行的图像：
使用 PIR 传感器检测运动
我们将建立一个带有常见家庭自动化传感器的项目：运动传感器（PIR）。你是否注意到过那些安装在房屋某些房间顶角的小白色塑料模块，当有人走过时会变成红色的模块？这正是我们这个项目要做的事情。
运动传感器必须有三个引脚：两个用于电源供应，一个用于信号。你还应该使用 5V 电压级别以与 Arduino 卡兼容，Arduino 卡也是在 5V 下运行的。以下图片显示了一个简单的运动传感器：
出于实际目的，我们将使用信号输入 8 来连接运动传感器，5 伏特的信号电压和地GND。
PIR 传感器与 Arduino 接口
PIR 传感器检测体热（红外能量）。被动红外传感器是家庭安全系统中最常用的运动检测器。一旦传感器变热，它就可以检测周围区域的热量和运动，形成一个保护网格。如果移动物体阻挡了太多的网格区域，并且红外能量水平迅速变化，传感器就会被触发。
在这一点上，我们将测试 Arduino 和运动传感器之间的通信。
我们定义变量和串行通信，定义数字引脚 8，输入信号，读取信号状态，并显示传感器的状态信号：
**int sensor = 8;**
**void setup() {**
**Serial.begin(9600);**
**pinMode(sensor,INPUT);**
**}**
**void loop(){**
**// Readind the sensor**
**int state = digitalRead(sensor);**
**Serial.print("Detecting sensor: ");**
**Serial.println(state);**
**delay(100);**
**}**
使用铁簧管检测门是否打开
已添加一个示例作为选项，以实现磁传感器来检测门或窗户何时打开或关闭。
使用铁簧管检测门是否打开
传感器在检测到磁场时输出0，当磁场远离时输出为1；因此你可以确定门是打开还是关闭。
Arduino 中的程序执行如下：
我们定义传感器的输入信号，并配置串行通信：
void setup() {
pinMode(sensor, INPUT_PULLUP);
Serial.begin(9600);
}
我们读取传感器的状态：
void loop() {
state = digitalRead(sensor);
它比较数字输入并在串行接口中显示门的状态：
if (state == LOW){
Serial.println("Door Close");
}
if (state == HIGH){
Serial.println("Door Open");
}
}
使用指纹传感器检测谁可以进入房屋
在本节中，我们将创建一个可以帮助我们建立完整安全系统的项目。在这个项目中，指纹访问将通过使用指纹传感器读取指纹来实现，如下图所示：
在这部分，我们将看到如何连接和配置我们的硬件，以便激活继电器。
硬件配置：
像往常一样，我们将使用 Arduino Uno 板作为项目的大脑。这个项目最重要的部分是指纹传感器。
首先，我们将看到如何组装这个项目的不同部分。让我们从连接电源开始。将 Arduino 板上的5V引脚连接到红色电源轨，将 Arduino 的GND连接到面包板上的蓝色电源轨。
现在，让我们连接指纹传感器。首先，通过将电缆连接到面包板上的相应颜色来连接电源。然后，将传感器的白色线连接到 Arduino 引脚 3，将绿色线连接到引脚 2。
之后，我们将连接继电器模块。将VCC引脚连接到红色电源轨，GND引脚连接到蓝色电源轨，将EN引脚连接到 Arduino 引脚 7：
保存指纹：
以下示例用于直接从库Adafruit_Fingerprint注册 ID 的指纹。
首先，我们定义库：
#include <Adafruit_Fingerprint.h>
#include <SoftwareSerial.h>
我们定义读取的 ID 和注册过程的功能：
uint8_t id;
uint8_tgetFingerprintEnroll();
我们定义与设备的串行通信：
SoftwareSerialmySerial(2, 3);
Adafruit_Fingerprint finger = Adafruit_Fingerprint(&mySerial);
我们声明传感器的实例：
//Adafruit_Fingerprint finger = Adafruit_Fingerprint(&Serial1);
我们设置并显示传感器是否正在配置：
void setup()
{
while (!Serial);
delay(500);
我们显示传感器确认：
Serial.begin(9600);
Serial.println("Adafruit Fingerprint sensor enrollment");
// set the data rate for the sensor serial port
finger.begin(57600);
我们识别传感器是否检测到：
if (finger.verifyPassword()) {
Serial.println("Found fingerprint sensor!");
} else {
Serial.println("Did not find fingerprint sensor :(");
while (1);
}
}
uint8_treadnumber(void) {
uint8_tnum = 0;
booleanvalidnum = false;
while (1) {
while (! Serial.available());
char c = Serial.read();
if (isdigit(c)) {
num *= 10;
num += c - '0';
validnum = true;
} else if (validnum) {
returnnum;
}
}
}
我们显示注册 ID：
void loop() // run over and over again
{
Serial.println("Ready to enroll a fingerprint! Please Type in the ID # you want to save this finger as...");
id = readnumber();
Serial.print("Enrolling ID #");
Serial.println(id);
while (! getFingerprintEnroll() );
}
注册的功能如下：
uint8_tgetFingerprintEnroll() {
int p = -1;
Serial.print("Waiting for valid finger to enroll as #"); Serial.println(id);
while (p != FINGERPRINT_OK) {
p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image taken");
break;
case FINGERPRINT_NOFINGER:
Serial.println(".");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
break;
default:
Serial.println("Unknown error");
break;
}
}
如果传感器成功读取图像，您将看到以下内容：
p = finger.image2Tz(1);
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
return p;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
return p;
case FINGERPRINT_INVALIDIMAGE:
如果无法找到指纹特征，您将看到以下内容：Serial.println("无法找到指纹特征");
return p;
default:
Serial.println("Unknown error");
return p;
}
移除指纹传感器：
Serial.println("Remove finger");
delay(2000);
p = 0;
while (p != FINGERPRINT_NOFINGER) {
p = finger.getImage();
}
Serial.print("ID "); Serial.println(id);
p = -1;
Serial.println("Place same finger again");
while (p != FINGERPRINT_OK) {
p = finger.getImage();
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image taken");
break;
case FINGERPRINT_NOFINGER:
Serial.print(".");
break;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
break;
case FINGERPRINT_IMAGEFAIL:
Serial.println("Imaging error");
break;
default:
Serial.println("Unknown error");
break;
}
}
指纹传感器的图像：
p = finger.image2Tz(2);
switch (p) {
case FINGERPRINT_OK:
Serial.println("Image converted");
break;
case FINGERPRINT_IMAGEMESS:
Serial.println("Image too messy");
return p;
case FINGERPRINT_PACKETRECIEVEERR:
Serial.println("Communication error");
return p;
case FINGERPRINT_FEATUREFAIL:
Serial.println("Could not find fingerprint features");
return p;
case FINGERPRINT_INVALIDIMAGE:
Serial.println("Could not find fingerprint features");
return p;
default:
Serial.println("Unknown error");
return p;
}
如果正确，您将看到以下内容：
Serial.print("Creating model for #"); Serial.println(id);
p = finger.createModel();
if (p == FINGERPRINT_OK) {
Serial.println("Prints matched!");
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println("Communication error");
return p;
} else if (p == FINGERPRINT_ENROLLMISMATCH) {
Serial.println("Fingerprints did not match");
return p;
} else {
Serial.println("Unknown error");
return p;
}
显示传感器的结果：
Serial.print("ID "); Serial.println(id);
p = finger.storeModel(id);
if (p == FINGERPRINT_OK) {
Serial.println("Stored!");
} else if (p == FINGERPRINT_PACKETRECIEVEERR) {
Serial.println("Communication error");
return p;
} else if (p == FINGERPRINT_BADLOCATION) {
Serial.println("Could not store in that location");
return p;
} else if (p == FINGERPRINT_FLASHERR) {
Serial.println("Error writing to flash");
return p;
} else {
Serial.println("Unknown error");
return p;
}
}
测试传感器
打开串行监视器，然后输入在上一步保存的 ID 号码：
以下截图表明您应该再次将同一手指放在传感器上：
以下截图显示传感器响应表明数字指纹已成功保存：
摘要
在本章中，我们看到如何与连接到 Arduino 板的不同传感器进行交互，例如用于能源消耗的流量电流，检测家庭风险，实施气体传感器，实施流水传感器以测量水量，制作安全系统，并使用指纹传感器控制访问。所有这些传感器都可以集成到一个完整的系统中，用于监控和控制您在任何项目上工作的一切。
在下一章中，我们将看到如何集成所有内容，监控和控制一个完整的系统，并在仪表板上读取 Arduino 板和树莓派 Zero 作为中央接口的传感器和执行器。
第四章：控制连接的设备
在本章中，我们将看看如何使用我们的 Raspberry Pi Zero 和 Arduino UNO 从远程站点控制设备，使用以下模块在网络中进行通信：Wi-Fi shield 和 Ethernet shield。我们将在本章中涵盖以下主题：
-
使用 Node.js 创建一个简单的 Web 服务器
-
使用 Restful API 和 Node.js 从 Raspberry Pi Zero 控制继电器
-
在计算机上配置 Node.js 作为 Web 服务器
-
使用 Node.js 和 Arduino Wi-Fi 监控温度、湿度和光线
-
使用 Node.js 和 Arduino Ethernet 监控温度、湿度和光线
使用 Node.js 创建一个简单的 Web 服务器
拥有 Raspberry Pi 最重要的一个方面是我们有一个配置了服务和服务器的真正的计算机。在本节中，我们将解释如何安装 Node.js，这是一个强大的框架，我们将用它来运行我们将在本书中看到的大多数应用程序。幸运的是，我们在 Raspberry Pi 上安装 Node.js 非常简单。
在本章的文件夹中，打开名为webserver.js的文件。我们将在端口8056上创建一个服务器。要测试程序并查看结果，我们必须在 MS-DOS 界面上打开 Node.js 终端，并使用以下命令运行此文件：
**node webserver.js**
添加以下行到webserver.js文件中声明 HTTP 请求命令：
var http = require('http');
我们使用以下函数创建服务器：
http.createServer(function (req, res) {
我们定义将在 HTML 代码中显示的文件内容：
res.writeHead(200, {'Content-Type': 'text/plain'});
我们从服务器发送响应：
res.end('Hello from Node.js');
重要的是要定义要打开的端口：
}).listen(8056);
显示服务器的消息：
console.log('Server running at port 8056');
要测试此程序，请在本地计算机上打开浏览器，导航到以下链接：http://192.168.1.105:8056。如果您看到以下屏幕；您的 Node.js 服务器在您的计算机上运行正常；您需要更改计算机的 IP 地址：
使用 Restful API 和 Node.js 从 Raspberry Pi Zero 控制继电器
在本节中，我们将向您展示如何控制连接到 Arduino UNO 板的继电器模块，以及用于从 Web 浏览器发送命令的继电器。让我们开始吧。
JSON 结构
JavaScript 对象表示法 (JSON) 是一种轻量级的数据交换格式。它易于人类阅读和编写。它易于机器解析和生成。它基于 JavaScript 编程语言的一个子集。
JSON 建立在两种结构上：
-
一组名称/值对。在各种语言中，这被实现为对象、记录、结构、字典、哈希表、键控列表或关联数组。
-
一系列值的有序列表。在大多数语言中，这被实现为数组、向量、列表或序列。
首先，我们需要知道如何应用我们用来描述这个结构的 JSON 格式，如下所示：
{"data": "Pin D6 set to 1", "id": "1", "name": "Arduino", "connected": true}
这是我们需要遵循并使响应的格式：
-
数据：定义命令的编号，然后描述命令的定义
-
名称：跟随设备的名称
-
已连接：确认设备是否已连接
所有在{ }之间的数据定义了我们的 JSON 格式。
使用 aREST API 的命令
使用aREST命令，我们可以定义我们的 Arduino 和设备，然后从 Web 浏览器控制它们。以下是aREST API 的命令示例：
-
设备的 IP 地址/模式/6/o：这将配置数字引脚 6 为输出引脚 -
设备的 IP 地址/digital/6/1：配置输出 6 并使函数像数字写入一样。例如：http://192.168.1.100/digital/6/1；我们定义设备的 IP 地址和将被激活的引脚的编号。
在您的 Raspberry Pi Zero 上安装 Node.js
Node.js 是一个工具，它将允许我们使用 JavaScript 代码在设备上创建运行的服务器。最重要的是，我们将应用这个框架来使用这段代码构建一个 Web 服务器。
使用 Node.js 意味着我们配置了一个将打开端口并连接到 Web 服务器的设备的 Web 服务器。
使用以下命令，您将在树莓派 Zero 上安装 Node.js：
**sudo apt-get install nodejs**
NPM 是 Node.js 的 JavaScript 运行时环境的默认包管理器。要配置和安装aREST模块，请在终端中输入以下命令：
**sudo npm install arest**
Express 的理念是为 HTTP 服务器提供小巧、强大的工具，使其成为单页应用程序、网站、混合应用程序或公共 HTTP API 的绝佳解决方案。
我们还需要使用以下命令配置 express 模块：
**sudo npm install express**
使用 aREST 命令从 Web 浏览器控制继电器
在接下来的部分中，我们将看到如何使用Rest命令从 Web 浏览器控制数字输出。让我们深入了解一下，以了解更多细节：
配置 Web 服务器
现在，您可以将代码复制到名为 outputcontrol.js 的文件中，或者只需从此项目的文件夹中获取完整的代码并使用 Node.js 执行它。在树莓派上打开终端并输入以下命令：
**sudo node output control.js**
我们通过以下方式定义设备的 GPIO 来导入命令：
var gpio = require('rpi-gpio');
现在我们将使用以下代码使用 Node.js 创建我们的 Web 服务器。
我们导入运行所需的 require 包。我们使用以下声明库：
var express = require('express');
var app = express();
定义 body 解析器并打开端口，在本例中为8099：
var Parser = require('body-parser');
var port = 8099;
使用 body-parser：
app.use(Parser.urlencoded({ extended: false }));
app.use(Parser.json());
配置GPIO 11，我们将控制它：
gpio.setup(11,gpio.DIR_OUT);
我们定义将从 Web 浏览器调用的函数。
函数的名称是ledon；它激活GPIO 11并向屏幕发送消息led1 is on：
function ledon() {
setTimeout(function() {
console.log('led1 is on');
gpio.write(11, 1);
}, 2000);
}
函数的名称是ledoff；它关闭GPIO 11并向屏幕发送消息led1 is off：
function ledoff() {
setTimeout(function() {
console.log('led1 is off');
gpio.write(11, 0);
}, 2000);
}
我们定义了GET函数，这意味着当浏览器接收到名为ledon的函数时，它会向服务器发出请求；服务器以以下格式做出响应：{status:"connected",led:"on"}。
现在我们将声明用于来自客户端的传入请求的 app 函数：
app.get('/ledon', function (req, res) {
ledon();
var data ={status:"connected",led:"on"};
res.json(data);
});
我们定义GET函数。这意味着当浏览器接收到名为/ledoff的函数时，它会向服务器发出请求；服务器以以下格式做出响应：{status:"connected",led:"off"}。
app.get('/ledoff', function (req, res) {
ledoff();
var data ={status:"connected",led:"off"};
res.json(data);
});
现在我们打开 Web 服务器的端口：
app.listen(port);
console.log('Server was started on ' + port);
如果一切正确，我们打开我们喜爱的浏览器并输入http://您的 Raspberry_PI_zero 的 IP 地址:端口/命令。
在这种情况下，我们输入 192.168.1.105:8099/ledon。
以下屏幕截图显示了 JSON 请求的响应：
接下来，我们将看到最终结果，如下图所示：
在计算机上配置 Node.js 作为 Web 服务器
Node.js 是一个开源的跨平台运行时环境，用于开发服务器端和网络应用程序。Node.js 应用程序是用 JavaScript 编写的，并可以在 OS X、Microsoft Windows 和 Linux 上的 Node.js 运行时环境中运行。
Node.js 还提供了丰富的各种 JavaScript 模块库，极大地简化了使用 Node.js 开发 Web 应用程序的过程。
在上一节中，我们在树莓派 Zero 上配置了 Node.js，现在在本节中，我们将使用 Windows 操作系统执行相同的操作，并配置我们的 Web 服务器 Node.js 在其上运行。
本节的主要目的是解释如何从在 Node.js 框架中运行的 Web 服务器控制我们的 Arduino 板。为此，安装它非常重要；我们的系统将在 Windows 计算机上运行。
在本节中，我们将解释如何在 Windows 上安装 Node.js。
下载 Node.js
首先，我们需要下载 Windows 64 位的 Node.js-它取决于您的操作系统版本，您只需要转到以下链接进行下载：nodejs.org/es/download/：
安装 Node.js
在下载了软件之后，按照以下步骤进行：
-
点击下一步按钮：
-
点击下一步按钮：
-
选择安装位置：
-
选择默认配置：
-
完成配置后，点击安装：
-
安装完成后我们将看到以下内容：
使用 Node.js 配置 web 服务器端口 8080
现在我们需要配置将要监听来自远程浏览器的打开连接的端口。打开本章文件夹中的文件，然后使用 Node.js 执行该文件。
现在你可以把代码复制到一个名为server.js的文件中，或者直接从这个项目的文件夹中获取完整的代码。
首先我们需要使用以下代码创建我们的服务器：
var server = require('http');
创建一个名为loadServer的函数，其中包含响应浏览器的代码：
function loadServer(requiere,response){
console.log("Somebody is connected");
如果这个函数响应数字 200，那么意味着连接已经建立，服务器工作正常：
response.writeHead(200,{"Content-Type":"text/html"});
response.write("<h1>The Server works perfect</h1>");
response.end();
}
创建并打开服务器端口：
server.createServer(loadServer).listen(8080);
在你的计算机上打开安装了 Node.js 服务器的终端，然后在 MS-DOS 界面中输入以下命令：
**C:\users\PC>node server.js**
现在，为了测试服务器是否运行，我们将在网页浏览器中输入localhost:端口号；你应该在屏幕上看到类似以下截图的内容：
http://localhost:8080
使用 Node.js 和 Arduino Wi-Fi 监控温度、湿度和光线
在本章的这部分，我们将解释 Arduino 的 Wi-Fi shield 的代码：
我们定义变量的数量；在这种情况下，我们将监控三个变量（温度、湿度和光线）：
#define NUMBER_VARIABLES 3
这里我们必须包含传感器的库：
#include "DHT.h"
我们定义传感器的引脚：
#define DHTPIN 7
#define DHTTYPE DHT11
我们定义传感器的实例：
DHT dht(DHTPIN, DHTTYPE);
我们导入模块的库：
#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <aREST.h>
我们定义连接模块的引脚：
using a breakout board
#define ADAFRUIT_CC3000_IRQ 3
#define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10
我们创建将要连接的模块的实例：
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS,
ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT);
我们定义 aREST 实例：
aREST rest = aREST();
然后我们定义 SSID 和密码，你需要进行更改：
#define WLAN_SSID "xxxxx"
#define WLAN_PASS "xxxxx"
#define WLAN_SECURITY WLAN_SEC_WPA2
我们配置端口以监听传入的 TCP 连接：
#define LISTEN_PORT 80
我们定义模块的服务器实例：
Adafruit_CC3000_Server restServer(LISTEN_PORT);
// DNS responder instance
MDNSResponder mdns;
我们定义将要发布的变量：
int temp;
int hum;
int light;
这里有一个设置，定义了串行通信的配置：
void setup(void)
{
// Start Serial
Serial.begin(115200);
dht.begin();
我们开始将要发布的变量：
rest.variable("light",&light);
rest.variable("temp",&temp);
rest.variable("hum",&hum);
我们定义设备的 ID 和名称：
rest.set_id("001");
rest.set_name("monitor");
我们连接到网络：
if (!cc3000.begin())
{
while(1);
}
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
while(1);
}
while (!cc3000.checkDHCP())
{
delay(100);
}
这里我们定义了连接设备的函数：
if (!mdns.begin("arduino", cc3000)) {
while(1);
}
我们在串行接口中显示连接：
displayConnectionDetails();
restServer.begin();
Serial.println(F("Listening for connections..."));
}
在这部分，我们声明将要获取的变量：
void loop() {
temp = (float)dht.readTemperature();
hum = (float)dht.readHumidity();
然后我们测量光线水平：
float sensor_reading = analogRead(A0);
light = (int)(sensor_reading/1024*100);
我们声明请求的函数：
mdns.update();
我们需要执行来自服务器的请求：
Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);
}
我们显示设备的网络配置：
bool displayConnectionDetails(void)
{
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&ipAddress, &netmask, &gateway, &dhcpserv, &dnsserv))
{
Serial.println(F("Unable to retrieve the IP Address!\r\n"));
return false;
}
else
{
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println();
return true;
}
}
在你的 Arduino 板上下载代码草图，然后转到串行监视器以查看从路由器获取的 IP 地址配置。之后，我们可以显示 Wi-Fi shield 的 IP 地址配置：
连接到 Wi-Fi 网络
现在我们可以看到你的 Arduino Wi-Fi shield 的 IP 地址，我们现在可以将我们的计算机连接到与 Arduino 板相同的网络。查看以下截图以获取更多细节：
为了测试应用程序，我们需要转到以下路径，并在安装了 Node.js 服务器的计算机上运行以下命令，或者如下截图所示：
在这个文件夹中，我们有 JavaScript 文件，输入命令 node app.js
在输入接口文件夹后，输入以下命令node app.js：
现在您已经启动了 Web 服务器应用程序，切换到浏览器，在同一台机器上输入机器的 IP 地址以查看结果：
服务器监听端口 300 后，它与 Wi-Fi 模块建立通信，向设备的 IP 地址发送请求：
使用 Node.js 与 Arduino Ethernet 监控温度、湿度和光照
在上一节中，我们展示了如何使用CC3000模块通过 Wi-Fi 监视我们的 Arduino；现在我们将使用另一个重要模块：以太网盾。部分的硬件连接类似于以下图像：
Arduino Ethernet 盾应用程序代码
现在您可以将代码复制到名为Monitor_Ethernet.ino的文件中，或者只需从此项目的文件夹中获取完整的代码；您需要使用 Arduino IDE。
以下是程序中包含的库：
#include <SPI.h>
#include <Ethernet.h>
#include <aREST.h>
#include <avr/wdt.h>
包括 DHT11 传感器的库：
#include "DHT.h"
我们定义温度和湿度传感器的引脚：
#define DHTPIN 7
#define DHTTYPE DHT11
我们有传感器的实例：
DHT dht(DHTPIN, DHTTYPE);
我们注册设备的 MAC 地址：
byte mac[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xFE, 0x40 };
IPAddress ip(192,168,1,153);
EthernetServer server(80);
我们现在创建aREST API 的实例：
aREST rest = aREST();
我们发布将被监视的变量：
int temp;
int hum;
int light;
我们现在配置串行通信并启动传感器的实例：
void setup(void)
{
// Start Serial
Serial.begin(115200);
dht.begin();
我们开始发布变量：
rest.variable("light",&light);
rest.variable("temp",&temp);
rest.variable("hum",&hum);
非常重要的是给出我们正在使用的设备的 ID 和名称：
rest.set_id("008");
rest.set_name("Ethernet");
我们开始以太网连接：
if (Ethernet.begin(mac) == 0) {
Serial.println("Failed to configure Ethernet using DHCP");
Ethernet.begin(mac, ip);
}
我们在串行监视器上显示 IP 地址：
server.begin();
Serial.print("server is at ");
Serial.println(Ethernet.localIP());
wdt_enable(WDTO_4S);
}
我们读取温度和湿度传感器：
void loop() {
temp = (float)dht.readTemperature();
hum = (float)dht.readHumidity();
我们测量传感器的光照水平：
float sensor_reading = analogRead(A0);
light = (sensor_reading/1024*100);
我们监听将连接的传入客户端：
EthernetClient client = server.available();
rest.handle(client);
wdt_reset();
}
现在我们已经完成了配置，打开一个网络浏览器并输入您的 Arduino Ethernet 盾的 IP 地址：http://192.168.1.153。如果一切顺利，它将显示以下屏幕，并显示来自板的 JSON 响应：
上述截图显示了 JSON 请求的结果。
在 Node.js 中配置设备
在本节中，我们将解释配置我们可以从网页控制的设备的代码。
在上一节中，我们安装了 express 包；如果遇到任何困难，只需打开终端并输入以下内容：
**npm install express**
我们定义节点 express 并创建应用程序：
var express = require('express');
var app = express();
然后我们定义要监听的端口：
var port = 3000;
我们定义 Jade 应用程序的实例，使用视图引擎：
app.set('view engine', 'jade');
我们配置公共文件夹：
app.use(express.static(__dirname + '/public'));
我们现在定义要监视的设备：
var rest = require("arest")(app);
rest.addDevice('http','192.168.1.153');
我们提供应用程序：
app.get('/', function(req, res){
res.render('interface');
});
我们启动服务器并在设备连接时发送消息：
app.listen(port);
console.log("Listening on port " + port);
在 MS-DOS 中打开终端并在 Node.js 服务器中执行app.js
要测试应用程序，请打开您的网络浏览器并输入http://localhost:3000；如果出现以下屏幕，恭喜，您已正确配置了服务器：
这里是我们在 Node.js 服务器中看到app.js执行的屏幕：
摘要
在本章中，您学习了如何使用树莓派 Zero 中的网络通信模块来控制 Arduino 板，在中央界面仪表板中。我们已经看到了如何从中央界面控制和监视设备；您可以使用其他传感器，例如气压传感器。
在下一章中，您将进行更多有趣的项目，例如将网络摄像头配置和连接到您的 Arduino 板，从您的 Raspberry Pi Zero 上进行监控。
第五章：将网络摄像头添加到监控安全系统
在之前的章节中，我们谈到了诸如连接到 Arduino 的传感器和从树莓派 Zero 监控，使用跨设备的网络，家庭安全项目的重要性以及家居自动化来监视现实世界中发生的事情。为此，我们为本章提出了一个建议。
在本章中，我们将配置我们的树莓派 Zero 来监视网络摄像头，并安装 TTL 串行摄像头以与 Arduino 板交互；我们将通过以下主题实现这一目标：
-
Arduino 和树莓派之间的交互
-
从树莓派 Zero 控制连接到 Arduino 的输出
-
将 TTL 串行摄像头连接到 Arduino 并将图片保存到 Micro SD
-
使用串行 TTL 摄像头检测运动
-
从树莓派控制快照
-
从网页控制您的摄像头
-
在网络中监控您的 USB 摄像头以确保安全
Arduino 和树莓派之间的交互
在本章中，我们将看看树莓派如何作为终端计算机来编程，不仅可以将设备作为服务器并部署页面或应用程序，还可以拥有用于编程 Arduino 板的集成开发环境。为此，我们需要将树莓派连接到 Arduino，以便它们可以相互通信。
这里有一些树莓派具有的接口，所有这些都包括在设备中：I2C 协议，SPI 通信，USB 端口和串行UART端口。在这种情况下，我们将使用 USB 端口在 Arduino 和树莓派之间进行通信。
以下是配置 Arduino 和树莓派相互交互的步骤：
-
为树莓派安装 Arduino IDE
-
用 PuTTY 打开您的终端并检查树莓派的 IP 地址
-
执行远程访问，并输入 IP 地址
-
在图形界面中打开 Arduino IDE
在 Raspbian 中安装 Arduino IDE
输入以下命令在树莓派上安装 Arduino IDE：
**sudo apt-get install arduino**
远程访问树莓派
在本节中，我们将查看访问远程桌面的屏幕，以执行安装在 Raspian 操作系统中的 Arduino IDE：一旦屏幕弹出，输入您的用户名和密码：
在图形界面中执行 Arduino
现在我们有了主屏幕，我们转到编程菜单，如果我们看到进入 Arduino IDE 的图标，那么一切都已安装。点击Arduino IDE的图标：
Raspian 中的 Arduino 界面
这里有 Arduino IDE 的界面，与我们在计算机上拥有的界面类似。从在树莓派上运行的 Arduino IDE 中，我们可以在两个板之间进行交互：
准备界面
我们需要验证我们选择了正确的板；在这种情况下，我们使用的是 Arduino UNO。在下一个窗口中选择板：
选择串行端口
在我们选择要使用的板之后，我们需要验证并选择将与我们的 Arduino 通信的端口，该端口连接到树莓派的 USB 端口上；我们需要选择端口名称：/dev/ttyACM0：
从图形界面下载草图
我们需要做的主要事情是从我们的树莓派 Zero 与 Arduino 进行通信，并将草图下载到 Arduino 板上，而不使用计算机，以便我们可以将树莓派用于其他目的。
以下截图显示了带有草图的界面：
我们应该在界面中下载草图。以下图片显示了连接的 Arduino-树莓派：太酷了！
从 Raspberry Pi Zero 控制连接到 Arduino 的输出
现在我们将看一个例子，使用 Python 从 Raspberry Pi 控制输出。
首先，我们需要将 sketch 下载到 Arduino 板上。为了测试我们的通信，我们将展示一个测试 Arduino 和 Raspberry Pi 之间链接的示例：
我们声明以下输出：
int led_output = 13;
我们从程序设置开始：
void setup () {
然后我们提到输出引脚：
pinMode(led_output, OUTPUT);
以 9600 开始串行通信：
Serial.begin(9600);
}
声明程序的循环：
void loop () {
这是我们检查串行端口是否可用的地方：
if (Serial.available() > 0){
如果找到了某些内容，则读取内容并将内容保存在c变量中：
char c = Serial.read();
如果读取了标记为高的字母H：
if (c == 'H'){
输出将打开连接到引脚13的 LED
digitalWrite(led_output, HIGH);
如果读取了标记为低的字母L：
}
else if (c == 'L'){
输出将关闭连接到引脚13的 LED：
digitalWrite(led_output, LOW);
}
}
}
从 Python 控制 Arduino 板
首先，我们需要安装串行库，因为这有助于通过 USB 端口通信与 Arduino 通信。键入以下命令以安装库：
**sudo apt-get install python-serial**
以下代码控制 Arduino 来自 Raspberry Pi；现在您可以将代码复制到名为ControlArduinoFromRasp.py的文件中，或者只需从此项目的文件夹中获取完整的代码。
以下片段在 Python 中导入串行库：
import serial
我们定义串行通信：
Arduino_UNO = serial.Serial('/dev/ttyACM0', 9600)
打印一条消息以查看通信是否完成：
print("Hello From Arduino!")
在执行此操作时，用户可以输入命令：
while True:
command = raw_input('Enter the command ')
Arduino_UNO.write(command)
如果是H，它会打印消息；如果为假，则显示 LED 关闭：
if command == 'H':
print('LED ON')
elif command == 'L':
print('LED OFF')
关闭连接：
arduino_UNO.close()
硬件连接
这是连接到 Arduino UNO 的 LED，可以使用 Python 从 Raspberry Pi 进行控制：
将 TTL 串行相机连接到 Arduino 并将照片保存到微型 SD 卡
在这里，我们有模式图，显示了微型 SD 卡与 TTL 串行相机的连接；我使用的是 Adafruit 的相机型号。以下链接包含您需要的所有信息，www.adafruit.com/product/397。在下图中，我们有项目的连接：
现在我们将解释如何拍照并将其保存到微型 SD 卡；主要想法是将相机连接到 Arduino，这样我们可以在家庭安全监控系统中实现这一点。
以下是用于测试 TTL 相机、拍照并将其保存在微型 SD 卡上的代码。请注意，代码太长，但我将解释执行先前操作所需的最重要和必要的代码。所有这些示例的代码都包含在书中，以获取更完整的信息。
在这里，我们从 TTL 相机导入文件，并与微型 SD 卡通信的文件：
#include <Adafruit_VC0706.h>
#include <SPI.h>
#include <SD.h>
我们定义软件库以通过串行通信：
// comment out this line if using Arduino V23 or earlier
#include <SoftwareSerial.h>
将chipSelect定义为引脚 10：
#define chipSelect 10
代码将用于连接引脚：
SoftwareSerial cameraconnection = SoftwareSerial(2, 3);
Adafruit_VC0706 cam = Adafruit_VC0706(&cameraconnection);
然后我们需要启动相机：
if (cam.begin()) {
Serial.println("Camera Found:");
} else {
Serial.println("No camera found?");
return;
}
在这里我们定义图像大小：
cam.setImageSize(VC0706_640x480);
这将显示图像大小：
uint8_t imgsize = cam.getImageSize();
Serial.print("Image size: ");
代码将拍照：
if (! cam.takePicture())
Serial.println("Failed to snap!");
else
Serial.println("Picture taken!");
创建文件以保存所拍摄的图像：
char filename[13];
保存文件的代码：
strcpy(filename, "IMAGE00.JPG");
for (int i = 0; i < 100; i++) {
filename[5] = '0' + i/10;
filename[6] = '0' + i%10;
准备微型 SD 卡以保存文件：
if (! SD.exists(filename)) {
break;
}
}
打开拍摄的文件进行预览：
File imgFile = SD.open(filename, FILE_WRITE);
显示所拍摄图像的大小：
uint16_t jpglen = cam.frameLength();
Serial.print("Storing ");
Serial.print(jpglen, DEC);
Serial.print(" byte image.");
从文件中读取数据：
byte wCount = 0; // For counting # of writes
while (jpglen > 0) {
将文件写入内存：
uint8_t *buffer;
uint8_t bytesToRead = min(32, jpglen);
buffer = cam.readPicture(bytesToRead);
imgFile.write(buffer, bytesToRead);
在屏幕上显示文件：
if(++wCount >= 64) {
Serial.print('.');
wCount = 0;
}
显示读取的字节数：
Serial.print(bytesToRead, DEC);
Serial.println(" bytes");
jpglen -= bytesToRead;
}
关闭打开的文件：
imgFile.close();
使用串行 TTL 相机检测运动
打开 TTL 相机的运动检测：
cam.setMotionDetect(true);
验证运动是否激活：
Serial.print("Motion detection is ");
if (cam.getMotionDetect())
Serial.println("ON");
else
Serial.println("OFF");
}
当相机检测到运动时会发生什么：
if (cam.motionDetected()) {
Serial.println("Motion!");
cam.setMotionDetect(false);
如果检测到运动，则拍照或显示消息：
if (! cam.takePicture())
Serial.println("Failed to snap!");
else
Serial.println("Picture taken!");
从 Raspberry Pi 控制快照
现在我们已经看到了如何在 Arduino 和 Raspberry Pi 之间进行通信，以控制板，我们可以将其应用于我们的安全系统项目。我们需要这样做以便从 Raspberry Pi 与控制我们的相机进行通信：
-
将 Arduino 和树莓派连接在一起
-
以 9,600 mbps 创建串行连接
-
调用将拍照并保存在微型 SD 卡中的函数
在树莓派上，我们需要做以下事情：
-
创建调用在 Arduino 中拍照的函数的脚本
-
使用 PuTTY 终端打开并执行脚本
以下部分是应下载到 Arduino 板中的草图：
首先我们开始串行通信：
void setup () {
Serial.begin(9600);
}
这是将告诉摄像头拍照的函数：
void loop () {
if (Serial.available() > 0) {
char c = Serial.read();
if (c == 'T') {
takingpicture():
}
}
}
拍照功能的代码
在这里我们讨论定义将提示摄像头拍照的函数的代码。
该函数包含将拍照的代码：
void takingpicture(){
拍照：
if (!cam.takePicture())
Serial.println("Failed to snap!");
else
Serial.println("Picture taken!");
在这里我们创建保存文件：
char filename[13];
在这里我们保存文件：
strcpy(filename, "IMAGE00.JPG");
for (int i = 0; i < 100; i++) {
filename[5] = '0' + i/10;
filename[6] = '0' + i%10;
准备微型 SD 卡保存文件：
if (! SD.exists(filename)) {
break;
}
}
打开文件进行预览：
File imgFile = SD.open(filename, FILE_WRITE);
在保存之前获取文件的大小：
uint16_t jpglen = cam.frameLength();
Serial.print("Storing ");
Serial.print(jpglen, DEC);
Serial.print(" byte image.");
从保存的文件中读取数据：
byte wCount = 0; // For counting # of writes
while (jpglen > 0) {
将文件写入内存：
uint8_t *buffer;
uint8_t bytesToRead = min(32, jpglen);
buffer = cam.readPicture(bytesToRead);
imgFile.write(buffer, bytesToRead);
保存后显示文件：
if(++wCount >= 64) {
Serial.print('.');
wCount = 0;
}
显示读取的字节数：
Serial.print(bytesToRead, DEC);
Serial.println(" bytes");
jpglen -= bytesToRead;
}
关闭已打开的文件：
imgFile.close();
}
从网页上控制您的摄像头
在这一部分，我们将看看如何从 PHP 的网页上控制我们的摄像头，并在树莓派上运行一个 Web 服务器。我们需要以下内容来运行 PHP 文件和 Web 服务器：
-
在树莓派上运行 Apache 服务器
-
安装 PHP 软件
对于控制的网页，我们需要在以下路径创建我们的 PHP 文件：/var/www/html，例如我们需要编辑index.php文件，并复制以下行。
以下 HTML 文件包括 PHP：
<!DOCTYPE html>
<html>
<head>
<title>Control Camera</title>
</head>
<body>
在这里我们定义了执行拍照动作的函数：
<form action="on.php">
<button type="submit">Taking the picture</button>
</form>
在这里我们定义如果检测到运动要采取的动作：
<form action="off.php">
<button type="submit">Motion</button>
</form>
</body>
</html>
从 PHP 调用 Python 脚本
在这一部分，我们需要从网页调用 Python 脚本并执行包含脚本的文件：
<?php
$prende= exec('sudo python on.py');
header('Location:index.php');
?>
<?php
$apaga = exec('sudo python motion.py');
header('Location:index.php');
?>
Python 脚本的代码
在服务器端，也就是树莓派上，我们有将从网页调用的 Python 脚本：
import serial
import time
Arduino_1 = serial.Serial('/dev/ttyACM0',9600)
Arduino_1.open()
Command='H'
if command:
Arduino_1.write(command)
Arduino_1.close()
import serial
import time
Arduino_1 = serial.Serial('/dev/ttyACM0',9600)
Arduino_1.open()
Command='L'
if command:
Arduino_1.write(command)
Arduino_1.close()
如果一切都配置完美，以下页面将出现：在你喜欢的浏览器中，输入你的PI/index.php的 IP 地址：
在网络中监控您的 USB 摄像头安全
在这一部分，我们将创建一个项目，允许我们监控连接到 Arduino YUN 的 USB 摄像头，它具有 USB 端口并包括以太网和 Wi-Fi 通信。因此，它有许多优势。我们将致力于在树莓派和 Arduino YUN 之间建立一个网络，所以主要的想法是从树莓派的网页上监控摄像头。该页面将存储在树莓派上。
配置 Arduino YUN
我们将使用支持 UVC 协议的罗技摄像头：
现在我们将解释安装我们的摄像头在 Arduino YUN 中的步骤：
-
将板连接到您的 Wi-Fi 路由器
-
验证 Arduino YUN 的 IP 地址
在我们输入 IP 地址后，将出现以下屏幕：
我们现在将在命令提示符下发出一系列命令来完成设置：
更新软件包：
**opkg update**
安装 UVC 协议：
**opkg install kmod-video-uvc**
安装摄像头驱动程序：
**opkg install fswebcam**
下载Mjpgstreamer：
**wget http://www.custommobileapps.com.au/downloads/mjpgstreamer.Ipk**
安装Mjpgstreamer：
**opkg install mjpg-streamer.ipk**
要手动启动摄像头，使用以下代码：
**mjpg_streamer -i "input_uvc.so -d /dev/video0 -r 640x480 -f 25" -o**
**"output_http.so -p 8080 -w /www/webcam" &**
要自动启动摄像头，我们将使用以下代码：
安装nano程序：
**opkg install nano**
输入以下文件：
**nano /etc/config/mjpg-streamer**
使用以下参数配置摄像头：
config mjpg-streamer core
option enabled "1"
option device "/dev/video0"
option resolution "640x480"
option fps "30"
option www "/www/webcam"
option port "8080"
使用以下命令启动服务：
**/etc/init.d/mjpg-streamer enable**
**/etc/init.d/mjpg-streamer stop**
**/etc/init.d/mjpg-streamer start**
从 MJPG-STREAMER 服务器监控
一旦你访问了 Arduino YUN 的服务器，就在你的网络浏览器中输入你的 Arduino YUN 的 IP 地址http://Arduino.local:8080。配置的结果如下截图所示：
从树莓派监控 USB 摄像头
连接到 Arduino YUN 的摄像头，现在我们可以实时监控树莓派上发布的网页。
为网页提供一个标题：
<html>
<head>
<title>Monitoring USB Camera</title>
我们通过输入 Arduino YUN 的 IP 地址来调用摄像头图像：
</head>
<body>
<center>
<img src="http://192.168.1.107:8080/?action=stream"/>
</center>
</body>
</html>
通过在浏览器中输入树莓派的 IP 地址（http://192.168.1.106/index.html）访问网页：
在下一节中，我们将看如何配置连接的设备和将在网络中进行交互的硬件。
以下图片代表了我们用可以监控的设备创建的网络；例如，我们监控房子的每个房间，将所有设备连接到一个 Wi-Fi 网络，并从树莓派上监控它们：
摘要
在本章中，您已经学会了如何配置连接到网络的网络摄像头，并监控物联网安全系统。我们使用 Arduino 板连接安全摄像头，并将连接到网络的树莓派 Zero 用于监控系统。在下一章中，我们将集成我们的系统，将树莓派 Zero 与 Arduino 连接，构建一个完整的系统连接设备并进行监控。
第六章：从仪表板构建 Web 监视器和控制设备
在本章中，我们将讨论本书非常重要的一部分，即创建一个可以从仪表板控制不同类型设备的网页。在自动化的家庭中，有不同类型的设备可以被控制，例如：灯、门或窗户、洗衣机等等。
在本章中，我们将涵盖以下主题：
-
配置 MySQL 数据库服务器
-
安装 PhpMyAdmin 以管理数据库
-
带有 MySQL 的数据记录器
-
调光 LED
-
控制直流电机的速度
-
使用电路控制灯光
-
控制门锁
-
控制浇水的植物
-
从任何地方远程访问您的 Raspberry Pi Zero
-
控制灯光和测量电流消耗
-
从 Raspberry Pi Zero 控制和监视 Arduino、Wi-Fi 和以太网 shield、连接的设备和传感器
配置 MySQL 数据库服务器
在本节中，您将学习如何配置 MySQL 服务器，以创建数据库并将所有内容集成到您的仪表板中，以记录数据库中的数据。
安装 MySQL
我们的 Raspberry Pi Zero 正在配置为 Web 服务器。在本节中，我们将使用以下命令安装 MySQL 数据库服务器，以便我们可以接收来自客户端的连接，显示存储在数据库中的数据，并在 SQL 中使用查询：
**sudo apt-get install mysql-server**
在过程中它会要求您输入root用户的密码：
安装完成后，连接到 MySQL 并键入以下命令：
**mysql -u root -p**
键入以下命令：
**show databases;**
在这里，我们可以看到现在安装在服务器上的系统数据库：
为 PHP 安装 MySQL 驱动程序
重要的是安装我们的驱动程序以使 PHP5 与 MySQL 数据库服务器通信，为此我们需要 MySQL 驱动程序以访问 MySQL 数据库，执行此命令以安装PHP-MySQL驱动程序。
**sudo apt-get install php5 php5-mysql**
测试 PHP 和 MySQL
在本节中，我们将使用以下命令创建一个简单的页面来测试 PHP 和 MySQL：
**sudo nano /var/www/html/hellodb.php**
以下屏幕截图显示了包含访问数据库的代码、连接到服务器并从中获取数据的脚本：
要测试页面和 PHP 与 MySQL 之间的连接，请键入您的 Raspberry Pi 的 IP 地址：http://192.168.1.105/hellodb.php。页面应该类似于以下屏幕截图：
安装 PhpMyAdmin 以管理数据库
在本节中，我们将讨论如何配置您的 PhpMyAdmin 以从远程面板管理您的数据库。重要的是我们在 Apache 服务器中安装客户端和模块 PHP5，因此键入以下命令：
**sudo apt-get install mysql-client php5-mysql**
接下来，我们将使用以下命令安装phpmyadmin软件包：
**sudo apt install phpmyadmin**
在下面的屏幕截图中，我们可以看到服务器的配置；在这种情况下，我们需要选择apache2：
我们选择 apache2 服务器：
之后我们可以选择数据库：
我们选择
配置 Apache 服务器
我们需要对文件apache2.conf进行配置。首先转到您的 Pi 上的终端：
**sudo nano /etc/apache2/apache2.conf**
在下一个屏幕上，我们需要添加代码：
**Include /etc/phpmyadmin/apche.conf**
我们在文件底部包含以下行：
**Include /etc/phpmyadmin/apche.conf**
我们终于完成了安装我们的 Apache 服务器，现在我们已经准备好进行下一步了。
进入 phpMyAdmin 远程面板
在配置了服务器之后，我们将进入 phpMyAdmin 远程面板，我们需要打开我们喜欢的网络浏览器，并输入我们的树莓派的 IP 地址：http://(树莓派地址)/phpmyadmin，这将显示以下屏幕：
显示 Arduinobd 数据库
以下截图显示了在服务器中创建的数据库：
以下截图显示了表measurements，列id，temperature和humidity：
从 Arduino 和以太网盾发送数据到 Web 服务器
我们使用 Arduino 和连接到网络的以太网盾，Arduino 将数据发送到树莓派 Zero 上发布的 Web 服务器。
您现在可以将代码复制到名为arduino_xaamp_mysql.ino的文件中，或者只需从本书的代码文件夹中获取完整的代码：
我们输入 Arduino UNO 的 IP 地址：
IPAddress ip(192,168,1,50);
我们配置了我们的树莓派 Zero 的 IP 地址：
IPAddress server(192,168,1,108);
我们需要连接到 Web 服务器：
if (client.connect(server, 80))
这些行定义了从远程服务器发出的 HTTP 请求：
client.println("GET /datalogger1.php?temp=" + temp + "&hum=" + hum + " HTTP/1.1");
client.println("Host: 192.168.1.108");
client.println("Connection: close");
client.println();
其余的代码显示在以下行中：
// Include libraries
#include <SPI.h>
#include <Ethernet.h>
#include "DHT.h"
// Enter a MAC address for your controller below.
byte mac[] = { 0x90, 0xA2, 0xDA, 0x0E, 0xFE, 0x40 };
// DHT11 sensor pins
#define DHTPIN 7
#define DHTTYPE DHT11
IPAddress ip(192,168,1,50);
IPAddress server(192,168,1,108);
EthernetClient client;
DHT dht(DHTPIN, DHTTYPE);
void setup() {
// Open serial communications
Serial.begin(9600);
Ethernet.begin(mac, ip);
Serial.print("IP address: ");
Serial.println(Ethernet.localIP());
delay(1000);
Serial.println("Conectando...");
}
void loop()
{
float h = dht.readHumidity();
float t = dht.readTemperature();
String temp = String((int) t);
String hum = String((int) h);
if (client.connect(server, 80)) {
if (client.connected()) {
Serial.println("conectado");
发出 HTTP 请求：
client.println("GET /datalogger1.php?temp=" + temp + "&hum=" + hum + " HTTP/1.1");
client.println("Host: 192.168.1.108");
client.println("Connection: close");
client.println();
}
else {
// If you didn't get a connection to the server
Serial.println("fallo la conexion");
}
这些行定义了客户端实例如何读取响应：
while (client.connected()) {
while (client.available()) {
char c = client.read();
Serial.print(c);
}
}
如果服务器断开连接，停止客户端：
if (!client.connected()) {
Serial.println();
Serial.println("desconectado.");
client.stop();
}
}
每秒重复一次：
delay(5000);
}
在这里我们可以看到我们使用的硬件：
带有 MySQL 的数据记录器
在接下来的部分，我们将构建一个数据记录器，它将记录服务器中的温度和湿度数据，以便我们随时可以获取数据并在网页中显示。
编程脚本软件
在下面的代码中，我们有一个将与 Arduino 板通信的脚本，并且它已安装在服务器上。
您现在可以将代码复制到名为datalogger1.php的文件中，或者只需从本项目的文件夹中获取完整的代码：
<?php
if (isset($_GET["temp"]) && isset($_GET["hum"])) {
$temperature = intval($_GET["temp"]);
$humidity = intval($_GET["hum"]);
$con=mysql_connect("localhost","root","ruben","arduinobd");
mysql_select_db('arduinobd',$con);
if(mysql_query("INSERT INTO measurements (temperature, humidity) VALUES ('$temperature', '$humidity');")){
echo "Data were saved";
}
else {
echo "Fail the recorded data";
}
mysql_close($con);
}
?>
测试连接
安装了脚本文件后，我们需要在您的计算机上打开一个网络浏览器，并输入您的树莓派的 IP 地址 Raspberry Pi/datalogger1.php?temp=70&hum=100，链接看起来像 (http://192.168.1.108/datalogger1.php?temp=70&hum=100)：
以下截图显示了保存在数据库中的数据的结果：
以下截图显示了数据表格：
从数据库查询数据
记录数据并进行一些查询以在网页中显示数据非常重要。
脚本软件
这里有我们用来在页面中显示数据的脚本：
您现在可以将代码复制到名为query1.php的文件中，或者只需从本项目的文件夹中获取完整的代码：
<!DOCTYPE html>
<html>
<body>
<h1>Clik on the buttons to get Data from MySQL</h1>
<form action="query1.php" method="get">
<input type="submit" value="Get all Data">
</form>
</br>
<form action="query2.php" method="get">
<input type="submit"value="Humidity <= 15">
</form>
</br>
<form action="query3.php" method="get">
<input type="submit" value="Temperature <=25">
</form>
</br>
<?php
$con=mysql_connect("localhost","root","ruben","arduinobd");
mysql_select_db('arduinobd',$con);
$result = mysql_query("SELECT * FROM measurements");
echo "<table border='1'>
<tr>
<th>Measurements</th>
<th>Temperature (°C)</th>
<th>Humidity (%)</th>
</tr>";
while($row = mysql_fetch_array($result)) {
echo "<tr>";
echo "<td>" . $row['id'] . "</td>";
echo "<td>" . $row['temperature'] . "</td>";
echo "<td>" . $row['humidity'] . "</td>";
echo "</tr>";
}
echo "</table>";
mysql_close($con);
?>
</body>
</html>
在以下截图中，我们有数据：
特定数据的脚本以显示
在接下来的几行中，我们可以看到我们可以进行一些 SQL 查询，以获取特定数值的信息，并从温度和湿度中获取数值：
<?php
$con=mysql_connect("localhost","root","ruben","arduinobd");
mysql_select_db('arduinobd',$con);
$result = mysql_query("SELECT * FROM measurements where humidity <= 15 order by id");
echo "<table border='1'>
<tr>
<th>Measurements</th>
<th>Temperature (°C)</th>
<th>Humidity (%)</th>
</tr>";
while($row = mysql_fetch_array($result)) {
echo "<tr>";
echo "<td>" . $row['id'] . "</td>";
echo "<td>" . $row['temperature'] . "</td>";
echo "<td>" . $row['humidity'] . "</td>";
echo "</tr>";
}
echo "</table>";
mysql_close($con);
?>
查询记录温度
在本节中，我们将创建一个查询以获取温度测量值。我们将服务器引用称为localhost，在本例中是树莓派零设备，用户和数据库的名称：
<?php
$con=mysql_connect("localhost","root","ruben","arduinobd");
mysql_select_db('arduinobd',$con);
$result = mysql_query("SELECT * FROM measurements where temperature <= 25 order by id");
echo "<table border='1'>
<tr>
<th>Measurements</th>
<th>Temperature (°C)</th>
<th>Humidity (%)</th>
</tr>";
while($row = mysql_fetch_array($result)) {
echo "<tr>";
echo "<td>" . $row['id'] . "</td>";
echo "<td>" . $row['temperature'] . "</td>";
echo "<td>" . $row['humidity'] . "</td>";
echo "</tr>";
}
echo "</table>";
mysql_close($con);
?>
查询结果显示在以下截图中：
控制和调光 LED
在本节中，我们将讨论一个可以应用于家庭自动化的项目。我们将调暗直流 LED，这可以应用于房子里的灯。LED 将改变亮度，并且我们将 LED 连接到树莓派的GPIO18，并串联一个330欧姆的电阻。
软件要求
首先，我们需要安装pigpio包。在终端中，键入以下内容：
**wget abyz.co.uk/rpi/pigpio/pigpio.zip**
然后解压包：
**unzip pigpio.zip**
之后，使用以下内容导航到解压后的文件夹：
**cd PIGPIO**
键入以下内容执行命令：
**Make**
最后安装文件：
**sudo make install**
测试 LED
在本节中，我们将使用Node.js脚本测试传感器：
var Gpio = require('pigpio').Gpio;
// Create led instance
var led = new Gpio(18, {mode: Gpio.OUTPUT});
var dutyCycle = 0;
// Go from 0 to maximum brightness
setInterval(function () {
led.pwmWrite(dutyCycle);
dutyCycle += 5;
if (dutyCycle > 255) {
dutyCycle = 0;
}
}, 20);
我们现在可以测试这段代码，使用 Pi 上的终端导航到此项目的文件夹，并键入以下内容：
**sudo npm install pigpio**
这将安装所需的node.js模块来控制 LED。然后，键入以下内容：
**sudo node led_test.js**
这是最终结果：
从界面控制 LED
在本节中，我们将从网页控制 LED。为此，我们将使用 HTML 与用户进行界面交互，使用node.js。
让我们看一下以下代码中包含的 Node.js 文件：
// Modules
var Gpio = require('pigpio').Gpio;
var express = require('express');
// Express app
var app = express();
// Use public directory
app.use(express.static('public'));
// Create led instance
var led = new Gpio(18, {mode: Gpio.OUTPUT});
// Routes
app.get('/', function (req, res) {
res.sendfile(__dirname + '/public/interface.html');
});
app.get('/set', function (req, res) {
// Set LED
dutyCycle = req.query.dutyCycle;
led.pwmWrite(dutyCycle);
// Answer
answer = {
dutyCycle: dutyCycle
};
res.json(answer);
});
// Start server
app.listen(3000, function () {
console.log('Raspberry Pi Zero LED control');
});
现在终于是时候测试我们的应用程序了！首先，从本书的存储库中获取所有代码，并像以前一样导航到项目的文件夹。然后，使用以下命令安装express：
**sudo npm install express**
完成后，使用以下命令启动服务器：
**sudo node led_control.js**
您现在可以测试项目，打开计算机上的网络浏览器，并输入链接- http://（树莓派 PI）/set?dutyCycle=20，我们可以看到 LED 随数值变化。
然后用http://192.168.1.108:3000打开您的网络浏览器，您应该在一个基本的网页上看到控制：
控制直流电机的速度
在房子里通常会有窗户或车库门。我们需要自动化这些类型的设备，以便我们可以使用直流电机移动这些物体。在本节中，我们将看到如何将直流电机连接到树莓派。为此，我们将使用 L293D 电路来控制电机。
首先，我们将看到如何将电机连接到我们的树莓派 Zero 板上。在下图中，我们可以看到 LD293 芯片的引脚：
基本上，我们需要连接电路的组件，如下所示：
-
树莓派的GPIO14连接到引脚1A
-
树莓派的GPIO15连接到引脚2A
-
树莓派的GPIO18连接到引脚1，2EN
-
DC电机连接到引脚1Y和2Y
-
树莓派的5V连接到VCC1
-
树莓派的GND连接到GND
-
适配器调节器连接到VCC2和GND
以下图显示了结果：
我们现在将测试直流电机的速度从 0 到最高速度：
// Modules
var Gpio = require('pigpio').Gpio;
// Create motor instance
var motorSpeed = new Gpio(18, {mode: Gpio.OUTPUT});
var motorDirectionOne = new Gpio(14, {mode: Gpio.OUTPUT});
var motorDirectionTwo = new Gpio(15, {mode: Gpio.OUTPUT})
// Init motor direction
motorDirectionOne.digitalWrite(0);
motorDirectionTwo.digitalWrite(1);
var dutyCycle = 0;
// Go from 0 to maximum brightness
setInterval(function () {
motorSpeed.pwmWrite(dutyCycle);
dutyCycle += 5;
if (dutyCycle > 255) {
dutyCycle = 0;
}
}, 20);
在这里，我们有这个应用程序的代码，可以使用网页界面来控制直流电机：
// Modules
var Gpio = require('pigpio').Gpio;
var express = require('express');
// Express app
var app = express();
// Use public directory
app.use(express.static('public'));
// Create led instance
var motorSpeed = new Gpio(18, {mode: Gpio.OUTPUT});
var motorDirectionOne = new Gpio(14, {mode: Gpio.OUTPUT});
var motorDirectionTwo = new Gpio(15, {mode: Gpio.OUTPUT});
// Routes
app.get('/', function (req, res) {
res.sendfile(__dirname + '/public/interface.html');
});
app.get('/set', function (req, res) {
// Set motor speed
speed = req.query.speed;
motorSpeed.pwmWrite(speed);
// Set motor direction
motorDirectionOne.digitalWrite(0);
motorDirectionTwo.digitalWrite(1);
// Answer
answer = {
speed: speed
};
res.json(answer);
});
// Start server
app.listen(3000, function () {
console.log('Raspberry Pi Zero Motor control started!');
});
我们在以下代码中看到用户界面：
$( document ).ready(function() {
$( "#motor-speed" ).mouseup(function() {
// Get value
var speed = $('#motor-speed').val();
// Set new value
$.get('/set?speed=' + speed);
});
});
<!DOCTYPE html>
<html>
<head>
<script src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
<script src="js/interface.js"></script>
<link rel="stylesheet" href="css/style.css">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<div id="container">
<h3>Motor Control</h3>
<div class='row'>
<div class='col-md-4'></div>
<div class='col-md-4 text-center'>
<input id="motor-speed" type="range" value="0" min="0" max="255" step="1">
</div>
<div class='col-md-4'></div>
</div>
</div>
</body>
</html>
要测试应用程序，您需要在计算机上打开网络浏览器，链接为http://192.168.1.108:3000，然后您需要替换您的 Pi 的 IP 地址。这是我们的界面：
使用电气电路控制灯
在接下来的章节中，您将找到更多控制房屋其他设备的项目想法。
电器设备
在房子里，我们有电器设备，例如灯，洗衣机，加热器和其他我们只需要打开或关闭的设备。在本节中，我们将学习如何使用电气电路来控制连接到树莓派 Zero 的灯，以及如何使用光耦合器（如 MOC3011）和三角形。以下图显示了应用程序的电路：
这里我们有连接到 Raspberry Pi Zero 的最终项目：
这里有用于控制设备的 JavaScript 代码：
// Modules
var express = require('express');
// Express app
var app = express();
// Pin
var lampPin = 12;
// Use public directory
app.use(express.static('public'));
// Routes
app.get('/', function (req, res) {
res.sendfile(__dirname + '/public/interface.html');
});
app.get('/on', function (req, res) {
piREST.digitalWrite(lampPin, 1);
// Answer
answer = {
status: 1
};
res.json(answer);
});
app.get('/off', function (req, res) {
piREST.digitalWrite(lampPin, 0);
// Answer
answer = {
status: 0
};
res.json(answer);
});
// aREST
var piREST = require('pi-arest')(app);
piREST.set_id('34f5eQ');
piREST.set_name('my_rpi_zero');
// Start server
app.listen(3000, function () {
console.log('Raspberry Pi Zero lamp control started!');
});
我们需要一个可以通过 HTML 语言的网页控制灯的界面：
<!DOCTYPE html>
<html>
<head>
<script src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
<script src="js/script.js"></script>
<link rel="stylesheet" href="css/style.css">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<div id="container">
<h3>Lamp Control</h3>
<div class='row'>
<div class='col-md-4'></div>
<div class='col-md-2'>
<button id='on' class='btn btn-block btn-primary'>On</button>
</div>
<div class='col-md-2'>
<button id='off' class='btn btn-block btn-warning'>Off</button>
</div>
<div class='col-md-4'></div>
</div>
</div>
</body>
</html>
进入网络浏览器后，我们将看到以下界面：
其他家用电器
在这一部分，我们将展示其他应用程序，您可以考虑创建和控制，然后在家里或不同的区域使用它们。
控制门锁
在这一部分，我们将看到其他可以从界面控制并连接到 Raspberry Pi 的家用电器。在家里，我们可以通过 Web 界面控制门锁：
控制浇水设备
我们可以控制的另一个家用电器是连接到 Raspberry Pi 的塑料水电磁阀-12V 的浇水设备：
通过这个项目，我们可以制作一个自动浇水系统，添加一个湿度传感器，并设置花园植物的浇水时间。
从任何地方远程访问您的 Raspberry Pi Zero
如果我们想要从网络外部访问我们的 Raspberry Pi，我们需要执行以下操作：
-
检查我们的调制解调器是否有公共 IP 地址
-
调查我们将在浏览器中使用的地址
-
在我们的浏览器中输入
whatismyipaddress.com/
ISP 提供的 IP 通常是动态 IP，会随时间变化。在我们的情况下，我们需要具有不时更改的静态地址。
如何访问我们的调制解调器进行配置
通过 IP 地址（网关）访问我们的调制解调器，并转到端口寻址部分。配置指向我们的 Web 服务器的端口80（输入我们帐户的 IP 地址），此 IP 地址是我们系统的 DHCP 服务器自动分配的 IP 地址。
这里有一些可以从调制解调器-路由器转发的端口：
要获取网关 IP 地址，请输入ipconfig命令，您需要具有管理员权限。之后，在您的router.1的网络浏览器中输入http://gatewayip_addres：
这是您在 Linksys 路由器上看到的示例，您的界面可能不同：
要打开一个端口，我们需要配置我们的路由器以允许从外部进入，因此我们需要在我们的路由器中给予权限：
这个屏幕截图显示了最终结果，如何打开端口号 3000，以及应用程序节点的名称：
配置动态 DNS
我们需要配置域名服务，这样我们就可以通过输入我们域名的名称来访问我们的 Web 服务器（学习网页的 IP 地址非常困难）。这就是为什么创建了域名服务器（DNS)。请按照下一节创建域名。
您可能希望从家外访问您的物联网控制面板。在这种情况下，您的 Web 服务器将需要成为互联网上的主机。
这并不是一件简单的事情，因为它在您家中的路由器后面。您的 ISP 通常不会给您一个静态的公共 IP 地址，因为大多数用户只是访问网络，而不是提供网页服务。
因此，您的路由器的公共一侧会被分配一个可能会不时更改的 IP 地址。如果您浏览<whatsmyip...>，您将看到您当前的公共 IP 是什么。
明天可能会不同。要设置外部访问，您可以选择以下两种方法之一。如果您想模拟具有静态 IP，可以使用动态 DNS 等服务。如果您只是想“尝试”外部访问，可以在路由器上打开一个端口
动态 DNS 的好处：
-
一种解决方案是安装一个客户端，允许公共 IP 固定。客户端功能（安装在计算机上的软件）与网站www.no-ip.org保持通信。
-
当我们的调制解调器的 IP 地址发生变化时，客户端会接受该 IP 变化。
-
这样我们的域名就可以始终指向我们的公共 IP 地址。安装的软件称为：No-IP DUC。
在 No-ip.org 创建一个账户
在下面的截图中，我们可以看到增强动态 DNS 设置：
控制灯光和测量电流消耗
现在，在本节中，我们将解释如何在灯开启或关闭时控制和监控您的电流消耗。通过 Web 页面使用您的 Arduino Wi-Fi shield，我们将监控此变量。当灯关闭时，它看起来如下：
当灯开启时，它看起来如下：
现在，您可以将代码复制到名为Controlling_lights_Current_Consumption.ino的文件中，或者只需从本书的文件夹中获取完整的代码。
定义监控和控制的变量和函数：
#define NUMBER_VARIABLES 2
#define NUMBER_FUNCTIONS 1
导入库以使用：
#include <Adafruit_CC3000.h>
#include <SPI.h>
#include <CC3000_MDNS.h>
#include <aREST.h>
配置继电器以激活：
const int relay_pin = 8;
计算电流的变量：
float amplitude_current;
float effective_value;
float effective_voltage = 110;
float effective_power;
float zero_sensor;
我们定义用于配置模块的引脚：
#define ADAFRUIT_CC3000_IRQ 3
#define ADAFRUIT_CC3000_VBAT 5
#define ADAFRUIT_CC3000_CS 10
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS,
ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBAT);
我们创建实例：
aREST rest = aREST();
我们定义您网络的 SSID 和密码：
#define WLAN_SSID "xxxxxxxx"
#define WLAN_PASS "xxxxxxxx"
#define WLAN_SECURITY WLAN_SEC_WPA2
我们配置服务器的端口：
#define LISTEN_PORT 80
服务器的实例：
Adafruit_CC3000_Server restServer(LISTEN_PORT);
MDNSResponder mdns;
使用的变量：
int power;
int light;
发布使用的变量：
void setup(void)
{
Serial.begin(115200);
rest.variable("light",&light);
rest.variable("power",&power);
设置继电器引脚为输出：
pinMode(relay_pin,OUTPUT);
校准电流传感器：
zero_sensor = getSensorValue(A1);
我们声明设备的 id 和名称：
rest.set_id("001");
rest.set_name("control");
在这部分，我们检查设备是否已连接：
if (!cc3000.begin())
{
while(1);
}
if (!cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY)) {
while(1);
}
while (!cc3000.checkDHCP())
{
delay(100);
}
在这部分中，我们定义了通信请求：
if (!mdns.begin("arduino", cc3000)) {
while(1);
}
displayConnectionDetails();
让我们启动服务器：
restServer.begin();
Serial.println(F("Listening for connections..."));
}
我们读取传感器：
void loop() {
float sensor_reading = analogRead(A0);
light = (int)(sensor_reading/1024*100);
float sensor_value = getSensorValue(A1);
我们进行电流计算并获取信号：
amplitude_current = (float)(sensor_value-zero_sensor)/1024*5/185*1000000;
effective_value = amplitude_current/1.414;
effective_power = abs(effective_value*effective_voltage/1000);
power = (int)effective_power;
mdns.update();
我们定义传入请求：
Adafruit_CC3000_ClientRef client = restServer.available();
rest.handle(client);
}
我们显示 IP 地址配置：
bool displayConnectionDetails(void)
{
uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
if(!cc3000.getIPAddress(&ipAddress, &netmask, &gateway, &dhcpserv, &dnsserv))
{
Serial.println(F("Unable to retrieve the IP Address!\r\n"));
return false;
}
else
{
Serial.print(F("\nIP Addr: ")); cc3000.printIPdotsRev(ipAddress);
Serial.print(F("\nNetmask: ")); cc3000.printIPdotsRev(netmask);
Serial.print(F("\nGateway: ")); cc3000.printIPdotsRev(gateway);
Serial.print(F("\nDHCPsrv: ")); cc3000.printIPdotsRev(dhcpserv);
Serial.print(F("\nDNSserv: ")); cc3000.printIPdotsRev(dnsserv);
Serial.println();
return true;
}
}
电流传感器的功能，计算特定测量的平均值并返回电流计算：
float getSensorValue(int pin)
{
int sensorValue;
float avgSensor = 0;
int nb_measurements = 100;
for (int i = 0; i < nb_measurements; i++) {
sensorValue = analogRead(pin);
avgSensor = avgSensor + float(sensorValue);
}
avgSensor = avgSensor/float(nb_measurements);
return avgSensor;
}
构建控制和监控界面
这里有用于显示控制灯光和监控传感器电流的界面的代码：
为 Node.js 安装 Jade
在这个项目中使用 Jade 界面很重要。为此，我们只需输入以下命令：
**npm install arest express jade**
如果需要，我们可以在系统需要更新时输入以下命令：
**npm install pug**
用于控制和监控的界面
首先，我们定义页面的标题并添加 HTML 标签：
doctype
html
head
title Control and monitoring
我们为 jQuery 和 Bootstrap 的功能定义链接：
link(rel='stylesheet', href='/css/interface.css')
link(rel='stylesheet',
href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.0/css/bootstrap.min.css")
script(src="https://code.jquery.com/jquery-2.1.1.min.js")
script(src="/js/interface.js")
我们在网页上显示控制按钮：
body
.container
h1 Controlling lights
.row.voffset
.col-md-6
button.btn.btn-block.btn-lg.btn-primary#1 On
.col-md-6
button.btn.btn-block.btn-lg.btn-danger#2 Off
.row
显示功率和光照水平：
.col-md-4
h3#powerDisplay Power:
.col-md-4
h3#lightDisplay Light level:
.col-md-4
h3#status Offline
现在我们将运行应用程序，如下截图所示。服务器在端口 3000 上打开，当它开始向板发送请求时，在 Web 浏览器中键入地址：http://localhost:3000。它显示了带有两个按钮的网页，设备已连接并在线：
单击蓝色开按钮以激活板上的灯，几秒钟后我们可以看到功率增加：
单击红色关按钮，几秒钟后功率下降直到0 W，这意味着一切都运行正常：
在连接设备和传感器上控制和监控 Arduino、Wi-Fi 和以太网 shield
在前几节中，我们看到如何使用在 Windows 计算机上运行的node.js从网页控制和监视我们的 Arduino 板。在本节中，我们将使用我们神奇的树莓派 Zero，在其上安装了 Node.js，并在板上运行 JavaScript 应用程序。
我已经看到了使用树莓派 Zero 而不是使用个人计算机安装为 Web 服务器的潜力，通过这种经验制作这些项目，我想说应用程序在树莓派 Zero 上运行更有效。
我们将看到如何在单个仪表板中使用不同设备控制多个设备，例如以下设备：
-
Wi-Fi 盾
-
ESP8266 模块
-
以太网盾
构建控制和监视设备的代码，从单一界面进行监控
现在您可以将代码复制到名为app.js的文件中，或者只需从此项目的文件夹中获取完整的代码。
配置系统中连接的设备的输出：
$.getq('queue', '/lamp_control/mode/8/o');
$.getq('queue', '/lamp_control2/mode/5/o');
启动控制功能：
$(document).ready(function() {
我们使用aREST API 进行ON的GET请求：
// Function to control lamp Ethernet Shield
$("#1").click(function() {
$.getq('queue', '/lamp_control/digital/8/1');
});
我们使用ARESt API 进行OFF的GET请求：
$("#2").click(function() {
$.getq('queue', '/lamp_control/digital/8/0');
});
我们对连接的 ESP8266 设备进行相同的操作ON：
//Function to control lamp ESP8266
$("#3").click(function() {
$.getq('queue', '/lamp_control2/digital/5/0');
});
我们对连接的 ESP8266 设备进行相同的操作OFF：
$("#4").click(function() {
$.getq('queue', '/lamp_control2/digital/5/1');
});
从传感器温度和湿度获取数据：
function refresh_dht() {
$.getq('queue', '/sensor/temperature', function(data) {
$('#temperature').html("Temperature: " + data.temperature + " C");
});
$.getq('queue', '/sensor2/temperature2', function(data) {
$('#temperature2').html("Temperature: " + data.temperature2 + " C");
});
$.getq('queue', '/sensor/humidity', function(data) {
$('#humidity').html("Humidity: " + data.humidity + " %");
});
$.getq('queue', '/sensor2/humidity2', function(data) {
$('#humidity2').html("Humidity: " + data.humidity2 + " %");
});
}
此代码每 10000 秒刷新页面一次：
refresh_dht();
setInterval(refresh_dht, 10000);
});
添加要监视和控制的设备
我可以看到系统非常稳定；我们需要添加将从树莓派 Zero 监视的设备，使用以下 JavaScript 片段中的应用程序。
我们创建 express 模块和必要的库：
var express = require('express');
var app = express();
我们定义将要打开的端口：
var port = 3000;
我们为 HTML 网页配置 Jade 引擎：
app.set('view engine', 'jade');
我们创建公共目录以便访问：
app.use(express.static(__dirname + '/public'));
执行服务器指令的界面：
app.get('/', function(req, res){
res.render('interface');
});
我们使用 rest 请求声明逮捕文件：
var rest = require("arest")(app);
此代码定义将被控制和监视的设备，我们可以添加想要的设备：
rest.addDevice('http','192.168.1.108');
rest.addDevice('http','192.168.1.105');
rest.addDevice('http','192.168.1.107');
rest.addDevice('http','192.168.1.110');
我们在端口 3000 上设置服务器并监听 Web 浏览器客户端：
app.listen(port);
console.log("Listening on port " + port);
如果一切都配置完美，我们通过输入以下命令来测试应用程序：
**sudo npm install arest express jade**
这将安装 Jade 平台并识别来自树莓派 Zero 的aREST API。
如果需要更新某些内容，请输入以下命令：
**sudo npm install pug**
要更新arrest express，请输入以下命令：
**sudo npm install pi-arest express**
安装此软件包非常重要，以包括逮捕 API：
**sudo npm install arest --unsafe-perm**
要运行应用程序，请转到应用程序所在的文件夹，并输入以下命令：
**node app.js**
在下面的屏幕截图中，我们看到服务器正在打开端口 3000：
最后的测试中，我们需要在您喜欢的网络浏览器中输入树莓派此刻的 IP 地址：http://IP_Address_of_Raspberry_Pi_Zero/port。
在下面的屏幕截图中，我们可以看到来自树莓派 Zero 的控制和监视数据仪表板，发布在单个网页上的不同设备上，这是一件有趣的事情，可以远程系统和控制面板：
最后，我们通过在单个数据仪表板中使用不同设备来展示控制和监视系统；我们得出结论，物联网可以在一个网页中拥有多个设备。
总结
在本章中，您学习了如何使用树莓派 Zero 与 Arduino 和之前章节中介绍的技术集成和构建监控仪表板。本章为您提供了基础知识和必要工具，可以帮助您创建自己的物联网系统，用于不同应用和领域，通过应用所有工具、Web 服务器、数据库服务器、连接的设备，并设置路由器来控制您的树莓派，从世界各地的任何地方。
在下一章中，您将为物联网构建非常好的设备；您将学习如何制作不同的迷你家庭自动化项目。
第七章：用物联网仪表盘构建间谍警察
在本章中，我们将看几个家庭项目。您可以将这些项目与我们在前几章中看到的其他工具结合使用。这样做将有助于提高您的知识，也让您自己开发。本章将涵盖以下主题：
-
检测噪音的间谍麦克风
-
调节交流灯调光器的电流
-
用 RFID 卡控制访问
-
检测烟雾
-
使用树莓派 Zero 构建报警系统
-
从远程仪表盘监控气候
检测噪音的间谍麦克风
在本节中，我们将看一个可以在房子里使用的项目，用于检测噪音或声音级别，以便我们可以检测到有人在房子前说话。这个项目包括一个带有麦克风的模块，类似于下面的图像：
软件代码
我们需要制作一个程序，可以读取模块发送到 Arduino 板的模拟信号：
const int ledPin = 12; // the number of the LED pin
const int thresholdvalue = 400; //The threshold to turn the led on
void setup() {
pinMode(ledPin, OUTPUT);
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(A0); //use A0 to read the electrical signal
Serial.print("Noise detected=");
Serial.println(sensorValue);
delay(100);
if(sensorValue > thresholdvalue)
digitalWrite(ledPin,HIGH);//if the value read from A0 is larger than 400,then light the LED
delay(200);
digitalWrite(ledPin,LOW);
}
然后我们下载草图，在下面的截图中我们有声音级别的结果：
在下面的图像中，我们可以看到最终的电路连接到 Arduino 板：
调节交流灯调光器的电流
在本节中，我们将看到如何调节交流灯。多年来，我一直想解释和分享这样的项目，现在终于可以了。这可以应用于调节家里的灯，以减少家庭用电量：接下来的章节将更详细地解释这个项目。
硬件要求
我们需要以下电子元件：
-
H 桥
-
24V 交流变压器
-
两个电阻 22k（1 瓦）
-
一个集成电路（4N25）
-
一个电阻 10k
-
一个 5k 的电位计
-
一个电阻 330 欧姆
-
一个电阻 180 欧姆
-
一个集成电路 MOC3011
-
一个 TRIAC 2N6073
在下面的电路图中，我们可以看到 Arduino 板上调光器的连接：
软件代码
现在您可以将代码复制到一个名为Dimner.ino的文件中，或者只需从此项目的文件夹中获取完整的代码：
int load = 10;
int intensity = 128;
void setup()
{
pinMode(loaf, OUTPUT);
attachInterrupt(0, cross_zero_int, RISING);
}
void loop()
{
intensity = map(analogRead(0),0,1023,10,128);
}
void cross_zero_int()
{
int dimtime = (65 * intensity);
delayMicroseconds(dimtime);
digitalWrite(load, HIGH);
delayMicroseconds(8);
digitalWrite(load, LOW);
}
在下载了草图之后，我们可以看到最终的结果。通过电位器，我们可以调节灯的亮度。在我们的房子里，我们可以随时打开灯：也许我们可以根据环境光控制它们。
在下面的图像中，我们将看到灯的不同时刻，如果我们调节电位器的输入信号：
在下面的图像中，我们可以看到调节灯的亮度的结果：
在这里我们可以看到灯的调光器处于最大亮度：
用 RFID 卡控制访问
在本节中，我们将看到如何通过门控制访问。在上一章中，我们看到了如何控制房子的锁和灯。这个项目可以作为上一个项目的补充，因为它可以让您控制门的打开，特定卧室的门，或其他房间的灯。
硬件要求
对于这个项目，我们需要以下设备：
-
读取标签卡
-
RFID RC522 模块
-
Arduino 板
下图显示了用于读取和控制访问的 RFID 标签：
下图显示了 Arduino 的 RFID 卡接口：
软件要求
我们需要安装<MFRC522.h>库，这个文件可以与并配置模块以读取标签卡进行通信。这个库可以从github.com/miguelbalboa/rfid下载。
软件代码
现在你可以将代码复制到名为RFID.ino的文件中，或者直接从该项目的文件夹中获取完整的代码：
#include <MFRC522.h>
#include <SPI.h>
#define SAD 10
#define RST 5
MFRC522 nfc(SAD, RST);
#define ledPinOpen 2
#define ledPinClose 3
void setup() {
pinMode(ledPinOpen,OUTPUT);
pinMode(ledPinClose,OUTPUT);
SPI.begin();
Serial.begin(115200);
Serial.println("Looking for RC522");
nfc.begin();
byte version = nfc.getFirmwareVersion();
if (! version) {
Serial.print("We don't find RC522");
while(1);
}
Serial.print("Found RC522");
Serial.print("Firmware version 0x");
Serial.print(version, HEX);
Serial.println(".");
}
#define AUTHORIZED_COUNT 2 //number of cards Authorized
byte Authorized[AUTHORIZED_COUNT][6] = {{0xC6, 0x95, 0x39, 0x31, 0x5B},{0x2E, 0x7, 0x9A, 0xE5, 0x56}};
void printSerial(byte *serial);
boolean isSame(byte *key, byte *serial);
boolean isAuthorized(byte *serial);
void loop() {
byte status;
byte data[MAX_LEN];
byte serial[5];
boolean Open = false;
digitalWrite(ledPinOpen, Open);
digitalWrite(ledPinClose, !Open);
status = nfc.requestTag(MF1_REQIDL, data);
if (status == MI_OK) {
status = nfc.antiCollision(data);
memcpy(serial, data, 5);
if(isAuthorized(serial))
{
Serial.println("Access Granted");
Open = true;
}
else
{
printSerial(serial);
Serial.println("NO Access");
Open = false;
}
nfc.haltTag();
digitalWrite(ledPinOpen, Open);
digitalWrite(ledPinClose, !Open);
delay(2000);
}
delay(500);
}
boolean isSame(byte *key, byte *serial)
{
for (int i = 0; i < 4; i++) {
if (key[i] != serial[i])
{
return false;
}
}
return true;
}
boolean isAuthorized(byte *serial)
{
for(int i = 0; i<AUTHORIZED_COUNT; i++)
{
if(isSame(serial, Authorized[i]))
return true;
}
return false;
}
void printSerial(byte *serial)
{
Serial.print("Serial:");
for (int i = 0; i < 5; i++) {
Serial.print(serial[i], HEX);
Serial.print(" ");
}
}
当我们将标签卡放在连接到 Arduino 的 RFID 模块前时，如果以下代码，它将显示消息（访问已授权）。
在代码的这一部分，我们配置了授权卡的数量：
**#define AUTHORIZED_COUNT 2**
**byte Authorized[AUTHORIZED_COUNT][6] = {{0xC6, 0x95, 0x39, 0x31, 0x5B},
{0x2E, 0x7, 0x9A, 0xE5, 0x56}};**
如果我们将卡片放在未注册的标签和卡上，它可以提供正确的访问：
完整连接的最终结果如下图所示：
检测烟雾
在这一部分，我们将测试一个可以检测烟雾的MQ135传感器。这也可以用于家庭检测气体泄漏。在这种情况下，我们将用它来检测烟雾。
在家庭自动化系统中，将所有传感器放置在家中以检测某些东西，我们测量真实世界：在这种情况下，我们使用了可以检测气体和烟雾的 MQ135 传感器，如下图所示：
软件代码
在下面的代码中，我们解释了如何使用气体传感器编程和检测烟雾：
const int sensorPin= 0;
const int buzzerPin= 12;
int smoke_level;
void setup() {
Serial.begin(115200);
pinMode(sensorPin, INPUT);
pinMode(buzzerPin, OUTPUT);
}
void loop() {
smoke_level= analogRead(sensorPin);
Serial.println(smoke_level);
if(smoke_level > 200){
digitalWrite(buzzerPin, HIGH);
}
else{
digitalWrite(buzzerPin, LOW);
}
}
如果它没有检测到烟雾，它会产生以下数值，如下截图所示：
如果检测到烟雾，测量值在305和320之间，可以在文件中看到如下截图：
完整电路连接的最终结果如下图所示：
使用树莓派 Zero 构建警报系统
在这一部分，我们将使用一个 PIR 传感器连接到树莓派 Zero 来构建一个简单的警报系统。这是一个重要的项目，因为它可以添加到家庭中，包括其他传感器，以便监控。
使用树莓派 Zero 的运动传感器
对于这个项目，我们需要树莓派 Zero、一个运动传感器 PIR 和一些电缆。实际上，这个项目的硬件配置将非常简单。首先，将运动传感器的VCC引脚连接到树莓派上的一个3.3V引脚。然后，将传感器的GND引脚连接到树莓派上的一个GND引脚。最后，将运动传感器的OUT引脚连接到树莓派上的GPIO17引脚。你可以参考前面的章节了解树莓派 Zero 板上的引脚映射。
以下图片显示了连接的最终电路：
软件代码
现在你可以将代码复制到名为Project1的文件夹中，或者直接从该项目的文件夹中获取完整的代码：
// Modules
var express = require('express');
// Express app
var app = express();
// aREST
var piREST = require('pi-arest')(app);
piREST.set_id('34f5eQ');
piREST.set_name('motion_sensor');
piREST.set_mode('bcm');
// Start server
app.listen(3000, function () {
console.log('Raspberry Pi Zero motion sensor started!');
});
警报模块
通常，家中会有模块，在检测到运动时会闪烁灯光并发出声音。当然，你也可以将其连接到真正的警报器而不是蜂鸣器，以便在检测到任何运动时发出响亮的声音。
要组装这个模块，首先将 LED 与 330 欧姆电阻串联放在面包板上，LED 的最长引脚与电阻接触。还要将蜂鸣器放在面包板上。然后，将电阻的另一端连接到树莓派上的GPIO14，LED 的另一端连接到树莓派上的一个GND引脚。对于蜂鸣器，将标有+的引脚连接到GPIO15，另一端连接到树莓派上的一个GND引脚。
软件代码
下面是编码细节：
// Modules
var express = require('express');
// Express app
var app = express();
// aREST
var piREST = require('pi-arest')(app);
piREST.set_id('35f5fc');
piREST.set_name('alarm');
piREST.set_mode('bcm');
// Start server
app.listen(3000, function () {
console.log('Raspberry Pi Zero alarm started!');
});
这是显示连接的最终电路：
中央接口
首先，我们使用以下代码为应用程序创建一个中央接口：
// Modules
var express = require('express');
var app = express();
var request = require('request');
// Use public directory
app.use(express.static('public'));
// Pi addresses
var motionSensorPi = "192.168.1.104:3000";
var alarmPi = "192.168.1.103:3000"
// Pins
var buzzerPin = 15;
var ledPin = 14;
var motionSensorPin = 17;
// Routes
app.get('/', function (req, res) {
res.sendfile(__dirname + '/public/interface.html');
});
app.get('/alarm', function (req, res) {
res.json({alarm: alarm});
});
app.get('/off', function (req, res) {
// Set alarm off
alarm = false;
// Set LED & buzzer off
request("http://" + alarmPi + "/digital/" + ledPin + '/0');
request("http://" + alarmPi + "/digital/" + buzzerPin + '/0');
// Answer
res.json({message: "Alarm off"});
});
// Start server
var server = app.listen(3000, function() {
console.log('Listening on port %d', server.address().port);
});
// Motion sensor measurement loop
setInterval(function() {
// Get data from motion sensor
request("http://" + motionSensorPi + "/digital/" + motionSensorPin,
function (error, response, body) {
if (!error && body.return_value == 1) {
// Activate alarm
alarm = true;
// Set LED on
request("http://" + alarmPi + "/digital/" + ledPin + '/1');
// Set buzzer on
request("http://" + alarmPi + "/digital/" + buzzerPin + '/1');
}
});
}, 2000);
图形界面
现在让我们看看界面文件，从 HTML 开始。我们首先导入项目所需的所有库和文件。
<!DOCTYPE html>
<html>
<head>
<script src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
<script src="js/script.js"></script>
<link rel="stylesheet" href="css/style.css">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<script type="text/javascript">
/* Copyright (C) 2007 Richard Atterer, richard©atterer.net
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License, version 2\. See the file
COPYING for details. */
var imageNr = 0; // Serial number of current image
var finished = new Array(); // References to img objects which have finished downloading
var paused = false;
</script>
<div id="container">
<h3>Security System</h3>
<div class='row voffset50'>
<div class='col-md-4'></div>
<div class='col-md-4 text-center'>
Alarm is OFF
</div>
<div class='col-md-4'></div>
</div>
<div class='row'>
<div class='col-md-4'></div>
<div class='col-md-4'>
<button id='off' class='btn btn-block btn-danger'>Deactivate Alarm</button>
</div>
<div class='col-md-4'></div>
</div>
</div>
</body>
</html>
从远程仪表板监控气候
如今，大多数智能家居都连接到互联网，这使用户能够监控他们的家。在本节中，我们将学习如何远程监控您的气候。首先，我们只需向树莓派 Zero 添加一个传感器，并从云仪表板监测测量值。让我们看看它是如何工作的。
以下图片显示了最终的连接：
探索传感器测试
var sensorLib = require('node-dht-sensor');
var sensor = {
initialize: function () {
return sensorLib.initialize(11, 4);
},
read: function () {
var readout = sensorLib.read();
console.log('Temperature: ' + readout.temperature.toFixed(2) + 'C, ' +
'humidity: ' + readout.humidity.toFixed(2) + '%');
setTimeout(function () {
sensor.read();
}, 2000);
}
};
if (sensor.initialize()) {
sensor.read();
} else {
console.warn('Failed to initialize sensor');
}
配置远程仪表板（Dweet.io）
我们需要访问freeboard.io并创建一个账户：
现在，我们创建一个新的仪表板来控制传感器：
使用以下参数添加新的数据源：
在仪表板内创建一个新的窗格，并为温度创建一个表盘小部件：
然后我们会立即在界面上看到温度：
我们也可以用湿度做同样的操作：
我们应该看到最终结果：
总结
在本章中，我们学习了如何构建和集成基于树莓派 Zero 和 Arduino 板的模块化安全系统。当然，有许多方法可以改进这个项目。例如，您可以简单地向项目添加更多模块，比如更多触发相同警报的运动传感器。即使您不在家庭 Wi-Fi 网络之外，也可以监控系统。
在下一章中，我们将学习如何从 Android 应用程序控制您的系统，以及如何从智能手机集成一个真实的系统，这太棒了！
第八章：从智能手机监控和控制您的设备
在之前的章节中，我们已经看到了从 Web 界面控制的项目。现在在本章中，我们将看到如何从 Android 的本机应用程序中控制您的 Arduino 和树莓派，使用平台来创建应用程序以进行控制和监视。
在本章中，我们将看到使用 Android 工具的不同项目和应用程序，将涵盖的主题如下：
-
使用 APP Inventor 从智能手机控制继电器
-
在 Android Studio 中读取 JSON 响应使用以太网盾
-
从 Android 应用程序控制直流电机
-
使用您的树莓派 Zero 从 Android 控制输出
-
通过蓝牙使用树莓派控制输出
使用 APP Inventor 从智能手机控制继电器
在本节中，我们将看到如何使用APP Inventor创建一个 Android 应用程序来控制连接到 Arduino 板的继电器。
硬件要求
项目所需的硬件如下：
-
继电器模块
-
Arduino UNO 板
-
以太网盾
-
一些电缆
软件要求
项目所需的软件如下：
-
软件 Arduino IDE
-
您需要激活 Gmail 帐户
创建我们的第一个应用程序
App Inventor for Android 是由 Google 最初提供的开源网络应用程序，现在由麻省理工学院（MIT）维护。它允许初学者为 Android 操作系统（OS）创建软件应用程序。它使用图形界面，非常类似于 Scratch 和 StarLogo TNG 用户界面，允许用户拖放可视对象以创建可以在 Android 设备上运行的应用程序。在创建 App Inventor 时，Google 利用了在教育计算领域的重要先前研究，以及 Google 在在线开发环境方面的工作。
您无需在计算机上安装任何软件来执行 APP Inventor；您只需要您的 Gmail 帐户来访问 APP Inventor 界面。
要进入 APP Inventor，只需访问：appinventor.mit.edu/explore/。
转到创建应用程序开始设计应用程序。
首先，我们需要一个 Gmail 帐户；我们需要创建如下图所示的文件：
转到菜单项目和开始新项目：
写下项目的名称：
在下图中，我们将项目的名称写为aREST：
按下确定，我们将看到项目已创建：
设计界面
现在是时候看看如何创建应用程序的界面了，创建项目后，我们点击项目名称，然后会看到以下屏幕：
在左侧的用户界面中（您可以看到所有对象），要将对象移动到主屏幕，只需拖动Web Viewer和Button，如下图所示：
在上一张屏幕截图中，我们可以看到我们将用来控制 Arduino 板的应用程序界面。
使用 APP Inventor 与 Arduino 以太网盾通信
现在我们将看到如何通过以太网网络与 Arduino 通信应用程序。
在Web Viewer控件的属性中，我们将看到主页 URL：
在这两个控件中，我们有我们的 Arduino 以太网盾的 URL，我们将使用RESTful服务发出请求，并将从应用程序发送以下请求：
-
http://192.168.1.110/digital/7/1 -
http://192.168.1.110/digital/7/0
APP Inventor 的代码
原始版本的块编辑器在单独的 Java 进程中运行，使用Open Blocks Java库创建可视块编程语言和编程。
当我们点击按钮时，我们有 APP 发明者的代码，为了做到这一点，你只需要做以下事情：
-
转到显示块的屏幕界面
-
每个按钮拖动
当...执行模块 -
在刚刚拖动的模块内部，放置
Call...WebViewer.GoToUrl模块 -
在模块的 URL 中，放置
WebViewer.HomeUrl模块
关闭应用程序：
-
拖动
当...按钮点击时执行模块 -
并在模块内部放置关闭应用程序模块
当我们打开 Web 浏览器时，我们将得到以下结果：
以下截图显示了应用程序在手机上运行的情况：
以下图像显示了连接的最终结果：
使用以太网盾在 Android Studio 中读取 JSON 响应
在本节中，我们将看到如何从 Arduino 板读取响应并在 Android Studio 中读取。
在我们继续下一部分之前，我们需要做以下事情：
-
安装 Android Studio 的 IDE，可以从以下网址获取：
developer.android.com/studio/index.html?hl=es-419 -
获取 Android Studio 的最新 SDK
然后我们将在 Android Studio 中创建一个项目，如下截图所示：
然后选择我们想要使用的 API 版本并单击下一步按钮：
然后选择空白活动并单击下一步按钮：
输入您的 Activity 和 Layout 的名称，然后单击完成按钮：
Android 应用程序
在本节中，我们将看到 Android 应用程序。在您的文件夹中，打开关于 Android Studio 的项目文件。
这里是界面代码生成的 XML 代码：
FrameLayout
android:id="@+id/container"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
tools:ignore="MergeRootFrame">
<WebView
android:id="@+id/activity_main_webview"
android:layout_width="match_parent"
android:layout_height="match_parent" />
</FrameLayout>
Java 类
当我们创建项目时，一些类会自动生成，我们将在以下行中看到：
- 类的名称：
import android.webkit.WebView;
- 主类：
public class MonitoringTemperatureHumidity extends
ActionBarActivity {
private WebView mWebView;
在 Android 应用程序的这一部分中，我们请求值：
mWebView.loadUrl("http://192.168.1.110/temperature");
mWebView.loadUrl("http://192.168.1.110/humidity");
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_monitoring_temperature_humidity);
我们定义将包含在主活动中的对象，在这种情况下是mWebView控件，它在应用程序的主活动中定义：
mWebView = (WebView) findViewById(R.id.activity_main_webview);
mWebView.loadUrl("http://192.168.1.110/humidity");
}
应用程序的权限
为了给予应用程序执行网络权限的权限，我们需要在 Android 清单文件中添加以下行：
<uses-permission android:name="android.permission.INTERNET"/>
当应用程序在设备上调试和安装后，我们将在屏幕上看到以下结果，显示温度的值：
湿度的值：
使用 Android 应用程序控制直流电机
在本节中，我们将有一个应用程序来将我们的智能手机与手机的蓝牙连接起来，它被称为Amarino，你可以从以下网址获取：www.amarino-toolkit.net/index.php/home.html。我们还将看到如何从 Android 应用程序控制直流电机，让我们深入研究一下！
硬件要求
在下图中，我们看到以下电路（L293D）用于控制电机的速度和转向：
在下图中，我们有电路连接到 Arduino 板的最终连接：
最终界面显示在以下截图中：
最终结果显示在以下图像中，带有连接：
使用 Raspberry Pi Zero 从 Android 控制输出
在本节中，我们将看到如何使用在Node.js服务器中运行的control.js脚本来控制连接到 Raspberry Pi 的输出。
我们需要使用 Android 应用程序控制 LED 输出的请求如下：
-
http://192.168.1.111:8099/ledon -
http://192.168.1.111:8099/ledoff
在 APP Inventor 中创建的界面将类似于以下截图：
最终电路连接将如以下截图所示：
通过蓝牙使用 Raspberry Pi 控制输出
一旦您尝试与使用蓝牙模块连接到 Raspberry Pi 的串行端口的其他电子设备进行通信，情况就会有所不同。
这些模块非常便宜，实际模块是坐落在我的模型的插板上的绿色板。纯 HC-05 只能在3.3V电平上工作，而不能在5V-TTL电平上工作。因此，人们需要电平转换器（再次）。
在本节中，我们将 Raspberry Pi Zero 与蓝牙模块进行通信，并连接 Raspberry Pi 的TX和RX引脚。
首先，我们需要配置系统文件，进行一些更改以激活 Raspberry Pi Zero TX 和 RX 的通信：
从 Android 应用程序控制灯光
我们需要下载蓝牙终端，如下截图所示：
以下截图显示了发送数字 1、2、3、4、5 和 6 的结果：
以下图像显示了项目的最终部分以及与 HC05 模块和 Raspberry Pi Zero 的连接：
总结
在本章中，您学会了如何使用 Android Studio 和 APP inventor 通过蓝牙和以太网通信从智能手机控制 Arduino 和 Raspberry Pi Zero。我们还研究了几个项目，如控制电机、控制继电器模块以及读取湿度和温度。对于未来的项目，您现在可以在应用程序的任何区域控制和监视任何您想要的东西。
在下一章中，我们将整合前几章的所有内容，并将所有知识应用到一起。
第九章：将所有内容放在一起
之前的章节为我们提供了设计和组装整个家庭系统的基础和元素，我们将在本章中进行研究。我希望我已经以相当结构化和逻辑的方式引导您进行了这次旅程，以便您已经准备好了。
作为构建整个系统的指南，在本章中，我们将指导您如何整合并给出一些将所有内容放在一起的想法，并为您提供最终的细节。然后，您可以使用我们在本章中提到的想法制作自己的项目。
在本章中，我们将涵盖以下主题：
-
整合系统-开发项目
-
使用矩阵键盘控制访问
-
将系统控制与继电器和设备集成
-
如何设置电源供应
整合系统-开发项目
在之前的章节中，我们已经看到了关于家庭自动化和家用电器控制和监控的不同项目。在本章中，我们将提供一些想法，开发一些可以在不同领域使用电子设备进行控制和监控的项目。
深入了解光传感器
正如其名称所示，“光敏电阻（LDR）”由一块暴露的半导体材料制成，例如硫化镉，当光照射到它时，它的电阻从黑暗中的几千欧姆变为只有几百欧姆，通过在材料中创建空穴-电子对。净效应是其导电性的改善，随着照明的增加，电阻减小。此外，光敏电池具有长时间的响应，需要多秒钟才能对光强度的变化做出反应。
在本节中，我们将看看如何使用光传感器来控制不同的设备：
-
需要时开关灯光
-
当传感器检测到房间内是否有光线时，调暗灯光
可以使用信号传感器调暗灯光；根据光传感器测量的数据，可以调节其强度。
运动传感器
运动传感器检测体热（红外能量）。被动红外传感器是家庭安全系统中最广泛使用的运动传感器。当您的系统处于武装状态时，您的运动传感器会被激活。一旦传感器变热，它就可以检测周围区域的热量和运动，形成一个保护网格。
如果移动物体阻挡了太多的网格区域，并且红外能量级别迅速变化，传感器就会触发。使用这个传感器，我们可以在需要时控制灯光的开关：
根据传感器测量的距离，它可以检测物体，因此您可以控制灯光：
自动光控制器
当您不在家时，或者当您告诉系统您不在家时，传感器会起作用。一些安全系统可以被编程，当检测到运动时通过安全摄像头记录事件。运动检测的主要目的是感应入侵者并向您的控制面板发送警报，从而向您的监控中心发出警报：
以下电路图显示了自动光控制的连接，其中使用了之前使用的所有元素，如 LDR 传感器、PIR 传感器和继电器模块：
太阳能电源监控电路
这里有另一个真实项目，显示了一个控制面板，将使用 Arduino 板监控太阳能电池板的能量。以下图表显示了传感器和太阳能电池板连接到 Arduino 板的连接：
带土壤传感器的自动灌溉系统
在下图中，我们有另一个项目；我们正在整合以前使用过的工具。在这种情况下，我们将使用土壤传感器在有或无水时控制浇水：
到目前为止，您已经看到了可以应用于真实情况的非常有趣和有价值的项目，涉及不同领域，如家庭、家庭自动化，甚至花园。在接下来的章节中，我们将看更多的项目。让我们开始吧！
Arduino 水位控制器
在这个项目中，我们将制作一个自动水位传感器，使用您的 Arduino 板来控制水位，如下图所示：
基于蓝牙的家庭自动化
在本节中，我们将看一个可以用于家庭自动化的项目，使用蓝牙模块进行通信，继电器模块和硬件集成作为软件工具来控制房屋中的设备。
下图显示了如何将继电器模块和 HC05 蓝牙模块连接到 Arduino 板：
使用矩阵键盘控制访问
在本节中，我们将看如何使用矩阵键盘控制访问代码。在下图中，我们可以看到我们将使用的键盘：
键盘
在下图中，我们看到了与 Arduino 板的硬件连接。它们连接到数字引脚：
连接 LCD 屏幕显示代码
在下图中，我们展示了 LCD 屏幕与 Arduino 板的硬件连接：
我们已经看过一些有趣的项目，您可以通过添加新的传感器来控制其他设备。在下一节中，我们将看一个非常有趣的项目。准备好迈出下一步，这是一个很好的目标。
使用键盘控制门锁
在下图中，我们看到了一个带锁的键盘。这一部分可以与上一个项目合并。这个设备可以从您的 Raspberry Pi Zero 或 Arduino 板上进行控制：
使用键盘访问的代码
您现在可以将代码复制到名为 Project_keyboard_Access_Control.ino 的文件中，或者只需使用 Arduino IDE 从此项目的文件夹中获取完整的代码：
void captura()
{
tecla = customKeypad.getKey();
if (tecla)
{
digito = digito + 1;
if(tecla==35){tecla=0;digito=0;valorf=0;lcd.setCursor(0,0);lcd.print(valorf);
lcd.print(" ");}
if(tecla==48){tecla=0;}
if(tecla==42){tecla=0;digito=0;valor = valorf;}
if(digito==1){valorf1 = tecla; valorf=valorf1;lcd.setCursor(0,0);
lcd.print(valorf);lcd.print(" ");}
if(digito==2){valorf2 = tecla+(valorf1*10);valorf=valorf2;lcd.setCursor(0,0);
lcd.print(valorf);lcd.print(" ");}
if(digito==3){valorf3 = tecla+(valorf2*10);valorf=valorf3;lcd.setCursor(0,0);
lcd.print(valorf);lcd.print(" ");}
if(digito==4){valorf4 = tecla+(valorf3*10);valorf=valorf4;lcd.setCursor(0,0);
lcd.print(valorf);lcd.print(" ");}
if(digito==5){valorf5 = tecla+(valorf4*10);valorf=valorf5;lcd.setCursor(0,0);
lcd.print(valorf);lcd.print(" ");digito=0;}
}
此功能检查键入的代码是否正确：
void loop()
{
captura();
if (valor == 92828)
{
digitalWrite(lock,HIGH);
}
if (valor == 98372)
{
digitalWrite(lock,LOW);
}
}
集成系统控制与继电器和设备
在下图中，我们正在整合书中的重要部分。我们将展示使用继电器在房屋中的连接，以及如何应用和控制真实负载使用灯：
控制多个电器
在现实生活中，我们将看到连接并控制真实世界的设备。在下图中，我们可以看到可以控制电子部分负载的继电器模块：
下图显示了最终电路。我们看到了与 Arduino 板的真实连接，以及它们如何控制真实世界。
完整系统
在下图中，我们看到了控制家庭自动化系统中真实设备的最终电路。这可以在家中的所有区域使用，在每个房间中我们可以有一个继电器模块，与控制系统通信：
如何设置电源供应
对于我们的系统，设置系统中将使用的电源非常重要。首先，我们需要确保 Arduino 的电压约为 5V。在下图中，我们展示了如何将电压配置为约 5 伏特：
交流负载的电源供应
如果我们需要将交流负载连接到 Arduino 或树莓派 Zero 并建立工业控制系统，我们需要使用 24V 直流电压，如下电路图所示：
将 24V 直流继电器连接到 Arduino 板
在下图中，我们有了使用 24 伏特直流继电器控制交流负载的电路：
我们有了最终电路，它代表了连接到 Raspberry Pi Zero 或 Arduino 板的数字引脚的接口，用于控制交流负载：这并不常见，但有必要学习如何将能够用 24 伏特直流通电的继电器连接到 Arduino 板：
最后，我们在一个板上有了最终电路。我们使用了一个需要用 24 伏特通电的线圈的继电器。Arduino 或树莓派的数字输出可以连接到继电器模块。
摘要
这是书籍《JavaScript 物联网编程》的最后一章。在本章中，您将学习如何整合在项目中需要考虑的所有元素，当您想要将硬件和软件工具应用到我们展示的项目中时。这将帮助您继续开发自己的项目，遵循本书中分享的基础知识。
