Робот-курьер

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

1. Подключи USB-кабель к Arduino и к компьютеру. Батарейный отсек моторов остаётся отключённым.
2. Открой MyRobotica, курс «Робот-курьер», урок 1.1 и его учебный проект.
3. В правой части кнопки Загрузить на робота выбери своего настоящего робота. Открой Подробнее о связи и проверь плату Arduino Uno. Отключи USB-кабель, посмотри, как изменилось состояние связи, и подключи его снова. Запиши имя порта в журнал.
4. В редакторе оставь пустые функции setup() и loop() и сохрани программу.

1. Подключи USB-кабель к Arduino и к компьютеру. Батарейный отсек моторов остаётся отключённым.
2. В MyRobotica открой курс «Робот-курьер», урок 1.1 и его учебный проект. В правой части кнопки Загрузить на робота выбери своего настоящего робота. Через Подробнее о связи проверь плату Arduino Uno и найди её порт.
3. Сохрани программу с пустыми setup() и loop(), нажми Проверить код, а потом Загрузить на робота.
4. Запиши в журнал: плату, порт, версию MyRobotica и чем Проверить код отличается от Загрузить на робота — что делает каждая кнопка и нужна ли для неё плата.

В программе уже готово всё, кроме двух функций в разделе «Твоя часть». Допиши их:

• reportSensors — печатает числа левого и правого датчика с подписями;
• beginPulse — включает выбранный мотор в нужную сторону со скоростью TEST_PWM. Второй мотор при этом выключен.

Остальную программу не меняй.

// Программа проверки для робота курса (Arduino Uno + шилд L298P).// Робот стоит на подставке: колёса висят в воздухе.// Колесо крутится со скоростью 120 из 255 около 0,3 секунды.const int LEFT_DIR = 7;const int LEFT_PWM = 6;const int RIGHT_DIR = 4;const int RIGHT_PWM = 5;const int LEFT_SENSOR = A4;const int RIGHT_SENSOR = A5;const int FORWARD = HIGH;const int BACKWARD = LOW;const int TEST_PWM = 120;const unsigned long PULSE_MS = 300;bool running = false;unsigned long startedAt = 0; // ===== Твоя часть =====void reportSensors() {  // Цель: показать в мониторе подписанные показания левого и правого датчиков.} void beginPulse(int dirPin, int pwmPin, int direction) {  // Цель: включить только указанный мотор с указанным направлением и TEST_PWM.} // ===== Готовая оболочка — не меняй =====void stopMotors() {  analogWrite(LEFT_PWM, 0);  analogWrite(RIGHT_PWM, 0);  running = false;} void setup() {  pinMode(LEFT_PWM, OUTPUT);  pinMode(RIGHT_PWM, OUTPUT);  stopMotors();  pinMode(LEFT_DIR, OUTPUT);  pinMode(RIGHT_DIR, OUTPUT);  pinMode(LEFT_SENSOR, INPUT);  pinMode(RIGHT_SENSOR, INPUT);  Serial.begin(9600);  Serial.println("READY: 1=L forward, 2=L backward, 3=R forward, 4=R backward, d=sensors, s=stop");} void loop() {  if (running && millis() - startedAt >= PULSE_MS) {    stopMotors();    Serial.println("PWM=0; verify physical stop");  }  if (!Serial.available()) return;  char command = Serial.read();  if (command == 's') {    stopMotors();    Serial.println("PWM=0; verify physical stop");    return;  }  // Пока идёт импульс, новые команды не продлевают и не перезапускают его.  if (running) return;  if (command == 'd') {    reportSensors();    return;  }  if (command < '1' || command > '4') return;  // Удаляем накопленные команды: один ввод не должен запускать очередь движений.  while (Serial.available()) Serial.read();  stopMotors();  startedAt = millis();  running = true;  if (command == '1') beginPulse(LEFT_DIR, LEFT_PWM, FORWARD);  if (command == '2') beginPulse(LEFT_DIR, LEFT_PWM, BACKWARD);  if (command == '3') beginPulse(RIGHT_DIR, RIGHT_PWM, FORWARD);  if (command == '4') beginPulse(RIGHT_DIR, RIGHT_PWM, BACKWARD);  Serial.println("Observe wheel; no automatic hardware PASS");}

Напиши программу сам. В заготовке есть только номера контактов и выключение моторов.

// Программа проверки для робота курса (Arduino Uno + шилд L298P).// Робот стоит на подставке: колёса висят в воздухе.// Колесо крутится со скоростью 120 из 255 около 0,3 секунды.const int LEFT_DIR = 7;const int LEFT_PWM = 6;const int RIGHT_DIR = 4;const int RIGHT_PWM = 5;const int LEFT_SENSOR = A4;const int RIGHT_SENSOR = A5;const int FORWARD = HIGH;const int BACKWARD = LOW;const int TEST_PWM = 120;const unsigned long PULSE_MS = 300;bool running = false;unsigned long startedAt = 0; // Напиши диагностику по требованиям урока. При включении моторы стоят.void setup() {  pinMode(LEFT_PWM, OUTPUT);  pinMode(RIGHT_PWM, OUTPUT);  analogWrite(LEFT_PWM, 0);  analogWrite(RIGHT_PWM, 0);} void loop() {}

