8. Python 教程¶
开发环境设置¶
在开始构建项目之前，你需要首先做一些准备，这是非常重要的，你不能跳过。
一、安装Thonny(重要)：
Thonny是一个免费、开源的软件平台，体积小，界面简单，操作简单，功能丰富，是一个适合初学者的Python IDE。在本教程中，我们使用这个IDE在整个过程中开发ESP32。Thonny支持多种操作系统，包括Windows, Mac OS, Linux。
1.下载Thonny软件：
(1) 进入软件官网：https://thonny.org 下载Thonny软件，最好下载最新版的，否则可能不支持ESP32.
(2) Thonny的开源代码库：https://github.com/thonny/thonny
请按照官网的指导安装或点击下面的链接下载安装。(请根据您的操作系统选择相应的选项.)
| 操作系统 | 下载链接/方法 |
|---|---|
| MAC OS： | https://github.com/thonny/thonny/releases/download/v3.2.7/thonny-3.2.7.pkg |
| Windows： | https://github.com/thonny/thonny/releases/download/v3.2.7/thonny-3.2.7.exe |
| Linux： | 最新版本:（如下） |
Binary bundle for PC (Thonny+Python):
bash <(wget -O - https://thonny.org/installer-for-linux)
With pip:
pip3 install thonny
Distro packages (may not be the latest version):
Debian, Rasbian, Ubuntu, Mint and others:
sudo apt install thonny
Fedora:
sudo dnf install thonny
2.Windows上安装Thonny软件：
A.下载后的Thonny图标如下。
B.双击“thonny-4.0.2.exe”，会出现下面对话框，我这里是选择“
”进行操作的。你也可以选择“
”进行操作的。
C.如果您不熟悉电脑软件安装，您可以一直单击“Next”直到安装完成。
D.如果您需要更改Thonny软件的安装路径，可以单击“Browse...”进行修改。选择安装路径后，单击“OK”。
如果您不想更改安装路径，只需单击“Next”；然后又继续单击“Next”。
E.选中“Create desktop icon”，Thonny软件会在你的桌面上生成一个快捷方式，方便你稍后打开Thonny软件。
F.单击“Install”安装软件。
G.在安装过程中，您只需等待安装完成，千万不要点击“Cancel”，否则将无法安装成功。
H.一旦看到如下界面，就表示已经成功安装了Thonny软件，点击“Finish”就可以。
I.如果你在安装过程中选择了“Create desktop icon”，则可以在桌面上看到如下图标。
二、Thonny软件基本配置
A.双击Thonny软件的桌面图标，可以看到如下界面，同时还可以进行语言选择(这里选择简体中文)和初始设置。设置完了点击“Let’s go！”。
B.选择“视图”→“文件”和“Shell”。
三、安装CP2102驱动：
ESP32通过CP2102驱动下载代码。所以在使用它之前，我们需要在计算机中安装CP2102驱动程序。
Windows 系统
检查CP2102驱动是否已经安装
1. 用USB线连接计算机和ESP32。
2. 进入计算机主界面，选择“此电脑”，右键单击选择“管理”。
3.单击“设备管理器”。如果你的计算机已经安装了CP2102驱动，则可以看到“Silicon Labs CP210x USB to UART Bridge(COMx)”。
安装CP2102驱动
1. 如果未安装CP2102驱动，界面显示如下。
2.单击“CP2102 USB to UART Bridge Controller”，右键选择“更新驱动程序(P)”。
3.单击“浏览我的电脑以查找驱动程序(R) ”.
4.单击“浏览(R)...”选择CP210x_6.7.4(驱动路径：..\其他重要资料\CP2102驱动文件\CP2102 驱动文件-Windows)，单击“下一页”
5. 等待CP2102驱动安装完成。当界面显示如下时，表示已安装CP2102驱动。你可以关闭该界面。
6.ESP32与计算机连接时，界面显示如下。
MAC 系统
安装CP2102驱动方法请参照 “Arduino C 教程 Windows” 教程中 “开发环境设置” 部分。
四、烧入Micropython固件(重要)
要在ESP32主板上运行Python程序，我们需要先将固件烧入到ESP32主板。
下载Micropython固件
microPython官方网站：http://micropython.org/
网页列出microPython的ESP32固件：https://micropython.org/download/esp32/
本教程中使用的固件是：esp32-20210902-v1.19.bin
我们的文件夹中也提供了这个固件：“..\其他重要资料\Python固件和软件\Python_固件”。
烧入Micropython固件
用USB线连接计算机和ESP32主板。
确保驱动程序已成功安装，并能正确识别COM端口。打开设备管理器并展开“端口(COM和LPT)”。
注意：不同的电脑，COM端口可能不同，这是正常情况。
1.打开Thonny，点击“运行” ，选择 “配置解释器”
2.选中“MicroPython (ESP32)”，选中“Silicon Labs CP210x USB to UART Bridge(COM7)”，然后点击“安装或更新MicroPython”。
3.弹出如下对话框，“Port”选择“Silicon Labs CP210x USB to UART Bridge(COM7)”，单击“Browse...”选择之前准备好的microPython固件esp32-20220618-v1.19.1.bin。检查“Erase flash before installing”和“Flash mode”，然后点击“安装”，等待安装完成提示。（注意：如果安装固件失败，请再次点击“安装”，然后按住ESP32主板上的Boot键
，出现上传进度百分比再松开Boot键。）
4.等待安装完成。安装完成后先点击“关闭”再点击“好的”就行。
5.关闭所有对话框，转到主界面，点击“
”。如下图所示：
6.到目前为止，一切准备工作都已就绪。
五、测试代码：
测试Shell命令
在“Shell”窗口中输入“print('hello world')”并按Enter键。
在线运行
ESP32需要连接到计算机时，它是在线运行。用户可以使用Thonny编写和调试程序。
1.打开Thonny并单击
“打开”。
2.在新弹出的窗口中，单击“此电脑”。
在新的对话框中，在路径：“..\程序代码\Python_代码\项目01 Hello World” 中选择 “Project_01_HelloWorld.py” 。
单击
, “Hello World”将在“Shell”窗口中打印出来。
注意：在线运行时，如果按下ESP32的复位键，用户的代码将不会再次执行。
六、Thonny常见的操作：
本教程中使用的代码保存在（即路径）：“..\程序代码\Python_代码”。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
上传代码到ESP32
为了方便起见，我们以“项目17 I2C 128×32 LCD”为例。在“项目17 I2C 128×32 LCD”文件夹中选择“lcd128_32.py”，右键单击鼠标，选择“上传到/”将代码上传到ESP32的根目录中。
下载代码到电脑
在“MicroPython 设备”中选择“boot.py”，右键选择“下载到…”把代码下载到你的电脑里。
删除ESP32根目录下的文件
在“MicroPython 设备”中选择“lcd128_32.py”，右键单击它且选择“删除”，将“lcd128_32.py”从ESP32的根目录中删除。
项目01 Hello World¶
1.项目介绍：
对于ESP32的初学者，我们将从一些简单的东西开始。在这个项目中，你只需要一个ESP32主板，USB线和电脑就可以完成“Hello World!”项目。它不仅是ESP32主板和电脑的通信测试，也是ESP32的初级项目。
2.项目元件：
 |
 |
|---|---|
| ESP32*1 | USB 线*1 |
3.项目接线：
在本项目中，我们通过USB线将ESP32和电脑连接起来。
4.在线运行代码：
要在线运行ESP32，你需要把ESP32连接到电脑上。这样就可以使用Thonny软件编译或调试程序。
优点：
- 你们可以使用Thonny软件编译或调试程序。
- 通过“Shell”窗口，你们可以查看程序运行过程中产生的错误信息和输出结果，并可以在线查询相关功能信息，帮助改进程序。
缺点：
- 要在线运行ESP32，你必须将ESP32连接到一台电脑上并和Thonny软件一起运行。
- 如果ESP32与电脑断开连接，当它们重新连接时，程序将无法再次运行。
基本操作：
1.打开Thonny软件，并且单击
“打开...”。
2.在新弹出的窗口中，单击“此电脑”。
在新的对话框中，选中“Project_01_HelloWorld.py”,单击“打开”。
注意：
本教程中使用的代码保存在：“..\程序代码\Python_代码” 的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
3.单击来执行程序“Hello World!”, "Welcome Keyestudio" 并将打印在“Shell”窗口。
5.退出在线运行
当在线运行时，单击Thonny软件上
或按Ctrl+C退出程序。
项目02 点亮LED¶
1.项目介绍：
在这个项目中，我们将向你展示点亮LED。我们使用ESP32的数字引脚打开LED，使LED被点亮。
2.项目元件：
|
 |
 |
|---|---|---|
| ESP32*1 | 面包板*1 | 红色LED*1 |
 |
 |
|
| 220Ω电阻*1 | 跳线*2 | USB 线*1 |
3.元件知识：
（1）LED
LED是一种被称为“发光二极管”的半导体，是一种由半导体材料(硅、硒、锗等)制成的电子器件。它有正极和负极。短腿为负极，接GND，长腿为正极，接3.3V或5V。
（2）五色环电阻
电阻是电路中限制或调节电流流动的电子元件。左边是电阻器的外观，右边是电阻在电路中表示的符号。电阻(R)的单位为欧姆(Ω)，1 mΩ= 1000 kΩ，1kΩ= 1000Ω。
我们可以使用电阻来保护敏感组件，如LED。电阻的强度（以Ω为单位）用小色环标记在电阻器的主体上。每种颜色代表一个数字，你可以用电阻对照卡查找。
在这个套件中，我们提供了3个具有不同电阻值的五色环电阻。这里以3个五色环电阻为例：
220Ω电阻×10
10KΩ电阻×10
1KΩ电阻×10
在相同的电压下，会有更小的电流和更大的电阻。电流、电压、电阻之间的联系可以用公式表示：I=U/R。在下图中，目前通过R1的电流: I = U / R = 3 V / 10 KΩ= 0.0003A= 0.3mA。
不要把电阻值很低的电阻直接连接在电源两极，这样会使电流过高而损坏电子元件。电阻是没有正负极之分。
（3）面包板
面包板是实验室中用于搭接电路的重要工具。面包板上有许多孔，可以插入集成电路和电阻等电路元件。熟练掌握面包板的使用方法是提高实验效率，减少实验故障出现几率的重要基础之一。下面就面包板的结构和使用方法做简单介绍。一个典型的面包板如下所示：
面包板的外观和内部结构如上图所示，常见的最小单元面包板分上、中、下三部分，上面和下面部分一般是由一行或两行的插孔构成的窄条，中间部分是由中间一条隔离凹槽和上下各5 行的插孔构成的条。
在面包板的两个窄条分别有两行插孔，两行之间是不连通的，一般是作为电源引入的通路。上方第一行标有“+”的一行有10组插孔（内部都是连通），均为正极；上方第二行标有“-”的一行有10组插孔，（内部都是连通），均为接地。面包板下方的第一行与第二行结构同上。如需用到整个面包板，通常将“+”与“+”用导线连接起来，“-”与“-”用导线连接起来。
中间部分宽条是由中间一条隔离凹槽和上下各5 行的插孔构成。在同一列中的5 个插孔是互相连通的，列和列之间以及凹槽上下部分则是不连通的。外观及结构如下图：
中间部分宽条的连接孔分为上下两部分，是面包板的主工作区，用来插接原件和跳线。在同一列中的5个插孔（即a-b-c-d-e，f-g-h-i-j）是互相连通的；列和列之间以及凹槽上下部分是不连通的。在做实验的时候，通常是使用两窄一宽组成的小单元，在宽条部分搭接电路的主体部分，上面的窄条取一行做电源，下面的窄条取一行做接地。中间宽条用于连接电路，由于凹槽上下是不连通的，所以集成块一般跨插在凹槽上。
(4)电源
ESP32需要3.3V-5V电源，在本项目中，我们通过用USB线将ESP32和电脑连起来。
4.项目接线图：
首先，切断ESP32的所有电源。然后根据接线图搭建电路。电路搭建好并验证无误后，用USB线将ESP32连接到电脑上。
注意：避免任何可能的短路(特别是连接3.3V和GND)!
警告：短路可能导致电路中产生大电流，造成元件过热，并对硬件造成永久性损坏。
注意:
怎样连接LED
怎样识别五色环220Ω电阻
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目02 点亮LED”。并鼠标左键双击“Project_02_Turn_On_LED.py”。
from machine import Pin
import time
led = Pin(15, Pin.OUT) # 创建引脚15为LED对象，设置引脚15为输出
led.value(1) # led点亮
6.项目现象：
确保ESP32已经连接到电脑上，单击
。
单击
，代码开始执行，你会看到的现象是：电路中的LED被点亮。按“Ctrl+C”或单击退出程序。
项目03 LED闪烁¶
1.项目介绍：
在这个项目中，我们将向你展示LED闪烁效果。我们使用ESP32的数字引脚打开LED，让它闪烁。
2.项目元件：
|
|
|
|---|---|---|
| ESP32*1 | 面包板*1 | 红色LED*1 |
|
|
|
| 220Ω电阻*1 | 跳线*2 | USB 线*1 |
3.项目接线图：
首先，切断ESP32的所有电源。然后根据电路图和接线图搭建电路。电路搭建好并验证无误后，用USB线将ESP32连接到电脑上。
注意：避免任何可能的短路(特别是连接3.3V和GND)!
警告：短路可能导致电路中产生大电流，造成元件过热，并对硬件造成永久性损坏。
注意:
怎样连接LED
怎样识别五色环220Ω电阻
4.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目03 LED闪烁”。并鼠标左键双击“Project_03_LED_Flashing.py”。
from machine import Pin
import time
led = Pin(15, Pin.OUT) # 创建引脚15为LED对象，设置引脚15为输出
try:
while True:
led.value(1) # LED点亮
time.sleep(0.5) # 延时 0.5s
led.value(0) # LED熄灭
time.sleep(0.5) # 延时 0.5s
except:
pass
5.项目现象：
确保ESP32已经连接到电脑上，单击。
单击“”，代码开始执行，你会看到的现象是：电路中的LED开始闪烁。按“Ctrl+C”或单击“”退出程序。
项目04 呼吸灯¶
1.项目介绍：
在之前的研究中，我们知道LED有亮/灭状态，那么如何进入中间状态呢?如何输出一个中间状态让LED“半亮”?这就是我们将要学习的。呼吸灯，即LED由灭到亮，再由亮到灭，就像“呼吸”一样。那么，如何控制LED的亮度呢?我们将使用ESP32的PWM来实现这个目标。
2.项目元件：
|
|
|
|---|---|---|
| ESP32*1 | 面包板*1 | 红色LED*1 |
|
|
|
| 220Ω电阻*1 | 跳线*2 | USB 线*1 |
3.元件知识：
模拟信号 & 数字信号
模拟信号在时间和数值上都是连续的信号。相反，数字信号或离散时间信号是由一系列数字组成的时间序列。生活中的大多数信号都是模拟信号，一个熟悉的模拟信号的例子是: 全天的温度是连续不断变化的，而不是突然从0到10的瞬间变化。然而，数字信号的值可以瞬间改变，这个变化用数字表示为1和0(二进制代码的基础)。如下图所示，我们可以更容易地看出它们的差异。
在实际应用中，我们经常使用二进制作为数字信号，即一系列的0和1。由于二进制信号只有两个值(0或1)，因此具有很大的稳定性和可靠性。最后，可以将模拟信号和数字信号相互转换。
PWM： 脉宽调制(PWM)是一种利用数字信号控制模拟电路的有效方法。普通处理器不能直接输出模拟信号。PWM技术使这种转换(将数字信号转换为模拟信号)非常方便。PWM技术利用数字引脚发送一定频率的方波，即高电平和低电平的输出，交替持续一段时间。每一组高电平和低电平的总时间一般是固定的，称为周期(注:周期的倒数是频率)。高电平输出的时间通常称为脉宽，占空比是脉宽(PW)与波形总周期(T)之比的百分比。高电平输出持续时间越长，占空比越长，模拟信号中相应的电压也就越高。下图显示了对应于脉冲宽度0%-100%的模拟信号电压在0V-3.3V(高电平为3.3V)之间的变化情况.
PWM占空比越长，输出功率越高。既然我们了解了这种关系，我们就可以用PWM来控制LED的亮度或直流电机的速度等等。从上面可以看出，PWM并不是真实的模拟信号，电压的有效值等于相应的模拟信号。因此，我们可以控制LED和其他输出模块的输出功率，以达到不同的效果。
ESP32 与 PWM
几乎所有ESP32输入/输出引脚都可用于PWM（脉冲宽度调制）。使用这些引脚可以控制电机和LED灯等。
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目04 呼吸灯”。并鼠标左键双击“Project_04_Breathing_LED.py”。
import time
from machine import Pin,PWM
# ESP32 PWM引脚输出的方式与传统控制器不同。
# 它可以改变频率和占空比通过配置PWM的参数在初始化阶段。
# 定义GPIO15的输出频率为10000Hz，分配给PWM。
pwm =PWM(Pin(15,Pin.OUT),10000)
try:
while True:
# 占空比范围为0-1023，因此我们使用第一个for回路控制PWM改变占空比值，使PWM输出0% -100%;
# 使用第二个for回路使PWM输出100%-0%。
for i in range(0,1023):
pwm.duty(i)
time.sleep_ms(1)
for i in range(0,1023):
pwm.duty(1023-i)
time.sleep_ms(1)
except:
# 每次使用PWM时，硬件定时器将打开以配合它。
# 因此，每次使用PWM后，都需要调用deinit()来关闭定时器。否则，下次PWM可能无法工作.
pwm.deinit()
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：电路中的LED从暗逐渐变亮，再从亮逐渐变暗，就像呼吸一样。按“Ctrl+C”或单击退出程序。
项目05 交通灯¶
1.项目介绍：
交通灯在我们的日常生活中很普遍。根据一定的时间规律，交通灯是由红、黄、绿三种颜色组成的。每个人都应该遵守交通规则，这可以避免许多交通事故。在这个项目中，我们将使用ESP32和一些led(红，黄，绿)来模拟交通灯。
2.项目元件：
|
|
|
 |
|---|---|---|---|
| ESP32*1 | 面包板*1 | 红色LED*1 | 黄色 LED*1 |
 |
|
|
|
| 绿色LED*1 | 220Ω电阻*3 | 跳线若干 | USB 线*1 |
3.项目接线图：
4.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目05 交通灯”。并鼠标左键双击“Project_05_Traffic_Lights.py”。
from machine import Pin
import time
led_red = Pin(0, Pin.OUT) # 创建引脚0为红色led对象，设置引脚0为输出
led_yellow = Pin(2, Pin.OUT) # 创建引脚2为黄色led对象，设置引脚2为输出
led_green = Pin(15, Pin.OUT) # 创建引脚15为绿色led对象，设置引脚15为输出
while True:
led_red.value(1) # 红色LED点亮
time.sleep(5) # 延时 5s
led_red.value(0) # 红色LED熄灭
led_yellow.value(1)
time.sleep(0.5)
led_yellow.value(0)
time.sleep(0.5)
led_yellow.value(1)
time.sleep(0.5)
led_yellow.value(0)
time.sleep(0.5)
led_yellow.value(1)
time.sleep(0.5)
led_yellow.value(0)
time.sleep(0.5)
led_green.value(1)
time.sleep(5)
led_green.value(0)
5.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：1.首先，红灯会亮5秒，然后熄灭；2.其次，黄灯会闪烁3次，然后熄灭；3.然后，绿灯会亮5秒，然后熄灭；4.继续运行上述1-3个步骤。按“Ctrl+C”或单击退出程序。
项目06 RGB LED¶
1.项目介绍：
RGB led由三种颜色(红、绿、蓝)组成，通过混合这三种基本颜色可以发出不同的颜色。在这个项目中，我们将向你介绍RGB LED，并向你展示如何使用ESP32控制RGB LED发出不同的颜色光。即使RGB LED是非常基本的，但这也是一个介绍自己或他人电子和编码基础的伟大方式。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | RGB LED*1 |
|
|
|
| 220Ω电阻*3 | 跳线若干 | USB 线*1 |
3.元件知识：
显示器大多遵循RGB颜色标准，电脑屏幕上的所有颜色都是由红、绿、蓝三种颜色以不同比例混合而成。
这个RGB LED有4个引脚，每个颜色(红，绿，蓝)和一个共同的阴极。为了改变RGB led的亮度，我们可以使用ESP的PWM引脚。PWM引脚会给RGB led不同占空比的信号以获得不同的颜色。
如果我们使用3个10位PWM来控制RGBLED，理论上我们可以通过不同的组合创建2^10 ×2^10 ×2^10= 1,073,741,824(10亿)种颜色。
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目06 RGB LED”。并鼠标左键双击“Project_06_RGB_LED.py”。
# 导入Pin、PWM和random库.
from machine import Pin, PWM
from random import randint
import time
# 配置GPIO15, GPIO2, GPIO0的输出方式为PWM输出，PWM频率为10000Hz.
pins = [0, 2, 15]
pwm0 = PWM(Pin(pins[0]),10000)
pwm1 = PWM(Pin(pins[1]),10000)
pwm2 = PWM(Pin(pins[2]),10000)
#定义一个函数来设置RGBLED的颜色.
def setColor(r, g, b):
pwm0.duty(1023-r)
pwm1.duty(1023-g)
pwm2.duty(1023-b)
try:
while True:
red = randint(0, 1023)
green = randint(0, 1023)
blue = randint(0, 1023)
setColor(red, green, blue)
time.sleep_ms(200)
except:
pwm0.deinit()
pwm1.deinit()
pwm2.deinit()
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：RGB LED开始显示随机颜色。按“Ctrl+C”或单击退出程序。
项目07 流水灯¶
1.项目介绍：
在日常生活中，我们可以看到许多由不同颜色的led组成的广告牌。他们不断地改变灯光(像流水一样)来吸引顾客的注意。在这个项目中，我们将使用ESP32控制10个leds实现流水的效果。
2.项目元件：
|
|
|
|---|---|---|
| ESP32*1 | 面包板*1 | 红色LED*10 |
|
|
|
| 220Ω电阻*10 | 跳线若干 | USB 线*1 |
3.项目接线图:
4.项目代码：
本项目是设计制作一个流水灯。这是这些行动：首先打开LED #1，然后关闭它。然后打开LED #2，然后关闭…并对所有10个LED重复同样的操作，直到最后一个LED关闭。这一过程反复进行，以实现流水的“运动”。
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目07 流水灯”。并鼠标左键双击“Project_07_Flowing_Water_Light.py”。
from machine import Pin
import time
# 使用阵列定义10个连接点阵屏的GPIO端口，便于操作。.
pins = [22, 21, 19, 18, 17, 16, 4, 0, 2, 15]
# 使用两个for循环分别从左到右打开led，然后从右到左打开led
def showLed():
for pin in pins:
print(pin)
led = Pin(pin, Pin.OUT)
led.value(1)
time.sleep_ms(100)
led.value(0)
time.sleep_ms(100)
for pin in reversed(pins):
print(pin)
led = Pin(pin, Pin.OUT)
led.value(1)
time.sleep_ms(100)
led.value(0)
time.sleep_ms(100)
while True:
showLed()
5.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：10个LED将从左到右点亮，然后从右到左返回。按“Ctrl+C”或单击退出程序。
项目08 一位数码管¶
1.项目介绍：
七段数码管是一种显示十进制数字的电子显示设备，广泛应用于数字时钟、电子仪表、基本计算器和其他显示数字信息的电子设备。甚至我们在电影中看到的炸弹也有七段数码管。也许七段数码管看起来不够现代，但它们是更复杂的点阵显示器的替代品，在有限的光线条件下和强烈的阳光下都很容易使用。在这个项目中，我们将使用ESP32控制一位数码管显示数字。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | 一位数码管*1 |
|
|
|
| 220Ω电阻*8 | 跳线若干 | USB 线*1 |
3.元件知识：
一位数码管显示原理： 数码管显示是一种半导体发光器件。它的基本单元是一个发光二极管(LED)。数码管显示根据段数可分为7段数码管和8段数码管。8段数码管比7段多一个LED单元(用于小数点显示)。七段LED显示屏的每段是一个单独的LED。根据LED单元接线方式，数码管可分为共阳极数码管和共阴极数码管。
在共阴极7段数码管中，分段LED的所有阴极(或负极)都连接在一起，你应该把共阴极连接到GND，要点亮一个分段LED，你可以将其关联的引脚设置为HIGH。
在共阳极7段数码管中，所有段的LED阳极(正极)都连接在一起，你应该把共阳极连接到+5V。要点亮一个分段LED，你可以将其关联的引脚设置为LOW。
数码管的每个部分由一个LED组成。所以当你使用它的时候，你也需要使用一个限流电阻。否则，LED会被烧坏。在这个实验中，我们使用了一个普通的共阴极一位数码管。正如我们上面提到的，你应该将公共阴极连接到GND，要点亮一个分段LED，你可以将其关联的引脚设置为HIGH。
4.项目接线图：
注意：插入面包板的七段数码管方向与接线图一致，右下角多一个点。
5.项目代码：
数字显示分7段，小数点显示分1段。当显示某些数字时，相应的段将被点亮。例如，当显示数字1时，b和c段将被打开。
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目08 一位数码管”。并鼠标左键双击“Project_08_One_Digit_Digital_Tube.py”。
from machine import Pin
import time
a = Pin(16, Pin.OUT)
b = Pin(4, Pin.OUT)
c = Pin(5, Pin.OUT)
d = Pin(18, Pin.OUT)
e = Pin(19, Pin.OUT)
f = Pin(22, Pin.OUT)
g = Pin(23, Pin.OUT)
dp = Pin(17, Pin.OUT)
pins = [Pin(id,Pin.OUT) for id in [16, 4, 5, 18, 19, 22, 23, 17]]
def show(code):
for i in range(0, 8):
pins[i].value(~code & 1)
code = code >> 1
# 选择0 ~ 9之间的编码
mask_digits = [0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8,0x80, 0x90]
for code in reversed(mask_digits):
show(code)
time.sleep(1)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：一位数码管将显示从9到0的数字。按“Ctrl+C”或单击退出程序。
项目09 四位数码管¶
1.项目介绍：
四位数码管是一种非常实用的显示器件，电子时钟的显示，球场上的记分员，公园里的人数都是需要的。由于价格低廉，使用方便，越来越多的项目将使用4位数码管。在这个项目中，我们使用ESP32控制四位数码管来显示四位数字。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | 四位数码管*1 |
|
|
|
| 220Ω电阻*8 | 跳线若干 | USB 线*1 |
3.元件知识：
四位数码管： 四位数码管有共阳极和共阴极两种四位数码管，显示原理是和一位数码管是类似的，都是8个GPIO口控制数码管的显示段，就是8个led灯，不过，这里是4位的，所以就还需要4个GPIO口来控制位选择端，就是选择哪个单个数码管亮，位的切换很快，肉眼区分不出来，这样看起来是多个数码管同时显示。
我们的四位数码管是共阴极的。
下图为4位数码管的引脚图，G1、G2、G3、G4就是控制位的引脚
。
下图为4位数码管内部布线原理图
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目09 四位数码管”。并鼠标左键双击“Project_09_Four_Digit_Digital_Tube.py”。
from machine import Pin
import time
#数码管每个数字引脚
a = Pin(18, Pin.OUT)
b = Pin(13, Pin.OUT)
c = Pin(2, Pin.OUT)
d = Pin(16, Pin.OUT)
e = Pin(17, Pin.OUT)
f = Pin(19, Pin.OUT)
g = Pin(0, Pin.OUT)
dp = Pin(4, Pin.OUT)
G1 = Pin(21, Pin.OUT)
G2 = Pin(22, Pin.OUT)
G3 = Pin(14, Pin.OUT)
G4 = Pin(15, Pin.OUT)
#数码管a到dp对应的引脚
d_Pins=[Pin(i,Pin.OUT) for i in [18,13,2,16,17,19,0,4]]
#数码管段G1、G2、G3、G4对应的引脚
w_Pins=[Pin(i,Pin.OUT) for i in [21,22,14,15]]
number={
'0':
[1,1,1,1,1,1,0,0],#0
'1':
[0,1,1,0,0,0,0,0],#1
'2':
[1,1,0,1,1,0,1,0],#2
'3':
[1,1,1,1,0,0,1,0],#3
'4':
[0,1,1,0,0,1,1,0],#4
'5':
[1,0,1,1,0,1,1,0],#5
'6':
[1,0,1,1,1,1,1,0],#6
'7':
[1,1,1,0,0,0,0,0],#7
'8':
[1,1,1,1,1,1,1,0],#8
'9':
[1,1,1,1,0,1,1,0],#9
}
def display(num,dp):
global number
count=0
for pin in d_Pins:#显示num的值
pin.value(number[num][count])
count+=1
if dp==1:
d_Pins[7].value(0)
def clear():
for i in w_Pins:
i.value(0)
for i in d_Pins:
i.value(1)
def showData(num):
#数值的百位、千位、个位和小数位
d_num=num
location=d_num.find('.')
if location>0:
d_num=d_num.replace('.','')
while len(d_num)<4:
d_num='0'+d_num
for i in range(0,4):
time.sleep(2)
clear()
w_Pins[3-i].value(1)
if i==location-1:
display(d_num[i],1)
else:
display(d_num[i],0)
if location<0:
for i in range(0,4):
time.sleep(2)
clear()
w_Pins[3-i].value(1)
display(d_num[i],0)
while True:
num='9016'
showData(num)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：四位数码管显示数字，并在一个无限循环中重复这些动作。按“Ctrl+C”或单击退出程序。
项目10 8×8点阵屏¶
1.项目介绍：
点阵屏是一种电子数字显示设备，可以显示机器、钟表、公共交通离场指示器和许多其他设备上的信息。在这个项目中，我们将使用ESP32控制8x8点阵屏来逐渐点亮点阵屏上的LED。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | 8×8点阵屏*1 |
|
|
|
| 220Ω电阻*8 | 跳线若干 | USB 线*1 |
3.元件知识：
8×8点阵： 是由64个led灯组成，有行共阳极和行共阴极两种，我们的模块是行共阳极的，也就是每一行有一条线将LED的正极连到一起，列就是将LED灯的负极连接到一起，看下图：
每个LED被放置在一行和一列的交叉点上。当某一行的电平为1，某列的电平为0时，对应的LED会亮起。如果你想点亮第一个点上的LED，你应该将引脚9设置为高电平，引脚13设置为低电平。如果你想点亮第一排的led，你应该把引脚9设置为高电平，把引脚13、3、4、10、6、11、15和16设置为低电平。如果您想点亮第一列的led，将引脚13设置为低电平，将引脚9、14、8、12、1、7、2和5设置为高电平。
8×8点阵屏的外部视图如下所示：
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目10 8×8点阵屏”。然后鼠标左键双击“Project_09_Four_Digit_Digital_Tube.py”。
from machine import Pin
import time
#定义行引脚并设置为输出.
row1 = Pin(14, Pin.OUT)
row2 = Pin(26, Pin.OUT)
row3 = Pin(4, Pin.OUT)
row4 = Pin(27, Pin.OUT)
row5 = Pin(19, Pin.OUT)
row6 = Pin(16, Pin.OUT)
row7 = Pin(18, Pin.OUT)
row8 = Pin(17, Pin.OUT)
#定义列的引脚并设置为输出
col1 = Pin(32, Pin.OUT)
col2 = Pin(21, Pin.OUT)
col3 = Pin(22, Pin.OUT)
col4 = Pin(12, Pin.OUT)
col5 = Pin(0, Pin.OUT)
col6 = Pin(13, Pin.OUT)
col7 = Pin(33, Pin.OUT)
col8 = Pin(25, Pin.OUT)
#将列的引脚设置为低电平
col1.value(0)
col2.value(0)
col3.value(0)
col4.value(0)
col5.value(0)
col6.value(0)
col7.value(0)
col8.value(0)
#由于点阵的列被设置为低电平，因此当该行的引脚处于高电平时，点阵的对应行将亮起
def Row(d):
if(d ==1):
row1.value(1) #点亮第一条线
if(d ==2):
row2.value(1) #点亮第二条线
if(d ==3):
row3.value(1)
if(d ==4):
row4.value(1)
if(d ==5):
row5.value(1)
if(d ==6):
row6.value(1)
if(d ==7):
row7.value(1)
if(d ==8):
row8.value(1)
#关闭格子
def off():
row1.value(0)
row2.value(0)
row3.value(0)
row4.value(0)
row5.value(0)
row6.value(0)
row7.value(0)
row8.value(0)
try:
print("test...")
while True:
for num in range(1,10): #逐行点亮格子
Row(num)
if(num == 9): #因为晶格只有8行，我在这里限定一下，等于9
off() #关闭格子
time.sleep(0.2)
except:
pass
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：8x8点阵屏逐渐点亮。按“Ctrl+C”或单击退出程序。
项目11 74HC595N控制8个LED¶
1.项目介绍：
在之前的项目中，我们已经学过了怎样点亮一个LED。
ESP32上只有32个IO端口，我们如何点亮大量的led呢? 有时可能会耗尽ESP32上的所有引脚，这时候就需要用移位寄存器扩展它。你可以使用74HC595N芯片一次控制8个输出，而只占用你的微控制器上的几个引脚。你还可以将多个寄存器连接在一起，以进一步扩展输出，在这个项目中，我们将使用ESP32，74HC595芯片和LED制作一个流水灯来了解74HC595芯片的功能。
2.项目元件：
|
|
 |
 |
|---|---|---|---|
| ESP32*1 | 面包板*1 | 74HC595N芯片*1 | 红色LED*8 |
|
|
|
|
| 220Ω电阻*8 | 跳线若干 | USB 线*1 |
3.元件知识：
74HC595N芯片： 简单来说就是具有8 位移位寄存器和一个存储器，以及三态输出功能。移位寄存器和存储器同步于不同的时钟，数据在移位寄存器时钟SCK的上升沿输入，在存储寄存器时钟RCK的上升沿进入的存储寄存器中去。如果两个时钟连在一起，则移位寄存器总是比存储寄存器早一个脉冲。移位寄存器有一个串行移位输入端（SI）和一个用于级联的串行输出端（SQH）,8位移位寄存器可以异步复位（低电平复位），存储寄存器有一个8位三态并行的总线输出，当输出使能（OE）被使能（低电平有效）将存储寄存器中输出至74HC595N的引脚（总线）。
引脚说明：
| 引脚： | 引脚说明： |
|---|---|
| 13引脚OE | 是一个输出使能引脚，用于确保锁存器的数据是否输入到Q0-Q7引脚。在低电平时，不输出高电平。在本实验中，我们直接连接GND，保持低电平输出数据。 |
| 14引脚SI/DS | 这是74HC595接收数据的引脚，即串行数据输入端，一次只能输入一位，那么连续输入8次，就可以组成一个字节了。 |
| 10引脚SCLR/MR | 一个初始化存储寄存器管脚的管脚。在低电平时初始化内部存储寄存器。在这个实验中，我们连接VCC以保持高水平。 |
| 11引脚SCK/SH_CP | 移位寄存器的时钟引脚，上升沿时，移位寄存器中的数据整体后移，并接收新的数据输入。 |
| 12引脚RCK/ST_CP | 存储寄存器的时钟输入引脚。上升沿时，数据从移位寄存器转存到存储寄存器中。这时数据就从Q0~Q7端口并行输出。 |
| 9引脚SQH | 引脚是一个串行输出引脚，专门用于芯片级联，接下一个74HC595的SI端。 |
| Q0--Q7(15引脚，1-7引脚) | 八位并行输出端，可以直接控制数码管的8个段。 |
4.项目接线图：
注意：需要注意74HC595N芯片插入的方向。
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目11 74HC595N控制8个LED”。选择“my74HC595.py”，鼠标右键单击选择 “上传到/”，等待“my74HC595.py”被上传到ESP32，然后鼠标左键双击“Project_11_74HC595N_Controls_8_LEDs.py”。
# 导入time和my74HC595库.
from my74HC595 import Chip74HC595
import time
# 创建Chip74HC595对象并配置引脚
chip = Chip74HC595(14, 12, 13)
# ESP32-14: 74HC595-DS(14)
# ESP32-12: 74HC595-STCP(12)
# ESP32-13: 74HC595-SHCP(11)
#第一个for循环使LED从左到右分别点亮
#而第二个for循环使它从右向左分别点亮.
while True:
x = 0x01
for count in range(8):
chip.shiftOut(1, x)
x = x<<1;
time.sleep_ms(300)
x = 0x01
for count in range(8):
chip.shiftOut(0, x)
x = x<<1
time.sleep_ms(300)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：8个LED开始以流水模式闪烁。按“Ctrl+C”或单击退出程序。
项目12 有源蜂鸣器¶
1.项目介绍：
有源蜂鸣器是一个发声组件。它被广泛用作电脑、打印机、报警器、电子玩具、电话、计时器等的发声元件。它有一个内在的振动源，只需连接5V电源，即可持续发出嗡嗡声。在这个项目中，我们将使用ESP32控制有源蜂鸣器发出“滴滴”声。
2.项目元件：
|
|
 |
 |
|---|---|---|---|
| ESP32*1 | 面包板*1 | 有源蜂鸣器*1 | NPN型晶体管(S8050)*1 |
|
|
|
|
| 1KΩ电阻*1 | 跳线若干 | USB线*1 |
3.元件知识：
有源蜂鸣器： 它内部有一个简单的振荡器电路，可以将恒定的直流电转换成特定频率的脉冲信号。一旦有源蜂鸣器收到一个高电平，它将产生声音。而无源蜂鸣器是一种内部没有振动源的集成电子蜂鸣器，它必须由2K-5K方波驱动，而不是直流信号。这两个蜂鸣器的外观非常相似，但是一个带有绿色电路板的蜂鸣器是无源蜂鸣器，而另一个带有黑色胶带的是有源蜂鸣器。无源蜂鸣器不能区分正极性而有源蜂鸣器是可以。如下所示：
晶体管: 由于蜂鸣器需要很大的电流，ESP32输出能力的GPIO不能满足要求，这里需要一个NPN型晶体管来放大电流。晶体管，全称:半导体晶体管，是一种控制电流的半导体器件。晶体管可以用来放大微弱信号，也可以用作开关。它有三个电极(pin)：基极(b)，集电极(c)和发射极(e)。当电流通过“be”之间时，“ce”将允许几倍的电流通过(晶体管放大)，此时，晶体管在放大区工作。当“be”之间的电流超过某个值时，“ce”将不再允许电流增加，此时晶体管工作在饱和区。晶体管有两种类型如下所示：PNP和NPN
在我们的套件中，PNP晶体管标记为8550, NPN晶体管标记为8050。
基于晶体管的特性，它常被用作数字电路中的开关。由于单片机输出电流的能力很弱，我们将使用晶体管来放大电流和驱动大电流的元件。在使用NPN晶体管驱动蜂鸣器时，通常采用以下方法：如果GPIO输出高电平，电流将流过R1，晶体管将传导，蜂鸣器将发出声音。如果GPIO输出低电平，没有电流流过R1，晶体管就不会传导，蜂鸣器也不会响。在使用PNP晶体管驱动蜂鸣器时，通常采用以下方法：如果GPIO输出低电平，电流将流过R1，晶体管将传导，蜂鸣器将发出声音。如果GPIO输出高电平，没有电流流过R1，晶体管就不会传导，蜂鸣器也不会响。
4.项目接线图：
注意：该电路中蜂鸣器的电源为5V。在3.3V的电源下，蜂鸣器可以工作，但会降低响度。
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目12 有源蜂鸣器”。并鼠标左键双击“Project_12_Active_Buzzer.py”。
from machine import Pin
import time
buzzer = Pin(15, Pin.OUT) # 创建引脚15为蜂鸣器对象，设置引脚15为输出
try:
while True:
buzzer.value(1) # 蜂鸣器鸣叫
time.sleep(0.5) # 延时 0.5s
buzzer.value(0) # 蜂鸣器关闭
time.sleep(0.5) # 延时 0.5s
except:
pass
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：有源蜂鸣器发出“滴滴”声。按“Ctrl+C”或单击退出程序。
项目13 无源蜂鸣器¶
1.项目介绍
在之前的项目中，我们研究了有源蜂鸣器，它只能发出一种声音，可能会让你觉得很单调。这个项目将学习另一种蜂鸣器，无源蜂鸣器。与有源蜂鸣器不同，无源蜂鸣器可以发出不同频率的声音。在这个项目中，你将使用ESP32控制无源蜂鸣器工作。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 无源蜂鸣器*1 | NPN型晶体管(S8050)*1 |
|
|
|
|
| 1KΩ电阻*1 | 跳线若干 | USB线*1 |
3.元件知识：
无源蜂鸣器： 它是一种内部没有振动源的集成电子蜂鸣器。它必须由2K-5K方波驱动，而不是直流信号。与有源蜂鸣器的外观非常相似，但是一个带有绿色电路板的蜂鸣器是无源蜂鸣器，而另一个带有黑色胶带的是有源蜂鸣器。无源蜂鸣器不能区分正极性而有源蜂鸣器是可以，如下图：
晶体管: 请参考项目12 。
4.项目接线图:
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目13 无源蜂鸣器”。并鼠标左键双击“Project_13_Passive_Buzzer.py”。
from machine import Pin
import time
# 初始化无源蜂鸣器
buzzer = Pin(15,Pin.OUT)
#模拟两种不同的频率
while True:
#输出500HZ频率声音
for i in range(80):
buzzer.value(1)
time.sleep(0.001)
buzzer.value(0)
time.sleep(0.001)
#输出250HZ频率声音
for i in range(100):
buzzer.value(1)
time.sleep(0.002)
buzzer.value(0)
time.sleep(0.002)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：无源蜂鸣器发出警报声。按“Ctrl+C”或单击退出程序。
项目14 小台灯¶
1.项目介绍：
你知道ESP32可以在你按下外接按键的时候点亮LED吗? 在这个项目中，我们将使用ESP32，一个按键开关和一个LED来制作一个迷你台灯。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | 按键*1 |
 |
 |
 |
| 10KΩ电阻*1 | 红色 LED*1 | 220Ω电阻*1 |
 |
|
|
| 按键帽*1 | 跳线若干 | USB 线*1 |
3.元件知识：
按键： 按键可以控制电路的通断，把按键接入电路中，不按下按键的时候电路是断开的，一按下按键电路就通啦，但是松开之后就又断了。可是为什么按下才通电呢？这得从按键的内部构造说起。没按下之前，电流从按键的一端过不去另一端；按下的时候，按键内部的金属片把两边连接起来让电流通过。
按键内部结构如图：
，未按下按键之前，1、2就是导通的，3、4也是导通的，但是1、3或1、4或2、3或2、4是断开（不通）的；只有按下按键时，1、3或1、4或2、3或2、4才是导通的。
在设计电路时，按键开关是最常用的一种元件。
按键的原理图:
什么是按键抖动？
我们想象的开关电路是“按下按键-立刻导通”“再次按下-立刻断开”，而实际上并非如此。
按键通常采用机械弹性开关，而机械弹性开关在机械触点断开闭合的瞬间（通常 10ms左右），会由于弹性作用产生一系列的抖动，造成按键开关在闭合时不会立刻稳定的接通电路，在断开时也不会瞬时彻底断开。
那又如何消除按键抖动呢？
常用除抖动方法有两种：软件方法和硬件方法。这里重点讲讲方便简单的软件方法。 我们已经知道弹性惯性产生的抖动时间为10ms 左右，用延时命令推迟命令执行的时间就可以达到除抖动的效果。
所以我们在代码中加入了0.02秒的延时以实现按键防抖的功能。
4.项目接线图：
注意:
怎样连接LED
怎样识别五色环220Ω电阻和五色环10KΩ电阻
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目14 小台灯”。并鼠标左键双击“Project_14_Mini_Table_Lamp.py”。
from machine import Pin
import time
led = Pin(4, Pin.OUT) # 创建引脚4为LED对象，设置引脚4为输出
button = Pin(15, Pin.IN, Pin.PULL_UP) #Pin15创建引脚15按钮对象，设置GP15为输入
#定义一个函数并将其命名为reverseGPIO()，用于反转LED的输出电平
def reverseGPIO():
if led.value():
led.value(0) #LED熄灭
else:
led.value(1) #LED点亮
try:
while True:
if not button.value():
time.sleep_ms(20)
if not button.value():
reverseGPIO()
while not button.value():
time.sleep_ms(20)
except:
pass
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：按下按钮，LED亮起；当按钮松开时，LED仍亮着。再次按下按钮，LED熄灭；当按钮释放时，LED保持关闭。是不是很像个小台灯？按“Ctrl+C”或单击退出程序。
项目15 模拟沙漏¶
1.项目介绍：
古代人没有电子时钟，就发明了沙漏来测时间，沙漏两边的容量比较大，在一边装了细沙，中间有个很小的通道，将沙漏直立，有细沙的一边在上方，由于重力的作用，细沙就会往下流通过通道到沙漏的另一边，当细沙都流到下边了，就倒过来，把一天反复的次数记录下来，第二天就可以通过沙漏反复流动的次数而知道这一天大概的时间了。这一课我们将利用ESP32控制倾斜开关和LED灯来模拟沙漏，制作一个电子沙漏。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 倾斜开关*1 | 10KΩ电阻*1 |
|
|
|
|
| 红色 LED*4 | 220Ω电阻*1 | 跳线若干 | USB 线*1 |
3.元件知识：
倾斜开关也叫数字开关或球形开关，里面有一个金属球。它用于检测小角度的倾斜。
原理很简单：当开关倾斜一定角度时，里面的球会向下滚动，接触到连接到外面引脚的两个触点，从而触发电路。否则，球将远离触点，从而断开电路。
这里用倾斜开关的内部结构来说明它是如何工作的，显示如下图：
4.项目接线图：
注意:
怎样连接LED
怎样识别五色环220Ω电阻和五色环10KΩ电阻
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目15 模拟沙漏”。并鼠标左键双击“Project_15_Tilt_And_LED.py”。
from machine import Pin
import time
led1 = Pin(16, Pin.OUT) # 创建引脚2为LED对象，设置引脚2为输出
led2 = Pin(17, Pin.OUT) # 创建引脚17为LED对象，设置引脚17为输出
led3 = Pin(18, Pin.OUT) # 创建引脚18为LED对象，设置引脚18为输出
led4 = Pin(19, Pin.OUT) # 创建引脚19为LED对象，设置引脚19为输出
Tilt_Sensor = Pin(15,Pin.IN) #创建引脚15倾斜传感器对象，设置GP15为输入
while True:
if(Tilt_Sensor.value() == 0) : #如果倾斜传感器的值为0时
led1.value(1) # led1 点亮
time.sleep_ms(200)#延时
led2.value(1) # led2 点亮
time.sleep_ms(200)#延时
led3.value(1) # led3 点亮
time.sleep_ms(200)#延时
led4.value(1) # led4 点亮
time.sleep_ms(200)#延时
else : #如果倾斜传感器的值为1时
led4.value(0) # led4 熄灭
time.sleep_ms(200)#延时
led3.value(0) # led3 熄灭
time.sleep_ms(200)#延时
led2.value(0) # led2 熄灭
time.sleep_ms(200)#延时
led1.value(0) # led1 熄灭
time.sleep_ms(200)#延时
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：将面包板倾斜到一定角度，led就会一个一个地亮起来。当回到上一个角度时，led会一个一个关闭。就像沙漏一样，随着时间的推移，沙子漏了出来。按“Ctrl+C”或单击退出程序。
项目16 防窃警报器¶
1.项目介绍：
人体红外传感器测量运动物体发出的热的红外(IR)线。该传感器可以检测人、动物和汽车的运动，从而触发安全警报和照明。它们被用来检测移动，是安全的理想选择，如防盗警报和安全照明系统。在这个项目中，我们将使用ESP32控制人体红外传感器、蜂鸣器和LED来模拟防盗报警器。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 人体红外传感器*1 | NPN型晶体管(S8050)*1 |
 |
|
|
|
| 有源蜂鸣器*1 | 红色 LED*1 | 220Ω电阻*1 | 1KΩ电阻*1 |
 |
|
|
|
| 3P转杜邦线公单*1 | 跳线若干 | USB 线*1 |
3.元件知识：
人体红外传感器： 是一款基于热释电效应的人体红外传感器，能检测到人体或动物身上发出的红外线，配合菲涅尔透镜能使传感器探测范围更远更广。它主要采用RE200B-P传感器元件，当附近有人或者动物运动时，该模块会输出一个高电平1；否则输出低电平0。特别注意，这个传感器可以检测在运动中的人、动物和汽车，静止中的人、动物和汽车是检测不到的，检测最远距离大约为7米左右。
注意：人体红外传感器应避开日光、汽车头灯、白炽灯直接照射，也不能对着热源(如暖气片、加热器)或空调，以避免环境温度较大的变化而造成误报。同时还易受射频辐射的干扰。
传感器技术参数：
最大输入电压：DC 5-15V
最大工作电流：50MA
最大功率：0.3W
静态电流: <50uA
工作温度：-20 ~ 85℃
控制信号：数字信号(1/0)
延迟时间：大约2.3到3秒钟
感应角度：小于100度锥角
检测最远距离：大约7米左右
传感器原理图：
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目16 防窃警报器”。并鼠标左键双击“Project_16_Burglar_Alarm.py”。
# 导入 Pin and time 库.
from machine import Pin
import time
# 定义人体红外传感器，led和有源蜂鸣器的引脚.
sensor_pir = Pin(15, Pin.IN)
led = Pin(0, Pin.OUT)
buzzer = Pin(2, Pin.OUT)
while True:
if sensor_pir.value():
buzzer.value(1)
led.value(1)
time.sleep(0.2)
buzzer.value(0)
led.value(0)
time.sleep(0.2)
else:
buzzer.value(0)
led.value(0)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：如果人体红外传感器检测到附近有人移动时，蜂鸣器就会不断地发出警报，且LED不断地闪烁。按“Ctrl+C”或单击退出程序。
项目17 I2C 128×32 LCD¶
1.项目介绍：
在生活中，我们可以利用显示器等模块来做各种实验。你也可以DIY各种各样的小物件。例如，用一个温度传感器和显示器做一个温度测试仪，或者用一个超声波模块和显示器做一个距离测试仪。下面，我们将使用LCD_128X32_DOT模块作为显示器，将其连接到ESP32控制板上。将使用ESP32主板控制LCD_128X32_DOT显示屏显示各种英文文字、常用符号和数字。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | LCD_128X32_DOT*1 |
 |
|
|
| 4P转杜邦线公单*1 | USB 线*1 |
3.元件知识：
LCD_128X32_DOT： 一个像素为128*32的液晶屏模块，它的驱动芯片为ST7567A。模块使用IIC通信方式，它不仅可以显示英文字母、符号，还可以显示中文文字和图案。使用时，还可以在代码中设置，让英文字母和符号等显示不同大小。
LCD_128X32_DOT原理图：
LCD_128X32_DOT技术参数：
显示像素：128*32 字符
工作电压：DC 5V
工作电流：100mA (5V)
模块最佳工作电压：5V
亮度、对比度可通过程序指令控制
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目17 I2C 128×32 LCD”。分别选择“lcd128_32.py”和 “lcd128_32_fonts.py”，右键单击鼠标选择 “上传到/”，等待“lcd128_32.py”和 “lcd128_32_fonts.py”被上传到ESP32，并鼠标鼠标左键双击“Project_17_I2C_128_32_LCD.py”。
import machine
import time
import lcd128_32_fonts
from lcd128_32 import lcd128_32
#i2c配置
clock_pin = 22
data_pin = 21
bus = 0
i2c_addr = 0x3f
use_i2c = True
def scan_for_devices():
i2c = machine.I2C(bus,sda=machine.Pin(data_pin),scl=machine.Pin(clock_pin))
devices = i2c.scan()
if devices:
for d in devices:
print(hex(d))
else:
print('no i2c devices')
if use_i2c:
scan_for_devices()
lcd = lcd128_32(data_pin, clock_pin, bus, i2c_addr)
lcd.Clear()
lcd.Cursor(0, 4)
lcd.Display("KEYESTUDIO")
lcd.Cursor(1, 0)
lcd.Display("ABCDEFGHIJKLMNOPQR")
lcd.Cursor(2, 0)
lcd.Display("123456789+-*/<>=$@")
lcd.Cursor(3, 0)
lcd.Display("%^&(){}:;'|?,.~\\[]")
"""
while True:
scan_for_devices()
time.sleep(0.5)
"""
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：128X32LCD模块显示屏第一行显示“KEYESTUDIO”、第二行显示“ABCDEFGHIJKLMNOPQR”、第三行显示“123456789+-*/<>=$@”、第四行显示“%^&(){}:;'|?,.~\[]”。按“Ctrl+C”或单击退出程序。
项目18 小风扇¶
1.项目介绍：
在炎热的夏季，需要电扇来给我们降温，那么在这个项目中，我们将使用ESP32控制直流电机和小扇叶来制作一个小电扇。
2.项目元件：
|
|
 |
 |
 |
|---|---|---|---|---|
| ESP32*1 | 面包板*1 | 直流电机*1 | 面包板专用电源模块*1 | 6节5号电池盒*1 |
 |
 |
|
 |
|
| IC L293D*1 | 风扇叶*1 | 跳线若干 | 5号电池(自备)*6 | USB 线*1 |
3.元件知识:
L293D芯片：L293D是一种直流电动驱动IC，在一些机器人项目中可用来驱动直流电机或步进电机。它共有16个引脚，可以同时驱动两路直流电机。输入电压范围：4.5 V ~ 36 V，每通道输出电流：MAX 600mA，可以驱动感性负载，特别是其输入端可以与主控板直接相连，从而很方便地受主控板控制。当驱动小型直流电机时，可以直接控制两路电机，并且可以实现电机正转与反转，实现此功能只需改变输入端的高低电平。市面上有许多采用L293D芯片的电机驱动板，当然我们也可以自己通过简单连接来使用它。
L293D引脚图：
| 引脚号 | 引脚名称 | 描述 |
|---|---|---|
| 1 | Enable1 | 该引脚使能输入引脚Input 1(2)和Input 2(7) |
| 2 | In1 | 直接控制输出1引脚，由数字电路控制 |
| 3 | Out1 | 连接到电机1的一端 |
| 4 | 0V | 接地引脚连接到电路的接地(0V) |
| 5 | 0V | 接地引脚连接到电路的接地(0V) |
| 6 | Out2 | 连接到电机1的另一端 |
| 7 | In2 | 直接控制输出2引脚。由数字电路控制 |
| 8 | +V motor | 连接到运行电机的电压引脚(4.5V至36V) |
| 9 | Enable2 | 该引脚使能输入引脚输入3(10)和输入4(15) |
| 10 | In3 | 直接控制输出3引脚。由数字电路控制 |
| 11 | Out3 | 连接到电机2的一端 |
| 12 | 0V | 接地引脚连接到电路的接地(0V) |
| 13 | 0V | 接地引脚连接到电路的接地(0V) |
| 14 | Out4 | 连接到电机2的另一端 |
| 15 | In4 | 直接控制输出4引脚，由数字电路控制 |
| 16 | +V | 连接到+ 5V以启用IC功能 |
面包板专用电源模块：
说明：
此模块，能方便的给面包板提供3.3V和5V的电源，具有DC2.1输入（DC7－12V），另外，具备USB Type C接口的电源输入。
规格：
输入电压：DC座：7-12V； Type C USB：5V
电流：3.3V：最大500mA； 5V：最大500mA；
最大功率: 2.5W
尺寸: 53mmx26.3mm
环保属性: ROHS
接口说明：
原理图：
4.项目接线图：
(注: 先接好线，然后在直流电机上安装一个小风扇叶片。)
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目18 小风扇”。并鼠标左键双击“Project_18_ Small_Fan.py”。
from machine import Pin,PWM
import time
#L293D对应引脚，设为输出
IN1_Pin = 2
IN2_Pin = 15
ENA_Pin = 0 #控制电机的速度
# speed：速度为0 - 100
# direction:旋转方向，1为顺时针，0为停止，-1为逆时针
# speed_pin:控制电机启动和停止的引脚编号
def motorRun(speed, direction, speed_pin, clockwise_pin, anti_clockwise_pin):
if speed > 100: speed=100
if speed < 0: speed=0
in1 = Pin(anti_clockwise_pin, Pin.OUT)
in2 = Pin(clockwise_pin, Pin.OUT)
pwm = PWM(Pin(speed_pin))
pwm.freq(50)
pwm.duty(int(speed/100*4096))
if direction < 0:
in2.value(0)
in1.value(1)
if direction == 0:
in2.value(0)
in1.value(0)
if direction > 0:
in2.value(1)
in1.value(0)
while True:
motorRun(100, 1, ENA_Pin, IN2_Pin, IN1_Pin)
time.sleep(5)
motorRun(100, 0, ENA_Pin, IN2_Pin, IN1_Pin)
time.sleep(2)
motorRun(100, -1, ENA_Pin, IN2_Pin, IN1_Pin)
time.sleep(5)
motorRun(100, 0, ENA_Pin, IN2_Pin, IN1_Pin)
time.sleep(2)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：小风扇先逆时针转5秒，停止2秒，再顺时针转5秒，停止2秒，以此规律重复执行。按“Ctrl+C”或单击退出程序。
项目19 舵机¶
1.项目介绍：
舵机是一种可以非常精确地旋转的电机。目前已广泛应用于玩具车、遥控直升机、飞机、机器人等领域。在这个项目中，我们将使用ESP32控制舵机转动。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | 舵机*1 |
 |
|
|
| 跳线若干 | USB 线*1 |
3.元件知识：
舵机： 舵机是一种位置伺服的驱动器，主要是由外壳、电路板、无核心马达、齿轮与位置检测器所构成。其工作原理是由接收机或者单片机发出信号给舵机，其内部有一个基准电路，产生周期为20ms，宽度为1.5ms 的基准信号，将获得的直流偏置电压与电位器的电压比较，获得电压差输出。经由电路板上的IC 判断转动方向，再驱动无核心马达开始转动，透过减速齿轮将动力传至摆臂，同时由位置检测器送回信号，判断是否已经到达定位。适用于那些需要角度不断变化并可以保持的控制系统。当电机转速一定时，通过级联减速齿轮带动电位器旋转，使得电压差为0，电机停止转动。一般舵机旋转的角度范围是0度到180 度。
控制舵机的脉冲周期为20ms，脉冲宽度为0.5ms ~ 2.5ms，对应位置为-90°~ +90°。下面是以一个180°角的舵机为例：
舵机有多种规格，但它们都有三根连接线，分别是棕色、红色、橙色(不同品牌可能有不同的颜色)。棕色为GND，红色为电源正极，橙色为信号线。
4.项目接线图：
舵机供电时请注意，电源电压应为3.3V-5V。请确保在将舵机连接到电源时不会出现任何错误。
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目19 舵机”。并鼠标左键双击“Project_19_Servo_Sweep.py”。
from machine import Pin, PWM
import time
p2 = PWM(Pin(15)) # 从引脚15创建PWM对象
p2.freq(50) # 设置PWM频率从1Hz到40MHz
p2.duty(256) # 将占空比从0到1023设置为占空比/1023，(现在是25%)
# 0度 P2.duty_u16(1638) #设置占空比从0到65535作为duty_u16/65535的比值
# 90度 p2.duty_u16(4915)
# 180度 p2.duty_u16(8192)
p2.duty_u16(1638) # 0度
time.sleep(1)
p2.duty_u16(4915) # 90度
time.sleep(1)
p2.duty_u16(8100) # 180度 # 真实舵机MG90S可以设为8192
time.sleep(1)
for i in range(1638, 8100, 10):
p2.duty_u16(i)
time.sleep_ms(10)
p2.duty_u16(1638)
time.sleep(1)
p2.deinit() # 在引脚上关闭PWM
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：舵机将转动。按“Ctrl+C”或单击退出程序。
项目20 步进电机¶
1.项目介绍：
步进电机定位准确，是工业机器人、3D打印机、大型车床等机械设备中最重要的部件。在这个项目中，我们将使用ESP32控制ULN2003步进电机驱动板来驱动步进电机转动。
2.项目元件：
|
|
 |
|---|---|---|
| ESP32*1 | 面包板*1 | ULN2003步进电机驱动板*1 |
|
|
 |
| 面包板专用电源模块*1 | 6节5号电池盒*1 | 步进电机*1 |
 |
|
|
| 公对母杜邦线若干 | 5号电池(自备)*6 | USB 线*1 |
3.项目知识：
步进电机： 是由一系列电磁线圈控制的电机。它可以根据需要旋转精确的度数(或步数)，允许你将它移动到一个精确的位置并保持该位置。它是通过在很短的时间内为电机内部的线圈供电来做到这一点的，但你必须一直为电机供电，以保持它在你想要的位置。有两种基本类型的步进电机，单极步进和双极步进。在本项目中，我们使用的是单极步进电机28-BYJ48。
28BYJ-48步进电机工作原理：
步进电机主要由定子和转子组成，定子是固定不动的，如下图绕着A、B、C、D线圈组的部分，线圈组导通电就会产生磁场；转子就是转动的部分，如下图定子中间的部分，两极是永磁铁。
单步4节拍的转动原理：开始A组线圈导通，转子两极正对着A组线圈；接着A组线圈断开，B组线圈导通，转子就会顺时针转到B组线圈，转子转了一步；B断开，C导通，转子转到C组；C断开，D导通，转子转到D组；D组断开，A组导通，转子转到A组线圈。这样转子就转了半圈180度，接着再重复一次，B-C-D-A，转子转回到A组线圈，这样转子就转了一圈，总共转动了8步。如下图所示，这就是步进电机单节拍转动的原理A - B - C - D - A ....。
如果想让步进电机逆时针转动，那只要把节拍顺序反过来就行，D - C - B - A - D .....。
半步8节拍转动原理：8节拍，采用的是单双拍的形式，A - AB - B - BC - C - CD - D - DA - A ...... ，这样运转一拍，转子只会转动半步，例如，A组线圈导通，转子转到正对着A组线圈；接着A和B组一起导通，这样产生的磁场最强的地方在AB组线圈中间，转子两极就会转到AB组线圈中间，也就是顺时针转了半步。
步进电机参数：
我们所提供的步进电机需要转动32步，转子才能转一圈，还经过了1:64的减速齿轮组带动输出轴，这样输出轴转动一圈需要：32 * 64 = 2048 步。
电压5V，4相步进电机 ，4节拍模式的步进角为11.25， 8节拍模式步进角为5.625， 减速比为1:64。
ULN2003步进电机驱动板： ULN2003型步进电机驱动器，将微弱信号转换为更强的控制信号，从而驱动步进电机。
下面的原理图显示了如何使用ULN2003步进电机驱动板接口将一个单极步进电机接到ESP32的引脚上，并显示了如何使用四个TIP120的接口。
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目20 步进电机”。并鼠标左键双击“Project_20_Stepping_Motor.py”。
from machine import Pin
import time
# 引脚初始化
in1 = Pin(15, Pin.OUT)
in2 = Pin(16, Pin.OUT)
in3 = Pin(17, Pin.OUT)
in4 = Pin(18, Pin.OUT)
# 延时
delay = 1
# 电机旋转一圈所需的步数，(约360°)，会有轻微偏差.
ROUND_VALUE = 509
# 四相八拍步进电机顺序值:A-AB-B-BC-C-CD-D-DA-A.
STEP_VALUE = [
[1, 0, 0, 0],
[1, 1, 0, 0],
[0, 1, 0, 0],
[0, 1, 1, 0],
[0, 0, 1, 0],
[0, 0, 1, 1],
[0, 0, 0, 1],
[1, 0, 0, 1],
]
# 引脚输出电平低
def reset():
in1(0)
in2(0)
in3(0)
in4(0)
# 如果count是正整数，则顺时针旋转，如果count是负整数，则逆时针旋转
def step_run(count):
direction = 1 # 顺时针转
if count < 0:
direction = -1 # 逆时针旋转
count = -count
for x in range(count):
for bit in STEP_VALUE[::direction]:
in1(bit[0])
in2(bit[1])
in3(bit[2])
in4(bit[3])
time.sleep_ms(delay)
reset()
# 如果a是正整数，则顺时针旋转，如果a是负整数，则逆时针旋转
def step_angle(a):
step_run(int(ROUND_VALUE * a / 360))
# 循环:顺时针转一圈，再逆时针转一圈.
while True:
step_run(509)
step_run(-509)
step_angle(360)
step_angle(-360)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：ULN2003驱动模块上的D1,D2,D3,D4四个LED点亮，步进电机先逆时针旋转，再顺时针旋转，并保持此状态循环。按“Ctrl+C”或单击退出程序。
项目21 继电器¶
1.项目介绍：
在日常生活中，我们一般使用交流来驱动电气设备，有时我们会用开关来控制电器。如果将开关直接连接到交流电路上，一旦发生漏电，人就有危险。从安全的角度考虑，我们特别设计了这款具有NO(常开)端和NC(常闭)端的继电器模块。在这节课我们将学习一个比较特殊，好用的开关，就是继电器模块。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 继电器模块*1 | 红色LED*1 |
|
|
|
|
| 3P转杜邦线公单*1 | USB 线*1 | 220Ω电阻*1 | 跳线若干 |
3.元件知识：
继电器： 它主要采用HK4100F-DC 5V-SHC继电器元件。继电器有3个接线柱用于外接电路，分别为NO、COM和NC端（背后丝印）。
常开（NO）：该引脚是常开的，除非向继电器模块的信号引脚提供信号，因此，普通接触针通过NC脚断开其连接，通过NO脚建立连接。
公共触点（COM）：此引脚用来连接其他模块/元器件，如LED。
LED：
常闭（NC）：此NC引脚通过COM引脚连接，形成闭合电路，可以通过ESP32等开发板，控制继电器模块，来切换闭合或断开。
当继电器没有接控制信号时，COM端和NC端连通，COM端和NO端断开。 控制时，把G接控制板的GND，V接控制板的5V，S接控制板的数字口。当S信号端设置为高电平时，继电器开启，继电器COM端和NC端断开，COM端和NO端连通；S信号端设置为低电平时，继电器关闭，继电器COM端和NC端连通，COM端和NO端断开。
- 工作电压：5V（DC）
- 工作电流：≤50MA
- 最大功率：0.25W
- 输入信号：数字信号
- 触点电流：<3A
继电器原理图：
4.项目接线图：
5.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目21 继电器”。并鼠标左键双击“Project_21_Relay.py”。
from machine import Pin
import time
# 创建引脚15为继电器对象，将引脚15设置为输出
relay = Pin(15, Pin.OUT)
# 继电器打开，继电器COM和NO连接，COM和NC断开.
def relay_on():
relay(1)
# 继电器闭合，继电器COM和NO断开，COM和NC接通.
def relay_off():
relay(0)
# 循环，继电器开一秒，关一秒
while True:
relay_on()
time.sleep(1)
relay_off()
time.sleep(1)
6.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：继电器将循环开与关，开启1秒LED点亮1秒，关闭1秒LED熄灭1秒。同时可以听到继电器开与关的声音，还可以看到继电器上的指示灯指示状态的变化。按“Ctrl+C”或单击退出程序。
项目22 调光灯¶
1.项目介绍：
电位器是一个带有滑动或旋转触点的三端电阻器，它形成一个可调的分压器。它的工作原理是在均匀电阻上改变滑动触点的位置。在电位器中，整个输入电压被施加到电阻的整个长度上，输出电压是固定触点和滑动触点之间的电压值。在这个项目中，我们将学习使用ESP32读取电位器的值，并结合LED制作一个调光灯。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 可调电位器*1 | 红色 LED*1 |
|
|
 |
|
| 220Ω电阻*1 | USB 线*1 | 跳线若干 |
3.元件知识：
可调电位器： 可调电位器是电阻和模拟电子元件的一种，具有0和1两种状态(高电平和低电平)。模拟值不同，其数据状态呈现为1 ~ 1024等线性状态。
ADC： ADC是一种电子集成电路，用于将模拟信号(如电压)转换为由1和0组成的数字或二进制形式。我们在ESP32上的ADC的范围是12位，这意味着分辨率是2^12=4096，它表示一个范围(3.3V)将被平均划分为4096份，模拟值的范围对应于ADC值。因此，ADC拥有的比特越多，模拟的分区就越密集，最终转换的精度也就越高。
分节1: 0V—(3.3/4095)V 范围内的模拟量对应数字0;
分节2: (3.3/4095)V—2*(3.3/4095)V 范围内的模拟量对应于数字1;
......
下面的模拟将被相应地划分。换算公式如下：
DAC： 这一过程的可逆需要DAC，数字到模拟转换器。数字I/O端口可以输出高电平和低电平(0或1)，但不能输出中间电压值，这就是DAC有用的地方。ESP32有两个8位精度的DAC输出引脚GPIO25和GPIO26，可以将VCC(这里是3.3V)分成2^8=256个部分。例如，当数字量为1时，输出电压值为3.3/256×1V，当数字量为128时，输出电压值为3.3/256 ×128=1.65V, DAC的精度越高，输出电压值的精度就越高。
换算公式如下：
ESP32主板上的ADC：
ESP32有16个引脚，可以用来测量模拟信号。GPIO引脚序列号和模拟引脚定义如下表所示：
ESP32主板上的DAC：
4.读取电位器的ADC值，DAC值和电压值：
我们将电位器连接到ESP32的模拟IO口上来读取电位器的ADC值，DAC值和电压值。接线请参照以下接线图：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目22 调光灯”。并鼠标左键双击“Project_22.1_Read_Potentiometer_Analog_Value.py”。
# 导入 Pin, ADC 和DAC 库.
from machine import ADC,Pin,DAC
import time
# 打开并配置0-3.3V的ADC
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
#每0.1秒读取一次ADC值，将ADC值转换为DAC值并输出，
#并将这些数据打印到“Shell”.
try:
while True:
adcVal=adc.read()
dacVal=adcVal//16
voltage = adcVal / 4095.0 * 3.3
print("ADC Val:",adcVal,"DACVal:",dacVal,"Voltage:",voltage,"V")
time.sleep(0.1)
except:
pass
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：Thonny IDE下的“Shell”窗口将打印出电位器的ADC值，DAC值和电压值，转动电位器手柄时，ADC值，DAC值和电压值发生变化。按“Ctrl+C”或单击退出程序。
5.调光灯的接线图：
在前面一步，我们读取了电位器的ADC值，DAC值和电压值，现在我们需要将电位器的ADC值转换成LED的亮度，来做成一个亮度可调的灯。见如下所示接线图：
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目22 调光灯”。并鼠标左键双击“Project_22.2_Dimming_Light.py”。
from machine import Pin,PWM,ADC
import time
pwm =PWM(Pin(15,Pin.OUT),1000)
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
try:
while True:
adcValue=adc.read()
pwm.duty(adcValue)
print(adc.read())
time.sleep_ms(100)
except:
pwm.deinit()
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：转动电位器手柄，LED的亮度会相应地改变。按“Ctrl+C”或单击退出程序。
项目23 火焰警报器¶
1.项目介绍：
火灾是一种可怕的灾害，火灾报警系统在房屋，商业建筑和工厂中是非常有用的。在本项目中，我们将使用ESP32控制火焰传感器，蜂鸣器和LED来模拟火灾报警装置。这是一个有意义的创客活动。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 火焰传感器*1 | 红色 LED*1 |
|
|
 |
|
| 有源蜂鸣器*1 | 220Ω电阻*1 | 10KΩ电阻*1 | 跳线若干 |
|
 |
 |
|
| NPN型晶体管(S8050)*1 | 1kΩ 电阻*1 | USB 线*1 |
3.元件知识：
火焰传感器（红外接收三极管）： 火焰会发出一定程度的IR光，这种光人眼是看不到的，但我们的红外接收三极管可以检测到它，并提醒微控制器（如ESP32）已经检测到火灾。红外接收三极管可以探测火焰，然后将火焰亮度转换为波动水平信号。红外接收三极管的短引脚是负极，另一个长引脚是正极。我们应该连接短引脚（负极)到5V，连接长引脚(正极)到模拟引脚，一个电阻和GND。如下图所示：
注意：火焰传感器应避开日光、汽车头灯、白炽灯直接照射，也不能对着热源(如暖气片、加热器)或空调，以避免环境温度较大的变化而造成误报。同时还易受射频辐射的干扰。
4.读取火焰传感器的ADC值，DAC值和电压值：
我们首先用一个简单的代码来读取火焰传感器的ADC值，DAC值和电压值并打印出来。接线请参照以下接线图：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目23 火焰警报器”。并鼠标左键双击“Project_23.1_Read_Analog_Value_Of_Flame_Sensor.py”。
# 导入 Pin, ADC and DAC 库.
from machine import ADC,Pin,DAC
import time
# 打开并配置0-3.3V的ADC
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
# 每0.1秒读取一次ADC值，将ADC值转换为DAC值并输出，
# 并将这些数据打印到“Shell”.
try:
while True:
adcVal=adc.read()
dacVal=adcVal//16
voltage = adcVal / 4095.0 * 3.3
print("ADC Val:",adcVal,"DACVal:",dacVal,"Voltage:",voltage,"V")
time.sleep(0.1)
except:
pass
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将打印火焰传感器读取的ADC值，DAC值和电压值，当火焰靠近火焰传感器时，ADC值，DAC值和电压值增大；反之，ADC值，DAC值和电压值减小。按“Ctrl+C”或单击退出程序。
5.火焰报警的接线图：
接下来，我们将使用火焰传感器和蜂鸣器、LED制作一个有趣的项目——火灾报警装置。当火焰传感器检测到火焰时，LED闪烁，蜂鸣器报警。
6.项目代码：
（注意：代码中的阀值500可以根据实际情况自己重新设置）
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目23 火焰警报器”。并鼠标左键双击“Project_23.2_Flame_Alarm.py”。
from machine import ADC, Pin
import time
# 打开并配置0-3.3V的ADC
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
# 创建引脚15为LED对象，设置引脚15为输出
led = Pin(15, Pin.OUT)
# 创建引脚4为蜂鸣器对象，设置引脚4为输出
buzzer = Pin(4, Pin.OUT)
# 如果火焰传感器检测到火焰，蜂鸣器将发出蜂鸣声
#，当模拟值大于500时，LED闪烁
# 否则，蜂鸣器不响，LED熄灭
while True:
adcVal=adc.read()
if adcVal >500:
buzzer.value(1) # 蜂鸣器鸣叫
led.value(1) # LED点亮
time.sleep(0.5) # 延时 0.5s
buzzer.value(0) # 蜂鸣器关闭
led.value(0)
time.sleep(0.5) # 延时 0.5s
else:
buzzer.value(0) # 蜂鸣器关闭
led.value(0) # LED熄灭
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：当火焰传感器检测到火焰时，LED闪烁，蜂鸣器报警；否则，LED不亮，蜂鸣器不响。按“Ctrl+C”或单击退出程序。
项目24 小夜灯¶
1.项目介绍：
传感器或元件在我们的日常生活中是无处不在的。例如，一些公共路灯在晚上会自动亮起，而在白天会自动熄灭。为什么呢? 事实上，这些都是利用了一种光敏元件，可以感应外部环境光强度的元件。晚上，当室外亮度降低时，路灯会自动打开；到了白天，路灯会自动关闭。这其中的原理是很简单的，在本实验中我们使用ESP32控制LED就来实现这个路灯的效果。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 光敏电阻*1 | 红色 LED*1 |
|
|
|
|
| 220Ω电阻*1 | 10KΩ电阻*1 | 跳线若干 | USB 线*1 |
3.元件知识：
光敏电阻：是一种感光电阻，其原理是光敏电阻表面上接收亮度(光)降低电阻，光敏电阻的电阻值会随着被探测到的环境光的强弱而变化。有了这个特性，我们可以使用光敏电阻来检测光强。光敏电阻及其电子符号如下：
下面的电路是用来检测光敏电阻电阻值的变化：
在上述电路中，当光敏电阻的电阻因光强的变化而改变时，光敏电阻与电阻R2之间的电压也会发生变化。因此，通过测量这个电压就可以得到光的强度。本项目是采用上图左边的电路来接线的。
4.读取光敏电阻的ADC值，DAC值和电压值：
我们首先用一个简单的代码来读取光敏电阻的ADC值，DAC值和电压值并打印出来。接线请参照以下接线图：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目24 小夜灯”。并鼠标左键双击“Project_24.1_Read_Photosensitive_Analog_Value.py”。
# 导入 Pin, ADC 和 DAC 库.
from machine import ADC,Pin,DAC
import time
# 打开并配置0-3.3V的ADC
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
#每0.1秒读取一次ADC值，将ADC值转换为DAC值并输出，
#并将这些数据打印到“Shell”.
try:
while True:
adcVal=adc.read()
dacVal=adcVal//16
voltage = adcVal / 4095.0 * 3.3
print("ADC Val:",adcVal,"DACVal:",dacVal,"Voltage:",voltage,"V")
time.sleep(0.1)
except:
pass
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将打印光敏电阻读取的ADC值，DAC值和电压值，当逐渐减弱光敏电阻所处环境中的光线强度时，ADC值，DAC值和电压值逐渐增大；反之，ADC值，DAC值和电压值逐渐减小。按“Ctrl+C”或单击退出程序。
5.光控灯的接线图：
我们在前面做了一个小小的调光灯，现在我们来做一个光控灯。它们的原理是相同的，即通过ESP32获取传感器的模拟值，然后调节LED的亮度。
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目24 小夜灯”。并鼠标左键双击“Project_24.2_Night_Lamp.py”。
from machine import Pin,PWM,ADC
import time
pwm =PWM(Pin(15,Pin.OUT),1000)
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
try:
while True:
adcValue=adc.read()
pwm.duty(adcValue)
print(adc.read())
time.sleep_ms(100)
except:
pwm.deinit()
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：当减弱光敏电阻所处环境中的光线强度时，LED变亮，反之，LED变暗。按“Ctrl+C”或单击退出程序。
项目25 人体感应灯¶
1.项目介绍：
人体感应灯一般都用在黑漆漆的楼道区域，随着科技的发展，人体感应灯的使用在我们现实生活中十分常见。小区的楼道，房间的卧室、地下城的车库、卫生间等区域都会用到人体感应灯。现实生活中的人体感应灯一般是由人体红外传感器、灯、光敏电阻传感器等组成的。 在本项目中，我们将学习如何利用人体红外传感器、LED、光敏电阻来制作一款人体感应灯。
2.项目元件：
|
|
|
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 光敏电阻*1 | 红色 LED*1 |
|
|
|
|
| 220Ω电阻*1 | 10KΩ电阻*1 | 跳线若干 | USB 线*1 |
|
|
||
| 人体红外传感器*1 | 3P转杜邦线公单*1 |
3.项目接线图：
4.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目25 人体感应灯”。并鼠标左键双击“Project_25_Human_Induction_Lamp.py”。
from machine import Pin, ADC
import time
# 人体红外传感器引脚
human = Pin(15, Pin.IN)
# 初始化光敏光传感器引脚到GP36 (ADC函数)
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
#创建引脚4为LED对象，设置引脚4为输出
led = Pin(4, Pin.OUT)
def detect_someone():
if human.value() == 1:
return True
return False
abc = 0
while True:
adcVal=adc.read()
if adcVal >= 500:
if detect_someone() == True:
abc += 1
led.value(1)
print("value=", abc)
time.sleep(1)
else:
if abc != 0:
abc = 0
led.value(0)
else:
led.value(0)
time.sleep(0.1)
5.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：当你的手覆盖光敏电阻的感光部分来模拟黑暗状态时，然后用另一只手在人体红外传感器前面晃动，LED也点亮，而且延时几秒钟后LED会自动关闭，同时Thonny IDE下的”Shell”窗口将打印LED点亮的延时时间。如果光敏电阻的感光部分没有被覆盖，这时候用手在人体红外传感器前面晃动，LED处于熄灭状态。按“Ctrl+C”或单击退出程序。
项目26 摇杆控制RGB灯¶
1.项目介绍：
摇杆模块是一个有两个模拟输入和一个数字输入的组件。广泛应用于游戏操作、机器人控制、无人机控制等领域。在这个项目中，我们使用ESP32和摇杆模块控制RGB。这样，你可以在实践中对摇杆模块的原理和操作有更深入的了解。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 摇杆模块*1 | RGB LED*1 |
|
|
|
 |
