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

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

Arduino — это платформа, куда входит аппаратная часть и программная часть.

• Аппаратная часть — это семейство контроллеров, например: Uno, Nano, Leonardo, Mega и другие.
• Программная часть — это среда разработки Arduino IDE.

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

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

Большинство платформ имеют 20 контактов ввода-вывода. Режим работы контакта вы задаёте в своей программе. При этом некоторые контакты могут работать в режиме 0 или 1, некоторые поддерживают диапазон значений [0…255], а 6 контактов распознают аж [0…1023] значений при подключении аналоговых датчиков на вход.

A0–A5 — это как раз контакты для подключения датчиков и приёма значений от 0 до 1023. Однако их можно переключить и на выход, например, чтобы управлять сервоприводами.

Если контакта (порт) отмечен символом ~, то он поддерживает режим [0…255] и на вход, и на выход. Для управления скоростью моторов нужны именно такие порты.

Управляющих плат Arduino бесконечно много — их выпускают тысячи производителей, включая Амперку. Конечно, все они более-менее стандартизированы, но на олимпиаде подразумевается, что школьник увидит оборудование первый раз в жизни. Поэтому стоит заранее ознакомиться и поработать с разными версиями контроллеров и плат расширения.

В первой части практикума, помимо платы Iskra Uno, фигурируют две платы расширения: Motor Shield для управления моторами и Troyka Shield для подключения датчиков. Иногда их ещё называют шилдами.

В основе Motor Shield лежит микросхема L298P — драйвер моторов, который позволяет управлять скоростью и направлением вращения двух коллекторных двигателей.

Питать шилд можно от Arduino (5 В), через контакт Vin (6,5–12 В) или от отдельного источника питания через клеммник PWR +/- (4,8–12 В). При установленной перемычке PWR JOIN моторы и Ардуино будут питаться от одного источника. При этом он может быть подключён как к DC-разъёму Ардуино, так и к клемме питания моторов.

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

Раздел в разработке

Старайся мыслить логически при сборке — получишь уважение от учителя и от жюри.

• На крепеже для моторов видно, что туда надо устанавливать именно гайки. Шляпки винтов тут торчать не должны.
• Не вкручивай винты, которые по сути ничего не держат. Это отверстие будет использовано в будущем для крепления аккумуляторного блока.
• Цвета проводов важны!
  • Красный — питание 5 В Vcc.
  • Чёрный / Синий / Коричневый — земля GND.
  • Сигнальные. Для подключения сигналов на одном модуле бери разные по цвету провода. Например на триггера и эхо дальномера нужно брать разные цвета, иначе ведь сам потом запутаешься.

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

Раздел в разработке

2-1.ino

// Даём понятное имя пину направления вращения левого мотора
#define MOTOR_L_DIR_PIN 7
// Даём понятное имя пину управления скоростью вращения левого мотора
#define MOTOR_L_SPEED_PIN 6
// Даём понятное имя пину направления вращения правого мотора
#define MOTOR_R_DIR_PIN 4
// Даём понятное имя пину управления скоростью вращения правого мотора
#define MOTOR_RIGHT_SPEED_PIN 5
// Даём понятное имя пину левого датчика линии
#define SENSOR_LINE_L_PIN A0
// Даём понятное имя пину правого датчика линии
#define SENSOR_LINE_R_PIN A1
// Даём понятные имена пинам левого энкодера A и B
#define ENCODER_L_PIN_A 2
#define ENCODER_L_PIN_B 12
// Даём понятные имена пинам правого энкодера A и B
#define ENCODER_R_PIN_A 3
#define ENCODER_R_PIN_B 13
// Даём понятное имя пину ИК-дальномера
#define SENSOR_DIST_IR_PIN A2
// Даём понятные имена пинам УЗ-дальномера TRIG и ECHO
#define SENSOR_DIST_UZ_TRIG_PIN 11
#define SENSOR_DIST_UZ_ECHO_PIN 10
// Даём понятное имя пину сервомотора дальномера
#define SERVO_DIST_UZ_PIN 8
// Даём понятное имя пину сервомотора захвата
#define SERVO_GRIP_PIN 9

Собирать робота нужно внимательно, не напортачив в мелочах.

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

Не торопись с креплением захватов! Их устанавливают только после того, как протестируют и узнают, где находятся положения 0 и 90°.

После сборки шасси можно устанавливать Arduino. Аккуратно подключай все шлейфы к Motor Shield. Обрезай стяжки, только когда всё проверишь.

Обрати внимание, как подключены моторы. Дальнейший код будет ориентирован именно на такое подключение плюса и минуса.

Могут встретиться подвохи с креплением чего-либо. Например, если модуль с двумя сервомоторами держится на двух винтах, то вкручивать третий не всегда нужно. Конкретно эта модель создана так, что третий винт и вовсе будет лишним.

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

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

Скачай подходящую версию Arduino IDE для операционной системы твоего компьютера и следуй нашим инструкциям по установке и настройке.

• Где скачать Arduino IDE
• Как установить и настроить Arduino IDE
• Как добавить новую плату в Arduino IDE

После всех манипуляций твоя среда Arduino IDE должна увидеть плату, подключённую по USB к компьютеру. Если что-то не получается с первого раза, внимательно сверься с инструкциями ещё раз.

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

Конечно, код нужно писать и оформлять на совесть. Но когда у тебя буквально 2–3 часа на выполнение задачи, нет времени печатать лишнее на клавиатуре. Поэтому используй понятные сокращения для обозначения контактов: L вместо left, M вместо motor и так далее.

Что делает define? Вообще говоря, это не создание переменных. Это функция «Найти и заменить» в тексте первое слово вторым. Код хорошо читаемый, а оперативку у ардуинки при этом не отбираем.

4-1.ino