Что должна уметь программа:

• работать с монитором порта на скорости 9600;
• по букве d печатать подписанные числа обоих датчиков;
• по 1 и 2 крутить левое колесо вперёд и назад, по 3 и 4 — правое;
• каждый раз крутить со скоростью 120 не дольше 300 мс, потом выключать оба мотора;
• по букве s сразу выключать оба мотора, даже во время вращения;
• после включения и кнопки Reset моторы стоят, пока не придёт новая команда;
• лишние нажатия не копятся в очередь и не продлевают вращение.

Каждым мотором управляют два контакта. Контакт направления решает, куда крутится колесо. Контакт скорости решает, насколько сильно: число от 0 (стоит) до 255 (полная мощность). Левый мотор подключён к контактам 7 (направление) и 6 (скорость).

1. Создай скетч L21_Left_Motor по шаблону и напиши setup() сам: что должно произойти, сказано в комментариях.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_DIR_PIN = 7;const int LEFT_SPEED_PIN = 6;const int FORWARD = HIGH; // ===== Твоя часть: напиши сам ===== void setup() {  // Подготовь оба контакта левого мотора.  // Левое колесо крутится вперёд 2 секунды с силой 100 из 255 и останавливается само.} void loop() {}

2. Загрузи программу при выключенном питании моторов.
3. Включи питание моторов и нажми кнопку Reset на плате: программа начнётся заново.

Левый мотор подключён к контактам 7 (направление) и 6 (скорость). Направление «вперёд» на этом комплекте — уровень HIGH.

Требование 1. Скетч L21_Left_Motor: левое колесо крутится вперёд ровно 2 секунды с силой из именованной переменной и останавливается само. Номера контактов — именованные константы, а не числа в командах.

Приёмка.

1. На подставке напарник засекает по секундомеру, сколько крутится колесо.
2. Замени уровень направления на противоположный. Что сделало колесо? Запиши, какой уровень на твоём роботе — «вперёд».
3. Объясни в журнале, почему колесо остановилось, хотя loop() пустой.

Правый мотор устроен так же, как левый: контакт направления 4 и контакт скорости 5. Имена всех четырёх контактов в шаблоне уже есть.

1. Создай скетч L21_Both_Motors по шаблону и напиши setup() сам. Свою программу левого мотора используй как образец.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_DIR_PIN = 7;const int LEFT_SPEED_PIN = 6;const int RIGHT_DIR_PIN = 4;const int RIGHT_SPEED_PIN = 5;const int FORWARD = HIGH;int speed = 100; // ===== Твоя часть: напиши сам ===== void setup() {  // Подготовь контакты обоих моторов.  // Оба колеса крутятся вперёд со скоростью speed одну секунду и останавливаются.} void loop() {}

2. Загрузи и запусти на подставке.
3. Поменяй speed на 60, потом на 200. Как меняется вращение?

Требование 2. Оба колеса крутятся вперёд ровно одну секунду со скоростью из одной именованной переменной speed и останавливаются. Правый мотор подключён к контактам 4 (направление) и 5 (скорость). Начни со своей программы для левого мотора и сохрани её как L21_Both_Motors.

Исследование: с какого числа колесо трогается. На подставке ставь speed = 20, 40, 60, 80… и запиши для каждого колеса, при каком наименьшем числе оно начинает уверенно крутиться.

void loop() {
  analogWrite(LEFT_SPEED_PIN, speed);
  analogWrite(RIGHT_SPEED_PIN, speed);
  delay(1000);
  analogWrite(LEFT_SPEED_PIN, 0);
  analogWrite(RIGHT_SPEED_PIN, 0);
}

1. Запиши ответ в журнал.
2. Предложи два разных исправления и запиши их кодом: одно — без loop(), второе — оставив движение в loop().

void forward(int ms) {
  drive(FORWARD, speed, FORWARD, speed);
  delay(ms);
}

void setup() {
  // … настройка контактов
  forward(1000);
}

void loop() {
}

Требование. Перепиши программу так, чтобы движение осталось в loop(), но робот проехал ровно одну секунду и больше не трогался. while (true) использовать нельзя.

1. Проверь на подставке: колёса крутятся одну секунду и стоят, пока не нажмёшь Reset.
2. Объясни в журнале, как твоя программа «помнит», что движение уже было.

Писать каждый раз по четыре строки неудобно. Соберём их в функции: forward(), backward(), stopMotors(). Функции drive и forward в шаблоне — образец.

