Практикум для «Олимпийца» (Olympic Bot). Часть 1: езда по линии с перекрёстками

В первой части практикума построим тренировочного робота «Олимпиец» (Olympic Bot) на Arduino, научим его ездить по линии и разберёмся с двумя примерами олимпиадных заданий за 2022–2023 учебный год.

По любым вопросам старайся сначала самостоятельно разобраться и найти ответ на многочисленных профильных сайтах про Arduino и робототехнику, например: wiki.amperka.ru, arduino.ru и так далее.

Готовый ответ, полученный от учителя или ИИ-помощника, ты забудешь на следующий день. А вот знания, «выстраданные» своими усилиями, останутся с тобой надолго и обязательно пригодятся на олимпиадах.

Для начала познакомимся с электроникой, которая будет управлять роботом «Олимпиец».

Контроллер Iskra Uno — «мозг» будущего робота. Именно она будет выполнять программу, считывать показания датчиков и передавать команды моторам и сервоприводу. Iskra Uno совместима с платформой Arduino, которую мы будем использовать для программирования робота.

Платформа Iskra Uno предоставляет 32 физических контакта на штатных колодках Arduino R3 и 6 дублирующих контактов на разъёме ICSP для подключения дополнительных плат расширения, модулей и сенсоров.

• Всего физических контактов: 38 (32+6)
• Контактов ввода-вывода GPIO: 20
• Контакты с ШИМ: 6 с разрядностью 8 бит
• Контакты с АЦП: 6 с разрядностью до 10 бит
• Аппаратные интерфейсы: 1× UART, 1× SPI, 1× I²C

Плата расширения Troyka Shield служит для комфортного подключения датчиков к контроллерам формфактора Arduino R3.

Troyka Shield устанавливается на управляющие платы формфактора Arduino R3 сверху методом бутерброда.

Датчики подключаются через стандартные трёхпроводные шлейфы без пайки и макетной платы.

Контакты Iskra Uno не рассчитаны на питание двигателей напрямую — моторы потребляют значительно больший ток. Плата расширения Motor Shield берёт на себя силовую часть: получает управляющие сигналы от Iskra Uno и с их помощью управляет направлением и скоростью вращения моторов.

Motor Shield устанавливается на управляющие платы формфактора Arduino R3 сверху методом бутерброда.

Моторы подключаются через клеммники M1 и M2.

По умолчанию Motor Shield использует следующие пины Iskra Uno.

1. Подключи контроллер Iskra Uno к компьютеру через кабель USB. При успешном подключении должен загореться индикаторный светодиод ON.
2. Скачай и установи Arduino IDE для операционной системы твоего компьютера.

После всех манипуляций среда Arduino IDE должна определить подключённую плату Iskra Uno.

• Заучи самые частые и полезные комбинации сочетания клавиш:
  • CTRL + C: копировать
  • CTRL + V: вставить
  • CTRL + /: закомментировать или раскоментировать фрагмент кода.
• Включи опции Показывать номера строк и Сворачивание кода.
• Воспользуйся онлайн-тренажёрами по печати текста, чтобы научиться печатать вслепую, не отвлекая взгляд на клавиатуру.

Перед тем как перейти к управлению оборудованием робота, подготовим основные настройки программы:

• Обозначение контактов — зададим понятные имена контактам, к которым подключено оборудование.
• Создание переменных — подготовим переменные для хранения и обработки данных.
• Настройка контактов — укажем, какие контакты контроллера работают как входы, а какие — как выходы.

Каждый модуль робота подключён к определённому пину контроллера. Чтобы не запоминать номера контактов и каждый раз не искать их в схеме подключения, дадим пинам понятные имена в самой программе.

Для назначения имён используем директиву препроцессора #define. Препроцессор заменяет заданное имя на соответствующее значение перед компиляцией программы. При этом оперативная память Arduino не расходуется.

Приведём пример, как назначить имена для всех задействованных пинов, и не запутаться.

4-1-pin-names-example.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
// Даём понятные имена пинам левого энкодера A и B
#define PIN_ENC_LA 2
#define PIN_ENC_LB 12
// Даём понятные имена пинам правого энкодера A и B
#define PIN_ENC_RA 3
#define PIN_ENC_RB 13
// Даём понятное имя пину ИК-дальномера
#define PIN_IRR A2
// Даём понятные имена пинам УЗ-дальномера TRIG и ECHO
#define PIN_USR_T 11
#define PIN_USR_E 10
// Даём понятное имя пину сервопривода головы
#define PIN_SRV_HEAD 8
// Даём понятное имя пину сервомотора захвата
#define PIN_SRV_GRIP 9

Во время работы «Олимпийцу» понадобится хранить различные данные: показания датчиков, рассчитанное расстояние и другие изменяющиеся значения. Для этого в программе используются переменные.

Чтобы было проще разобраться, как устроена программа и за что отвечает каждая её часть, сначала познакомься с несколькими базовыми понятиями:

• Переменные и типы данных: int, float, bool, unsigned long и другие.
• Локальные и глобальные переменные.
• Функции, их параметры и возвращаемые значения.

Создадим базовые необходимые переменные в начале программы.

4-2-basic-variables.ino

// Переменные для хранения данных с датчиков линии
int senLineL, senLineR;
// Переменная для хранения данных с ИК-дальномера
int senIRR;
// Переменная для хранения данных с УЗ-дальномера
int senUSR;

Мы уже дали всем контактам понятные имена. Теперь нужно указать контроллеру, как будет использоваться каждый из них — для получения или передачи сигнала.

Для настройки пина используй функцию pinMode(). Настройку выполняем в функции setup(), поскольку этот код должен выполниться только один раз — при запуске контроллера.

4-3-pin-mode-setup.ino

void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  // Настраиваем пины управления сервоприводами в режим выхода
  pinMode(PIN_SRV_HEAD, OUTPUT);
  pinMode(PIN_SRV_GRIP, OUTPUT);
  // Настраиваем пины УЗ-дальномера
  // пин TRIG в режим выхода, пин ECHO в режим входа
  pinMode(PIN_USR_T, OUTPUT);
  pinMode(PIN_USR_E, INPUT);
  // Настраиваем пины датчиков линии в режим входа
  pinMode(PIN_LINE_L, INPUT);
  pinMode(PIN_LINE_R, INPUT);
  // Настраиваем пин ИК-дальномера в режим входа
  pinMode(PIN_IRR, INPUT);
  // Настраиваем пины энкодеров в режим входа
  pinMode(PIN_ENC_LA, INPUT);
  pinMode(PIN_ENC_LB, INPUT);
  pinMode(PIN_ENC_RA, INPUT);
  pinMode(PIN_ENC_RB, INPUT);
}

Базовая конфигурация готова: мы дали понятные имена используемым контактам, создали необходимые переменные и настроили режим работы выводов. Теперь программа знает, к каким контактам подключены основные элементы робота. Пора научить «Олимпийца» получать информацию об окружающем мире.

Основные моменты при проверке жюри программы:

• Читаемость кода. Используй понятные названия переменных и функций, а код разбивай на логические блоки.
• Комментарии. Добавляй комментарии к блокам кода, процедурам и функциям — комментировать каждую строку не нужно.
• Настройки. Выделяй комментариями параметры, которые часто требуются для настройки робота, чтобы их можно было быстро найти и изменить.

Чтобы ориентироваться на трассе, «Олимпийцу» необходимо получать информацию об окружающем мире. Ориентироваться на трассе роботу помогают сразу несколько датчиков:

• Ультразвуковой дальномер для измерения расстояния до объектов.
• Инфракрасный дальномер для детекции препятствий.
• Датчики линии для считывания границ линии на поверхности трассы.

