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

4. 代码示例

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();
    }
}

要点解读

• 模糊控制与动态调度的耦合：模糊逻辑用于处理非线性系统（如避障中的距离 - 速度关系），而动态调度决定何时应用这些规则（如紧急避障时暂停路径跟踪）。实现技巧：通过 enable/disable 任务或调整模糊规则权重实现优先级切换。
• 实时性保障机制：使用硬件定时器（如 Timer1）确保关键控制周期（如 BLDC 换相频率≥20kHz）。超时处理：当高优先级任务阻塞时，通过看门狗或超时标志触发安全模式（如自由滑行）。
• 资源冲突解决：共享资源（如 I2C 传感器）采用互斥锁（xSemaphore）或分时复用。示例：机械臂控制中，高优先级关节可独占 ADC 读取窗口。
• 能效优化策略：动态调整模糊控制计算频率（如静止时降低采样率）。代码实现：通过 millis() 判断运动状态，空闲时进入低功耗模式。
• 故障安全设计：模糊规则必须包含安全边界（如'当距离<5cm 时输出最大反向速度'）。调度策略：硬件故障（如电机过流）应立即终止所有任务并进入故障处理流程。

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);
}

要点解读

• 模糊逻辑在调度中的核心价值是处理'不确定性'：传统调度器基于固定阈值（如"CPU>80%"触发降频），而模糊调度器处理渐进变化。例如案例 4 中，不是"电量<30%"就立即降频，而是通过隶属度函数（如"低电量"从 20% 到 40% 逐渐隶属），实现平滑过渡。这避免了传统调度中的"乒乓效应"（频繁在两种策略间切换）。
• 多目标优化的权衡艺术：案例 4 通过加权奖励函数在性能、能效、安全间权衡。权重不是固定的，而是通过模糊规则动态调整。例如紧急状态下，性能权重从 0.5 提高到 0.8，安全权重从 0.2 提高到 0.7，能效权重从 0.3 降到 0.1。这种动态权重调整是模糊调度的核心优势。
• Q 学习使调度策略具备'学习能力'：案例 5 的模糊 Q 学习本质是模糊状态表示 + 强化学习决策。传统 Q 学习使用离散状态（如"电量低"），而模糊 Q 学习使用连续状态（'电量隶属度为 0.7'），大大减少了"维度灾难"。探索率ε的衰减（EXPLORATION_RATE *= 0.95）实现了从探索到利用的平滑过渡，这是确保学习收敛的关键。
• 分布式调度的关键挑战是'通信开销'：案例 6 的多 MCU 调度中，I2C 通信本身消耗资源。必须在调度收益和通信成本间权衡。通过模糊评估 redistributionNeed，只有匹配度<0.3 时才触发重分配。任务迁移不是全有全无，而是部分迁移：只将高 CPU 负载、低通信需求的任务（如 SensorFusion）迁移，而高实时性任务（如 MotorFOC）保持在本地。
• 实时性保证的层次化设计：所有案例都采用时间触发 + 事件触发混合调度。电机控制（10ms 周期）采用时间触发保证实时性，通信接收采用事件触发减少空转。模糊调度器运行在 100ms 周期（案例 4），只做宏观决策，不干扰微观执行。这种控制频率解耦（决策 100ms，执行 10ms）是保证实时性的关键。同时，为最高优先级任务（如急停）保留不可剥夺的执行窗口。

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