//найти в программе первое «слово» и заменить вторым (для всех пинов)
#define DL 12    //пин для направления вращения левого мотора
#define SL 10    //пин для управления скоростью вращения левого мотора
#define DR 13    //пин для направления вращения правого мотора
#define SR 11    //пин для управления скоростью вращения правого мотора
#define IR A2    //пин для подключения инфракрасного дальномера
#define UT 7     //пин для подключения ультразвукового дальномера (TRIG в T)
#define UE 8     //пин для подключения ультразвукового дальномера (для эхо)
#define TURN A3  //для подключения сервомотора для поворота "головы"
#define GRIP 9   //пин для подключения сервомотора для захвата
#define LL A4    //пин для левого датчика "цвета"
#define LR A5    //пин для правого датчика "цвета"
// все нужные (и не очень) глобальные переменные
float Kp = 3, Kd = 1.0;         // коэффициенты ПД-регулятора
float er = 0, erO = 0;          //ошибка и прошлая ошибка
int PL, PR;                     //мощности левого и правого моторов
int c1, c2, c3;                 //счётчики каких-нибудь объектов
unsigned long old, t1, t2, t3;  // разные таймеры
int dl, dr;                     //данные с датчиков цвета
int ir, us;                     //данные с дальномеров
int tmp1, tmp2;                 //вспомогательные переменные
bool f1 = false, f2 = false, f3 = false, f4 = false, f5 = false;

Стоит также почитать про типы данных: int, float, bool, unsigned long, а также про локальные и глобальные переменные.

Далее описываем режимы работы (pinMode) всех используемых контактов в процедуре setup. В ней потом будет располагаться основная программа (алгоритм).

5-1.ino

//=====настройка и то, что выполняется 1 раз ======
void setup() {
  //настройка выходов
  pinMode(DL, OUTPUT);
  pinMode(SL, OUTPUT);
  pinMode(DR, OUTPUT);
  pinMode(SR, OUTPUT);
  pinMode(TURN, OUTPUT);
  pinMode(GRIP, OUTPUT);
  pinMode(UT, OUTPUT);
  //настройка входов
  pinMode(UE, INPUT);
  pinMode(IR, INPUT);
  pinMode(LL, INPUT);
  pinMode(LR, INPUT);
  //подключаем монитор последовательного порта
  Serial.begin(9600);
  delay(1000);
  //=================================
  //И вот тут будет основной алгоритм...
  //runForest();
  //=================================
}
//=====бесконечный цикл===========
void loop() {
  // и этот цикл будет пустым...
}

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

Ультразвуковой дальномер HC-SR04 работает так: подаём импульс с продолжительностью 10 мкс на пин Trig, и модуль посылает ультразвуковой импульс, который отражается от препятствия и детектируется. Затем с пина Echo возвращается импульс, продолжительность которого равна времени путешествия звуковой волны. Ардуинка должна измерить этот импульс.

Инфракрасный дальномер Sharp GP2Y0A21 предназначен для измерения расстояния до препятствий от 10 до 80 см.

В датчиках Sharp установлен инфракрасный светодиод (IR LED) с линзой, который излучает узкий световой луч. Отражённый от объекта луч направляется через другую линзу на позиционно-чувствительный фотоэлемент (Position-Sensitive Detector, PSD). От местоположения падающего на PSD луча зависит его проводимость и, следовательно, напряжение. Таким образом можно вычислить расстояние до объекта.

Работать с сенсором Sharp довольно просто — достаточно подключить к нему питание и завести вывод на аналоговый вход Arduino. Значение на входе представляет собой целое число от 0 до 1023. Можно не преобразовывать данные в сантиметры, а просто сравнивать показания.

Итак, для ультразвукового дальномера есть две рекомендации по коду: брать значение по модулю и ограничить расстояние (100 см вполне хватит). Так он будет меньше «глючить» и ошибаться. А вот писать фильтр данных, к сожалению, будет слишком долго.

6-1.ino

//ультразвуковой дальномер (получаем см)
int us_cm() {
  digitalWrite(UT, LOW);
  delayMicroseconds(5);
  digitalWrite(UT, HIGH);
  delayMicroseconds(10);
  digitalWrite(UT, LOW);
  int tmp0 = pulseIn(UE, HIGH);
  int tmp = abs(tmp0 / 58);
  if (tmp > 100) { tmp = 100; }
  return tmp;
}

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

Датчик непрерывно генерирует импульсы в ИК-диапазоне. Если импульс не отражается совсем или отражается так слабо, что уровень детектируемого сигнала не превышает заданное пороговое значение (для этого и регулятор — потенциометр), то цифровой выход модуля находится в состоянии 1 (высокий логический уровень). Как только в области детекции появляется какой-нибудь объект, то будет 0, о чём сигнализирует встроенный светодиод.

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

6-2.ino

// тестирование всех датчиков
void test_sensors(int t) {
  old = millis();
  while (millis() - old < t) {
    dl = (1024 - analogRead(LL)) / 16;
    dr = (1024 - analogRead(LR)) / 16;
    ir = analogRead(IR);
    us = us_cm();
    Serial.print(" l=");
    Serial.print(dl);
    Serial.print(" r=");
    Serial.print(dr);
    Serial.print(" ir= ");
    Serial.print(ir);
    Serial.print(" us=");
    Serial.println(us);
    delay(100);
  }
}

dl = (1024 - analogRead(LL))
dr = (1024 - analogRead(LR))

dl = (1024 - analogRead(LL))/10;
dr = (1024 - analogRead(LR))/10;

dl = (1024 - analogRead(LL))/16;
dr = (1024 - analogRead(LR))/16;

Сервопривод — это электромотор с редуктором и блоком управления в одном корпусе. FS90 — аналоговый сервопривод с удержанием угла, то есть мотор, который преобразует управляющие сигналы в установку и удержание заданного угла. Его диапазон вращения от 0 до 180°.

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

Протестируем две процедуры управления сервомоторами и выберем лучшую. Но знать нужно обе.

6-3.ino

//управление захватом (указывать градусы от 0 до 180)
void grip(int x) {
  int wait = 7 * x + 500;
  for (int i = 0; i <= 50; i++) {
    digitalWrite(GRIP, HIGH);
    delayMicroseconds(wait);
    digitalWrite(GRIP, LOW);
    delay(20);
  }
}
//управление захватом (указывать градусы от 0 до 180)
void gripV2(int a) {
  // Преобразуем угол (0-180) в ширину импульса (500-2500 мкс)
  int pw = map(a, 0, 180, 500, 2500);
  // Отправляем импульс управления сервоприводу
  digitalWrite(GRIP, HIGH);
  delayMicroseconds(pw);
  digitalWrite(GRIP, LOW);
  delay(20);
}

Ответственный момент — всё аккуратно тестируем.

