Arduino BLDC 模糊动态任务调度机器人

基于 Arduino 的 BLDC 模糊动态任务调度机器人

基于 Arduino 的 BLDC 模糊动态任务调度机器人，是一种将模糊逻辑控制理论应用于机器人多任务管理与执行机构（BLDC 电机）协同控制的智能系统。该方案的核心在于解决传统基于固定优先级或时间片轮转的调度算法在面对非结构化环境时，对'不确定性'和'实时性'处理能力不足的问题。

主要特点

模糊逻辑驱动的优先级动态仲裁

这是系统区别于传统实时操作系统的核心，它将离散的'任务优先级'转化为连续的'任务紧迫度'。

• 多输入变量融合：系统不再仅依据任务注册的时间或预设的静态优先级来调度，而是将传感器数据（如障碍物距离、电池电量、目标接近度）作为模糊输入变量。
• 语言值描述与规则库：通过定义'很近'、'较远'、'极低'、'正常'等模糊集合，将数值型数据转化为语言型描述。例如，规则库中可定义：'如果前方障碍物距离为'很近'且电池电量为'充足'，则避障任务的优先级为'最高'，巡航任务的优先级为'零''。
• 平滑的优先级过渡：相较于传统算法中任务优先级的'硬切换'导致的系统抖动，模糊逻辑输出的优先级权重是连续变化的，使得任务切换过程更加平滑，避免了执行机构（BLDC）的剧烈冲击。

BLDC 执行机构的响应特性匹配

模糊调度策略必须与底层电机的动态响应特性相匹配，才能发挥效能。

• 能耗 - 时间折中策略：在资源受限（如电量低）的情况下，模糊调度器可以调整 BLDC 的运动参数。例如，将'快速到达目标'的任务调整为'低速巡航模式'，通过牺牲时间指标来换取能耗指标的优化。
• 死锁与冲突消解：当多个任务（如'前往充电座'和'躲避障碍物'）产生运动指令冲突时，模糊仲裁器根据各任务的'紧迫度'计算出一个加权后的合成输出，驱动 BLDC 执行折中动作（如原地慢速旋转寻找出路），而非简单的任务挂起或终止。

轻量化与嵌入式实时性

• 去模型化设计：模糊逻辑不依赖于对机器人动力学或环境的精确数学建模，这大大降低了在资源受限的 Arduino 平台上（如 Uno, Nano）的计算负担，相比神经网络或复杂的优化算法，更适合做实时调度。
• 快速推理机制：通过查表法（Look-Up Table）或简化的 MIN-MAX 推理机，模糊控制器能在微秒级时间内完成规则匹配与去模糊化，满足机器人控制系统对毫秒级响应的要求。

应用场景

1. 复杂环境下的自主探索机器人：在未知的废墟或洞穴环境中，机器人需要同时处理'地图构建'、'路径规划'、'传感器数据采集'和'能源管理'等多个任务。模糊动态调度器能根据环境复杂度（如狭窄通道增多）和传感器数据质量，动态分配 CPU 时间片和电机控制资源，确保在复杂区域降低移动速度以保证数据采集的完整性。
2. 多任务服务机器人：例如医院的送药机器人，它需要在'自主导航'、'语音交互响应'、'药品箱状态监测'之间切换。当护士发出紧急语音指令时，模糊调度器能瞬间将'语音交互任务'的优先级提升至最高，暂停导航任务或降低 BLDC 速度，确保及时响应人工干预。
3. 工业巡检与预测性维护：在工厂中，巡检机器人搭载多种传感器（红外、振动、声音）。当模糊系统检测到某台设备的异常信号（如振动幅值'较大'且温度'偏高'）时，会动态调整任务调度，指令机器人降低 BLDC 速度，在该设备前停留更长时间进行详细检测，而非按固定路线匆匆路过。
4. 教育与科研验证平台：作为研究人工智能调度算法、多智能体协同控制的低成本硬件平台，学生可以通过修改模糊规则库，直观地观察不同调度策略对机器人行为的影响。

注意事项