1. Создай скетч L21_Moves по шаблону. Напиши backward, stopMotors и движение в setup() сам.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях.// Функции drive и forward ниже — образец. const int LEFT_DIR_PIN = 7;const int LEFT_SPEED_PIN = 6;const int RIGHT_DIR_PIN = 4;const int RIGHT_SPEED_PIN = 5;const int FORWARD = HIGH;const int BACKWARD = (FORWARD == HIGH) ? LOW : HIGH;int speed = 100; // ===== Твоя часть: напиши сам ===== void backward(int ms) {  // Оба колеса крутятся назад со скоростью speed ms миллисекунд.} void stopMotors() {  // Оба мотора стоят.} void setup() {  pinMode(LEFT_DIR_PIN, OUTPUT);  pinMode(LEFT_SPEED_PIN, OUTPUT);  pinMode(RIGHT_DIR_PIN, OUTPUT);  pinMode(RIGHT_SPEED_PIN, OUTPUT);  stopMotors();  delay(2000); // время убрать руки от робота   // Вперёд 1 секунду, остановка, пауза полсекунды, назад 1 секунду, остановка.} // ===== Образец — не меняй ===== void drive(int leftDir, int leftSpeed, int rightDir, int rightSpeed) {  digitalWrite(LEFT_DIR_PIN, leftDir);  digitalWrite(RIGHT_DIR_PIN, rightDir);  analogWrite(LEFT_SPEED_PIN, leftSpeed);  analogWrite(RIGHT_SPEED_PIN, rightSpeed);} void forward(int ms) {  drive(FORWARD, speed, FORWARD, speed);  delay(ms);} void loop() {}

2. Найди, где функции описаны и где они вызываются. Покажи напарнику.

Требование 3. Программа L21_Moves построена из функций:

• drive(leftDir, leftSpeed, rightDir, rightSpeed) — единственное место, где задаются направление и скорость колёс;
• forward(ms) и backward(ms) — движение на заданное время, stopMotors() — остановка;
• направление «назад» не записано числом, а получено из FORWARD: на другом комплекте FORWARD может быть другим;
• после включения есть 2 секунды, чтобы убрать руки;
• в setup(): вперёд 1 секунду, стоп, пауза полсекунды, назад 1 секунду, стоп.

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

4. Одинаково ли робот ошибается в трёх заездах? Запиши вывод.

Узнай, насколько прямо едет твой робот, и попробуй это исправить одним изменением.

1. Проверь программу на подставке, потом поставь робота на пол у начала метровой полосы скотча. Проедь вперёд 2 секунды. Измерь, на сколько сантиметров нос ушёл вбок от полосы. Повтори три раза.
2. Предложи одно изменение, которое уменьшит увод: например, разные скорости левого и правого колеса. Запиши, почему ты ожидаешь улучшения.
3. Сделай изменение и снова три заезда. Стало лучше? На сколько?

1. Сделай так, чтобы робот проехал вперёд в два раза дальше, а назад — как раньше.
2. Сделай «челнок» — вперёд, стоп, назад, стоп три раза подряд, — написав вызовы forward, stopMotors, backward только один раз. Нужен цикл for из урока 1.1.

Требование 4. Функция shuttle(times, ms) делает «челнок» times раз: вперёд ms миллисекунд, стоп, назад, стоп. Вызовы движений в ней написаны один раз.

Исследование: сколько проезжает робот.

1. Три раза запусти forward(1000) при speed = 100 и измерь путь линейкой в миллиметрах. Повтори при speed = 200.
2. Посчитай, сколько миллиметров в секунду проезжает робот при каждой скорости. Во сколько раз отличаются результаты? Вдвое ли, как отличаются числа speed?
3. Подбери время backward так, чтобы после одного челнока робот вставал не дальше 2 см от старта. Запиши, почему вперёд и назад время получилось разным.

1. Создай скетч L22_Turn_Test по шаблону. Функции drive и stopMotors из урока 2.1 уже есть. Напиши поворот в setup() по своему прогнозу.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_DIR_PIN = 7;const int LEFT_SPEED_PIN = 6;const int RIGHT_DIR_PIN = 4;const int RIGHT_SPEED_PIN = 5;const int FORWARD = HIGH;const int BACKWARD = (FORWARD == HIGH) ? LOW : HIGH;int turnSpeed = 100;int turnMs = 400; // подбираем: время поворота на 90° // ===== Твоя часть: напиши сам ===== void setup() {  setupMotors();  delay(2000);   // Робот крутится на месте налево turnMs миллисекунд и останавливается.} // ===== Готовое из урока 2.1 — не меняй ===== void drive(int leftDir, int leftSpeed, int rightDir, int rightSpeed) {  digitalWrite(LEFT_DIR_PIN, leftDir);  digitalWrite(RIGHT_DIR_PIN, rightDir);  analogWrite(LEFT_SPEED_PIN, leftSpeed);  analogWrite(RIGHT_SPEED_PIN, rightSpeed);} void stopMotors() {  analogWrite(LEFT_SPEED_PIN, 0);  analogWrite(RIGHT_SPEED_PIN, 0);} void setupMotors() {  pinMode(LEFT_DIR_PIN, OUTPUT);  pinMode(LEFT_SPEED_PIN, OUTPUT);  pinMode(RIGHT_DIR_PIN, OUTPUT);  pinMode(RIGHT_SPEED_PIN, OUTPUT);  stopMotors();} void loop() {}

