“Arduino BLDC之家庭服务机器人——红外+IMU融合的轻量SLAM导航与避障监控”是一个典型的低成本、高集成度的嵌入式机器人系统。它利用Arduino作为核心控制器，结合无刷直流电机（BLDC）的高动态性能，通过红外传感器与惯性测量单元（IMU）的数据融合，实现轻量级的同步定位与地图构建（SLAM）以及动态避障功能。以下从主要特点、应用场景及注意事项三个方面进行详细解析。

主要特点

1. 高动态BLDC移动底盘
   底盘是机器人的“双腿”，其性能直接决定了机器人的机动性与适应性。
   卓越的动力学性能：采用BLDC轮毂电机或关节电机，相较于有刷电机，具备更高的功率密度、更快的动态响应速度和更长的使用寿命。这使得机器人能够在拥挤的环境中快速启动、制动和灵活转向，有效避开突然出现的障碍物。
   低噪声与高效率：BLDC电机的无刷结构和正弦波驱动（如FOC控制）显著降低了运行噪音和转矩脉动。这在医院、酒店等需要保持安静的服务环境中至关重要，同时高效率也延长了单次充电的续航时间。
   全向移动能力：通过差速驱动或麦克纳姆轮/全向轮布局，配合BLDC电机的精确控制，机器人可实现原地转向、侧向移动等全向运动，极大增强了在狭窄空间内的通过性和定位精度。
2. 红外与IMU融合的轻量SLAM导航
   这是机器人实现“智能化”的核心，使其能够在复杂、动态的环境中“看清”并“理解”周围世界。
   异构传感器阵列：系统融合了多种传感器的优势，构建了对环境的立体认知。例如，红外传感器作为近距离补充，用于检测玻璃、镜面等激光雷达难以识别的物体；IMU（惯性测量单元）提供高频的姿态和加速度数据，用于在传感器数据更新间隙进行状态估计和运动补偿。
   实时SLAM与动态避障：基于融合后的传感器数据，机器人运行SLAM（即时定位与地图构建）算法，实时构建并更新环境地图，确定自身位置。针对动态障碍物，采用如DWA（动态窗口法）或TEB（时间弹性带）等局部路径规划算法，实时预测障碍物运动趋势并生成平滑、安全的避障轨迹。
3. 分层式控制架构与任务调度
   为了协调复杂的硬件和算法，系统通常采用分层式控制架构，实现计算资源的合理分配。
   上位机（决策层）：采用高性能计算平台（如NVIDIA Jetson或Raspberry Pi），运行机器人操作系统（ROS），负责运行SLAM、全局路径规划、任务调度和高级人机交互逻辑。
   下位机（执行层 - Arduino）：以高性能Arduino（如Teensy 4.0/4.1或Arduino Mega）作为微控制器，负责底层的实时控制任务。它接收来自上位机的运动指令（如目标速度、转向角），通过PID或更高级的控制算法，精确控制BLDC电机的转速和位置，同时实时采集编码器、IMU和底层传感器数据，进行故障检测和紧急制动处理。

应用场景
该类机器人凭借其强大的环境适应性和多功能性，主要应用于以下动态服务领域：
家庭服务机器人：在客厅、卧室间自主移动（如递送物品），通过红外+超声波检测家具、门槛等障碍，避障精度需控制在±5cm内，避免碰撞家居。
实验室样品运输：在固定实验台之间运输试剂，沿预设路线行驶，检测到实验人员或设备时自动避让，确保样品安全。
仓储货架巡检：在仓库货架间（宽度1-1.5米）移动，检测货架立柱、托盘等障碍，通过近距离红外传感器确保不剐蹭货架。
园区巡检机器人：在工厂园区、校园内巡逻，检测围栏、路灯、行人等障碍，结合GPS辅助导航，实现大范围自主移动。
农业温室巡检：在温室大棚内检测作物长势，避开灌溉管道、育苗架等障碍，BLDC电机需适应土壤、地膜等复杂地面（防打滑）。

需要注意的事项
在实现该系统的自主导航系统时，需要关注以下事项：
传感器选择与布局：选择合适的传感器，并合理布局以确保获取准确的环境数据，避免盲区。
算法复杂度：在选择导航算法时，考虑其计算复杂度和实时性能，确保系统能够快速响应动态环境变化。
数据处理与融合：采用有效的数据处理和融合方法，减少传感器噪声和误差对导航精度的影响。
电源管理：确保系统具备良好的电源管理，防止电池不足导致的导航中断，提升小车的续航能力。
调试与测试：在不同环境下进行充分的调试与测试，确保系统在实际应用中的稳定性和可靠性。
安全机制设计：设计必要的安全机制，如碰撞检测、急停功能等，以确保小车在异常情况下能够安全停机，保护人员和设备安全。
严格的电源管理与电磁兼容（EMC）：BLDC电机在启停和差速转向时会产生极大的电流冲击和高频电磁噪声，极易导致Arduino主控复位或IMU数据失真。必须采用隔离DC-DC模块为控制电路独立供电，并在电机驱动端并联大容量低ESR电容吸收反电动势。IMU与视觉模块的信号线需使用屏蔽线，并远离动力线布线。
主控算力分配与实时性保障：视觉特征解算、IMU姿态融合与多路BLDC的FOC控制对算力要求极高。标准Arduino Uno难以胜任，建议采用ESP32、STM32或树莓派+Arduino的异构架构。控制回路必须使用硬件定时器中断或millis()非阻塞定时（建议控制频率≥50Hz），严禁使用delay()函数，以确保视觉数据与电机控制的严格同步。
IMU安装与视觉抗干扰设计：IMU必须刚性固定在底盘重心附近，并加硅胶减震垫以隔离电机高频振动。在视觉跟随算法中，需设置合理的置信度阈值，过滤低置信度的目标检测结果，避免误将墙壁或背景识别为跟随目标。同时，视觉传感器的安装位置需避免被机器人自身结构遮挡，确保足够的视场角（FOV）。
PID参数整定与安全冗余机制：跟随控制中的距离PID与转向PID参数需根据实际机械结构进行精细标定，参数过大会导致跟随抖动，过小则响应迟缓。此外，必须设置软件级限速与倾角超限保护，并配备物理急停按钮或防撞条作为最后的安全防线，确保在系统失控时能瞬间切断电机动力。

