⚙️ Умное управление скоростью

Секреты плавного движения роботов: алгоритмы регулирования скорости

🎯 Цель: Изучаем как роботы движутся плавно и точно
⭐ Результат: Создаем блок-схему умного регулятора скорости

👨‍🏫 Учитель: Ахметов Рустам
🏫 Школа: ГБОУ № 1362
📅 Дата: 2025-06-14
⏰ Время: 85 минут

🎬 Мотивация: Два робота - две истории

🤖 Робот А: “Дергунчик”

Наблюдаем:

  • Резко стартует и тормозит
  • Движется рывками
  • Скорость “скачет” вверх-вниз
  • Тратит много энергии
  • Быстро изнашивается

🤖 Робот Б: “Плавняшка”

Наблюдаем:

  • Мягко набирает скорость
  • Движется равномерно
  • Точно поддерживает заданную скорость
  • Экономно расходует энергию
  • Работает долго и надежно

🤔 Главный вопрос

В чем секрет плавного движения?

🎯 Сегодня раскрываем тайну умного управления скоростью!

🔧 Проблемы простого управления

⚡ Как мы управляли скоростью раньше

Простейший способ:

1void setSpeed(int speed) {
2    motorPower = speed;  // Просто задаем мощность
3}

Что происходит:

  • Хотим скорость 50% → ставим мощность 50%
  • Хотим скорость 100% → ставим мощность 100%
  • Изменения мгновенные и резкие

❌ Проблемы такого подхода

1. Инерция системы:

  • Мотор не может мгновенно изменить скорость
  • Робот продолжает двигаться по инерции
  • Возникают “проскоки” и колебания

2. Внешние помехи:

  • Робот едет в горку → скорость падает
  • Робот едет с горки → скорость растет
  • Разная нагрузка → разная скорость

3. Неточность:

  • Заданная мощность ≠ реальная скорость
  • Нет контроля результата
  • Нет коррекции ошибок

🔄 Принцип обратной связи

🧠 Как работает умное управление

Идея: Постоянно проверяем результат и корректируем управление

 1🎯 Заданная скорость
 2         ↓
 3    ⚖️ Сравнение ← 📊 Измеренная скорость
 4         ↓                    ↑
 5    📈 Ошибка                 ↑
 6         ↓                    ↑
 7    🔧 Регулятор              ↑
 8         ↓                    ↑
 9    ⚡ Управление              ↑
10         ↓                    ↑
11    🤖 Робот → 📏 Датчик ------┘

📊 Математика обратной связи

Основные величины:

  • r(t) - заданная (целевая) скорость
  • y(t) - измеренная (фактическая) скорость
  • e(t) - ошибка регулирования
  • u(t) - управляющее воздействие

Формула ошибки:

\[e(t) = r(t) - y(t)\]

Цель регулятора: Свести ошибку e(t) к нулю!

⭐ Для любознательных: Теория управления

Передаточная функция системы:

Для простого мотора с инерцией:

\[H(s) = \frac{K}{Ts + 1}\]

где:

  • K - коэффициент усиления
  • T - постоянная времени (инерционность)
  • s - комплексная переменная Лапласа

Характеристическое уравнение замкнутой системы:

\[1 + G_c(s) \cdot G_p(s) = 0\]

где $G_c(s)$ - передаточная функция регулятора, $G_p(s)$ - передаточная функция объекта

Критерии устойчивости:

  • Критерий Рауса-Гурвица
  • Критерий Найквиста
  • Логарithmические критерии (Боде)

Качественные показатели:

  • Время переходного процесса
  • Перерегулирование
  • Статическая ошибка
  • Запас устойчивости

📊 Типы регуляторов

📈 Пропорциональный (P) регулятор

Принцип: Управление пропорционально ошибке

Формула:

\[u(t) = K_p \cdot e(t)\]

где $K_p$ - коэффициент пропорциональности

Алгоритм:

