Arduino BLDC规则迷宫循迹求解机器人，是以Arduino/ESP32为主控、BLDC无刷电机为底盘驱动，通过红外/超声波/ToF等多传感器阵列感知迷宫结构，结合路径探索算法（如左手法则、洪水填充、A等）实现自主探索与最优路径求解的竞赛型智能机器人系统。 该方案具备两阶段执行策略、BLDC高精度位置闭环、多传感器融合与状态判断、路径记录与优化四大特点，主要应用于Micromouse迷宫竞赛、全国大学生电子设计竞赛、校园科创实训及智能仓储原型验证等场景；实际部署时需重点关注传感器布局与校准、BLDC驱动选型与闭环控制、电源管理与EMC、内存与算法优化、机械结构与PID调参。
一、 技术架构与主要特点
两阶段执行策略（探索+冲刺）：这是迷宫求解机器人的核心工作模式，分为两个阶段：
探索阶段（Mapping Mode）：机器人以保守策略（如左手法则/右手法则）遍历迷宫，在每个岔路口记录方向信息（左转L、右转R、直行S、掉头U），构建完整的迷宫拓扑图。此阶段要求稳健、容错率高，允许慢速行驶。
冲刺阶段（Speed Run Mode）：基于探索阶段获得的完整地图，使用优化算法（如洪水填充、A、Dijkstra）计算出从起点到终点的最短路径，然后以最高速度沿最优路径直抵终点。此阶段要求快速、精准，对BLDC电机的响应速度和定位精度要求极高。
BLDC高精度位置闭环控制：迷宫求解要求机器人精确停在网格格点上，这对电机控制提出了严格要求。BLDC电机通过外置高分辨率编码器（如每转≥1000线的增量式编码器或绝对值磁编码器）提供位置反馈，Arduino通过PID控制器（位置环）精确控制电机转动的角度或圈数，从而控制行进距离和转向角度。相比传统直流减速电机，BLDC具有高效率、高扭矩密度、低噪音、长寿命的优势，特别适合需要频繁启停和精确转向的场景。若需更高性能，可采用FOC（磁场定向控制）驱动，实现低速平滑运转和极低转矩纹波。
多传感器融合与状态判断：系统需要同时完成"定位"和"探墙"两项任务：
循迹传感器：通常采用3~5路红外反射式传感器（如TCRT5000）一字排开，检测地面黑线，通过传感器状态组合（如0b110表示前方和左侧检测到线）判断当前处于直线、弯道还是岔路口。
测距传感器：超声波（HC-SR04）、红外测距（Sharp GP2Y0A）或ToF传感器（VL53L0X）安装在前方和两侧，检测墙壁距离，辅助判断迷宫结构和修正里程计误差。
编码器+IMU：编码器提供轮式里程计数据，IMU提供姿态信息，两者融合可修正长时间运行中的累积漂移。
路径记录与优化算法：
路径记录：Arduino的RAM用于存储迷宫地图（如二维数组表示的网格地图）和探索路径（如方向序列栈）。由于Arduino Uno的EEPROM仅1KB，不足以存储完整路径，推荐外接SD卡或使用FRAM等非易失性存储器，路径数据应包含冗余校验（如CRC）防止写入错误。
寻路算法：常用算法包括左手法则/右手法则（简单但不一定最优）、深度优先搜索（DFS，能记录路径）、广度优先搜索（BFS，理论上能找到最短路径但对内存要求高）、洪水填充（Flood Fill，Micromouse竞赛经典算法）和A算法（已知全局地图时效率最高）。在资源受限的Arduino上，可考虑"探索阶段用简单规则，冲刺阶段加载优化路径"的分阶段策略。
二、 典型应用场景
Micromouse迷宫竞赛：这是最直接、最经典的应用场景。目标是制造能在最短时间内自主解决16×16迷宫的微型机器人。顶尖的Micromouse机器人完美体现了"探索+冲刺"两阶段策略、BLDC高精度控制和洪水填充算法的综合实力。
全国大学生电子设计竞赛/校园科创竞赛：如"全国大学生智能车竞赛""Robocon"以及各高校电子设计竞赛中，常设迷宫挑战项目。赛题通常要求机器人从起点出发，按指定路线抵达中间点位完成打靶任务，最终驶向终点，综合考验路径识别、自动避障、定点作业等多项技术能力。
教育与科研实验平台：广泛应用于高校机器人课程、嵌入式系统实训、自动控制原理教学等场景，帮助学生理解SLAM（同步定位与建图）、路径规划、电机控制等核心概念。
智能仓储与物流原型验证：迷宫环境可抽象为仓库货架间的通道网络，路径记录与优化能力可迁移至AGV（自动导引车）的调度系统开发中。
三、 关键注意事项
传感器布局与校准：
红外循迹传感器：建议采用5路一字排开布局（间距约1_{1.5cm），最左（S0）、左（S1）、中（S2）、右（S3）、最右（S4），可清晰识别直线、弯道、十字、T字等岔口。3路传感器是最低配置，识别十字路口能力较弱。传感器距地面高度需可调（通常0.5}1.5cm），过高或过低都会影响检测灵敏度。
测距传感器：前方、左侧、右侧各安装一路，用于检测墙壁距离。多个超声波传感器之间需错开安装角度，防止串扰。
传感器校准：每次上电后需进行传感器阈值校准，适应不同地面反射率和环境光照条件。
BLDC驱动选型与闭环控制：
驱动选型：多数消费级BLDC ESC设计用于航模，PWM信号频率（通常50Hz）与Arduino标准Servo库兼容，但响应延迟较大。若需高精度控制（如FOC），建议使用专用驱动芯片（如TI DRV8305 + STM32，或通过Arduino Due配合SimpleFOC库），但会增加系统复杂度。
编码器闭环：必须使用编码器实现位置闭环控制，确保机器人精确停在网格格点上。编码器安装必须严格对中，机械间隙（backlash）会引入非线性误差，需通过预紧或软件补偿消除。
PID调参：遵循"先内环后外环"原则，先调速度环至响应快速且无振荡，再接入位置环。必须加入积分限幅（Anti-windup）防止积分饱和。
电源管理与EMC防护：
电源隔离：BLDC启动电流大，严禁与Arduino共用电源。必须采用隔离DC-DC模块为控制电路独立供电，配备足够容量的锂电池（如2S 7.4V或3S 11.1V）及稳压电路，避免电压跌落导致Arduino复位。
EMC防护：高频PWM信号可能干扰模拟传感器（如红外测距），需合理布线、加装滤波电容或使用光耦隔离。动力线与信号线必须分开走线。
内存与算法优化：
内存限制：Arduino Uno仅有2KB SRAM和32KB Flash，存储迷宫地图和运行寻路算法资源紧张但可用。建议设计精简的数据结构（如用2bit编码每个格子的墙壁信息），或升级至Arduino Mega 2560（8KB SRAM）或ESP32。
算法复杂度：在资源受限的Arduino上实现A或Dijkstra算法需谨慎优化内存使用。可考虑"探索阶段用简单规则，回溯阶段加载优化路径"的分阶段策略。
机械结构与运动精度：
底盘设计：要求结构稳固，重心低，车轮材质需匹配地面（如室内光滑地面用橡胶轮防打滑）。两轮差速驱动是常见方案，万向轮辅助支撑。
里程计精度：编码器+IMU的航位推算在长时间运行中会产生漂移，建议结合环境特征（如墙角、特定标记）进行定期校正，或引入简易SLAM思想。
转向精度：转弯角度必须精确（90°/180°），可通过编码器反馈实现闭环转向控制，避免开环延时转向的累积误差。
竞赛策略与调试技巧：
分阶段调试：先单独调试循迹功能（确保直线不跑偏、弯道不脱线），再调试岔路口识别，最后调试路径优化算法。
地图一致性：竞赛场地的迷宫地图可能每次不同，机器人必须具备完全自主的探索能力，不能依赖预设地图。
时间优化：冲刺阶段的速度是竞赛成绩的关键。可通过学习曲线逐步提高速度——先以安全速度完成全程，再逐步提速至极限。

