ESP32 开发板介绍

ESP32 是一款国产芯片，这个芯片专为移动设备、可穿戴设备与物联网应用而设计，集成了低功耗蓝牙和 Wi-Fi。这也是为什么 ESP32 在 DIY 爱好者中备受推崇的原因。

其中模块的含义：

ESP32 芯片有 48 个引脚，具有多种功能，并不是所有的 ESP32 开发板的管脚都暴露在外，有些管脚不能使用。

ESP32 芯片有 34 个可编程的 GPIO 引脚，每个引脚执行多个功能，也就是 IO 口复用，设置 IO 口功能的时候只有一个功能会被激活。可以在程序中将引脚配置为 GPIO、ADC、UART 等等。此外，有些引脚具有特定的功能，使得它们适合或不适合特定的项目。

ESP32 开发板引脚图如下：

ESP32 开发方式

ESP32 的开发方式主要有三种：

• MicroPython，常用的开发软件为 Thonny，支持 Python 语法，容易上手
• Arduino，便捷灵活、方便上手的开源电子原型平台，支持 ESP32、ESP8266等，可以使用 Arduino IDE 或者 VSCode/Clion + PlatformIO 进行项目开发。
• ESP-IDF，是乐鑫官方的物联网开发框架，基于 C/C++ 语言提供了一个自给自足的 SDK，方便用户在这些平台上开发通用应用程序。

还有几个比较小众的开放方式比如 Lua、Javascript 等等，大家可以去了解。

什么是 Arduino？

Arduino 是一款开源电子原型平台，由意大利的开发者 Massimo Banzi 和 David Cuartielles 共同开发。它由硬件和软件两部分组成，硬件部分包括一个控制器和一些电子元件，软件部分则是基于简单易学的 C++ 编程语言的 Arduino IDE。

Arduino 的最大优势就是它简单易学，开发门槛低，所以成为了电子制作、物联网等领域的热门选择。在 Arduino 的官方网站上，你可以找到各种各样的项目示例，从简单的 LED 闪烁到复杂的机器人控制都有。同时，Arduino 社区非常活跃，有很多志同道合的开发者分享自己的作品和经验，可以帮助新手更快地入门。

如果你是初学者，可以从以下几个方面了解 Arduino：

1. 了解 Arduino 的特点和优势。Arduino 是一款方便快捷的原型开发平台，拥有简单易学的编程语言和大量的开源项目，可以让你快速上手，快速实现自己的创意；
2. 了解 Arduino 的硬件组成。Arduino 包括一个主板和一些电子元件，如电阻、电容、LED 灯等。其中最重要的是主板，它包括一个控制器，可以通过 USB 接口与电脑进行通信，以及一些引脚，可以连接其他电子元件；
3. 学习 Arduino 的编程语言。Arduino 的编程语言是基于 C++ 的，但是简化了很多语法，让初学者容易上手。你可以通过 Arduino IDE 编写代码，并将代码上传到主板上运行；
4. 尝试一些简单的项目。例如让 LED 灯闪烁、控制舵机转动、检测温度等。这些简单的项目可以帮助你熟悉 Arduino 的编程语言和硬件组成，为以后的更复杂的项目打下基础。

总的来说，Arduino 是一款十分有趣和有用的电子原型平台。对于初学者来说，可以通过 Arduino 入门电子制作，实现自己的创意。希望这篇文章可以帮助你初步了解 Arduino，并激发你对电子制作的兴趣。

想要玩开发板必须得写代码，要不然 Arduino 不知道怎么运行，Arduino 的开发语言是 C 语言，大家可能都听说过 C 语言很难，不适合新手小白入门。这一点大家不需要担心，准确来说，Arduino 属于类 C 语言，并没有 C 语言那么复杂，只用到了 C 语言中的基本语法。这也是为什么 Arduino 能够如此流行的原因。

下载 Arduino

官方下载地址：www.arduino.cc/en/softwareopen in new window

打开网页就是下面这个图，官方的支持两种编程方式，一种是 Code Online，一种是下载软件本地编程，为了编程体验，果断选择下载软件。

官方的 IDE 支持不同的操作系统，根据你自己的平台选择即可。

官方最新的 IDE 已经出到了 2.0.4，但是 Arduino 2.x 仅支持 Win 10 之后的系统，所以如果你的电脑上是 Win7 的话，就只能选择 Arduino 1.8.x 了，当前页面继续下拉即可找到 Arduino 1.8.19。本套教程也将采用 1.8.19 版本演示。

点击链接后会跳转到下载界面，如果你想要为开源软件做点贡献，可以考虑捐款，不想捐的话就点击 JUST DOWNLOAD 即可，在我们的资料包中也有 Arduino 1.8.19 与 2.0.4 的安装程序。

安装过程很简单，一直点击下一步即可，

勾选所有选项，点击下一步，

选择一个合适的安装路径，之后点击 install，等待安装完成即可。

安装 ESP32 开发环境

为了能够使用 Arduino IDE 开发 ESP32，你需要向 Arduino IDE 板管理器添加一个额外的源，然后安装 ESP32。我们需要先添加 ESP32 开发板附加网址。打开文件 菜单下的 首选项。

把下面的链接复制粘贴到 附加开发板管理网址 中：

https://espressif.github.io/arduino-esp32/package_esp32_index.json
https://espressif.github.io/arduino-esp32/package_esp32_dev_index_cn.json   

再安装 ESP32 开发板，选择 工具 菜单中的 开发板 -> 开发板管理器...

在搜索栏中搜索 esp32，可以看到 esp32 库，选择 2.0.4 版本，点击安装，等待安装完成即可。

选择对应的开发板 ESP32 Dev Module，

选择好开发板后，工具菜单中就会多出一些选项，如果你不会调试的话，按照默认的即可。

接着，选择 ESP32 对应的端口，

最后，我们打开资料包中 0.开机测试代码中的 Arduino 测试代码，编译并运行，

最后，如果开发板上有一个 LED 在闪烁，说明安装成功。运行的代码是保存在开发板的 FLASH 中的，断电后不会丢失。

常见问题

1. JSON下载失败和下载速度慢的问题

在 Arduino IDE 中的开发板管理器添加开发板 ESP32：

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.jsonopen in new window

但是，使用这个地址是没办法正常下载的，就会出现以下错误信息，

• 解决方法一：可以将之前的开发板地址更换为国内可以访问的代理加速地址，比如：

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
https://arduino.me/packages/esp32.json
https://dl.espressif.com/dl/package_esp32_index.json

正常来说原地址和镜像地址的主域名会有区别，后面的路径是一样的。这个时候，如果镜像地址没有问题，就可以正常下载到 JSON 文件。

之后，我们就可以在 开发板管理器 中搜索到 esp32 了。

如果以上镜像地址均失效，可以尝试一下离线安装。

• 解决方法二：手动下载 esp32 包，在我们的资料包中的 3.开发工具 下的 esp32-2.0.4(离线库)。

复制该文件夹中的所有文件，

打开缓存目录：

将离线库的所有文件复制到该目录下的 staging 下的 packages 中：

选择 工具 菜单中的 开发板 -> 开发板管理器...

在搜索栏中搜索 esp32，可以看到 esp32 库，选择 2.0.4 版本，点击安装，等待安装完成即可。

2. 配置解释器没有发现端口

这里有两种解决方法：

1. 检查esp32连接电脑的数据线，如果是单纯的供电线是不可以的，需要更换为能传输数据的数据线。
2. 安装对应的 ESP32 USB 驱动，可以将资料包中的开发工具中的ESP32 驱动 CP210X下的压缩包解压安装即可。

3. 检测到端口，但是有警告图标，端口无法使用

这种情况很有可能是设备驱动有问题。串口显示黄色的，需要更新设备驱动，如下图，右键设备，点击更新设备驱动。

手动查找驱动程序，

从计算机上的可用驱动程序列表中选取，

选择 端口（COM 和 LPT），

安装两个驱动，第一个是 USB 串行设备，

重复上图的操作,安装另一个驱动 USB 串行调制解调器设备，

这样就 OK 了。

我们说过 Arduino 是基于 C++，我们需要了解一下，Arduino 的语法以及如何使用。

注释

当你编写代码时，注释（comments）是非常重要的一部分。注释是对代码的解释和说明，而且对于其他开发者或者自己日后需要修改代码的时候，都非常有帮助。注释可以提高代码的可读性和可维护性，并且可以帮助你自己更好地理解代码。

注释是由双斜线 // 或者斜线星号 /*...*/ 来表示的。单行注释以两个斜线开头，多行注释则以斜线星号开头，以星号斜线结尾。例如：

// 这是一个单行注释

/*
这是一个多行注释
它可以跨越多行
*/

注释可以用来解释代码的功能，算法或者实现细节。例如，以下是一些常见的注释用法：

• 函数或者方法的用途
• 参数的说明
• 返回值的说明
• 代码实现的说明
• 代码的限制或者假设条件
• 作者信息、创建时间、修改时间等等

注释应该尽可能的清晰、简洁和明了，同时避免使用无用的注释，以免给代码带来混淆和干扰。注释应该随着代码一起更新，以确保注释和代码的一致性。

变量

当我们编写程序时，变量是一个非常基本的概念。一个变量可以存储一个值，这个值可以是数字、字符串、布尔值、对象等。

在 Arduino 编程语言中，变量需要在使用前声明，声明语法为：

数据类型 变量名；

数据类型指定变量可以存储的数据类型，常见的数据类型有：

• int：整数类型，占用2个字节，可以表示范围为 -32768 到 32767 之间的整数。
• float：浮点数类型，占用4个字节，可以表示小数。
• char：字符类型，占用1个字节，可以表示一个字符。
• bool：布尔类型，占用1个字节，只有两个值：true 或 false。

变量名是标识符，命名规则为字母、数字、下划线的组合，第一个字符不能是数字。

下面是一些变量的示例：

int a; // 声明一个名为 a 的整型变量
float b = 3.14; // 声明一个名为 b 的浮点型变量，并初始化为 3.14
char c = 'A'; // 声明一个名为 c 的字符型变量，并初始化为字符 'A'
bool d = true; // 声明一个名为 d 的布尔型变量，并初始化为 true

变量在程序中可以被赋值或者修改：

int a = 10; // 初始化 a 为 10
a = 20; // 修改 a 的值为 20

除了上述基本数据类型外，Arduino 还支持其他的数据类型，如字符串类型 String，数组类型等。在使用变量时，需要根据需求选择合适的数据类型，避免浪费内存。

条件语句

当我们需要根据某个条件来执行不同的代码时，就需要使用条件语句。在 Arduino 编程语言中，常见的条件语句有 if 语句和 switch 语句。

if 语句

if 语句是最基本的条件语句，其语法如下：

if (condition) {
  // if 条件成立时要执行的代码
}

其中，condition 是一个条件表达式，如果这个条件表达式的值为真，则执行花括号中的代码块。

如果需要在条件不成立时执行代码，则可以添加 else 语句：

if (condition) {
  // if 条件成立时要执行的代码
} else {
  // if 条件不成立时要执行的代码
}

当然，也可以在 else 语句后面添加一个 if 语句，从而实现多个条件判断。这个语法结构被称为 else if：

if (condition1) {
  // if 条件 1 成立时要执行的代码
} else if (condition2) {
  // if 条件 2 成立时要执行的代码
} else {
  // 如果以上条件都不成立，则执行这里的代码
}

switch 语句

switch 语句也是一种条件语句，通常用于比较一个变量与一系列常量值。其语法如下：

switch (variable) {
  case value1:
    // 如果 variable 的值等于 value1，则执行这里的代码
    break;
  case value2:
    // 如果 variable 的值等于 value2，则执行这里的代码
    break;
  default:
    // 如果 variable 的值不等于任何一个 case 的值，则执行这里的代码
    break;
}

在 switch 语句中，variable 是要进行比较的变量，而 case 是常量值。如果 variable 的值等于某个 case 的值，则执行该 case 对应的代码块，并且在代码块末尾添加 break 语句，以防止执行其他的 case。如果 variable 的值不等于任何一个 case 的值，则执行 default 中的代码块。需要注意的是，在 switch 语句中，每个 case 的值必须是常量，且不可重复。

总的来说，if 语句和 switch 语句都是用于控制程序执行流程的条件语句，开发者可以根据具体情况选择使用哪种语句。

循环语句

当我们需要重复执行一段代码时，就需要用到循环语句。在 Arduino 中，有两种主要的循环语句：for 循环和 while 循环。

for 循环

for 循环是一个控制结构，它允许你重复执行一系列语句，具体次数由循环次数确定。for 循环的语法如下：

for (初始化表达式; 布尔表达式; 更新表达式) {
  // 代码块
}

for 循环由三部分组成：

• 初始化表达式：在循环开始时执行一次，通常用于初始化计数器。
• 布尔表达式：在每次迭代开始前计算，如果结果为 true，则执行循环体语句，否则退出循环。
• 更新表达式：在每次迭代结束后执行，通常用于更新计数器。

下面是一个简单的 for 循环的例子，它输出数字 0 到 9：

for (int i = 0; i < 10; i++) {
  Serial.println(i);
}

在这个例子中，初始化表达式初始化了计数器 i 为 0，布尔表达式检查 i 是否小于 10，更新表达式将 i 增加 1。在每次迭代中，计数器 i 的值都会被输出。

while 循环

while 循环是另一种重复执行语句块的方法。它会在条件为 true 时重复执行代码块。while 循环的语法如下：

while (布尔表达式) {
  // 代码块
}

while 循环只由一个条件表达式组成，当这个表达式为 true 时，执行循环体语句。在每次循环执行后，条件表达式都会被重新计算。如果条件表达式为 false，则跳过循环体语句，直接执行循环后面的代码。

下面是一个使用 while 循环输出数字 0 到 9 的例子：

int i = 0;
while (i < 10) {
  Serial.println(i);
  i++;
}