1. 规则库的完备性与'维数灾难'：
   • 规则膨胀问题：随着任务数量和输入变量的增加，模糊规则的数量呈指数级增长。这会导致 Arduino 的 Flash 存储空间迅速耗尽，且推理时间变长。
   • 对策：应精简输入变量，采用分层模糊控制（先粗调再细调），或将部分规则固化为查表法，避免在线进行复杂的数学运算。
2. 实时性与计算资源瓶颈：
   • 8 位单片机的局限：标准的 Arduino Uno（ATmega328P）处理浮点运算和模糊推理较慢。如果任务调度周期要求极高（< 10ms），建议使用 Arduino Due（ARM Cortex-M3）、Teensy 或 ESP32 等 32 位高性能平台。
   • 中断优先级配置：模糊调度器本身应运行在较高的中断优先级上，但要注意不能阻塞底层的电机控制 PWM 中断，否则会导致 BLDC 电机失控。
3. 任务模型的抽象与量化：
   • 输入量的归一化：不同任务的传感器数据单位和量纲不同（如超声波距离是 cm，电流是 A）。在输入模糊控制器前，必须将这些数据归一化到 [0, 1] 或 [-1, 1] 的论域范围内。
   • 输出量的解耦：模糊控制器输出的往往是任务的'执行强度'或'优先级权重'，需要设计合理的接口函数将其转换为 BLDC 电机的具体 PWM 占空比或目标速度。
4. 安全性与故障冗余：
   • 硬件看门狗：模糊算法如果出现逻辑死循环，会导致机器人停在原地或乱撞。必须启用 Arduino 的硬件看门狗定时器，确保程序跑飞时能自动复位。
   • 硬线优先级：对于'急停'、'碰撞检测'等最高安全等级的任务，建议采用硬件中断直接切断电机电源，绕过模糊软件调度层，确保绝对的安全响应速度。

代码示例

1. 移动机器人避障与路径跟踪（基于 DRV8323RS）

#include <Fuzzy.h>
#include <DRV8323RS.h>

// 模糊控制器初始化
Fuzzy *fuzzy = new Fuzzy();
FuzzySet *near = new FuzzySet(0, 0, 20, 40); // 近距离障碍物
FuzzySet *far = new FuzzySet(30, 50, 100, 100); // 远距离障碍物

// 电机驱动对象
DRV8323RS motorLeft(5, 6, 7, 10); // 左电机 PWM/DIR/EN/CS
DRV8323RS motorRight(8, 9, 10, 11); // 右电机 PWM/DIR/EN/CS

void setup() {
    // 模糊输入：超声波传感器距离
    FuzzyInput *distance = new FuzzyInput(1);
    distance->addFuzzySet(near);
    distance->addFuzzySet(far);
    fuzzy->addFuzzyInput(distance);

    // 模糊输出：电机速度调整
    FuzzyOutput *speedAdjust = new FuzzyOutput(1);
    speedAdjust->addFuzzySet(new FuzzySet(-100, -100, -50, 0)); // 减速
    speedAdjust->addFuzzySet(new FuzzySet(0, 50, 100, 100)); // 加速
    fuzzy->addFuzzyOutput(speedAdjust);

    // 模糊规则
    FuzzyRule *rule1 = new FuzzyRule(1, near, speedAdjust, new FuzzySet(-80, -60, -40, -20));
    fuzzy->addFuzzyRule(rule1);
}

void loop() {
    int dist = ultrasonicSensor.read(); // 读取超声波距离
    fuzzy->setInput(1, dist);
    fuzzy->fuzzify();
    float adjustment = fuzzy->defuzzify(1);
    
    motorLeft.setSpeed(baseSpeed + adjustment);
    motorRight.setSpeed(baseSpeed - adjustment); // 差速转向

    // 动态任务调度：优先级高的任务中断低优先级任务
    if (emergencyStopTriggered()) {
        stopAllMotors();
        delay(1000); // 紧急停止优先级最高
    } else if (pathTrackingActive()) {
        adjustPathFollowing(); // 路径跟踪次优先级
    }
}

2. 机械臂关节协同控制（基于 L6234）