1、基础迷宫求解 —— Flood Fill + 差速驱动
场景：校园科创竞赛中最常见的未知迷宫探索任务，机器人从起点出发，需自主探索并找到迷宫中心/终点。

核心逻辑：采用经典的 Flood Fill（洪泛填充）算法，将迷宫离散化为网格，每个网格存储到目标的“距离值”，机器人始终向值更小的相邻格子移动。发现新墙时，立即重新计算（Re-flood）更新地图。

#include <SimpleFOC.h>
#include <SharpIR.h>

#define MAZE_SIZE 16
#define GOAL_X 7
#define GOAL_Y 7

// BLDC差速电机定义（motorL, motorR）
// 三个Sharp IR距离传感器（前、左、右）

int mazeMap[MAZE_SIZE][MAZE_SIZE];  // 0=未知,1=墙
int floodValues[MAZE_SIZE][MAZE_SIZE];

void setup() {
  // 初始化BLDC电机、FOC、编码器、传感器
  // 目标中心格初始值为0
  floodValues[GOAL_X][GOAL_Y] = 0;
  // 调用 floodFill() 初始化全图距离值
}

void loop() {
  // 1. 传感器采样，更新地图墙信息
  updateWallsFromSensors();
  
  // 2. 发现新墙 → 重新Flood
  floodFill();
  
  // 3. 选择最优移动方向
  int bestDir = chooseBestDirection();
  moveOneCell(bestDir);
  
  // 4. 检查是否到达目标
  if (robotX == GOAL_X && robotY == GOAL_Y) {
    stopMotors();
    // 进入“竞速冲刺模式”
  }
  delay(50);
}

void floodFill() {
  // 从目标格开始，队列式BFS向外扩展
  // 每个格子的值 = 到目标的最短步数
  // 墙阻隔的格子不更新
}

int chooseBestDirection() {
  // 比较四个方向相邻格子的flood值
  // 选择值最小的可通行方向
  // 若多个方向值相同，优先选择直行（优化转向次数）
}

关键要点：该算法在竞速迷宫（Micromouse）中被广泛使用，确保机器人总能沿着当前已知的最短路径前进。当探索完成并回到起点后，可用同一算法规划的最优路径进行高速冲刺。

2、竞速优化 —— A* + 路径平滑与指令压缩
场景：完成迷宫探索建图后，需要最快速度跑完全程的竞赛阶段，目标是减少转向次数并最大化直道速度。

核心逻辑：使用优化版A算法，在标准A基础上增加方向权重——当扩展方向与前一方向一致时给予微小奖励，从而生成“少转弯”路径。路径后处理将栅格坐标压缩为“直行N格 + 转向”的运动指令，减少单片机解析次数，同时利用BLDC的高转速特性在直道高速巡航。

#include <SimpleFOC.h>

// 16x16迷宫地图（探索完成后已知）
int mazeMap[MAZE_SIZE][MAZE_SIZE];  // 1=墙,0=空地
int openList[MAZE_SIZE * MAZE_SIZE]; // 环形队列Open表
uint8_t closedList[MAZE_SIZE][MAZE_SIZE];

struct PathNode { int x, y; int parent; };
struct PathNode path[MAX_PATH_LEN];

void setup() {
  // BLDC电机初始化、加载已探索的地图
  // 调用优化A*计算最优路径
  vector<Point> gridPath = optimizedAStar(startX, startY, goalX, goalY);
  
  // 路径压缩：栅格坐标 → 运动指令序列
  vector<MoveCmd> cmdSeq = compressPath(gridPath);
  // 示例：[(直行,3), (右转,1), (直行,5), (左转,1)]
}