1float pController(float setpoint, float measured) {
2    float error = setpoint - measured;
3    float output = Kp * error;
4    return output;
5}

Свойства:

  • ✅ Простота реализации
  • ✅ Быстрая реакция на большие ошибки
  • ❌ Статическая ошибка (остаточное отклонение)
  • ❌ Может вызывать колебания при больших Kp

🏔️ Интегральный (I) регулятор

Принцип: Учитывает накопленную ошибку за все время

Формула:

\[u(t) = K_i \int_0^t e(\tau) d\tau\]

Дискретная реализация:

 1class IController {
 2private:
 3    float integral = 0;
 4    float Ki = 0.1;
 5    
 6public:
 7    float calculate(float error, float dt) {
 8        integral += error * dt;
 9        return Ki * integral;
10    }
11};

Свойства:

  • ✅ Устраняет статическую ошибку
  • ✅ Учитывает историю ошибок
  • ❌ Медленная реакция
  • ❌ Может вызывать перерегулирование

⚡ Дифференциальный (D) регулятор

Принцип: Реагирует на скорость изменения ошибки

Формула:

\[u(t) = K_d \frac{de(t)}{dt}\]

Дискретная реализация:

 1class DController {
 2private:
 3    float lastError = 0;
 4    float Kd = 0.01;
 5    
 6public:
 7    float calculate(float error, float dt) {
 8        float derivative = (error - lastError) / dt;
 9        lastError = error;
10        return Kd * derivative;
11    }
12};

Свойства:

  • ✅ Предсказывает будущее поведение
  • ✅ Уменьшает перерегулирование
  • ✅ Повышает устойчивость
  • ❌ Усиливает шумы
  • ❌ Чувствителен к помехам

⭐ Для любознательных: Продвинутые регуляторы

Нечеткий (Fuzzy) регулятор:

 1class FuzzyController {
 2private:
 3    struct FuzzyRule {
 4        float errorLow, errorHigh;
 5        float outputLow, outputHigh;
 6    };
 7    
 8    vector<FuzzyRule> rules;
 9    
10public:
11    float calculate(float error) {
12        float totalWeight = 0;
13        float weightedSum = 0;
14        
15        for (auto& rule : rules) {
16            float membership = getMembership(error, rule.errorLow, rule.errorHigh);
17            if (membership > 0) {
18                float output = interpolate(rule.outputLow, rule.outputHigh, membership);
19                weightedSum += output * membership;
20                totalWeight += membership;
21            }
22        }
23        
24        return (totalWeight > 0) ? weightedSum / totalWeight : 0;
25    }
26};

Адаптивный регулятор с самонастройкой:

 1class AdaptivePID {
 2private:
 3    float Kp, Ki, Kd;
 4    float learningRate = 0.01;
 5    
 6public:
 7    void adaptParameters(float error, float errorRate) {
 8        // Самонастройка на основе поведения системы
 9        if (abs(error) > threshold) {
10            Kp += learningRate * sign(error * errorRate);
11        }
12        
13        if (hasOscillations()) {
14            Kd += learningRate * 0.1;
15        }
16        
17        if (hasSteadyStateError()) {
18            Ki += learningRate * 0.01;
19        }
20    }
21};

🎛️ ПИД-регулятор: объединяем все лучшее

🔄 Комбинированный подход

Формула ПИД-регулятора:

\[u(t) = K_p e(t) + K_i \int_0^t e(\tau)d\tau + K_d \frac{de(t)}{dt}\]

Каждый компонент отвечает за свое:

  • P-компонент: быстрая реакция на текущую ошибку
  • I-компонент: устранение накопленной ошибки
  • D-компонент: сглаживание переходных процессов