2. Поставь робота на пол, на лист бумаги. Прочерти карандашом линию вдоль его носа. Включи питание моторов и нажми Reset.
3. Измени программу так, чтобы робот повернул направо. Проверь.

Требование. В своей программе L21_Moves из урока 2.1 сделай пробу поворота: колёса крутятся в разные стороны с одной скоростью turnSpeed в течение turnMs, потом робот останавливается. Сохрани как L22_Turn_Test.

Исследование: вокруг чего крутится робот.

1. Положи робота на лист бумаги и обведи карандашом оба колеса.
2. Запусти поворот и обведи колёса снова. Найди точку, вокруг которой повернулся робот.
3. Совпадает ли она с серединой между колёсами? Если нет — насколько сантиметров и почему?

На поворот 90° нужно какое-то время в миллисекундах. Узнать его можно только опытом. Как подбирать — реши сам, но меняй только turnMs и записывай каждую попытку.

1. Начерти на листе две линии под прямым углом. Поставь робота носом вдоль первой.
2. Подбирай turnMs, пока робот не повернёт на 90°. В журнале — не меньше четырёх попыток и объяснение, почему ты выбрал следующее число.
3. Когда поворот получился, повтори его три раза.

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

1. Найди одно время, при котором робот явно не доворачивает, и одно, при котором явно перекручивает. Пробуй середину между ними и сужай промежуток, пока ошибка не станет меньше 5°.
2. С найденным временем сделай пять поворотов подряд. Для каждого отметь на листе, куда смотрит нос, и измерь транспортиром ошибку в градусах.
3. Повтори пункт 2 при другой turnSpeed (например, 160). При какой скорости повороты точнее и одинаковее?
4. Повернёт ли робот направо за то же время? Проверь и запиши.

1. Проверь прогноз на полу и подправь число, если нужно. Запиши время разворота.
2. Ответь в журнале: получилось ровно вдвое больше, чем на 90°? Если нет, как ты это объяснишь?

1. Предскажи время разворота по своему времени на 90° и проверь на полу. Подбери точное время тем же методом, что и для 90°.
2. Сравни: во сколько раз время на 180° больше времени на 90°? Объясни в журнале, откуда берётся разница. Назови две причины.
3. Выведи правило: сколько миллисекунд нужно на один градус при развороте и при повороте на 90°? Какое из чисел точнее подойдёт для поворота на 45°? Проверь.

1. Создай скетч L22_Turns по шаблону. Впиши свои времена из журнала в turn90Ms и turn180Ms.
2. Напиши turnLeft, turnRight, turnAround и квадрат в setup() сам. Функция forward из урока 2.1 уже есть — пользуйся ей как образцом.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_DIR_PIN = 7;const int LEFT_SPEED_PIN = 6;const int RIGHT_DIR_PIN = 4;const int RIGHT_SPEED_PIN = 5;const int FORWARD = HIGH;const int BACKWARD = (FORWARD == HIGH) ? LOW : HIGH;int speed = 100;int turnSpeed = 100;int turn90Ms = 400;  // впиши своё время из журналаint turn180Ms = 800; // впиши своё время из журнала // ===== Твоя часть: напиши сам ===== void turnLeft() {  // Поворот на месте налево на 90° по времени turn90Ms; в конце колёса стоят.} void turnRight() {  // Поворот на месте направо на 90° по времени turn90Ms; в конце колёса стоят.} void turnAround() {  // Разворот на месте на 180° по времени turn180Ms; в конце колёса стоят.} void setup() {  setupMotors();  delay(2000);   // Квадрат: четыре раза — вперёд 1 секунду, пауза, поворот налево, пауза.} // ===== Готовое из урока 2.1 — не меняй ===== void drive(int leftDir, int leftSpeed, int rightDir, int rightSpeed) {  digitalWrite(LEFT_DIR_PIN, leftDir);  digitalWrite(RIGHT_DIR_PIN, rightDir);  analogWrite(LEFT_SPEED_PIN, leftSpeed);  analogWrite(RIGHT_SPEED_PIN, rightSpeed);} void stopMotors() {  analogWrite(LEFT_SPEED_PIN, 0);  analogWrite(RIGHT_SPEED_PIN, 0);} void setupMotors() {  pinMode(LEFT_DIR_PIN, OUTPUT);  pinMode(LEFT_SPEED_PIN, OUTPUT);  pinMode(RIGHT_DIR_PIN, OUTPUT);  pinMode(RIGHT_SPEED_PIN, OUTPUT);  stopMotors();} void forward(int ms) {  drive(FORWARD, speed, FORWARD, speed);  delay(ms);  stopMotors();} void loop() {}