// 优化版A*（裁剪到极致的嵌入式版本）
vector<Point> optimizedAStar(int sx, int sy, int gx, int gy) {
  // 1. 启发式 = 曼哈顿距离 + 方向惩罚
  //    同方向扩展 → 微小奖励，减少转弯数
  // 2. Open表用静态环形队列（不用malloc）
  // 3. Closed表用固定二维uint8_t数组
  // 4. 首次弹出目标即终止，不遍历全图
}

void loop() {
  // 顺序执行运动指令队列
  if (!cmdSeq.empty()) {
    MoveCmd cmd = cmdSeq.front();
    switch(cmd.type) {
      case STRAIGHT:
        // BLDC速度环控制，直道全速
        motorL.move(MAX_SPEED);
        motorR.move(MAX_SPEED);
        // 编码器计数达到目标距离后停止
        break;
      case TURN_LEFT:
        // 差速原地转向，IMU锁定转角
        motorL.move(-TURN_SPEED);
        motorR.move(TURN_SPEED);
        // 陀螺仪积分达到90°后停止
        break;
    }
    cmdSeq.pop_front();
  }
}

关键要点：优化版A是为资源受限的Arduino量身定制的，通过静态数组替代动态内存分配、方向加权减少转弯、环形队列加速Open表查找，大幅提升算法效率。BLDC电机在直道的高速特性与优化A生成的“少转弯路径”形成正向协同。

3、动态避障探索 —— 右墙优先 + 多传感器融合
场景：迷宫存在动态障碍物（如竞赛中临时布置的移动挡板），路径完全未知，机器人需在探索过程中实时避障并记录路径。

核心逻辑：采用“右墙优先”探索策略，结合红外/超声波传感器阵列实时检测三面墙况，动态决策转向，并通过路径队列记录探索轨迹，为后续回溯或路径优化提供数据。

#include <SimpleFOC.h>
#include <NewPing.h>

#define BASE_SPEED 0.6
#define TURN_SPEED 0.3

// 三路超声波传感器（前、左前、右前）
NewPing sonarF(TRIG_F, ECHO_F);
NewPing sonarL(TRIG_L, ECHO_L);
NewPing sonarR(TRIG_R, ECHO_R);

Queue<int> pathQueue;  // 记录动作序列：0=直行,1=左转,2=右转,3=掉头

void loop() {
  // 1. 传感器检测
  bool frontBlock = sonarF.ping_cm() < 20;
  bool leftBlock = sonarL.ping_cm() < 20;
  bool rightBlock = sonarR.ping_cm() < 20;
  
  // 2. 动态避障优先（应对突发障碍）
  if (frontBlock && !leftBlock && !rightBlock) {
    // 前方突发障碍，急减速避免碰撞
    motorL.move(OBSTACLE_SPEED);
    motorR.move(OBSTACLE_SPEED);
    delay(100);
  }
  
  // 3. 右墙优先探索决策
  if (!rightBlock) {
    // 右方通畅 → 优先右转
    turnRight();
    pathQueue.push(2);
  } else if (!frontBlock) {
    // 前方通畅 → 直行
    motorL.move(BASE_SPEED);
    motorR.move(BASE_SPEED);
    pathQueue.push(0);
  } else if (!leftBlock) {
    // 左侧通畅 → 左转
    turnLeft();
    pathQueue.push(1);
  } else {
    // 三面皆堵 → 掉头
    turnAround();
    pathQueue.push(3);
  }
  
  delay(50);
}

关键要点：“右墙优先”是迷宫探索中最稳定高效的策略之一，确保在未知环境中不遗漏任何路径。路径队列记录的动作序列可用于后续回溯或BFS路径优化。动态障碍出现时，通过急减速为避障决策留出缓冲时间。

要点解读
算法选型决定竞赛成绩天花板：校园科创竞赛中，Flood Fill因其高效性和对未知地图的自适应性，成为Micromouse类竞赛的“黄金标准”。而简单右墙优先法适合入门级探索任务，但无法保证最短路径。对于有刷电机平台，PID循迹是主流选择，但BLDC平台应充分发挥其高动态响应优势。

路径优化 = 少转弯 + 高直道速度：在竞速阶段，转向次数比路径长度更影响总时间，因为每次90°转向都需要减速→停车→转向→加速的过程。优化A*通过方向加权启发式生成“更直”的路径，配合BLDC直道高速巡航能力，能显著缩短完赛时间。

资源裁剪是Arduino平台A落地的关键：标准A在Arduino上无法运行malloc动态内存操作。工程上的解决方案包括：静态二维数组替代动态Open/Closed表、环形队列实现高效FIFO、位图存储迷宫墙信息以节约SRAM。这些都是嵌入式算法工程化的重要思维。

传感器融合与地图一致性是“看不见的坑”：机器人必须在栅格中心采样才有效，否则传感器斜射会导致墙误判。工程实践中，利用编码器里程计和IMU航向角锁定位置，确保每次“移动一格”后位于格子正中心，是避免A*规划出“撞墙路径”的基础。

运动控制与路径规划解耦：将路径规划（算法层）和路径执行（运动层）分离是优秀架构的标志。规划层输出“直行3格、右转”等高级指令，执行层负责编码器计数、PID速度控制、IMU转角锁定等底层工作。这种解耦使得算法更换不影响底层驱动调试，同时确保紧急避障中断能高优先级执行。

4、标准方格迷宫循迹（最短路径求解，竞赛经典题型）
适用场景：校园科创竞赛中最常见的方格迷宫，迷宫由黑色边界线围合，内部为白色通道，机器人需从起点沿最短路径到达终点，通道宽度固定，交叉点规则（十字路口、T字路口、死胡同）。

核心逻辑：
循迹感知：用3路TCRT5000红外循迹传感器检测黑色边界线（白色通道为基准）；
BLDC控制：左右电机差速驱动，实现直线行走与精准转向；
路径算法：采用左手定则（基础循迹）结合死胡同回溯（避免重复走死路），实现最短路径求解；
交叉点识别：通过3路传感器组合判断路口类型，触发对应转向逻辑。