1、红外+IMU互补滤波姿态融合与轻量栅格建图
场景：家庭机器人以低速巡航，红外传感器阵列扫描周围环境，IMU提供航向角补偿里程计漂移，构建简单的占据栅格地图用于路径规划。

/* ===== 红外+IMU互补滤波 + 轻量栅格建图 =====
 * 硬件：Arduino Mega/ESP32 + SimpleFOC BLDC + MPU6050 + 红外阵列 + 编码器
 * 核心：互补滤波融合姿态 + 红外扫描更新栅格
 */
#include <SimpleFOC.h>
#include <Wire.h>
#include <MPU6050.h>

// --- BLDC 差速底盘 ---
BLDCMotor motorL(7), motorR(7);
BLDCDriver3PWM driverL(9, 10, 11, 8);
BLDCDriver3PWM driverR(3, 5, 6, 7);

// --- 红外传感器阵列（前、左、右、底部悬崖）---
const int IR_FRONT = A0;
const int IR_LEFT = A1;
const int IR_RIGHT = A2;
const int IR_BOTTOM = A3;  // 悬崖检测

MPU6050 imu;

// --- 编码器（中断读取）---
volatile long encL = 0, encR = 0;
const int ENC_L_PIN = 2, ENC_R_PIN = 3;
const float WHEEL_RADIUS = 0.05;
const float WHEEL_BASE = 0.30;
const int PULSES_PER_REV = 500;

// --- 位姿状态 ---
float posX = 0, posY = 0;
float yaw = 0;
float yawIMU = 0;

// --- 互补滤波参数 ---
const float ALPHA = 0.98;  // 陀螺仪权重

// --- 栅格地图 ---
#define GRID_SIZE 30
#define CELL_SIZE 0.20  // 20cm/格
byte grid[GRID_SIZE][GRID_SIZE];  // 0=未知, 1=空闲, 2=障碍
int robotGridX = 15, robotGridY = 15;

void IRAM_ATTR encLISR() { encL++; }
void IRAM_ATTR encRISR() { encR++; }

// 读取红外距离（简化映射）
float readIRDistance(int pin) {
  int val = analogRead(pin);
  // 红外距离与模拟值近似反比
  float dist = 1000.0 / (val + 1);  // cm
  if (dist > 80) dist = 80;
  if (dist < 5) dist = 5;
  return dist / 100.0;  // 转米
}

// 互补滤波更新航向角
void updateYaw(float dt) {
  int16_t gz;
  imu.getRotation(nullptr, nullptr, &gz);
  float gyroRate = gz / 131.0;  // 度/秒

  // 陀螺仪积分
  yawIMU += gyroRate * dt;

  // 互补滤波：陀螺仪短期积分 + 编码器长期航向
  float encYaw = yaw;  // 编码器推算的航向
  yaw = ALPHA * (yaw + gyroRate * dt) + (1 - ALPHA) * yawIMU;
}

// 编码器里程计更新
void updateOdometry() {
  static long lastEncL = 0, lastEncR = 0;
  long dL = encL - lastEncL;
  long dR = encR - lastEncR;
  lastEncL = encL;
  lastEncR = encR;

  float distL = dL * 2 * PI * WHEEL_RADIUS / PULSES_PER_REV;
  float distR = dR * 2 * PI * WHEEL_RADIUS / PULSES_PER_REV;

  float dCenter = (distL + distR) / 2.0;
  float dYaw = (distR - distL) / WHEEL_BASE;

  yaw += dYaw;
  posX += dCenter * cos(yaw);
  posY += dCenter * sin(yaw);
}

// 红外扫描更新栅格地图
void updateGrid() {
  float dFront = readIRDistance(IR_FRONT);
  float dLeft = readIRDistance(IR_LEFT);
  float dRight = readIRDistance(IR_RIGHT);

  // 机器人所在栅格
  int rx = (int)(posX / CELL_SIZE) + 15;
  int ry = (int)(posY / CELL_SIZE) + 15;

  // 前方扫描
  int cellsF = (int)(dFront / CELL_SIZE);
  for (int i = 1; i <= cellsF; i++) {
    int gx = rx + (int)(i * cos(yaw));
    int gy = ry + (int)(i * sin(yaw));
    if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {
      grid[gx][gy] = (i == cellsF) ? 2 : 1;  // 末端为障碍，中间为空闲
    }
  }

  // 左侧扫描
  int cellsL = (int)(dLeft / CELL_SIZE);
  float leftAngle = yaw + PI / 2;
  for (int i = 1; i <= cellsL; i++) {
    int gx = rx + (int)(i * cos(leftAngle));
    int gy = ry + (int)(i * sin(leftAngle));
    if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {
      grid[gx][gy] = (i == cellsL) ? 2 : 1;
    }
  }

  // 右侧扫描
  int cellsR = (int)(dRight / CELL_SIZE);
  float rightAngle = yaw - PI / 2;
  for (int i = 1; i <= cellsR; i++) {
    int gx = rx + (int)(i * cos(rightAngle));
    int gy = ry + (int)(i * sin(rightAngle));
    if (gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE) {
      grid[gx][gy] = (i == cellsR) ? 2 : 1;
    }
  }
}

void setup() {
  Serial.begin(115200);
  Wire.begin();
  imu.initialize();
  imu.setFullScaleGyroRange(MPU6050_GYRO_FS_250);

  pinMode(ENC_L_PIN, INPUT_PULLUP);
  pinMode(ENC_R_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(ENC_L_PIN), encLISR, RISING);
  attachInterrupt(digitalPinToInterrupt(ENC_R_PIN), encRISR, RISING);

  for (int x = 0; x < GRID_SIZE; x++)
    for (int y = 0; y < GRID_SIZE; y++)
      grid[x][y] = 0;

  driverL.voltage_power_supply = 24; driverL.init();
  motorL.linkDriver(&driverL); motorL.init(); motorL.initFOC();
  motorL.controller = MotionControlType::velocity;

  driverR.voltage_power_supply = 24; driverR.init();
  motorR.linkDriver(&driverR); motorR.init(); motorR.initFOC();
  motorR.controller = MotionControlType::velocity;
}