#include <Fuzzy.h>
#include <L6234.h>

// 多关节模糊控制
Fuzzy *jointFuzzy[3]; // 3 个关节的模糊控制器
L6234 joints[3] = {
    L6234(2, 3, 4, 5), // 关节 1
    L6234(6, 7, 8, 9), // 关节 2
    L6234(10, 11, 12, 13) // 关节 3
};

void setup() {
    // 初始化每个关节的模糊控制器（示例省略重复代码）
    for (int i = 0; i < 3; i++) {
        jointFuzzy[i] = new Fuzzy();
        // 配置输入（位置误差/速度误差）和输出（扭矩调整）
    }
}

void loop() {
    // 动态任务调度：根据任务优先级分配计算资源
    if (highPriorityTaskActive()) {
        controlHighPriorityJoint(); // 例如末端执行器关节
    } else {
        for (int i = 0; i < 3; i++) {
            float error = readJointError(i);
            jointFuzzy[i]->setInput(1, error);
            jointFuzzy[i]->fuzzify();
            joints[i].setTorque(baseTorque[i] + jointFuzzy[i]->defuzzify(1));
        }
    }

    // 实时性保障：通过定时器中断确保关键控制周期
    if (millis() - lastControlTime > CONTROL_PERIOD) {
        handleControlTimeout(); // 超时处理（如切换到安全模式）
    }
}

3. AGV 动态调度系统（自定义 H 桥）

#include <Fuzzy.h>
#include <TaskScheduler.h>

// 任务调度器
Scheduler runner;
Task task1(10, TASK_FOREVER, &avoidObstacle); // 避障任务（高优先级）
Task task2(50, TASK_FOREVER, &batteryMonitor); // 电池监控（低优先级）

// 电机控制
int motorPins[4] = {5, 6, 7, 8}; // 自定义 H 桥控制引脚
Fuzzy *speedFuzzy = new Fuzzy();

void setup() {
    // 初始化模糊控制器（输入：负载/速度误差；输出：PWM 调整）
    runner.init();
    runner.addTask(task1);
    runner.addTask(task2);
    task1.enable();
}

void loop() {
    runner.execute(); // 动态调度任务

    // 模糊控制根据当前任务优先级调整参数
    if (task1.isRunning()) {
        speedFuzzy->setSensitivity(HIGH_SENSITIVITY); // 避障时更激进
    } else {
        speedFuzzy->setSensitivity(LOW_SENSITIVITY); // 正常行驶
    }

    // 电机控制
    int pwm = calculateFuzzyPWM();
    setMotorSpeed(motorPins, pwm);
}

// 动态调度回调函数
void avoidObstacle() {
    if (obstacleDetected()) {
        runner.disableAll(); // 抢占所有资源
        emergencyManeuver();
        runner.enable();
    }
}

4. 模糊逻辑多任务调度器

场景：巡逻机器人需动态平衡移动、传感、通信任务的 CPU 和功率资源。 核心逻辑：模糊推理机动态分配各子系统的执行时间片。

#include <SimpleFOC.h>
#include <Fuzzy.h>

// BLDC 电机
BLDCMotor motorL = BLDCMotor(11);
BLDCMotor motorR = BLDCMotor(11);

// 模糊逻辑系统
Fuzzy* fuzzyScheduler = new Fuzzy();

// 任务结构体
struct RobotTask {
    const char* name;
    uint8_t priority; // 基础优先级 1-10
    uint32_t lastRun; // 上次执行时间
    uint32_t desiredPeriod; // 期望周期 (ms)
    uint32_t actualPeriod; // 实际周期
    float cpuUsage; // CPU 使用率估算
    bool enabled;
};

// 任务列表
RobotTask tasks[] = {
    {"MotorCtrl", 8, 0, 10, 0, 0.1, true}, // 电机控制
    {"SensorRead", 6, 0, 50, 0, 0.05, true}, // 传感器读取
    {"Navigation", 7, 0, 100, 0, 0.2, true}, // 导航规划
    {"CommTX", 5, 0, 200, 0, 0.15, true}, // 通信发送
    {"CommRX", 4, 0, 0, 0, 0.1, true}, // 通信接收 (事件驱动)
    {"BatteryMon", 3, 0, 1000, 0, 0.02, true}, // 电池监控
    {"DebugLog", 2, 0, 500, 0, 0.05, true} // 调试输出
};
#define TASK_COUNT (sizeof(tasks)/sizeof(tasks[0]))