/* ===== 标准方格迷宫循迹：左手定则+死胡同回溯 =====
 * 适用场景：校园方格迷宫竞赛，通道宽度适配传感器
 * 核心：3路循迹+BLDC差速+死胡同回溯，10cm通道宽度适配
 */

// ---------- 硬件定义 ----------
#define LEFT_MOTOR_IN1 3
#define LEFT_MOTOR_IN2 4
#define RIGHT_MOTOR_IN1 5
#define RIGHT_MOTOR_IN2 6

// 3路循迹传感器（左、中、右）
#define SENSOR_LEFT A0
#define SENSOR_MID A1
#define SENSOR_RIGHT A2

// 编码器引脚（左、右电机，外部中断）
#define ENC_LEFT_PIN 2
#define ENC_RIGHT_PIN 3

// ---------- 变量定义 ----------
volatile int left_pulse = 0;  // 左电机编码脉冲
volatile int right_pulse = 0; // 右电机编码脉冲
int left_target = 0;          // 左电机目标脉冲
int right_target = 0;         // 右电机目标脉冲

// 路口状态（死胡同=0，直行=1，左转=2，右转=3）
enum CrossState { DEAD = 0, STRAIGHT, LEFT, RIGHT };
CrossState current_state = STRAIGHT;

// 传感器阈值（黑色线检测，需现场调试，数值范围0-1023）
const int SENSOR_THRESHOLD = 300;
bool sensor_left = false, sensor_mid = false, sensor_right = false;

// ---------- 函数定义 ----------

// 编码器计数函数（外部中断触发）
void countLeftPulse() { left_pulse++; }
void countRightPulse() { right_pulse++; }

// 传感器状态读取（数字信号：黑线=true，白线=false）
void readSensors() {
  sensor_left = analogRead(SENSOR_LEFT) < SENSOR_THRESHOLD;
  sensor_mid = analogRead(SENSOR_MID) < SENSOR_THRESHOLD;
  sensor_right = analogRead(SENSOR_RIGHT) < SENSOR_THRESHOLD;
}

// 路口状态识别
CrossState detectCrossState() {
  readSensors();
  // 死胡同：左右传感器都检测到黑线（通道尽头）
  if (sensor_left && sensor_right) return DEAD;
  // 十字路口：中传感器未检测，左右传感器都未检测（通道中间，无分支）
  else if (!sensor_mid && !sensor_left && !sensor_right) return STRAIGHT;
  // 左转路口：左传感器未检测，右传感器检测到（左侧有分支）
  else if (!sensor_left && sensor_right) return LEFT;
  // 右转路口：右传感器未检测，左传感器检测到（右侧有分支）
  else if (sensor_left && !sensor_right) return RIGHT;
  // 默认直行（T字路口等）
  return STRAIGHT;
}

// BLDC电机控制：差速驱动（脉冲控制，精准转向）
void motorControl(int left_speed, int right_speed) {
  // 左电机
  if (left_speed > 0) {
    digitalWrite(LEFT_MOTOR_IN1, HIGH);
    digitalWrite(LEFT_MOTOR_IN2, LOW);
  } else if (left_speed < 0) {
    digitalWrite(LEFT_MOTOR_IN1, LOW);
    digitalWrite(LEFT_MOTOR_IN2, HIGH);
  } else {
    digitalWrite(LEFT_MOTOR_IN1, LOW);
    digitalWrite(LEFT_MOTOR_IN2, LOW);
  }
  analogWrite(LEFT_MOTOR_PWM, abs(left_speed)); // 引脚需补充PWM引脚，如9

  // 右电机（同上，补充PWM引脚如10）
  if (right_speed > 0) {
    digitalWrite(RIGHT_MOTOR_IN1, HIGH);
    digitalWrite(RIGHT_MOTOR_IN2, LOW);
  } else if (right_speed < 0) {
    digitalWrite(RIGHT_MOTOR_IN1, LOW);
    digitalWrite(RIGHT_MOTOR_IN2, HIGH);
  } else {
    digitalWrite(RIGHT_MOTOR_IN1, LOW);
    digitalWrite(RIGHT_MOTOR_IN2, LOW);
  }
  analogWrite(RIGHT_MOTOR_PWM, abs(right_speed));
}

// 直线行走（编码器闭环，保持直线）
void straightMove(int target_pulse) {
  left_target = target_pulse;
  right_target = target_pulse;
  left_pulse = right_pulse = 0;

  while (abs(left_pulse) < abs(left_target) && abs(right_pulse) < abs(right_target)) {
    // 差速闭环：左脉冲不足加速，右脉冲不足加速
    int left_error = left_target - abs(left_pulse);
    int right_error = right_target - abs(right_pulse);
    int left_speed = 180 + left_error * 0.5;  // 基础速度180，误差修正
    int right_speed = 180 + right_error * 0.5;
    motorControl(left_speed, right_speed);
    delay(10);
  }
  motorControl(0, 0);
}

// 左转90度（编码器计数控制转向角度）
void turnLeft() {
  left_pulse = right_pulse = 0;
  // 设定左转脉冲差（需提前测试，180脉冲对应90度）
  int turn_pulse = 180;
  while (abs(left_pulse - right_pulse) < turn_pulse) {
    motorControl(-200, 200); // 左轮反转，右轮正转，差速转向
    delay(10);
  }
  motorControl(0, 0);
}

// 右转90度（同理）
void turnRight() {
  left_pulse = right_pulse = 0;
  int turn_pulse = 180;
  while (abs(left_pulse - right_pulse) < turn_pulse) {
    motorControl(200, -200);
    delay(10);
  }
  motorControl(0, 0);
}

// 死胡同回溯（后退+180度转向）
void backtrack() {
  // 后退10cm（编码器脉冲倒退）
  left_target = right_target = -180;
  left_pulse = right_pulse = 0;
  while (abs(left_pulse) < abs(left_target)) {
    motorControl(-180, -180);
    delay(10);
  }
  motorControl(0, 0);
  // 180度转向（两次左转）
  turnLeft();
  turnLeft();
}