void loop() {
  motorL.loopFOC(); motorR.loopFOC();

  static unsigned long lastTime = 0;
  unsigned long now = millis();
  float dt = (now - lastTime) / 1000.0;
  lastTime = now;
  if (dt > 0.5) dt = 0.05;

  updateOdometry();
  updateYaw(dt);
  updateGrid();

  // 简单避障：前方红外检测到障碍则转向
  float dFront = readIRDistance(IR_FRONT);
  float v = 0.25, w = 0;

  if (dFront < 0.25) {
    v = 0.1;
    w = (readIRDistance(IR_LEFT) > readIRDistance(IR_RIGHT)) ? 0.5 : -0.5;
  }

  motorL.move(v - w * WHEEL_BASE / 2);
  motorR.move(v + w * WHEEL_BASE / 2);

  delay(30);
}

核心要点：互补滤波的核心是“陀螺仪短期精确、编码器长期稳定”。陀螺仪积分在几秒内非常准确，但会累积漂移；编码器航向在转弯时可靠，但直线行驶时因轮子打滑会逐渐偏航。ALPHA = 0.98 意味着 98% 信任陀螺仪短期变化，2% 用长期基准修正漂移。栅格地图的增量更新只标记红外扫描到的栅格，不进行全图重算，适合 Arduino 有限算力。

2、三层安全监控与分级响应
场景：家庭环境中机器人需要“远-中-近”三层防护：SLAM 全局路径避开已知障碍，红外检测中距动态障碍，底部红外检测悬崖防止跌落，每层触发不同响应级别。

/* ===== 三层安全监控 + 分级响应 =====
 * 硬件：Arduino + SimpleFOC BLDC + 红外阵列（前/底） + IMU
 * 核心：远(SLAM) → 中(红外) → 近(悬崖) 三级安全链
 */
#include <SimpleFOC.h>
#include <Wire.h>
#include <MPU6050.h>

BLDCMotor motorL(7), motorR(7);
BLDCDriver3PWM driverL(9, 10, 11, 8);
BLDCDriver3PWM driverR(3, 5, 6, 7);

MPU6050 imu;

// --- 红外传感器 ---
const int IR_FRONT = A0;    // 前方中距
const int IR_LEFT = A1;     // 左侧
const int IR_RIGHT = A2;    // 右侧
const int IR_BOTTOM_L = A3; // 底部悬崖左
const int IR_BOTTOM_R = A4; // 底部悬崖右

// --- 安全等级 ---
enum SafetyLevel { LEVEL_NORMAL, LEVEL_CAUTION, LEVEL_AVOID, LEVEL_EMERGENCY };
SafetyLevel safetyLevel = LEVEL_NORMAL;

// --- 参数 ---
const float SAFE_FRONT = 0.30;    // 前方安全距离 (m)
const float CAUTION_FRONT = 0.50; // 前方警戒距离
const float CLIFF_THRESHOLD = 0.15; // 悬崖检测阈值 (m)

float yaw = 0;

// 读取红外距离
float readIR(int pin) {
  int val = analogRead(pin);
  float dist = 1000.0 / (val + 1);
  if (dist > 80) dist = 80;
  if (dist < 3) dist = 3;
  return dist / 100.0;
}

// 三层安全评估
void evaluateSafety() {
  float dFront = readIR(IR_FRONT);
  float dLeft = readIR(IR_LEFT);
  float dRight = readIR(IR_RIGHT);
  float dCliffL = readIR(IR_BOTTOM_L);
  float dCliffR = readIR(IR_BOTTOM_R);

  // 第一层：悬崖检测（最高优先级）
  if (dCliffL < CLIFF_THRESHOLD || dCliffR < CLIFF_THRESHOLD) {
    safetyLevel = LEVEL_EMERGENCY;
    return;
  }

  // 第二层：近距障碍
  if (dFront < SAFE_FRONT) {
    safetyLevel = LEVEL_AVOID;
    return;
  }

  // 第三层：中距警戒
  if (dFront < CAUTION_FRONT) {
    safetyLevel = LEVEL_CAUTION;
    return;
  }

  safetyLevel = LEVEL_NORMAL;
}

// 分级响应执行
void executeResponse() {
  float dFront = readIR(IR_FRONT);
  float dLeft = readIR(IR_LEFT);
  float dRight = readIR(IR_RIGHT);

  float v = 0, w = 0;

  switch (safetyLevel) {
    case LEVEL_NORMAL:
      v = 0.30;
      w = 0;
      break;

    case LEVEL_CAUTION:
      v = 0.20;  // 减速
      w = 0;
      break;

    case LEVEL_AVOID:
      v = 0.10;  // 极低速
      // 哪边空间大往哪边转
      if (dLeft > dRight) w = 0.6;
      else w = -0.6;
      break;

    case LEVEL_EMERGENCY:
      v = -0.15;  // 后退
      w = 0;
      // 后退 300ms 后停止
      motorL.move(v);
      motorR.move(v);
      delay(300);
      motorL.move(0);
      motorR.move(0);
      return;
  }

  float wheelBase = 0.30;
  motorL.move(v - w * wheelBase / 2);
  motorR.move(v + w * wheelBase / 2);
}

void setup() {
  Serial.begin(115200);
  Wire.begin();
  imu.initialize();

  driverL.voltage_power_supply = 24; driverL.init();
  motorL.linkDriver(&driverL); motorL.init(); motorL.initFOC();
  motorL.controller = MotionControlType::velocity;

  driverR.voltage_power_supply = 24; driverR.init();
  motorR.linkDriver(&driverR); motorR.init(); motorR.initFOC();
  motorR.controller = MotionControlType::velocity;
}

void loop() {
  motorL.loopFOC(); motorR.loopFOC();

  evaluateSafety();
  executeResponse();

  // 调试
  static unsigned long lastPrint = 0;
  if (millis() - lastPrint > 300) {
    lastPrint = millis();
    Serial.print("Level:"); Serial.print(safetyLevel);
    Serial.print(" Front:"); Serial.println(readIR(IR_FRONT), 2);
  }

  delay(20);
}

核心要点：三层安全监控的关键是优先级明确、响应分级。悬崖检测作为第一层（LEVEL_EMERGENCY），因为跌落对家庭机器人可能是致命性的；近距障碍作为第二层（LEVEL_AVOID），触发转向避让；中距警戒作为第三层（LEVEL_CAUTION），仅减速不转向。家庭场景中，红外传感器对黑色家具、深色地毯的检测能力弱于超声波，但响应速度更快，适合作为“最后一道防线”。

3、红外扫描式局部定位与动态避障
场景：机器人不使用复杂SLAM，而是通过红外传感器扫描周围环境，识别“墙壁/障碍轮廓”，结合IMU航向角进行简单的局部定位与动态避障，适合成本敏感的家庭机器人。