Ультразвуковой дальномер HC-SR04 служит для определения расстояния до объекта с помощью ультразвуковых волн. Диапазон измерений от 2 до 400 см.

Ультразвуковой дальномер HC-SR04 работает по принципу эхолокации.

Измерим расстояние с помощью УЗ-дальномера и выведем полученное значение в монитор порта.

ultrasonic-distance-sensor-example.ino

// Даём понятные имена пинам УЗ-дальномера TRIG и ECHO
#define PIN_USR_T 11
#define PIN_USR_E 10
 
void setup() {
  // Открываем COM-порт на работу со скоростью 9600 бит/сек
  Serial.begin(9600);
  // Настраиваем пины УЗ-дальномера
  // пин TRIG в режим выхода, пин ECHO в режим входа
  pinMode(PIN_USR_T, OUTPUT);
  pinMode(PIN_USR_E, INPUT);
}
 
void loop() {
  // Считываем расстояние с УЗ-дальномера
  int senUSR = readDistUSR();
  // Выводим показания датчиков в монитор порта
  Serial.print("USR = ");
  Serial.println(senUSR);
  // Ждём 100 мс
  delay(100);
}
 
// Получение показаний с УЗ-дальномера
int readDistUSR() {
  // Формируем импульс длительностью 10 мкс на пине TRIG
  digitalWrite(PIN_USR_T, LOW);
  delayMicroseconds(5);
  digitalWrite(PIN_USR_T, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_USR_T, LOW);
  // Измеряем длительность импульса на пине ECHO
  int duration = pulseIn(PIN_USR_E, HIGH);
  // Переводим время прохождения сигнала в расстояние в см
  int distance = abs(duration / 58);
  // Возвращаем измеренное расстояние
  return distance;
}

Инфракрасный дальномер Sharp GP2Y0A21 служит для определения расстояния до объектов с помощью инфракрасного света. Диапазон измерений от 10 до 80 см.

Дальномер Sharp GP2Y0A21 работает в невидимом для глаза инфракрасном спектре.

В рабочем диапазоне датчика положение светового пятна на PSD изменяется вместе с расстоянием до объекта. Электроника датчика преобразует это положение в выходное напряжение. Зависимость напряжения от расстояния нелинейная, поэтому для получения расстояния в сантиметрах потребуется преобразование показаний.

Измерим расстояние с помощью ИК-дальномера и выведем полученное значение в монитор порта.

ir-distance-sensor-example.ino

// Даём понятное имя пину ИК-дальномера
#define PIN_IRR A2
 
void setup() {
  // Открываем COM-порт на работу со скоростью 9600 бит/сек
  Serial.begin(9600);
  // Настраиваем пин ИК-дальномера в режим входа
  pinMode(PIN_IRR, INPUT);
}
 
void loop() {
  // Считываем расстояние с ИК-дальномера
  int senIRR = readDistIRR();
  // Выводим показания датчиков в монитор порта
  Serial.print("IRR = ");
  Serial.println(senIRR);
  // Ждём 100 мс
  delay(100);
}
 
// Получение показаний с ИК-дальномера
int readDistIRR() {
  // Считываем показания с ИК-дальномера в отчётах АЦП
  int value = analogRead(PIN_IRR);
  // Конвертируем показания в напряжение
  float voltage = value * (5.0 / 1024.0);
  // Конвертируем напряжение в расстояние в см
  float distance = 29.988 * pow(v, -1.173);
  // Возвращаем полученное значение
  return int(distance);
}

Датчик линии определяет отражающую способность поверхности под роботом и позволяет отличать светлую поверхность от тёмной линии.

Датчик линии выполнен на оптопаре TCRT5000, которая состоит из двух элементов:

• ИК-светодиод (излучатель)
• Фототранзистор (приёмник)

Когда светодиод излучает инфракрасный свет, световой поток отражается от поверхности и попадает на фототранзистор, где преобразуется в электрический сигнал. Тёмный цвет отражает меньше света, светлый — больше.

Контроллеры Arduino считывают показания с датчиков линии в диапазоне [0…1023]. При этом значения получаются инверсными: чёрному цвету соответствует большее значение, а белому цвету — меньшее.

Если тебе доводилось писать ПД-регулятор для Lego-робота, то привычнее работать со шкалой [0…100], где всё наоборот: чёрному цвету соответствует меньшее значение, а чёрному цвету — большее. Поэтому приведём показания Arduino к привычной Lego-шкале.

1. Инвертируем показания, чтобы на белом датчик показывал больше, а на чёрном — меньше:

   senLineL = (1024 - analogRead(PIN_LINE_L))
   senLineR = (1024 - analogRead(PIN_LINE_R))

2. Сжимаем диапазон до [0…100].

   senLineL = (1024 - analogRead(PIN_LINE_L)) / 10;
   senLineR = (1024 - analogRead(PIN_LINE_R)) / 10;

3. Также можно воспользоваться встроенной в Arduino IDE функцией map():

   senLineL = map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);
   senLineR = map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);

Считаем показания датчиков линии и выведем полученные значения в монитор порта.

line-sensor-example.ino

// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
 
void setup() {
  // Открываем COM-порт на работу со скоростью 9600 бит/сек
  Serial.begin(9600);
  // Настраиваем пины датчиков линии в режим входа
  pinMode(PIN_LINE_L, INPUT);
  pinMode(PIN_LINE_R, INPUT);
}
 
void loop() {
  // Считываем данные с датчиков линии
  readSenLines();
}
 
// Получение показаний с датчиков линии
void readSenLines() {
  // Считываем показание левого датчика линии
  int senLineL = map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);
  // Считываем показание правого датчика линии
  int senLineR = map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);
  // Выводим показания датчиков в монитор порта
  Serial.print("L = ");
  Serial.print(senLineL);
  Serial.print("\tR = ");
  Serial.print(senLineR);
  // Ждём 100 мс
  delay(100);
}

Теперь проверим работу всех датчиков одновременно. Выведем показания сенсоров в монитор последовательного порта и убедимся в правильности работы.

all-sensors-test.ino

// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
// Даём понятное имя пину ИК-дальномера
#define PIN_IRR A2
// Даём понятные имена пинам УЗ-дальномера TRIG и ECHO
#define PIN_USR_T 11
#define PIN_USR_E 10
 
 
void setup() {
  // Открываем COM-порт на работу со скоростью 9600 бит/сек
  Serial.begin(9600);
}
 
void loop() {
  // Считываем показание левого датчика линии
  int senLineL = map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);;
  // Считываем показание правого датчика линии
  int senLineR = map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);;
  // Считываем расстояние с ИК-дальномера
  int senIRR = readDistIRR();
  // Считываем расстояние с УЗ-дальномера
  int senUSR = readDistUSR();
  // Выводим показания датчиков в монитор порта
  Serial.print("L = ");
  Serial.print(senLineL);
  Serial.print("\tR = ");
  Serial.print(senLineR);
  Serial.print("\tIRR = ");
  Serial.print(senIRR);
  Serial.print("\tUSR =");
  Serial.println(senUSR);
  // Ждём 100 мс
  delay(100);
}
 
// Получение показаний с ИК-дальномера
int readDistIRR() {
  // Считываем показания с ИК-дальномера в отчётах АЦП
  int value = analogRead(PIN_IRR);
  // Конвертируем показания в напряжение
  float voltage = value * (5.0 / 1024.0);
  // Конвертируем напряжение в расстояние в см
  float distance = 29.988 * pow(v, -1.173);
  // Возвращаем полученное значение
  return int(distance);
}
 