// ---------- 主程序 ----------
void setup() {
  // 串口调试
  Serial.begin(9600);
  // 电机引脚初始化
  pinMode(LEFT_MOTOR_IN1, OUTPUT);
  pinMode(LEFT_MOTOR_IN2, OUTPUT);
  pinMode(RIGHT_MOTOR_IN1, OUTPUT);
  pinMode(RIGHT_MOTOR_IN2, OUTPUT);
  // 编码器中断初始化
  attachInterrupt(0, countLeftPulse, RISING); // 左编码器
  attachInterrupt(1, countRightPulse, RISING); // 右编码器
  Serial.println("迷宫机器人启动，进入循迹模式");
}

void loop() {
  // 1. 识别当前路口状态
  current_state = detectCrossState();

  // 2. 按状态执行路径决策
  switch (current_state) {
    case DEAD: // 死胡同：回溯
      Serial.println("死胡同，触发回溯");
      backtrack();
      break;
    case STRAIGHT: // 直行：继续前进
      straightMove(180); // 每次前进10cm（对应180脉冲）
      break;
    case LEFT: // 左转路口：左转
      Serial.println("左转路口，执行左转");
      straightMove(90); // 先前进到路口中心
      turnLeft();
      break;
    case RIGHT: // 右转路口：右转
      Serial.println("右转路口，执行右转");
      straightMove(90);
      turnRight();
      break;
  }

  // 3. 避障传感器检测（可选，避免撞墙）
  // 加入超声波避障逻辑，此处省略，需时可补充

  delay(50); // 循环周期，避免过快触发
}

5、环形迷宫循迹（动态避障+时间优化，竞赛进阶题型）
适用场景：校园环形迷宫竞赛，通道为单向环形，部分节点有动态障碍物（如小障碍块），机器人需从起点出发，沿环形通道避开障碍物，最快到达终点，核心考验动态避障与时间优化。

核心逻辑：
循迹+避障融合：4路循迹传感器识别环形边界，2路超声波传感器检测动态障碍；
BLDC动态控制：障碍物前减速，无障时全速行驶，转向时精准差速；
算法逻辑：基于右手定则循迹，结合动态避障规则（检测到障碍时，优先绕右侧，若无右空间则减速停车等待）；
时间优化：通过编码器计算行驶距离，动态调整速度，减少不必要的停顿。

/* ===== 环形迷宫循迹：动态避障+时间优化 =====
 * 适用场景：环形迷宫竞赛，含动态障碍，核心提升行驶速度
 * 核心：4路循迹+2路超声波避障+编码器速度闭环
 */

// ---------- 硬件定义 ----------
// 电机驱动（同案例1，补充PWM引脚）
#define LEFT_PWM 9
#define RIGHT_PWM 10
#define LEFT_IN1 3
#define LEFT_IN2 4
#define RIGHT_IN1 5
#define RIGHT_IN2 6

// 4路循迹传感器
#define SENSOR_L1 A0
#define SENSOR_L2 A1
#define SENSOR_R1 A2
#define SENSOR_R2 A3

// 2路超声波（前、右）
#define ULTRA_TRIG1 7
#define ULTRA_ECHO1 8
#define ULTRA_TRIG2 11
#define ULTRA_ECHO2 12

// 编码器
#define ENC_LEFT 2
#define ENC_RIGHT 3

// ---------- 变量定义 ----------
volatile int left_enc = 0, right_enc = 0;
int left_target = 0, right_target = 0;
int ultra_front = 0, ultra_right = 0; // 超声波距离（cm）
const int SAFE_DISTANCE = 15; // 安全距离阈值（障碍距机器人15cm时避障）
const int MAX_SPEED = 220;   // 最大速度（无障时）
const int MIN_SPEED = 100;   // 最小速度（避障时）

// 循迹状态（环形通道：左边界或右边界持续存在）
bool track_left = false, track_right = false;

// ---------- 函数定义 ----------

// 编码器计数
void countLeft() { left_enc++; }
void countRight() { right_enc++; }

// 超声波测距（单路）
int measureUltra(int trig, int echo) {
  digitalWrite(trig, LOW);
  delayMicroseconds(2);
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  long duration = pulseIn(echo, HIGH);
  return duration / 29 / 2; // 厘米转换
}

// 双超声波检测
void checkObstacle() {
  ultra_front = measureUltra(ULTRA_TRIG1, ULTRA_ECHO1);
  ultra_right = measureUltra(ULTRA_TRIG2, ULTRA_ECHO2);
}

// 4路循迹传感器读取（判断环形边界）
void readTrackSensors() {
  int l1 = analogRead(SENSOR_L1);
  int l2 = analogRead(SENSOR_L2);
  int r1 = analogRead(SENSOR_R1);
  int r2 = analogRead(SENSOR_R2);
  track_left = (l1 < 300) || (l2 < 300); // 左边界存在
  track_right = (r1 < 300) || (r2 < 300); // 右边界存在
}

// 速度动态控制（避障+循迹双闭环）
void motorDrive(bool avoid_obstacle) {
  readTrackSensors();
  int base_speed = avoid_obstacle ? MIN_SPEED : MAX_SPEED;
  // 循迹闭环：左传感器检测到边界，左轮减速（靠左修正）
  int left_speed = base_speed;
  int right_speed = base_speed;
  if (track_left) left_speed -= 30; // 左偏修正
  if (track_right) right_speed -= 30; // 右偏修正

  // 避障修正：前方有障碍，减速；右侧有障碍，优先绕左
  if (ultra_front < SAFE_DISTANCE) {
    left_speed = MIN_SPEED;
    right_speed = MIN_SPEED;
    // 右侧无空间，停车等待（模拟动态障碍通过）
    if (ultra_right < SAFE_DISTANCE) {
      motorControl(0, 0);
      return;
    }
    // 右侧有空间，右转避障
    else {
      turnRightSmall(); // 小角度右转，绕开障碍
    }
  }

  // 执行驱动
  motorControl(left_speed, right_speed);
}