| 220Ω电阻*3 | 跳线若干 | USB 线*1 | 5P转杜邦线公单*1 |
3.元件知识：
摇杆模块： 主要是采用PS2手柄摇杆元件，实际上摇杆模块有3个信号端引脚，模拟3维空间，摇杆模块的引脚分别是GND、VCC、信号端（B、X、Y），其中信号端X、Y模拟空间的X轴和Y轴，控制时，模块的X、Y信号端是连接控制板模拟口，通过控制2个模拟输入值来控制物体在空间X、Y轴的坐标。信号端B模拟空间Z轴，它一般是接数字口，做按键使用。
VCC接控制板的电源输出端V/VCC（3.3/5V），GND接控制板的G/GND，原始状态下读出电压大约为1.65V/2.5V左右，对于X轴方向，当随箭头方向逐渐移动，读出电压值随着增加，且可以达到最大电压；随箭头相反方向逐渐移动，读出电压值逐渐减少，减少到最小电压。对于Y轴方向，当沿着模块上的箭头方向逐渐按下，读出电压值随着增加，且可以达到最大电压；随箭头相反方向逐渐按下，读出电压值逐渐减少，减少到最小电压。对于Z轴方向，信号端B接数字口，原始状态下输出0，按下输出1。这样，我们可以读取两个模拟值和一个数字口的高低电平情况，来判断模块上摇杆的工作状态。
模块参数： - 输入电压：DC 3.3V ~ 5V - 输出信号：X/Y双轴模拟值+Z轴数字信号 - 适用范围：适用于控制点坐标在平面内的运动，双自由度舵机的控制等。 - 产品特点：外观精美，摇杆手感优越，操作简单，反应灵敏，使用寿命长。
4.读取摇杆模块的值：
我们必须使用ESP32的模拟IO口从摇杆模块的X/Y引脚读取值，并使用数字IO口读取按钮的数字信号。请按照下面的接线图进行接线：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目26 摇杆控制RGB灯”。并鼠标左键双击“Project_26.1_Read_Rocker_Value.py”。
from machine import Pin, ADC
import time
# 初始化摇杆模块(ADC函数)
rocker_x=ADC(Pin(36))
rocker_y=ADC(Pin(39))
button_z=Pin(14,Pin.IN,Pin.PULL_UP)
# 将两个ADC通道的电压采集范围设置为0-3.3V，
#，数据采集宽度为0-4095.
rocker_x.atten(ADC.ATTN_11DB)
rocker_y.atten(ADC.ATTN_11DB)
rocker_x.width(ADC.WIDTH_12BIT)
rocker_y.width(ADC.WIDTH_12BIT)
# 在代码中，将Z_Pin配置为上拉输入模式。
# 在loop()中，使用Read()读取X轴和Y轴的值
# 和使用value()来读取Z轴的值，然后显示它们.
while True:
print("X,Y,Z:",rocker_x.read(),",",rocker_y.read(),",",button_z.value())
time.sleep(0.5)
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将打印当前摇杆的模拟值和数字值，移动摇杆或按下摇杆帽将改变”Shell”中的模拟值和数字值。按“Ctrl+C”或单击退出程序。
5.摇杆模块控制RGB的接线图：
我们刚读了摇杆模块的值，这里我们需要用摇杆模块和RGB做一些事情，按照下图连接：
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目26 摇杆控制RGB灯”。并鼠标左键双击“Project_26.2_Rocker_Control_Light.py”。
from machine import Pin, ADC,PWM
import time
#设置RGB的接口和频率
rgb_r = PWM(Pin(4))
rgb_g = PWM(Pin(0))
rgb_b = PWM(Pin(2))
rgb_b.freq(1000)
rgb_r.freq(1000)
rgb_g.freq(1000)
#Set rocker pin
rocker_x=ADC(Pin(36))
rocker_y=ADC(Pin(39))
# 将两个ADC通道的电压采集范围设置为0-3.3V，
# 数据采集宽度为0-4095.
rocker_x.atten(ADC.ATTN_11DB)
rocker_y.atten(ADC.ATTN_11DB)
rocker_x.width(ADC.WIDTH_12BIT)
rocker_y.width(ADC.WIDTH_12BIT)
while True:
y = rocker_y.read()#得到摇杆模块的Y值
x = rocker_x.read()#得到摇杆模块的X值
if x < 1000: #左
rgb_b.duty(0)
rgb_r.duty(1023)
rgb_g.duty(0)
elif x > 3000: #右
rgb_b.duty(0)
rgb_r.duty(0)
rgb_g.duty(1023)
elif y < 1000: #下
rgb_b.duty(1023)
rgb_r.duty(0)
rgb_g.duty(0)
elif y > 3000: #上
rgb_b.duty(1023)
rgb_r.duty(1023)
rgb_g.duty(1023)
time.sleep(0.01)
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：①如果摇杆在X方向上移动到最左边，RGB光变成红色; ②如果摇杆在X方向上移动到最右边，RGB光变为绿色; ③如果摇杆在Y方向上移动到最上面，RGB光变成白色; ④如果摇杆在Y方向上移动到最下面，RGB光变成蓝色。按“Ctrl+C”或单击退出程序。
项目27 温湿度表¶
1.项目介绍：
在冬季时，空气中的湿度很低，就是空气很干燥，再加上寒冷，人体的皮肤就容易过于干燥而裂，所以需要在用加湿器给家里的空气增加湿度，但是怎么知道空气过于干燥了呢？那就需要检测空气湿度的设备，这节课就来学习温湿度传感器的使用。我们使用温湿度传感器制作一个温湿度计，并且还结合LCD 128X32 DOT来显示温度和湿度值。
2.项目元件：
|
|
|
 |