// 系统状态
float batterySOC = 80.0; // 电池剩余电量%
float cpuLoad = 0.0; // 当前 CPU 负载
float urgencyLevel = 0.5; // 紧急程度
uint32_t scheduleCounter = 0; // 调度计数器

void setup() {
    Serial.begin(115200);
    // 电机初始化
    motorL.initFOC();
    motorR.initFOC();
    // 初始化模糊调度器
    initFuzzyScheduler();
    Serial.println("模糊任务调度器启动");
}

void loop() {
    static uint32_t lastScheduleTime = 0;
    uint32_t now = millis();

    // 1. 每 100ms 执行一次调度决策
    if (now - lastScheduleTime >= 100) {
        updateSystemStatus();
        calculateDynamicPriorities();
        rescheduleTasks();
        lastScheduleTime = now;
        scheduleCounter++;
    }

    // 2. 执行就绪任务
    executeScheduledTasks();

    // 3. 低优先级循环任务
    lowPriorityIdleTasks();
}

void updateSystemStatus() {
    // 模拟读取系统状态
    batterySOC = analogRead(A0) * 100.0 / 1023.0;
    cpuLoad = calculateCPULoad();
    // 紧急程度评估
    static float obstacleDistance = 100.0;
    obstacleDistance = readUltrasonic();
    urgencyLevel = map(constrain(obstacleDistance, 0, 100), 0, 100, 1.0, 0.0);
    // 更新任务实际周期
    for (int i = 0; i < TASK_COUNT; i++) {
        if (tasks[i].lastRun > 0) {
            tasks[i].actualPeriod = now - tasks[i].lastRun;
        }
    }
}

void calculateDynamicPriorities() {
    // 模糊推理：根据电池电量、CPU 负载、紧急程度计算动态调整系数
    fuzzyScheduler->setInput(1, batterySOC);
    fuzzyScheduler->setInput(2, cpuLoad);
    fuzzyScheduler->setInput(3, urgencyLevel);
    fuzzyScheduler->fuzzify();
    float adjustFactor = fuzzyScheduler->defuzzify(1);

    // 应用动态调整
    for (int i = 0; i < TASK_COUNT; i++) {
        if (tasks[i].enabled) {
            // 动态优先级 = 基础优先级 * 调整系数
            float dynamicPriority = tasks[i].priority * adjustFactor;
            // 根据任务类型应用不同权重
            switch (i) {
                case 0: // 电机控制
                    if (urgencyLevel > 0.7) dynamicPriority *= 1.5; // 紧急时提高优先级
                    break;
                case 3: // 通信发送
                    if (batterySOC < 30.0) dynamicPriority *= 0.7; // 低电量时降低优先级
                    break;
            }
            tasks[i].priority = (uint8_t)constrain(dynamicPriority, 1, 10);
        }
    }
}

void rescheduleTasks() {
    // 基于动态优先级重新计算期望周期
    for (int i = 0; i < TASK_COUNT; i++) {
        if (tasks[i].enabled) {
            // 优先级越高，周期越短
            float basePeriod = 1000.0 / tasks[i].priority; // 基础周期
            // 应用模糊调整
            float periodMultiplier = 1.0;
            if (cpuLoad > 0.8) { periodMultiplier = 2.0; } // CPU 负载高时延长周期
            if (batterySOC < 20.0) { periodMultiplier *= 1.5; } // 低电量时延长周期
            tasks[i].desiredPeriod = (uint32_t)(basePeriod * periodMultiplier);
            tasks[i].desiredPeriod = constrain(tasks[i].desiredPeriod, 10, 5000);
        }
    }
}

