🎯 Точное движение роботов

Программирование робота для движения по заданной траектории

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

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

🚀 Наша задача сегодня

🎯 Что мы будем делать?

Программируем точное движение:

  1. 📐 Выбираем геометрическую фигуру - квадрат, треугольник или восьмерка
  2. 🧮 Рассчитываем параметры - углы, расстояния, скорости
  3. 💻 Создаем программу - алгоритм точного движения
  4. 🔧 Учитываем физику - инерция, трение, проскальзывание
  5. ⚡ Тестируем и улучшаем - отладка для максимальной точности

🏆 Критерии успеха

Наш робот должен:

  • ✅ Точно воспроизводить выбранную геометрическую фигуру
  • ✅ Возвращаться в исходную точку с точностью ±3 см
  • ✅ Двигаться плавно без рывков
  • ✅ Работать стабильно при повторных запусках

🎪 Это настоящий вызов для программистов роботов!

📐 Математические основы траекторий

🔢 Геометрические фигуры и их параметры

🟦 Квадрат:

  • Угол поворота: 90°
  • Количество сторон: 4
  • Сумма углов: 360°

🔺 Треугольник:

  • Угол поворота: 120°
  • Количество сторон: 3
  • Сумма углов: 360°

♾️ Восьмерка:

  • Два полукруга
  • Угол каждого полукруга: 180°
  • Переход между кругами

🧮 Расчет углов поворота

Формула для правильного многоугольника: \[\alpha = \frac{360°}{n}\]

где n - количество сторон

Примеры:

  • Квадрат (n=4): α = 360°/4 = 90°
  • Треугольник (n=3): α = 360°/3 = 120°
  • Шестиугольник (n=6): α = 360°/6 = 60°

⚙️ Физика движения роботов

🌪️ Влияние инерции

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

  1. Робот движется прямо с постоянной скоростью
  2. Получает команду поворота
  3. Инерция заставляет продолжать движение вперед
  4. Поворот начинается с задержкой
  5. Траектория “сглаживается”

Факторы, влияющие на инерцию:

  • Масса робота
  • Скорость движения
  • Коэффициент трения колес
  • Момент инерции относительно центра масс

🎯 Компенсация физических эффектов

Методы компенсации:

1. Снижение скорости перед поворотом:

1void turnWithCompensation(int angle) {
2    setSpeed(50);        // Замедляемся
3    delay(200);          // Даем время затормозить
4    turn(angle);         // Поворачиваем
5    delay(100);          // Даем время повернуться
6    setSpeed(100);       // Восстанавливаем скорость
7}

2. Поправочные коэффициенты:

1int compensatedAngle = targetAngle * 1.05;  // Компенсация недоворота
2int compensatedTime = targetTime * 0.95;    // Компенсация инерции

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

Центростремительная сила при повороте:

\[F_c = \frac{m v^2}{R}\]

где:

  • m - масса робота
  • v - скорость движения
  • R - радиус поворота

Максимальная скорость поворота без проскальзывания:

\[v_{max} = \sqrt{\mu g R}\]

где μ - коэффициент трения

Момент инерции для поворота:

\[I = \frac{1}{2} m (a^2 + b^2)\]

для прямоугольного робота с размерами a×b

Угловое ускорение:

\[\epsilon = \frac{M}{I}\]

где M - момент силы от моторов

Время поворота на угол θ:

\[t = \sqrt{\frac{2\theta}{\epsilon}}\]

при равноускоренном движении от покоя

💻 Программирование точного движения

🔧 Базовые функции управления

Основные команды движения:

 1// Движение вперед на заданное расстояние
 2void moveForward(int distance, int speed) {
 3    // Расчет времени движения
 4    int time = (distance * 1000) / speed;  // мс
 5    
 6    motors.setSpeed(speed);
 7    motors.forward();
 8    delay(time);
 9    motors.stop();
10}
11
12// Поворот на заданный угол
13void turnRight(int angle) {
14    // Калибровочный коэффициент для данного робота
15    float turnCoeff = 5.5;  // мс на градус
16    int turnTime = angle * turnCoeff;
17    
18    motors.turnRight();
19    delay(turnTime);
20    motors.stop();
21}