3. Нажми Проверить.

Требование. Продолжи свою программу L21_Moves из урока 2.1 и сохрани как L22_Turns:

• turnLeft(), turnRight(), turnAround() — повороты на 90° и разворот по твоим временам, каждый заканчивается остановкой;
• времена — именованные переменные в начале скетча; если в шаге подбора время налево и направо получилось разным, у каждого поворота своя переменная;
• направление и скорость колёс задаёт только drive;
• в setup() — квадрат для следующего шага: четыре раза «вперёд 1 секунду, налево».

1. Отметь старт скотчем. Запусти программу на полу три раза.
2. Каждый раз измерь, на сколько сантиметров робот не доехал до старта, и на сколько градусов примерно повёрнут его нос.
3. Объясни в журнале, почему ошибка в конце больше, чем ошибка одного поворота.

1. Запусти квадрат три раза. Каждый раз измерь, насколько робот промахнулся мимо старта (в сантиметрах) и насколько повёрнут нос (в градусах).
2. Оцени ошибку одного поворота: раздели ошибку направления в конце на четыре. Совпадает ли она с ошибкой, которую ты мерил при подборе времени?
3. Что сильнее портит квадрат: ошибка поворотов или увод на прямой? Как это проверить отдельным опытом? Проведи его и запиши вывод.

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

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

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

1. Сделай дорожку: прямая, плавный изгиб, крутая дуга и перекрёсток. Подготовь белую и чёрную карточки.
2. Измерь линейкой ширину линии и расстояние между датчиками (между серединами окошек).
3. Поставь робота на линию. Сколько миллиметров остаётся от края линии до каждого датчика? Запиши в журнал: что будет, если линия шире расстояния между датчиками?

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

1. Создай скетч L31_Read_Sensors по шаблону и напиши обе части сам. Левый датчик подключён к A4, правый — к A5.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_SENSOR_PIN = A4;const int RIGHT_SENSOR_PIN = A5; // ===== Твоя часть: напиши сам ===== void setup() {  // Включи связь с компьютером на той же скорости, что в мониторе порта: 9600.} void loop() {  // Пять раз в секунду печатай одну строку: L=число левого датчика  R=число правого.}

2. Загрузи программу и открой монитор порта со скоростью 9600.
3. Поднеси под левый датчик белую карточку, затем чёрную. Держи карточку на той же высоте, на которой датчик стоит над полом.

Датчик светит на пол и меряет, сколько света вернулось. Левый датчик подключён к A4, правый — к A5.

Требование. Скетч L31_Read_Sensors пять раз в секунду печатает строку t=… L=… R=…, где t — время в миллисекундах с включения.

Приёмка.

1. По числам t в мониторе проверь, что строки идут примерно каждые 200 мс. На сколько миллисекунд отличается промежуток от 200 и почему?
2. Поднеси под левый датчик белую, затем чёрную карточку на рабочей высоте. Запиши, на сколько меняется число.

1. Заполни таблицу для четырёх положений робота:

2. Почему в последней строке оба числа «белые», хотя робот стоит на линии? Запиши.

Сними профиль датчиков: как меняются числа, пока линия проходит под роботом поперёк.

1. Положи робота поперёк линии так, чтобы линия была далеко справа от правого датчика.
2. Сдвигай робота влево шагами по 5 мм, пока линия не уйдёт за левый датчик. На каждом шаге записывай L и R.

3. Нарисуй в журнале два графика: L и R от сдвига. Найди по графику, где линия ровно между датчиками и на сколько миллиметров можно уйти в сторону, пока датчик её не заметит.

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

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

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

1. Для каждого датчика запиши по 10 показаний на белом и 10 на чёрном. Найди наименьшее и наибольшее в каждой серии — это разброс.
2. Сравни разброс с разницей белого и чёрного. Во сколько раз разница больше разброса?
3. Повтори белое у окна и в тёмном углу класса. Меняются ли числа сильнее разброса?
4. Запиши вывод: где можно доверять калибровке и когда её нужно повторить.

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