void executeScheduledTasks() {
    uint32_t now = millis();
    for (int i = 0; i < TASK_COUNT; i++) {
        if (!tasks[i].enabled) continue;
        // 检查是否到达执行时间
        if (now - tasks[i].lastRun >= tasks[i].desiredPeriod) {
            uint32_t startTime = micros();
            // 执行任务
            switch (i) {
                case 0: taskMotorControl(); break;
                case 1: taskSensorRead(); break;
                case 2: taskNavigation(); break;
                case 3: taskCommunicationTX(); break;
                case 4: taskCommunicationRX(); break;
                case 5: taskBatteryMonitor(); break;
                case 6: taskDebugLog(); break;
            }
            // 更新任务信息
            tasks[i].lastRun = now;
            uint32_t execTime = micros() - startTime;
            tasks[i].cpuUsage = (execTime / 1000.0) / tasks[i].desiredPeriod;
        }
    }
}

void taskMotorControl() {
    // 电机控制任务
    static float targetSpeed = 0.0;
    // 读取控制输入
    float throttle = readThrottle();
    float steering = readSteering();
    // 差速计算
    float speedL = throttle + steering;
    float speedR = throttle - steering;
    // 应用模糊速度限制
    float speedLimit = fuzzyGetSpeedLimit();
    speedL = constrain(speedL, -speedLimit, speedLimit);
    speedR = constrain(speedR, -speedLimit, speedLimit);
    // 执行电机控制
    motorL.move(speedL);
    motorR.move(speedR);
    motorL.loopFOC();
    motorR.loopFOC();
}

5. 基于模糊 Q 学习的自适应调度

场景：学习型机器人，能根据历史性能数据优化任务调度策略。 核心逻辑：模糊 Q 学习算法动态调整调度参数。

#include <SimpleFOC.h>
#include <Fuzzy.h>

// Q 学习参数
#define STATE_COUNT 5
#define ACTION_COUNT 3
#define LEARNING_RATE 0.1
#define DISCOUNT_FACTOR 0.9
#define EXPLORATION_RATE 0.3

// 模糊 Q 表
float qTable[STATE_COUNT][ACTION_COUNT];

// 状态定义
enum SystemState {
    STATE_NORMAL, // 正常状态
    STATE_EMERGENCY, // 紧急状态
    STATE_LOW_BATTERY, // 低电量状态
    STATE_HIGH_LOAD, // 高负载状态
    STATE_IDLE // 空闲状态
};

// 动作定义
enum SchedulingAction {
    ACTION_AGGRESSIVE, // 激进调度
    ACTION_CONSERVATIVE, // 保守调度
    ACTION_BALANCED // 平衡调度
};

// 系统变量
SystemState currentState = STATE_NORMAL;
SchedulingAction lastAction = ACTION_BALANCED;
float totalReward = 0.0;
int learningEpisodes = 0;

void setup() {
    Serial.begin(115200);
    initFuzzyQLearning();
    Serial.println("模糊 Q 学习调度器启动");
}

void loop() {
    static uint32_t lastDecisionTime = 0;
    uint32_t now = millis();

    // 1. 每 2 秒进行一次调度决策
    if (now - lastDecisionTime >= 2000) {
        // 感知当前状态
        SystemState observedState = observeSystemState();
        // 选择动作
        SchedulingAction action = selectAction(observedState);
        // 执行动作
        executeSchedulingAction(action);
        // 获取奖励
        float reward = calculateReward(observedState, action);
        totalReward += reward;
        // Q 学习更新
        updateQTable(observedState, action, reward);
        // 状态转移
        currentState = observedState;
        lastAction = action;
        lastDecisionTime = now;
        learningEpisodes++;
        // 每 10 个周期降低探索率
        if (learningEpisodes % 10 == 0) {
            EXPLORATION_RATE *= 0.95;
            EXPLORATION_RATE = max(EXPLORATION_RATE, 0.1f);
        }
    }

    // 2. 执行当前调度策略下的任务
    executeTasksUnderCurrentPolicy();
}

