1. 项目概述：从闪烁到编排，理解子程序的核心价值

如果你玩过Arduino，点亮第一个LED灯时的兴奋感肯定还记得。但当你试图让8个LED灯像商场门口的广告牌一样，按照“左移、右移、交叉闪烁”等复杂模式运行时，是不是立刻觉得 loop() 函数里挤满了 digitalWrite() 和 delay() ，代码变得又长又乱，改起来头疼？这就是我们今天要解决的痛点：如何用 子程序 （或叫函数）来优雅地实现一个 广告灯模型 。

简单说，这个实验的目标不是仅仅让灯亮，而是学习如何像导演编排舞蹈一样，用清晰、模块化的代码去控制LED灯阵的复杂动作。子程序就是将一段特定功能的代码“打包”成一个独立的指令块，主程序可以随时调用它。这样做的好处是，你的核心逻辑（ loop 循环）会变得非常干净，就像一本书的目录，而具体的实现细节都封装在了各个章节（子程序）里。无论是修改某种灯效，还是增加新的模式，都只需要改动对应的子程序，而不会牵一发而动全身。

这对于从Arduino新手迈向有组织能力的开发者来说，是关键一步。我们常说的“代码重构”，其起点往往就是学会合理地使用函数。本次实验将使用最常见的Arduino Uno和8个LED灯，通过构建几种典型的广告灯效，让你彻底掌握子程序的编写、调用以及参数传递，理解模块化编程如何提升代码的可读性、可维护性和复用性。

2. 核心思路拆解：为什么非得用子程序？

在动手写代码之前，我们先抛开技术，想想现实中的场景。一个广告灯箱，其显示模式（比如“逐一点亮”、“来回扫描”）通常是固定的几种，并且会循环播放。如果用最基础的“面条式”代码写在 loop() 里，会是什么样子？

你可能会写出这样的伪代码：

void loop() {
  // 模式1：从左到右依次点亮
  digitalWrite(2, HIGH); delay(200); digitalWrite(2, LOW);
  digitalWrite(3, HIGH); delay(200); digitalWrite(3, LOW);
  // ... 重复8次，代码又长又重复

  // 模式2：从中间向两边扩散
  digitalWrite(5, HIGH); digitalWrite(4, HIGH); delay(200);
  // ... 逻辑复杂，delay穿插，难以阅读

  // 想调整模式1的速度？你得在一大堆代码里找到所有相关的delay并修改。
}

这段代码的问题显而易见： 重复 、 混乱 、 难以维护 。而子程序编程思想的核心，就是 “分离关注点” 。

2.1 功能抽象：定义清晰的“动作”

我们可以将每一种灯效定义为一个独立的子程序。例如：

• void waveFromLeftToRight() : 实现从左到右的波浪效果。
• void blinkAll() : 实现所有LED同时闪烁。
• void convergeFromSides() : 实现从两侧向中间汇聚的效果。

这样，主程序 loop() 就变得极其简洁和清晰：

void loop() {
  waveFromLeftToRight();
  delay(500); // 效果间的间隔
  blinkAll(3, 300); // 闪烁3次，每次亮灭各300ms
  convergeFromSides();
}

2.2 参数化设计：让子程序更灵活

一个好的子程序不应是死板的。比如“闪烁”这个动作，闪烁几次？速度多快？这些应该可以作为参数传入。这就用到了 带参数的子程序 。

对比一下：

• 死板的子程序： void blinkAll() 只能以固定方式闪烁一次。
• 灵活的子程序： void blinkAll(int times, int speed) 可以指定次数和速度。

在 loop() 中调用时，你可以轻松改变行为： blinkAll(5, 100) 表示快速闪烁5次， blinkAll(2, 500) 表示慢速闪烁2次。这种设计大大增强了代码的灵活性。

2.3 硬件与逻辑解耦

另一个关键思路是，将 引脚定义 与 控制逻辑 分离。我们通常会用一个数组来管理所有LED引脚，并在 setup() 中统一初始化。子程序只针对这个数组进行操作，而不关心具体的引脚号。这样，如果硬件上LED的接线顺序变了，你只需要修改数组定义，所有子程序都无需改动。