1. Создай скетч L31_Line_Detect по шаблону и впиши свои четыре числа вместо нулей.
2. Напиши loop() сам: решение «линия или нет» для каждого датчика и печать.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_SENSOR_PIN = A4;const int RIGHT_SENSOR_PIN = A5; // Впиши свои измерения из бортового журнала.const int LEFT_WHITE = 0;const int LEFT_BLACK = 0;const int RIGHT_WHITE = 0;const int RIGHT_BLACK = 0; // ===== Твоя часть: напиши сам ===== void loop() {  int leftValue = analogRead(LEFT_SENSOR_PIN);  int rightValue = analogRead(RIGHT_SENSOR_PIN);   // Для каждого датчика реши, линия ли под ним (правило «ближе к чёрному»): leftOnLine и rightOnLine.  // Печатай строку L=… R=…, а если под датчиком линия — допиши «слева линия» или «справа линия».  // Пять строк в секунду.} // ===== Готовое из прошлого шага — не меняй ===== void setup() {  Serial.begin(9600);}

3. Загрузи программу, открой монитор порта и подводи чёрную карточку под датчики по очереди.
4. Ответь в журнале: что начнёт печатать программа, если в ней перепутать белое и чёрное местами? Почему?

bool leftOnLine = abs(leftValue - LEFT_BLACK) < abs(leftValue - RIGHT_WHITE);

Требование 1. Функция onLine(value, white, black) отвечает true, когда под датчиком линия:

• показание ближе к чёрному измерению, чем к белому;
• работает и когда у датчика чёрное — большое число, и когда маленькое;
• внутри нет готовых чисел-порогов: только value, white и black.

Приёмка. Напиши onLine в тестовом скетче, загрузи его и открой монитор порта (9600). Тест проверяет восемь случаев для двух видов датчиков, в том числе показания за пределами твоих измерений.

// Проверка функции onLine. Напиши функцию здесь, загрузи и открой монитор порта.// Когда все строки PASS, перенеси onLine в свою программу. // Требование 1: true, если показание ближе к чёрному, чем к белому.bool onLine(int value, int white, int black) {  return false;} int failed = 0; void expect(int value, int white, int black, bool expected) {  bool actual = onLine(value, white, black);  Serial.print(actual == expected ? "PASS " : "FAIL ");  Serial.print("onLine(");  Serial.print(value);  Serial.print(", ");  Serial.print(white);  Serial.print(", ");  Serial.print(black);  Serial.print(") = ");  Serial.print(actual ? "true" : "false");  Serial.print(", ожидаем ");  Serial.println(expected ? "true" : "false");  if (actual != expected) {    failed++;  }} void setup() {  Serial.begin(9600);   // Датчик, у которого чёрное — большое число, а белое — маленькое.  expect(780, 120, 780, true);  expect(120, 120, 780, false);  expect(600, 120, 780, true);  expect(300, 120, 780, false);  // За пределами измерений.  expect(900, 120, 780, true);  expect(50, 120, 780, false);  // Датчик, у которого наоборот: белое — большое число, чёрное — маленькое.  expect(300, 900, 120, true);  expect(700, 900, 120, false);   if (failed == 0) {    Serial.println("Все проверки пройдены");  } else {    Serial.print("Ошибок: ");    Serial.println(failed);  }} void loop() {}

Когда все строки PASS, добавь onLine в свою программу из шага «Посмотри, что видит датчик» и сохрани её как L31_Line_Detect. Пусть она печатает «слева линия» и «справа линия». Впиши свои измерения и проверь карточкой.

Робот едет вперёд, и линия должна оставаться между датчиками. Если линия оказалась под одним датчиком, робот уехал в сторону. Колесо пока умеет только ехать или стоять. Как вернуть робота к линии?

1. Поставь выключенного робота на линию. Сдвинь его так, чтобы линия оказалась под левым датчиком. Куда робот уехал? Куда ему повернуть? Какое колесо для этого остановить?
2. То же — для правого датчика.
3. Заполни таблицу в журнале:

4. Объясни в журнале одной фразой, почему остановка одного колеса поворачивает робота.

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

1. Проверь каждую строку на выключенном роботе: сдвинь его рукой и покажи, куда он должен поехать.
2. «Оба белое» бывает в двух разных положениях робота. В каких? Может ли программа их различить? Запиши, что тогда случится с роботом.
3. На прямой дорожке «оба — линия» почти не бывает. Где на итоговом поле это встретится и что тогда должен делать робот?

Соберём всё вместе: датчики, правило «ближе к чёрному» и моторы из урока 2.1. Колёса будут слушаться правил из твоей таблицы.