6-4.ino

//пишем основной алгоритм для робота
//всё тестирование тоже можно писать
void runForest() {
  gripV1(0);
  delay(1000);
  gripV1(90);
  delay(1000);
  gripV1(0);
  delay(1000);
  gripV1(90);
  delay(1000);
  gripV1(0);
  delay(1000);
  gripV1(90);
  delay(1000);
  gripV2(0);
  delay(1000);
  gripV2(90);
  delay(1000);
  gripV2(0);
  delay(1000);
  gripV2(90);
  delay(1000);
  gripV2(0);
  delay(1000);
  gripV2(90);
  delay(1000);
  test_sensors(30000);
}

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

6-5.ino

//настраиваем положение захвата и "головы"
void test_servo() {
  turn(0);    //"голова" вперёд
  gripV1(0);  // 0 = захват опущен
  delay(1500);
  gripV1(120);  //90-120 = захват поднят
  turn(90);     //поворот "головы" влево
  gripV1(0);    // 0 = захват опущен
  delay(1500);
  gripV1(120);  //90-120 = захват поднят; ЭТО ПЕРВОНАЧАЛЬНОЕ ПОЛОЖЕНИЕ
  turn(0);      //"голова смотрит вперёд"; ЭТО ПЕРВОНАЧАЛЬНОЕ ПОЛОЖЕНИЕ
}

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

Например, при 10 см до объекта его наличие точно определяется условием: показания больше 300. Если так — объект есть, иначе объекта нет. Запиши полученное значение и запомни: ближе 10 см — показания больше 400.

Если понадобятся несколько позиций объекта с разным расстоянием до него, то придётся протестировать все позиции, где может располагаться объект.

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

6-6.ino

//====спецнастройки датчиков линии
int delL = 15;           // подобрать делитель, чтобы на белом было 55–60
int delR = 12;           // подобрать делитель, чтобы на белом было 55–60
int wl = 59;             // внести из монитора данные на белом (левый)
int bl = 10;             // внести из монитора данные на чёрном (левый)
int wr = 57;             // внести из монитора данные на белом (правый)
int br = 10;             // внести из монитора данные на чёрном (правый)
int Br = (wr + br) / 2;  // это для остановок на линии при движении и поворотах
int Bl = (wl + br) / 2;  // это для остановок на линии при движении и поворотах
//================================
 
void setup() {
 
}
 
void loop() {
  dl = (1024 - analogRead(LL)) / delL;
  dr = (1024 - analogRead(LR)) / delR;
}

Подбираем делители delL и delR так, чтобы получить значения 55–60.

Моторы с редуктором GA12-N20 имеют угловую скорость от 10 до 300 об/мин. Какой именно попадётся тебе — неизвестно… Нужно знать общий принцип, как с ними работать.

Любой мотор постоянного тока требует для работы ток силой 0,2–1 А. Но цифровой выход Arduino может дать нам только 20 мА. Микроконтроллеры электрически слишком слабы, чтобы управлять вращением моторов напрямую. Поэтому контроллеру нужен мощный посредник — драйвер моторов.

Для ВсОШ прописан драйвер L298N. Он может контролировать скорость и направление вращения двух двигателей постоянного тока суммарным током до 4 А.

Для Arduino делаются специальные платы расширения — шилды на драйвере L298N, такие как Motor Shield и многие другие. С ними Ардуинка уже сможет управлять двумя моторами по 2 А.

Алгоритм здесь такой:

1. Включаем мотор.
2. Немного ждём.
3. Ждём, когда датчик «увидит» линию.
4. Останавливаем мотор.
5. Немного вращаем его обратно.

8-1.ino

//поворот НАПРАВО до линии
void turnR(int sl, int t) {
  digitalWrite(DL, LOW);  //указываем направление вращения
  analogWrite(SL, sl);    //включаем мотор и даём съехать с линии
  delay(t);
  //ждём черную линию под датчиком
  dl = (1024 - analogRead(LL)) / delL;
  while (dl > bl) {
    dl = (1024 - analogRead(LL)) / delL;
    delay(10);
  }
  analogWrite(SL, 0);  //останавливаем мотор
  delay(500);
  digitalWrite(DL, HIGH);  //нужно чуть назад покрутить левое колесо
  analogWrite(SL, sl);
  delay(200);
  analogWrite(SL, 0);
  delay(250);
}
//поворот НАЛЕВО до линии
void turnL(int sr, int t) {
  digitalWrite(DR, LOW);  //указываем направление вращения
  analogWrite(SR, sr);    //включаем мотор и даём съехать с линии
  delay(t);
  dr = (1024 - analogRead(LR)) / delR;  // ждём чёрную линию под датчиком
  while (dr > Br) {
    dr = (1024 - analogRead(LR)) / delR;
    delay(10);
  }
  analogWrite(SR, 0);  //останавливаем мотор
  delay(500);
  digitalWrite(DR, HIGH);  //нужно чуть назад покрутить левое колесо
  analogWrite(SR, sr);
  delay(200);
  analogWrite(SR, 0);
  delay(250);
}

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

Этот манёвр выполняется так:

1. Включаем мотор в обратную сторону.
2. Ждём время.
3. Ждём сигнал датчика.
4. Снова выжидаем паузу.

9-1.ino

//возврат после поворота НАПРАВО до линии
//возврат обратно после поворота НАПРАВО до линии
void turnR_back(int sl, int t) {
  digitalWrite(DL, HIGH);  //указываем направление вращения
  analogWrite(SL, sl);     //включаем мотор и даём съехать с линии
  delay(t);
  // ждём черную линию
  dl = (1024 - analogRead(LL)) / delL;
  while (dl > Bl) {
    dl = (1024 - analogRead(LL)) / delL;
    delay(10);
  }
  delay(100);
  analogWrite(SL, 0);
  delay(250);
}

Не располагай датчики слишком широко. Посмотри на фото: расстояние между датчиками примерно соответствует ширине линии, может, на 3–5 мм больше.

Возврат после поворота налево делается аналогично, но что-то всегда может пойти не так. В таком случае смело делай «костыль» — быстро написанное решение, которое хоть как-то решает проблему. Например, добавь роботу ещё небольшое движение вперёд и поворот направо до линии.

9-2.ino