// Получение показаний с УЗ-дальномера
int readDistUSR() {
  // Формируем импульс длительностью 10 мкс на пине TRIG
  digitalWrite(PIN_USR_T, LOW);
  delayMicroseconds(5);
  digitalWrite(PIN_USR_T, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_USR_T, LOW);
  // Измеряем длительность импульса на пине ECHO
  int duration = pulseIn(PIN_USR_E, HIGH);
  // Переводим время прохождения сигнала в расстояние в см
  int distance = abs(duration / 58);
  // Возвращаем измеренное расстояние
  return distance;
}

В роботе «Олимпиец» используются два сервопривода, каждый из которых управляет своим механизмом:

• Сервопривод головы — поворачивает голову с ультразвуковым дальномером.
• Сервопривод захвата — поднимает и опускает захват.

Сначала разберёмся с принципом работы сервопривода и способами управления им, а затем применим полученные знания к обоим механизмам робота.

Сервопривод — это электромотор со встроенной системой управления и обратной связью, которая позволяет точно устанавливать и удерживать вал в заданном положении.

В нашем роботе используется аналоговый сервопривод Feetech FS90. Он поворачивает вал на заданный угол в диапазоне от 0 до 180° и обладает крутящим моментом до 1,5 кг·см.

Сервоприводы используются для открывания/закрывания заслонок, поворота различных механизмов на заданный градус и в качестве «суставов» при создании разнообразных механизмов. Для этого в комплекте сервы есть разные насадки, которые надеваются на вал мотора для дальнейшего соединения с механизмами устройств.

Как сервопривод понимает, куда повернуться? На управляющий провод сервопривода нужно периодически подавать короткие импульсы PDM (Pulse Duration Modulation). Импульсы повторяются с одинаковым периодом в 20 мс, но имеют разную длительность — от 544 до 2400 мкс. Эта длительность определяет положение вала сервопривода в диапазоне от 0 до 180°.

Для управления сервоприводом рассмотрим три способа:

• Математическое выражение — преобразуем заданный угол в ширину управляющего импульса по математической формуле.
• Функция map() — преобразуем заданный угол в ширину управляющего импульса с помощью встроенной функции в Arduino.
• Библиотека Servo — преобразуем заданный угол в ширину управляющего импульса с помощью встроенной библиотеки в Arduino.

Проверим все три способа на повороте головы и выберем наиболее удобный для дальнейшей работы.

servo-math-control-example.ino

// Даём понятное имя пину сервопривода головы
#define PIN_SRV_HEAD 8
 
void setup() { }
 
void loop() {
  // Устанавливаем вал сервопривода на 0°
  headMath(0);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 90°
  headMath(90);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 180°
  headMath(180);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 90°
  headMath(90);
  // Ждём 1 секунду
  delay(1000);
}
 
// Управление сервоприводом захвата с помощью формулы
// Угол задаётся в градусах от 0° до 180°
void headMath(int pos) {
  int wait = 10.3 * pos + 544;
  for (int i = 0; i <= 50; i++) {
    digitalWrite(PIN_SRV_HEAD, HIGH);
    delayMicroseconds(wait);
    digitalWrite(PIN_SRV_HEAD, LOW);
    delay(20);
  }
}

servo-map-control-example.ino

// Даём понятное имя пину сервопривода головы
#define PIN_SRV_HEAD 8
 
void setup() {
}
 
void loop() {
  // Устанавливаем вал сервопривода на 0°
  headMap(0);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 90°
  headMap(90);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 180°
  headMap(180);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 90°
  headMap(90);
  // Ждём 1 секунду
  delay(1000);
}
 
// Управление сервоприводом захвата с помощью функции map()
// Угол задаётся в градусах от 0° до 180°
void headMap(int pos) {
  // Преобразуем угол [0…180] в ширину импульса [544…2400] мкс
  int wait = map(pos, 0, 180, 544, 2400);
  // Отправляем серию управляющих импульсов
  for (int i = 0; i <= 50; i++) {
    digitalWrite(PIN_SRV_HEAD, HIGH);
    delayMicroseconds(wait);
    digitalWrite(PIN_SRV_HEAD, LOW);
    delay(20);
  }
}

servo-lib-control-example.ino

// Даём понятное имя пину сервопривода головы
#define PIN_SRV_HEAD 8
 
// Библиотека для работы с сервоприводами
#include <Servo.h>
 
// Создаём объект для работы сервоприводом головы
Servo head;
 
void setup() {
  // Инициализируем сервопривод головы
  head.attach(PIN_SRV_HEAD); 
}
 
void loop() {
  // Устанавливаем вал сервопривода на 0°
  head.write(0);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 90°
  head.write(90);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 180°
  head.write(180);
  // Ждём 1 секунду
  delay(1000);
  // Устанавливаем вал сервопривода на 90°
  head.write(90);
  // Ждём 1 секунду
  delay(1000);
}

Ручной расчёт управляющих импульсов помог разобраться в принципе работы сервопривода. Для дальнейшей работы воспользуемся библиотекой Servo — она возьмёт формирование импульсов на себя и сделает управление сервоприводами значительно удобнее.

Проверим финальную работу сервопривода головы. В примере будем последовательно поворачивать голову робота в несколько заданных положений и наблюдать за движением сервопривода.

servo-head-test.ino

// Даём понятное имя пину сервопривода 
#define PIN_SRV_HEAD 8
 
// Библиотека для работы с сервоприводами
#include <Servo.h>
 
// Создаём объект для работы сервоприводом головы
Servo head;
 
// Задаём крайние углы поворота головы влево и вправо
constexpr int HEAD_MAX_L = 0;
constexpr int HEAD_MAX_R = 180;
// Вычисляем угол для положения головы прямо
constexpr int HEAD_STRAIGHT = (HEAD_MAX_L + HEAD_MAX_R) / 2;
 
void setup() {
  // Инициализируем сервопривода захвата
  head.attach(PIN_SRV_HEAD); 
}
 
void loop() {
  // Поворачиваем голову влево
  head.write(HEAD_MAX_L);
  // Ждём 1 секунду
  delay(1000);
  // Поворачиваем голову прямо
  head.write(HEAD_STRAIGHT);
  // Ждём 1 секунду
  delay(1000);
  // Поворачиваем голову вправо
  head.write(HEAD_MAX_R);
  // Ждём 1 секунду
  delay(1000);
  // Возвращаем голову прямо
  head.write(HEAD_STRAIGHT);
  // Ждём 1 секунду
  delay(1000);
}

Проверим работу сервопривода захвата и подберём рабочий диапазон. Движение захвата ограничено корпусом робота, поэтому нужно определить опытным путём наклон захвата в крайних положениях:

• GRIP_UP — угол в верхнем положении
• GRIP_DOWN — угол в нижнем положении

Изменяй значения, пока не получишь нужный диапазон движения захвата.

servo-gripper-test.ino

// Даём понятное имя пину сервомотора захвата
#define PIN_SRV_GRIP 9
 
// Библиотека для работы с сервоприводами
#include <Servo.h>
 
// Создаём объект для работы сервоприводом захвата
Servo grip;
 
// Задаём углы для верхнего и нижнего положения захвата
// Значения углов подбираются экспериментально в диапазоне от 0 до 180
constexpr int GRIP_UP = 175;
constexpr int GRIP_DOWN = 75;
 
void setup() {
  // Инициализируем сервопривода захвата
  head.attach(PIN_SRV_GRIP); 
}
 
void loop() {
  // Захват поднят
  grip.write(GRIP_UP);
  // Ждём 1 секунду
  delay(1000);
  // Захват опущен
  grip.write(GRIP_DOWN);
  // Ждём 1 секунду
  delay(1000);
}

Колёса «Олимпийца» приводятся в движение коллекторными моторами GA12-N20 с редуктором и энкодером. Редуктор уменьшает скорость вращения двигателя и увеличивает крутящий момент, благодаря чему мотор лучше подходит для привода колёс робота. Независимое управление моторами позволяет роботу двигаться вперёд и назад, а также поворачивать влево и вправо.