在这个例子中，初始化变量 i 的值为 0。while 循环的条件表达式检查变量 i 是否小于 10。只要条件为 true，循环就会一直执行，每次将变量 i 的值增加 1。在每次循环中，变量 i 的值都会被输出。

总体来说，for 循环适用于知道循环次数的情况，而 while 循环适用于不知道循环次数的情况。

数组

接下来我们来看看如何使用 Arduino 的数组。

数组是一种用于存储多个值的数据类型。数组的每个元素都有一个唯一的索引，可以使用这个索引来访问数组中的元素。

定义数组的语法如下：

type arrayName[arraySize];

其中，type 是数组中元素的数据类型，arrayName 是数组的名称，arraySize 是数组的大小，下面是一个例子：

int myArray[5];

这个代码定义了一个包含 5 个整数的数组，可以使用 myArray[0] 到 myArray[4] 访问这些元素。

可以在定义数组时初始化数组。例如：

int myArray[5] = {1, 2, 3, 4, 5};

这个代码定义了一个包含 5 个整数的数组，并将其初始化为 1、2、3、4、5。

也可以使用以下方式初始化数组：

int myArray[] = {1, 2, 3, 4, 5};

这个代码定义了一个包含 5 个整数的数组，并将其初始化为 1、2、3、4、5。

你可以使用下标访问数组元素。下标从 0 开始，例如：

int myArray[5] = {1, 2, 3, 4, 5};
int x = myArray[2];  // 将 x 的值设置为数组中下标为 2 的元素，即 3。

可以使用循环遍历数组中的所有元素。例如：

int myArray[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
  // 打印数组中的每个元素
  Serial.println(myArray[i]);
}

Arduino 中还支持多维数组。例如：