//возврат обратно после поворота НАЛЕВО до линии
void turnL_back(int sr, int t) {
  digitalWrite(DR, HIGH);  //указываем направлние вращения
  analogWrite(SR, sr);     //включаем мотор и даём съехать с линии
  delay(t);
  dl = (1024 - analogRead(LR)) / delR;
  while (dl > Bl) {
    dl = (1024 - analogRead(LR)) / delR;
    delay(10);
  }
  delay(100);
  analogWrite(SR, 0);
  delay(250);
  //может слетать с линии
  //"костыль": чуть вперёд и довернуть до линии
  digitalWrite(DL, LOW);
  digitalWrite(DR, LOW);
  analogWrite(SL, 70);
  analogWrite(SR, 90);
  delay(200);
  analogWrite(SL, 0);
  analogWrite(SR, 0);
  delay(250);
  turnR(70, 50);
}

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

Роботу просто необходимо уметь делать разворот на 180° для большинства задач. В какую сторону поворачивать — не имеет значения.

Идея алгоритма такая:

1. Крутим колёса в разные стороны какое-то время, чтобы оба датчика оказались над белым полем.
2. После этого доворачиваем, пока датчик не «увидит» линию.
3. Так как робот встанет не очень ровно, чуть-чуть поворачиваем обратно (~150 мс).

10-1.ino

//разворот на 180 (крутится влево)
void turn180(int sl, int sr, int t) {
  digitalWrite(DR, LOW);   //указываем направление вращения
  digitalWrite(DL, HIGH);  //указываем направление вращения
  analogWrite(SR, sr);     //включаем мотор и даём съехать с линии
  analogWrite(SL, sl);     //включаем мотор и даём съехать с линии
  delay(t);
  //а вот теперь ждём чёрную линию под датчиком
  dr = (1024 - analogRead(LR)) / delR;
  while (dr > Br) {
    dr = (1024 - analogRead(LR)) / delR;
    delay(10);
  }
  analogWrite(SR, 0);  //останавливаем мотор
  analogWrite(SL, 0);
  delay(200);
  digitalWrite(DR, HIGH);  //покрутимся в обратную сторону
  digitalWrite(DL, LOW);
  analogWrite(SL, sl);
  analogWrite(SR, sr);
  delay(150);
  analogWrite(SR, 0);
  analogWrite(SL, 0);
  delay(250);
}

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

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

Ошибкой будем называть отклонение от уставки, то есть, фактически, разность показаний левого и правого датчика линии.

Мощности моторов тогда будем вычислять по формулам:

PL = sl + Kp × (dl − dr);

PR = sr − Kp × (dl − dr);

• sl — стартовая скорость левого мотора, sr — стартовая скорость правого.
• dl — показания левого датчика линии, dr — показания правого.
• Kp × (dl − dr) — управляющее воздействие на моторы. Как видно из формул, оно пропорционально ошибке.
• dl − dr — это и есть ошибка.
• Kp — усиливающий коэффициент.

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

Пропорциональный регулятор — это регулятор, в котором управляющее воздействие пропорционально отклонению. Говоря проще, чем сильнее робот (наш объект управления) отклонился от желаемого значения — тем сильнее он будет корректировать своё отклонение подруливанием.

Чтобы понять работу данного регулятора, раскроем некоторые термины.

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

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

Управляющее воздействие — сила, с которой объект корректирует отклонение.

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

Пишем процедуру движения робота по линии на заданное время, используя П-регулятор.

11-1.ino

// движение по линии (скорости моторов и миллисекунды)
void goLine_s(int sl, int sr, int t) {
  digitalWrite(DL, LOW);
  digitalWrite(DR, LOW);
  analogWrite(SL, sl);
  analogWrite(SR, sr);
  old = millis();
  while (millis() - old < t) {
    dl = (1024 - analogRead(LL)) / delL;
    dr = (1024 - analogRead(LR)) / delR;
    int PL = sl + Kp * (dl - dr);
    int PR = sr - Kp * (dl - dr);
    if (PL < 0) { PL = 0; }
    if (PR < 0) { PR = 0; }
    if (PL > 200) { PL = 200; }
    if (PR > 200) { PR = 200; }
    analogWrite(SL, PL);
    analogWrite(SR, PR);
    delay(10);
  }
  analogWrite(SL, 0);
  analogWrite(SR, 0);
}
float se = 0;
float Ki = 0.01;
erO = 0;
old = millis();
while (millis() - old < t) {
  dl = (1024 - analogRead(LL)) / delL;
  dr = (1024 - analogRead(LR)) / delR;
  er = dl - dr;
  se = se + er;
  int PL = sl + (Kp * er + Ki * se + Kd * (er - erO));
  int PR = sr - (Kp * er + Ki * se + Kd * (er - erO));
  if (PL < 0) { PL = 0; }
  if (PR < 0) { PR = 0; }
  if (PL > 200) { PL = 200; }
  if (PR > 200) { PR = 200; }
  analogWrite(SL, PL);
  analogWrite(SR, PR);
  delay(10);
  erO = er;
}

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

12-1.ino

// движение до перекрёстка (скорости моторов)
void goLine_c(int sl, int sr) {
  digitalWrite(DL, LOW);
  digitalWrite(DR, LOW);
  analogWrite(SL, sl);
  analogWrite(SR, sr);
  old = millis();
  while (millis() - old < 500) {
    dl = (1024 - analogRead(LL)) / delL;
    dr = (1024 - analogRead(LR)) / delR;
    PL = sl + Kp * (dl - dr);
    PR = sr - Kp * (dl - dr);
    if (PL < 0) { PL = 0; }
    if (PR < 0) { PR = 0; }
    if (PL > 200) { PL = 200; }
    if (PR > 200) { PR = 200; }
    analogWrite(SL, PL);
    analogWrite(SR, PR);
    delay(5);
  }
  while (dl + dr > Bl + Br) {
    dl = (1024 - analogRead(LL)) / delL;
    dr = (1024 - analogRead(LR)) / delR;
    PL = sl + Kp * (dl - dr);
    PR = sr - Kp * (dl - dr);
    if (PL < 0) { PL = 0; }
    if (PR < 0) { PR = 0; }
    if (PL > 200) { PL = 200; }
    if (PR > 200) { PR = 200; }
    analogWrite(SL, PL);
    analogWrite(SR, PR);
    delay(5);
  }
  delay(150);  // чтобы чуть проехал за линию
  analogWrite(SL, 0);
  analogWrite(SR, 0);
  delay(250);
}

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