const int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // LED引脚数组
const int ledCount = 8;

void setup() {
  for (int i = 0; i < ledCount; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}
// 子程序通过索引 i 来操作 ledPins[i]，与具体引脚号解耦。

3. 硬件搭建与电路原理详解

3.1 元器件清单与作用

• Arduino Uno x1 : 控制器，执行我们编写的程序。
• LED（发光二极管） x8 : 建议使用不同颜色，方便观察效果。注意LED有正负极之分。
• 220Ω 电阻 x8 : 至关重要 的限流电阻。直接连接LED到5V引脚会因电流过大而烧毁LED或损坏Arduino的IO口。220Ω是常用值，在5V电压下，能为LED提供约10-15mA的安全电流。
• 面包板 x1 和 杜邦线 若干 : 用于搭建电路。
• USB数据线 x1 : 为Arduino供电并上传程序。

3.2 电路连接图与要点

我们将8个LED分别连接到Arduino Uno的数字引脚2~9。每个LED的连接方式完全一致，遵循以下规则：

1. LED长脚（阳极，+） ：通过一个220Ω电阻，连接到Arduino的数字引脚（如Pin 2）。
2. LED短脚（阴极，-） ：直接连接到Arduino的GND（接地）引脚。

注意 ：这里采用的是“共地”接法，即所有LED的负极都接到同一个GND上。也可以使用“共阳极”接法（所有正极接5V，负极接IO口），但那样代码逻辑需要反转（ LOW 点亮， HIGH 熄灭），对于初学者稍显不直观。我们采用最常规的“共阴极”接法。

连接对照表 ：

Arduino 数字引脚	连接至
Pin 2	LED1 阳极 (通过220Ω电阻)
Pin 3	LED2 阳极 (通过220Ω电阻)
Pin 4	LED3 阳极 (通过220Ω电阻)
Pin 5	LED4 阳极 (通过220Ω电阻)
Pin 6	LED5 阳极 (通过220Ω电阻)
Pin 7	LED6 阳极 (通过220Ω电阻)
Pin 8	LED7 阳极 (通过220Ω电阻)
Pin 9	LED8 阳极 (通过220Ω电阻)
GND	LED1~LED8 的所有阴极

3.3 为什么必须加限流电阻？—— 一次烧毁教训带来的原理

这是我早期犯过的错误：觉得LED能亮就行，省掉了电阻。结果一个LED瞬间变得异常亮然后熄灭，再也不能点亮，同时那个数字引脚也变得不太稳定。这就是过流导致的物理损坏。

Arduino Uno的数字引脚最大可提供约40mA的电流，但单个引脚推荐持续电流不超过20mA。一个典型的红色LED在2V左右电压下工作，电流在5-20mA时亮度合适。根据欧姆定律： 电阻 R = (电源电压Vcc - LED压降Vf) / 期望电流I 。 假设 Vcc=5V , Vf=2V , I=15mA ，则 R = (5-2)/0.015 ≈ 200Ω 。选择220Ω这个标准阻值，实际电流约为 (5-2)/220 ≈ 13.6mA ，既安全又能保证足够亮度。

实操心得 ：焊接或插接时，可以将电阻紧挨着LED的正极引脚。一来节省空间，二来即使接线短路到地，也是电阻承受电流，保护了LED和Arduino。养成好习惯，每个LED都独立配电阻。

4. 软件设计：子程序的结构与编写

4.1 子程序的基本语法

在Arduino（基于C/C++）中，一个子程序（函数）的基本结构如下：

返回类型 函数名(参数1类型 参数1名称, 参数2类型 参数2名称, ...) {
    // 函数体：执行具体操作的代码
    return 返回值; // 如果返回类型不是void
}

• 返回类型 ：函数执行完后返回的数据类型。如果只是执行操作不返回数据，用 void 。
• 函数名 ：自定义的名称，应清晰描述其功能，如 blinkLED 。
• 参数 ：调用函数时传递给它的数据。可以为空 () 。
• 函数体 ：花括号 {} 内的所有代码。

4.2 定义无参数的子程序：以“全部点亮/熄灭”为例

我们从最简单的开始。这两个函数没有参数，功能固定。

// 函数定义
void turnOnAllLEDs() {
  for (int i = 0; i < ledCount; i++) {
    digitalWrite(ledPins[i], HIGH); // 高电平点亮LED
  }
}

void turnOffAllLEDs() {
  for (int i = 0; i < ledCount; i++) {
    digitalWrite(ledPins[i], LOW); // 低电平熄灭LED
  }
}

在 loop() 中，你可以这样调用它们来制造一个“呼吸式”全亮全灭效果：

void loop() {
  turnOnAllLEDs();
  delay(1000);
  turnOffAllLEDs();
  delay(1000);
}

4.3 定义带参数的子程序：让“闪烁”功能活起来

现在，我们创建一个更强大的闪烁函数，它可以指定闪烁次数和每次亮/灭的持续时间。

// 函数定义：让所有LED闪烁指定次数
// 参数：times - 闪烁次数， speed - 每次亮或灭的毫秒数
void blinkAllLEDs(int times, int speed) {
  for (int count = 0; count < times; count++) {
    turnOnAllLEDs(); // 调用之前定义的函数，代码复用！
    delay(speed);
    turnOffAllLEDs();
    delay(speed);
  }
}

这个函数展示了子程序的另一个优势： 可以调用其他子程序 。 blinkAllLEDs 复用了 turnOnAllLEDs 和 turnOffAllLEDs ，避免了重复代码。

调用示例：

blinkAllLEDs(3, 200); // 快速闪烁3下
blinkAllLEDs(1, 1000); // 慢闪1下（亮1秒，灭1秒）

4.4 定义更复杂的模式子程序：“流水灯”与“来回扫描”

这才是广告灯的核心效果。我们需要操作单个LED，并控制它们依次点亮或熄灭。

4.4.1 从左到右的流水灯

void flowFromLeftToRight(int delayTime) {
  for (int i = 0; i < ledCount; i++) {
    digitalWrite(ledPins[i], HIGH); // 点亮当前LED
    delay(delayTime);
    digitalWrite(ledPins[i], LOW);  // 熄灭当前LED
    // 注意：这里没有立刻熄灭上一个，形成了“流动”感。
    // 如果想要“跑马灯”（只有一个亮），需要在点亮下一个前熄灭上一个。
  }
}

这是“流水”效果，像水流过一样。如果想要“跑马灯”（始终只有一个灯亮），代码需要稍作修改：

void runningLight(int delayTime) {
  for (int i = 0; i < ledCount; i++) {
    turnOffAllLEDs(); // 先全部熄灭
    digitalWrite(ledPins[i], HIGH); // 只点亮当前一个
    delay(delayTime);
  }
}

4.4.2 从两边向中间汇聚

这个效果逻辑稍复杂，需要同时控制两个LED。

void convergeFromSides(int delayTime) {
  for (int i = 0; i < ledCount / 2; i++) {
    // 点亮左侧的灯
    digitalWrite(ledPins[i], HIGH);
    // 点亮右侧对称位置的灯
    digitalWrite(ledPins[ledCount - 1 - i], HIGH);
    delay(delayTime);
    // 可以选择熄灭，也可以不熄灭形成累积效果。
    // digitalWrite(ledPins[i], LOW);
    // digitalWrite(ledPins[ledCount - 1 - i], LOW);
  }
  // 循环结束后，所有灯都亮着。如果需要重置，可以调用 turnOffAllLEDs();
}

5. 完整代码整合与主程序编排

现在，我们将所有零件组装起来，形成一个完整的、可循环播放多种灯效的广告灯程序。

/*
  广告灯模型实验 - 子程序应用
  控制8个LED实现多种动态效果。
*/

// 1. 硬件配置常量
const int ledPins[] = {2, 3, 4, 5, 6, 7, 8, 9}; // LED引脚数组
const int ledCount = 8; // LED数量

// 2. 初始化函数
void setup() {
  // 初始化所有LED引脚为输出模式
  for (int i = 0; i < ledCount; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
  // 可选：初始化串口，用于调试
  // Serial.begin(9600);
  // Serial.println("广告灯程序启动！");
}

// 3. 子程序定义区
// 3.1 基础控制函数
void turnOnAllLEDs() {
  for (int i = 0; i < ledCount; i++) {
    digitalWrite(ledPins[i], HIGH);
  }
}

void turnOffAllLEDs() {
  for (int i = 0; i < ledCount; i++) {
    digitalWrite(ledPins[i], LOW);
  }
}

// 3.2 参数化闪烁函数
void blinkAllLEDs(int times, int speed) {
  for (int count = 0; count < times; count++) {
    turnOnAllLEDs();
    delay(speed);
    turnOffAllLEDs();
    delay(speed);
  }
}

// 3.3 流水效果（从左到右）
void flowLeftToRight(int delayTime) {
  for (int i = 0; i < ledCount; i++) {
    digitalWrite(ledPins[i], HIGH);
    delay(delayTime);
    digitalWrite(ledPins[i], LOW);
  }
}

// 3.4 跑马灯效果（始终只有一个亮）
void runningLight(int delayTime) {
  for (int i = 0; i < ledCount; i++) {
    turnOffAllLEDs();
    digitalWrite(ledPins[i], HIGH);
    delay(delayTime);
  }
}

// 3.5 从两边向中间汇聚（点亮不熄灭）
void convergeToCenter(int delayTime) {
  turnOffAllLEDs(); // 先清空
  for (int i = 0; i < ledCount / 2; i++) {
    digitalWrite(ledPins[i], HIGH);
    digitalWrite(ledPins[ledCount - 1 - i], HIGH);
    delay(delayTime);
  }
  // 如果LED数量是奇数，点亮中间那个
  if (ledCount % 2 != 0) {
    digitalWrite(ledPins[ledCount / 2], HIGH);
    delay(delayTime);
  }
}

// 3.6 从中间向两边扩散
void divergeFromCenter(int delayTime) {
  turnOffAllLEDs();
  // 先处理奇数个的情况
  if (ledCount % 2 != 0) {
    digitalWrite(ledPins[ledCount / 2], HIGH);
    delay(delayTime);
  }
  // 从最内层向外点亮
  for (int i = (ledCount / 2) - 1; i >= 0; i--) {
    digitalWrite(ledPins[i], HIGH);
    digitalWrite(ledPins[ledCount - 1 - i], HIGH);
    delay(delayTime);
  }
}

// 4. 主循环 - 像编排节目单一样调用子程序
void loop() {
  // 模式1：快速流水灯
  flowLeftToRight(80);
  delay(300);

  // 模式2：跑马灯
  runningLight(150);
  delay(300);

  // 模式3：汇聚效果
  convergeToCenter(200);
  blinkAllLEDs(2, 200); // 汇聚后闪烁两下
  delay(300);

  // 模式4：扩散效果
  divergeFromCenter(200);
  delay(300);

  // 模式5：全体闪烁收尾
  blinkAllLEDs(5, 100);
  delay(500);

  // 清场，准备下一次循环
  turnOffAllLEDs();
  delay(1000);
}

代码编排解析 ： 主程序 loop() 现在读起来就像一个清晰的演出流程单。每个模式都是一个独立的子程序调用，参数可以轻松调整速度。如果你想调整演出顺序，或者增加、删除一个模式，只需要简单地移动、添加或注释掉一行调用代码即可，完全不会影响其他模式的逻辑。这就是模块化编程带来的巨大优势。

6. 调试、优化与进阶思考

6.1 常见问题与排查（FAQ）

在实际操作中，你可能会遇到以下问题：

现象	可能原因	排查步骤
所有LED都不亮	电源问题；GND未共地；代码未上传成功	1. 检查USB连接和Arduino电源指示灯。2. 用万用表或导线检查所有LED阴极是否连通并接到GND。3. 检查IDE是否提示上传成功，尝试上传Blink示例程序测试板子。
部分LED不亮	该LED或电阻接触不良；引脚定义错误；LED焊反	1. 交换不亮的LED和正常LED的位置，判断是LED问题还是电路问题。2. 检查代码中 ledPins 数组定义顺序是否与实物连接一致。3. 确认LED正负极是否接反。
LED亮度很暗	限流电阻阻值过大	尝试更换为100Ω或150Ω电阻（需确保电流在安全范围内）。
灯效混乱，不按顺序	ledPins 数组顺序与硬件连接不匹配； for 循环逻辑错误	1. 逐一单独点亮每个LED（ digitalWrite(pin, HIGH); delay(1000); ），确认引脚与物理位置的对应关系。2. 仔细检查子程序中的循环变量 i 和数组索引 ledPins[i] 的使用。
程序运行一次后停止	loop() 函数中有死循环或阻塞代码；硬件复位	检查 loop() 中是否有不带条件的 while(1) 或异常长的 delay 。确保程序能正常执行到 loop() 末尾。

6.2 使用非阻塞延时优化体验

上述所有代码都使用了 delay() 函数。它的缺点是 阻塞 ——在延时期间，CPU什么都做不了。对于简单的灯效没问题，但如果未来你想加入按键切换模式， delay 会使得按键检测不灵敏。这时可以使用 非阻塞 的定时方法，例如利用 millis() 函数。

这里提供一个将 blinkAllLEDs 改造成非阻塞模式的思路，供进阶学习：

unsigned long previousMillis = 0; // 记录上次动作的时间
int blinkState = LOW; // LED当前状态
int blinkCount = 0; // 已闪烁次数
const int blinkTarget = 5; // 目标闪烁次数
const int blinkInterval = 200; // 闪烁间隔

void nonBlockingBlink() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= blinkInterval) {
    previousMillis = currentMillis; // 保存本次动作时间

    if (blinkState == LOW) {
      turnOnAllLEDs();
      blinkState = HIGH;
    } else {
      turnOffAllLEDs();
      blinkState = LOW;
      blinkCount++;
    }
  }
  if (blinkCount >= blinkTarget) {
    // 闪烁完成，重置计数器，可以进行其他任务
    blinkCount = 0;
    // ... 切换到下一个模式
  }
}
// 在loop()中，只需不断调用 nonBlockingBlink()，同时可以执行其他代码（如检测按键）。