int myArray[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

这个代码定义了一个 3 行 3 列的二维数组，并将其初始化为：

1 2 3
4 5 6
7 8 9

可以使用两个下标来访问数组中的元素。例如：

int myArray[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int x = myArray[1][2];  // 将 x 的值设置为数组中第 2 行第 3 列的元素，即 6。

函数

当程序中需要执行某个特定任务时，函数是非常有用的。函数可以包含一些代码块，这些代码块可以在程序的其他地方多次调用。在 Arduino 编程语言中，函数包含了一个函数头和一个函数体。函数头包含了函数名称和参数列表，函数体包含了一些要执行的代码。

以下是一个简单的函数示例：

int add(int a, int b) {    //函数头
  int sum = a + b;         //函数体
  return sum;
}

这个函数的名称是 add，它有两个参数，分别是 a 和 b，函数体包含了将 a 和 b 相加的操作，最后通过 return 返回结果。

在程序中调用函数时，可以像这样使用：

int x = 3;
int y = 5;
int z = add(x, y);    //调用函数

在这个示例中，我们将 x 和 y 作为参数传递给 add 函数，该函数返回它们的和，最后将结果存储在 z 变量中。

函数的参数也可以是其他类型的数据，例如字符串、浮点数等等。在 Arduino 编程语言中，函数也可以没有参数，也可以没有返回值。以下是一个没有参数和返回值的函数示例：

void sayHello() {    //函数头
  Serial.println("Hello World!");    //函数体
}

这个函数的名称是 sayHello，它没有参数和返回值。函数体包含了一条输出语句，它将字符串 "Hello World!" 输出到串行监视器中。

函数的使用可以让代码更加清晰、易读和易于维护。通过将代码块封装到函数中，可以使代码更加模块化，也可以避免在多个地方重复编写相同的代码。在编写代码时，应该尽可能地使用函数，以便使代码更加可读、易于维护和可扩展。

常用函数介绍

下面列出了一些常用的 Arduino 函数：

当使用 Arduino 进行编程时，有许多内置函数可用。这些函数可以帮助我们更轻松地编写程序，处理输入和输出，控制逻辑流和实现其他功能。下面是一些常用的 Arduino 函数：

1. pinMode(pin, mode): 用于配置数字引脚的输入或输出模式。pin 是数字引脚的编号，mode 是要设置的模式（输入或输出）。

2. digitalWrite(pin, value): 用于在数字引脚上写入数字值（HIGH 或 LOW）。pin 是数字引脚的编号，value 是要写入的值。

3. digitalRead(pin): 用于读取数字引脚上的数字值（HIGH 或 LOW）。pin 是数字引脚的编号。

4. analogRead(pin): 用于读取模拟引脚上的模拟值（0-1023）。pin 是模拟引脚的编号。

5. analogWrite(pin, value): 用于在支持 PWM 输出的数字引脚上输出模拟值（0-255）。pin 是数字引脚的编号，value 是要输出的值。

6. delay(ms): 用于在程序中创建暂停（延迟）时间。ms 是要延迟的毫秒数。

7. millis(): 返回自启动以来的毫秒数，可以用于时间跟踪和计时器。

8. Serial.begin(baud): 用于初始化串口通信，其中 baud 是波特率。

9. Serial.print(data): 用于将数据打印到串口监视器。data 可以是数字，字符串或其他数据类型。

10. Serial.available(): 用于检查是否有数据可以从串口读取。

这些函数只是 Arduino 可用的众多函数中的一部分。熟悉这些常用函数可以帮助我们更轻松地编写程序，并为实现特定功能提供了有用的工具。

下面是一个简单的实例代码，演示了如何控制一个 LED 灯的亮灭：

// 设置 LED 引脚
int led_pin = 2;

void setup() {
  // 设定引脚为输出模式
  pinMode(led_pin, OUTPUT);
}

void loop() {
  // 点亮 LED
  digitalWrite(led_pin, HIGH);
  // 等待一段时间
  delay(1000);
  // 关闭 LED
  digitalWrite(led_pin, LOW);
  // 等待一段时间
  delay(1000);
}

这段代码中，我们首先定义了一个整型变量 led_pin，表示连接 LED 灯的引脚。在 setup() 函数中，我们将该引脚设定为输出模式，然后在 loop() 函数中交替点亮和关闭 LED 灯，并在两次操作之间等待 1 秒钟的时间。

总结

本文介绍了 Arduino 的基本概念和编程语言，并演示了如何通过 Arduino 板上的数字和模拟引脚来控制硬件设备。对于初学者而言，理解这些基础知识是开始进行更高级项目的基础。如果你想进一步深入了解 Arduino，可以参考官方文档或者更高级别的教程。

我们在使用单片机的时候，电路搭建是必不可少的，而面包板和杜邦线可以让你更加轻松地搭建电路，这节课就来讲讲面包板与杜邦线的简单使用。

实验原理

1. 面包板

面包板是实验室中用于搭接电路的重要工具，熟练掌握面包板的使用方法是提高实 验效率，减少实验故障出现几率的重要基础之一。下面就面包板的结构和使用方法做简 单介绍。

面包板的外观和内部结构如上图所示，常见的最小单元面包板分上、中、下三部分，上面和下面部分一般是由一行或两行的插孔构成的窄条，中间部分是由中间一条隔离凹槽和上下各 5 行的插孔构成的宽条。

上下两部分的窄条，外观和结构如下图：

窄条上下两行之间电气不连通。每 5 个插孔为一组，通常的面包板上有 10 组(为了方便展示，第一张图展示的是小面包板，只有 5 组，原理相同)。标注 + 的窄条一般接电源，- 接地。

中间部分宽条是由中间一条隔离凹槽和上下各 5 行的插孔构成。在同一列中的 5 个 插孔是互相连通的，列和列之间以及凹槽上下部分则是不连通的。外观及结构如下图：

2. 杜邦线

杜邦线是美国杜邦公司生产的有特殊效用的排线。 电子行业中，杜邦线可用于实验板的引脚扩展，增加实验项目等，能够非常牢靠地和插针连接，无需焊接，便于快速进行电路试验。

杜邦线的线头有公、母两种，公杜邦线指的是尖头的杜邦线，有针脚。母杜邦线是带孔的连接线。

杜邦线的三种类型为：公公线、公母线、母母线。

硬件电路设计

物料清单（BOM 表）：

了解完面包板与杜邦线的工作原理后，我们可以先搭建一个最基础的电路。

并且我们可以使用 ESP32 开发板的 3V3 引脚或者 Vin 引脚供电与 LED 的阳极相连，阴极与电阻相连，电阻的另一端接 GND，如下图：

如果你想要同时点亮多个 LED，而我们的开发板只有两个电源引脚，这时候，我们就需要用到面包板的正负极拍针孔。

每一个 LED 的正极与面包板的正极拍针孔通过一个电阻相连，阴极接面包板负极，如下图：

不论学习什么单片机，最简单的外设莫过于 IO 口的高低电平控制 LED，本节课将向大家介绍如何使用 MicroPython 控制 ESP32 的 GPIO 输出。通过本节课的学习，让大家对 MicroPython 的程序架构有一定的认识，为以后大型项目程序学习打下基础，增强信心。

实验原理

1. GPIO 引脚

引脚又叫管脚，英文叫 Pin, 就是从集成电路（芯片以及一些电子元件）内部电路引出与外围电路的接线的接口。

在我们的 ESP32 开发板上, 我们可以把这些称为引脚, 这些引脚其实是从 ESP32 芯片内部引出来的, 我们可以看到每个引脚都标了自己独特的名字。

其中有一类引脚叫 GPIO 引脚, 负责输入/输出电压。开发板上 D 开头的引脚都是这种引脚, 比如 D2、D4、D15 等等

输入我们暂时不讲，这里我们先讲一下输出，简单来说，每个 GPIO 都可以输出高低电平。

2. LED

LED（light-emitting diode） 即发光二极管。它具有单向导电性，通过 5mA 左右电流即可发光，电流越大，其亮度越强，但若电流过大，会烧毁二极管，一般我们控制在 3mA-20mA 之间，通常我们会在 LED 管脚上串联一个电阻，目的就是为了限制通过发光二极管的电流不要太大，因此这些电阻又可以称为限流电阻。当发光二极管发光时，测量它两端电压约为 1.7V，这个电压又叫做发光二极管的导通压降。

发光二极管正极又称阳极，负极又称阴极，电流只能从阳极流向阴极。直插式发光二极管长脚为阳极，短脚为阴极。

硬件电路设计

物料清单（BOM 表）：

LED 的正极接开发板的 D12 引脚，并串联一个电阻，负极接 GND，如下图：

软件设计

1. 点亮一颗 LED

因此，如果我们想要点亮这颗 LED 的话，只需要先设定相关引脚为输出模式，然后给这个引脚赋值一个高电平即可。

// 设置 LED 引脚
int led_pin = 12;

void setup() {
  // 设定引脚为输出模式
  pinMode(led_pin, OUTPUT);
  // 点亮 LED
  digitalWrite(led_pin, HIGH);
}

void loop() {
  
}

通过 IDE 编写上述代码，然后运行，此时会看到电路中的 LED 灯被点亮了。

2. 闪烁的 LED 灯

我们已经成功点亮一颗 LED 了，接下来，可以尝试一下稍微复杂一点的逻辑，比如让这颗 LED 闪烁。

实现 LED 闪烁的原理很简单，就是在 loop 函数中使用延时函数 delay。先设置高电平，延时 X 秒，再设置低电平，延时 X 秒，之后就不断循环该语句即可。

在之前的 初识 Arduino 编程语言 中，我们学习了 loop 函数的用法，如果我们想要让灯泡一直闪烁，则需要在 loop 函数中不断改变 LED 状态。

// 设置 LED 引脚
int led_pin = 12;

void setup() {
  // 设定引脚为输出模式
  pinMode(led_pin, OUTPUT);
}

void loop() {
  // 点亮 LED
  digitalWrite(led_pin, HIGH);
  // 等待一段时间
  delay(1000);
  // 关闭 LED
  digitalWrite(led_pin, LOW);
  // 等待一段时间
  delay(1000);
}

运行程序，LED 就闪烁了。

上节课我们已经学习了如何点亮一颗 LED 并且让其闪烁，这节课我们学习如何制作流水灯。

硬件电路设计

物料清单（BOM 表）：

每一个 LED 的正极与开发板一个 GPIO 引脚相连，并串联一个电阻，负极接 GND，如下图：

当然你也可以选择只使用一个电阻：

软件程序设计

1. 正常流水灯

因为我们要用到多个 GPIO 引脚，所以，我们最好把所有的 GPIO 引脚放在一个数组中，然后遍历这个数组

// 定义 GPIO 引脚数组
int pin_list[5] = {13, 12, 14, 27, 26};
// 获取数组长度
int size = sizeof(pin_list) / sizeof(pin_list[0]);

void setup() {
  // 设定 GPIO 引脚为输出模式
  for (int i=0; i<size;i++) {
    pinMode(pin_list[i], OUTPUT);
    }
}

void loop() {
  // 将所有引脚设置为高电平
  for (int i=0;i<size;i++) {
    digitalWrite(pin_list[i], HIGH);
    delay(50);
    }
  // 将所有引脚设置为低电平
  for (int i=0;i<size;i++) {
    digitalWrite(pin_list[i], LOW);
    delay(50);
    }
}

2. 反复流水灯

我们还可以对该程序进行微调，比如之前是依次改变流水灯的状态，现在，修改为让流水灯往复亮。

// 定义 GPIO 引脚数组
int pin_list[5] = {13, 12, 14, 27, 26};
// 获取数组长度
int size = sizeof(pin_list) / sizeof(pin_list[0]);

void setup() {
  // 设定 GPIO 引脚为输出模式
  for (int i=0; i<size;i++) {
    pinMode(pin_list[i], OUTPUT);
    }
}

void loop() {
  // 将所有引脚设置为高电平
  for (int i=0;i<size;i++) {
    digitalWrite(pin_list[i], HIGH);
    delay(50);
    }
  // 将所有引脚设置为低电平
  for (int i=size-1;i>=0;i--) {
    digitalWrite(pin_list[i], LOW);
    delay(50);
    }
}

3. LED 移动

让 LED 实现平移的效果是这样实现的，每次在我点亮这颗 LED 的时候，同时把上一颗 LED 的状态改为低电平，并且当索引值为 0 时，让最后一颗 LED 状态改为低电平代码如下：

// 定义 GPIO 引脚数组
int pin_list[5] = {13, 12, 14, 27, 26};
// 获取数组长度
int size = sizeof(pin_list) / sizeof(pin_list[0]);

void setup() {
  // 设定 GPIO 引脚为输出模式
  for (int i=0; i<size;i++) {
    pinMode(pin_list[i], OUTPUT);
    }
}

void loop() {
  // 将所有引脚设置为高电平
  for (int i=0;i<size;i++) {
    digitalWrite(pin_list[i], HIGH);
    if (i > 0){
      digitalWrite(pin_list[i-1], LOW);
      }else {
      digitalWrite(pin_list[size-1], LOW);
      }
    delay(250);
    
    }
}

现阶段，无论 LCD 和 OLED 显示技术有多好，都无法替代这个古老的显示方式 - 数码管。直到现在，很多领域都离不开数码管。最主要的原因是他便宜有稳定，而且控制简单。

实验原理

数码管是一种半导体发光器件，其基本单元依然是 LED。 数码管按段数可分为七段数码管和八段数码管，八段数码管比七段数码管多一个发光二极管单元，也就是多一个小数点（DP），这个小数点可以更精确的表示数码管想要显示的内容。

按照能显示的位数可分为 1 位、2 位、3 位、4 位、5 位、6 位、7 位等数码管。

按发光二极管单元连接方式可分为共阳极数码管和共阴极数码管：

1. 共阳数码管是指将所有发光二极管的阳极接到一起形成公共阳极（COM）的数码管，共阳数码管在应用时应将公共极 COM 接到 +5V ，当某一字段发光二极管的阴极为低电平时，相应字段就点亮，当某一字段的阴极为高电平时，相应字段就不亮。
2. 共阴数码管是指将所有发光二极管的阴极接到一起形成公共阴极（COM）的数码管，共阴数码管在应用时应将公共极 COM 接到地线 GND 上，当某一字段发光二极管的阳极为高电平时，相应字段就点亮，当某一字段的阳极为低电平时，相应字段就不亮。

原理图如下：

引脚图中间的两个 COM，是公共端，共阴数码管要将其接地，共阳数码管将其接电源。a，b，c，d，e，f，g，dp 被称为段选线。

如何判断是共阴还是共阳？

如果你不清楚你的数码管到底是共阴还是共阳，可以使用下面三种方法测试。

1. 一般在数码管的侧面会标注该数码管的型号，可以在浏览器中搜索该型号，获取对应的原理图

2. 用 ESP32 单片机给面包板通电（3.3V 引脚），公共端通过一个限流电阻接电源, 用跳线连通电源和数码管的 LED 引脚，如果亮了说明是共阳型数码管；反之，说明是共阳型数码管。

3. 使用万用表的二极管档，红表笔接公共端，黑表笔接任一引脚，亮了说明是共阳型数码管，反之，则说明是共阴型数码管。

硬件电路设计

物料清单（BOM 表）：

将材料按照下图相连:

软件程序设计

设计这个程序时，我们需要使用二维数组。

如果我们想让这个数码管某一引脚亮起来，那么我们需要给对应的引脚设置一个低电平。如果我们想要显示一个数字时，就需要让多个 LED 同时亮，比如数字 1 需要 b、c 引脚给低电平，其余引脚给高电平。程序可以这样写：

// 定义输出引脚并把所有引脚存到数组中
int pin_a = 4;
int pin_b = 5;
int pin_c = 19;
int pin_d = 21;
int pin_e = 22;
int pin_f = 2;
int pin_g = 15;
int pin_dp = 18;

int pin_array[8] = {pin_a, pin_b, pin_c, pin_d, pin_e, pin_f, pin_g, pin_dp};

// 定义数字显示逻辑的二维数组
int number_array[][8] = {
    {0, 0, 0, 0, 0, 0, 1, 1}, // 0
    {1, 0, 0, 1, 1, 1, 1, 1}, // 1
    {0, 0, 1, 0, 0, 1, 0, 1}, // 2
    {0, 0, 0, 0, 1, 1, 0, 1}, // 3
    {1, 0, 0, 1, 1, 0, 0, 1}, // 4
    {0, 1, 0, 0, 1, 0, 0, 1}, // 5
    {0, 1, 0, 0, 0, 0, 0, 1}, // 6
    {0, 0, 0, 1, 1, 1, 1, 1}, // 7
    {0, 0, 0, 0, 0, 0, 0, 1}, // 8
    {0, 0, 0, 0, 1, 0, 0, 1}, // 9
};

void setup() {
  // 设置所有引脚为输出模式，初始化所有引脚为高电平
  for (int i=0;i<8;i++){
    pinMode(pin_array[i], OUTPUT);
    digitalWrite(pin_array[i], HIGH);
    }
}

void loop() {
  // 显示数字
  int num = 8;
  for (int i=0;i<8;i++){
      digitalWrite(pin_array[i], number_array[num][i]);
      }
}

我们也可以使用函数来把显示数字的逻辑代码封装起来，方便我们在其他地方使用：

// 定义输出引脚并把所有引脚存到数组中
int pin_a = 4;
int pin_b = 5;
int pin_c = 19;
int pin_d = 21;
int pin_e = 22;
int pin_f = 2;
int pin_g = 15;
int pin_dp = 18;

int pin_array[8] = {pin_a, pin_b, pin_c, pin_d, pin_e, pin_f, pin_g, pin_dp};

// 定义数字显示逻辑的二维数组
int number_array[][8] = {
    {0, 0, 0, 0, 0, 0, 1, 1}, // 0
    {1, 0, 0, 1, 1, 1, 1, 1}, // 1
    {0, 0, 1, 0, 0, 1, 0, 1}, // 2
    {0, 0, 0, 0, 1, 1, 0, 1}, // 3
    {1, 0, 0, 1, 1, 0, 0, 1}, // 4
    {0, 1, 0, 0, 1, 0, 0, 1}, // 5
    {0, 1, 0, 0, 0, 0, 0, 1}, // 6
    {0, 0, 0, 1, 1, 1, 1, 1}, // 7
    {0, 0, 0, 0, 0, 0, 0, 1}, // 8
    {0, 0, 0, 0, 1, 0, 0, 1}, // 9
};

void display_number(int num){
  // 清屏
  for (int i=0;i<8;i++){
    digitalWrite(pin_array[i], HIGH);
    }

  // 改变对应引脚的电平;
  for (int i=0;i<8;i++){
      digitalWrite(pin_array[i], number_array[num][i]);
      }
  }

void setup() {
  // 设置所有引脚为输出模式，初始化所有引脚为高电平
  for (int i=0;i<8;i++){
    pinMode(pin_array[i], OUTPUT);
    digitalWrite(pin_array[i], HIGH);
    }
}

void loop() {
  // 显示数字
  for (int i=0;i<10;i++){
    display_number(i);
    delay(500);
    }
}

实验原理

4 位数码管，即 4 个 1 位数码管并列集中在一起形成一体的数码管。

当多位数码管一体时，它们内部的公共端是独立的，而负责显示什么数字的段线（a-dp）全部是连接在一起的，独立的公共端可以控制多位一体中的哪一位数码管点亮，而连接在一起的段线可以控制这个能点亮数码管亮什么数字，通常我们把公共端叫做 位选线 ，连接在一起的段线叫做 段选线，有了这两个线后，通过单片机及外部驱动电路就可以控制任意的数码管显示任意的数字了。

4 位数码管与 1 位数码管的原理基本一致，除了引脚不同。

相同的地方是，数码管中的 LED 的分段映射相同，如下图：

有区别的地方首先是 1 位数码管有两个相同的公共（COM）端接地或者接电源，而 4 位数码管没有公共端，有四个控制不同位置显示的选通端。

一般一位数码管有 10 个引脚，四位数码管是12 个引脚，关于具体的引脚及段、位标号大家可以查询相关资料，最简单的办法就是用数字万用表测量，若没有数字万用表也可用 5V 直流电源串接1k 电阻后测量，将测量结果记录，通过统计便可绘制出引脚标号。多位数码管有许多是按一定要求设计的，引脚不完全按照一般规则设定，所以需要在使用时查找手册，最直接的办法就是按照数码管上的标示向生产商要求。

硬件电路设计

物料清单（BOM 表）：

将材料按照下图相连:

软件程序设计

我们一步一步的来，先写一个最简单的程序，让任意一位数码管显示任意数字，代码可以这么写：

// 定义位选线引脚
int seg_1 = 5;
int seg_2 = 18;
int seg_3 = 19;
int seg_4 = 21;

// 定义位选线数组
int seg_array[4] = {seg_1, seg_2, seg_3, seg_4};

// 定义段选线引脚;
int a = 32;
int b = 25;
int c = 27;
int d = 12;
int e = 13;
int f = 33;
int g = 26;
int dp = 14;

// 定义位选线引脚
int led_array[8] = {a, b, c, d, e, f, g, dp};

// 定义共阴极数码管不同数字对应的逻辑电平的二维数组
int logic_array[10][8] = {
 //a, b, c, d, e, f, g, dp
  {1, 1, 1, 1, 1, 1, 0, 0}, // 0
  {0, 1, 1, 0, 0, 0, 0, 0}, // 1
  {1, 1, 0, 1, 1, 0, 1, 0}, // 2
  {1, 1, 1, 1, 0, 0, 1, 0}, // 3
  {0, 1, 1, 0, 0, 1, 1, 0}, // 4
  {1, 0, 1, 1, 0, 1, 1, 0}, // 5
  {1, 0, 1, 1, 1, 1, 1, 0}, // 6
  {1, 1, 1, 0, 0, 0, 0, 0}, // 7
  {1, 1, 1, 1, 1, 1, 1, 0}, // 8
  {1, 1, 1, 1, 0, 1, 1, 0}, // 9
  };


// 清屏函数
void clear() {
  for (int i=0;i<4;i++) {
    digitalWrite(seg_array[i], HIGH);
    }

  for (int i=0;i<8;i++) {
    digitalWrite(led_array[i], LOW);
    }
  }

// 显示数字的函数
void display_number(int order, int number) {

  // 清屏
  clear();

  // 把对应位选线的电平拉低
  digitalWrite(seg_array[order], LOW);

  // 显示数字
  for (int i=0;i<8;i++) {
    digitalWrite(led_array[i], logic_array[number][i]);
    }
  }

void setup() {
  // 设置所有位选线引脚为输出模式，初始化所有位选线引脚为高电平
  for (int i=0;i<4;i++) {
    pinMode(seg_array[i], OUTPUT);
    digitalWrite(seg_array[i], HIGH);
    }
    
  // 设置所有段选线引脚为输出模式，初始化所有段选线引脚为低电平
  for (int i=0;i<8;i++) {
    pinMode(led_array[i], OUTPUT);
    digitalWrite(led_array[i], LOW);
    }
}

void loop() {
  // 第三位显示数字 3
  // display_number(2, 3);
  
  // 按顺序让所有位置显示 0~9
  for (int i=0;i<4;i++) {
    for (int j=0;j<10;j++) {
      display_number(i, j);
      delay(200);
      }
    }
}

我们选择多位数码管，肯定是要在不同位置显示不同数字的，这时候，我们需要用到 动态扫描。

我们可以通过运行下面这段代码，更生动形象地理解 动态扫描 的原理:

/*
  该程序的作用是演示动态扫描原理。
  在线文档：https://docs.geeksman.com/esp32/Arduino/08.esp32-arduino-4-digits-7segment.html
*/


// 定义位选线引脚
int seg_1 = 5;
int seg_2 = 18;
int seg_3 = 19;
int seg_4 = 21;

// 定义位选线数组
int seg_array[4] = {seg_1, seg_2, seg_3, seg_4};

// 定义段选线引脚;
int a = 32;
int b = 25;
int c = 27;
int d = 12;
int e = 13;
int f = 33;
int g = 26;
int dp = 14;

// 定义位选线引脚
int led_array[8] = {a, b, c, d, e, f, g, dp};

// 定义共阴极数码管不同数字对应的逻辑电平的二维数组
int logic_array[10][8] = {
 //a, b, c, d, e, f, g, dp
  {1, 1, 1, 1, 1, 1, 0, 0}, // 0
  {0, 1, 1, 0, 0, 0, 0, 0}, // 1
  {1, 1, 0, 1, 1, 0, 1, 0}, // 2
  {1, 1, 1, 1, 0, 0, 1, 0}, // 3
  {0, 1, 1, 0, 0, 1, 1, 0}, // 4
  {1, 0, 1, 1, 0, 1, 1, 0}, // 5
  {1, 0, 1, 1, 1, 1, 1, 0}, // 6
  {1, 1, 1, 0, 0, 0, 0, 0}, // 7
  {1, 1, 1, 1, 1, 1, 1, 0}, // 8
  {1, 1, 1, 1, 0, 1, 1, 0}, // 9
  };

// 延时时间
int count = 355;


// 清屏函数
void clear() {
  for (int i=0;i<4;i++) {
    digitalWrite(seg_array[i], HIGH);
    }

  for (int i=0;i<8;i++) {
    digitalWrite(led_array[i], LOW);
    }
  }

// 显示数字的函数
void display_number(int order, int number) {

  // 清屏
  clear();

  // 把对应位选线的电平拉低
  digitalWrite(seg_array[order], LOW);

  // 显示数字
  for (int i=0;i<8;i++) {
    digitalWrite(led_array[i], logic_array[number][i]);
    }
  }

void setup() {
  // 设置所有位选线引脚为输出模式，初始化所有位选线引脚为高电平
  for (int i=0;i<4;i++) {
    pinMode(seg_array[i], OUTPUT);
    digitalWrite(seg_array[i], HIGH);
    }
    
  // 设置所有段选线引脚为输出模式，初始化所有段选线引脚为低电平
  for (int i=0;i<8;i++) {
    pinMode(led_array[i], OUTPUT);
    digitalWrite(led_array[i], LOW);
    }
}

void loop() {
  display_number(0, 1);
  delay(count);

  display_number(1, 2);
  delay(count);

  display_number(2, 3);
  delay(count);

  display_number(3, 4);
  delay(count);

  if (count > 10) {
    if (count > 110) {
      count -= 50;
    }else {
      count -= 10;  
    }
    }
}

理解了 动态扫描 的原理之后，我们就可以写代码了，先把之前写的这些代码复制过来，然后我们还需要实现通过动态扫描的方法实现 4 位数字显示的功能：

// 4 位数码管显示函数
void display_4_number(int number) {
  // 把输入的数字格式化为 4 位数的数组
  if (number < 10000) {
    // 获取每一位对应的数字
//    // 获取个位
//    int seg_4_number = number % 10;
//    number /= 10;
//
//    // 获取十位
//    int seg_3_number = number % 10;
//    number /= 10;
//
//    // 获取百位
//    int seg_2_number = number % 10;
//    number /= 10;
//
//    // 获取千位
//    int seg_1_number = number % 10;

    // 定义格式化数组
    int number_array[4];

    // 使用循环获取格式化数组
    for (int i=3;i>=0;i--) {
      number_array[i] = number % 10;
      number /= 10;
      }
      
    // 显示数字
    for (int i=0;i<4;i++) {
      display_number(i, number_array[i]);
      delay(5);
      }
    }
}

这样，我们就能通过在 loop 函数中调用 display_4_number 函数，来显示数字内容了。

前面几节课介绍的都是 IO 口输出的使用，本节课我们通过按键实验来介绍 IO 口作为输入的使用并通过按键电路实现开关灯的效果。

实验原理

按键是一种电子开关，使用时轻轻按开关按钮就可使开关接通，当松开手时，开关断开。

按钮有两组引脚（触点）。当按下按钮时，它会连接这两个触点，从而关闭电路。

一般来说 4 脚开关（轻触按键）相距较远的是相通的，离得较近的是一组开关，最好是测量一下，如果懒得测，接对角肯定是可以的。

下图说明了按钮内部的连接：

使用按键的时候，通常情况下需要进行消抖。

按键的抖动对于人类来说是感觉不到的，但对单片机来说，则是完全可以感应到的，而且还是一个很漫长的过程，因为单片机处理的速度在微秒级，而按键抖动的时间至少在毫秒级。

一次按键动作的电平波形如下图。存在抖动现象，其前后沿抖动时间一般在 5ms~10ms 之间。由于单片机运行速度非常快，刚按下的时候会检测到低电平判断按键被按下。但是由于按键存在抖动，单片机在此时也会检测到高电平，误以为松开按键，紧接着又检测到低电平，判断到按键被按下。周而复始，在 5-10ms 内可能会出现很多次按下的动作，每一次按键的动作判断的次数都不相同。

这种抖动可能会影响程序误判，造成严重后果，一般我们采用两种方式对按键进行消抖：

1. 硬件消抖，硬件消抖的典型做法是：采用 R-S 触发器或 RC 积分电路。
2. 软件消抖，通常我们会使用软件延时 10ms 来消抖。例如，当按键按下后，引脚为低电平；所以首先读取引脚电平，若引脚为低电平，则延时 10ms 后再次读取引脚电平，若为低电平，则证明按键已按下。

硬件方法一般用在对按键操作过程比较严格，且按键数量较少的场合，而按键数量较多时，通常采用软件消抖。值得一提的是，对于复杂且多任务的单片机系统来说，若简单地采用循环指令来实现软件延时，则会浪费CPU宝贵的时间资源，大大降低系统的实时性，所以，更好的做法是利用定时中断服务程序或利用标志位的方法来实现软件消抖。

硬件电路设计

使用按键电路实现开关灯的效果。

物料清单（BOM 表）：

将材料按照下图相连:

按键一端接 3V3 引脚，一端接 D14，LED 接 D2。

软件程序设计

这里我们在使用 pinMode 方法的时候，第二个参数就不能传递 OUTPUT 了，并且我们需要使用 digitalRead 方法来获取输入值。

与输出不同的是，设置输入引脚时，我们需要配置上拉或下拉电阻，目的是确定某个状态电路中的高电平或低电平。

上、下拉电阻的作用是提高电路稳定性，避免引起误动作。按键如果不通过电阻上拉到高电平，那么在上电瞬间可能就发生误动作，因为在上电瞬间单片机的引脚电平是不确定的，上拉电阻的存在保证了其引脚处于高电平状态，而不会发生误动作。

在 Arduino 中，设置引脚的上拉电阻或下拉电阻需要使用 pinMode 函数和 INPUT_PULLUP 或 INPUT_PULLDOWN 常量。

如果要设置引脚为上拉电阻，需要将引脚设置为输入模式，并调用 pinMode(pin, INPUT_PULLUP) 函数，其中 pin 为引脚号。

因此，我们的代码需要这么写：

// 定义 LED 与 按键引脚
int led_pin = 2;
int button_pin = 14;

// 定义 LED 逻辑值
int led_logic = 0;
// 判断 LED 的状态是否改变过
bool status = false;


void setup() {  
  pinMode(led_pin, OUTPUT);
  pinMode(button_pin, INPUT_PULLDOWN);
}

void loop() {
  // 按键消抖
  if (digitalRead(button_pin)) {
    // 睡眠 10ms，如果依然为高电平，说明抖动已消失。
    delay(10);
    if (digitalRead(button_pin) && !status) {
      led_logic = !led_logic;
      digitalWrite(led_pin, led_logic);
      // led 的状态发生了变化，即使我持续按着按键，LED 的状态也不应该改变。
      status = !status;
      }else if (!digitalRead(button_pin)) {
        status = false;  
      }
    }
}

我们也可以不在 setup 前定义变量，而是选择 宏定义 的方法。

在 Arduino 中，宏定义是一种预处理器指令，它被用于创建常量和替代符号。通过使用宏定义，可以让代码更易读，更易于维护和修改，同时也可以避免在代码中出现重复的代码块。

宏定义以 #define 关键字开头，后面跟着宏名称和宏值。宏值可以是数字、字符或者表达式。一旦定义了宏，它将会被整个程序使用。

例如，下面的代码创建了一个宏定义 LED_PIN，将其值设置为 13：

#define LED_PIN 13

然后，在程序中可以使用宏定义来指定要使用的引脚，而不是写出具体的数字，从而使代码更具可读性：

#define LED_PIN     2
#define BUTTON_PIN  14


// 定义 LED 逻辑值
int led_logic = 0;
// 判断 LED 的状态是否改变过
bool status = false;


void setup() {  
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLDOWN);
}

void loop() {
  // 按键消抖
  if (digitalRead(BUTTON_PIN)) {
    // 睡眠 10ms，如果依然为高电平，说明抖动已消失。
    delay(10);
    if (digitalRead(BUTTON_PIN) && !status) {
      led_logic = !led_logic;
      digitalWrite(LED_PIN, led_logic);
      // led 的状态发生了变化，即使我持续按着按键，LED 的状态也不应该改变。
      status = !status;
      }else if (!digitalRead(BUTTON_PIN)) {
        status = false;  
      }
    }
}

宏定义和变量定义都是定义标识符的方式，但二者有以下区别：

• 宏定义在预处理时进行处理，而变量定义在编译时进行处理。宏定义是一种文本替换机制，会在编译前被展开为其定义的文本，而变量则需要在编译时分配内存空间；
• 宏定义的作用域是从定义到文件结束，而变量定义的作用域则是在定义处到包含该定义的代码块结束；
• 宏定义可以定义函数或代码块，而变量定义只能定义变量；
• 宏定义不会占用内存空间，而变量需要分配内存空间；
• 宏定义不需要类型声明，而变量定义需要类型声明。

总之，宏定义主要是一种代码替换的机制，能够提高代码的可读性和可维护性，而变量定义则是用于在程序中存储和管理数据的标识符。

之前我们使用的 LED 做过流水灯的实验，这节课，我们学习制作呼吸灯，通过 LED 灯的亮度变化来验证 PWM 不同电压的输出。呼吸灯是指灯光在单片机的控制之下完成由亮到暗的逐渐变化，感觉好像是人在呼吸。

实验原理

脉冲宽度调制（PWM），是英文 Pulse Width Modulation 的缩写，简称脉宽调制，是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术，广泛应用在测量、通信到功率控制与变换的许多领域中。

PWM 通过调节输出不同频率（频率是指 1 秒钟内信号从高电平到低电平再回到高电平的次数（一个周期））、占空比（一个周期内高电平出现时间占总时间比例）的方波。以实现固定频率或平均电压输出。频率固定，改变占空比可改变输出电压，如下所示：

硬件电路设计

物料清单（BOM 表）：

LED 的正极接开发板的 D12 引脚，并串联一个电阻，负极接 GND，如下图：

软件程序设计

1. analogWrite() 函数实现呼吸灯效果

想要通过 Arduino 输出 PWM 有两种方法，第一种就是使用 Arduino 自带的 analogWrite(pin, value) 函数，其中的两个参数：

• pin：要写入的 Arduino 引脚。允许的数据类型：int.
• value：占空比：介于 0（始终关闭）和 255（始终开启）之间。允许的数据类型：int.

，代码如下：

// 宏定义 GPIO 输出引脚
#define LED_PIN   12

void setup() {
  // 配置 GPIO 输出引脚
  pinMode(LED_PIN, OUTPUT);

}

void loop() {
  // 实现渐亮效果
  for(int i=0;i<256;i++) {
    // 设置亮度模拟值
    analogWrite(LED_PIN, i);
    // 延时 10ms
    delay(10);
    }
  // 实现渐灭效果
  for(int i=255;i>=0;i--) {
    // 设置亮度模拟值
    analogWrite(LED_PIN, i);
    // 延时 10ms
    delay(10);
    }
}

2. LEDC 输出 PWM 信号

第二种是使用 ESP32 的 LEDC 外设，在 ESP32 上有一个 LEDC 外设模块专用于输出 PWM 波形。

LED PWM 控制器可以生成 16 路通道（0 ~ 15），波形的周期和占空比可配置。分为高低速两组，高速通道（0 ~ 7）由 80MHz 时钟驱动，低速通道（8 ~ 15）由 1MHz 时钟驱动。另外，每路 LED PWM 支持自动步进式地增加或减少占空比，可以用于 LED RGB 彩色梯度发生器。

作为刚入门的学习者，上面这段概念不理解也不影响我们后续的学习，我们需要了解的是 LEDC 的控制函数以及 PWM 信号的产生流程。

打开 esp32_hal_led.h 文件之后，我们可以看到 LEDC 的所有控制函数：

// 设置 LEDC 通道对应的频率和计数位数（占空比分辨率），返回最终频率
// 分辨率的意思就是把一个周期分成 2 的 resolution_bits 份。
uint32_t    ledcSetup(uint8_t channel, uint32_t freq, uint8_t resolution_bits);

// 指定通道输出一定占空比波形
void        ledcWrite(uint8_t channel, uint32_t duty);

// 类似于 arduino 的 tone ，当外接无源蜂鸣器的时候可以发出某个声音（根据频率不同而不同）
uint32_t    ledcWriteTone(uint8_t channel, uint32_t freq);

//  该方法是上面方法的进一步封装，可以直接输出指定调式和音阶声音的信号
uint32_t    ledcWriteNote(uint8_t channel, note_t note, uint8_t octave);

// 返回指定通道占空比的值
uint32_t    ledcRead(uint8_t channel);

// 返回指定通道当前频率（如果当前占空比为0 则该方法返回0）
uint32_t    ledcReadFreq(uint8_t channel);

// 将 LEDC 通道绑定到指定 IO 口上以实现输出
void        ledcAttachPin(uint8_t pin, uint8_t channel);

// 解除 IO 口的 LEDC 功能
void        ledcDetachPin(uint8_t pin);

使用 LEDC 外设的时候需要遵循以下步骤：

1. 使用 ledcSetup() 函数建立 LEDC 通道；
2. 通过 ledcAttachPin() 将 GPIO 口与 LEDC 通道关联；
3. 通过 ledcWrite()、ledcWriteTone()、ledcWriteNote()设置频率、设置蜂鸣器音调等等
4. 通过 ledcDetachPin() 解除 GPIO 口与 LEDC 通道的关联

所有我们可以通过以下代码，实现呼吸灯效果：

#define FREQ        2000    // 频率
#define CHANNEL     0       // 通道
#define RESOLUTION  8       // 分辨率
#define LED         12      // LED 引脚


void setup()
{
  ledcSetup(CHANNEL, FREQ, RESOLUTION); // 设置通道
  ledcAttachPin(LED, CHANNEL);          // 将通道与对应的引脚连接
}

void loop()
{
  // 逐渐变亮
  for (int i=0;i<pow(2, RESOLUTION); i++)
  {
    ledcWrite(CHANNEL, i); // 输出PWM
    delay(5);
  }

  // 逐渐变暗
  for (int i=pow(2, RESOLUTION)-1;i>=0;i--)
  {
    ledcWrite(CHANNEL, i); // 输出PWM
    delay(5);
  }
}

前面我们介绍使用 PWM 输出不同电压值，类似于模拟信号输出。如果需要 ESP32 检测外部输入的模拟信号该怎么办？这就是本节课要学习的 ADC，通过 ADC 将模拟信号转换为数字信号给 ESP32 处理。

实验原理

在学习 ADC 之前，我们要首先学习什么是模拟信号，什么是数字信号。

模拟信号（Analog Signal）：模拟信号是连续变化的量或者信号，生活中接触到的信号基本都是模拟信号，温度变化，天体运动等等，这些都是连续的信息，都是模拟信号。模拟信号，简单的说就是用电信号模拟出其他的信号，比如用电信号模拟出图像，模拟出声音的声波。

数字信号（Digital Signal）：数字信号是时间离散、数值离散的信号，数字信号存在采样，还存在量化，只能取到一些不连续的固定值，这也是数字信号和模拟信号之间可以进行相互转换的原因。

所以，总结就是模拟信号时间连续，幅值连续，数字信号时间离散，幅值离散。模拟电路就是使用、处理模拟信号的电路；数字电路就是使用、处理数字信号的电路。

我们举个简单的例子：

1. 指针时钟显示的就是时间的模拟信号，他表示时间是连续变化的，
2. 数字时钟显示的就是时间的数字信号，时间的显示是按照固定增量变化的，他可以显示 1、2、3，但是无法显示 1.1、2.1、等，所以在数字电路中使用的数字信号一般只能取 0 或 1，把 0 对应为低电平，把 1 对应为高电平，说白了就是有或者没有

数字信号是在模拟信号的基础上依次经过 采样、量化、编码而形成的。具体地说，采样 就是把输入的模拟信号按适当的时间间隔得到各个时刻的样本值；量化 是把经采样测得的各个时刻的值用二进制码来表示；编码 则是把量化生成的二进制数排列在一起形成顺序脉冲序列。

ADC（Analog to Digital Converter）即模数转换器，它可以将模拟信号转换为数字信号。由于单片机只能识别二进制数字，所以外界模拟信号常常会通过 ADC 转换成其可以识别的数字信号。常见的应用就是将变化的电压转成数字信号。

硬件电路设计

物料清单（BOM 表）：

电位器相当于一个滑动变阻器，两端引脚阻值是固定的，中间引脚对任何一端的引脚阻值是可变的，他等效于从中间把电位器分成两个串联的电阻，串联总阻值是确定的，一端接输入电源，一端接地

软件程序设计

1. 在串口监视器显示 analogRead() 模拟输入

我们可以先在串口监视器中，打印一下读取到的 analogRead() 的值，这里需要使用到 Arduino 内置的串口函数：

• Serial.begin()：设置通信波特率，一般使用 9600，这样就可以在串口监视器中直接打印出来内容；
• Serial.println()：在串口屏中打印内容。

因此，我们的代码可以这么写：

#define POT 26

 
// 初始化电位计输入信号
int pot_value;

 
void setup() {
    // 设置串口通信波特率 9600
    Serial.begin(9600);
    pinMode(POT, INPUT);
}
 
void loop() {
    // 读取电位计模拟输入值
    pot_value = analogRead(POT);
    // 打印模拟值在串口屏上
    Serial.println(pot_value);
    delay(50);
}

2. 使用 analogRead() 调节 LED 亮度

我们可以使用 analogRead() 来读取电位计传入的模拟值，范围是在 0 ~ 4095，而我们想要输入 analogWrite() 的参数范围是在 0 ~ 255，因此，我们还需要把读取到的模拟值范围转换成输出范围，代码如下：

#define POT 26
#define LED 13
 
// variable for storing the potentiometer value
int pot_value;
int led_value;
 
void setup() {
    Serial.begin(9600);
    pinMode(POT, INPUT);
    pinMode(LED, OUTPUT);
}
 
void loop() {
    // 读取电位计模拟输入值
    pot_value = analogRead(POT);
    // 把电位计模拟输入值转换为 LED 的模拟输出值。
    led_value = pot_value / 16;
    analogWrite(LED, led_value);
    delay(50);
}

3. 使用 ADC 模拟通道输入

打开 esp32_hal_adc.h 文件之后，我们可以看到 ADC 的所有控制函数：

• analogReadResolution(resolution)：设置样本位和分辨率。它可以是一个介于 9(0 - 511)和 12 位(0 - 4095)之间的值。默认是 12 位分辨率。
• analogSetWidth(width)：设置样本位和分辨率。它可以是一个介于 9(0 - 511)和 12 位(0 - 4095)之间的值。默认是 12 位分辨率。
• analogSetCycles(cycles)：设置每个样本的循环次数。默认是 8。取值范围：1 ~ 255。
• analogSetSamples(samples)：设置范围内的样本数量。默认为 1 个样本。它有增加灵敏度的作用。
• analogSetClockDiv(attenuation)：设置ADC时钟的分压器。默认值为1。取值范围:1 ~ 255。
• adcAttachPin(pin)：附加一个引脚到 ADC(也清除任何其他模拟模式可能是 on)。返回TRUE或FALSE结果。
• analogSetAttenuation(attenuation)：设置所有 ADC 引脚的输入衰减。默认是 ADC_11db。其他取值:
  1. ADC_0db: 集没有衰减。ADC 可以测量大约 800mv (1V 输入 = ADC 读数 1088)。
  2. ADC_2_5db: ADC 的输入电压将被衰减，扩展测量范围至约。1100 mV。(1V 输入 = ADC 读数 3722)。
  3. ADC_6db: ADC 的输入电压将被衰减，扩展测量范围至约。1350 mV。(1V 输入= ADC 读数 3033)。
  4. ADC_11db: ADC 的输入电压将被衰减，扩展测量范围至约。2600 mV。(1V 输入= ADC 读数 1575)。
• analogSetPinAttenuation(pin, attenuation)：设置指定引脚的输入衰减。默认是 ADC_11db。衰减值与前一个函数相同。

因此，代码可以这么写：

#define POT       26
#define LED       13
#define CHANNEL   0


// 初始化模拟输入值
int pot_value;

 
void setup() {
  Serial.begin(9600);
  // 设置 ADC 分辨率
  analogReadResolution(12);
  // 配置衰减器
  analogSetAttenuation(ADC_11db);
  // 建立 LEDC 通道，配置 LEDC 分辨率
  ledcSetup(CHANNEL, 1000, 12);
  // 关联 GPIO 口与 LEDC 通道
  ledcAttachPin(LED, CHANNEL);
}


void loop() {
  // 获取模拟输入值
  pot_value = analogRead(POT);
  // 输出 PWM
  ledcWrite(CHANNEL, pot_value);
  delay(50);
}

上一课介绍了如何使用四位数码管模块来显示数字，本课将进一步介绍如何使用基于 IIC 接口驱动的 LCD1602 液晶屏。

在前面章节，我们已经学习过两种显示装置，数码管和 4 位数码管。使用它们可以直观显示一些字符数据，但是它们也有各种局限性，比如显示字符数据太少，硬件设计复杂、代码编写难度大等。这一章就来介绍一种非常简单且常用的显示装置--LCD1602 液晶显示器，使用它可以显示更多的字符数字。

实验原理

1. LCD1602 液晶屏

LCD1602 是很多单片机爱好者较早接触的字符型液晶显示器，所以，在这里花点时间是值得的。

1602 液晶屏的称呼来自于其显示的内容容量，其中的 16 代表每行的字符（数字或英文字符）数，02 代表屏幕一共两行，实际开发中根据需要显示信息的内容多少不但可以选用 1602 屏，还可以选用诸如 2004 屏等。如下图：

1602 液晶显示屏除了电源、地以外，有 3 个控制引脚 RS R/W E 和 8 个数据引脚 DB0-7。

2. 认识 IIC（I2C）接口

由于 1602 的管脚数过多，如果直接与 ESP32 开发板连接需要占用大量的 GPIO 管脚，不但容易造成资源浪费，连接也非常不方便。

因此实际使用时往往会给 1602 屏增加一块 IIC 驱动版，将 1602 的 16 个管脚连接到由 PCF8574T 作为主要芯片的驱动版上，将接口转换为 IIC 再连接开发板，具体情况如上图所示。

IIC 是一种硬件设备间常用的接口通讯协议，全称是 Inter-Integrated Circuit，也可以写为 I2C。他的设计时的理念是：信号线尽量少并且速率要尽量高。 信号线少，可以减少引脚占用，这对早期的芯片（引脚很少）的很重要。

使用 IIC 接口时一共需要连接四根线，包括：VCC、GND、SDA、SCL，其中 SDA 和 SCL 需要占用 GPIO 管脚，连接到开发板上任何一组 IIC 接口的对应管脚都可以。

标准的 I2C 需要两根信号线：

• SCL（Serial Clock）：时钟线，时钟都是有 master 提供的
• SDA（Serial Data）：双向数据线，发数据或者收数据（收发不能同时）

简单来说，只需要 2 根线，就可以对多台设备传输大量数据，减少单片机上 IO 口的占用。

硬件电路设计

物料清单（BOM 表）：

将材料按照下图相连:

这里连接的这两个引脚可不是随便连接的，而是对应了 ESP32 芯片原理图，ESP32 的 I2C 引脚的 SDA 对应 D21，SCL 对应 D22，如图：

软件程序设计

在 Arduino 中使用 I2C 控制 LCD1602 需要下载第三方代码 LiquidCrystal_I2C，其中包括 LiquidCrystal_I2C.h 和 LiquidCrystal_I2C.cpp 两个文件，我们只需要把这两个文件放在项目的文件夹中即可。

Arduino 项目的创建非常简单，就是打开 Arduino IDE 后保存，它会在你选择的位置新建一个文件夹，这就是项目的文件夹。

.h 与 .cpp 文件到底是什么？在 Arduino 开发中，.h 和 .cpp 文件同样是用于代码组织和模块化的文件类型，但在 Arduino 环境中有些特殊的用法和约定。

1. .h 文件（头文件）：在 Arduino 中，头文件通常包含库、类、函数和变量的声明。头文件的目的是为了让多个源代码文件可以共享相同的声明，以便在程序中使用这些声明而无需重复编写。头文件通常使用预处理器指令 #include 引入到源文件中。在 Arduino 库中，.h 文件中通常包含类的声明、常量定义、函数原型等。

2. .cpp 文件（源文件）：在 Arduino 中，.cpp 文件是用于存放函数和类的实现代码的文件。.cpp 文件中包含了类成员函数的具体实现和其他函数的定义。通常，Arduino 项目中的 .cpp 文件中会包含 .h 文件，以便使用其中的声明。

需要注意的是，Arduino 开发中的 .h 和 .cpp 文件的约定与传统的 C++ 开发并不完全相同。Arduino IDE 会在编译过程中将 .ino 文件转换为 .cpp 文件，并将其中的代码放置在全局范围。因此，在 Arduino 项目中，.ino 文件也可以包含全局变量和函数，而不仅限于 .cpp 文件。

总结起来，.h 文件是用于声明库、类、函数和变量的头文件，而 .cpp 文件是用于实现函数和类的源文件。这样的组织方式有助于提高代码的可读性、可维护性和重用性。

接着，我们就可以了解 LiquidCrystal_I2C 库的使用：

1. LiquidCrystal_I2C(uint8_t addr, uint8_t cols, uint8_t rows)：构造函数，用于构造 LCD I2C 对象，参数：addr 是地址，默认的是 0x27，cols 是 LCD 显示的列数，rows 是 LCD 显示的函数；
2. void init()：初始化显示屏；
3. void clear()：清除 LCD 屏幕上内容，并将光标置于左上角；
4. void home()：将光标在定位在屏幕左上角；
5. void noBacklight() 与 void backlight()：是否开启背光；
6. print()：显示内容；
7. void leftToRight() 与 void rightToLeft()：控制文字显示的方向，默认是从左向右；
8. void noDisplay() 与 void display()：关闭显示或恢复显示（内容不会丢失）；
9. void setCursor(uint8_t col, uint8_t row)：设置光标的位置，列，行，基于 0；
10. void noCursor() 与 void cursor：显示与不显示光标，默认不显示；
11. void noBlink() 与 void blink()：光标是否闪烁，默认不闪烁。

现在，我们就可以写代码了。

1. 在屏幕上显示 Hello，world

了解了第三方库之后，我们先写一个最简单的程序，比如，在屏幕上显示 Hello, world，代码如下：

#include "LiquidCrystal_I2C.h"


// 设置 LCD1602 的地址，列数，行数
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup()
{
  // 初始化 LCD 对象
  lcd.init();
 
  // 打印内容
  lcd.backlight();
  lcd.print("Hello, world!");
}

void loop()
{
}

2. 读取串口输入内容

在这个程序中，我们需要用到串口的另外两个方法 Serial.available() 与 Serial.read():

1. Serial.available()：返回串口缓冲区中当前剩余的字符个数。一般用这个函数来判断串口的缓冲区有无数据，当 Serial.available()>0 时，说明串口接收到了数据，可以读取；
2. Serial.read() 指从串口的缓冲区取出并读取一个 Byte 的数据，比如有设备通过串口向 Arduino 发送数据了，我们就可以用 Serial.read() 来读取发送的数据。

#include "LiquidCrystal_I2C.h"


// 设置 LCD1602 的地址，列数，行数
LiquidCrystal_I2C lcd(0x27,16,2);  

void setup()
{
  // 初始化 LCD 对象
  lcd.init(); 
  // 开启背光
  lcd.backlight();
  // 开启串口通信
  Serial.begin(9600);
}

void loop()
{
  // 检测是否有串口输入
  if (Serial.available()) {
    // 延时以等待所有数据传输完成
    delay(100);
    // 清屏
    lcd.clear();
    // 反复读取串口的数据并在 LCD1602 屏幕上显示，直到数据读完
    while (Serial.available() > 0) {
      lcd.write(Serial.read());
    }
  }
}

我们已经学会了 Arduino IDE 的基本使用了，这节课，我们来学习使用另一款软件进行 Arduino 开发，他就是 PlatformIO。

PlatformIO 是一个开源的跨平台的物联网（IoT）开发平台，用于嵌入式系统和物联网设备的开发。它提供了一个统一的开发环境和工具链，支持多种硬件平台（如 Arduino、ESP8266、ESP32、Raspberry Pi 等）和开发框架（如 Arduino 框架、ESP-IDF、STM32Cube等），使开发者可以更轻松地进行嵌入式开发。

PlatformIO 的主要特点和优势包括：

1. 跨平台支持：可以在 Windows、Mac 和 Linux 等操作系统上运行，并支持多种开发板和处理器架构。
2. 统一的开发环境：提供了集成开发环境（IDE）插件，如 VS Code、Clion 等，使开发者可以在一个统一的界面中进行代码编辑、编译、调试和上传。
3. 库管理和依赖管理：内置了强大的库管理器，可以方便地搜索、安装和更新开源库，同时支持管理项目的依赖关系。
4. 丰富的功能：支持代码自动完成、语法检查、固件升级、调试器、单元测试等功能，提供了全面的开发工具和功能。
5. 强大的扩展性：可以通过插件系统扩展功能，支持自定义构建脚本、添加新的开发板和框架等。
6. 社区支持：PlatformIO 拥有活跃的社区，开发者可以在社区中获取技术支持、交流经验和分享项目。

使用 PlatformIO 可以简化嵌入式开发的流程，提高开发效率，并使项目更易于管理和维护。无论是初学者还是有经验的嵌入式开发者，都可以受益于 PlatformIO 提供的功能和工具。

PlatformIO 只是一个插件，因此，我们需要先选择一个 IDE，在 IDE 中安装 PlatformIO 插件，这里我推荐一下两种：VSCode 与 Clion。具体该怎么选择呢？

1. 如果你是经验丰富的程序员或者重度依赖 JetBrains 系列开发工具，建议使用 Clion；
2. 如果你是初学者，且对 C/C++ 语言的认识仅停留在学习阶段，没有实战经验或商业项目，建议选择 VSCode，而且 VSCode 是免费。

为了照顾初学者，本套教程，使用 VSCode 安装 PlatformIO。

1. 安装 VSCode

前往 VSCode 官网 ，建议下载 System Installer 版本的安装包，该版本安装在非用户目录，例如 C 盘根目录。

下载完毕后进行安装，安装时建议按如下进行勾选。

安装完毕后打开软件，安装中文插件。

2. 安装 PlatformIO 插件

在 VSCode 中根据下图步骤安装 PlatformIO IDE 插件。

插件安装完毕后，VSCode 右下角会出现 PlatformIO 的下载进程，等待其下载完毕后即可。由于 PlatformIO 的服务器在国外，下载速度特别慢，耐心等待即可。

下载完毕后，PlatformIO 只下载了公共的数据包，没有下载特定板子的数据包，因此如需使用他人的工程，需依照该工程所用芯片新建一个工程，在第一次新建工程时，PlatformIO 会下载好该工程所需的文件。

假设需运行的工程所使用的芯片为 ESP32，使用的框架为 arduino，那么在第一次运行该工程前需先按照如下步骤新建一次工程，只有第一次需要，后续就可以直接运行了。

点击 VSCode 左下角的桌面图标。

点击 New Project，即可创建新项目。

设置项目的名称，选择开发板型号，开发框架以及项目路径。

点击 Finish 后，需要较长的一段时间，此阶段 PlatformIO 会下载该工程所需的文件，新建完成后，即可关闭此工程（直接关闭 VSCode 软件）。接着打开我们所需运行的工程即可（在工程路径下，鼠标右键后，选择通过 Code 打开）。

左下角的图标含义如图。

3. 如何使用 PlatformIO

当使用 PlatformIO 创建 ESP32 Arduino 项目时，项目目录的结构通常如下所示：

1. .pio：该文件夹是 PlatformIO 的工作目录，包含编译生成的二进制文件、日志文件等。
2. .vscode：如果你在 VSCode 中使用 PlatformIO 插件，该文件夹包含了与项目相关的配置文件，如任务配置、调试配置等。
3. include：存放头文件。
4. lib：该文件夹用于存放项目依赖的库文件。你可以通过 PlatformIO 的库管理器安装所需的库，并它们会自动下载到该文件夹。
5. src：该文件夹是存放源代码的主目录。你的主要代码文件（通常是.cpp和.h文件）应放在这个目录下。
6. test：用于存放项目的测试代码和测试数据。这个目录通常用于编写单元测试或集成测试的代码，用于验证项目的功能和逻辑是否正确。
7. .gitignore：如果你使用版本控制系统如Git进行项目管理，你可以在这个文件中指定需要忽略的文件和文件夹。
8. platformio.ini：这是 PlatformIO 的配置文件，用于指定项目的配置选项，如目标硬件平台、编译选项、上传设置等。

在 PlatformIO 创建的项目中，lib 和 include 目录都是用于存放代码文件的特定目录。它们的区别如下：

• lib 目录：用于存放项目的依赖库文件。在这个目录下，可以放置项目需要引用的第三方库或自己编写的库。这些库文件通常是以源代码的形式提供，可以是单个文件或多个文件的集合。在构建过程中，这些库文件会被编译并链接到项目中。
• include 目录：用于存放项目的头文件。头文件包含了函数、类、变量的声明，供其他源文件在编译时引用。在这个目录下，可以放置项目自定义的头文件，或者是一些需要被其他文件引用的第三方库的头文件。在编译过程中，编译器会在该目录下查找所需的头文件。

总结一下，lib 目录主要用于存放项目的依赖库文件，而 include 目录用于存放项目的头文件。这样的组织结构可以方便地管理项目所需的库文件和头文件，并在构建过程中正确引用和链接它们。

主要的代码，我们可以写在 main.cpp 中，src 目录下的 main.cpp 文件基本等同于 Arduino IDE 中创建的 .ino 文件。

只不过，在 main.cpp 文件的第一行需要 #include <Arduino.h>，其余的代码部分内容一致，我们可以直接把上节课读取串口输入的代码复制过来，但是不要忘了 #include <Arduino.h>。

#include <Arduino.h>
#include <LiquidCrystal_I2C.h>


LiquidCrystal_I2C lcd(0x27, 16, 2); // set the LCD address to 0x27 for a 16 chars and 2 line display

void setup()
{
  lcd.init(); // initialize the lcd
  lcd.backlight();
  Serial.begin(9600);
}

void loop()
{
  // when characters arrive over the serial port...
  if (Serial.available())
  {
    // wait a bit for the entire message to arrive
    delay(100);
    // clear the screen
    lcd.clear();
    // read all the available characters
    while (Serial.available() > 0)
    {
      // display each character to the LCD
      lcd.write(Serial.read());
    }
  }
}

想要运行该程序，可以点击左下角的或者右上角的上传选项，或者使用快捷键 ctrl + alt + u

这时候，我们还没有导入 LiquidCrystal_I2C 库，所以，代码会运行失败，想要在 PlatformIO 中导入第三方库比 Arduino IDE 方便的多，我们可以打开 PlatformIO Home 页面，点击 libraries，输入我们想要导入的库名称，添加到项目中即可。

PlatformIO 还会非常贴心的给你一个使用示例，

所以，如果你想要使用 ESP32 在 Arduino 框架下实现一个稍微复杂一点的项目的话，Platform 是你最佳的选择。

这一节我们学习如何使用 ESP32 开发板，通过 SPI 控制 OLED 液晶屏。

实验原理

1. SPI

SPI（Serial Peripheral Interface） 协议是由摩托罗拉公司提出的通讯协议，即串行外围设备接口，是一种同步、全双工、主从式接口，但并不是所有的 SPI 都是全双工。来自主机或从机的数据在时钟上升沿或下降沿同步。主机和从机可以同时传输数据。SPI 接口可以是 1 线、2 线 3 线式或 4 线式，这节课，我们用到的就是 3 线 SPI。

产生时钟信号的器件称为 主机。主机和从机之间传输的数据与主机产生的时钟同步。同 I2C 接口相比，SPI 器件支持更高的时钟频率。用户应查阅产品数据手册以了解 SPI 接口的时钟频率规格。

标准 4 线 SPI 芯片的管脚上只占用四根线。

• MOSI： 主器件数据输出，从器件数据输入。
• MISO：主器件数据输入，从器件数据输出。
• SCK： 时钟信号，由主设备控制发出。
• CS（NSS）： 从机设备选择信号，由主设备控制。当 CS 为低电平则选中从器件。

3 线 SPI 没有 MISO，或者 MISO 与 MOSI 共线。

SPI 接口只能有一个主机，但可以有一个或多个从机。下图显示了主机和从机之间的 SPI 连接。来自主机的片选信号用于选择从机。这通常是一个低电平有效信号，拉高时从机与 SPI 总线断开连接。当使用多个从机时，主机需要为每个从机提供单独的片选信号。MOSI 和 MISO 是数据线。MOSI 将数据从主机发送到从机，MISO将数据从从机发送到主机。

ESP32 集成了 4 个 SPI 外设。

• 其中两个在内部用于访问 ESP32 所连接的闪存。两个控制器共享相同的 SPI 总线信号，并且有一个仲裁器来确定哪个可以访问该总线。
• 另外两个是通用 SPI 控制器，分别称为 HSPI 和 VSPI。它们向用户开放，具有独立的总线信号，分别具有相同的名称。每条总线具有 3 条 CS 线，最多能控制 6 个 SPI 从设备。

I2C 与 SPI 区别

I2C 只需两根信号线，而标准 SPI 至少四根信号，如果有多个从设备，信号需要更多。一些 SPI 变种虽然只使用三根线—— SCK、CS 和双向的 MISO/MOSI，但 CS 线还是要和从设备一对一根。另外，如果 SPI 要实现多主设备结构，总线系统需额外的逻辑和线路。用 I2C 构建系统总线唯一的问题是有限的 7 位地址空间，但这个问题新标准已经解决 --- 使用 10 位地址。

如果应用中必须使用高速数据传输，那么 SPI 是必然的选择。因为 SPI 是全双工，IIC 的不是。SPI 没有定义速度限制，一般的实现通常能达到甚至超过 10Mbps。IIC 最高的速度也就快速+模式（1Mbps）和高速模式（3.4Mbps），后面的模式还需要额外的 I/O 缓冲区，还并不是总是容易实现的。SPI 适合数据流应用，而 IIC 更适合“字节设备”的多主设备应用。

SPI 有一个非常大的缺陷，主要是没有标准的协议，SPI 比较混乱，主要是没有标准的协议，只有moto的事实标准。所以衍生出多个版本，但没有本质的差异。

2. OLED 屏幕

OLED，即有机发光二极管（Organic Light Emitting Diode）。OLED 由于同时具备自发光，不需背光源、对比度高、厚度薄、视角广、反应速度快、可用于挠曲性面板、使用温度范围广、构造及制程较简单等优异之特性，被称为是第三代显示技术。

LCD 都需要背光，而 OLED 不需要，因为它是自发光的。这样同样的显示 OLED 效果要来得好一些。以目前的技术，OLED 的尺寸还难以大型化，但是分辨率确可以做到很高。

我们今天用到的屏幕是 0.96 寸的 SSD1306 芯片驱动的 OLED 屏幕。他的分辨率是 128*64，意思就是横向有 128 个像素点，纵向有 64 个

OLED 显示屏模块接口定义：

1. GND：电源地。
2. VCC：电源正（3.3～5V）。
3. D0：OLED 的 D0 脚，在 SPI 通信中为时钟管脚。
4. D1：OLED 的 D1 脚，在 SPI 通信中为数据管脚。
5. RES：OLED 的 RES 脚，用来复位（低电平复位）。
6. DC：数据和命令控制管脚。
7. CS：片选管脚。

硬件电路设计

物料清单（BOM 表）：

软件程序设计

如果想要使用 Arduino 控制 SSD1306 驱动的 OLED 屏幕，有以下两种第三方库可以使用：

1. Adafruit_SSD1306 库：专门针对 SSD1306 驱动 OLED 屏幕的显示图形库；
2. U8G2 库：目前 Arduino 平台上使用最广泛的 OLED 库。

1. Adafruit_SSD1306 控制 OLED 屏幕

想要使用 Adafruit_SSD1306，还需要安装 Adafruit_GFX 第三方库。Arduino 的 Adafruit_GFX 库为我们所有的 LCD 和 OLED 显示器提供了通用语法和图形功能集，也就是说这是一个通用图形库，并不针对特定的显示器型号。

• Adafruit_GFX 定义了一系列的绘画方法（线，矩形，圆等等），属于基础类，并且最重要的一点，drawPixel 方法由子类来实现；
• Adafruit_SSD1306 定义了一系列跟 SSD1306 有关的方法，并且重写了 drawPixel 方法，属于扩展类。

首先，我们就需要先下载这两个第三方库，PlatformIO 已经为我们提供了方便的下载途径，我们可以直接在 PlatformIO 的 PIO HOME 页面中选择 Libraries 中分别搜索 Adafruit GFX Library 与 Adafruit_SSD1306，然后添加到项目中即可。

下载完以上两个第三方库之后，打开 platformio.ini 文件，可以看到 lib_deps 中出现了 SSD1306 与 Adafruit GFX Library 两个依赖，

在学习 Adafruit_SSD1306 之前，你需要明白无论什么 OLED 屏幕，最终都可以抽象为像素点阵，想显示什么内容就把具体位置的像素点亮起来。比如 SSD1306-12864 就是一个 128X64 像素点阵，这个点阵拥有自己的一套坐标系，在坐标系中，左上角是原点，向右是X轴，向下是Y轴。

接下来，我们就可以深入学习该库了。

SSD1306 包括 IIC 和 SPI 总线版本，所以针对不同版本又有对应的构造器方法，因为我们的 OLED 是 SPI 版本的，因此，我们只讲 SPI 总线的构造方法。以下代码是

/*! 
    @brief  Constructor for SPI SSD1306 displays, using software (bitbang)
            SPI.(软件SPI总线)
    @param  w
            Display width in pixels
    @param  h
            Display height in pixels
    @param  mosi_pin
            MOSI (master out, slave in) pin (using Arduino pin numbering).
            This transfers serial data from microcontroller to display.
    @param  sclk_pin
            SCLK (serial clock) pin (using Arduino pin numbering).
            This clocks each bit from MOSI.
    @param  dc_pin
            Data/command pin (using Arduino pin numbering), selects whether
            display is receiving commands (low) or data (high).
    @param  rst_pin
            Reset pin (using Arduino pin numbering), or -1 if not used
            (some displays might be wired to share the microcontroller's
            reset pin).
    @param  cs_pin
            Chip-select pin (using Arduino pin numbering) for sharing the
            bus with other devices. Active low.
    @return Adafruit_SSD1306 object.
    @note   Call the object's begin() function before use -- buffer
            allocation is performed there!
*/
Adafruit_SSD1306(uint8_t w, uint8_t h, int8_t mosi_pin, int8_t sclk_pin,
    int8_t dc_pin, int8_t rst_pin, int8_t cs_pin);
    
/*!
    @brief  Constructor for SPI SSD1306 displays, using native hardware SPI.（硬件SPI总线）
    @param  w
            Display width in pixels
    @param  h
            Display height in pixels
    @param  spi
            Pointer to an existing SPIClass instance (e.g. &SPI, the
            microcontroller's primary SPI bus).
    @param  dc_pin
            Data/command pin (using Arduino pin numbering), selects whether
            display is receiving commands (low) or data (high).
    @param  rst_pin
            Reset pin (using Arduino pin numbering), or -1 if not used
            (some displays might be wired to share the microcontroller's
            reset pin).
    @param  cs_pin
            Chip-select pin (using Arduino pin numbering) for sharing the
            bus with other devices. Active low.
    @param  bitrate
            SPI clock rate for transfers to this display. Default if
            unspecified is 8000000UL (8 MHz).
    @return Adafruit_SSD1306 object.
    @note   Call the object's begin() function before use -- buffer
            allocation is performed there!
*/    
Adafruit_SSD1306(uint8_t w, uint8_t h, SPIClass *spi,
    int8_t dc_pin, int8_t rst_pin, int8_t cs_pin, uint32_t bitrate=8000000UL);

软件 SPI 总线用法，代码如下：

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
// 软件SPI总线
// Declaration for SSD1306 display connected using software SPI (default case):
#define OLED_MOSI   13
#define OLED_CLK   18
#define OLED_DC    2
#define OLED_CS    4
#define OLED_RESET 15
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT,
  OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

使用硬件 SPI 总线，代码如下：

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define OLED_DC     2
#define OLED_CS     4
#define OLED_RESET  15
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT,
  &SPI, OLED_DC, OLED_RESET, OLED_CS);