Подключать моторы напрямую к Iskra Uno нельзя. Для работы им требуется значительно больший ток, чем может обеспечить контроллер. Поэтому между контроллером и моторами нужен драйвер моторов Motor Shield — он получает команды от Iskra Uno и управляет питанием двигателей.

Для начала разберём базовое управление моторами — научимся задавать направление, скорость вращения, а также останавливать моторы.

motors-basic-control-example.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
 
void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
}
void loop() {
  // Задаём направление движение вперёд
  digitalWrite(PIN_ML_DIR, LOW);
  digitalWrite(PIN_MR_DIR, LOW);
  // Едем вперёд со скоростью 50% в течении трёх секунд
  analogWrite(PIN_ML_SPEED, 126);
  analogWrite(PIN_MR_SPEED, 126);
  delay(3000);
  // Едем вперёд со скоростью 100% в течении трёх секунд
  analogWrite(PIN_ML_SPEED, 255);
  analogWrite(PIN_MR_SPEED, 255);
  delay(3000);
  // Останавливаемся на пять секунд
  analogWrite(PIN_ML_SPEED, 126);
  analogWrite(PIN_MR_SPEED, 126);
  delay(5000);
  // Задаём направление движение назад
  digitalWrite(PIN_ML_DIR, HIGH);
  digitalWrite(PIN_MR_DIR, HIGH);
  // Едем назад со скоростью 50% в течение трёх секунд
  analogWrite(PIN_ML_SPEED, 126);
  analogWrite(PIN_MR_SPEED, 126);
  delay(3000);
  // Едем назад со скоростью 100% в течение трёх секунд
  analogWrite(PIN_ML_SPEED, 255);
  analogWrite(PIN_MR_SPEED, 255);
  delay(3000);
}

Управлять каждым мотором отдельными командами неудобно — особенно когда программа робота станет больше. Поэтому объединим управление обоими моторами в одну функцию drive(). В функцию будем передавать скорость левого и правого мотора, при этом знак «минус» означает вращение в обратном направлении.

motors-function-control-example.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
 
// Настраиваем направление вращения моторов
// Если мотор вращается в обратную сторону, меняем false на true
constexpr bool ML_INVERT = false;
constexpr bool MR_INVERT = false;
 
void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_MR_SPEED, OUTPUT);
}
 
void loop() {
  // Едем вперёд со скоростью 50%
  motorsDrive(126, 126);
  delay(3000);
  // Едем вперёд со скоростью 100%
  motorsDrive(255, 255);
  delay(3000);
  // Останавливаемся
  motorsDrive(0, 0);
  delay(3000);
  // Едем назад со скоростью 50%
  motorsDrive(-126, -126);
  delay(3000);
  // Едем назад со скоростью 100%
  motorsDrive(-255, -255);
  delay(3000);
  // Останавливаемся
  motorsDrive(0, 0);
  delay(3000);
}
 
// Управление движением робота
// Указываем скорость левого и правого мотора от 0 до 255,
// где 0 — остановка, а 255 — максимальная скорость
// Знак задаёт направление вращения: плюс — вперёд, минус — назад
void motorsDrive(int ml, int mr) {
  // Определяем направление вращения левого мотора
  bool mlDir = ml < 0;
  // Определяем направление вращения правого мотора
  bool mrDir = mr < 0;
  // При необходимости инвертируем направление моторов
  if (ML_INVERT) mlDir = !mlDir;
  if (MR_INVERT) mrDir = !mrDir;
  // Задаём направление вращения моторов
  digitalWrite(PIN_ML_DIR, mlDir);
  digitalWrite(PIN_MR_DIR, mrDir);
  // Задаём скорость вращения моторов
  analogWrite(PIN_ML_SPEED, abs(ml));
  analogWrite(PIN_MR_SPEED, abs(mr));
}

Теперь, когда мы научились считывать показания датчиков и управлять моторами, пора переходить к более сложным элементам движения. Один из базовых приёмов — поворот робота на перекрёстке.

Робот может поворачивать тремя способами:

1. Поворот вокруг своей оси. Для такого поворота необходимо, чтобы моторы вращались с одинаковой скоростью, но в разную сторону.
2. Поворот вокруг одного из колёс. Для такого поворота необходимо, чтобы один мотор вращался, а второй стоял на месте.
3. Поворот вокруг внешней точки. Для такого поворота необходимо, чтобы оба мотора вращались в одну сторону, но с разной скоростью.

Для нашего алгоритма рассмотрим поворот вокруг одного из колёс. В этом случае один мотор вращается, а второй остаётся на месте:

• Для поворота налево → вращаем правый мотор вперёд.
• Для поворота направо → вращаем левый мотор вперёд.

Чтобы робот примерно понимал своё положение относительно перекрёстка, будем использовать датчики линии в качестве обратной связи.

Алгоритм поворота робота направо:

1. Включаем левый мотор вперёд.
2. Выжидаем экспериментально время, чтобы левый датчик успел пересечь вертикальную чёрную линию.
3. Ожидаем сигнал с левого датчика о фиксации горизонтальной чёрной линии и выключаем левый мотор.
4. Включаем правый мотор вперёд.
5. Выжидаем экспериментально время, пока робот не выровняется прямо относительно линии и выключаем правый мотор.

</WRAP>

Реализуем алгоритм поворота направо в программе. Напишем функцию turnR() с двумя аргументами:

• speed — скорость вращения колеса.
• timeTurn — время в миллисекундах, необходимое для того, чтобы робот съехал с линии. Это время может отличаться у разных роботов и его нужно подобрать экспериментально.

8-1-function-turn-r.ino

// Функция поворота направо
void turnR(int speed, int timeTurn) {
  // Включаем левый мотор вперёд
  motorsDrive(speed, 0);
  // Выжидаем время, чтобы левый датчик успел сойти с вертикальной чёрной линии
  delay(timeTurn);
  // Ожидаем сигнал с левого датчика о фиксации горизонтальной чёрной линии
  while (readLineL() > LINE_BLACK) {
    delay(10);
  }
  // Выключаем все моторы
  motorsDrive(0, 0);
  delay(500);
  // Включаем правый мотор вперёд
  motorsDrive(0, speed);
  // Выжидаем время, пока робот не выровняется прямо относительно линии
  delay(TIME_TURN_BACK);
  // Выключаем все моторы
  motorsDrive(0, 0);
  delay(250);
}

Поворот налево выполняется аналогичным способом, но зеркально.

1. Включаем правый мотор вперёд.
2. Выжидаем экспериментально время, чтобы правый датчик успел пересечь вертикальную чёрную линию.
3. Ожидаем сигнал с правого датчика о фиксации горизонтальной чёрной линии и выключаем правый мотор.
4. Включаем левый мотор вперёд.
5. Выжидаем экспериментально время, пока робот не выровняется прямо относительно линии и выключаем левый мотор.

8-2-robot-turn-lr.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
 
// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
 
// Настраиваем направление вращения моторов
// Если мотор вращается в обратную сторону, меняем false на true
constexpr bool ML_INVERT = false;
constexpr bool MR_INVERT = false;
 
// Задаем порог, ниже которого считаем, что датчик видит чёрную линию
constexpr int LINE_BLACK = 20;
 
// Задаём скорост вращения мотора при повороте
constexpr int TURN_SPEED = 128;
 
// Задаём время для сьезда с линии при повороте в миллисекундах
constexpr int TURN_WAIT  = 150;
 
// Задаем время поворота робота назад для выравнивания по линии
constexpr int TURN_BACK  = 200;
 
void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_MR_SPEED, OUTPUT);
  // Настраиваем пины датчиков линии в режим входа
  pinMode(PIN_LINE_L, INPUT);
  pinMode(PIN_LINE_R, INPUT);
  // Делаем паузу 10 секунд, чтобы успеть поставить робота на поле
  delay(10000);
}
 
