Arduino BLDC 模糊逻辑+多模式自适应清洁机器人的核心是通过模糊逻辑控制器（FLC）将传感器模糊输入转化为BLDC多电机协同指令，使机器人能根据地面类型、脏污程度和障碍物分布动态切换工作模式，实现无需精确数学模型的智能清洁。
一、 系统架构与核心原理
该系统由三大核心模块构成：
感知层：超声波/红外/ToF 传感器（避障）、灰尘检测传感器（脏污程度判断）、IMU（姿态与坡度检测）、悬崖传感器（防跌落）、沿墙传感器等。
决策层（模糊逻辑控制器）：将传感器精确数值模糊化为语言变量（如"较近"“适中”“较远”），通过预设的"If-Then"规则库进行推理，输出去模糊化后的精确控制量（如电机转速、转向角度、吸力档位）。
执行层（多BLDC电机协同）：行走轮 BLDC（差速驱动）、主滚刷/吸尘风机 BLDC（高速吸力）、边刷 BLDC（边缘清扫），各电机根据模糊控制器输出独立调速。
其本质是：模糊逻辑负责"判断该怎么做"，BLDC 电机负责"精准执行"。
二、 主要特点
. 模糊逻辑驱动的智能决策
模糊逻辑控制（FLC）的核心优势在于不依赖精确数学模型，而是模拟人类经验决策过程。
突破二值逻辑：传统控制基于"是/否"判断，模糊逻辑引入隶属度函数，允许变量处于"部分真"状态。例如，灰尘浓度不再是"有/无"，而是"轻微"“中等”"严重"的模糊概念，更贴近人类判断方式。
规则库驱动：通过预设的"If-Then"规则实现控制。例如：
“如果前方距离较近，且左侧距离较远，则向左急转”
“如果灰尘浓度严重，且地面为地毯，则提升吸力至最大档并降低速度”
“如果检测到台阶边缘，则立即后退并切换方向”
自适应参数调整：高级设计中，模糊控制器可动态调整 PID 参数（Kp、Ki、Kd），根据工况自动优化控制性能。
. 多模式自适应切换
"多模式"是该系统的核心差异化特征，机器人能根据环境感知结果自动切换工作模式：
标准清扫模式：平坦硬质地面，中速行走，中等吸力，边刷常开。
深度清洁模式：灰尘传感器检测到高浓度脏污区域，自动降低速度、提升吸尘风机转速至最大，主滚刷加大压力。
沿墙清扫模式：沿墙传感器检测到墙壁，保持恒定距离沿边清扫，边刷单侧加速。
地毯增压模式：通过电流检测或地面类型识别，检测到地毯后提升吸力并降低行走速度。
避障/脱困模式：超声波/碰撞传感器触发，执行后退-转向-绕行策略。
节能巡航模式：电量低于阈值时，降低所有电机功率，优先返回充电座。
. 多BLDC电机协同驱动
BLDC 电机在该系统中承担三大功能，各司其职：
行走驱动（差速架构）：两台 BLDC 构成差速驱动，实现前进、后退、原地转向。BLDC 的高效率和长寿命适合长时间连续运行。
吸尘风机（高速 BLDC）：驱动高速风机产生吸力，空载转速可达 24000 转/分以上，需具备抗风阻波动能力。
滚刷/边刷（中低速 BLDC）：主滚刷拍打地面去除灰尘，边刷将角落垃圾扫向主吸口。滚刷电机需具备堵转保护和反转脱困能力（应对毛发缠绕）。
. 强鲁棒性与抗干扰能力
模糊逻辑对传感器噪声和测量误差具有天然容忍度。即使超声波传感器偶尔出现跳变，模糊控制器也能通过隶属度函数平滑处理，避免机器人产生剧烈抖动或误判。
三、 应用场景
. 家庭室内清洁机器人
在家具布局复杂、存在宠物或儿童的室内环境中，模糊避障系统能确保安全运行，同时根据地面类型（木地板/瓷砖/地毯）自动切换清洁策略。
. 楼梯自适应清洁机器人
通过行星轮与麦克纳姆轮结合的机构，配合水平开关和超声波传感器判断所处状态（平地/楼梯），自动在"平地清洁模式"和"楼梯清洁模式"之间切换，实现复式楼房的全覆盖清洁。
. 户外/半户外清洁机器人
在沙滩、停车场、工厂车间等非结构化环境中，通过 LiDAR + IMU 感知地形坡度和表面类型，模糊控制器动态调整刷头高度、刷速和行走速度，实现自适应清洁。
. 工业 AGV 清洁车
在仓库、车间等人机协作区域，模糊避障系统使清洁车能灵活绕开随机走动的工人或临时堆放的货物，同时根据区域脏污程度自适应调整清洁强度。
. 教育与竞赛平台
作为控制工程课程案例，演示模糊控制理论在实际机器人系统中的完整应用，涵盖传感器融合、多电机协同、模式切换等核心知识点。
四、 需要注意的事项
. 模糊规则库的设计与完备性
这是系统成败的关键。规则库必须覆盖所有可能的环境状态组合，规则缺失会导致特定场景下无输出、机器人失控。初始规则通常基于经验试凑，需通过大量实地测试反复调整隶属度函数形状和规则内容，消除震荡或死锁现象。
. 多传感器融合与数据预处理
单一传感器存在盲区和精度限制。建议融合超声波（测距远）、红外/ToF（精度高、响应快）甚至 LiDAR（构建局部地图）的数据。在输入模糊控制器前，应对传感器数据进行滑动平均或中值滤波处理，消除剧烈跳变。
. Arduino 平台计算资源限制
模糊推理（特别是复杂规则库和重心法去模糊化）需要一定计算时间。标准 Arduino Uno（8 位 AVR）难以支撑高频（>100Hz）模糊控制环，建议采用 ESP32（双核 240MHz）、Teensy 4.1 或 STM32 等高性能平台，确保控制周期稳定（建议 < 50ms）。
. 多电机 EMI 干扰与电源管理
多个 BLDC 电机同时工作时，功率器件开关噪声大，存在 EMI 互相干扰。需注意：
功率区与信号区 PCB 布局分离，编码器信号线与功率线保持间距。
母线侧并联高频陶瓷电容与电解电容组合，抑制电压纹波。
电机动力电源与 Arduino 逻辑电源共地但独立供电，避免电机启动电流导致主控重启。
. 安全与故障冗余
模糊逻辑是软件层面的控制，一旦软件跑飞或传感器完全失效，机器人可能失控。必须设计：
硬件急停按钮或碰撞开关作为最后一道安全防线。
看门狗（Watchdog）和传感器自检功能，检测到关键传感器失效时立即进入安全模式（减速停止）。
低电量保护：电压低于阈值时自动切断电机并返回充电座。