/* ===== 红外扫描局部定位 + 动态避障 =====
 * 硬件：Arduino + 伺服云台 + 红外测距 + IMU
 * 核心：扫描式环境感知 + 局部极坐标定位
 */
#include <SimpleFOC.h>
#include <Servo.h>
#include <Wire.h>
#include <MPU6050.h>

BLDCMotor motorL(7), motorR(7);
BLDCDriver3PWM driverL(9, 10, 11, 8);
BLDCDriver3PWM driverR(3, 5, 6, 7);

MPU6050 imu;
Servo scanServo;

// --- 扫描参数 ---
const int SCAN_MIN = 0;      // 最小角度
const int SCAN_MAX = 180;    // 最大角度
const int SCAN_STEP = 15;    // 步进角度
const int SCAN_COUNT = (SCAN_MAX - SCAN_MIN) / SCAN_STEP + 1;

float scanDist[SCAN_COUNT];
int scanIdx = 0;
unsigned long lastScan = 0;

// --- 避障参数 ---
const float SAFE_DIST = 0.35;  // 安全距离 (m)
float yaw = 0;

// 红外测距（简化）
float readIRDistance() {
  int val = analogRead(A0);
  float dist = 1000.0 / (val + 1);
  if (dist > 80) dist = 80;
  if (dist < 5) dist = 5;
  return dist / 100.0;
}

// IMU航向角更新
void updateYaw() {
  int16_t gz;
  imu.getRotation(nullptr, nullptr, &gz);
  yaw += (gz / 131.0) * 0.02;  // 度 → 弧度近似
}

// 扫描更新
void updateScan() {
  if (millis() - lastScan < 40) return;
  lastScan = millis();

  int angle = SCAN_MIN + scanIdx * SCAN_STEP;
  scanServo.write(angle);
  delay(15);  // 等待舵机到位

  scanDist[scanIdx] = readIRDistance();

  scanIdx = (scanIdx + 1) % SCAN_COUNT;
}

// 查找最安全方向
int findSafestDirection() {
  int bestIdx = 0;
  float maxDist = 0;

  for (int i = 0; i < SCAN_COUNT; i++) {
    if (scanDist[i] > maxDist) {
      maxDist = scanDist[i];
      bestIdx = i;
    }
  }

  // 转换为相对角度（0-180 → -90~90）
  int angle = SCAN_MIN + bestIdx * SCAN_STEP;
  return angle - 90;
}

// 前方障碍检测
float getFrontDistance() {
  // 取中间三个扫描点
  int mid = SCAN_COUNT / 2;
  float minDist = 10;
  for (int i = mid - 1; i <= mid + 1; i++) {
    if (i >= 0 && i < SCAN_COUNT) {
      minDist = min(minDist, scanDist[i]);
    }
  }
  return minDist;
}

void setup() {
  Serial.begin(115200);
  Wire.begin();
  imu.initialize();

  scanServo.attach(9);
  scanServo.write(90);

  driverL.voltage_power_supply = 24; driverL.init();
  motorL.linkDriver(&driverL); motorL.init(); motorL.initFOC();
  motorL.controller = MotionControlType::velocity;

  driverR.voltage_power_supply = 24; driverR.init();
  motorR.linkDriver(&driverR); motorR.init(); motorR.initFOC();
  motorR.controller = MotionControlType::velocity;

  // 初始化扫描数据
  for (int i = 0; i < SCAN_COUNT; i++) scanDist[i] = 2.0;
}

void loop() {
  motorL.loopFOC(); motorR.loopFOC();

  updateYaw();
  updateScan();

  float frontDist = getFrontDistance();
  float v = 0.25, w = 0;

  if (frontDist < SAFE_DIST) {
    // 前方有障碍：查找最安全方向
    int safeDir = findSafestDirection();
    v = 0.10;
    w = safeDir * 0.015;  // 根据安全方向转向

    // 限幅
    w = constrain(w, -0.8, 0.8);
  }

  float wheelBase = 0.30;
  motorL.move(v - w * wheelBase / 2);
  motorR.move(v + w * wheelBase / 2);

  delay(20);
}

核心要点：扫描式定位的优点是用一个红外传感器获得 180° 视野，成本远低于多传感器阵列。程序中的 findSafestDirection() 遍历扫描数据找到距离最大的方向，作为避障转向的目标。这种方法在家庭环境中特别有效，因为家具和墙壁的反射率稳定，红外扫描能可靠地勾勒出房间轮廓。IMU 航向角用于将扫描数据从“机器人坐标系”转换到“世界坐标系”，实现简单的局部定位。

要点解读

1. 红外+IMU 融合的本质是“互补”，而非“冗余”
   红外传感器提供环境信息（障碍物距离、悬崖），但易受光照和表面反射率影响；IMU 提供自身状态（姿态、航向），但存在积分漂移。两者融合的价值在于：IMU 在红外帧间提供高频姿态预测，红外在校正时提供绝对参考。互补滤波中的 ALPHA = 0.98 意味着系统 98% 信任陀螺仪的短期变化，2% 用长期基准修正漂移，这是轻量级 Arduino 上最实用的融合策略。

2. 家庭 SLAM 的“够用原则”：不需要厘米级精度，但需要绝对安全
   工业 SLAM 追求高精度建图，家庭 SLAM 的核心约束是安全。三层安全监控（悬崖→近距→中距）是家庭机器人的“生存底线”。悬崖检测必须独立于 SLAM 主循环运行，因为跌落对家庭机器人可能是致命的。程序案例二的 LEVEL_EMERGENCY 响应（后退+停止）必须优先于所有其他逻辑。

3. 栅格地图的增量更新比全图重构更适合 Arduino
   家庭环境的地图变化缓慢（家具基本固定），但 Arduino 算力有限。程序案例一中的栅格更新只标记红外扫描到的栅格，不进行全图重算。20×20 的 byte 数组仅占 400 字节，远小于完整概率栅格地图的内存需求。对于更大的家庭环境，可采用“滚动窗口栅格”——只维护机器人周围的局部地图。