void loop() {
  // Поворачиваем направо
  turnR(TURN_SPEED, TURN_WAIT);
  // Делаем паузу 10 секунд
  delay(10000);
 
  // Поворачиваем налево
  turnL(TURN_SPEED, TURN_WAIT);
  // Делаем паузу 10 секунд
  delay(10000);
}
 
// Функция поворота направо
void turnR(int speed, int waitTime) {
  // Включаем левый мотор
  motorsDrive(speed, 0);
  // Даем роботу время съехать с линии
  delay(waitTime);
  // Ждём, пока левый датчик снова увидит линию
  while (readLineL() > LINE_BLACK) {
    delay(10);
  }
  // Останавливаемся после обнаружения линии
  motorsDrive(0, 0);
  delay(500);
  // Немного доворачиваем назад, чтобы выровнять робота
  motorsDrive(0, speed);
  delay(TURN_BACK);
  // Останавливаем моторы
  motorsDrive(0, 0);
  delay(250);
}
 
// Функция поворота налево
void turnL(int speed, int waitTime) {
  // Включаем правый мотор
  motorsDrive(0, speed);
  // Даем роботу время съехать с линии
  delay(waitTime);
  // Ждём, пока правый датчик снова увидит линию
  while (readLineR() > LINE_BLACK) {
    delay(10);
  }
  // Останавливаемся после обнаружения линии
  motorsDrive(0, 0);
  delay(500);
  // Немного доворачиваем назад, чтобы выровнять робота
  motorsDrive(speed, 0);
  delay(TURN_BACK);
  // Останавливаем моторы
  motorsDrive(0, 0);
  delay(250);
}
 
// Функция управления моторами
void motorsDrive(int ml, int mr) {
  // Определяем направление вращения левого мотора
  bool mlDir = ml < 0;
  // Определяем направление вращения правого мотора
  bool mrDir = mr < 0;
  // При необходимости инвертируем направление моторов
  if (ML_INVERT) mlDir = !mlDir;
  if (MR_INVERT) mrDir = !mrDir;
  // Задаём направление вращения моторов
  digitalWrite(PIN_ML_DIR, mlDir);
  digitalWrite(PIN_MR_DIR, mrDir);
  // Задаём скорость вращения моторов
  analogWrite(PIN_ML_SPEED, abs(ml));
  analogWrite(PIN_MR_SPEED, abs(mr));
}
 
// Считывание левого датчика линии
int readLineL() {
  return map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);
}
 
// Считывание правого датчика линии
int readLineR() {
  return map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);
}

Иногда после поворота роботу нужно просто вернуться обратно в исходную точку. Для возвратного поворота нужно перевернуть последовательность действий обычного поворота. Рассмотрим алгоритм возвращения после поворота направо.

1. Включаем правый мотор в обратную сторону.
2. Продолжаем поворачивать, пока левый датчик линии не увидит чёрную линию.
3. Еще немно доворачиваем правым моторм, чтобы выровнятся по линии.
4. Останавливаем мотор.

Реализуем этот алгоритм в программе. Для обратного поворота напишем функцию turnBackR(). Она принимает два аргумента:

• speed — скорость вращения колеса.
• waitTime — время в миллисекундах, необходимое для того, чтобы робот выровнялся по линии (подбирается экспериментально).

right-turnback-function-example.ino

// Функция возврата после поворота направо
void turnBackR(int speed, int waitTime) {
  // Включаем левый мотор в обратную сторону
  motorsDrive(-speed, 0);
  // Ждём, пока левый датчик снова увидит линию
  while (readLineL() > LINE_BLACK) {
    delay(10);
  }
  // Даем время, чтобы выровнять робота
  delay(waitTime);
  // Останавливаем моторы
  motorsDrive(0, 0);
  delay(250);
}

Возврат после поворота налево выполняется аналогичным способом, но зеркально.

1. Включаем левый мотор в обратную сторону.
2. Продолжаем поворачивать, пока правый датчик линии не увидит чёрную линию.
3. Еще немно доворачиваем правым моторм, чтобы выровнятся по линии.
4. Останавливаем мотор.

Ниже приведён полный программный код для этого раздела. Но мы советуем тебе не заглядывать туда сразу. Сначала попробуй написать функцию возвратного поворота самостоятельно!

bot-turnback-functions-test.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
 
// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
 
// Настраиваем направление вращения моторов
// Если мотор вращается в обратную сторону, меняем false на true
constexpr bool ML_INVERT = false;
constexpr bool MR_INVERT = false;
 
// Задаем порог, ниже которого считаем, что датчик видит чёрную линию
constexpr int LINE_BLACK = 20;
 
// Задаём скорост вращения мотора при повороте
constexpr int TURN_SPEED = 128;
 
// Задаём время для сьезда с линии при повороте в миллисекундах
constexpr int TURN_WAIT  = 150;
 
// Задаем время поворота робота назад для выравнивания по линии
constexpr int TURN_BACK  = 200;
 
void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_MR_SPEED, OUTPUT);
  // Настраиваем пины датчиков линии в режим входа
  pinMode(PIN_LINE_L, INPUT);
  pinMode(PIN_LINE_R, INPUT);
  // Делаем паузу 10 секунд, чтобы успеть поставить робота на поле
  delay(10000);
}
 
void loop() {
  // Поворачиваем направо
  turnBackR(TURN_SPEED, TURN_WAIT);
  // Делаем паузу 10 секунд
  delay(10000);
 
  // Поворачиваем налево
  turnBackL(TURN_SPEED, TURN_WAIT);
  // Делаем паузу 10 секунд
  delay(10000);
}
 
// Функция возврата после поворота направо
void turnBackR(int speed, int waitTime) {
  // Включаем левый мотор в обратную сторону
  motorsDrive(-speed, 0);
  // Ждём, пока левый датчик снова увидит линию
  while (readLineL() > LINE_BLACK) {
    delay(10);
  }
  // Даем время, чтобы выровнять робота
  delay(waitTime);
  // Останавливаем моторы
  motorsDrive(0, 0);
  delay(250);
}
 
// Функция возврата после поворота налево
void turnBackL(int speed, int waitTime) {
  // Включаем левый мотор в обратную сторону
  motorsDrive(0, -speed);
  // Ждём, пока левый датчик снова увидит линию
  while (readLineR() > LINE_BLACK) {
    delay(10);
  }
  // Даем время, чтобы выровнять робота
  delay(waitTime);
  // Останавливаем моторы
  motorsDrive(0, 0);
  delay(250);
}
 
// Функция управления моторами
void motorsDrive(int ml, int mr) {
  // Определяем направление вращения левого мотора
  bool mlDir = ml < 0;
  // Определяем направление вращения правого мотора
  bool mrDir = mr < 0;
  // При необходимости инвертируем направление моторов
  if (ML_INVERT) mlDir = !mlDir;
  if (MR_INVERT) mrDir = !mrDir;
  // Задаём направление вращения моторов
  digitalWrite(PIN_ML_DIR, mlDir);
  digitalWrite(PIN_MR_DIR, mrDir);
  // Задаём скорость вращения моторов
  analogWrite(PIN_ML_SPEED, abs(ml));
  analogWrite(PIN_MR_SPEED, abs(mr));
}
 
// Считывание левого датчика линии
int readLineL() {
  return map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);
}
 
// Считывание правого датчика линии
int readLineR() {
  return map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);
}

Каждому роботу необходимо уметь выполнять разворот на 180°. При этом не имеет значения, в какую сторону будет поворачивать робот — по часовой стрелке или против.

Рассмотрим алгоритм поворота вокруг своей оси на месте:

• Разворот против часовой стрелки — крутим моторы в разные стороны с одинаковой скоростью.
• Разворот по часовой стрелке — то же самое, только крутим моторы в другую сторону.

Как и в прошлом примере, будем использовать датчики линии для получения обратной связи. Алгоритм здесь будет следующим:

1. Крутим моторы в разные стороны какое-то время, чтобы оба датчика оказались над белым полем.
2. После этого доворачиваем робота, пока датчик не увидит черную линию.
3. Так как робот может встать не совсем ровно, выполняем небольшой доворот для выравнивания.
4. Останавливаем моторы.

Реализуем этот алгоритм в программе. Для разворота на 180° по часовой стрелке мы добавили функцию turn180()_R. Как и функция поворота из предыдущего примера, она принимает 2 аргумента:

• speed — скорость вращения колёс.
• waitTime — время в миллисекундах, необходимое для того, чтобы робот съехал с линии (подбирается экспериментально).

right-turnaround-function-example.ino

// Функция разворота на 180° по часовой стрелке (направо)
void turn180_R(int speed, int waitTime) {
  // Включаем моторы в разные стороны
  motorsDrive(speed, -speed);
  // Даем роботу время съехать с линии
  delay(waitTime);
  // Ждём, пока датчик снова увидит линию
   while (readLineL() > LINE_BLACK) {
    delay(10);
  }
  // Останавливаемся после обнаружения линии
  motorsDrive(0, 0);
  delay(200);
  // Немного доворачиваем назад, чтобы выровнять робота
  motorsDrive(-speed, speed);
  delay(TURN_BACK);
  // Останавливаем моторы
  motorsDrive(0, 0);;
  delay(250);
}

Имея функцию разворота по часовой стрелке, довольно легко сделать разворот в обратную сторону. Достаточно лишь заменить все «правосторонние» действия на «левосторонние», и наоборот.

Ниже приведён полный программный код для этого раздела. Но мы советуем тебе не заглядывать туда сразу. Сначала попробуй написать функции разворота робота в разные стороны самостоятельно. На олимпиаде на это не будет времени, а вот на тренировке стоит попробовать все варианты!

bot-turnaround-functions-test.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
 
// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
 
// Настраиваем направление вращения моторов
// Если мотор вращается в обратную сторону, меняем false на true
constexpr bool ML_INVERT = false;
constexpr bool MR_INVERT = false;
 
// Задаем порог, ниже которого считаем, что датчик видит чёрную линию
constexpr int LINE_BLACK = 20;
 
// Задаём скорост вращения мотора при повороте
constexpr int TURN_SPEED = 200;
 
// Задаём время для сьезда с линии при повороте в миллисекундах
constexpr int TURN_WAIT  = 500;
 
// Задаем время поворота робота назад для выравнивания по линии
constexpr int TURN_BACK  = 200;
 
void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_MR_SPEED, OUTPUT);
  // Настраиваем пины датчиков линии в режим входа
  pinMode(PIN_LINE_L, INPUT);
  pinMode(PIN_LINE_R, INPUT);
  // Делаем паузу 10 секунд, чтобы успеть поставить робота на поле
  delay(10000);
}
 
void loop() {
  // Поворачиваем направо
  turn180_R(TURN_SPEED, TURN_WAIT);
  // Делаем паузу 10 секунд
  delay(10000);
 
  // Поворачиваем налево
  turn180_L(TURN_SPEED, TURN_WAIT);
  // Делаем паузу 10 секунд
  delay(10000);
}
 
// Функция разворота на 180° по часовой стрелке (направо)
void turn180_R(int speed, int waitTime) {
  // Включаем моторы в разные стороны
  motorsDrive(speed, -speed);
  // Даем роботу время съехать с линии
  delay(waitTime);
  // Ждём, пока датчик снова увидит линию
   while (readLineL() > LINE_BLACK) {
    delay(10);
  }
  // Останавливаемся после обнаружения линии
  motorsDrive(0, 0);
  delay(200);
  // Немного доворачиваем назад, чтобы выровнять робота
  motorsDrive(-speed, speed);
  delay(TURN_BACK);
  // Останавливаем моторы
  motorsDrive(0, 0);;
  delay(250);
}
 
// Функция разворота на 180° против часовой стрелке (налево)
void turn180_L(int speed, int waitTime) {
  // Включаем моторы в разные стороны
  motorsDrive(-speed, speed);
  // Даем роботу время съехать с линии
  delay(waitTime);
  // Ждём, пока датчик снова увидит линию
   while (readLineR() > LINE_BLACK) {
    delay(10);
  }
  // Останавливаемся после обнаружения линии
  motorsDrive(0, 0);
  delay(200);
  // Немного доворачиваем назад, чтобы выровнять робота
  motorsDrive(speed, -speed);
  delay(TURN_BACK);
  // Останавливаем моторы
  motorsDrive(0, 0);;
  delay(250);
}
 
// Функция управления моторами
void motorsDrive(int ml, int mr) {
  // Определяем направление вращения левого мотора
  bool mlDir = ml < 0;
  // Определяем направление вращения правого мотора
  bool mrDir = mr < 0;
  // При необходимости инвертируем направление моторов
  if (ML_INVERT) mlDir = !mlDir;
  if (MR_INVERT) mrDir = !mrDir;
  // Задаём направление вращения моторов
  digitalWrite(PIN_ML_DIR, mlDir);
  digitalWrite(PIN_MR_DIR, mrDir);
  // Задаём скорость вращения моторов
  analogWrite(PIN_ML_SPEED, abs(ml));
  analogWrite(PIN_MR_SPEED, abs(mr));
}
 
// Считывание левого датчика линии
int readLineL() {
  return map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);
}
 
// Считывание правого датчика линии
int readLineR() {
  return map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);
}

Итак, переходим к движению по линии. Так как времени обычно немного и нет соревнования по скорости роботов, для движения по линии вполне достаточно П-регулятора.

П-регулятор работает просто: чем больше ошибка, тем сильнее корректировка. Именно поэтому робот сам подстраивает своё движение под линию и удерживается на траектории в течение всего времени движения.

Идея здесь простая. Сначала договоримся, что в идеальном случае показания левого и правого датчиков линии одинаковые. Тогда разность между ними равна нулю. Это и есть целевое значение, или уставка.

Если показания датчиков отличаются, значит робот отклонился от линии. Такое отклонение называют ошибкой. В нашем случае ошибкой будет разность между показаниями левого и правого датчика.

• err = leftLine - rightLine

После вычисления ошибки нужно сформировать управляющее воздействие. Оно вычисляется как произведение ошибки на коэффициент Кp. Этот коэффициент показывает, насколько сильно робот будет реагировать на отклонение. Если Кp увеличить, робот начнёт подруливать резче. Если сделать Кp слишком маленьким, робот будет реагировать медленно и может не успевать возвращаться на линию.

• out = Kp * err

После вычисления управляющего воздействия его нужно применить к скорости моторов. В зависимости от того, с какой стороны робот отклонился от линии, скорость одного мотора увеличивается, а другого уменьшается. Благодаря этому робот поворачивает в нужную сторону и возвращается на линию.

• motorsDrive(speed + out, speed - out)

Чтобы лучше понять работу регулятора, разберём несколько терминов.

• Регулятор — это устройство или программа, которая поддерживает объект управления в нужном состоянии. Для этого он получает данные с датчиков и формирует управляющее воздействие, которое помогает устранить отклонение.

• Пропорциональный регулятор — это регулятор, у которого управляющее воздействие зависит от величины отклонения. Проще говоря, чем сильнее робот отклонился от линии, тем сильнее он будет подруливать.

• Пропорциональность — это зависимость, при которой две величины изменяются согласованно. Например, если x = 2 × y, то одна величина в два раза больше другой.