1、基础三向模糊避障控制器
此案例实现了最基础的多传感器融合避障。它通过前、左、右三个方向的传感器获取环境信息，利用模糊逻辑推理出平滑的转向指令，避免传统“非左即右”的硬逻辑带来的顿挫感。

#include <Fuzzy.h> // 引入模糊逻辑库 [citation:1]

// 引脚定义
#define FRONT_PIN A0
#define LEFT_PIN A1
#define RIGHT_PIN A2
#define MOTOR_L_PWM 9
#define MOTOR_R_PWM 10

Fuzzy *fuzzy = new Fuzzy();

void setup() {
  // 1. 初始化模糊控制器输入（距离）和输出（电机速度）[citation:1]
  fuzzy->addInput("FrontDistance", 0, 30, 5);
  fuzzy->addInput("LeftDistance", 0, 30, 5);
  fuzzy->addInput("RightDistance", 0, 30, 5);
  fuzzy->addOutput("MotorSpeed", -255, 255, 5);

  // 2. 定义模糊规则（核心决策逻辑）[citation:1]
  // 示例规则：如果前方近且左侧远，则快速左转
  fuzzy->addRule("FrontDistance : Near & LeftDistance : Far => MotorSpeed : Fast_Left");
  fuzzy->addRule("FrontDistance : Near & RightDistance : Far => MotorSpeed : Fast_Right");
  // 更多规则可根据实际场景补充...
}

void loop() {
  // 3. 读取传感器并模糊化 [citation:1]
  int fDist = analogRead(FRONT_PIN);
  int lDist = analogRead(LEFT_PIN);
  int rDist = analogRead(RIGHT_PIN);
  
  // 4. 执行模糊推理
  fuzzy->setInput("FrontDistance", map(fDist, 0, 1023, 0, 30));
  fuzzy->setInput("LeftDistance", map(lDist, 0, 1023, 0, 30));
  fuzzy->setInput("RightDistance", map(rDist, 0, 1023, 0, 30));
  fuzzy->compute();

  // 5. 解模糊得到控制量，驱动BLDC电机（差速转向）[citation:1]
  int speed = fuzzy->getOutput("MotorSpeed");
  // 通过限制输出范围防止电机失控 [citation:1]
  analogWrite(MOTOR_L_PWM, constrain(speed + 100, 0, 255)); 
  analogWrite(MOTOR_R_PWM, constrain(100 - speed, 0, 255));
  
  delay(50);
}

2、多模式自适应清洁策略
此案例在基础避障上增加了模式识别。机器人能根据传感器数据判断当前所处的环境（如开阔区域、窄通道、沿墙），并自动切换到相应的清洁策略，实现更高效的任务执行。

// 定义工作模式
enum RobotMode { EXPLORE, WALL_FOLLOW, NARROW_PASSAGE };
RobotMode currentMode = EXPLORE;

void loop() {
  // 1. 读取多传感器数据
  int front = analogRead(FRONT_PIN);
  int left = analogRead(LEFT_PIN);
  int right = analogRead(RIGHT_PIN);

  // 2. 环境识别与模式切换（简易状态机）[citation:3]
  if (front < 200 && left > 100 && right > 100) {
    currentMode = EXPLORE; // 前方有障，两侧开阔 -> 探索避障
  } else if (left < 150 || right < 150) {
    currentMode = WALL_FOLLOW; // 一侧有墙 -> 沿墙清扫
  } else if (left < 80 && right < 80) {
    currentMode = NARROW_PASSAGE; // 两侧都很近 -> 窄通道直行
  }

  // 3. 根据模式执行不同的模糊控制逻辑
  int turnAdjust = 0;
  int baseSpeed = 100;

  switch (currentMode) {
    case EXPLORE:
      // 调用案例一中的模糊避障逻辑
      // ...
      break;
    case WALL_FOLLOW:
      // 沿墙逻辑：根据与墙的距离误差进行微调 [citation:7]
      float wallError = (left < right) ? left - 150 : right - 150;
      turnAdjust = wallError * 1.5;
      baseSpeed = 80; // 沿墙时速度稍慢
      break;
    case NARROW_PASSAGE:
      // 窄通道逻辑：尽量居中直行
      float centerError = left - right;
      turnAdjust = centerError * 2.0;
      baseSpeed = 60; // 狭窄空间慢速通过
      break;
  }

  // 4. 驱动电机
  analogWrite(MOTOR_L_PWM, constrain(baseSpeed - turnAdjust, 0, 255));
  analogWrite(MOTOR_R_PWM, constrain(baseSpeed + turnAdjust, 0, 255));
  delay(50);
}