💻 Реализация ПИД-регулятора 

 1class PIDController {
 2private:
 3    float Kp, Ki, Kd;
 4    float integral = 0;
 5    float lastError = 0;
 6    unsigned long lastTime = 0;
 7    
 8public:
 9    PIDController(float kp, float ki, float kd) : Kp(kp), Ki(ki), Kd(kd) {}
10    
11    float calculate(float setpoint, float measured) {
12        unsigned long now = millis();
13        float dt = (now - lastTime) / 1000.0;  // секунды
14        
15        if (dt == 0) return 0;  // Избегаем деления на ноль
16        
17        float error = setpoint - measured;
18        
19        // Пропорциональная составляющая
20        float P = Kp * error;
21        
22        // Интегральная составляющая
23        integral += error * dt;
24        float I = Ki * integral;
25        
26        // Дифференциальная составляющая
27        float derivative = (error - lastError) / dt;
28        float D = Kd * derivative;
29        
30        // Итоговое управление
31        float output = P + I + D;
32        
33        // Ограничиваем выход
34        output = constrain(output, -255, 255);
35        
36        // Запоминаем для следующего раза
37        lastError = error;
38        lastTime = now;
39        
40        return output;
41    }
42    
43    void reset() {
44        integral = 0;
45        lastError = 0;
46        lastTime = millis();
47    }
48};

📊 Настройка коэффициентов

Влияние каждого коэффициента:

Параметр Увеличение приводит к: Побочные эффекты
Kp Faster response, Higher overshoot Instability, Oscillations
Ki Eliminates steady-state error Slower response, Overshoot
Kd Reduced overshoot, Improved stability Noise amplification

Метод настройки Зиглера-Никольса:

  1. Установить Ki = Kd = 0
  2. Увеличивать Kp до начала колебаний
  3. Критическое значение Kp = Kc
  4. Измерить период колебаний Tc
  5. Рассчитать коэффициенты:
\[K_p = 0.6 \cdot K_c\] \[K_i = \frac{2 \cdot K_p}{T_c}\] \[K_d = \frac{K_p \cdot T_c}{8}\]

⭐ Для любознательных: Продвинутая реализация

ПИД с защитой от wind-up:

 1class AdvancedPID {
 2private:
 3    float Kp, Ki, Kd;
 4    float integral = 0;
 5    float lastError = 0;
 6    float maxIntegral = 1000;  // Ограничение интеграла
 7    float outputMin = -255, outputMax = 255;
 8    
 9public:
10    float calculate(float setpoint, float measured, float dt) {
11        float error = setpoint - measured;
12        
13        // P-компонент
14        float P = Kp * error;
15        
16        // I-компонент с защитой от wind-up
17        float potentialIntegral = integral + error * dt;
18        float potentialOutput = P + Ki * potentialIntegral;
19        
20        if (potentialOutput >= outputMin && potentialOutput <= outputMax) {
21            integral = potentialIntegral;  // Обновляем только если не насыщение
22        }
23        integral = constrain(integral, -maxIntegral, maxIntegral);
24        
25        float I = Ki * integral;
26        
27        // D-компонент с фильтрацией
28        float rawDerivative = (error - lastError) / dt;
29        static float filteredDerivative = 0;
30        filteredDerivative = 0.8 * filteredDerivative + 0.2 * rawDerivative;  // Низкочастотный фильтр
31        float D = Kd * filteredDerivative;
32        
33        lastError = error;
34        
35        float output = P + I + D;
36        return constrain(output, outputMin, outputMax);
37    }
38};

📋 Блок-схема пропорционального регулятора

🏗️ Структура алгоритма 

flowchart TD
    A[🎯 Задать целевую скорость] --> B[📏 Измерить текущую скорость]
    B --> C[⚖️ Вычислить ошибку<br/>e = target - current]
    C --> D[📈 Вычислить управление<br/>u = Kp × e]
    D --> E[⚡ Применить к моторам<br/>motor.setPower(u)]
    E --> F[⏱️ Ждать интервал Δt]
    F --> B
    
    G[🛑 Стоп-условие?] --> H[⏹️ Остановить моторы]
    F --> G
    G -->|Нет| B