• Отклонение (ошибка) — это величина, показывающая, насколько текущее значение отличается от желаемого.

• Управляющее воздействие — это действие, с помощью которого робот исправляет отклонение.

Напишем функцию followLine() с алгоритмом следования по линии с П-регулятором. На входе функция будет принимать два параметра:

• speed - скорость, с которой должен двигаться робот.
• followTime - время, в течение которого робот должен ехать по линии.

line-follow-function-example.ino

// Функция следования по линии
void followLine(int speed, int followTime) {
  // Задаём пропорционаальный коэффициеент П-регулятора 
  int Kp = 5;
  // Сохраняем время начала движения
  int startTime = millis();
  // Следуем по линии в течение задангого времени waitTime
  while (millis() - startTime < followTime) {
    // Считываем показания датчиков линии
    int leftLine = readLineL();
    int rightLine = readLineR();
    // Расчитываем оибку
    int err = leftLine - rightLine;
    // Формируем управляющий сигнал
    int out = Kp * err ; 
    // Ограничиваем максимальное и минимальное значения управляющего сингала
    out = constrain(out, 0, 200);
    // Ругулируем скорость моторов в соответсвии с управляющим сигналом 
    motorsDrive(speed + out, speed - out);
  }
  // Останавливаем моторы
  motorsDrive(0, 0);
}

Ниже мы привели полный программный код для этого раздела. Поставь робота под углом к линии, чтобы протестировать надёжность стабилизации движения. Попробуй изменять коэффициент Кp в большую или меньшую сторону и посмотри, как это влияет на поведение робота.

bot-line-follow-test.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
 
// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
 
// Настраиваем направление вращения моторов
// Если мотор вращается в обратную сторону, меняем false на true
constexpr bool ML_INVERT = false;
constexpr bool MR_INVERT = false;
 
// Задаём скорост моторов
constexpr int FOLLOW_SPEED = 150;
 
// Задаём время, в течение которого робот делжен ехать
constexpr int FOLLOW_TIME = 10000;
 
void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_MR_SPEED, OUTPUT);
  // Настраиваем пины датчиков линии в режим входа
  pinMode(PIN_LINE_L, INPUT);
  pinMode(PIN_LINE_R, INPUT);
  // Делаем паузу 10 секунд, чтобы успеть поставить робота на поле
  delay(10000);
 
  // Даем команду роботу ехать по линии
   followLine(FOLLOW_SPEED, FOLLOW_TIME);
}
 
void loop() {
  // В этом примере loop() ничего не делает
}
 
// Функция следования по линии
void followLine(int speed, int followTime) {
  // Задаём пропорционаальный коэффициеент П-регулятора 
  int Kp = 5;
  // Сохраняем время начала движения
  int startTime = millis();
  // Следуем по линии в течение задангого времени waitTime
  while (millis() - startTime < followTime) {
    // Считываем показания датчиков линии
    int leftLine = readLineL();
    int rightLine = readLineR();
    // Расчитываем оибку
    int err = leftLine - rightLine;
    // Формируем управляющий сигнал
    int out = Kp * err ; 
    // Ограничиваем максимальное и минимальное значения управляющего сингала
    out = constrain(out, 0, 200);
    // Ругулируем скорость моторов в соответсвии с управляющим сигналом 
    motorsDrive(speed + out, speed - out);
  }
  // Останавливаем моторы
  motorsDrive(0, 0);
}
 
// Функция управления моторами
void motorsDrive(int ml, int mr) {
  // Определяем направление вращения левого мотора
  bool mlDir = ml < 0;
  // Определяем направление вращения правого мотора
  bool mrDir = mr < 0;
  // При необходимости инвертируем направление моторов
  if (ML_INVERT) mlDir = !mlDir;
  if (MR_INVERT) mrDir = !mrDir;
  // Задаём направление вращения моторов
  digitalWrite(PIN_ML_DIR, mlDir);
  digitalWrite(PIN_MR_DIR, mrDir);
  // Задаём скорость вращения моторов
  analogWrite(PIN_ML_SPEED, abs(ml));
  analogWrite(PIN_MR_SPEED, abs(mr));
}
 
// Считывание левого датчика линии
int readLineL() {
  return map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);
}
 
// Считывание правого датчика линии
int readLineR() {
  return map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);
}

Движение по линии до перекрёстка очень похоже на обычное движение по линии из прошлого раздела. Разница лишь в том, что вместо движения в течение заданного времени мы будем ехать до тех пор, пока не встретим перекрёсток.

Как понять, что робот доехал до перекрёстка? Очень просто: если оба датчика линии показывают, что видят чёрную линию, значит робот находится на перекрёстке.

В коде это будет выглядеть так:

crossroads-detection.ino

// Считываем показания датчиков линии
int leftLine = readLineL();
int rightLine = readLineR();
 
// Ожидаем перекрёсток
while (leftLine > LINE_BLACK && rightLine > LINE_BLACK) {
  // Выполняем движение по линии
}

Напишем функцию goToCrossroad() для этого алгоритма. Она будет примимать однин параметр speed — скорость, с которой должен двигаться робот.

crossroads-function-example.ino

// Функция езды до перекрестка
void goToCrossroad(int speed) {
  // Задаём пропорциональный коэффициент П-регулятора
  int Kp = 10;
  // Считываем показания датчиков линии
  int leftLine = readLineL();
  int rightLine = readLineR();
  // Следуем по линии, пока не встретим перекрёсток
  while (leftLine > LINE_BLACK && rightLine > LINE_BLACK) {
    // Считываем показания датчиков линии
    leftLine = readLineL();
    rightLine = readLineR();
    // Рассчитываем ошибку
    int err = leftLine - rightLine;
    // Формируем управляющий сигнал
    int out = Kp * err;
    // Ограничиваем максимальное и минимальное значения управляющего сингала
    out = constrain(out, -100, 100);
    // Регулируем скорость моторов в соответствии с управляющим сигналом
    motorsDrive(speed + out, speed - out);
  }
  // Даем роботу немного времени заехать за линию
  motorsDrive(speed, speed);
  delay(500);
  // Останавливаем моторы
  motorsDrive(0, 0);
}

Поэкспериментируй со значениями коэффициента и скорости робота. Подбери такие параметры, при которых робот будет двигаться по линии максимально быстро и плавно, уверенно проходя все изгибы трассы без сбоев.

Помни: отладка — важнейшая часть работы. Именно на неё уходит большая часть времени при создании эффективных роботов.

Ниже мы привели полный программный код для этого раздела.

bot-line-crossroads-test.ino

// Даём понятное имя пину направления вращения левого мотора
#define PIN_ML_DIR 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define PIN_ML_SPEED 6
// Даём понятное имя пину направления вращения правого мотора
#define PIN_MR_DIR 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define PIN_MR_SPEED 5
 
// Даём понятное имя пину левого датчика линии
#define PIN_LINE_L A0
// Даём понятное имя пину правого датчика линии
#define PIN_LINE_R A1
 
// Настраиваем направление вращения моторов
// Если мотор вращается в обратную сторону, меняем false на true
constexpr bool ML_INVERT = false;
constexpr bool MR_INVERT = false;
 
// Задаем порог, ниже которого считаем, что датчик видит чёрную линию
constexpr int LINE_BLACK = 40;
 
// Задаём скорост моторов
constexpr int M_SPEED = 150;
 
void setup() {
  // Настраиваем пины управления моторами в режим выхода
  pinMode(PIN_ML_DIR, OUTPUT);
  pinMode(PIN_ML_SPEED, OUTPUT);
  pinMode(PIN_MR_DIR, OUTPUT);
  pinMode(PIN_MR_SPEED, OUTPUT);
  // Настраиваем пины управления сервоприводами в режим выхода
  pinMode(PIN_LINE_L, INPUT);
  pinMode(PIN_LINE_R, INPUT);
  // Делаем небольшую задержку, чтобы успеть поставить робота
  delay(10000);
 
  // Запускаем алгоритм езды до перекрестка
  goToCrossroad(M_SPEED);
}
 