3、基于IMU的姿态稳定与爬坡控制
此案例针对更复杂的清洁环境，通过IMU（惯性测量单元）检测机器人的姿态，在爬坡或颠簸路面动态调整电机功率和主刷转速，实现稳定的清洁效果。

#include <MPU6050_tockn.h> // MPU6050库 [citation:7]
MPU6050 mpu6050(Wire);

float targetPitch = 0.0; // 目标俯仰角（水平）
float motorPower = 0.0;

void setup() {
  Wire.begin();
  mpu6050.begin();
  mpu6050.calcGyroOffsets(true); // 校准陀螺仪零偏 [citation:7]
  // ...BLDC电机初始化...
}

void loop() {
  // 1. 读取IMU当前俯仰角 [citation:7]
  mpu6050.update();
  float currentPitch = mpu6050.getAngleX();

  // 2. 爬坡控制：根据俯仰角误差动态调节电机功率
  float error = targetPitch - currentPitch;
  motorPower = constrain(error * 5.0, -255, 255); // 比例控制 [citation:7]

  // 3. 主刷电机自适应调速：爬坡时降低主刷转速防止过载
  float baseBrushSpeed = 150;
  float adjustedBrushSpeed = baseBrushSpeed * (1 - abs(error) * 0.02);
  // brushMotor.move(adjustedBrushSpeed); // 驱动主刷BLDC

  // 4. 将功率指令输出到驱动轮BLDC电机
  // motorL.move(motorPower); 
  // motorR.move(motorPower);

  delay(10);
}

要点解读
模糊逻辑是平滑决策的关键：与传统的“阈值判断”不同，模糊逻辑通过“隶属度函数”将传感器数值转换为“近、中、远”等模糊概念，并通过“If-Then”规则库进行决策。这使得机器人的动作更加平滑、拟人化，能有效避免因传感器微小波动导致的剧烈抖动和顿挫感。在设计规则时，需要根据实际场景灵活调整，例如近距离的障碍物应获得更高的避障权重。

多模式切换让清洁有“策略”：单一的模糊规则无法应对所有环境。通过与有限状态机结合，机器人可以根据环境特征（如开阔、沿墙、窄通道）切换不同的模糊规则集或控制参数。例如，在开阔区域以“弓”字形覆盖清扫；检测到墙壁后，则切换到“沿墙”模式，利用沿墙传感器保持恒定距离进行精准的边缘清扫。

BLDC+闭环控制是精准执行的保障：模糊逻辑输出的控制指令，需要通过BLDC电机的高性能驱动来精准落实。采用FOC（磁场定向控制）算法可以实现对BLDC电机的力矩、速度和位置的高精度闭环控制。配合编码器或霍尔传感器的速度反馈，机器人可以避免因打滑或负载变化导致的轨迹偏差，确保“指哪打哪”。

多传感器融合是环境感知的基础：可靠的避障和模式切换依赖于对环境的准确感知。典型的配置包括用于探测障碍的超声波/红外传感器、用于沿墙检测的侧向红外传感器、用于防跌落的悬崖传感器，以及用于姿态感知的IMU。这些传感器各有优劣，需要结合使用，以弥补单一传感器的盲区和噪声问题。

警惕算力瓶颈，采用分层架构：完整的SLAM建图、全局路径规划（如A*、Dijkstra算法）对算力要求很高，远超标准Arduino（如Uno）的能力。成熟的工程方案普遍采用分层架构：
决策层（上位机）：通常由树莓派、Jetson Nano或ESP32等高性能芯片担任，负责SLAM、全局路径规划、地图构建和用户交互等复杂任务。
执行层（下位机）：Arduino（或ESP32的部分内核）作为协处理器，专职负责高频的传感器数据采集、电机PID闭环控制、模糊逻辑快速决策和紧急制动等硬实时任务。这既保证了系统性能，也发挥了Arduino在底层控制上的优势。

4、家庭自适应吸尘拖地机器人——模糊避障+双模式切换
适用场景：家庭客厅、卧室等复杂家具环境，需同时完成吸尘（毛发、灰尘）与拖地（污渍、水渍），核心需求是应对家具/墙角等不规则障碍的模糊避障、吸拖模式按需切换、地面材质自适应。

核心逻辑：采用模糊逻辑感知避障（多传感器融合模糊化处理），避免碰撞家具/卡困；基于地面材质（地毯/硬地板）与脏污程度（灰尘/水渍），自动切换“强力吸尘（地毯）”“静音吸尘（硬地板）”“湿拖+轻吸（水渍）”三模式；BLDC驱动轮组实现低噪音、高扭矩的平稳移动，适配家庭多地形。