SystemState observeSystemState() {
    // 模糊状态观测
    float battery = readBatteryLevel();
    float load = calculateSystemLoad();
    float urgency = assessUrgency();
    float performance = calculatePerformanceMetric();
    // 模糊规则确定状态
    Fuzzy* stateFuzzy = new Fuzzy();
    // ... 模糊规则定义
    stateFuzzy->fuzzify();
    // 去模糊化得到状态
    float stateValue = stateFuzzy->defuzzify(1);
    // 映射到离散状态
    if (stateValue < 0.2) return STATE_IDLE;
    else if (stateValue < 0.4) return STATE_NORMAL;
    else if (stateValue < 0.6) return STATE_LOW_BATTERY;
    else if (stateValue < 0.8) return STATE_HIGH_LOAD;
    else return STATE_EMERGENCY;
}

SchedulingAction selectAction(SystemState state) {
    // ε-greedy 策略
    float randomValue = random(100) / 100.0;
    if (randomValue < EXPLORATION_RATE) {
        // 探索：随机选择动作
        return (SchedulingAction)random(ACTION_COUNT);
    } else {
        // 利用：选择 Q 值最大的动作
        int bestAction = 0;
        float bestQValue = qTable[state][0];
        for (int a = 1; a < ACTION_COUNT; a++) {
            if (qTable[state][a] > bestQValue) {
                bestQValue = qTable[state][a];
                bestAction = a;
            }
        }
        return (SchedulingAction)bestAction;
    }
}

void executeSchedulingAction(SchedulingAction action) {
    switch (action) {
        case ACTION_AGGRESSIVE: // 激进调度：优先性能
            setTaskPeriod("MotorCtrl", 5);
            setTaskPeriod("Navigation", 20);
            setTaskPeriod("CommTX", 100);
            break;
        case ACTION_CONSERVATIVE: // 保守调度：优先能效
            setTaskPeriod("MotorCtrl", 20);
            setTaskPeriod("Navigation", 100);
            setTaskPeriod("CommTX", 500);
            break;
        case ACTION_BALANCED: // 平衡调度
            setTaskPeriod("MotorCtrl", 10);
            setTaskPeriod("Navigation", 50);
            setTaskPeriod("CommTX", 200);
            break;
    }
}

float calculateReward(SystemState state, SchedulingAction action) {
    // 奖励函数设计是关键
    float reward = 0.0;
    // 性能奖励
    float performance = calculatePerformanceMetric();
    reward += performance * 0.5;
    // 能效奖励
    float efficiency = calculateEnergyEfficiency();
    reward += efficiency * 0.3;
    // 安全奖励
    float safety = calculateSafetyMetric();
    reward += safety * 0.2;
    // 状态惩罚
    if (state == STATE_EMERGENCY) reward -= 0.5;
    if (state == STATE_LOW_BATTERY) reward -= 0.3;
    return reward;
}

void updateQTable(SystemState state, SchedulingAction action, float reward) {
    // Q 学习更新公式：Q(s,a) = Q(s,a) + α[r + γ*maxQ(s',a') - Q(s,a)]
    float currentQ = qTable[state][action];
    float maxNextQ = 0.0;
    // 找到下一个状态的最大 Q 值
    for (int a = 0; a < ACTION_COUNT; a++) {
        if (qTable[state][a] > maxNextQ) {
            maxNextQ = qTable[state][a];
        }
    }
    // 计算新 Q 值
    float newQ = currentQ + LEARNING_RATE * (reward + DISCOUNT_FACTOR * maxNextQ - currentQ);
    qTable[state][action] = newQ;
}

6. 分布式模糊调度（多 MCU 协同）

场景：复杂机器人系统，多个 MCU 协同工作，需动态分配计算任务。 核心逻辑：主从式模糊调度 + 负载均衡。

#include <SimpleFOC.h>
#include <Fuzzy.h>
#include <Wire.h>

// 多 MCU 架构
#define I2C_ADDR_MASTER 8
#define I2C_ADDR_MOTOR_CTRL 9
#define I2C_ADDR_SENSOR_FUSION 10
#define I2C_ADDR_COMM 11

