Robot courier

Programs for the robot are written in MyRobotica. It has lessons and a code editor.

1. Connect the USB cable to the Arduino and to the computer. The battery compartment of the motors remains disconnected.
2. Open MyRobotica course "Robot Courier", lesson 1.1 and his study project.
3. On the right side of the button Upload to robot choose your real robot. Open up More about communication and check the board Arduino Uno. Unplug the USB cable, see how the connection status changes, and plug it in again. Log the port name.
4. Leave empty functions in the editor setup() and loop() and save the program.

1. Connect the USB cable to the Arduino and to the computer. The battery compartment of the motors remains disconnected.
2. Open a course in MyRobotica "Robot Courier", lesson 1.1 and his educational project. On the right side of the button Upload to robot choose your real robot. Via More about communication check the board Arduino Uno and find its port.
3. Save the program with empty setup() and loop(), click Check code, and then Upload to robot.
4. Write down in the log: board, port, MyRobotica version and what Check code is different from Upload to robot - what each button does and whether a board is needed for it.

Everything in the program is already ready, except for two functions in the “Your part” section. Add them:

• reportSensors — prints the numbers of the left and right sensor with captions;
• beginPulse - turns the selected motor in the desired direction at speed TEST_PWM. The second motor is turned off.

Don't change the rest of the program.

// Программа проверки для робота курса (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");}

Write the program yourself. The blank contains only contact numbers and turning off the motors.

// Программа проверки для робота курса (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() {}

What the program should be able to do:

• work with Serial Monitor at speed 9600;
• by letter d print signed numbers of both sensors;
• by 1 and 2 turn the left wheel forward and backward, 3 and 4 - right;
• spin each time at speed 120 for no longer than 300 ms, then turn off both motors;
• by letter s turn off both motors at once, even during rotation;
• after turning on and the Reset button, the motors stand until a new command arrives;
• extra clicks do not accumulate in the queue and do not prolong the rotation.

Each motor is controlled by two contacts. Contact directions decides which way the wheel turns. Contact speed decides how strong: a number from 0 (worth it) to 255 (full power). The left motor is connected to the contacts 7 (direction) and 6 (speed).

1. Create a sketch L21_Left_Motor according to the template and write setup() himself: what should happen is said in the comments.

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

2. Load the program with the motors power off.
3. Turn on the power to the motors and press the Reset button on the board: the program will start again.

The left motor is connected to the contacts 7 (direction) and 6 (speed). The forward direction on this set is level HIGH.

Requirement 1. Sketch L21_Left_Motor: the left wheel spins forward for exactly 2 seconds with the force from the named variable and stops itself. Pin numbers are named constants, not numbers in commands.

Acceptance.

1. On the stand, the partner uses a stopwatch to time how long the wheel spins.
2. Replace the direction level with the opposite one. What did the wheel do? Write down what level is on your robot - “forward”.
3. Explain in the journal why the wheel stopped, although loop() empty.

The right motor is designed in the same way as the left one: direction contact 4 and speed contact 5. The names of all four contacts are already in the template.

1. Create a sketch L21_Both_Motors according to the template and write setup() himself. Use your left motor program as a model.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. 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. Upload and test with the robot on a stand.
3. Change speed by 60, then by 200. How does the rotation change?

Requirement 2. Both wheels spin forward for exactly one second at a speed from one named variable speed and stop. The right motor is connected to the contacts 4 (direction) and 5 (speed). Start with your program for the left motor and save it as L21_Both_Motors.

Research: at what date does the wheel start moving. Place on the stand speed = 20, 40, 60, 80... and write down for each wheel at what smallest number it begins to spin confidently.

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. Write your answer in your journal.
2. Suggest two different corrections and write them down with code: one - without loop(), the second - leaving the movement in loop().

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

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

void loop() {
}

Requirement. Rewrite the program so that the movement remains in loop(), but the robot drove for exactly one second and did not move again. while (true) cannot be used.

1. Check it on the stand: the wheels spin for one second and stay there until you press Reset.
2. Explain in the log how your program “remembers” that the movement has already happened.

Writing four lines each time is inconvenient. Let's collect them in functions: forward(), backward(), stopMotors(). Functions drive and forward in the template is a sample.

1. Create a sketch L21_Moves according to the template. Write backward, stopMotors and movement in setup() himself.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях.// Функции 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. Find where the functions described and where are they are called. Show it to your partner.

Requirement 3. Software L21_Moves is built from the functions:

• drive(leftDir, leftSpeed, rightDir, rightSpeed) is the only place where the direction and speed of the wheels are set;
• forward(ms) and backward(ms) - movement for a specified time, stopMotors() - stop;
• the direction "backward" is not written as a number, but is obtained from FORWARD: on another set FORWARD may be different;
• after turning on there are 2 seconds to remove your hands;
• in setup(): forward 1 second, stop, pause half a second, backward 1 second, stop.

1. Load the program on the stand and check: forward, pause, backward, stop.
2. Place the robot on the floor, mark the start with tape, turn on the power to the motors and press Reset.
3. Repeat three times. Each time, mark where the robot stopped, and measure with a ruler how many centimeters it moved forward, backward and sideways from the start.

4. Does the robot make the same mistakes in three runs? Write down the conclusion.

Find out how straight your robot is going and try to fix it with one change.

1. Test the program on the stand, then place the robot on the floor at the beginning of a meter strip of tape. Drive forward for 2 seconds. Measure how many centimeters the nose moves sideways from the stripe. Repeat three times.
2. Suggest one change that will reduce slip: for example, different speeds for the left and right wheels. Write down why you expect improvement.
3. Make the change and do three runs again. Has it gotten better? How long?

1. Make the robot travel forward twice as far and backward as before.
2. Make the robot shuttle three times in a row: forward, stop, backward, stop. Write calls to forward, stopMotors, backward only once. Need a cycle for from lesson 1.1.

Requirement 4. Function shuttle(times, ms) does "shuttle" times times: forward ms milliseconds, stop, back, stop. The movement calls are written only once.

Research: how far does a robot travel?

1. Run three times forward(1000) at speed = 100 and measure the path with a ruler in millimeters. Repeat when speed = 200.
2. Calculate how many millimeters per second the robot travels at each speed. How many times do the results differ? How do the numbers differ? speed?
3. Find the time backward so that after one shuttle the robot stands no further than 2 cm from the start. Write down why forward and backward times turned out different.

1. Create a sketch L22_Turn_Test according to the template. Functions drive and stopMotors from lesson 2.1 is already there. Write the turn in setup() according to his forecast.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. 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. Place the robot on the floor, on a piece of paper. Draw a line along his nose with a pencil. Turn on the power to the motors and press Reset.
3. Change the program so that the robot turns to the right. Check it out.

Requirement. In my program L21_Moves from lesson 2.1 do a turning test: the wheels spin in different directions at the same speed turnSpeed for turnMs, then the robot stops. Save as L22_Turn_Test.

Research: what the robot revolves around.

1. Place the robot on a piece of paper and trace both wheels with a pencil.
2. Start the turn and circle the wheels again. Find the point around which the robot turned.
3. Does it line up with the center between the wheels? If not, how many centimeters and why?

A 90° turn takes some time in milliseconds. You can only know it through experience. How to choose - decide for yourself, but change only turnMs and write down each attempt.

1. Draw two lines at right angles on the sheet. Place the robot with its nose along the first one.
2. Pick up turnMs, until the robot turns 90°. The log contains at least four attempts and an explanation of why you chose the next number.
3. When the turn is successful, repeat it three times.

Select the turning time method and find out how much you can trust him.

1. Find one time at which the robot clearly does not turn enough, and one at which it clearly turns over. Try the middle between them and narrow the gap until the error is less than 5°.
2. With the time you find, make five turns in a row. For each, mark on a piece of paper where the nose is pointing and use a protractor to measure the error in degrees.
3. Repeat step 2 for another turnSpeed (for example, 160). At what speed are turns more accurate and consistent?
4. Will the robot turn right in the same time? Check and write down.

1. Check the forecast on the floor and adjust the number if necessary. Record the turnaround time.
2. Answer in the journal: did it turn out to be exactly twice as much as 90°? If not, how do you explain it?

1. Predict the time of the 90° turn using your time and check on the floor. Find the exact time using the same method as for 90°.
2. Compare: how many times is the time of 180° longer than the time of 90°? Explain in the journal where the difference comes from. Give two reasons.
3. Derive a rule: how many milliseconds does it take per degree for a turn and for a 90° turn? Which number is more accurate for a 45° rotation? Check it out.

1. Create a sketch L22_Turns according to the template. Write your times from the journal into turn90Ms and turn180Ms.
2. Write turnLeft, turnRight, turnAround and square in setup() himself. Function forward from lesson 2.1 is already there - use it as a sample.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. 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. Click Check.

Requirement. Continue with your program L21_Moves from lesson 2.1 and save as L22_Turns:

• turnLeft(), turnRight(), turnAround() - 90° turns and a turn according to your times, each ending with a stop;
• times are named variables at the beginning of the sketch; if in the selection step the time to the left and to the right turns out to be different, each turn has its own variable;
• sets the direction and speed of the wheels only drive;
• in setup() - square for the next step: four times “forward 1 second, left.”

1. Mark the start with tape. Run the program on the floor three times.
2. Each time, measure how many centimeters the robot missed the start, and approximately how many degrees its nose is turned.
3. Explain in the journal why the error at the end is greater than the error of one turn.

1. Run the square three times. Each time, measure how far the robot missed the start (in centimeters) and how much the nose is turned (in degrees).
2. Estimate the error of one turn: divide the error of direction at the end by four. Does it match the error you measured when selecting the time?
3. What spoils the square more: a turning error or a slip on a straight line? How can this be verified by separate experiment? Run it and record the conclusion.

The sensor needs a clear picture: a light background and a dark line. For intermediate level tasks on the path you will also need an intersection.

1. Take a light matte field with a black line or stick black matte electrical tape on a white sheet: straight, smooth bend and one intersection.
2. Prepare two cards: white and black.
3. Find the left and right sensors on the robot. Put the robot on the line and check: does the line pass between the sensors and not touch any of them?

Prepare a track for your level and check if it suits your robot.

1. Make a path: straight, smooth bend, sharp arc and intersection. Prepare white and black cards.
2. Using a ruler, measure the width of the line and the distance between the sensors (between the centers of the windows).
3. Put the robot on the line. How many millimeters are left from the edge of the line to each sensor? Write in your journal: what happens if the line is wider than the distance between the sensors?

The sensor shines on the floor and measures how much light has returned. The board turns this into a number, and to see it, the program sends the number to the computer.

1. Create a sketch L31_Read_Sensors according to the template and write both parts yourself. The left sensor is connected to A4, right - to A5.

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

2. Upload the program and open the Serial Monitor with speed 9600.
3. Place a white card under the left sensor, then a black one. Keep the card at the same height as the sensor above the floor.

The sensor shines on the floor and measures how much light has returned. The left sensor is connected to A4, right - to A5.

Requirement. Sketch L31_Read_Sensors prints the line five times per second t=… L=… R=…, where t — time in milliseconds since switching on.

Acceptance.

1. By numbers t in the monitor, check that the lines are coming approximately every 200 ms. How many milliseconds does the interval differ from 200 and why?
2. Place a white card under the left sensor, then a black card at working height. Write down how much the number changes.

1. Fill out the table for the four robot positions:

2. Why are both numbers “white” in the last line, although the robot is on the line? Write it down.

Take it off profile sensors: how the numbers change while the line passes crosswise under the robot.

1. Place the robot across the line so that the line is far to the right of the right sensor.
2. Move the robot to the left in 5 mm steps until the line goes beyond the left sensor. Write down L and R at each step.

3. Draw two graphs in your journal: L and R versus shift. Find on the graph where the line is exactly between the sensors and how many millimeters you can go to the side until the sensor notices it.

The sensors are not the same: even over the same field their numbers are different. Therefore, each sensor needs its own measurements - calibration.

1. For each sensor, record three readings on white and three on black, in different places on the track.
2. Choose a typical number for each cell and write down why.

Calibrate the sensors and prove that the calibration can be trusted.

1. For each sensor, record 10 readings on white and 10 on black. Find the smallest and largest in each series - this is spread.
2. Compare the spread with the difference between white and black. How many times is the difference greater than the spread?
3. Repeat white near the window and in the dark corner of the classroom. Do the numbers change more than the spread?
4. Write down the conclusion: where the calibration can be trusted and when it needs to be repeated.

The program needs a rule: when to assume that there is a line under the sensor? Compare the new reading with two measurements: if it is closer to black than to white, there is a line under the sensor.

1. Create a sketch L31_Line_Detect according to the template and enter your four numbers instead of zeros.
2. Write loop() myself: deciding "line or not" for each sensor and printing.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. 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. Upload the program, open the Serial Monitor and place the black card under the sensors one by one.
4. Answer in the journal: what will the program start printing if white and black in it are mixed up? Why?

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

Requirement 1. Function onLine(value, white, black) replies true, when there is a line under the sensor:

• reading is closer to the black dimension than to the white dimension;
• works both when the sensor is black - a large number, and when it is small;
• there are no ready-made threshold numbers inside: only value, white and black.

Acceptance. Write onLine in the test sketch, load it and open the Serial Monitor (9600). The test checks eight cases for two types of sensors, including readings outside your measurements.

// Проверка функции 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() {}