4. 红外传感器在家庭场景中的“盲区”必须通过布局补偿
   红外传感器对黑色物体（深色沙发、黑色地毯）检测距离会显著缩短，对透明物体（玻璃茶几）几乎无反射。程序案例一和案例二都部署了多方向红外（前/左/右/底），通过空间冗余补偿单一传感器的盲区。家庭机器人应优先选择数字红外传感器（如 E18-D80NK），其阈值可调，对黑色物体的检测稳定性优于模拟红外。

5. BLDC+FOC 在家庭机器人中的价值是“安静且精确”
   家庭场景对噪音敏感，有刷电机的换相啸叫和齿槽效应会产生明显噪音。BLDC 配合 FOC 的正弦驱动使电机运行更安静，低速下转矩脉动小，适合家庭夜间巡航。同时，FOC 的速度闭环控制使编码器里程计数据更平滑，间接改善了轻量 SLAM 的位姿估计质量。SimpleFOC 库的 estimated_current 模式在无电流传感器时提供了近似力矩控制，进一步降低了硬件成本。

红外+IMU融合的轻量SLAM基础导航程序（核心：场地构建与基础定位）
适用场景：家庭客厅、餐厅等开阔区域，机器人实现基础环境扫描、地图构建与自主导航，完成物品递送、区域巡检等基础服务。

核心逻辑
融合红外测距与IMU姿态数据，实现漂移补偿，提升定位精度
基于红外采集的边界点，简化构建场地轮廓地图
根据定位结果，控制机器人避障并前往目标位置

// 红外+IMU融合轻量SLAM基础导航程序
// 硬件：3路红外测距+MPU6050 IMU+2轮BLDC驱动
// 功能：家庭开阔区域地图构建、定位与基础避障导航

#include <Arduino.h>
#include <Wire.h>
#include <MPU6050.h>

// ========== 硬件引脚定义 ==========
const byte IR_LEFT = A0, IR_RIGHT = A1, IR_FRONT = A2; // 红外测距引脚
const byte PWM_LEFT = 6, DIR_LEFT = 7, PWM_RIGHT = 8, DIR_RIGHT = 9; // BLDC驱动引脚

// ========== SLAM核心参数 ==========
float robotX = 0.0, robotY = 0.0;   // 机器人坐标（基于起点）
float headingAngle = 0.0;            // 航向角（度，北为0，顺时针增加）
float moveSpeed = 30.0;              // 移动速度（cm/s）
float lastGyroAngle = 0.0;           // 上一次陀螺仪累加角度
const float STEP_DISTANCE = 2.0;     // 每步采样距离（cm）
const float POSITION_UPDATE_RATE = 50.0; // 定位更新周期（ms）

// 简易地图（记录红外检测到的边界，0为可通行，1为障碍）
#define MAP_SIZE 100
byte simpleMap[MAP_SIZE][MAP_SIZE];
bool mapInitialized = false;

MPU6050 mpu;
unsigned long lastUpdateTime = 0;

// ========== 函数声明 ==========
void initIMU();
float getHeading();
void updateOdometry();
void scanEnvironment();
void updateMap();
void避障Navigate(float targetX, float targetY);
void driveMotor(float left, float right);

void setup() {
  Serial.begin(115200);
  Serial.println("红外+IMU融合SLAM导航系统初始化完成");

  // 初始化IMU
  Wire.begin();
  initIMU();

  // 初始化地图
  for (int i=0; i<MAP_SIZE; i++){
    for (int j=0; j<MAP_SIZE; j++){
      simpleMap[i][j] = 0;
    }  }
  mapInitialized = true;

  // 初始化驱动引脚
  pinMode(PWM_LEFT, OUTPUT); pinMode(DIR_LEFT, OUTPUT);
  pinMode(PWM_RIGHT, OUTPUT); pinMode(DIR_RIGHT, OUTPUT);
}

void loop() {
  uint32_t now = millis();
  // 周期更新定位与地图
  if (now - lastUpdateTime > POSITION_UPDATE_RATE) {
    updateOdometry();       // 1. 融合IMU更新定位
    scanEnvironment();      // 2. 红外扫描环境
    updateMap();            // 3. 更新地图
    lastUpdateTime = now;
  }

  // 导航到目标位置（示例：前方100cm，右侧50cm）
  Navigate(100.0, 50.0);
  delay(10);
}

// 初始化MPU6050
void initIMU() {
  if (!mpu.begin(MPU6050_SCALE_2000DPS)) {
    Serial.println("MPU6050初始化失败！");
    while (1);
  }
  mpu.setGyroRange(MPU6050_GYRO_2000DPS);
  mpu.setAccelRange(MPU6050_ACCEL_2G);
  mpu.setSleepEnabled(false);
}

// 获取航向角（融合陀螺仪，漂移补偿）
float getHeading() {
  mpu.update();
  float gyroZ = mpu.getGyroZ();  // 陀螺仪Z轴角速度（°/s）
  // 角速度积分更新角度，定期复位基准
  headingAngle += gyroZ * 0.01;  // 采样周期10ms
  // 简易校准：超过360度归零，减少累积误差
  if (headingAngle > 360.0) headingAngle -= 360.0;
  if (headingAngle < 0.0) headingAngle += 360.0;
  return headingAngle;
}

// 融合IMU与编码器，更新里程计定位
void updateOdometry() {
  float currentHeading = getHeading();
  // 模拟编码器获取移动距离（此处简化，实际需接入编码器计数）
  float moveDistance = getEncoderDistance(); // 实际场景需实现编码器读取函数
  // 极坐标转笛卡尔坐标，更新位置
  float deltaX = moveDistance * cos(radians(currentHeading));
  float deltaY = moveDistance * sin(radians(currentHeading));
  robotX += deltaX / STEP_DISTANCE;
  robotY += deltaY / STEP_DISTANCE;
}

// 红外扫描环境障碍
void scanEnvironment() {
  float irLeft = analogRead(IR_LEFT) * 0.1;
  float irRight = analogRead(IR_RIGHT) * 0.1;
  float irFront = analogRead(IR_FRONT) * 0.1;
  // 检测障碍范围，超出安全距离标记为障碍
  if (irFront < 150.0) {
    int mapX = (int)robotX;
    int mapY = (int)robotY;
    if (mapX >=0 && mapX < MAP_SIZE && mapY >=0 && mapY < MAP_SIZE) {
      simpleMap[mapX][mapY] = 1; // 标记前方障碍
    }
  }
}