// 任务负载结构
struct TaskLoad {
    char taskName[20];
    float cpuLoad; // CPU 负载估算
    float memoryUsage; // 内存使用率
    float priority; // 动态优先级
    uint32_t period; // 执行周期
    bool assigned; // 是否已分配
    uint8_t assignedTo; // 分配给哪个 MCU
};

// 系统负载表
TaskLoad systemTasks[] = {
    {"MotorFOC", 0.15, 0.1, 0.9, 10, false, 0},
    {"SensorFusion", 0.25, 0.2, 0.8, 20, false, 0},
    {"PathPlanning", 0.35, 0.3, 0.7, 50, false, 0},
    {"SLAM", 0.45, 0.4, 0.6, 100, false, 0},
    {"CommProtocol", 0.2, 0.15, 0.5, 30, false, 0},
    {"VisionProc", 0.6, 0.5, 0.4, 50, false, 0}
};
#define TASK_COUNT (sizeof(systemTasks)/sizeof(systemTasks[0]))

// MCU 能力表
struct MCUCapability {
    uint8_t address;
    float cpuCapacity; // CPU 计算能力
    float memCapacity; // 内存容量
    float powerBudget; // 功率预算
    float currentLoad; // 当前负载
    float temperature; // 温度
};
MCUCapability mcuNodes[] = {
    {I2C_ADDR_MOTOR_CTRL, 1.0, 1.0, 5.0, 0.0, 40.0},
    {I2C_ADDR_SENSOR_FUSION, 1.2, 1.5, 3.0, 0.0, 45.0},
    {I2C_ADDR_COMM, 0.8, 1.0, 2.0, 0.0, 35.0}
};
#define MCU_COUNT (sizeof(mcuNodes)/sizeof(mcuNodes[0]))

void setup() {
    Serial.begin(115200);
    Wire.begin(I2C_ADDR_MASTER);
    // 初始化模糊调度器
    initFuzzyScheduler();
    // 扫描从 MCU 节点
    scanMCUNodes();
    Serial.println("分布式模糊调度系统启动");
}

void loop() {
    static uint32_t lastLoadBalanceTime = 0;
    uint32_t now = millis();

    // 1. 每 5 秒执行一次负载均衡
    if (now - lastLoadBalanceTime >= 5000) {
        collectNodeStatus();
        evaluateLoadDistribution();
        redistributeTasks();
        sendSchedulingCommands();
        lastLoadBalanceTime = now;
        // 输出调度信息
        printSchedulingInfo();
    }

    // 2. 执行本地任务
    executeLocalTasks();

    // 3. 处理从节点请求
    handleSlaveRequests();
}

void collectNodeStatus() {
    // 通过 I2C 收集各 MCU 状态
    for (int i = 0; i < MCU_COUNT; i++) {
        Wire.beginTransmission(mcuNodes[i].address);
        Wire.write(0x01); // 状态查询命令
        Wire.endTransmission();
        Wire.requestFrom(mcuNodes[i].address, 12);
        if (Wire.available() >= 12) {
            mcuNodes[i].currentLoad = Wire.read() / 100.0;
            mcuNodes[i].temperature = Wire.read();
            // 读取其他状态...
        }
    }
}

void evaluateLoadDistribution() {
    // 模糊评估负载分布
    Fuzzy* loadFuzzy = new Fuzzy();
    // 计算系统总负载
    float totalLoad = 0.0;
    for (int i = 0; i < MCU_COUNT; i++) {
        totalLoad += mcuNodes[i].currentLoad;
    }
    float avgLoad = totalLoad / MCU_COUNT;
    // 计算负载均衡度
    float loadImbalance = 0.0;
    for (int i = 0; i < MCU_COUNT; i++) {
        loadImbalance += pow(mcuNodes[i].currentLoad - avgLoad, 2);
    }
    loadImbalance = sqrt(loadImbalance / MCU_COUNT);
    // 模糊输入
    loadFuzzy->setInput(1, avgLoad);
    loadFuzzy->setInput(2, loadImbalance);
    loadFuzzy->setInput(3, mcuNodes[0].temperature); // 关键节点温度
    // 模糊推理
    loadFuzzy->fuzzify();
    // 输出：是否需要重分配
    float redistributionNeed = loadFuzzy->defuzzify(1);
    if (redistributionNeed > 0.7) {
        triggerTaskRedistribution();
    }
}