🟦 Программа для квадрата

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

 1void drawSquare(int sideLength) {
 2    Serial.println("Начинаем рисовать квадрат");
 3    
 4    for (int i = 0; i < 4; i++) {
 5        Serial.print("Сторона ");
 6        Serial.println(i + 1);
 7        
 8        // Движение по стороне
 9        moveForward(sideLength, 80);
10        delay(500);  // Пауза для стабилизации
11        
12        // Поворот на 90 градусов
13        turnRight(90);
14        delay(500);  // Пауза для стабилизации
15    }
16    
17    Serial.println("Квадрат завершен!");
18}
19
20void setup() {
21    Serial.begin(9600);
22    motors.init();
23}
24
25void loop() {
26    drawSquare(200);  // Квадрат со стороной 20 см
27    delay(5000);      // Пауза перед повтором
28}

🔺 Программа для треугольника

Особенности треугольника:

  • Угол поворота: 120°
  • Более острые повороты
  • Требует большей компенсации инерции
 1void drawTriangle(int sideLength) {
 2    Serial.println("Начинаем рисовать треугольник");
 3    
 4    for (int i = 0; i < 3; i++) {
 5        Serial.print("Сторона ");
 6        Serial.println(i + 1);
 7        
 8        // Движение по стороне
 9        moveForward(sideLength, 70);  // Чуть медленнее для точности
10        delay(700);  // Больше времени на стабилизацию
11        
12        // Поворот на 120 градусов с компенсацией
13        compensatedTurn(120);
14        delay(700);
15    }
16    
17    Serial.println("Треугольник завершен!");
18}
19
20void compensatedTurn(int angle) {
21    // Снижаем скорость перед поворотом
22    motors.setSpeed(40);
23    delay(200);
24    
25    // Поворот с поправкой на инерцию
26    turnRight(angle * 1.08);  // Компенсация недоворота
27    
28    delay(300);  // Время на завершение поворота
29}

♾️ Программа для восьмерки

Самая сложная фигура:

  • Два соединенных полукруга
  • Плавные дуговые движения
  • Точка пересечения в центре
 1void drawFigureEight(int radius) {
 2    Serial.println("Начинаем рисовать восьмерку");
 3    
 4    // Первый полукруг (правый)
 5    drawSemicircle(radius, true);   // по часовой стрелке
 6    
 7    // Переход в центр
 8    delay(500);
 9    
10    // Второй полукруг (левый)
11    drawSemicircle(radius, false);  // против часовой стрелки
12    
13    Serial.println("Восьмерка завершена!");
14}
15
16void drawSemicircle(int radius, bool clockwise) {
17    int steps = 18;  // 18 шагов по 10 градусов = 180°
18    int stepAngle = 10;
19    int arcLength = (2 * PI * radius) / (360 / stepAngle);
20    
21    for (int i = 0; i < steps; i++) {
22        moveForward(arcLength, 60);
23        delay(100);
24        
25        if (clockwise) {
26            turnRight(stepAngle);
27        } else {
28            turnLeft(stepAngle);
29        }
30        delay(100);
31    }
32}

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

Adaptive Speed Control (адаптивное управление скоростью):

 1class TrajectoryController {
 2private:
 3    float currentSpeed;
 4    float targetSpeed;
 5    float acceleration;
 6    
 7public:
 8    void smoothAcceleration(float target, float accel) {
 9        acceleration = accel;
10        targetSpeed = target;
11        
12        while (abs(currentSpeed - targetSpeed) > 0.1) {
13            if (currentSpeed < targetSpeed) {
14                currentSpeed += acceleration;
15            } else {
16                currentSpeed -= acceleration;
17            }
18            
19            motors.setSpeed(currentSpeed);
20            delay(20);  // 50 Hz update rate
21        }
22    }
23    
24    void smoothTurn(int angle, float radius) {
25        // Расчет оптимальной скорости для поворота
26        float maxSpeed = sqrt(FRICTION_COEFF * GRAVITY * radius);
27        smoothAcceleration(maxSpeed, 2.0);
28        
29        // Выполнение поворота
30        float arcLength = (PI * radius * angle) / 180.0;
31        executeArc(arcLength, radius);
32        
33        // Возврат к нормальной скорости
34        smoothAcceleration(100, 2.0);
35    }
36};