// 更新简易地图，简化构建场地轮廓
void updateMap() {
  // 将当前位置及周边区域标记为已扫描
  int cx = (int)robotX;
  int cy = (int)robotY;
  for (int i=max(0, cx-2); i<min(MAP_SIZE, cx+3); i++){
    for (int j=max(0, cy-2); j<min(MAP_SIZE, cy+3); j++){
      // 未标记且无障碍的区域标记为已探索
      if (simpleMap[i][j] !=1) {
        simpleMap[i][j] = 2; // 2为已探索可通行区域
      }
    }
  }
}

// 基础避障导航：走向目标位置，遇障避让
void Navigate(float targetX, float targetY) {
  float dx = targetX - robotX;
  float dy = targetY - robotY;
  float distance = sqrt(dx*dx + dy*dy);
  if (distance < 5.0) {
    driveMotor(0.0, 0.0); // 到达目标，停止
    Serial.println("到达目标位置");
    return;
  }

  // 计算目标航向
  float targetHeading = degrees(atan2(dy, dx));
  float headingDiff = targetHeading - headingAngle;
  // 航向角归一化，避免正负跳变
  if (headingDiff > 180.0) headingDiff -= 360.0;
  if (headingDiff < -180.0) headingDiff += 360.0;

  // 前方有障碍，优先避让
  float irFront = analogRead(IR_FRONT) * 0.1;
  if (irFront < 100.0) {
    // 左转避障
    if (abs(headingDiff) > 0) {
      driveMotor(moveSpeed * 0.5, moveSpeed * 1.0);
    }
    return;
  }

  // 调整航向并前进
  if (abs(headingDiff) > 5.0) {
    // 航向偏差大，差速转向修正
    if (headingDiff > 0) {
      driveMotor(moveSpeed * 0.7, moveSpeed);
    } else {
      driveMotor(moveSpeed, moveSpeed * 0.7);
    }
  } else {
    // 航向正确，直行
    driveMotor(moveSpeed, moveSpeed);
  }
}

// 电机驱动函数
void driveMotor(float left, float right) {
  left = constrain(left, 0.0, 255.0);
  right = constrain(right, 0.0, 255.0);
  digitalWrite(DIR_LEFT, HIGH); analogWrite(PWM_LEFT, (int)left);
  digitalWrite(DIR_RIGHT, HIGH); analogWrite(PWM_RIGHT, (int)right);
}

// 编码器测距（简化函数，实际需根据编码器实现）
float getEncoderDistance() {
  static unsigned long prevLeft = 0, prevRight = 0;
  unsigned long leftCount = readEncoder(LEFT_ENCODER); // 需实现编码器读取函数
  unsigned long rightCount = readEncoder(RIGHT_ENCODER);
  long leftDelta = leftCount - prevLeft;
  long rightDelta = rightCount - prevRight;
  prevLeft = leftCount;
  prevRight = rightCount;
  // 计数转换为实际距离（需按轮径标定）
  return (leftDelta + rightDelta) * 0.05;
}

适用场景优化
可增加边界跟踪算法，沿墙壁行驶，提升场地扫描的完整性
优化IMU校准逻辑，定期根据已知位置修正累积误差，提升长期定位精度
扩展地图存储，记录探索过的全局区域，支持多轮次导航任务

5、红外+IMU融合SLAM+动态避障监控程序（核心：障碍识别与避障控制）
适用场景：家庭走廊、家具密集的卧室等场景，机器人需实时监控障碍物，实现动态避障，避免碰撞家具、宠物或人员。

核心逻辑
融合多路红外传感器，实现全方位障碍识别
基于IMU定位与红外数据，判断障碍类型与避障路径
实时调整行驶方向，实现绕障、跟墙等动态避障

// 红外+IMU融合SLAM+动态避障监控程序
// 硬件：5路红外测距（前+左右前+后）+MPU6050+2轮BLDC
// 功能：家具密集区域动态避障，监控环境变化，安全导航

#include <Arduino.h>
#include <Wire.h>
#include <MPU6050.h>

// ========== 硬件定义 ==========
const byte IR_F = A0, IR_FL = A1, IR_FR = A2, IR_L = A3, IR_R = A4; // 5路红外
const byte PWM_L = 6, DIR_L = 7, PWM_R = 8, DIR_R = 9;

// ========== 避障与SLAM参数 ==========
float robotX = 0.0, robotY = 0.0, headingAngle = 0.0;
const float SAFE_DIST = 80.0;    // 安全距离（cm）
const float MIN_DIST = 30.0;     // 最小避障距离（cm）
const float BASE_SPEED = 25.0;   // 基础速度
float obstacleInfo[5] = {0};     // 存储各红外检测距离

// ========== 函数声明 ==========
void readIMU();
void scanAllInfrared();
void判断避障Strategy();
void updatePosition();
void driveMotor(float l, float r);

void setup() {
  Serial.begin(115200);
  Serial.println("动态避障SLAM系统初始化完成");

  Wire.begin();
  mpu.begin(MPU6050_SCALE_2000DPS);

  for (byte i=0; i<5; i++) {
    pinMode(IR_F+i, INPUT);
  }
  pinMode(PWM_L, OUTPUT); pinMode(DIR_L, OUTPUT);
  pinMode(PWM_R, OUTPUT); pinMode(DIR_R, OUTPUT);
}

void loop() {
  readIMU();              // 1. 读取姿态
  scanAllInfrared();      // 2. 多路红外扫描
  judge避障Strategy();    // 3. 制定避障策略
  updatePosition();       // 4. 更新定位
  delay(15);
}

// 读取IMU，更新航向角
void readIMU() {
  mpu.update();
  float gyroZ = mpu.getGyroZ();
  headingAngle += gyroZ * 0.01;
  headingAngle = fmodf(headingAngle, 360.0);
  if (headingAngle < 0) headingAngle += 360.0;
}

// 采集5路红外距离
void scanAllInfrared() {
  obstacleInfo[0] = analogRead(IR_F) * 0.1;   // 前方
  obstacleInfo[1] = analogRead(IR_FL) * 0.1;  // 左前
  obstacleInfo[2] = analogRead(IR_FR) * 0.1;  // 右前
  obstacleInfo[3] = analogRead(IR_L) * 0.1;   // 左侧
  obstacleInfo[4] = analogRead(IR_R) * 0.1;   // 右侧

  // 异常值过滤，避免干扰
  for (byte i=0; i<5; i++) {
    if (obstacleInfo[i] < 10.0 || obstacleInfo[i] > 300.0) {
      obstacleInfo[i] = 300.0; // 超大值视为无障碍
    }
  }
}