void redistributeTasks() {
    // 基于模糊决策的任务重分配
    // 1. 对任务按优先级排序
    sortTasksByPriority();
    // 2. 对 MCU 按负载排序
    sortMCUsByLoad();
    // 3. 模糊任务分配
    for (int t = 0; t < TASK_COUNT; t++) {
        if (!systemTasks[t].assigned) {
            // 寻找最优 MCU
            int bestMCU = findOptimalMCUForTask(t);
            if (bestMCU >= 0) {
                // 分配任务
                systemTasks[t].assigned = true;
                systemTasks[t].assignedTo = mcuNodes[bestMCU].address;
                // 更新 MCU 负载
                mcuNodes[bestMCU].currentLoad += systemTasks[t].cpuLoad;
            }
        }
    }
}

int findOptimalMCUForTask(int taskIndex) {
    // 模糊评估任务与 MCU 的匹配度
    float bestScore = 0.0;
    int bestMCU = -1;
    for (int m = 0; m < MCU_COUNT; m++) {
        // 计算匹配分数
        float score = calculateFuzzyMatchScore(taskIndex, m);
        if (score > bestScore) {
            bestScore = score;
            bestMCU = m;
        }
    }
    return bestMCU;
}

float calculateFuzzyMatchScore(int taskIdx, int mcuIdx) {
    // 模糊匹配度计算
    Fuzzy* matchFuzzy = new Fuzzy();
    // 输入 1: 负载匹配度
    float loadMatch = 1.0 - (mcuNodes[mcuIdx].currentLoad + systemTasks[taskIdx].cpuLoad);
    loadMatch = constrain(loadMatch, 0.0, 1.0);
    // 输入 2: 能力匹配度
    float capabilityMatch = min(mcuNodes[mcuIdx].cpuCapacity / systemTasks[taskIdx].cpuLoad, 1.0);
    // 输入 3: 温度因素
    float tempFactor = 1.0 - (mcuNodes[mcuIdx].temperature - 40.0) / 40.0;
    tempFactor = constrain(tempFactor, 0.0, 1.0);
    matchFuzzy->setInput(1, loadMatch);
    matchFuzzy->setInput(2, capabilityMatch);
    matchFuzzy->setInput(3, tempFactor);
    matchFuzzy->fuzzify();
    return matchFuzzy->defuzzify(1);
}

要点解读

模糊控制与动态调度的耦合

模糊逻辑用于处理非线性系统（如避障中的距离 - 速度关系），而动态调度决定何时应用这些规则（如紧急避障时暂停路径跟踪）。 实现技巧：通过 enable/disable 任务或调整模糊规则权重实现优先级切换。

实时性保障机制

使用硬件定时器（如 Timer1）确保关键控制周期（如 BLDC 换相频率≥20kHz）。 超时处理：当高优先级任务阻塞时，通过看门狗或超时标志触发安全模式（如自由滑行）。

资源冲突解决

共享资源（如 I2C 传感器）采用互斥锁（xSemaphore）或分时复用。 示例：机械臂控制中，高优先级关节可独占 ADC 读取窗口。

能效优化策略

动态调整模糊控制计算频率（如静止时降低采样率）。 代码实现：通过 millis() 判断运动状态，空闲时进入低功耗模式。

故障安全设计

模糊规则必须包含安全边界（如'当距离<5cm 时输出最大反向速度'）。 调度策略：硬件故障（如电机过流）应立即终止所有任务并进入故障处理流程。

注意，以上案例只是为了拓展思路，仅供参考。它们可能有错误、不适用或者无法编译。您的硬件平台、使用场景和 Arduino 版本可能影响使用方法的选择。实际编程时，您要根据自己的硬件配置、使用场景和具体需求进行调整，并多次实际测试。您还要正确连接硬件，了解所用传感器和设备的规范和特性。涉及硬件操作的代码，您要在使用前确认引脚和电平等参数的正确性和安全性。