PID-регулятор для точного позиционирования:

 1class PIDController {
 2private:
 3    float kp, ki, kd;
 4    float lastError;
 5    float integral;
 6    
 7public:
 8    PIDController(float p, float i, float d) : kp(p), ki(i), kd(d) {
 9        lastError = 0;
10        integral = 0;
11    }
12    
13    float calculate(float setpoint, float actual) {
14        float error = setpoint - actual;
15        integral += error;
16        float derivative = error - lastError;
17        
18        float output = kp * error + ki * integral + kd * derivative;
19        
20        lastError = error;
21        return output;
22    }
23};
24
25// Использование для коррекции траектории
26PIDController anglePID(2.0, 0.1, 0.5);
27
28void correctiveMove(float targetDistance) {
29    float actualDistance = getDistanceFromSensor();
30    float correction = anglePID.calculate(targetDistance, actualDistance);
31    
32    // Применяем коррекцию к скорости моторов
33    motors.setLeftSpeed(baseSpeed + correction);
34    motors.setRightSpeed(baseSpeed - correction);
35}

🧪 Тестирование и калибровка

📏 Измерение точности

Метрики для оценки качества:

1. Точность возврата в исходную точку:

 1struct Point {
 2    float x, y;
 3};
 4
 5Point startPoint = {0, 0};
 6Point endPoint;
 7
 8float calculateDeviation() {
 9    return sqrt(pow(endPoint.x - startPoint.x, 2) + 
10                pow(endPoint.y - startPoint.y, 2));
11}

2. Отклонение от эталонной траектории:

1float maxDeviation = 0;
2float currentDeviation;
3
4void checkTrajectory(Point current, Point reference) {
5    currentDeviation = distance(current, reference);
6    if (currentDeviation > maxDeviation) {
7        maxDeviation = currentDeviation;
8    }
9}

🔧 Калибровка параметров

Алгоритм автоматической калибровки:

 1void calibrateMovement() {
 2    Serial.println("Начинаем калибровку...");
 3    
 4    // Калибровка прямолинейного движения
 5    float distanceCoeff = calibrateDistance();
 6    
 7    // Калибровка поворотов
 8    float turnCoeff = calibrateTurns();
 9    
10    // Сохранение коэффициентов
11    saveCalibration(distanceCoeff, turnCoeff);
12    
13    Serial.println("Калибровка завершена!");
14}
15
16float calibrateDistance() {
17    // Движение на известное расстояние
18    moveForward(1000, 80);  // 1 секунда на скорости 80
19    
20    // Измерение фактического расстояния
21    float actualDistance = measureDistance();
22    
23    // Расчет коэффициента
24    return actualDistance / 80.0;  // мм на единицу скорости
25}
26
27float calibrateTurns() {
28    for (int i = 0; i < 4; i++) {
29        turnRight(90);
30        delay(500);
31    }
32    
33    // Измерение отклонения от исходного направления
34    float angleError = measureAngleError();
35    
36    // Коэффициент коррекции
37    return 1.0 + (angleError / 360.0);
38}

⭐ Для любознательных: Математическая оптимизация

Least Squares для калибровки:

Если у нас есть n измерений пар (команда, результат):

\[\min \sum_{i=1}^{n} (y_i - (a \cdot x_i + b))^2\]

Решение:

\[a = \frac{n\sum x_i y_i - \sum x_i \sum y_i}{n\sum x_i^2 - (\sum x_i)^2}\] \[b = \frac{\sum y_i - a\sum x_i}{n}\]

Adaptive learning алгоритм:

 1class AdaptiveLearning {
 2private:
 3    float learningRate = 0.1;
 4    float distanceCoeff = 1.0;
 5    float turnCoeff = 1.0;
 6    
 7public:
 8    void updateFromError(float commandDistance, float actualDistance) {
 9        float error = actualDistance - commandDistance;
10        float gradient = error / commandDistance;
11        
12        distanceCoeff -= learningRate * gradient;
13        
14        // Ограничиваем коэффициент разумными пределами
15        distanceCoeff = constrain(distanceCoeff, 0.5, 2.0);
16    }
17    
18    float getOptimalDistance(float target) {
19        return target * distanceCoeff;
20    }
21};

🎯 Продвинутые техники

🌊 Сглаживание траекторий

Проблема: Резкие повороты создают рывки и неточности

Решение: Сплайн-интерполяция

 1struct Waypoint {
 2    float x, y;
 3    float heading;
 4};
 5
 6class SmoothTrajectory {
 7public:
 8    void addWaypoint(float x, float y, float heading) {
 9        waypoints.push_back({x, y, heading});
10    }
11    
12    void executeSmoothPath() {
13        for (int i = 0; i < waypoints.size() - 1; i++) {
14            smoothTransition(waypoints[i], waypoints[i+1]);
15        }
16    }
17    
18private:
19    vector<Waypoint> waypoints;
20    
21    void smoothTransition(Waypoint start, Waypoint end) {
22        // Bezier curve interpolation
23        int steps = 20;
24        for (int i = 0; i <= steps; i++) {
25            float t = (float)i / steps;
26            Waypoint current = interpolate(start, end, t);
27            moveToPoint(current);
28        }
29    }
30    
31    Waypoint interpolate(Waypoint p1, Waypoint p2, float t) {
32        return {
33            p1.x + t * (p2.x - p1.x),
34            p1.y + t * (p2.y - p1.y),
35            p1.heading + t * (p2.heading - p1.heading)
36        };
37    }
38};