接下来的方法（函数）无论是 I2C 还是 SPI 总线构建的，用法都是一致的：

• clearDisplay：清除显示，该方法仅清除 Arduino 缓存，不会立即显示在屏幕上，可以通过调用 display 来立即清除；
• display：显示内容，这个方法才是真正把绘制内容画在 OLED 屏幕上（非常重要）；
• drawCircle：绘制空心圆；
• fillCircle：绘制实心圆；
• drawTriangle：绘制空心三角形；
• fillTriangle：绘制实心三角形；
• drawRoundRect：绘制空心圆角方形；
• fillRoundRect：绘制实心圆角方形；
• drawBitmap：绘制 Bitmap 图形；
• drawXBitmap：绘制 XBitmap 图形；
• drawChar：绘制单个字符；
• getTextBounds：计算字符串在当前字体大小下的像素大小，返回左上角坐标以及宽度高度像素值；
• setTextSize：设置字体大小；
• setFont：设置字体；
• setCursor：设置光标位置；
• setTextColor：设置字体颜色；
• setTextWrap：设置是否自动换行；
• drawPixel：绘制像素点；
• drawFastHLine：绘制水平线；
• drawFastVLine：绘制垂直线；
• startscrollright：滚动到右边；
• startscrollleft：滚动到左边；
• startscrolldiagright：沿着对角线滚动到右边；
• startscrolldiagleft：沿着对角线滚动到左边；
• stopscroll：停止滚动：