1. Создай скетч L31_First_Line по шаблону. Впиши свои четыре измерения. Настройка моторов и защита уже готовы.
2. Напиши loop() сам: перенеси свои условия из L31_Line_Detect, задай колёсам скорости по своей таблице правил и отправь их на моторы.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_SENSOR_PIN = A4;const int RIGHT_SENSOR_PIN = A5; // Впиши свои измерения из бортового журнала.const int LEFT_WHITE = 0;const int LEFT_BLACK = 0;const int RIGHT_WHITE = 0;const int RIGHT_BLACK = 0;const int LEFT_DIR_PIN = 7;const int LEFT_SPEED_PIN = 6;const int RIGHT_DIR_PIN = 4;const int RIGHT_SPEED_PIN = 5;const int FORWARD = HIGH;int speed = 100; // начальная скорость, подбираем на подставке // ===== Твоя часть: напиши сам ===== void loop() {  int leftValue = analogRead(LEFT_SENSOR_PIN);  int rightValue = analogRead(RIGHT_SENSOR_PIN);   // Реши, линия ли под каждым датчиком, — перенеси свои условия из L31_Line_Detect.  // Колёса выполняют твою таблицу правил: линия под датчиком — его колесо стоит.  // Колесо, которое правило остановило, снова едет, когда его датчик видит белое.} // ===== Готовое: настройка и защита — не меняй ===== void setup() {  pinMode(LEFT_DIR_PIN, OUTPUT);  pinMode(LEFT_SPEED_PIN, OUTPUT);  pinMode(RIGHT_DIR_PIN, OUTPUT);  pinMode(RIGHT_SPEED_PIN, OUTPUT);   analogWrite(LEFT_SPEED_PIN, 0);  analogWrite(RIGHT_SPEED_PIN, 0);  digitalWrite(LEFT_DIR_PIN, FORWARD);  digitalWrite(RIGHT_DIR_PIN, FORWARD);   // Без измерений робот не поедет: программа остановится здесь.  if (LEFT_WHITE == LEFT_BLACK || RIGHT_WHITE == RIGHT_BLACK) {    while (true) {    }  }   delay(2000); // время убрать руки от робота}

3. Нажми Проверить.

Возьми каркас: в нём контакты, моторы и функция drive из урока 2.1. Перенеси в него свои измерения и функцию onLine и сохрани как L31_First_Line. Эта программа понадобится тебе в уроке 3.2.

// Каркас движения по линии. Требования к программе — в тексте урока.const int LEFT_SENSOR_PIN = A4;const int RIGHT_SENSOR_PIN = A5; // Впиши свои измерения из бортового журнала.const int LEFT_WHITE = 0;const int LEFT_BLACK = 0;const int RIGHT_WHITE = 0;const int RIGHT_BLACK = 0; const int LEFT_DIR_PIN = 7;const int LEFT_SPEED_PIN = 6;const int RIGHT_DIR_PIN = 4;const int RIGHT_SPEED_PIN = 5;const int FORWARD = HIGH; void drive(int leftDir, int leftSpeed, int rightDir, int rightSpeed) {  digitalWrite(LEFT_DIR_PIN, leftDir);  digitalWrite(RIGHT_DIR_PIN, rightDir);  analogWrite(LEFT_SPEED_PIN, leftSpeed);  analogWrite(RIGHT_SPEED_PIN, rightSpeed);} // Требование 1: перенеси функцию onLine из тестового скетча.bool onLine(int value, int white, int black) {  return false;} void setup() {  pinMode(LEFT_DIR_PIN, OUTPUT);  pinMode(LEFT_SPEED_PIN, OUTPUT);  pinMode(RIGHT_DIR_PIN, OUTPUT);  pinMode(RIGHT_SPEED_PIN, OUTPUT);  drive(FORWARD, 0, FORWARD, 0);   // Требование 3: защита от запуска без измерений и время убрать руки.} void loop() {  // Требование 2: прочитать датчики, решить по своей таблице правил, задать скорости.  drive(FORWARD, 0, FORWARD, 0);}

Требование 2. Колёса выполняют твою таблицу правил:

• в каждом повторе программа заново читает оба датчика и решает заново: колесо, остановленное один раз, снова едет, когда его датчик видит белое;
• решение принимает твоя функция onLine;
• скорость — одна именованная переменная speed в начале скетча.

Требование 3. Робот безопасен:

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

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

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

3. Проверь свой прогноз про скорость, заданную в setup(). Выключи питание моторов.

Приёмка требований 2–3 на подставке.

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

1. Выключи питание моторов, отключи USB-кабель.
2. Поставь робота на прямой участок: линия между датчиками. Включи питание. Будь готов выключить его, если робот уходит с дорожки.
3. Пройди дорожку три раза при speed = 100, потом три раза при 80 и при 130. Записывай, сколько раз робот прошёл изгиб.

4. Почему робот едет рывками? Запиши одной фразой.

1. Выключи питание моторов, отключи USB-кабель. Будь готов выключить питание, если робот уходит с дорожки.
2. Найди наибольшую speed, при которой робот проходит плавный изгиб три раза из трёх. Начни с 80 и поднимай шагами по 20.
3. На наибольшей скорости, которую робот не выдержал, посмотри, где он теряет линию. Объясни в журнале причину через твою таблицу правил.
4. Запиши, что нужно изменить в правилах, чтобы робот держал линию быстрее. Проверишь это в уроке 3.2.