📡 Использование датчиков для коррекции

Интеграция с энкодерами колес:

 1class EncoderNavigation {
 2private:
 3    long leftEncoder, rightEncoder;
 4    float wheelDiameter = 65.0;  // мм
 5    int encoderPPR = 360;        // импульсов на оборот
 6    
 7public:
 8    void updatePosition() {
 9        long leftTicks = getLeftEncoder() - leftEncoder;
10        long rightTicks = getRightEncoder() - rightEncoder;
11        
12        float leftDistance = ticksToMM(leftTicks);
13        float rightDistance = ticksToMM(rightTicks);
14        
15        // Расчет изменения позиции
16        float deltaDistance = (leftDistance + rightDistance) / 2.0;
17        float deltaAngle = (rightDistance - leftDistance) / wheelBase;
18        
19        // Обновление текущей позиции
20        currentX += deltaDistance * cos(currentHeading);
21        currentY += deltaDistance * sin(currentHeading);
22        currentHeading += deltaAngle;
23        
24        leftEncoder = getLeftEncoder();
25        rightEncoder = getRightEncoder();
26    }
27    
28private:
29    float ticksToMM(long ticks) {
30        return (ticks * PI * wheelDiameter) / encoderPPR;
31    }
32};

⭐ Для любознательных: Machine Learning для оптимизации

Reinforcement Learning для калибровки:

 1class QLearning {
 2private:
 3    float qTable[STATES][ACTIONS];
 4    float learningRate = 0.1;
 5    float discountFactor = 0.9;
 6    float explorationRate = 0.1;
 7    
 8public:
 9    int selectAction(int state) {
10        if (random(100) < explorationRate * 100) {
11            return random(ACTIONS);  // Исследование
12        } else {
13            return getBestAction(state);  // Использование знаний
14        }
15    }
16    
17    void updateQ(int state, int action, float reward, int nextState) {
18        float maxQ = getMaxQ(nextState);
19        float oldQ = qTable[state][action];
20        
21        qTable[state][action] = oldQ + learningRate * 
22            (reward + discountFactor * maxQ - oldQ);
23    }
24    
25    float calculateReward(float trajectoryError) {
26        // Чем меньше ошибка, тем больше награда
27        return 1.0 / (1.0 + trajectoryError);
28    }
29};

Genetic Algorithm для оптимизации параметров:

 1struct Individual {
 2    float distanceCoeff;
 3    float turnCoeff;
 4    float speed;
 5    float fitness;
 6};
 7
 8class GeneticOptimizer {
 9private:
10    vector<Individual> population;
11    int populationSize = 20;
12    float mutationRate = 0.1;
13    
14public:
15    void evolve() {
16        // Оценка приспособленности
17        evaluateFitness();
18        
19        // Селекция лучших
20        selection();
21        
22        // Скрещивание
23        crossover();
24        
25        // Мутация
26        mutation();
27    }
28    
29private:
30    void evaluateFitness() {
31        for (auto& individual : population) {
32            individual.fitness = testTrajectory(individual);
33        }
34    }
35    
36    float testTrajectory(Individual params) {
37        // Запуск робота с данными параметрами
38        // Измерение точности траектории
39        // Возврат обратной величины ошибки
40        return 1.0 / (1.0 + measureTrajectoryError(params));
41    }
42};

🏆 Демонстрация и соревнование

📊 Критерии оценки

Система баллов:

Критерий Отлично (5) Хорошо (4) Удовлетв. (3) Плохо (2)
Точность фигуры ±2 см ±5 см ±10 см >10 см
Возврат в исходную точку ±3 см ±7 см ±15 см >15 см
Плавность движения Без рывков Малые рывки Заметные рывки Сильные рывки
Стабильность 100% успех 75% успех 50% успех <50% успех

🎪 Форматы соревнований

Соревнование 1: “Точность”

  • Каждая команда демонстрирует свою фигуру 3 раза
  • Измеряется отклонение от эталона
  • Побеждает самая точная команда