使用 Adafruit_SSD1306 库分为三个步骤：

1. 初始化 OLED，调用构造函数，调用 begin 方法；
2. 初始化成功后，调用绘制类函数，当然可以设置颜色、字体等
3. 绘制完毕，调用显示类函数 display。

了解完基本原理之后，我们就可以写一个简单的程序了，比如我们可以在屏幕上显示一些图形和字符，代码如下：

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED 显示屏宽度
#define SCREEN_HEIGHT 64 // OLED 显示屏高度

// 软件SPI总线
#define OLED_MOSI 13
#define OLED_CLK 18
#define OLED_DC 2
#define OLED_CS 4
#define OLED_RESET 15
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT,
                      OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

void setup()
{
  oled.begin();
  oled.clearDisplay();                          // 清除显示
  oled.drawFastHLine(32, 5, 48, SSD1306_WHITE); // 绘制水平线
  oled.drawLine(32, 5, 48, 30, SSD1306_WHITE);  // 绘制线
  oled.drawRect(5, 5, 10, 25, SSD1306_WHITE);   // 绘制矩形
  oled.fillRect(75, 5, 10, 30, SSD1306_WHITE);  // 绘制实心矩形
  oled.setCursor(5, 50);                        // 设置光标位置
  oled.setTextSize(2);                          // 设置字体大小
  oled.setTextColor(WHITE);                     // 设置文本颜色
  oled.println("Hello, world!");                // 显示文字
  oled.display();                               // 显示内容
}