// 小角度右转（30度，避障用）
void turnRightSmall() {
  left_enc = right_enc = 0;
  int turn_pulse = 60; // 30度对应60脉冲
  while (abs(left_enc - right_enc) < turn_pulse) {
    motorControl(150, -150);
    delay(10);
  }
  motorControl(0, 0);
}

// 直线高速行驶（编码器闭环）
void straightFast(int pulse) {
  left_target = right_target = pulse;
  left_enc = right_enc = 0;
  bool avoid = false; // 避障标志
  while (abs(left_enc) < abs(left_target)) {
    checkObstacle();
    if (ultra_front < SAFE_DISTANCE) avoid = true;
    else avoid = false;
    motorDrive(avoid);
    delay(10);
  }
  motorControl(0, 0);
}

// 电机基础控制函数（同案例1，补充PWM引脚）
void motorControl(int left_spd, int right_spd) {
  // 左电机
  if (left_spd > 0) {
    digitalWrite(LEFT_IN1, HIGH);
    digitalWrite(LEFT_IN2, LOW);
    analogWrite(LEFT_PWM, left_spd);
  } else if (left_spd < 0) {
    digitalWrite(LEFT_IN1, LOW);
    digitalWrite(LEFT_IN2, HIGH);
    analogWrite(LEFT_PWM, -left_spd);
  } else {
    digitalWrite(LEFT_IN1, LOW);
    digitalWrite(LEFT_IN2, LOW);
    analogWrite(LEFT_PWM, 0);
  }
  // 右电机
  if (right_spd > 0) {
    digitalWrite(RIGHT_IN1, HIGH);
    digitalWrite(RIGHT_IN2, LOW);
    analogWrite(RIGHT_PWM, right_spd);
  } else if (right_spd < 0) {
    digitalWrite(RIGHT_IN1, LOW);
    digitalWrite(RIGHT_IN2, HIGH);
    analogWrite(RIGHT_PWM, -right_spd);
  } else {
    digitalWrite(RIGHT_IN1, LOW);
    digitalWrite(RIGHT_IN2, LOW);
    analogWrite(RIGHT_PWM, 0);
  }
}

// ---------- 主程序 ----------
void setup() {
  Serial.begin(9600);
  // 电机引脚初始化
  pinMode(LEFT_IN1, OUTPUT); pinMode(LEFT_IN2, OUTPUT);
  pinMode(RIGHT_IN1, OUTPUT); pinMode(RIGHT_IN2, OUTPUT);
  // 超声波引脚初始化
  pinMode(ULTRA_TRIG1, OUTPUT); pinMode(ULTRA_ECHO1, INPUT);
  pinMode(ULTRA_TRIG2, OUTPUT); pinMode(ULTRA_ECHO2, INPUT);
  // 编码器中断
  attachInterrupt(0, countLeft, RISING);
  attachInterrupt(1, countRight, RISING);
  Serial.println("环形迷宫机器人启动，进入动态避障模式");
}

void loop() {
  // 核心循迹逻辑：环形通道沿右手边行驶（右手定则）
  // 检测到右边界时保持速度，左边界时修正
  checkObstacle();
  if (ultra_front >= SAFE_DISTANCE) {
    // 无障时高速行驶
    straightFast(360); // 每步前进20cm
  } else {
    // 有障时避障处理
    motorDrive(true);
    delay(200); // 避障时延长检测周期
  }

  // 终点检测（可选：当行驶总脉冲达到终点阈值时停止）
  // 例如：总脉冲达到10000时，触发终点停止逻辑

  delay(50);
}

6、带任务点的多层迷宫求解（路径记忆+任务执行，竞赛综合题型）
适用场景：校园综合科创竞赛，迷宫为多层复合结构（地面层+二层），含多个任务点（如搬运小球、识别标记），机器人需先完成地面层任务，再沿路径上楼，完成二层任务后返回起点，考验路径记忆、任务执行、跨层导航能力。

核心逻辑：
多层循迹：地面层用3路循迹，二层用4路循迹，通过倾斜传感器识别楼层切换点；
任务执行：每个任务点配备红外触发传感器（或视觉模块简化版），触发对应机械动作（如夹爪夹取小球）；
路径记忆：用Flash存储路径节点（如节点1：起点，节点2：任务点A，节点3：楼梯口），通过编码器计算行驶距离，识别当前节点；
跨层导航：楼梯口用距离传感器识别，触发上楼/下楼动作（差速转向+坡度行驶）。

/* ===== 多层任务迷宫：路径记忆+任务执行 =====
 * 适用场景：含多层、多任务点的竞赛迷宫，核心实现路径记忆与任务联动
 * 核心：节点记忆+红外任务触发+跨层导航
 */

// ---------- 硬件定义 ----------
// 电机驱动（同前）
#define LEFT_PWM 9
#define RIGHT_PWM 10
#define LEFT_IN1 3
#define LEFT_IN2 4
#define RIGHT_IN1 5
#define RIGHT_IN2 6

// 循迹传感器（地面层3路，二层4路）
#define TRACK_G_L A0
#define TRACK_G_M A1
#define TRACK_G_R A2
#define TRACK_S_L1 A3
#define TRACK_S_R1 A4

// 任务传感器（3个任务点，红外触发）
#define TASK_1_PIN 7
#define TASK_2_PIN 8
#define TASK_3_PIN 9

// 楼层传感器（倾斜传感器，简化为数字按键触发）
#define FLOOR_SENSOR_PIN 12

// 机械夹爪（舵机）
#define CLAW_SERVO 11
#include <Servo.h>
Servo claw;

// 编码器
#define ENC_LEFT 2
#define ENC_RIGHT 3

// ---------- 变量定义 ----------
volatile int left_enc = 0, right_enc = 0;
int current_floor = 0; // 0=地面，1=二层
int current_node = 0;  // 当前路径节点（0=起点，1=任务1，2=楼梯口...）
const int NODE_DISTANCES[] = {0, 360, 720, 1080, 1440}; // 各节点累计距离（脉冲）
int total_enc = 0;     // 总行驶脉冲