When all lines PASS, add onLine into your program from the “See what the sensor sees” step and save it as L31_Line_Detect. Have her type “line on the left” and “line on the right.” Enter your measurements and check with the card.

The robot moves forward and the line must remain between the sensors. If the line was under one sensor, the robot moved to the side. The wheel can only move or stand still. How to return the robot to the line?

1. Place the switched off robot on the line. Move it so that the line is under the left sensor. Where did the robot go? Which way should he turn? Which wheel should I stop for this?
2. The same for the right sensor.
3. Fill out the table in the journal:

4. In your journal, explain in one sentence why stopping one wheel turns the robot.

The robot moves forward and the line must remain between the sensors. Make up the rules yourself: what the wheels do in each of the four cases and why.

1. Check each line with the robot turned off: move it with your hand and show where it should go.
2. "Both White" appears in two different robot positions. Which ones? Can the program distinguish between them? Write down what happens to the robot then.
3. On a straight track, “both are a line” almost never happens. Where on the final field will this occur and what should the robot do then?

Let's put everything together: sensors, the “closer to black” rule and motors from lesson 2.1. The wheels will obey the rules from your table.

1. Create a sketch L31_First_Line according to the template. Enter your four dimensions. Motor tuning and protection are already ready.
2. Write loop() himself: transfer your conditions from L31_Line_Detect, set the wheels to speed according to your table of rules and send them to the motors.

// Шаблон среднего уровня. Напиши код в разделе «Твоя часть» по целям в комментариях. 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. Click Check.

Take the frame: it contains contacts, motors and function drive from lesson 2.1. Transfer your measurements and function into it onLine and save as L31_First_Line. You will need this program in lesson 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);}

Requirement 2. Wheels follow your rules table:

• in each repetition the program reads both sensors anew and decides anew: the wheel, stopped once, moves again when its sensor sees white;
• your function makes the decision onLine;
• speed - one named variable speed at the beginning of the sketch.

Requirement 3. The robot is safe:

• without measurements, white and black wheels stand;
• after turning on, you have 2 seconds to remove your hands.

Acceptance - on the stand in the next step: the robot performs every line of your rule table, and without measurements the wheels don’t spin.

1. Place the robot on the stand, load the program, turn on the power to the motors.
2. Check all four rows of your rules table: place the cards so that the sensors see what you need. Write down what the wheels do.

3. Check your prediction about the speed specified in setup(). Turn off the power to the motors.

Acceptance of requirements 2–3 on a stand.

1. Load the program with zeros instead of measurements. The wheels should not spin. Enter the measurements and upload again.
2. Check each line of your rules table with cards.
3. Note how many seconds after switching on the wheels start moving.

1. Turn off the power to the motors, unplug the USB cable.
2. Place the robot on a straight line: the line between the sensors. Turn on the power. Be prepared to turn it off if the robot leaves the path.
3. Walk the path three times at speed = 100, then three times at 80 and at 130. Record how many times the robot went through the bend.

4. Why does the robot move jerkily? Write it down in one sentence.

1. Turn off the power to the motors, disconnect the USB cable. Be prepared to turn off the power if the robot leaves the track.
2. Find the largest speed, in which the robot goes through a smooth bend three times out of three. Start at 80 and work your way up in 20 steps.
3. At the highest speed, which the robot could not withstand, look where it loses the line. Explain the reason in the journal through your rule table.
4. Write down what needs to be changed in the rules to make the robot keep the line faster. You will check this in lesson 3.2.

Imagine that you are driving a bicycle along a line: if you go a little further, you turn the handlebars a little, if you go too far, you turn it more. The program from lesson 3.1 cannot do this: it only knows “there is a line” or “not”.

1. Run the program from lesson 3.1 on an arc of 350 mm and see how the robot drives.
2. Write it down in your journal in one sentence: what does the program lack to turn smoothly?

Research the problem before you solve it.

1. Run your program from lesson 3.1 on an arc of 350 mm, then on an arc of 125 mm. Record how the robot drives: jerking, wobbling, leaving the line.
2. Explain in the journal what information from sensors program 3.1 throws out and why this causes the robot to move jerkily.
3. Before you read further, come up with your own rule: how wheel speeds should depend on sensor readings. Write it down in words or a formula. At the end of the lesson, compare it with the P-controller.

The sensors have different white and black numbers, so they cannot be compared directly. We need a general scale: black - 0, white - 100. The reading on the scale is “how many percent of the path from black to white” it has passed.

1. Create a sketch L32_Error according to the template, transfer measurements from the log.
2. Write the function level himself. Error in loop() don't touch it yet.

// Наблюдение в 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);  }}