void loop()
{
}

2. 在 OLED 上显示进度条

我们也可以在 OLED 屏幕中实现一个进度条加载的动画效果，代码如下：

#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define SCREEN_WIDTH 128 // OLED 显示屏宽度
#define SCREEN_HEIGHT 64 // OLED 显示屏高度

// 软件SPI总线
#define OLED_MOSI 13
#define OLED_CLK 18
#define OLED_DC 2
#define OLED_CS 4
#define OLED_RESET 15
Adafruit_SSD1306 oled(SCREEN_WIDTH, SCREEN_HEIGHT,
                      OLED_MOSI, OLED_CLK, OLED_DC, OLED_RESET, OLED_CS);

// 初始化进度条变量
int progress = 0;

void setup()
{
  oled.begin();
  oled.setTextSize(2);              // 设置字体大小
  oled.setTextColor(SSD1306_WHITE); // 设置文本颜色
  oled.display();                   // 显示内容
}

void loop()
{
  // 清空屏幕
  oled.clearDisplay();

  // 设置光标位置
  oled.setCursor(25, 40);
  // 显示文字
  oled.println("Process");

  // 显示进度条边框
  oled.drawRoundRect(0, 10, 128, 20, 5, SSD1306_WHITE);
  // 显示进度
  oled.fillRoundRect(5, 15, progress, 10, 2, SSD1306_WHITE);

  // 进度递增
  if (progress < 118)
  {
    progress++;
  }
  else
  {
    progress = 0;
  }

  // 刷新屏幕
  oled.display();

  delay(50); // 延迟一段时间后更新显示
}