/* ===== 家庭自适应吸尘拖地机器人：模糊避障 + 双模式切换 =====
 * 硬件：Arduino ESP32 + BLDC差速底盘 + 前方/侧向红外传感器 + 灰尘传感器 + 湿度传感器 + 吸尘/拖地执行机构
 * 核心：模糊避障逻辑 + 地面材质/脏污自适应模式 + BLDC差速控制
 */
#include <SimpleFOC.h>

// --- 硬件驱动定义 ---
BLDCMotor motorL(7), motorR(7);          // BLDC驱动左右轮
BLDCDriver3PWM driverL(9,10,11,8);       // 左轮驱动
BLDCDriver3PWM driverR(3,5,6,7);         // 右轮驱动
const int IRFrontPin = A0;                // 前方障碍物红外
const int IRLeftPin = A1, IRRightPin = A2;// 侧向避障红外
const int dustSensorPin = A3;             // 灰尘传感器（输出值越大灰尘越多）
const int humiditySensorPin = A4;         // 地面湿度传感器
const int vacuumPin = 13, mopPumpPin = 12;// 吸尘风机、拖地水泵

// --- 模糊避障与模式参数 ---
#define DUST_CLEAN_THRESH 300             // 灰尘清洁阈值
#define HUMID_WET_THRESH 200              // 地面潮湿阈值
float fuzzyObstacleOutput = 0;             // 模糊避障输出
int currentMode = 0;                       // 0:强力吸尘 1:静音吸尘 2:湿拖+轻吸

// --- 模糊避障核心：多传感器模糊化+规则推理 ---
float fuzzyAvoidObstacle(int frontVal, int leftVal, int rightVal) {
  // 距离归一化（传感器值越小障碍越近）
  float frontNorm = map(frontVal, 0, 1023, 1.0, 0.0);
  float leftNorm = map(leftVal, 0, 1023, 1.0, 0.0);
  float rightNorm = map(rightVal, 0, 1023, 1.0, 0.0);
  
  // 模糊化：障碍距离分为“远（F）、中（M）、近（C）”
  float frontF = frontNorm > 0.7 ? 1.0 : (frontNorm > 0.4 ? (frontNorm-0.4)/0.3 : 0);
  float frontM = frontNorm > 0.4 && frontNorm <= 0.7 ? 1.0 : 0;
  float frontC = frontNorm <= 0.4 ? 1.0 : (frontNorm > 0.7 ? (0.7-frontNorm)/0.3 : 0);
  
  float leftC = leftNorm <= 0.3 ? 1.0 : 0;   // 左侧有障碍
  float rightC = rightNorm <= 0.3 ? 1.0 : 0; // 右侧有障碍
  
  // 模糊规则库（避障优先级：前方>侧方）
  float turnOut = 0;
  if (frontC > 0.5) {          // 前方近→紧急避让
    if (leftC > 0.8) turnOut = -0.8; // 左有障碍→右转
    else if (rightC > 0.8) turnOut = 0.8; // 右有障碍→左转
    else turnOut = 0.5;                // 两侧无障碍→右转避让
  } else if (leftC > 0.7) {    // 左侧近→右转远离
    turnOut = 0.6;
  } else if (rightC > 0.7) {   // 右侧近→左转远离
    turnOut = -0.6;
  }
  
  return constrain(turnOut, -0.7, 0.7);
}

// --- 多模式自适应切换逻辑 ---
void adaptiveModeSwitch() {
  int dustVal = analogRead(dustSensorPin);
  int humidVal = analogRead(humiditySensorPin);
  
  // 规则1：地面潮湿+灰尘少→湿拖+轻吸模式
  if (humidVal > HUMID_WET_THRESH && dustVal < DUST_CLEAN_THRESH) {
    currentMode = 2;
    analogWrite(vacuumPin, 100);  // 轻吸
    analogWrite(mopPumpPin, 150); // 湿拖（小流量）
  }
  // 规则2：灰尘多→强力吸尘模式
  else if (dustVal > DUST_CLEAN_THRESH) {
    currentMode = 0;
    analogWrite(vacuumPin, 255);  // 全功率吸尘
    analogWrite(mopPumpPin, 0);   // 关闭拖地
  }
  // 规则3：灰尘少+地面干燥→静音吸尘模式
  else {
    currentMode = 1;
    analogWrite(vacuumPin, 80);   // 静音吸尘（低功率）
    analogWrite(mopPumpPin, 0);   // 关闭拖地
  }
}

void setup() {
  Serial.begin(115200);
  // BLDC初始化
  motorL.linkDriver(&driverL); motorR.linkDriver(&driverR);
  driverL.voltage_power_supply = 12; driverR.voltage_power_supply = 12;
  driverL.init(); driverR.init();
  motorL.controller = MotionControlType::velocity;
  motorR.controller = MotionControlType::velocity;
  motorL.init(); motorR.init(); motorL.initFOC(); motorR.initFOC();
  // 执行机构初始化
  pinMode(vacuumPin, OUTPUT); pinMode(mopPumpPin, OUTPUT);
  digitalWrite(vacuumPin, LOW); digitalWrite(mopPumpPin, LOW);
}