// 制定避障策略
void judge避障Strategy() {
  float frontDist = obstacleInfo[0];
  float leftDist = obstacleInfo[3];
  float rightDist = obstacleInfo[4];
  float leftFrontDist = obstacleInfo[1];
  float rightFrontDist = obstacleInfo[2];

  // 前方无障碍，正常前进
  if (frontDist > SAFE_DIST) {
    driveMotor(BASE_SPEED, BASE_SPEED);
    return;
  }

  // 前方障碍距离适中，判断绕障方向
  if (frontDist > MIN_DIST) {
    // 左侧空间充足，左侧绕障
    if (leftFrontDist > frontDist + 50.0 && leftDist > SAFE_DIST) {
      driveMotor(BASE_SPEED * 0.6, BASE_SPEED); // 左转绕障
    }
    // 右侧空间充足，右侧绕障
    else if (rightFrontDist > frontDist + 50.0 && rightDist > SAFE_DIST) {
      driveMotor(BASE_SPEED, BASE_SPEED * 0.6); // 右转绕障
    }
    // 左右空间均不足，减速直行寻找避障空间
else {
      driveMotor(BASE_SPEED * 0.3, BASE_SPEED * 0.3);
    }
    return;
  }

  // 后方无障碍，倒车避让（极端情况）
  float rearDist = getRearDistance(); // 需补充后方红外或估算
  if (rearDist > SAFE_DIST) {
    driveMotor(-BASE_SPEED * 0.8, -BASE_SPEED * 0.8); // 倒车
    return;
  }

  // 全向空间不足，紧急停止
  driveMotor(0.0, 0.0);
  Serial.println("警告：全向障碍，紧急停止");
}

// 更新定位（简化逻辑，同案例1）
void updatePosition() {
  float deltaHeading = headingAngle - lastHeading;
  float distance = getEncoderDistance();
  robotX += distance * cos(radians(headingAngle));
  robotY += distance * sin(radians(headingAngle));
  lastHeading = headingAngle;
}

// 电机驱动
void driveMotor(float l, float r) {
  l = constrain(l, -255.0, 255.0);
  r = constrain(r, -255.0, 255.0);
  if (l >=0) { digitalWrite(DIR_L, HIGH); analogWrite(PWM_L, (int)l); }
  else { digitalWrite(DIR_L, LOW); analogWrite(PWM_L, (int)abs(l));}
  if (r >=0) { digitalWrite(DIR_R, HIGH); analogWrite(PWM_R, (int)r); }
  else { digitalWrite(DIR_R, LOW); analogWrite(PWM_R, (int)abs(r)); }
}

// 获取后方距离（简化，可补充红外或估算）
float getRearDistance() {
  // 无后方红外时，基于历史定位估算，此处返回安全距离
  return 200.0;
}

// 编码器测距函数（同案例1，需按实际实现）
float getEncoderDistance() {
  return 2.0 / 10.0; // 按实际轮径与采样周期计算
}

适用场景优化
加入动态障碍识别，区分固定家具与移动物体（如宠物、人），提升避障针对性
优化避障路径规划，结合SLAM地图选择最优绕障路线，减少绕行距离
增加速度自适应，障碍越近速度越低，提升安全性

6、红外+IMU融合SLAM+导航监控与异常保护程序（核心：安全运行与状态监控）
适用场景：家庭全场景服务，机器人需实时监控自身状态、定位精度与运行环境，异常时快速响应，保障设备与居家安全。

核心逻辑
监控SLAM定位状态、传感器健康与电机运行状态
检测定位漂移、传感器故障、电机异常等风险
异常时触发保护机制，推送告警，确保安全停机或调整运行

// 红外+IMU融合SLAM+导航监控与异常保护程序
// 硬件：红外+IMU+BLDC+蜂鸣器+状态指示灯
// 功能：全场景运行监控，异常保护，保障服务安全

#include <Arduino.h>
#include <Wire.h>
#include <MPU6050.h>

// ========== 监控与保护参数 ==========
const byte BUZZER = 10;    // 异常蜂鸣器
const byte LED_OK = 11;   // 正常运行指示灯
const byte LED_ERR = 12;  // 异常指示灯

float robotX = 0.0, robotY = 0.0, headingAngle = 0.0;
float lastX = 0.0, lastY = 0.0;// 辅助判断定位异常
bool imuError = false, irError = false, motorError = false;
bool shutdown = false;

// 监控阈值
const float POSITION_DRIFT = 50.0; // 定位漂移阈值（cm）
const float BATTERY_LOW = 20.0;    // 低电量阈值（%）（需接入电压采集）
unsigned long errorStartTime = 0;

// ========== 函数声明 ==========
void monitorIMU();
void monitorInfrared();
void monitorMotor();
void checkProtect();
void driveMotor(float l, float r);
void triggerFault();

void setup() {
  Serial.begin(115200);
  Serial.println("导航监控与异常保护系统初始化完成");

  pinMode(BUZZER, OUTPUT);
  pinMode(LED_OK, OUTPUT);
  pinMode(LED_ERR, OUTPUT);

  Wire.begin();
  mpu.begin(MPU6050_SCALE_2000DPS);
}

void loop() {
  monitorIMU();       // 1. 监控IMU状态
  monitorInfrared();  // 2. 监控红外传感器
  monitorMotor();     // 3. 监控电机状态
  checkProtect();     // 4. 异常保护判断
  // 正常时执行基础导航
  if (!shutdown) {
    basicNavigate();
  } else {
    driveMotor(0.0, 0.0);
  }
  delay(20);
}

// 监控IMU健康状态
void monitorIMU() {
  bool currentImuOk = mpu.update();
  if (!currentImuOk) {
    imuError = true;
  } else {
    // 检测航向角跳变，判断IMU数据异常
    float currentHeading = mpu.getGyroZ() * 0.01;
    if (abs(currentHeading - headingAngle) > 180.0) {
      imuError = true;
    } else {
      imuError = false;
    }
  }
}

// 监控红外传感器状态
void monitorInfrared() {
  int irFront = analogRead(IR_F);
  // 传感器异常（输出固定值或断线）判断
  if (irFront == 0 || irFront == 1023) {
    irError = true;
  } else {
    irError = false;
  }
}