3. U8G2 库控制 OLED

学会使用 Adafruit_SSD1306 库之后，我们再学习另一个并且是 Arduino 平台上使用最广泛的 OLED 库 - U8G2 库open in new window。U8g2 是嵌入式设备的单色图形库，一句话简单明了。主要应用于嵌入式设备，包括我们常见的单片机。

安装方法与 Adafruit_SSD1306 一致，只需要在 PlatformIO 中的 libraries 中搜索对应的库，添加到项目中即可。

为什么要运用 U8g2 库？也就是说 U8g2 库能带给我们什么样的开发便利，主要考虑几个方面：

• 平台支持性好，兼容多款开发板如 ESP32、ESP8266、Arduino Uno 等；
• 显示控制器支持性好，基本上市面上的 OLED 都完美支持；
• API 众多，特别支持了中文，支持了不同字体，这是一个对于开发者来说不小的福利。

因为 U8G2 库兼容很多版本的驱动以及不同尺寸的 OLED，所以 U8G2 构造方法有很多，但是我们需要根据我们自己的 OLED 的型号，选择适合我们的构造方法。打开 U8g2lib.h 文件，找到构造器的位置：

我们可以看到这些构造方法的名字有一定的规律：U8G2_驱动芯片_屏幕尺寸_缓存大小_总线，而我们的 OLED 尺寸是 128x64，SPI 总线，SSD1306 驱动，因此，我们可以搜索 U8G2_SSD1306_128X64，

HW 表示硬件（hardware），SW 表示软件（software），4W 表示 4 线，因此，我们就找到了最适合我们的构造器

U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI
U8G2_SSD1306_128X64_NONAME_2_4W_SW_SPI
U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI

这里的 1、2、F 表示不同的缓存大小：

• 1；只有一页的缓冲区，需要使用 firstPage/nextPage 方法来循环更新屏幕，使用 128 字节的内存；
• 2：保持两页的缓冲区，使用 256 字节的内存；
• F：保存有完整的显示的缓存，可以使用所有的函数，但是 ram 消耗大，一般用在 ram 空间比较大的开发板；

所有的软件模拟总线构造函数的第一个参数都是 rotation，这个参数表示显示内容是否旋转，U8G2 提供了以下几个选项：

• U8G2_R0：不旋转；
• U8G2_R1：顺时针转 90°；
• U8G2_R2：顺时针转 180°；
• U8G2_R3：顺时针转 270°；
• U8G2_MIRROR：镜像翻转；

构造完对象之后，我们就可以学习 U8G2 的方法了，方法可以分为四大类（这里我们只列举了部分，详细内容可以查阅 u8g2 库）：

1. 基本函数
   • begin()：初始化方法；
   • initDisplay()：初始化显示控制器，这个方法不需要我们单独调用，会在 begin 函数主动调用一次，我们主要理解即可，会在里面针对具体的 OLED 进行配置；；
   • clearDisplay()：清除屏幕内容，这个方法不需要我们单独调用，会在 begin 函数主动调用一次，我们主要理解即可，并且不要在 firstPage 和 nextPage 函数之间调用该方法；
   • clear()：清除操作；
   • clearBuffer()：清除缓冲区；
   • enableUTF8Print()：开启 Arduino 平台下支持输出 UTF8 字符集，我们的中文字符就是UTF8；
   • home()：重置显示光标的位置，回到原点（0，0）；
2. 绘制相关函数
   • drawPixel()：绘制像素点；
   • drawHLine()：绘制水平线；
   • drawLine()：两点之间绘制线
   • drawBox()：画实心方形；
   • drawFrame()：画空心方形
   • drawCircle()：画空心圆；
   • drawDisc()：画实心圆；
   • drawStr()：绘制字符串，需要先设置字体，调用 setFont 方法；
   • drawXBM()/drawXBMP()：绘制图像；
   • firstPage()/nextPage()：绘制命令，firstPage 方法会把当前页码位置变成 0，修改内容处于 firstPage 和 nextPage 之间，每次都是重新渲染所有内容；
   • print()：绘制内容；
3. 显示配置相关函数
   • getDisplayHeight()：获取显示器的高度；
   • getDisplayWidth()：获取显示器的宽度；
   • setCursor()：设置绘制光标位置；
   • setDisplayRotation()：设置显示器的旋转角度；
   • setFont()：设置字体集（字体集用于字符串绘制方法或者glyph绘制方法）；
4. 缓存相关函数
   • getBufferPtr()：获取缓存空间的地址；
   • getBufferTileHeight()：获取缓冲区的Tile高度，一个tile等于8个像素点；
   • getBufferTileWidth()：获取缓冲区的Tile宽度；
   • getBufferCurrTileRow()：获取缓冲区的当前Tile row；
   • clearBuffer()：清除内部缓存区；
   • sendBuffer()：发送缓冲区的内容到显示器。

U8g2 支持以下两种绘制模式：

1. Full screen buffer mode，全屏缓存模式；
2. Page mode，分页模式；

全屏缓存模式使用步骤：

1. 构造对象，根据 OLED 的型号选择对应的构造器，构造器必须带 F，因此，需要使用 U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI；
2. 初始化对象，使用 begin() 方法，清除缓冲区内容，使用 u8g2.clearBuffer()；
3. 绘制内容，使用绘制函数或者设置字体等；
4. 发送缓冲区的内容到显示器 u8g2.sendBuffer()。

了解完构造方法与使用方法之后，我们就可以来在程序中使用 U8G2 库了，代码如下：

#include <Arduino.h>
#include <U8g2lib.h>

// 构造对象
U8G2_SSD1306_128X64_NONAME_F_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/18, /* data=*/13, 
                                             /* cs=*/4, /* dc=*/2, /* reset=*/15);

void setup(void)
{
  // 初始化 oled 对象
  u8g2.begin();
  // 开启中文字符集支持
  u8g2.enableUTF8Print();
}

void loop(void)
{
  // 设置字体
  u8g2.setFont(u8g2_font_unifont_t_chinese2);
  // 设置字体方向
  u8g2.setFontDirection(0);
  // 
  u8g2.clearBuffer();
  u8g2.setCursor(0, 15);
  u8g2.print("Hello GeeksMan!");
  u8g2.setCursor(0, 40);
  u8g2.print("你好, ESP32!");
  u8g2.sendBuffer();

  delay(1000);
}

4. U8G2 库的分页模式实现进度条效果

分页模式的使用步骤：

1. 构造对象，根据 OLED 的型号选择对应的构造器；
2. 初始化对象，使用 begin() 方法，调用 firstPage() 进入第一页
3. 开始一个 do while 循环，循环条件是 nextPage()，作用是进入下一页，如果还有下一页则返回 true；
4. 在循环内部 操作一些绘制方法。

#include <Arduino.h>
#include <U8g2lib.h>

U8G2_SSD1306_128X64_NONAME_2_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/18, /* data=*/13,
                                             /* cs=*/4, /* dc=*/2, /* reset=*/15);

int progress = 0;

void setup()
{
  // 初始化 OLED 对象
  u8g2.begin();
}

void loop()
{
  // 进入第一页
  u8g2.firstPage();
  do
  {
    // 显示进度条边框
    u8g2.drawFrame(0, 10, 128, 20);
    // 显示进度
    u8g2.drawBox(5, 15, progress, 10);

  } while (u8g2.nextPage());  // 进入下一页，如果还有下一页则返回true

  // 进度递增
  if (progress < 118)
  {
    progress++;
  }
  else
  {
    progress = 0;
  }
}

5. 按键控制菜单

在搞清楚 U8G2 库的使用方法之后，我们就可以设计一个按键控制菜单了，UI 大概就是下面这个样子