void loop() {
  motorL.loopFOC(); motorR.loopFOC();
  
  // 1. 传感器数据采集
  int frontVal = analogRead(IRFrontPin);
  int leftVal = analogRead(IRLeftPin);
  int rightVal = analogRead(IRRightPin);
  
  // 2. 模糊避障输出
  fuzzyObstacleOutput = fuzzyAvoidObstacle(frontVal, leftVal, rightVal);
  
  // 3. 自适应模式切换
  adaptiveModeSwitch();
  
  // 4. 差速控制（基础速度+避障修正）
  float baseSpeed = (currentMode == 0) ? 0.4 : 0.3; // 强力吸尘速度略高
  float leftSpd = baseSpeed - fuzzyObstacleOutput;
  float rightSpd = baseSpeed + fuzzyObstacleOutput;
  
  // 执行电机控制
  motorL.move(leftSpd);
  motorR.move(rightSpd);
  
  // 调试输出
  Serial.print("Mode:");Serial.print(currentMode);
  Serial.print(" FuzzyOut:");Serial.print(fuzzyObstacleOutput);
  Serial.println();
  
  delay(50);
}

5、商用大面积自适应扫洗一体机器人——模糊导航+多区域模式
适用场景：商场、写字楼大厅等大面积开阔区域，需完成清扫（垃圾、纸屑）与洗地（油污、泥渍），核心需求是大范围高效覆盖、多区域自适应（开阔区/窄通道）、清扫/洗地模式切换。

核心逻辑：基于模糊逻辑的导航与区域适配，开阔区域采用“弓字形全覆盖”模式，窄通道采用“沿边精细化”模式；通过超声波识别区域宽度，结合地面脏污类型（纸屑/油污），自适应切换“清扫优先”“洗地优先”或“扫洗同步”模式；BLDC提供持续高扭矩，满足长时间大负载运行需求。

/* ===== 商用大面积自适应扫洗一体机器人：模糊导航 + 多区域模式 =====
 * 硬件：Arduino ESP32 + BLDC差速底盘 + 前方/侧向超声波 + 垃圾识别传感器 + 油污识别传感器 + 扫刷/洗地执行机构
 * 核心：模糊区域适配 + 多模式覆盖清扫 + BLDC持续驱动
 */
#include <SimpleFOC.h>

// --- 硬件驱动定义 ---
BLDCMotor motorL(7), motorR(7);
BLDCDriver3PWM driverL(9,10,11,8);
BLDCDriver3PWM driverR(3,5,6,7);
const int ultraFrontPin = A0;          // 前方超声波（测距）
const int ultraLeftPin = A1, ultraRightPin = A2;// 侧向超声波（测区域宽度）
const int garbageSensorPin = A3;       // 垃圾识别（纸屑/硬物）
const int oilSensorPin = A4;           // 油污识别（输出值越大油污越重）
const int sweepMotorPin = 13, washMotorPin = 12;// 扫刷、洗地电机

// --- 模糊区域与模式参数 ---
#define WIDE_AREA_THRESH 150           // 开阔区域宽度阈值（cm）
#define REGION_MODE 0;                 // 0:开阔区 1:窄通道
#define OIL_WASH_THRESH 350            // 油污洗地阈值

float fuzzyRegionOutput = 0;            // 模糊区域适配输出
int currentCleanMode = 0;               // 0:清扫优先 1:洗地优先 2:扫洗同步

// --- 模糊区域适配核心：根据区域宽度自适应导航模式 ---
float fuzzyRegionAdapt(int frontWidth, int leftWidth, int rightWidth) {
  // 区域宽度归一化（超声波值越大，区域越宽）
  float avgWidth = (frontWidth + leftWidth + rightWidth) / 3.0;
  float normWidth = map(avgWidth, 0, 500, 0.0, 1.0);
  
  // 模糊化：区域宽度分为“窄（N）、中（M）、宽（W）”
  float widthN = normWidth <= 0.3 ? 1.0 : 0;      // 窄通道
  float widthM = normWidth > 0.3 && normWidth <= 0.6 ? 1.0 : 0; // 中等区域
  float widthW = normWidth > 0.6 ? 1.0 : 0;       // 开阔区域
  
  // 模糊规则：宽度适配导航策略
  float speedOut = 0, turnOut = 0;
  if (widthW > 0.8) {        // 开阔区→高速弓字形覆盖
    speedOut = 0.6;
    turnOut = 0.15; // 小转向角，实现弓字形路径
  } else if (widthN > 0.8) { // 窄通道→低速沿边精细化
    speedOut = 0.3;
    turnOut = 0.4; // 大转向角，沿边清扫
  } else {                  // 中等区域→平衡速度
    speedOut = 0.45;
    turnOut = 0.25;
  }
  
  return speedOut; // 返回基础速度，转向由规则单独控制
}