Помни, что отладка – важнейшая часть работы, и большая часть времени при создании эффективных роботов посвящена именно ей.

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

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

13-1.ino

#define BUZ 4  //пищалка (если есть)
 
pinMode(BUZ, OUTPUT);
 
//три раза пикнуть
void pip() {
  for (int i = 0; i < 3; i++) {
    digitalWrite(BUZ, HIGH);
    delay(200);
    digitalWrite(BUZ, LOW);
    delay(200);
  }
}
 
void setup() {
  // put your setup code here, to run once:
}
 
void loop() {
  // put your main code here, to run repeatedly:
}

Когда робот будет обнаруживать объекты, это нужно как-то контролировать. Например, моргнуть светодиодом или подать звуковой сигнал пищалкой.

Скорее всего, под рукой будет встроенный светодиод контроллера, но его порт может быть занят другой периферией. А вот пищалка весьма кстати — она легко подключается напрямую к контактам Arduino, как показано на схеме.

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

Построить и запрограммировать робота, который:

• Начинает движение в зоне старта (целиком своей вертикальной проекцией находится внутри зоны, ограниченной квадратом жёлтого цвета).
• Движется по линии с перекрёстками и перемещает кубики, расположенные в нижней части полигона, на противолежащие перекрёстки в верхней части полигона, на которых не расположены кубики, за бортик внутрь синего квадрата 100×100 мм.
• Останавливается в зоне финиша (жёлтый квадрат 300×300 мм).

Итак, какой план для робота? Можно поступить так:

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

Пока так. Подробности уточним по мере того, как начнём кодить.

14-1.ino

// пишем основной алгоритм для робота
void runForest() {
  pip();
  // сканим верхний ряд
  bool o[5] = {0, 0, 0, 0, 0}; // массив логических элементов
  int n = 5;                   // количество перекрёстков
  int i = 0;                   // номер текущего перекрёстка
  while (i < n) {
    goLine_c(100, 120); // едем до перекрёстка
    turnR(120, 1000);   // поворачиваем
    delay(500);         // замерли перед замером
    if (analogRead(IR) > 300) {  // проверяем наличие кубика
      pip();    // пикаем
      o[i] = 1; // запоминаем, что на i-м месте есть кубик
    }
    turnR_back(120, 500); // возвращаемся на основную линию
    i++;                  // увеличиваем номер перекрёстка (следующий)
  }
  goLine_c(100, 120); // едем в верхний правый угол
  turnR(120, 1000);   // поворачиваем
  goLine_c(100, 120); // едем в нижний правый угол
  turnR(120, 1000);   // поворачиваем
  // мы в правом нижнем углу, верхний ряд отсканирован
  // для теста вернёмся в зону старта
  i = 0;
  while (i < n) {
    goLine_c(100, 120); // едем до перекрёстка
    i++;                // увеличиваем номер перекрёстка (следующий)
  }
  goLine_c(100, 120); // едем в нижний левый угол
  turnR(120, 1000);   // поворачиваем
  goLine_c(100, 120); // едем в верхний левый угол
}

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

14-2.ino

// пишем основной алгоритм для робота
void runForest()
{
  pip();
  delay(3000); // это чтобы успеть нажать на "монитор порта"
  Serial.println("===============");
  bool o[5] = {1, 1, 0, 0, 1};  // заменяем расположение кубиков двиочным кодом
  bool o2[5] = {0, 0, 0, 0, 0}; // это массив для нижнего ряда, какие брать
  for (int j = 0; j < 5; j++)
  {                      // заполняем массив нижнего ряда
    o2[j] = o[4 - j];    // последний вверху - это первый внизу :)
    Serial.print(o2[j]); // выводим для контроля
  }
}

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

Ну, вперёд! Разбирайся, вникай, тестируй, исследуй.

14-3.ino

// пишем основной алгоритм для робота
void runForest()
{
  // мы в правом нижнем углу, верхний ряд отсканирован
  pip();
  gripV1(100);
  bool o[5] = {1, 1, 0, 0, 0};  // заменяем расположение кубиков кодом
  bool o2[5] = {0, 0, 0, 0, 0}; // это массив для нижнего ряда, какие брать
  for (int j = 0; j < 5; j++)
    o2[j] = o[4 - j]; // заполняем массив нижнего ряда
  // последний вверху - это первый внизу :)
  int n = 5; // количество перекрёстков
  int x = 0; // номер текущего перекрёстка
  while (x < 5)
  {
    goLine_c(100, 120); // едем до перекрёстка
    if (o2[x] == 0)
    {
      turnR(120, 1000);      // поворачиваем
      goLine_c(100, 120);    // подъезжаем к кубику
      gripV1(0);             // захватываем
      turn180(70, 90, 1000); // разворот
      goLine_c(100, 120);    // обратно к перекрёстку
      turnL(120, 1000);      // поворот
      // надо ехать к нижнему правому углу
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      turnL(120, 1000);
      goLine_c(100, 120);
      turnL(120, 1000);
      // теперь робот в верхнем правом углу
      pip(); // для отладки
      // едем к нужной зоне
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      // выгрузка кубика
      turnL(120, 1000);
      goLine_c(100, 120);
      gripV1(100);
      turn180(70, 90, 1000);
      goLine_c(100, 120); // обратно к перекрёстку
      turnR(120, 1000);   // поворот
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      turnR(120, 1000); // поворот
      goLine_c(100, 120);
      turnR(120, 1000);
      // и мы снова в правом нижнем углу
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      // и мы на том перекрёстке, который обработали
      // переходим к следующему шагу
      pip();
      x++; // следующий шаг
    }
    else
      x++;
  }
  goLine_c(100, 120);
  turnR(120, 1000);
  goLine_c(100, 120);
  pip();
}

После всех экспериментов получаем итоговый алгоритм.

14-4.ino