按键控制菜单的原理其实很简单 -，当我检测到按键按下的时候，就切换屏幕状态，因为只有部分区域发生了改变，让你产生立箭头移动的错觉，代码如下：

#include <Arduino.h>
#include <U8g2lib.h>

// PlatformIO 中 自己编写的函数如果处于末尾，需要在文件顶部显式声明
void display_menu(unsigned int index);

U8G2_SSD1306_128X64_NONAME_2_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/18, /* data=*/13,
                                            /* cs=*/4, /* dc=*/2, /* reset=*/15);

#define MENU_SIZE 4
char *menu[MENU_SIZE] = {"Item 1", "Item 2", "Item 3", "Item 4"};

#define BUTTON_UP 12
#define BUTTON_DOWN 14

// 定义当前选项
unsigned int  order = 0;

void setup()
{
  // 初始化 OLED 对象
  u8g2.begin();
  u8g2.setFont(u8g2_font_6x12_tr);
  
  // 配置输入按键
  pinMode(BUTTON_UP, INPUT_PULLUP);
  pinMode(BUTTON_DOWN, INPUT_PULLUP);
}

void loop()
{
  // 判断按键是否按下，并记录当前箭头位置
  if(!digitalRead(BUTTON_UP)) 
  {
    order = (order - 1) % 4;
  }else if (!digitalRead(BUTTON_DOWN))
  {
    order = (order + 1) % 4;
  }
  
  // 显示菜单
  display_menu(order);

  // 延时
  delay(100);
}

void display_menu(unsigned int index)
{
  // 进入第一页
  u8g2.firstPage();
  do
  {
    // 绘制页面内容
    u8g2.drawStr(0, 12, "Menu");
    u8g2.drawHLine(0, 14, 128);
    for (int i = 0; i < MENU_SIZE; i++)
    {
      if (i == index)
      {
        u8g2.drawStr(5, (i + 2) * 12 + 2, ">");
        u8g2.drawStr(20, (i + 2) * 12 + 2, menu[i]);
      }
      else
      {
        u8g2.drawStr(5, (i + 2) * 12 + 2, menu[i]);
      }
    }
  } while (u8g2.nextPage()); // 进入下一页，如果还有下一页则返回 True.
}

在写这个程序的时候，我们用到了以下几个新的知识点，

1. 使用 unsigned int 可以声明小于 0 的整数；
2. do ... while 是先执行一次循环体，再判断的循环；
3. 自己写的函数需要在文件顶部声明；
4. 指针数组是一个数组，其中的每个元素都是指针类型的变量。换句话说，指针数组存储了多个指针，每个指针可以指向内存中的不同位置。

之前我们学习了 ESP32 的按键控制，当时通过查询 GPIO 输入电平来判断按键状态，这种方法占用 CPU 资源，效率不高。本节课我们学习外部中断，通过外部中断实现按键控制 LED。

实验原理

在单片机中，中断是指当 CPU 在正常处理主程序时，突然发生了另一件事件 A（中断发生）需要 CPU 去处理，这时 CPU 就会暂停处理主程序（中断响应），转而去处理事件 A（中断服务）。当事件 A 处理完以后，再回到主程序原来中断的地方继续执行主程序（中断返回）。这一整个过程称为中断。

例如，当你正在洗衣时，突然手机响了（中断发生），你暂时中断洗衣的工作，转去接电话（中断响应和中断服务），待你接完后，再回来继续洗衣（中断返回），这一过程就是中断。

当中断过程 A 中，发生了另一个中断级别更高的中断事件 B,则 CPU 又会中断当前的 A 转而去处理 B，完毕后再回到 A 的断点继续处理。这称为中断的嵌套。

中断的嵌套涉及到中断的优先级问题，优先级高的中断就可以在打断优先级低的中断执行。

中断可以根据中断源分为 硬件中断 和 软件中断：

1. 硬件中断：也被称为外部中断，硬件中断响应外部硬件事件而发生。例如，当检测到触摸时会发生触摸中断，而当 GPIO 引脚的状态发生变化时会发生 GPIO 中断。GPIO 中断和触摸中断属于这一类；
2. 软件中断：当触发软件事件（例如定时器溢出）时，会发生这种类型的中断。定时器中断是软件中断的一个例子。

前面我们在做按键控制实验时，虽然能实现 IO 口输入功能，但代码是一直在检测 IO 输入口的变化，因此效率不高，特别是在一些特定的场合，比如某个按键，可能 1 天才按下一次去执行相关功能，这样我们就浪费大量时间来实时检测按键的情况。

为了解决这样的问题，我们引入外部中断概念，顾名思义，就是当按键被按下（产生中断）时，才去执行相关功能。这大大节省了 CPU 的资源，因此中断在实际项目中应用非常普遍。

ESP32 的外部中断有上升沿、下降沿、低电平、高电平触发模式。上升沿和下降沿触发如下：

若将按键对应 IO 配置为下降沿触发，当按键按下后即触发中断，然后在中断回调函数内执行对应的功能。

硬件电路设计

使用按键电路实现开关灯的效果。

物料清单（BOM 表）：

将材料按照下图相连:

软件程序设计

Arduino 中的外部中断配置函数 attachInterrupt(digitalPinToInterrupt(pin), ISR, mode) 包括 3 个参数：

1. pin：GPIO 端口号；
2. ISR：中断服务程序，没有参数与返回值的函数；
3. mode：中断触发的方式，支持以下触发方式：
   • LOW 低电平触发
   • HIGH 高电平触发
   • RISING 上升沿触发
   • FALLING 下降沿触发
   • CHANGE 电平变化触发

在 Arduino 中使用中断需要注意一下几点：

1. 尽量保证中断程序内容少

2. 避免在中断处理函数中使用阻塞函数（如 delay()），使用非阻塞的延迟方法来处理需要延迟的操作（micros() 函数），以保证中断的正常执行和系统的稳定性。这是因为 delay() 函数会阻塞整个系统，包括中断的正常执行。当中断触发时，处理函数应该尽快执行完毕，以确保及时响应并避免中断积压；

3. 与主程序共享的变量要加上 volatile 关键字；

4. 在 Arduino 中使用中断时，应尽量避免在中断处理函数中使用 Serial 对象的打印函数。当在中断处理函数中使用 Serial 打印函数时，会导致以下问题：

   • 时间延迟：Serial 打印函数通常是比较耗时的操作，它会阻塞中断的执行时间，导致中断响应的延迟。这可能会导致在中断期间丢失其他重要的中断事件或导致系统不稳定。
   • 缓冲区溢出：Serial 对象在内部使用一个缓冲区来存储要发送的数据。如果在中断处理函数中频繁调用 Serial 打印函数，可能会导致缓冲区溢出，造成数据丢失或不可预测的行为。

为了避免这些问题，建议在中断处理函数中尽量避免使用 Serial 打印函数。如果需要在中断处理函数中输出调试信息，可以使用其他方式，如设置标志位，在主循环中检查标志位并进行打印，代码如下：

#define BUTTON  14


// 定义可以在外部中断函数中使用的变量
volatile bool flag = false;


// 定义外部中断函数
void handle_interrupt() {
  flag = true;
  number += 10000;
}

void setup() {
  Serial.begin(9600);
  pinMode(BUTTON, INPUT_PULLDOWN);
  // 配置中断引脚
  attachInterrupt(digitalPinToInterrupt(BUTTON), handle_interrupt, FALLING);
}

void loop() {
  if (flag) {
    Serial.println("外部中断触发");
    flag = false;
  }

}

因此，我们使用外部中断点灯的代码可以这么写：

#define BUTTON 14
#define LED     2 


volatile bool flag = false;


void ISR() {
  flag = true;
}


void setup() {
  pinMode(BUTTON, INPUT_PULLDOWN);
  pinMode(LED, OUTPUT);

  // 配置中断引脚
  attachInterrupt(digitalPinToInterrupt(BUTTON), ISR, FALLING);
}


void loop() {
  if (flag) {
    digitalWrite(LED, HIGH);
    delay(2000);
    digitalWrite(LED, LOW);

    // 重置中断标志位
    flag = false;
  }
}

上一节我们介绍了 ESP32 的外部中断的使用，本节课介绍 ESP32 的定时器功能。

实验原理

定时器，顾名思义就是用来计时的，我们常常会设置计时或闹钟，然后时间到了就告诉我们要做什么。ESP32 也是这样，通过定时器可以完成各种预设好的任务。ESP32 定时器到达指定时间后也会产生中断，然后在回调函数内执行所需功能，这个和外部中断类似。

在 Arduino 中操控 ESP32 时，有 硬件定时器 和 软件定时器 两种类型的定时器可供选择。它们具有不同的工作原理和用途。

硬件定时器 是 ESP32 芯片上的内置计时器，它们是专门设计用于定时和计时任务的硬件模块。硬件定时器可以通过设置特定的寄存器来配置和控制，通常具有更高的精确度和稳定性。它们不受软件的影响，可以在后台独立运行，不会受到其他代码的干扰。硬件定时器适用于需要高精度和实时性的定时任务，例如 PWM 输出、捕获输入脉冲等。

软件定时器 是通过编写代码在 Arduino 中模拟实现的定时器。它们不依赖于硬件模块，而是使用计数器变量来实现定时功能。软件定时器是基于延时循环的原理，在特定的时间间隔内执行特定的任务。但是，使用软件定时器时需要注意，它们可能会受到其他代码的影响而产生误差，特别是当涉及到需要精确时间控制的应用时，如通信协议处理、高速数据采集等。

硬件定时器和软件定时器各有优劣，具体选择取决于你的应用需求。如果需要高精度、实时性和稳定性，建议使用硬件定时器。如果时间精度要求不高，或者只需要基本的定时功能，可以使用软件定时器来简化代码编写。

需要注意的是，ESP32 具有 4 个硬件定时器，具体使用哪个定时器取决于你的需求和硬件资源的可用性。请参考 ESP32 的官方文档和相关库的文档以获取更详细的信息和使用示例。

硬件电路设计

物料清单（BOM 表）：

LED 的正极接开发板的 D2、D4 引脚，并串联一个电阻，负极接 GND，如下图：

软件程序设计

1. 硬件定时器

在 ESP32 Arduino 开发环境中，可以使用以下几个库函数来配置和操作硬件定时器（Timer）：

1. void timerBegin(timer_num_t timer_num, uint32_t divider, bool count_up)：初始化硬件定时器，参数说明：

• timer_num：定时器编号，可选值为 0-3 等。
• divider：定时器的分频系数，用于设置定时器的时钟频率。较大的分频系数将降低定时器的时钟频率。可以根据需要选择合适的值，一般设置为 80 即可；
• count_up：指定定时器是否为向上计数模式。设置为 true 表示向上计数，设置为 false 表示向下计数。

2. timerAttachInterrupt(hw_timer_t *timer, void (*isr)(void *), void *arg, int intr_type)：用于将中断处理函数与特定的定时器关联起来，参数含义如下：

• timer；定时器指针；
• isr: 中断处理函数。
• arg: 传递给中断处理函数的参数。
• intr_type: 中断类型，可选值为 ture（边沿触发）或 false（电平触发）。

3. timerAlarmWrite(hw_timer_t *timer, uint64_t alarm_value, bool autoreload)：用于设置定时器的计数值，即定时器触发的时间间隔，参数含义如下：

• timer：定时器指针；
• alarm_value: 定时器的计数值，即触发时间间隔；
• autoreload: 是否自动重载计数值，可选值为 true（自动重载）或 false（单次触发）。

4. timerAlarmEnable(hw_timer_t *timer)：用于启动定时器，使其开始计数；
5. timerAlarmDisable(hw_timer_t *timer)：用于禁用定时器，停止计数；
6. timerGetAutoReload(hw_timer_t *timer)：获取定时器是否自动重新加载；
7. timerAlarmRead(hw_timer_t *timer)：获取定时器计数器报警值；
8. timerStart(hw_timer_t *timer)：计数器开始计数；
9. timerStop(hw_timer_t *timer)：计数器停止计数；
10. timerRestart(hw_timer_t *timer)：计数器重新开始计数，从 0 开始；
11. timerStarted(hw_timer_t *timer)：计数器是否开始计数。

以上是一些常用的硬件定时器相关的库函数，你可以根据自己的需求和定时器的特性，调用适当的函数来配置和操作硬件定时器。请参考 ESP32 的官方文档和相关库的文档，以获取更详细的信息。

使用硬件定时器的基本步骤如下：

1. 初始化定时器：使用 timerBegin() 函数初始化所需的硬件定时器；
2. 注册中断处理函数：使用 timerAttachInterrupt() 函数将中断处理函数与定时器关联起来；
3. 设置定时器模式：使用 timerAlarmWrite()，设置触发一次，还是周期性触发；
4. 启动定时器：使用 timerAlarmEnable() 函数启动定时器，使其开始计数。

因此，我们的代码可以这么写：

#define LED   2
#define LED_ONCE  4

hw_timer_t *timer = NULL;
hw_timer_t *timer_once=NULL;


// 定时器中断处理函数
void timer_interrupt(){
  digitalWrite(LED, !digitalRead(LED));
}

void timer_once_interrupt() {
  digitalWrite(LED_ONCE, !digitalRead(LED_ONCE));
}
 
void setup() {
  pinMode(LED, OUTPUT);
  pinMode(LED_ONCE, OUTPUT);

  // 初始化定时器
  timer = timerBegin(0,80,true);
  timer_once = timerBegin(1, 80, true);

  // 配置定时器
  timerAttachInterrupt(timer,timer_interrupt,true);
  timerAttachInterrupt(timer_once, timer_once_interrupt, true);

  // 定时模式，单位us，只触发一次
  timerAlarmWrite(timer,1000000,true); 
  timerAlarmWrite(timer_once, 3000000, false);
  // 启动定时器
  timerAlarmEnable(timer); 
  timerAlarmEnable(timer_once);
 
}
 
void loop() {
}