// 监控电机运行状态
void monitorMotor() {
  // 检测电机堵转：电流过大且转速为零（需接入电流采集，此处简化）
  if (getMotorCurrent() > 800) {
    motorError = true;
  } else {
    motorError = false;}
}

// 异常保护判断与执行
void checkProtect() {
  // 定位漂移检测：无位移但航向变化过大，判断为定位异常
  float dist = sqrtf((robotX-lastX)*(robotX-lastX) + (robotY-lastY)*(robotY-lastY));
    if (dist < 1.0 && getHeadingChange() > 20.0) {
      errorStartTime = millis();
  }

  float driftTime = millis() - errorStartTime;

  // 任一异常触发立即保护
  if (imuError || irError || motorError) {
    triggerFault();
    shutdown = true;
     return;
  }

  // 定位漂移超时，触发告警并暂停
  if (driftTime > 1000.0) {
    triggerFault();
    shutdown = true;
  }

  // 低电量保护
  float batteryVoltage = getBatteryVoltage();
  if (batteryVoltage < BATTERY_LOW) {
    Serial.println("警告：低电量，需尽快返航");
    driveMotor(-BASE_SPEED * 0.5, -BASE_SPEED * 0.5);
  }
}

// 触发异常告警
void triggerFault() {
  digitalWrite(LED_ERR, HIGH);
  digitalWrite(LED_OK, LOW);
  // 蜂鸣器间歇鸣叫
  for (byte i=0; i<3; i++) {
    digitalWrite(BUZZER, HIGH);
    delay(150);
    digitalWrite(BUZZER, LOW);
    delay(150);
  }
  Serial.println("系统异常，触发保护！");
  errorStartTime = millis();
}

// 基础导航（简化，同案例1）
void basicNavigate() {
  digitalWrite(LED_OK, HIGH);
  digitalWrite(LED_ERR, LOW);
  driveMotor(25.0, 25.0);
}

// 电机驱动
void driveMotor(float l, float r) {
  l = constrain(l, -255.0, 255.0);
  r = constrain(r, -255.0, 255.0);
  if (l >=0) { digitalWrite(PWM_L, HIGH); analogWrite(PWM_L, (int)l);}
  else { digitalWrite(PWM_L, LOW); analogWrite(PWM_L, (int)abs(l)); }
  if (r >=0) { digitalWrite(PWM_R, HIGH); analogWrite(PWM_R, (int)r);}
  else { digitalWrite(PWM_R, LOW); analogWrite(PWM_R, (int)abs(r)); }
}

// 辅助函数：获取航向变化量
float getHeadingChange() {
  return headingAngle - lastHeadingAngle;
}
float getMotorCurrent() {
  // 需接入电流采样电路，此处返回模拟值
  return analogRead(A5);
}
float getBatteryVoltage() {
  // 需接入电压采集，此处返回模拟值
  return analogRead(A6) * 0.03;
}

适用场景优化
增加远程状态上报功能，异常时向用户推送告警，提升运维效率
优化异常恢复逻辑，传感器短暂异常后自动复位，避免频繁停机
加入机器人姿态保护，检测到倾翻风险时自动调整轮端力矩，防止摔倒

要点解读
要点1：红外+IMU融合是轻量SLAM的核心，互补优势提升精度
红外与IMU的特性互补，是低成本实现SLAM的关键。
功能互补：红外测距擅长检测近距离障碍、环境边界，成本低、响应快，但存在检测盲区；IMU可获取航向、姿态数据，实现陀螺仪测角与加速度计测速，弥补红外无法检测方向、动态角速度的不足
漂移补偿：单独使用IMU存在累积漂移问题，结合红外检测的边界、障碍特征，可定期校准定位，修正长距离行驶的累积误差，提升长期定位精度
低成本适配：两类器件体积小、功耗低、价格亲民，适配家庭服务机器人的轻量化、低成本需求，无需依赖激光雷达等高成本传感器

要点2：低漂移定位需结合多源校准，保障导航可靠性
轻量SLAM的定位精度依赖持续校准，避免误差累积。
IMU标定与滤波：需在开机时完成IMU的零点校准、温度补偿，运行中采用卡尔曼滤波等算法处理陀螺仪与加速度计数据，抑制噪声干扰，减少姿态测量误差
边界特征校准：利用红外检测到的墙壁、家具等固定边界，结合航向角换算实际坐标，作为定位基准，定期修正里程计漂移，确保定位长期准确
里程计标定：准确标定编码器与轮径、行驶距离的对应关系，减少移动距离计算误差，为定位提供可靠的位移输入

要点3：多红外协同实现全方位避障，适配家庭复杂环境
家庭环境障碍物密集、形状多样，需通过多红外协同实现可靠避障。
多路红外布局：采用前、左前、右前、左、右的布局，实现前向与侧向全覆盖，减少检测盲区，精准判断障碍位置与距离
动态避障策略：根据障碍距离、周边空间，灵活选择绕障、减速、跟随等策略，例如家具间隙狭窄时贴边行驶，移动障碍时快速避让，适配不同障碍类型
环境自适应：针对不同家居环境（空旷客厅、狭窄走廊、家具密集卧室），调整红外检测阈值与避障速度，提升环境适应能力

要点4：SLAM地图需轻量化存储与高效应用，平衡性能与精度
轻量SLAM的地图需兼顾计算效率与导航需求，适配Arduino等低算力平台。
地图简化设计：采用栅格地图或特征点地图，替代高精度全量地图，记录障碍位置、可通行区域等关键信息，减少存储与计算压力，适配轻量级硬件
增量构建：机器人行驶过程中动态更新地图，仅存储已探索区域与障碍信息，避免冗余，提升地图构建效率
地图复用：将构建的地图保存至存储模块，支持开机加载，避免重复扫描，提升机器人多次巡查的效率

要点5：运行监控与异常保护是安全底线，保障居家场景可靠运行
家庭场景人员活动频繁、环境多变，必须完善监控与保护机制。
状态全景监控：实时监控传感器（红外、IMU）、定位、电机、电量等核心状态，全方位掌握机器人运行情况，及时发现异常隐患
异常分级响应：将异常分为轻、中、重三级，轻微异常减速预警，中度异常暂停校准，严重异常紧急停机，避免或减少碰撞、故障等风险
安全防护设计：加入急停控制、倒车避险、低电量返航等保护逻辑，异常时优先保障家居与人的安全，适配家庭使用的高安全要求

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