// пишем основной алгоритм для робота
void runForest()
{
  delay(6000);
  pip();
  gripV1(100);
  // сканим верхний ряд
  bool o[5] = {0, 0, 0, 0, 0}; // массив логических элементов
  int n = 5;                   // количество перекрёстков
  int i = 0;                   // номер текущего перекрёстка
  while (i < n)
  {
    goLine_c(100, 120); // едем до перекрёстка
    turnR(120, 1000);   // поворачиваем
    delay(500);         // замерли перед замером
    if (analogRead(IR) > 300)
    {           // проверяем наличие кубика
      pip();    // пикаем
      o[i] = 1; // запоминаем, что на i-м месте есть кубик
    }
    turnR_back(120, 500); // возвращаемся на основную линию
    i++;                  // увеличиваем номер перекрёстка (следующий)
  }
  goLine_c(100, 120); // едем в верхний правый угол
  turnR(120, 1000);   // поворачиваем
  goLine_c(100, 120); // едем в нижний правый угол
  turnR(120, 1000);   // поворачиваем
  //==================================================
  // мы в правом нижнем углу, верхний ряд отсканирован
  pip();
  gripV1(100);
  // bool o[5] = { 1, 1, 0, 0, 0 }; //заменяем расположение кубиков кодом
  bool o2[5] = {0, 0, 0, 0, 0}; // это массив для нижнего ряда, какие брать
  for (int j = 0; j < 5; j++)
  {                   // заполняем массив нижнего ряда
    o2[j] = o[4 - j]; // последний вверху - это первый внизу :)
  }
  // int n = 5; // количество перекрёстков
  int x = 0; // номер текущего перекрёстка
  while (x < 5)
  {
    // for (int z = 0; z < x + 1; z++)
    goLine_c(100, 120); // едем до перекрёстка
    if (o2[x] == 0)
    {
      turnR(120, 1000);         // поворачиваем
      goLine_c(100, 120);       // подъезжаем к кубику
      gripV1(0);                // захватываем
      40 turn180(70, 90, 1000); // разворот
      goLine_c(100, 120);       // обратно к перекрёстку
      turnL(120, 1000);         // поворот
      // надо ехать к нижнему правому углу
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      turnL(120, 1000);
      goLine_c(100, 120);
      turnL(120, 1000);
      // теперь робот в верхнем правом углу
      pip(); // для отладки
      // едем к нужной зоне
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      // выгрузка кубика
      turnL(120, 1000);
      goLine_c(100, 120);
      gripV1(100);
      turn180(70, 90, 1000);
      goLine_c(100, 120); // обратно к перекрёстку
      turnR(120, 1000);   // поворот
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      turnR(120, 1000); // поворот
      goLine_c(100, 120);
      turnR(120, 1000);
      // и мы снова в правом нижнем углу
      for (int z = 0; z < x + 1; z++)
        goLine_c(100, 120);
      // и мы на том перекрёстке, который обработали
      // переходим к следующему шагу
      pip();
      x++; // следующий шаг
    }
    else
    {
      x++;
    }
  }
  goLine_c(100, 120);
  turnR(120, 1000);
  goLine_c(100, 120);
  pip();
}

450 строк кода за 3 часа — это немало, а ведь ещё есть проект и теория! Поэтому тренировать придётся всё: сборку/разборку робота, написание кода и отладку программы на время.

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

Посмотри также несколько репортажей с заключительного этапа ВсОШ по робототехнике.

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

Построить и запрограммировать робота, который:

• Начинает движение в зоне старта (целиком своей вертикальной проекцией находится внутри зоны, ограниченной квадратом жёлтого цвета).
• Движется по линии с перекрёстками и перемещает кубики, расположенные на перекрёстках в верхней и нижней части полигона, на противолежащие перекрёстки внутрь синего квадрата 100×100 мм.
• Останавливается в зоне финиша (жёлтый квадрат 300×300 мм).

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

1. Просканируем и верхний, и нижний ряды с кубиками, составив «карту» (два массива) с ними.
2. После этого будем их сортировать.

16-1.ino

// пишем основной алгоритм для робота
void runForest()
{
  int spdL = 150, spdR = 170; // скорости
  pip();
  gripV1(100);
  // сканим верхний ряд
  bool o[5] = {0, 0, 0, 0, 0}; // массив логических элементов
  int n = 5;                   // количество перекрёстков
  int i = 0;                   // номер текущего перекрёстка
  while (i < n)
  {
    goLine_c(spdL, spdR); // едем до перекрёстка
    turnR(spdL, 1000);    // поворачиваем
    delay(200);           // замерли перед замером
    if (analogRead(IR) > 300)
    {           // проверяем наличие кубика
      pip();    // пикаем
      o[i] = 1; // запоминаем, что на i-м месте есть кубик
    }
    turnR_back(spdL, 500); // возвращаемся на основную линию
    i++;                   // увеличиваем номер перекрёстка (следующий)
  }
  goLine_c(spdL, spdR); // едем в верхний правый угол
  turnR(spdL, 1000);    // поворачиваем
  goLine_c(spdL, spdR); // едем в нижний правый угол
  turnR(120, 1000);     // поворачиваем
  // сканим нижний ряд
  bool o2[5] = {0, 0, 0, 0, 0}; // массив логических элементов
  i = 0;                        // номер текущего перекрёстка
  while (i < n)
  {
    goLine_c(spdL, spdR); // едем до перекрёстка
    turnR(spdL, 1000);    // поворачиваем
    delay(200);           // замерли перед замером
    if (analogRead(IR) > 300)
    {                // проверяем наличие кубика
      pip();         // пикаем
      o2[4 - i] = 1; // запоминаем, что на i-м месте есть кубик
    }
    turnR_back(120, 500); // возвращаемся на основную линию
    i++;                  // увеличиваем номер перекрёстка (следующий)
  }
  goLine_c(spdL, spdR); // едем в верхний правый угол
  turnR(spdL, 1000);    // поворачиваем
  goLine_c(spdL, spdR); // едем в нижний правый угол
  turnR(spdL, 1000);    // поворачиваем
  // мы на старте, знаем где кубики...
}

Целых 80 секунд на сканирование — долго! Но мы можем изменить расположение датчика — поставить его сбоку и сканировать объекты, не поворачивая. Тогда впишемся в 40 с.

16-2.ino