📊 Детальная блок-схема

Входные данные:

  • targetSpeed - желаемая скорость (0-100%)
  • Kp - коэффициент пропорциональности
  • dt - интервал обновления (мс)

Выходные данные:

  • motorPower - мощность мотора (-255 до +255)

Алгоритм в коде:

 1void proportionalSpeedControl() {
 2    // Шаг 1: Инициализация
 3    float targetSpeed = 50.0;  // Целевая скорость %
 4    float Kp = 2.0;           // Коэффициент
 5    
 6    while (true) {
 7        // Шаг 2: Измерение
 8        float currentSpeed = measureSpeed();
 9        
10        // Шаг 3: Вычисление ошибки
11        float error = targetSpeed - currentSpeed;
12        
13        // Шаг 4: Регулирование
14        float motorPower = Kp * error;
15        
16        // Шаг 5: Ограничение
17        motorPower = constrain(motorPower, -255, 255);
18        
19        // Шаг 6: Применение
20        setMotorPower(motorPower);
21        
22        // Шаг 7: Ожидание
23        delay(20);  // 50 Hz
24        
25        // Шаг 8: Проверка условий выхода
26        if (shouldStop()) break;
27    }
28}

🧪 Практическая работа: Создаем свой регулятор

🎯 Задание для групп

Разработайте блок-схему регулятора скорости для одной из ситуаций:

Группа 1: “Робот-доставщик”

  • Должен поддерживать постоянную скорость 30 км/ч
  • Дорога с подъемами и спусками
  • Важна экономия энергии

Группа 2: “Робот-пылесос”

  • Скорость зависит от типа поверхности
  • Ковер: медленно, плитка: быстро
  • Препятствия требуют резкого торможения

Группа 3: “Гоночный робот”

  • Максимальная скорость на прямых
  • Замедление перед поворотами
  • Важна точность и быстрота реакции

📝 Шаблон блок-схемы 

 11. [НАЧАЛО]
 2   ↓
 32. [Инициализация параметров]
 4   ↓
 53. [Чтение датчиков]
 6   ↓
 74. [Вычисление ошибки]
 8   ↓
 95. [Применение алгоритма регулирования]
10   ↓
116. [Ограничение выходного сигнала]
12   ↓
137. [Управление моторами]
14   ↓
158. [Проверка условий]
16   ↓
179. [КОНЕЦ или возврат к п.3]

📈 Анализ поведения регуляторов

📊 Графики переходных процессов

График 1: Только P-регулятор

 1Скорость
 2    ↑
 3100%|     ╭──── Цель
 4    |    ╱
 5 80%|   ╱    ╲
 6    |  ╱      ╲
 7 60%| ╱        ╲╱╲╱╲ ← Колебания
 8    |╱              ╲
 9  0%└─────────────────→ Время
10    0  1  2  3  4  5 сек

График 2: P + I регулятор

 1Скорость
 2    ↑
 3100%|        ╭────── Точное достижение цели
 4    |       ╱
 5 80%|      ╱
 6    |     ╱
 7 60%|    ╱
 8    |   ╱
 9  0%└───╱─────────────→ Время
10    0  1  2  3  4  5 сек

График 3: ПИД-регулятор

 1Скорость
 2    ↑
 3100%|      ╭──── Быстро и точно
 4    |     ╱
 5 80%|    ╱
 6    |   ╱
 7 60%|  ╱
 8    | ╱
 9  0%└╱────────────────→ Время
10    0  1  2  3  4  5 сек

⚡ Реакция на возмущения

Ситуация: Робот едет в горку

Плохой регулятор:

1Скорость падает и долго восстанавливается
250% → 30% → медленно → 50%

Хороший ПИД-регулятор:

1Скорость быстро компенсируется
250% → 45% → быстро → 50%