// 任务执行标志
bool task1_done = false, task2_done = false, task3_done = false;

// ---------- 函数定义 ----------

// 编码器计数
void countLeft() { left_enc++; total_enc++; }
void countRight() { right_enc++; total_enc++; }

// 机械夹爪控制
void openClaw() { claw.write(0); delay(500); }
void closeClaw() { claw.write(90); delay(500); }

// 任务点触发检测与执行
void checkTask() {
  if (!task1_done && digitalRead(TASK_1_PIN) == HIGH) {
    Serial.println("到达任务点1，执行夹取动作");
    openClaw();
    closeClaw();
    task1_done = true;
    delay(1000); // 动作完成后等待
  }
  if (!task2_done && digitalRead(TASK_2_PIN) == HIGH) {
    Serial.println("到达任务点2，执行放置动作");
    openClaw();
    closeClaw();
    task2_done = true;
    delay(1000);
  }
  if (!task3_done && digitalRead(TASK_3_PIN) == HIGH) {
    Serial.println("到达任务点3，执行识别动作");
    task3_done = true;
    delay(1000);
  }
}

// 节点识别（通过总脉冲匹配预设距离）
void identifyNode() {
  for (int i = 0; i < sizeof(NODE_DISTANCES)/sizeof(int); i++) {
    if (total_enc >= NODE_DISTANCES[i] && total_enc < NODE_DISTANCES[i]+100) {
      current_node = i;
      Serial.print("当前节点:"); Serial.println(current_node);
      break;
    }
  }
}

// 楼层切换（触发倾斜传感器）
void switchFloor() {
  if (digitalRead(FLOOR_SENSOR_PIN) == HIGH) {
    current_floor = 1 - current_floor;
    Serial.print("切换到"); Serial.print(current_floor == 0 ? "地面层" : "二层"); Serial.println();
    // 楼层切换时，调整循迹传感器（切换为对应楼层的循迹逻辑）
  }
}

// 循迹驱动（按楼层适配）
void trackDrive() {
  if (current_floor == 0) {
    // 地面层：3路循迹，左手定则
    bool g_l = analogRead(TRACK_G_L) < 300;
    bool g_m = analogRead(TRACK_G_M) < 300;
    bool g_r = analogRead(TRACK_G_R) < 300;
    int left_speed = 180, right_speed = 180;
    if (g_l && !g_r) left_speed -= 20; // 左偏修正
    if (g_r && !g_l) right_speed -= 20; // 右偏修正
    motorControl(left_speed, right_speed);
  } else {
    // 二层：4路循迹，沿右侧行驶
    bool s_l1 = analogRead(TRACK_S_L1) < 300;
    bool s_r1 = analogRead(TRACK_S_R1) < 300;
    int left_speed = 180, right_speed = 180;
    if (s_r1 && !s_l1) right_speed -= 20; // 沿右边界行驶
    if (s_l1 && !s_r1) left_speed -= 20;
    motorControl(left_speed, right_speed);
  }
}

// 跨层楼梯行驶（差速爬坡，简化为固定脉冲）
void climbStairs() {
  Serial.println("开始爬楼梯");
  left_enc = right_enc = 0;
  int climb_pulse = 540; // 爬楼梯需要的脉冲（固定测试值）
  while (abs(left_enc) < climb_pulse && abs(right_enc) < climb_pulse) {
    // 保持左右轮同步，缓慢爬坡
    motorControl(120, 120);
    delay(10);
  }
  motorControl(0, 0);
  Serial.println("楼梯爬完");
}

// 电机基础控制（同前）
void motorControl(int left_spd, int right_spd) {
  if (left_spd > 0) {
    digitalWrite(LEFT_IN1, HIGH); digitalWrite(LEFT_IN2, LOW); analogWrite(LEFT_PWM, left_spd);
  } else if (left_spd < 0) {
    digitalWrite(LEFT_IN1, LOW); digitalWrite(LEFT_IN2, HIGH); analogWrite(LEFT_PWM, -left_spd);
  } else {
    digitalWrite(LEFT_IN1, LOW); digitalWrite(LEFT_IN2, LOW); analogWrite(LEFT_PWM, 0);
  }
  if (right_spd > 0) {
    digitalWrite(RIGHT_IN1, HIGH); digitalWrite(RIGHT_IN2, LOW); analogWrite(RIGHT_PWM, right_spd);
  } else if (right_spd < 0) {
    digitalWrite(RIGHT_IN1, LOW); digitalWrite(RIGHT_IN2, HIGH); analogWrite(RIGHT_PWM, -right_spd);
  } else {
    digitalWrite(RIGHT_IN1, LOW); digitalWrite(RIGHT_IN2, LOW); analogWrite(RIGHT_PWM, 0);
  }
}

// ---------- 主程序 ----------
void setup() {
  Serial.begin(9600);
  // 电机引脚初始化
  pinMode(LEFT_IN1, OUTPUT); pinMode(LEFT_IN2, OUTPUT);
  pinMode(RIGHT_IN1, OUTPUT); pinMode(RIGHT_IN2, OUTPUT);
  // 任务传感器（上拉输入）
  pinMode(TASK_1_PIN, INPUT_PULLUP);
  pinMode(TASK_2_PIN, INPUT_PULLUP);
  pinMode(TASK_3_PIN, INPUT_PULLUP);
  // 楼层传感器
  pinMode(FLOOR_SENSOR_PIN, INPUT_PULLUP);
  // 编码器中断
  attachInterrupt(0, countLeft, RISING);
  attachInterrupt(1, countRight, RISING);
  // 夹爪初始化
  claw.attach(CLAW_SERVO);
  claw.write(90); // 初始闭合
  Serial.println("多层任务迷宫机器人启动");
}