void runForest()
{
  int spdL = 170, spdR = 185;
  pip();
  gripV1(100);
  bool o[5] = {0, 0, 0, 0, 0};  // для верхнего ряда
  bool o2[5] = {0, 0, 0, 0, 0}; // для нижнего ряда
  int n = 5, i;                 // перекрёстки... и текущий номер
  int x = 0;                    // номер ряда
  while (x < 2)
  {
    i = 0; // обнуляем счётчик перекрёстков в ряду
    while (i < n)
    {
      goLine_c(spdL, spdR); // едем до перекрёстка
      delay(200);           // замерли перед замером
      if (analogRead(IR) > 200)
      { // проверяем наличие кубика
        pip();
        if (x == 0)
          o[i] = 1; // если верхний ряд, то...
        if (x == 1)
          o2[4 - i] = 1; // если нижний ряд, то...
      }
      i++; // увеличиваем номер перекрёстка (следующий)
    }
    goLine_c(spdL, spdR);
    turnR(spdL, 600);
    goLine_c(spdL, spdR);
    turnR(spdL, 600);
    x++;
  } // мы на старте и знаем где кубики...
}

Когда проведём сканирование, закомментируем код и принудительно укажем массивы o и о2.

16-3.ino

int spdL = 170, spdR = 185;
pip();
gripV1(100);
// scan_cubes();
bool o[5] = {0, 1, 0, 1, 0};  // для верхнего ряда
bool o2[5] = {1, 0, 1, 0, 1}; // для нижнего ряда
int n = 5, i;                 // перекрёстки... и текущий номер
goLine_c(spdL, spdR);         // к 1-й зоне верхнего ряда
 
if (o[0] == 1 && o2[0] == 0)
{
    pip();
    // отправить кубик в нижний ряд и вернуться на перекрёсток
}
goLine_c(spdL, spdR); // ко 2-й зоне верхнего ряда
if (o[1] == 1 && o2[1] == 0)
{
    pip();
    // отправить кубик в нижний ряд и вернуться на перекрёсток
}
goLine_c(spdL, spdR); // к 3-й зоне верхнего ряда
if (o[2] == 1 && o2[2] == 0)
{
    pip();
    // отправить кубик в нижний ряд и вернуться на перекрёсток
}
goLine_c(spdL, spdR); // к 4-й зоне верхнего ряда
if (o[3] == 1 && o2[3] == 0)
{
    pip();
    // отправить кубик в нижний ряд и вернуться на перекрёсток
}
goLine_c(spdL, spdR); // к 5-й зоне верхнего ряда
if (o[4] == 1 && o2[4] == 0)
{
    pip();
    // отправить кубик в нижний ряд и вернуться на перекрёсток
}

Это не программа, а так — болванка, шаблончик. Видишь закономерность, которую можно заменить циклом? Ещё нужно срочно написать процедуру для движения из любого верхнего перекрёстка в соответствующий нижний.

А ещё у нашего робота теперь сбоку выступает дальномер, и становится особенно важно, в какую сторону делать разворот. Протестируем всё на первых трёх верхних кубиках.

16-4.ino

// разворот на 180 (крутится вправо)
void turn180R(int sl, int sr, int t)
{
  digitalWrite(DR, HIGH); // указываем направление вращения
  digitalWrite(DL, LOW);  // указываем направление вращения
  analogWrite(SR, sr);    // включаем мотор и даём съехать с линии
  analogWrite(SL, sl);    // включаем мотор и даём съехать с линии
  delay(t);
  // а вот теперь ждём чёрную линию под датчиком
  dl = (1024 - analogRead(LL)) / delL;
  while (dl > Bl)
  {
    dl = (1024 - analogRead(LL)) / delL;
    delay(10);
  }
  analogWrite(SR, 0); // останавливаем мотор
  analogWrite(SL, 0);
  delay(200);
  // нужно чуть назад покрутить левое колесо
  digitalWrite(DR, LOW);
  digitalWrite(DL, HIGH); // указываем направление вращения
  analogWrite(SL, sl);
  analogWrite(SR, sr);
  delay(150);
  analogWrite(SR, 0);
  analogWrite(SL, 0);
  delay(250);
}
 
void teleport_012(int spdL, int spdR, int x)
{
  turnR(spdL, 1000);       // поворачиваем
  goLine_c(spdL, spdR);    // подъезжаем к кубику
  gripV1(0);               // захватываем
  turn180(100, 120, 1000); // разворот
  goLine_c(spdL, spdR);    // обратно к перекрёстку
  turnL(spdR, 600);        // поворот
  // надо ехать к углу
  for (int z = 0; z < x + 1; z++)
    goLine_c(spdL, spdR);
  turnL(spdR, 600);
  goLine_c(spdL, spdR);
  turnL(spdR, 600);
  // едем к нужной зоне
  for (int z = 0; z < x + 1; z++)
    goLine_c(spdL, spdR);
  // выгрузка кубика
  turnL(spdR, 600);
  goLine_c(spdL, spdR);
  gripV1(100);
  turn180R(100, 120, 1000);
  goLine_c(spdL, spdR); // обратно к перекрёстку
  turnR(spdL, 600);
  for (int z = 0; z < x + 1; z++)
    goLine_c(spdL, spdR);
  turnR(spdL, 600);
  goLine_c(spdL, spdR);
  turnR(spdL, 600);
  for (int z = 0; z < x + 1; z++)
    goLine_c(spdL, spdR);
  // и мы на том перекрёстке, который обработали
}
 
void runForest()
{
  int spdL = 200, spdR = 220;
  pip();
  gripV1(100);
  bool o[5] = {1, 1, 1, 1, 0};  // для верхнего ряда
  bool o2[5] = {0, 0, 0, 0, 1}; // для нижнего ряда
  int n = 5, i;                 // перекрёстки... и текущий номер
  //=====================================
  goLine_c(spdL, spdR); // к 1-й зоне верхнего ряда
  if (o[0] == 1 && o2[0] == 0)
    teleport_012(spdL, spdR, 0);
  goLine_c(spdL, spdR); // ко 2-й зоне верхнего ряда
  if (o[1] == 1 && o2[1] == 0)
    teleport_012(spdL, spdR, 1);
  goLine_c(spdL, spdR); // к 3-й зоне верхнего ряда
  if (o[2] == 1 && o2[2] == 0)
    teleport_012(spdL, spdR, 2);
}

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

Видишь, что сканировать можно только верхнюю область?