Код для тестирования:

 1void testDisturbanceRejection() {
 2    PIDController pid(2.0, 0.1, 0.5);
 3    float targetSpeed = 50.0;
 4    
 5    for (int t = 0; t < 100; t++) {
 6        float measuredSpeed = simulateRobot(t);
 7        
 8        // Имитируем возмущение на t=50
 9        if (t == 50) {
10            measuredSpeed -= 20;  // Резкое снижение скорости
11        }
12        
13        float control = pid.calculate(targetSpeed, measuredSpeed);
14        Serial.print(t); Serial.print(","); Serial.println(measuredSpeed);
15        
16        delay(100);
17    }
18}

⭐ Для любознательных: Анализ устойчивости

Характеристический полином замкнутой системы:

Для системы 2-го порядка с ПИД-регулятором:

\[s^3 + (1+K_d)s^2 + K_p s + K_i = 0\]

Критерий устойчивости Рауса:

Система устойчива, если все коэффициенты положительны и:

\[(1+K_d) \cdot K_p > K_i\]

Оптимальные настройки (метод LQR):

Минимизируем функционал:

\[J = \int_0^{\infty} (x^T Q x + u^T R u) dt\]

где Q - матрица весов состояний, R - матрица весов управления

🏃 Физкультминутка: Человеческие регуляторы

🎮 Упражнение “Регулятор равновесия”

Эксперимент 1: P-регулятор

  • Встаньте на одну ногу
  • Почувствуйте, как тело качается
  • Корректируйте положение пропорционально отклонению
  • Наблюдение: Постоянные колебания

Эксперимент 2: ПИД-регулятор

  • Снова балансируйте на одной ноге
  • Но теперь:
    • P: Реагируйте на текущий наклон
    • I: Помните общую тенденцию падения
    • D: Предугадывайте будущий наклон по скорости изменения
  • Наблюдение: Более стабильное равновесие

Эксперимент 3: “Робот и оператор”

  • Один ученик - “робот” (с закрытыми глазами)
  • Другой - “регулятор” (дает команды)
  • Задача: пройти по прямой линии
  • Сравнить: P-регулятор vs ПИД-регулятор

🌍 Применение в реальном мире

🚗 Автомобили

Круиз-контроль:

  • Поддержание заданной скорости
  • Компенсация подъемов/спусков
  • Адаптация к ветру и нагрузке

Код круиз-контроля:

 1class CruiseControl {
 2private:
 3    PIDController speedPID;
 4    float targetSpeed;
 5    
 6public:
 7    void update() {
 8        float currentSpeed = getVehicleSpeed();
 9        float throttleCommand = speedPID.calculate(targetSpeed, currentSpeed);
10        
11        if (throttleCommand > 0) {
12            setThrottle(throttleCommand);
13            setBrake(0);
14        } else {
15            setThrottle(0);
16            setBrake(-throttleCommand);
17        }
18    }
19};

✈️ Дроны и самолеты

Автопилот:

  • Стабилизация по всем осям
  • Поддержание высоты и скорости
  • Следование по маршруту

🏭 Промышленные роботы

Манипуляторы:

  • Точное позиционирование
  • Управление скоростью движения
  • Компенсация нагрузки

🚀 Космическая техника

Системы ориентации:

  • Поддержание ориентации спутников
  • Управление двигателями ракет
  • Стыковка космических аппаратов

🤔 Рефлексия: что мы изучили

🎯 Ключевые принципы

Основы управления скоростью:

  • ✅ Обратная связь - основа умного управления
  • ✅ Ошибка регулирования - ключевая величина
  • ✅ Разные типы регуляторов для разных задач
  • ✅ ПИД-регулятор - универсальное решение

Практические навыки:

  • ✅ Построение блок-схем алгоритмов управления
  • ✅ Анализ поведения различных регуляторов
  • ✅ Понимание влияния коэффициентов на качество регулирования
  • ✅ Применение теории к реальным задачам