// --- 多模式自适应清洁逻辑 ---
void adaptiveCleanMode() {
  int garbageVal = analogRead(garbageSensorPin);
  int oilVal = analogRead(oilSensorPin);
  
  // 规则1：油污重→洗地优先
  if (oilVal > OIL_WASH_THRESH) {
    currentCleanMode = 1;
    analogWrite(sweepMotorPin, 60);  // 低转速扫刷
    analogWrite(washMotorPin, 200);  // 高流量洗地
  }
  // 规则2：垃圾多且油污少→清扫优先
  else if (garbageVal > 200 && oilVal < OIL_WASH_THRESH) {
    currentCleanMode = 0;
    analogWrite(sweepMotorPin, 200); // 高转速扫刷
    analogWrite(washMotorPin, 50);   // 低流量洗地
  }
  // 规则3：垃圾少且油污中等→扫洗同步
  else {
    currentCleanMode = 2;
    analogWrite(sweepMotorPin, 150); // 中转速扫刷
    analogWrite(washMotorPin, 120);  // 中流量洗地
  }
}

void setup() {
  Serial.begin(115200);
  // BLDC初始化
  motorL.linkDriver(&driverL); motorR.linkDriver(&driverR);
  driverL.voltage_power_supply = 12; driverR.voltage_power_supply = 12;
  driverL.init(); driverR.init();
  motorL.controller = MotionControlType::velocity;
  motorR.controller = MotionControlType::velocity;
  motorL.init(); motorR.init(); motorL.initFOC(); motorR.initFOC();
  // 执行机构初始化
  pinMode(sweepMotorPin, OUTPUT); pinMode(washMotorPin, OUTPUT);
  digitalWrite(sweepMotorPin, LOW); digitalWrite(washMotorPin, LOW);
}

void loop() {
  motorL.loopFOC(); motorR.loopFOC();
  
  // 1. 区域与脏污数据采集
  int frontWidth = analogRead(ultraFrontPin);
  int leftWidth = analogRead(ultraLeftPin);
  int rightWidth = analogRead(ultraRightPin);
  
  // 2. 模糊区域适配（获取基础速度）
  float baseSpeed = fuzzyRegionAdapt(frontWidth, leftWidth, rightWidth);
  
  // 3. 自适应清洁模式切换
  adaptiveCleanMode();
  
  // 4. 路径生成（弓字形/沿边）
  float turnOut = 0;
  int avgWidth = (frontWidth + leftWidth + rightWidth)/3;
  if (avgWidth > WIDE_AREA_THRESH) turnOut = 0.15; // 开阔区小转向
  else turnOut = 0.4; // 窄通道大转向
  
  // 差速控制
  float leftSpd = baseSpeed - turnOut;
  float rightSpd = baseSpeed + turnOut;
  
  motorL.move(leftSpd);
  motorR.move(rightSpd);
  
  // 调试输出
  Serial.print("CleanMode:");Serial.print(currentCleanMode);
  Serial.print(" Speed:");Serial.print(baseSpeed);
  Serial.println();
  
  delay(100);
}

6、工业仓储自适应深度清洁机器人——模糊负载+多强度模式
适用场景：工业仓储车间，地面存在厚灰尘、顽固油污、重物残留等重度脏污，核心需求是高负载自适应（地面阻力变化）、清洁强度自适应（轻度/重度）、窄通道精准导航。

核心逻辑：采用模糊逻辑的负载感知，通过电流检测BLDC负载，结合油污/灰尘类型，自适应调整电机输出扭矩与清洁强度（刷盘压力、清洁剂流量）；针对仓储窄通道，采用模糊沿边导航实现精准避障；支持“轻度清洁（日常保洁）”“重度清洁（定期深度清洁）”多强度模式切换。

/* ===== 工业仓储自适应深度清洁机器人：模糊负载 + 多强度模式 =====
 * 硬件：Arduino ESP32 + BLDC差速底盘 + 负载电流检测 + 油污/灰尘传感器 + 刷盘压力执行器 + 清洁剂泵
 * 核心：模糊负载感知 + 多强度清洁 + 窄通道沿边导航
 */
#include <SimpleFOC.h>

// --- 硬件驱动定义 ---
BLDCMotor motorL(7), motorR(7);
BLDCDriver3PWM driverL(9,10,11,8);
BLDCDriver3PWM driverR(3,5,6,7);
const int currentSenseL = A0, currentSenseR = A1;// 左右电机电流检测
const int oilSensorPin = A2, dustSensorPin = A3;// 油污、灰尘传感器
const int brushPressurePin = 13, cleanerPumpPin = 12;// 刷盘压力、清洁剂泵
const int sideSonarPin = A4;            // 侧向沿边超声波

// --- 模糊负载与强度参数 ---
#define LOAD_HEAVY_THRESH 800           // 重负载电流阈值
#define DUST_HEAVY_THRESH 400           // 重度灰尘阈值
float fuzzyLoadOutput = 0;              // 模糊负载输出（扭矩修正系数）
int currentIntensityMode = 0;            // 0:轻度 1:重度