Нижняя будет или инверсной, или в ней будет пара пустых зон (вверху и внизу). А так получаем пары: (В0, Н1) и (В1, Н0). Поэтому можно просканировать только верхний ряд и начинать обработку с зелёной зоны у пятого верхнего кубика.

Что потеряем? Будет лишняя обработка одной пары (В4 и Н4 на рисунке). Условно говоря, это первый подход.

Второй подход: последовательно сканировать и сразу обрабатывать зоны C1–C5. Увидел в В1 кубик — перемести в Н1, не увидел — перемещай из Н1 в В1. Есть только один подвох: 1024 возможные комбинации!

Однако, если задуматься над тем, как должен двигаться робот, то вариантов очень мало.

Ещё можно как бы совместить два подхода: начать сканирование; если найден кубик — переместить его и продолжить сканирование с другой стороны. Чтобы переключить сторону, можно использовать флаг — логическую переменную со значениями (true|false).

Не верится, но весь алгоритм довольно компактный.

17-1.ino

i = 4;
side_up == true;
while (i < 5)
{
  goLine_c(spdL, spdR); // едем до ближайшего перекрёстка
  find = false;         // сбрасываем флаг "Объект обнаружен"
  ir = analogRead(IR);  // измеряем расстояние
  ir2 = analogRead(IR2);
  if (ir > 220 || ir2 > 220)
    find = true;
  if (find)
  { // если объект обнаружен, то...
    pip();
    if (side_up)
    {
      //=========================================
      // объект обнаружен и робот в верхнем ряду
      //=========================================
    }
    else
    {
      //=========================================
      // объект обнаружен и робот в нижнем ряду
      //=========================================
    }
    side_up = !side_up; // инвертируем сторону (на противоположную)
  }
  else
  {
    if (side_up)
    {
      //=========================================
      // объект НЕ обнаружен и робот в верхнем ряду
      //=========================================
    }
    else
    {
      //=========================================
      // объект НЕ обнаружен и робот в нижнем ряду
      //=========================================
    }
  }
  i++; // увеличиваем номер перекрёстка (следующий)
}

Обрати внимание, что в задании для 11 класса были строчки:

• Инфракрасный дальномер (10–80 см) Sharp GP2Y0A21 или аналог, 2 шт.
• Пассивное крепление для дальномера, 2 шт.

Как думаешь, зачем дают два ИК-дальномера? Правильно, чтобы можно было сканировать с двух сторон.

Ещё несколько небольших уточнений:

• Хорошо бы уже дописать ПД- или ПИД-регулятор.
• Все временны́е задержки в коде надо бы сделать через переменные, чтобы было удобнее их массово изменять сразу во всей программе.
• Написать небольшую процедуру, чтобы в самом начале робот ждал, когда окажется на белом поле. Это ускорит процесс тестирования и отладки.

Алгоритм сравнительно простой, но программа постепенно усложняется. Приступаем к написанию.

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

• Мы ввели процедуру ожидания перед тем, как робот начнёт выполнять задание на поле.
• Внимательно изучи процедуру управления захватом. Постарайся понять принцип и запомнить формулу.
• У нас езда по коротким прямым, поэтому в программе применили ПИД-регулятор с нулевым коэффициентом интегральной составляющей. То есть, получился ПД-регулятор. Подробнее читай в брошюре про ПИД-регуляторы.
• Если бы линии были кривые или очень длинные, то стоило бы ввести интегральную составляющую для дополнительной коррекции курса.
• Скорости моторов в программе не оптимизировались, но если время позволяет — это полезно сделать.
• Как видно из объёма кода, необходим план, в какой последовательности его писать. Общая идея — поменьше набирать код текстом, побольше использовать функции «копировать/вставить».

Кубики 4 и 5 робот должен перевозить короткой дорогой. В прошлом алгоритме нужно уменьшить i до 3 и дописать шаблон.

А дописать программу нужно самостоятельно.

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

1. Поле остаётся прежним. Во всех 10 зонах расположены кубики двух цветов: чёрного и белого. Если кубик белый, то его не трогаем, а если чёрный — то везём в красную зону на схеме.

Подсказка: проверь сначала, можно ли отличить чёрный и белый объект с помощью инфракрасного дальномера. Может, он показывает разные значения, и этой разницы достаточно, чтобы различать цвета кубиков?

2. Посмотри на поле и придумай какое-нибудь задание сам. Будешь варьировать алгоритмы — будет больше понимания во всех нюансах происходящего.

Основным видом конструкторских документов в различных областях электротехники, радиоэлектроники, связи и др. являются схемы.

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

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

Правила выполнения и оформления схем регламентируют стандарты седьмой классификационной группы ЕСКД. ГОСТ 2.701-84 устанавливает единую классификацию схем для всех отраслей техники. По этой классификации все схемы (см. таблицу 1) разделены на виды (по характеру отображаемых физических процессов), типы (в зависимости от основного назначения) и имеют наименование и буквенно-цифровое обозначение (шифр, код).

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

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

Схему можно считать выполненной, если соблюдены следующие условия:

• Схема соответствует устройству участника (все линии взаимосвязи указаны верно, очевидны подключения всех компонентов схемы, собранных участником).
• Использованы верные условные графические обозначения (УГО) элементов.
• Линии взаимосвязи и их повороты выполнены горизонтально, вертикально или под углом, кратным 45°. Пересечения линий взаимосвязи строго под углом 90°.
• Узлы, соединяющие более трёх проводников, обозначены точкой.
• Подписаны позиционные обозначения элементов на схеме.
• Указаны контакты разъёмов функциональных блоков (контроллер Arduino, схема управления моторами и т. д.), к которым осуществлено подключение.

Один балл можно снизить, если:

• Допущена одна ошибка в подключении линий взаимосвязи (всё остальное верно).
• Схема нарисована небрежно: не соблюдены углы линий взаимосвязи, элементы не имеют позиционных обозначений, но все подключения верны.
• Большинство использованных УГО не соответствуют ГОСТ, но все подписи верны и схема читаема.

Если нарушений больше, задание оценивается в ноль баллов.

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

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

• Вспомогательные файлы к практикуму № 1

Методические материалы | Часть 2: моторы с энкодерами и ПИД-регулятор →

• Тренировочный робот «Олимпиец» в магазине
• Образовательные решения Амперки