void loop() {
  // Функция loop() ничего не делает
}
 
// Функция езды до перекрестка
void goToCrossroad(int speed) {
  // Задаём пропорциональный коэффициент П-регулятора
  int Kp = 10;
  // Считываем показания датчиков линии
  int leftLine = readLineL();
  int rightLine = readLineR();
  // Следуем по линии, пока не встретим перекрёсток
  while (leftLine > LINE_BLACK && rightLine > LINE_BLACK) {
    // Считываем показания датчиков линии
    leftLine = readLineL();
    rightLine = readLineR();
    // Рассчитываем ошибку
    int err = leftLine - rightLine;
    // Формируем управляющий сигнал
    int out = Kp * err;
    // Ограничиваем максимальное и минимальное значения управляющего сингала
    out = constrain(out, -100, 100);
    // Регулируем скорость моторов в соответствии с управляющим сигналом
    motorsDrive(speed + out, speed - out);
  }
  // Даем роботу немного времени заехать за линию
  motorsDrive(speed, speed);
  delay(500);
  // Останавливаем моторы
  motorsDrive(0, 0);
}
 
// Функция управления моторами
void motorsDrive(int ml, int mr) {
  // Определяем направление вращения левого мотора
  bool mlDir = ml < 0;
  // Определяем направление вращения правого мотора
  bool mrDir = mr < 0;
  // При необходимости инвертируем направление моторов
  if (ML_INVERT) mlDir = !mlDir;
  if (MR_INVERT) mrDir = !mrDir;
  // Задаём направление вращения моторов
  digitalWrite(PIN_ML_DIR, mlDir);
  digitalWrite(PIN_MR_DIR, mrDir);
  // Задаём скорость вращения моторов
  analogWrite(PIN_ML_SPEED, abs(ml));
  analogWrite(PIN_MR_SPEED, abs(mr));
}
 
// Считывание левого датчика линии
int readLineL() {
  return map(analogRead(PIN_LINE_L), 0, 1024, 100, 0);
}
 
// Считывание правого датчика линии
int readLineR() {
  return map(analogRead(PIN_LINE_R), 0, 1024, 100, 0);
}

Когда робот подключён к компьютеру по USB-кабелю, для отладки удобно использовать сообщения в последовательный порт. Но во время прохождения трассы такой возможности уже не будет.

Поэтому в боевых условиях для отладки удобно использовать пищалку (англ. buzzer). Она может подавать сигнал при обнаружении какого-либо объекта, а также обозначать начало или завершение отдельной фазы алгоритма.

Напишем функцию beep(), которая позволит тебе подавать звуковой сигнал во время выполнения задания. На вход она будет принимать один параметр n - количество раз, которое нужно пропищать.

buzzer-function-example.ino

// Даём понятное имя пину пищалки
#define PIN_BUZZER 4
 
void setup() {
  // Настраиваем пин управления пищалкой
  pinMode(PIN_BUZZER, OUTPUT);
}
 
void loop() {
  // Пищим 3 раза
  beep(3);
  // Делаем паузу 5 секунд
  delay(5000);
}
 
// Функция для звукового сигнала
void beep(int n) {
  // Включаем и выключам пищалку в цикле n раз
  for (int i = 0; i < n; i++) {
    // Включаем пищалку на 250 миллисекунд
    digitalWrite(PIN_BUZZER, HIGH);
    delay(250);
    // Выключаем пищалку на 250 миллисекунд
    digitalWrite(PIN_BUZZER, LOW);
    delay(250);
  }
}

[Тут нужно вставить схему подключения пищалки на Робота олимпийца]

Мы рассмотрели основные алгоритмы движения робота, которые понадобятся вам на олимпиаде. Теперь перейдём к практическому заданию из реальной олимпиады.

Рассмотрим практическое задание заключительного этапа Всероссийской олимпиады школьников по труду (технологии) по профилю «Робототехника» для 9-х классов в 2022/23 учебном году.

Участникам предлагается такое поле:

Разберёмся с его элементами:

• Жёлтый квадрат — стартовая зона. Робот должен полностью находиться внутри неё и не выходить за границы.
• Синие квадраты — зоны, в которых могут располагаться кубики.
• Коричневая полоса — стена. Роботу запрещено пересекать её. На соревнованиях такую стену обычно изготавливают из фанеры или пластика.

На трассе есть два ряда перекрёстков: верхний и нижний. Назовём их рядами A и B. Столбцы с перекрёстками пронумеруем от 0 до 4.

В дальнейшем мы будем обозначать секции сочетанием буквы и цифры. Например, секция A2 — это третий перекрёсток верхнего ряда, а секция B1 — второй перекрёсток нижнего.

Нумерация столбцов начинается с нуля не случайно: так будет проще сопоставлять секции с кодом, поскольку элементы массивов в программировании обычно нумеруются начиная с нуля.

Перед каждым заездом жюри проводит жеребьёвку, чтобы определить расположение кубиков в ряду A. При этом ряд B всегда полностью заполнен кубиками.

Например, после жеребьёвки трасса может выглядеть так:

Задача участника — разработать алгоритм и запрограммировать робота так, чтобы он переместил кубики из ряда B в соответствующие свободные ячейки ряда A.

После правильного выполнения задания трасса должна выглядеть так:

Алгоритм кажется достаточно сложным. С чего же начать?

Любой сложный алгоритм лучше разбивать на небольшие подзадачи. Их проще решать по отдельности, а затем объединять решения в одну программу. Мы поступим именно так.

Сначала нужно определить, где расположены кубики в ряду A. Для этого робот последовательно проедет через каждый перекрёсток. На каждом перекрёстке он остановится, повернётся к ячейке с кубиком и измерит расстояние с помощью ИК-дальномера.

Размеры трассы заранее известны, поэтому по показанию дальномера можно определить, есть ли кубик в ячейке. Предположим, что расстояние от перекрёстка до стены составляет 50 см, а кубик установлен на расстоянии 30 см от перекрёстка. Тогда показание около 30 см означает, что кубик есть. Если дальномер показывает расстояние, близкое к 50 см, значит, ячейка свободна.

Робот повторит эту процедуру пять раз — по одному разу для каждого перекрёстка. Результаты сканирования мы сохраним в массиве логических значений типа bool.

[Пояснение о том, что такое массив, как это было сделано в «8-битной академии». Пока оставляю эту заглушку.]

Чтобы сделать код короче и понятнее, вместо значений true и false будем использовать числа:

• 1 означает true: кубик есть.
• 0 означает false: ячейка свободна.

Итак, нам нужно выполнить следующие действия:

1. Начать движение из жёлтой стартовой зоны.
2. Проехать через пять перекрёстков ряда A — от 0 до 4.
3. На каждом перекрёстке:
   1. остановиться.
   2. повернуться направо к ячейке.
   3. измерить расстояние с помощью ИК-дальномера.
   4. определить, есть ли в ячейке кубик:
      • если кубик есть, записать в массив 1.
      • если кубика нет, записать в массив 0.
   5. повернуться обратно на трассу.
4. После сканирования всех перекрёстков остановиться.

Приступим к написанию кода. Сначала подготовим его основу, а затем по ходу разбора задания будем постепенно добавлять необходимые функции.

Весь алгоритм поместим в отдельную функцию runRobot(). В конце функции setup() вызовем runRobot() один раз. Это нужно для того, чтобы робот выполнил задание только один раз, а не повторял его снова и снова по кругу.