Соревнование 2: “Скорость и точность”

  • Ограничение времени: 30 секунд на фигуру
  • Баллы = Точность × Коэффициент скорости
  • Балансирование между скоростью и качеством

Соревнование 3: “Творческая траектория”

  • Команды создают собственную сложную фигуру
  • Оценивается сложность, точность и оригинальность

🏅 Специальные номинации

  • 🎯 “Снайпер” - самая точная траектория
  • ⚡ “Скоростной” - быстрое и точное выполнение
  • 💡 “Инноватор” - лучший алгоритм компенсации
  • 🛠️ “Инженер” - самая элегантная программа
  • 🎨 “Художник” - самая красивая траектория

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

🎯 Полученные навыки

Программные навыки:

  • ✅ Алгоритмизация сложных движений
  • ✅ Структурирование программного кода
  • ✅ Отладка и оптимизация программ
  • ✅ Интеграция математических расчетов в код

Инженерные навыки:

  • ✅ Учет физических факторов в программировании
  • ✅ Калибровка и настройка систем
  • ✅ Измерение и анализ точности
  • ✅ Компенсация систематических ошибок

🔍 Понимание принципов

Взаимосвязь дисциплин:

  • Математика → расчет параметров движения
  • Физика → понимание инерции и трения
  • Программирование → реализация алгоритмов
  • Инженерия → оптимизация решений

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

Где используются эти принципы:

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

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

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

1. Алгоритм для многоугольника Составьте алгоритм движения робота по правильному пятиугольнику. Рассчитайте:

  • Угол поворота на каждом углу
  • Последовательность команд
  • Ожидаемые проблемы и способы их решения

2. Отчет о практической работе Подготовьте краткий отчет (1-2 страницы):

  • Какую фигуру программировали
  • Какие трудности возникли
  • Как решали проблемы с точностью
  • Какие улучшения внесли

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

3. Программа для спирали Разработайте программу для движения робота по спирали с постепенно уменьшающимся радиусом:

  • Начальный радиус: 30 см
  • Финальный радиус: 5 см
  • Количество витков: 5

4. Исследование влияния скорости Проведите эксперимент:

  • Протестируйте движение по квадрату на разных скоростях (50%, 75%, 100%)
  • Измерьте отклонения для каждой скорости
  • Постройте график зависимости точности от скорости

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

5. Адаптивный алгоритм Разработайте программу, которая автоматически подстраивает параметры движения:

  • Измеряет отклонения в реальном времени
  • Корректирует параметры на следующем цикле
  • Обучается на собственных ошибках

6. Сложная траектория Создайте программу для движения по произвольной траектории, заданной массивом точек:

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

🎉 Заключение

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

Практические результаты:

  • 🤖 Запрограммировали роботов для точного движения
  • 📐 Применили математику для расчета траекторий
  • ⚙️ Учли физические факторы в программах
  • 🔧 Освоили методы калибровки и оптимизации

Новые навыки:

  • 💻 Программирование сложных алгоритмов движения
  • 🧮 Интеграция математических расчетов в код
  • 🔍 Анализ и исправление систематических ошибок
  • ⚡ Оптимизация производительности программ

🌟 Главное открытие

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

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

Современные применения:

  • Беспилотные автомобили используют те же принципы для движения по полосам
  • Промышленные роботы выполняют миллиметрово точные операции
  • Дроны летают по заданным маршрутам с GPS-навигацией
  • Космические аппараты корректируют траекторию для точной посадки

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

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

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

Программирование роботов:

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

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

  • “Программирование роботов” - П.Р. Ограммиров
  • “Математика в робототехнике” - М.А. Тематиков
  • “Физика движения роботов” - Ф.И. Зическов

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

  • “Robot Motion Planning” - J.C. Latombe
  • “Introduction to Robotics” - J.J. Craig
  • “Modern Robotics” - K.M. Lynch, F.C. Park

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

Симуляторы и среды разработки:

  • Arduino IDE - программирование микроконтроллеров
  • Scratch for Arduino - визуальное программирование
  • Tinkercad Circuits - онлайн-симулятор
  • Robot Virtual Worlds - симуляция движения

🎮 Дополнительные проекты

Идеи для развития:

  • Робот-художник (рисует сложные картины)
  • Система автопарковки (точная постановка в гараж)
  • Робот-танцор (хореография движений)
  • Система слежения за линией с препятствиями

Успехов в программировании точного движения роботов! 🎯🤖✨