6.3 如何设计更复杂的灯效？

掌握了子程序的基本用法后，你可以发挥创意：

1. 组合效果 ：将几个基本效果组合在一个新的子程序里，比如先流水再汇聚。
2. 随机效果 ：使用 random() 函数随机点亮某个LED或选择下一个要执行的效果子程序。
3. 亮度控制 ：将LED连接到支持PWM（脉宽调制）的引脚（如3, 5, 6, 9, 10, 11），使用 analogWrite(pin, brightness) （0-255）来控制LED的亮度，实现呼吸灯、渐变等高级效果。
4. 外部控制 ：增加一个按钮或旋钮电位器。编写对应的子程序来读取这些输入，并用 if 语句在 loop() 中决定调用哪个灯效子程序，实现交互式广告灯。

6.4 从Arduino到其他平台

子程序（函数）是编程的通用概念。你在Arduino上学会的 void functionName(int param) 这种定义和调用方式，在真正的C/C++、Python、Java等语言中几乎一模一样。区别可能只是语法细节（如Python用 def ，不需要声明参数类型）。因此，这个实验锻炼的 模块化思维 和 代码封装能力 ，是你学习任何编程语言和平台的宝贵基础。当你未来使用ESP32做物联网项目，或者用STM32做更复杂的控制时，良好的函数设计习惯会让你事半功倍。

最后，把硬件收拾整齐，给你的广告灯拍个小视频吧。看着自己用清晰、有条理的代码指挥着一排LED翩翩起舞，这种从混乱到有序的成就感，正是编程最大的乐趣之一。试着去修改参数、创造新的效果函数，这才是学习的开始。