🔍 Понимание системы

Что делает регулятор “умным”:

  • Постоянный контроль результата
  • Автоматическая коррекция ошибок
  • Адаптация к изменяющимся условиям
  • Предсказание и предотвращение проблем

🌟 Связь с будущим

Тренды в управлении роботами:

  • Адаптивные регуляторы с самонастройкой
  • Нейронные сети для управления
  • Робастные алгоритмы для неопределенных условий
  • Распределенное управление роя роботов

🏠 Домашнее задание

📋 Базовый уровень (для всех)

1. Блок-схема регулятора Создайте детальную блок-схему пропорционального регулятора для робота, поддерживающего заданную скорость при движении на подъем.

2. Анализ ситуаций Опишите, в каких ситуациях лучше использовать:

  • Только P-регулятор
  • PI-регулятор
  • Полный ПИД-регулятор

🎯 Повышенный уровень (по желанию)

3. Блок-схема ПИД-регулятора Разработайте полную блок-схему ПИД-регулятора с учетом всех трех компонентов и их взаимодействия.

4. Исследование применений Найдите примеры использования регуляторов скорости в реальных технических системах (автомобили, дроны, промышленные роботы) и подготовьте краткий обзор.

⭐ Для школьных аспирантов

5. Программная реализация Напишите программу симуляции ПИД-регулятора с возможностью изменения коэффициентов и наблюдения за поведением системы.

6. Настройка параметров Исследуйте различные методы настройки ПИД-регуляторов (Зиглера-Никольса, эмпирические методы) и сравните их эффективность.

🎉 Заключение

🏆 Что мы достигли

Теоретические знания:

  • 🧠 Понимание принципов обратной связи в управлении
  • 📊 Знание различных типов регуляторов и их свойств
  • ⚙️ Понимание математических основ ПИД-регулирования
  • 📈 Умение анализировать поведение систем управления

Практические навыки:

  • 📋 Построение блок-схем алгоритмов управления
  • 🔧 Проектирование регуляторов для конкретных задач
  • 📊 Анализ качества регулирования по графикам
  • 🎯 Выбор оптимального типа регулятора

🌟 Главное понимание

“Умное управление скоростью - это не просто ‘газ-тормоз’. Это искусство создания системы, которая сама думает, анализирует и корректирует свое поведение для достижения идеального результата!”

🚀 Применение в жизни

Где используются регуляторы скорости:

  • 🚗 Круиз-контроль в автомобилях
  • ✈️ Автопилоты самолетов и дронов
  • 🏭 Конвейеры и промышленные линии
  • 🚀 Системы управления космических аппаратов
  • 🏠 Умные системы отопления и кондиционирования

🎯 Сегодня вы изучили одну из основ современной автоматики!

📚 Дополнительные ресурсы

🔗 Полезные ссылки

Теория управления:

📖 Рекомендуемая литература

Для школьников:

  • “Основы автоматического управления” - О.А. Втоматиков
  • “ПИД-регуляторы: теория и практика” - Р.Е. Гуляторов
  • “Системы управления роботами” - С.У. Правлениев

⭐ Для углубленного изучения:

  • “Modern Control Engineering” - K. Ogata
  • “Automatic Control Systems” - B.C. Kuo
  • “PID Controllers: Theory, Design and Tuning” - K.J. Åström

🛠️ Программные инструменты

Симуляторы систем управления:

  • MATLAB/Simulink - профессиональное моделирование
  • Scilab/Xcos - бесплатная альтернатива
  • Python Control Systems Library - программирование регуляторов
  • Arduino PID Library - практическая реализация

🎮 Интерактивные демо

Онлайн-симуляторы:

  • PID Control Simulator
  • Control Systems Interactive Demos
  • Root Locus Design Tools
  • Bode Plot Analyzers

Успехов в изучении умного управления роботами! ⚙️🤖✨