|---|---|---|---|
| ESP32*1 | 面包板*1 | LCD_128X32_DOT*1 | 温湿度传感器*1 |
|
|
|
|
| 3P转杜邦线公单*1 | 4P转杜邦线公单*1 | USB 线*1 |
3.元件知识：
温湿度传感器： 是一款含有已校准数字信号输出的温湿度复合传感器，其精度湿度±5%RH， 温度±2℃，量程湿度20-90%RH， 温度0~50℃。温湿度传感器应用专用的数字模块采集技术和温湿度传感技术，确保产品具有极高的可靠性和卓越的长期稳定性。温湿度传感器包括一个电阻式感湿元件和一个NTC测温元件，非常适用于对精度和实时性要求不高的温湿度测量场合。 工作电压在3.3V-5.5V范围内。
温湿度传感器有三个引脚，分别为VCC，GND和S。S为数据输出的引脚。使用的是串行通讯。
温湿度传感器的单总线格式定义：
| 名称 | 单总线格式定义 |
|---|---|
| 起始信号 | 微处理器把数据总线(SDA)拉低一段时间至少 18ms(最大不得超过 30ms)，通知传感器准备数据。 |
| 响应信号 | 传感器把数据总线（SDA）拉低 83µs，再接高 87µs 以响应主机的起始信号。 |
| 湿度 | 湿度高位为湿度整数部分数据，湿度低位为湿度小数部分数据 |
| 温度 | 温度高位为温度整数部分数据，温度低位为温度小数部分数据，且温度低位 Bit8 为 1 则表示负温度，否则为正温度 |
| 校验位 | 校验位＝湿度高位+湿度低位+温度高位+温度低位 |
温湿度传感器数据时序图：
用户主机（MCU）发送一次开始信号后，温湿度传感器从低功耗模式转换到高速模式，待主机开始信号结束后，温湿度传感器发送响应信号，送出 40bit 的数据，并触发一次信采集。信号发送如图所示。
温湿度传感器可以很容易地将温湿度数据添加到您的DIY电子项目中。它是完美的远程气象站，家庭环境控制系统，和农场或花园监测系统。
温湿度传感器的参数：
- 工作电压：+5 V
- 温度范围：0-50 °C ，误差：± 2 °C
- 湿度范围：20-90% RH ，误差：± 5% RH
- 数字接口
温湿度传感器的原理图：
4.读取温湿度值：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目27 温湿度表”。并鼠标左键双击“Project_27.1_Detect_Temperature_Humidity.py”。
# 导入 machine, time 和 dht 库.
import machine
import time
import dht
#关联DHT11引脚(13).
DHT = dht.DHT11(machine.Pin(13))
# 每秒获取一次温湿度数据，并打印出来.
while True:
DHT.measure() # 启动DHT11一次测量数据.
# 调用DHT的内置函数来获取温度
# 和湿度数据并打印在“Shell”中.
print('temperature:',DHT.temperature(),'℃','humidity:',DHT.humidity(),'%')
time.sleep_ms(1000)
确保ESP32已经连接到电脑上，单击。
单击，如果你的温湿度传感器连接错误，在“Shell”窗口中将打印以下信息。请确保你的电路已正确连接，再次单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将打印当前显示当前环境中的温湿度数据，如下图。
再次单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将打印声音传感器读取的模拟值，当对着传感器拍拍手，声音传感器的模拟值发生了显著的变化。按“Ctrl+C”或单击退出程序。
5.温湿度仪表的接线图：
现在我们开始用LCD_128X32_DOT打印温湿度传感器的值，我们会在LCD_128X32_DOT的屏幕上看到相应的值。让我们开始这个项目吧。请按照下面的接线图进行接线：
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目27 温湿度表”。分别选择“lcd128_32.py”和 “lcd128_32_fonts.py”，右键单击鼠标选择 “上传到/”，等待 “lcd128_32.py”和 “lcd128_32_fonts.py”被上传到ESP32，然后鼠标左键左键双击“Project_27.2_Temperature_Humidity_Meter.py”。
from machine import Pin
import machine
import dht
import time
import lcd128_32_fonts
from lcd128_32 import lcd128_32
temp = 0
humi = 0
#关联DHT11引脚(13).
DHT = dht.DHT11(Pin(13))
#i2c配置
clock_pin = 22
data_pin = 21
bus = 0
i2c_addr = 0x3f
use_i2c = True
def scan_for_devices():
i2c = machine.I2C(bus,sda=machine.Pin(data_pin),scl=machine.Pin(clock_pin))
devices = i2c.scan()
if devices:
for d in devices:
print(hex(d))
else:
print('no i2c devices')
try:
while True:
DHT.measure()
temp = int(DHT.temperature())
humi = int(DHT.humidity())
if use_i2c:
scan_for_devices()
lcd = lcd128_32(data_pin, clock_pin, bus, i2c_addr)
lcd.Clear()
lcd.Cursor(0, 0)
lcd.Display("temper:")
lcd.Cursor(0, 8)
lcd.Display(str(temp))
lcd.Cursor(0, 11)
lcd.Display("C")
lcd.Cursor(2, 0)
lcd.Display("Humid:")
lcd.Cursor(2, 7)
lcd.Display(str(humi))
lcd.Cursor(2, 10)
lcd.Display("%")
time.sleep(0.1)
except:
pass
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：LCD 128X32 DOT的屏幕上显示温湿度传感器检测环境中相应的温度值和湿度值。按“Ctrl+C”或单击退出程序。
项目28 测距仪表¶
1.项目介绍：
HC-SR04超声波传感器是一种非常实惠的距离传感器，主要用于各种机器人项目中的物体躲避。它也被用于水位传感器，甚至作为一个停车传感器。我们把超声波传感器当作蝙蝠的眼睛，在黑暗中，蝙蝠仍然可以通过超声波识别前方的物体和方向。在本项目中，我们使用ESP32控制超声波传感器和LED模拟超声波测距仪。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 超声波传感器*1 | 4P转杜邦线公单*1 |
|
|
|
|
| 红色 LED*4 | 220Ω电阻*4 | 跳线若干 | USB 线*1 |
3.元件知识：
HC-SR04超声波传感器： 像蝙蝠一样使用声纳来确定与物体的距离，它提供了精准的非接触范围检测，高精度和稳定的读数。它的操作不受阳光或黑色材料的影响，就像精密的照相机(在声学上像布料这样比较软的材料很难被探测到)。它带有超声波发射器和接收器。
在超声波传感器的前面是两个金属圆筒，这些是转换器。转换器将机械能转换成电信号。在超声波传感器中，有发射转换器和接收转换器。发射转换器将电信号转换为超声波脉冲，接收转换器将反射的超声波脉冲转换回电信号。如果你看超声波传感器的背面，你会看到的发射转换器后面有一个IC。这是控制发射转换器的IC。在接收转换器后面也有一个IC，这是一个四运算放大器，它将接收转换器产生的信号放大成足以传输到微控制器的信号。
时序图：
图示HC-SR04的时序图。为了开始测量，SR04的Trig必须接受至少10us的高(5V)脉冲，这将启动传感器将发射出8个周期的40kHz的超声波脉冲，并等待反射的超声波脉冲。当传感器从接收器检测到超声波时，它将设置回波引脚为高(5V)和延迟一个周期(宽度)，与距离成比例。为了获得距离，测量Echo引脚的宽度。
时间=回波脉冲宽度，单位为us(微秒)
距离厘米=时间/ 58
距离(英寸)=时间/ 148
**4.读取超声波传感器距离值 **
我们将从一个简单的超声波测距开始，并打印测量的距离。
HC-SR04超声波传感器有四个引脚：Vcc、Trig、Echo和GND。Vcc引脚提供产生超声波脉冲的电源，接Vcc/+5V。GND引脚接地/GND。Trig引脚是控制板发送信号来启动超声波脉冲的地方。Echo引脚是超声波传感器向控制板发送关于超声波脉冲行程持续时间的信息的地方。按下图接线：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目28 测距仪表”。并鼠标左键双击“Project_28.1_Ultrasonic_Ranging.py”。
from machine import Pin
import time
# 定义超声波测距模块的控制引脚.
Trig = Pin(13, Pin.OUT, 0)
Echo = Pin(14, Pin.IN, 0)
distance = 0 # 定义初始距离为0.
soundVelocity = 340 #设置声速.
# getDistance()函数用于驱动超声波模块测量距离，Trig 引脚保持在高位10us以启动超声波模块。
# Echo.value()用于读取超声波模块Echo引脚的状态，
# 然后使用时间模块的时间戳函数计算Echo的持续时间
# 引脚的高电平，根据时间计算测量距离并返回值.
def getDistance():
Trig.value(1)
time.sleep_us(10)
Trig.value(0)
while not Echo.value():
pass
pingStart = time.ticks_us()
while Echo.value():
pass
pingStop = time.ticks_us()
pingTime = time.ticks_diff(pingStop, pingStart) // 2
distance = int(soundVelocity * pingTime // 10000)
return distance
# 延迟2秒，等待超声波模块稳定下来，从超声波模块获得的数据每500毫秒打印一次.
time.sleep(2)
while True:
time.sleep_ms(500)
distance = getDistance()
print("Distance: ", distance, "cm")
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将打印超声波传感器和物体之间的距离值。按“Ctrl+C”或单击退出程序。
5.超声波测距仪的接线图：
接下来，我们将使用ESP32控制超声波传感器和4个LED来模拟超声波测距仪。按如下图接好线：
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目28 测距仪表”。并鼠标左键双击“Project_28.2_Ultrasonic_Ranger.py”。
from machine import Pin
import time
# 定义四个led的引脚.
led1 = Pin(4, Pin.OUT)
led2 = Pin(0, Pin.OUT)
led3 = Pin(2, Pin.OUT)
led4 = Pin(15, Pin.OUT)
# 定义超声波测距模块的控制引脚.
Trig = Pin(13, Pin.OUT, 0)
Echo = Pin(14, Pin.IN, 0)
distance = 0 # 定义初始距离为0.
soundVelocity = 340 #设置声速.
# getDistance()函数用于驱动超声波模块测量距离，Trig 引脚保持在高位10us以启动超声波模块。
# Echo.value()用于读取超声波模块Echo引脚的状态，
# 然后使用时间模块的时间戳函数计算Echo的持续时间
# 引脚的高电平，根据时间计算测量距离并返回值.
def getDistance():
Trig.value(1)
time.sleep_us(10)
Trig.value(0)
while not Echo.value():
pass
pingStart = time.ticks_us()
while Echo.value():
pass
pingStop = time.ticks_us()
pingTime = time.ticks_diff(pingStop, pingStart) // 2
distance = int(soundVelocity * pingTime // 10000)
return distance
# 延迟2秒，等待超声波模块稳定下来，从超声波模块获得的数据每500毫秒打印一次.
time.sleep(2)
while True:
time.sleep_ms(500)
distance = getDistance()
print("Distance: ", distance, "cm")
if distance <= 5:
led1.value(1)
else:
led1.value(0)
if distance <= 10:
led2.value(1)
else:
led2.value(0)
if distance <= 15:
led3.value(1)
else:
led3.value(0)
if distance <= 20:
led4.value(1)
else:
led4.value(0)
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将打印超声波传感器和物体之间的距离值，另外，当我们用手在超声波传感器前移动时，相应的LED会亮起来。按“Ctrl+C”或单击退出程序。
项目29 温度仪表¶
1.项目介绍：
热敏电阻是一种电阻，其阻值取决于温度和温度的变化，广泛应用于园艺、家庭警报系统等装置中。因此，我们可以利用这一特性来制作温度仪表。
2.项目元件：
|
|
|
 |
|---|---|---|---|
| ESP32*1 | 面包板*1 | LCD_128X32_DOT*1 | 热敏电阻*1 |
|
|
|
|
| 10KΩ电阻*1 | 4P转杜邦线公单*1 | USB 线*1 | 跳线若干 |
3.元件知识：
热敏电阻： 热敏电阻是一种温度敏感电阻。当热敏电阻感应到温度的变化时，它的电阻就会发生变化。我们可以利用热敏电阻的这种特性来检测温度强度。热敏电阻及其电子符号如下所示。
热敏电阻的电阻值与温度的关系为：
式中：
Rt为热敏电阻在T2温度下的电阻；
R为热敏电阻在T1温度下的标称阻值；
EXP[n]是e的n次幂；
B为温度指数；
T1，T2是开尔文温度(绝对温度)，开尔文温度=273.15 +摄氏温度。对于热敏电阻的参数，我们使用：B=3950, R=10KΩ，T1=25℃。热敏电阻的电路连接方法与光敏电阻类似，如下所示：
我们可以利用ADC转换器测得的值来得到热敏电阻的电阻值，然后利用公式来得到温度值。因此，温度公式可以推导为：
4.读取热敏电阻的值：
首先我们学习热敏电阻读取当前的ADC值、电压值和温度值并将其打印出来。请按下面的接线图接好线：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目29 温度仪表”。并鼠标左键双击“Project_29.1_Read_the_thermistor_analog_value.py”。
from machine import Pin, ADC
import time
import math
#设置 ADC
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
try:
while True:
adcValue = adc.read()
voltage = adcValue / 4095 * 3.3
Rt = 10 * voltage / (3.3-voltage)
tempK = (1 / (1 / (273.15+25) + (math.log(Rt/10)) / 3950))
tempC = (tempK - 273.15)
print("ADC value:",adcValue," Voltage:",voltage,"V"," Temperature: ",tempC,"C");
time.sleep(1)
except:
pass
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：Thonny IDE下的”Shell”窗口将不断显示热敏电阻当前的ADC值、电压值和温度值。试着用食指和拇指捏一下热敏电阻(不要碰触导线)一小段时间，你应该会看到温度值增加。按“Ctrl+C”或单击
退出程序。
5.温度仪表的接线图：
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目29 温度仪表”。分别选择“lcd128_32.py”和 “lcd128_32_fonts.py”，右键单击鼠标选择 “上传到/”，等待“lcd128_32.py”和 “lcd128_32_fonts.py”被上传到ESP32。并鼠标左键双击“Project_29.2_Temperature_Instrument.py”。
from machine import Pin, ADC, I2C
import machine
import time
import math
import lcd128_32_fonts
from lcd128_32 import lcd128_32
#设置 ADC
adc=ADC(Pin(36))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
#i2c配置
clock_pin = 22
data_pin = 21
bus = 0
i2c_addr = 0x3f
use_i2c = True
def scan_for_devices():
i2c = machine.I2C(bus,sda=machine.Pin(data_pin),scl=machine.Pin(clock_pin))
devices = i2c.scan()
if devices:
for d in devices:
print(hex(d))
else:
print('no i2c devices')
try:
while True:
adcValue = adc.read()
voltage = adcValue / 4095 * 3.3
Rt = 10 * voltage / (3.3-voltage)
tempK = (1 / (1 / (273.15+25) + (math.log(Rt/10)) / 3950))
tempC = int(tempK - 273.15)
if use_i2c:
scan_for_devices()
lcd = lcd128_32(data_pin, clock_pin, bus, i2c_addr)
lcd.Clear()
lcd.Cursor(0, 0)
lcd.Display("Voltage:")
lcd.Cursor(0, 8)
lcd.Display(str(voltage))
lcd.Cursor(0, 20)
lcd.Display("V")
lcd.Cursor(2, 0)
lcd.Display("Temperature:")
lcd.Cursor(2, 12)
lcd.Display(str(tempC))
lcd.Cursor(2, 15)
lcd.Display("C")
time.sleep(0.5)
except:
pass
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：LCD 128X32 DOT的屏幕上显示热敏电阻的电压值和当前环境中的温度值。按“Ctrl+C”或单击退出程序。
项目30 密码锁¶
1.项目介绍：
常用的数字按钮传感器，一个按钮就使用一个IO口，而有时我们需要的按钮比较多时，就会占用过多的IO口，为了节省IO口的使用，把多个按钮做成了矩阵类型，通过行列线的控制，实现少IO口控制多个按钮。在本项目中，我们将来学习ESP32和薄膜4*4矩阵键盘控制舵机和蜂鸣器。
2.项目元件：
|
|
|
|---|---|---|
| ESP32*1 | 面包板*1 | 舵机*1 |
 |
|
|
| 薄膜4×4矩阵键盘*1 | USB 线*1 | 跳线若干 |
|
|
|
| NPN型晶体管(S8050)*1 | 有源蜂鸣器*1 | 1KΩ电阻*1 |
3.元件知识：
4×4矩阵键盘： 键盘是一种集成了许多键的设备。如下图所示，一个4x4键盘集成16个键。
与LED矩阵集成一样，在4x4键盘中，每排键都是用一根引脚连接，每一列键都是一样的。这样的连接可以减少处理器端口的占用。内部电路如下所示。
使用方法类似于矩阵LED，即使用行扫描或列扫描方法检测每列或每行上的键的状态。以列扫描法为例，向第4列(Pin4)发送低电平，检测第1、2、3、4行电平状态，判断A、B、C、D键是否按下。然后依次将低电平发送到列3、2、1，检测是否有其它键被按下。然后，你可以获得所有键的状态。
4.读取4*4矩阵键盘的键值：
我们首先使用一个简单的代码读取4*4矩阵键盘的键值并将其打印出来，其接线图如下所示：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目30 密码锁”。选择“keypad.py”，右键单击鼠标选择 “上传到/”，等待 “keypad.py”被上传到ESP32. 并鼠标左键双击“Project_30.1_4x4_Matrix_Keypad_Display.py”。
# 导入 keypad 库.
from keypad import KeyPad
import time
# 将键盘模块与ESP32引脚关联.
keyPad = KeyPad(22, 21, 19, 18, 17, 16, 4, 0)
#调用函数keyPan.scan()来获取所按键的值。一旦得到，就打印出来.
def key():
keyvalue = keyPad.scan()
if keyvalue != None:
print(keyvalue, end="\t")
time.sleep_ms(300)
return keyvalue
while True:
key()
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：按下键盘，Thonny IDE下的”Shell”窗口将打印对应的键值，如下图所示。按“Ctrl+C”或单击退出程序。
5.密码锁的接线图：
在上一实验中，我们已经知道了4×4矩阵键盘的键值，接下来，我们使用4×4矩阵键盘作为键盘来控制舵机和蜂鸣器。
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目30 密码锁”。选择“keypad.py”，右键单击鼠标选择 “上传到/”，等待 “keypad.py”被上传到ESP32. 并鼠标左键双击“Project_30.2_Keypad_Door.py”。
from keypad import KeyPad
from machine import Pin, PWM
import time
keyPad = KeyPad(22, 21, 19, 18, 17, 16, 4, 0)
servo= PWM(Pin(15))
servo.freq(50)
servo.duty(256)
servo.duty_u16(1638)
time.sleep_ms(1000)
activeBuzzer = Pin(2, Pin.OUT)
# 定义数组并设置密码.
passWord = "1234"
keyIn = ""
def key():
keyvalue = keyPad.scan()
if keyvalue != None:
print('Your input:', keyvalue)
time.sleep_ms(200)
return keyvalue
while True:
# 每次按下一个键，蜂鸣器就会短促地鸣叫一声，
# 键的键值将存储在keydata数组中.
keydata = key()
if keydata != None:
activeBuzzer.value(1)
time.sleep_ms(100)
activeBuzzer.value(0)
keyIn += keydata
# 当按下4个键时，判断密码是否正确。
# 如果正确，伺服将旋转90度，1秒后再转回来。
# 如果密码输入错误，蜂鸣器会长时间鸣叫一次，并清除keyInNum的值.
if len(keyIn) == 4:
if keyIn == passWord:
print("passWord right!")
servo.duty_u16(4915)
time.sleep_ms(1000)
servo.duty_u16(1638)
else:
print("passWord error!")
activeBuzzer.value(1)
time.sleep_ms(1000)
activeBuzzer.value(0)
keyIn = ""
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：按键盘输入4个字符的密码，如果输入正确（正确密码：1234），舵机会转动一定角度，然后回到原来的位置。如果输入错误，将发出输入错误警报。按“Ctrl+C”或单击退出程序。
项目31 红外遥控控制声音和LED¶
1.项目介绍：
红外遥控是一种低成本、易于使用的无线通信技术。IR光与可见光非常相似，除了它的波长稍长一点。这意味着红外线是人眼无法检测到的，这对于无线通信来说是完美的。例如，当你按下电视遥控器上的一个按钮时，一个红外LED会以每秒38000次的频率反复开关，将信息(如音量或频道控制)传送到电视上的红外感光器。
我们将首先解释常见的红外通信协议是如何工作的。然后我们将从一个遥控器和一个红外接收组件开始这个项目。
2.项目元件：
|
|
 |
|
|---|---|---|---|
| ESP32*1 | 面包板*1 | 红外接收器*1 | RGB LED*1 |
|
|
|
 |
| 有源蜂鸣器*1 | 220Ω电阻*3 | 10KΩ电阻*1 | 红外遥控器*1 |
|
|
|
|
| NPN型晶体管(S8050)*1 | 1kΩ电阻*1 | USB 线*1 | 跳线若干 |
**3.元件知识： **
红外(IR)遥控器： 是一种可以发射红外光信号的设备。按下不同的按钮，位于遥控器前端的红外发射管会发出不同指令的红外线。红外遥控技术应用广泛，如电视、空调等。因此，在当今科技发达社会，红外遥控技术使你切换电视节目和调节空调温度都很方便。
我们使用的遥控器如下所示：
该红外遥控器采用NEC编码。
红外(IR)接收器： 它是一种元件，可以接收红外光，所以可以用它来接收红外遥控器发出的红外光信号。红外接收器解调接收到的红外光信号，并将其转换回二进制，然后将信息传递给微控制器。
红外信号调制过程图：
4.解码红外信号：
我们按照下面接线图将红外接收元件连接到ESP32。
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目31 红外遥控控制声音和LED”。选择“irrecvdata.py”，右键单击选择 “上传到/”,等待“irrecvdata.py”被上传到ESP32. 并鼠标左键双击“Project_31.1_Decoded_IR_Signal.py”。
# 导入红外解码器.
from irrecvdata import irGetCMD
# 将红外解码器与GP0关联.
recvPin = irGetCMD(0)
# 当获得红外键值时，在“Shell”中打印出来.
try:
while True:
irValue = recvPin.ir_read() #调用ir_read()来读取所按键的值并将其赋值给IRValue.
if irValue:
print(irValue)
except:
pass
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：将红外遥控器发射器对准红外接收头，按下红外控制器上的按键，Thonny IDE下的”Shell”窗口将打印当前接收到的按键编码值。按“Ctrl+C”或单击退出程序。
写下红外遥控器与每个按键相关联的按键编码值，因为你稍后将需要这些信息。
5.红外遥控的接线图：
6.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目31 红外遥控控制声音和LED”。选择“irrecvdata.py”，右键单击选择 “上传到/”,等待“irrecvdata.py”被上传到ESP32. 并鼠标左键双击“Project_31.2_IR_Control_Sound_And_LED.py”。
from machine import Pin,PWM
import time
from irrecvdata import irGetCMD
#设置RGB的接口和频率
rgb_r = PWM(Pin(22))
rgb_g = PWM(Pin(21))
rgb_b = PWM(Pin(4))
rgb_r.freq(1000)
rgb_g.freq(1000)
rgb_b.freq(1000)
rgb_r.duty(0)
rgb_g.duty(0)
rgb_b.duty(0)
# 初始化蜂鸣器引脚
buzzer=Pin(15, Pin.OUT)
#配置红外接收引脚和库
recvPin = irGetCMD(0)
while True:
irValue = recvPin.ir_read() # 读取远程控制数据
# 确定是否有满足需求的按钮
if irValue:
print(irValue)
buzzer.value(1)
time.sleep(0.1)
buzzer.value(0)
if irValue == '0xff6897': #1
rgb_r.duty(1023)
rgb_g.duty(0)
rgb_b.duty(0)
print('1')
elif irValue == '0xff9867': #2
rgb_r.duty(0)
rgb_g.duty(1023)
rgb_b.duty(0)
print('2')
elif irValue == '0xffb04f': #3
rgb_r.duty(0)
rgb_g.duty(0)
rgb_b.duty(1023)
print('3')
elif irValue == '0xff30cf': #4
rgb_r.duty(1023)
rgb_g.duty(1023)
rgb_b.duty(0)
print('4')
elif irValue == '0xff18e7': #5
rgb_r.duty(1023)
rgb_g.duty(0)
rgb_b.duty(1023)
print('5')
elif irValue == '0xff7a85': #6
rgb_r.duty(0)
rgb_g.duty(1023)
rgb_b.duty(1023)
print('6')
elif irValue == '0xff10ef': #7
rgb_r.duty(1023)
rgb_g.duty(1023)
rgb_b.duty(1023)
print('7')
else:
rgb_r.duty(0)
rgb_g.duty(0)
rgb_b.duty(0)
7.项目现象：
确保ESP32已经连接到电脑上，单击。
单击，代码开始执行，你会看到的现象是：按红外遥控器的1~7键，蜂鸣器都会鸣响一次，同时RGB分别亮红灯，绿灯，蓝灯，黄灯，洋红灯，蓝绿灯，白灯。按其他另一按键（除1-7键以外），RGB熄灭。按“Ctrl+C”或单击退出程序。
特别注意：当代码在运行时有时候会出现以下类似提示语，只要鼠标先单击，然后再单击就可以使代码重新运行。
项目32 WiFi 工作模式¶
在如今科技高速发展的时代，人们的生活质量越来越好，生活节奏越来越快，开始有人觉得复杂多样的智能化设备控制起来十分麻烦，通过手机统一控制智能化设备这种方法逐渐得到了人们的青睐。这种方法是利用单片机通过wifi模块和Internet网络建立手机和智能化设备之间的连接以此来实现对智能化设备的远程控制。在本章中，我们将重点关注ESP32的WiFi基础设施。ESP32有3种不同的WiFi工作模式：Station模式、AP模式和AP+Station模式。所有WiFi编程项目在使用WiFi前必须配置WiFi运行模式，否则无法使用WiFi。
项目32.1: WIFI Station 模式
1.实验元件：
|
|
|---|---|
| USB 线 x1 | ESP32x1 |
2.实验接线：
使用USB线将ESP32主板连接到电脑上的USB口。
3.元件知识：
Station 模式： 当ESP32选择Station模式时，它作为一个WiFi客户端。它可以连接路由器网络，通过WiFi连接与路由器上的其他设备通信。如下图所示，PC和路由器已经连接，ESP32如果要与PC通信，需要将PC和路由器连接起来。
4.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目32 WiFi 工作模式”。 并鼠标左键双击“Project_32.1_WiFi_Station_Mode.py”。
import time
import network # 导入 network 库.
ssidRouter = 'ChinaNet-2.4G-0DF0' # 输入路由器名称
passwordRouter = 'ChinaNet@233' # 输入路由器密码
def STA_Setup(ssidRouter,passwordRouter):
print("Setup start")
sta_if = network.WLAN(network.STA_IF) # 设置ESP32为“Station模式”.
if not sta_if.isconnected():
print('connecting to',ssidRouter)
# 激活ESP32的站模式，向路由器发起连接请求
# 并输入连接密码.
sta_if.active(True)
sta_if.connect(ssidRouter,passwordRouter)
#等待ESP32与路由器连接成功.
while not sta_if.isconnected():
pass
# 在Shell中打印分配给ESP32-WROVER的IP地址.
print('Connected, IP address:', sta_if.ifconfig())
print("Setup End")
try:
STA_Setup(ssidRouter,passwordRouter)
except:
sta_if.disconnect()
5.项目现象：
由于各个地方的路由器名称和密码不同，所以在运行代码之前，用户需要在上图所示的红色框中输入正确的路由器名称和密码。
在确认正确输入路由器名和密码后，单击，代码开始执行，等待ESP32连接到你的路由器，在“Shell”窗口中打印路由器分配给ESP32的IP地址。
项目35.2：WIFI AP 模式
1.实验元件&接线：
实验元件和实验接线与上面的项目32.1: WIFI Station 模式相同。
2.元件知识：
AP模式： 当ESP32选择AP模式时，会创建一个独立于Internet的热点网络，等待其他WiFi设备连接。如下图所示，以ESP32为热点。如果手机或PC需要与ESP32通信，则必须连接到ESP32的热点。只有通过ESP32建立连接后才能进行通信。
3.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目32 WiFi 工作模式”。 并鼠标左键双击“Project_32.2_WiFi_AP_Mode.py”。
import network #导入 network 库.
#请输入正确的路由器名称和密码.
ssidAP = 'ESP32_Wifi' #输入AP名称
passwordAP = '12345678' #输入AP密码
local_IP = '192.168.1.147'
gateway = '192.168.1.1'
subnet = '255.255.255.0'
dns = '8.8.8.8'
#配置ESP32为AP模式.
ap_if = network.WLAN(network.AP_IF)
def AP_Setup(ssidAP,passwordAP):
ap_if.ifconfig([local_IP,gateway,subnet,dns])
print("Setting soft-AP ... ")
ap_if.config(essid=ssidAP,authmode=network.AUTH_WPA_WPA2_PSK, password=passwordAP)
ap_if.active(True)
print('Success, IP address:', ap_if.ifconfig())
print("Setup End\n")
try:
AP_Setup(ssidAP,passwordAP)
except:
print("Failed, please disconnect the power and restart the operation.")
ap_if.disconnect()
4.项目现象：
在程序代码运行之前，你可以像上图所示对红色框中ESP32的AP名称和密码进行任何更改。当然，在默认情况下，你也可以不修改它。
单击，代码开始执行，打开ESP32的AP功能，“Shell”窗口中打印接入点信息。
观察串口监视器打印信息时，打开手机WiFi扫描功能，可以看到ESP32上的ssid_AP被调用，在本程序代码中称为“ESP32_Wifi”。你可以输入密码“12345678”连接它，也可以通过修改程序代码来修改它的AP名称和密码。
项目35.3：WIFI AP+Station模式
1.实验元件&接线：
实验元件和实验接线与上面的项目32.1: WIFI Station 模式和项目32.2: WIFI AP 模式相同。
2.元件知识：
AP+Station模式： ESP32除AP模式和Station模式外，还可以同时使用AP模式和Station模式。此模式包含前两种模式的功能。打开ESP32的Station模式，将其连接到路由器网络，它可以通过路由器与Internet通信。同时开启其AP模式，创建热点网络。其他WiFi设备可以选择连接路由器网络或热点网络与ESP32通信。
3.项目代码：
本教程中使用的代码保存在：“..\程序代码\Python_代码”的路径中。
你可以把代码移到任何地方。例如，我们将代码保存在D盘中，路径为D:\2. 项目教程。
打开“Thonny”软件，点击“此电脑”→“D:”→“2. 项目教程”→“项目32 WiFi 工作模式”。 并鼠标左键双击“Project_32.3_WiFi_Station+AP_Mode.py”。
import network #导入 network 库.
ssidRouter = 'ChinaNet-2.4G-0DF0' #输入路由器名称
passwordRouter = 'ChinaNet@233' #输入路由器密码
ssidAP = 'ESP32_Wifi'#输入AP名称
passwordAP = '12345678' #输入AP密码
local_IP = '192.168.4.147'
gateway = '192.168.1.1'
subnet = '255.255.255.0'
dns = '8.8.8.8'
sta_if = network.WLAN(network.STA_IF)
ap_if = network.WLAN(network.AP_IF)
def STA_Setup(ssidRouter,passwordRouter):
print("Setting soft-STA ... ")
if not sta_if.isconnected():
print('connecting to',ssidRouter)
sta_if.active(True)
sta_if.connect(ssidRouter,passwordRouter)
while not sta_if.isconnected():
pass
print('Connected, IP address:', sta_if.ifconfig())
print("Setup End")
def AP_Setup(ssidAP,passwordAP):
ap_if.ifconfig([local_IP,gateway,subnet,dns])
print("Setting soft-AP ... ")
ap_if.config(essid=ssidAP,authmode=network.AUTH_WPA_WPA2_PSK, password=passwordAP)
ap_if.active(True)
print('Success, IP address:', ap_if.ifconfig())
print("Setup End\n")
try:
AP_Setup(ssidAP,passwordAP)
STA_Setup(ssidRouter,passwordRouter)
except:
sta_if.disconnect()
ap_if.idsconnect()
4.项目现象：
它类似于上面的项目32.1和项目32.2。在运行代码之前，你需要修改ssidRouter、passwordRouter、ssidAP和passwordAP，如上图中的红色框所示。在确保正确修改代码后，单击，代码开始执行，“Shell”窗口中将显示如下：
打开手机的WiFi搜索功能，可以在ESP32上看到ssid_AP被调用。