Представь, что ты ведёшь велосипед по линии: чуть ушла — чуть поворачиваешь руль, сильно ушла — сильнее. Программа из урока 3.1 так не умеет: она знает только «линия есть» или «нет».

1. Запусти программу из урока 3.1 на дуге 350 мм и посмотри, как едет робот.
2. Запиши в журнал одной фразой: чего не хватает программе, чтобы поворачивать плавно?

Исследуй проблему, прежде чем решать.

1. Запусти свою программу из урока 3.1 на дуге 350 мм, потом на дуге 125 мм. Запиши, как едет робот: рывки, виляние, сход с линии.
2. Объясни в журнале, какую информацию с датчиков программа 3.1 выбрасывает и почему из-за этого робот едет рывками.
3. До того как читать дальше, придумай своё правило: как скорости колёс должны зависеть от показаний датчиков. Запиши словами или формулой. В конце урока сравни его с П-регулятором.

У датчиков разные числа белого и чёрного, поэтому сравнивать их напрямую нельзя. Нужна общая шкала: чёрное — 0, белое — 100. Показание на шкале — это «сколько процентов пути от чёрного до белого» оно прошло.

1. Создай скетч L32_Error по шаблону, перенеси измерения из журнала.
2. Напиши функцию level сам. Ошибку в loop() пока не трогай.

// Наблюдение в MyRobotica включается сборщиком; обычный Arduino работает без библиотеки.#include <math.h>#if defined(ROBOT_TELEMETRY_BUILD_ID)#include <RobotTelemetry.h>robot_telemetry::TelemetryStream courseTelemetry;#endif // Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. const int LEFT_SENSOR_PIN = A4;const int RIGHT_SENSOR_PIN = A5; // Измерения белого и чёрного из журнала (урок 3.1).const int LEFT_WHITE = 0;const int LEFT_BLACK = 0;const int RIGHT_WHITE = 0;const int RIGHT_BLACK = 0; // ===== Твоя часть: напиши сам ===== int level(int value, int white, int black) {  // Шкала: чёрное — 0, белое — 100, между ними — по прямой.  // Работает и когда у датчика чёрное — большое число, и когда маленькое; не выходит за 0…100.  return 0;} void loop() {  int leftRaw = analogRead(LEFT_SENSOR_PIN);  int rightRaw = analogRead(RIGHT_SENSOR_PIN);  int leftLevel = level(leftRaw, LEFT_WHITE, LEFT_BLACK);  int rightLevel = level(rightRaw, RIGHT_WHITE, RIGHT_BLACK);   // Ошибка: насколько и в какую сторону линия ушла от середины; линия посередине — 0.  float error = NAN; // Пока ошибка не вычислена, график показывает «нет данных».   courseTelemetryReport(leftRaw, rightRaw, error, NAN);  Serial.print("L=");  Serial.print(leftLevel);  Serial.print("  R=");  Serial.print(rightLevel);  Serial.print("  ошибка=");  Serial.println(error);  courseWait(200);} // ===== Готовое: настройка и защита — не меняй ===== void setup() {  courseTelemetryBegin();  if (LEFT_WHITE == LEFT_BLACK || RIGHT_WHITE == RIGHT_BLACK) {    Serial.println("Впиши измерения белого и чёрного");    while (true) {      courseTelemetryPoll();    }  }} // ===== Готовое: передача наблюдений — не меняй =====void courseTelemetryBegin() {#if defined(ROBOT_TELEMETRY_BUILD_ID)  using namespace robot_telemetry::wire;  courseTelemetry.begin((1UL << Line0) | (1UL << Line1) |                        (1UL << LineError) | (1UL << ControlOutput));#else  Serial.begin(9600);#endif} void courseTelemetryPoll() {#if defined(ROBOT_TELEMETRY_BUILD_ID)  courseTelemetry.update();#endif} // NAN означает «ещё не вычислено», а не нулевую ошибку или поправку.void courseTelemetryReport(int leftRaw, int rightRaw, float error, float output) {#if defined(ROBOT_TELEMETRY_BUILD_ID)  using namespace robot_telemetry::wire;  courseTelemetry.setUnsigned(Line0, leftRaw);  courseTelemetry.setUnsigned(Line1, rightRaw);  if (isnan(error)) courseTelemetry.setMissing(LineError);  else courseTelemetry.setFloat(LineError, error);  if (isnan(output)) courseTelemetry.setMissing(ControlOutput);  else courseTelemetry.setFloat(ControlOutput, output);  courseTelemetry.update();#endif} void courseWait(unsigned long durationMs) {  unsigned long started = millis();  while (millis() - started < durationMs) {    courseTelemetryPoll();    delay(1);  }}