// --- 模糊负载感知核心：根据电流与脏污类型调整扭矩 ---
float fuzzyLoadAdapt(int currentL, int currentR, int dustVal, int oilVal) {
  // 平均电流归一化
  float avgCurrent = (currentL + currentR) / 2.0;
  float normCurrent = map(avgCurrent, 0, 1023, 0.0, 1.0);
  
  // 脏污程度归一化
  float dustNorm = map(dustVal, 0, 1023, 0.0, 1.0);
  float oilNorm = map(oilVal, 0, 1023, 0.0, 1.0);
  
  // 模糊化：负载分为“轻（L）、中（M）、重（H）”，脏污分为“轻（L）、重（H）”
  float loadL = normCurrent <= 0.3 ? 1.0 : 0;
  float loadM = normCurrent > 0.3 && normCurrent <= 0.6 ? 1.0 : 0;
  float loadH = normCurrent > 0.6 ? 1.0 : 0;
  
  float dustH = dustNorm > 0.5 ? 1.0 : 0;
  float oilH = oilNorm > 0.5 ? 1.0 : 0;
  
  // 模糊规则：负载与脏污决定扭矩修正
  float torqueCorrect = 1.0;
  if (loadH > 0.7 && (dustH > 0.5 || oilH > 0.5)) { // 重负载+重度脏污→大幅提升扭矩
    torqueCorrect = 1.5;
  } else if (loadM > 0.7 && (dustH > 0.5 || oilH > 0.5)) { // 中等负载+重度脏污→提升扭矩
    torqueCorrect = 1.3;
  } else if (loadH > 0.7) { // 重负载+轻度脏污→适当提升扭矩
    torqueCorrect = 1.2;
  } else if (loadL > 0.7 && dustNorm < 0.3 && oilNorm < 0.3) { // 轻负载+轻度脏污→降低扭矩节能
    torqueCorrect = 0.8;
  }
  
  return constrain(torqueCorrect, 0.8, 1.5);
}

// --- 多强度清洁模式切换 ---
void intensityModeSwitch(int dustVal, int oilVal) {
  // 重度脏污→重度清洁模式
  if (dustVal > DUST_HEAVY_THRESH || oilVal > 400) {
    currentIntensityMode = 1;
    analogWrite(brushPressurePin, 200);  // 高刷盘压力
    analogWrite(cleanerPumpPin, 200);    // 大剂量清洁剂
  }
  // 轻度脏污→轻度清洁模式
  else {
    currentIntensityMode = 0;
    analogWrite(brushPressurePin, 80);   // 低刷盘压力
    analogWrite(cleanerPumpPin, 60);     // 小剂量清洁剂
  }
}

void setup() {
  Serial.begin(115200);
  // BLDC初始化
  motorL.linkDriver(&driverL); motorR.linkDriver(&driverR);
  driverL.voltage_power_supply = 12; driverR.voltage_power_supply = 12;
  driverL.init(); driverR.init();
  motorL.controller = MotionControlType::velocity;
  motorR.controller = MotionControlType::velocity;
  motorL.init(); motorR.init(); motorL.initFOC(); motorR.initFOC();
  // 执行机构初始化
  pinMode(brushPressurePin, OUTPUT); pinMode(cleanerPumpPin, OUTPUT);
  digitalWrite(brushPressurePin, LOW); digitalWrite(cleanerPumpPin, LOW);
}

void loop() {
  motorL.loopFOC(); motorR.loopFOC();
  
  // 1. 负载与脏污数据采集
  int currentL = analogRead(currentSenseL);
  int currentR = analogRead(currentSenseR);
  int dustVal = analogRead(dustSensorPin);
  int oilVal = analogRead(oilSensorPin);
  int sideDist = analogRead(sideSonarPin); // 侧向沿边距离
  
  // 2. 模糊负载感知（扭矩修正系数）
  fuzzyLoadOutput = fuzzyLoadAdapt(currentL, currentR, dustVal, oilVal);
  
  // 3. 多强度清洁模式
  intensityModeSwitch(dustVal, oilVal);
  
  // 4. 窄通道沿边导航（基础速度+负载修正）
  float baseSpeed = 0.35;
  float wallCorrect = map(sideDist, 100, 400, 0.4, 0.0); // 侧边距离修正转向
  
  // 扭矩修正后的速度
  baseSpeed *= fuzzyLoadOutput;
  
  // 差速控制
  float leftSpd = baseSpeed - wallCorrect;
  float rightSpd = baseSpeed + wallCorrect;
  
  motorL.move(leftSpd);
  motorR.move(rightSpd);
  
  // 调试输出
  Serial.print("Intensity:");Serial.print(currentIntensityMode);
  Serial.print(" TorqueCorr:");Serial.print(fuzzyLoadOutput);
  Serial.println();
  
  delay(80);
}

要点解读

1. 模糊逻辑的核心价值：适配环境不确定性，实现自适应决策
   模糊逻辑是多模式清洁机器人的“决策大脑”，其核心价值在于用“模糊化”替代精确计算，解决清洁环境（地面材质、障碍分布、脏污类型）的强不确定性问题，让机器人具备人类式的直觉决策能力。

应对传感器非线性与噪声：清洁场景中，红外、超声波等传感器受地面反光、障碍角度影响，数据波动大，传统二值逻辑（如“有障碍=停”）易导致机器人频繁启停。模糊逻辑通过隶属度函数，将传感器数值转化为“远/近”“多/少”等模糊概念，对噪声和非线性具有天然抗性，实现平滑避障与导航。

模拟人类清洁直觉：清洁决策依赖多因素权衡（如避障优先级、脏污程度、区域类型），难以用精确公式建模。模糊逻辑的规则库（如“前方近且左无障→右转”）直接复刻人类清洁经验，无需复杂的运动学建模，大幅降低算法复杂度，适配Arduino等算力有限平台。