void loop() {
  // 1. 核心逻辑：节点识别→任务执行→路径驱动→楼层切换
  identifyNode();
  checkTask();
  switchFloor();
  trackDrive();

  // 2. 跨层触发（节点3为楼梯口）
  if (current_node == 3 && !task1_done) {
    climbStairs();
    current_node = 4; // 切换到二层第一个节点
  }

  // 3. 终点判断（所有任务完成+返回起点）
  if (task1_done && task2_done && task3_done && current_node == 0 && total_enc > 2000) {
    Serial.println("所有任务完成，返回起点，停车");
    motorControl(0, 0);
    while (1); // 停止运行
  }

  delay(20);
}

要点解读

1. 循迹传感器的“规则适配与阈值校准”：竞赛调试的核心基础
   校园竞赛的迷宫是标准化规则迷宫，传感器适配直接决定循迹稳定性，核心要点包括：
   传感器布局适配通道宽度：3路传感器适配10-15cm通道（案例4），4路适配15-20cm通道（案例2），布局需与迷宫通道严格匹配（传感器间距=通道宽度×0.6-0.8），避免漏检或误检；
   阈值现场校准方法：竞赛现场环境光照、地面材质（黑/白对比度）差异大，需用“实时采样+串口打印”校准：调用analogRead()读取传感器数值，找到黑色边界与白色通道的临界值（如案例1中300），用const int定义阈值，避免硬编码导致的场景失效；
   抗干扰设计：红外传感器易受环境光干扰，可加入滤波逻辑（连续3次采样一致才判断为有效信号），避免光线变化导致误触发，提升循迹鲁棒性。
2. BLDC驱动的“差速闭环与转向精度”：路径执行的核心保障
   BLDC电机是机器人移动的核心，竞赛中路径精度直接决定是否能快速通过迷宫，核心要点包括：
   差速控制的“直线精度”保障：采用编码器闭环控制（案例4-6均实现），通过左右电机脉冲计数差，动态调整速度（如左脉冲少则加速左轮），解决电机性能差异导致的直线偏离，相比开环控制，直线精度提升50%以上；
   转向的“角度量化”控制：转向角度通过编码器脉冲量化（案例4中180脉冲对应90度），需提前在赛道测试“脉冲-角度”对应关系，用固定脉冲实现精准转向，避免依赖时间控制（受电机负载影响大）；
   启动与刹车的“平稳性”优化：竞赛机器人频繁启停，直接满速启动易偏离路径，采用线性加速/减速（如案例5中从0到220逐渐加速），减少启动冲击和刹车打滑，提升路径跟踪的连贯性。
3. 迷宫求解算法的“规则适配与竞赛简化”：算法落地的核心技巧
   竞赛场景追求“算法简单、运行稳定、调试快捷”，无需复杂算法，核心要点包括：
   算法与迷宫规则强绑定：针对不同迷宫规则选对应算法，避免过度设计——方格迷宫用左手定则+死胡同回溯（案例4），环形迷宫用右手定则+动态避障（案例2），多层任务迷宫用节点记忆+距离识别（案例3），算法复杂度低，调试周期短；
   死胡同与重复路径的“避免策略”：死胡同是竞赛高频陷阱，采用回溯机制（案例4中后退+180度转向），同时通过记录已走路径（编码器累计距离）避免重复行驶，比复杂的最短路径算法（如Dijkstra）更易调试、运行更快；
   竞赛场景的“算法简化”原则：拒绝不必要的复杂算法（如SLAM），聚焦核心逻辑——用编码器累计距离替代地图构建，用传感器组合替代复杂定位，用固定转向脉冲替代视觉识别，确保1-2天内即可完成算法调试，适配竞赛准备周期。
4. 竞赛场景的“调试工具与模块化设计”：快速迭代的核心支撑
   校园竞赛时间紧迫，调试效率决定成败，核心要点包括：
   串口调试的“分层输出”设计：代码中加入分层串口打印（如传感器数值、当前状态、执行动作），通过串口监视器实时监控机器人状态，快速定位问题（如传感器异常则检查阈值，电机不转则检查驱动接线），避免盲目改代码；
   硬件模块化设计：将循迹、驱动、任务执行等功能模块化（如单独写readSensors()、motorControl()函数），硬件升级时仅修改对应模块（如传感器从3路换4路，仅改readSensors()），降低调试复杂度；
   参数的“宏定义集中管理”：将所有可调参数（如传感器阈值、脉冲对应距离、速度值）用const int或define集中定义在代码头部，调试时仅需修改宏定义，无需全局搜索修改，避免遗漏参数。
5. 竞赛现场的“应急容错与可靠性设计”：稳定得分的核心底线
   竞赛现场环境复杂，机器人易出现异常，可靠性是得分前提，核心要点包括：
   关键场景的“容错机制”：核心场景加入容错设计——死胡同回溯（案例1）、避障停车等待（案例5）、节点距离容错（案例3中100脉冲容差），避免机器人因轻微偏差陷入死循环；
   硬件保护与异常处理：加入电机过流保护（用电流采样电阻，电流过大则停机）、传感器失效备用逻辑（如循迹传感器失效，切换为超声波避障），避免硬件故障导致机器人无法运行；
   机械与电气的“竞赛级可靠性”：简化机械结构（避免复杂传动，采用直驱底盘），电气接线用端子固定（避免虚接），电池用高倍率锂电池（保证电机动力），现场准备备用代码和硬件，确保出现故障可快速切换，保障竞赛全程稳定运行。

请注意：以上案例仅作为思路拓展的参考示例，不保证完全正确、适配所有场景或可直接编译运行。由于硬件平台、实际使用场景、Arduino 版本的差异，均可能影响代码的适配性与使用方法的选择。在实际编程开发时，请务必根据自身硬件配置、使用场景及具体功能需求进行针对性调整，并通过多次实测验证效果；同时需确保硬件接线正确，充分了解所用传感器、执行器等设备的技术规范与核心特性。对于涉及硬件操作的代码，使用前务必核对引脚定义、电平参数等关键信息的准确性与安全性，避免因参数错误导致硬件损坏或运行异常。