多输入多输出自适应：模糊逻辑支持多传感器输入与多执行器输出，可同时融合避障、脏污、负载等信息，输出电机速度、清洁强度等控制量，实现“传感器输入-模糊决策-动作输出”的闭环自适应，这是传统固定逻辑无法实现的。

2. 多模式自适应的核心逻辑：数据驱动的动态匹配，兼顾效率与清洁质量
   多模式自适应的本质是让机器人根据场景数据动态匹配最优清洁策略，核心是建立“感知数据-清洁需求-模式动作”的映射规则，解决单一固定模式效率低、清洁效果差的问题。

场景维度的自适应匹配：不同清洁场景的需求差异显著，多模式自适应需覆盖“家庭小场景（复杂障碍）、商用大场景（开阔覆盖）、工业重场景（高负载）”三大维度，通过传感器识别场景特征，自动切换模式。这种场景匹配避免了人工手动切换，提升机器人通用性。

脏污类型的自适应适配：不同脏污（灰尘、油污、水渍）对清洁方式的需求不同，多模式需基于脏污数据动态调整执行器动作，确保清洁动作与脏污类型高度匹配，避免“高功率清洁轻度脏污”的能源浪费，或“低功率清洁重度脏污”的清洁不彻底。

动态切换的闭环控制：自适应并非“一次性决策”，而是持续闭环：传感器实时采集环境数据，模式控制器持续评估当前模式是否匹配需求，若脏污加重、环境变化，立即触发模式切换。闭环控制让机器人具备动态调整能力，应对清洁过程中的突发状况。

3. BLDC电机的适配控制：动力基础与响应核心，保障清洁稳定性
   BLDC电机是清洁机器人的动力核心，其控制方式直接决定机器人的负载能力、响应速度与清洁稳定性，是多模式自适应与模糊逻辑落地的硬件支撑。

高扭矩与负载自适应能力：工业清洁场景存在厚灰尘、顽固油污，地面阻力大，普通有刷电机易过载堵转。BLDC电机功率密度高、扭矩大，配合FOC磁场定向控制，可在模糊负载感知的驱动下动态调整输出扭矩，确保重负载下机器人稳定移动与清洁部件高效运转，避免卡困或动力不足。

快速响应与平滑控制：模糊逻辑的避障与导航决策需要毫秒级的响应速度，否则机器人易碰撞或偏离路径。BLDC的FOC控制支持高带宽速度环，可快速跟踪模糊控制器输出的速度指令，实现加速、减速、转向的平滑过渡，避免传统有刷电机的启动冲击和速度跳变，提升清洁稳定性与机器人寿命。

低噪音与长寿命，适配场景需求：家庭清洁对噪音敏感，商用与工业清洁需要长续航。BLDC无电刷磨损，噪音远低于有刷电机，寿命可达数万小时，满足家庭静音与商用/工业长期高强度运行的需求，这是清洁机器人规模化落地的关键硬件保障。

4. 传感器融合的关键：多源互补，提升决策可靠性
   单一传感器存在盲区和干扰，多模式清洁机器人的可靠决策依赖于多传感器融合，通过不同类型传感器的优势互补，构建全面、准确的环境感知，为模糊逻辑提供可靠数据支撑。

避障与导航的融合：前方红外/超声波检测正前方障碍，侧向红外/超声波检测侧面距离，融合后可判断障碍方位（左/右/前），避免单一传感器因角度盲区导致漏检，提升避障可靠性，为模糊避障提供完整输入。

脏污与环境的融合：灰尘传感器检测灰尘浓度，油污传感器识别油污程度，湿度传感器识别地面干湿，三者融合可全面判断地面脏污类型，避免单一传感器误判，为多模式清洁提供精准的脏污数据。

负载与清洁状态的融合：电流传感器检测BLDC负载，反映地面阻力，结合脏污传感器数据，可区分“阻力大是因为重物还是厚灰尘”，为模糊负载感知提供多维度输入，避免负载误判导致的清洁强度不匹配。

5. 工程落地的核心：参数整定与系统协同，确保理论落地
   模糊逻辑与多模式自适应的理论方案能否落地，关键在于参数整定与系统协同，解决理论模型与实际场景的差异，实现机器人稳定运行。

模糊参数的实地整定：隶属度函数的边界（如“障碍近”对应的传感器数值）和模糊规则的权重，需通过实地测试反复调整。例如家庭场景的障碍距离阈值与工业场景不同，需针对场景特性重新整定参数，否则会出现避障失效、模式切换混乱等问题。整定可采用“先经验后试凑”的方法，先基于经验设置初始参数，再通过多场景测试逐步优化。

多模式切换的边界条件设计：模式切换需明确合理的阈值和滞回区间，避免频繁切换。例如“重度脏污→重度模式”与“轻度脏污→轻度模式”的阈值需留有余量，同时加入滞回逻辑，避免脏污数值在阈值附近波动导致模式频繁切换，造成执行器磨损和机器人不稳定。

硬件与软件的协同匹配：电机驱动、传感器接口、执行器控制的电气特性需与软件逻辑匹配。例如BLDC的最大速度、传感器采样频率、执行器功率，需与模糊控制器的输出范围匹配，避免硬件过载或软件指令无法执行。系统协同需在硬件选型阶段就结合软件需求，确保硬件性能满足软件算法的要求，同时软件算法适配硬件特性。

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