Глава 5 Практическая часть
5.1 Модель «Мотоцикл»

Мотоцикл
Цель:
Сформировать навыки сборки, программирования и управления двухколёсным роботом «Мотоцикл» для движения вперёд, назад и поворота с использованием мотора постоянного тока, сервомотора, зубчатых передач, датчиков линии и ультразвукового датчика.
Состав и описание модели
- Блок-контроллер ЭДУино.
- Аккумуляторный иодуль PowerBank 9V 3A.
- Двигатель постоянного тока − 2 шт.
- Конструктивные элементы.
- Модуль «Ультразвуковой дальномер» − 1 шт.
- Модуль «Датчик линии» − 2 шт.
Данная модель представляет из себя передвижную сбалансированную платформу, приводимую в движение за счёт мотора постоянного тока и управляемую сервомотором.
Эта модель познакомит с применением поворотных механизмов и зубчатых передач. После завершения сборки модель будет устойчиво стоять на двух колёсах. Приводя в движения мотор — можно заставить модель двигаться вперёд или назад. С помощью сервомотора — можно заставить модель поворачиваться.
Для модели используется зубчатая передача с соотношением 40/24/24.
Вращение от вала мотора сначала передаётся на зубчатое колесо с 40 зубьями. Оно входит в зацепление с колесом на 24 зуба, за счёт чего скорость вращения увеличивается, а крутящий момент уменьшается примерно в 40/24, то есть в 5/3 раза. При этом направление вращения изменяется на противоположное.
Далее вращение передаётся на ещё одно зубчатое колесо с таким же числом зубьев (24). Так как количество зубьев одинаковое, скорость и крутящий момент остаются без изменений, но направление вращения снова меняется.
В результате такая схема передачи изменяет скорость и крутящий момент вращения мотора, обеспечивая нужные характеристики для движения модели.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
// --- Библиотека для работы с сервомотором ---
#include <Servo.h>
// --- Пин для мотора постоянного тока (M1) ---
const int dir_pin_M1 = 7; // Пин направления
const int speed_pin_M1 = 6; // Пин ШИМ (скорость)
// --- Пины для датчиков линии ---
const int lineSensorLeft = A4; // Левый датчик линии
const int lineSensorRight = A5; // Правый датчик линии
// --- Пины для ультразвукового датчика (УЗ) ---
const int trigPin = 9; // Пин Trig
const int echoPin = 10; // Пин Echo
// --- Пин для сервомотора ---
const int servoPin = 2;
// --- Настройки ---
const int motorSpeed = 65; // Основная скорость мотора (0-255)
const int obstacleDistance = 15; // Дистанция до препятствия в см
// --- Настройки углов сервомотора (ВАЖНО: подберите свои значения!)
const int SERVO_CENTER = 90; // Угол для движения прямо
const int SERVO_LEFT = 45; // Угол для поворота налево
const int SERVO_RIGHT = 135; // Угол для поворота направо
Servo myServo; // Создаем объект сервомотора
// Определяем, что считать "черной линией"
const int BLACK = HIGH;
const int WHITE = LOW;
void setup() {
// --- Инициализация портов ---
Serial.begin(9600); // Для отладки
// Мотор
pinMode(dir_pin_M1, OUTPUT);
pinMode(speed_pin_M1, OUTPUT);
// Датчики линии
pinMode(lineSensorLeft, INPUT);
pinMode(lineSensorRight, INPUT);
// Ультразвуковой датчик
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
// Сервомотор
myServo.attach(servoPin);
myServo.write(SERVO_CENTER); // Установить руль прямо
delay(500);
}
void loop() {
// 1. Проверяем, есть ли препятствие
long distance = getDistance();
if (distance > 0 && distance < obstacleDistance) {
// Если есть препятствие, выполняем маневр объезда
avoidObstacle();
} else {
// 2. Если препятствия нет, едем по линии
followLine();
}
}
// --- Функция движения по линии ---
void followLine() {
bool leftSeesLine = (digitalRead(lineSensorLeft) == BLACK);
bool rightSeesLine = (digitalRead(lineSensorRight) == BLACK);
// Для поворота с помощью сервопривода нужно всегда двигаться вперед
moveForward(motorSpeed);
if (leftSeesLine && !rightSeesLine) {
// Робот съезжает вправо -> поворачиваем руль налево
myServo.write(SERVO_LEFT);
} else if (!leftSeesLine && rightSeesLine) {
// Робот съезжает влево -> поворачиваем руль направо
myServo.write(SERVO_RIGHT);
} else if (leftSeesLine && rightSeesLine) {
// Робот едет по центру -> руль прямо
myServo.write(SERVO_CENTER);
} else {
// Оба датчика не видят линию -> стоп
stopMotor();
}
}
// --- Функция объезда препятствия ---
void avoidObstacle() {
// 1. Останавливаемся и немного сдаем назад
stopMotor();
myServo.write(SERVO_CENTER); // Ставим руль прямо
delay(300);
moveBackward(65);
delay(700);
stopMotor();
delay(300);
// 2. Поворачиваем руль налево и едем вперед, совершая поворот
myServo.write(SERVO_LEFT);
delay(300); // Даем серво время повернуться
moveForward(motorSpeed);
delay(1200); // Подберите это время для поворота на 90 градусов
// 3. Поворачиваем руль направо и едем вперед, чтобы выровняться
myServo.write(SERVO_RIGHT);
delay(300);
moveForward(motorSpeed);
delay(1200); // Время должно быть таким же, как при повороте налево
// 4. Ставим руль прямо и едем немного вперед, чтобы найти линию
myServo.write(SERVO_CENTER);
delay(300);
moveForward(motorSpeed);
delay(500);
}
// --- Базовые функции управления мотором ---
void moveForward(int speed) {
digitalWrite(dir_pin_M1, LOW); // Направление "вперед"
analogWrite(speed_pin_M1, speed);
}
void moveBackward(int speed) {
digitalWrite(dir_pin_M1, HIGH); // Направление "назад"
analogWrite(speed_pin_M1, speed);
}
void stopMotor() {
analogWrite(speed_pin_M1, 0); // Выключаем скорость
}
// --- Функция получения дистанции с УЗ датчика ---
long getDistance() {
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
long duration = pulseIn(echoPin, HIGH);
return duration / 58;
}Пример рабочей программы на графическом языке:





Все примеры кода в электронном виде можно скачать по ссылке
5.2 Модель «Змея»

Змея
Цель:
Сформировать навыки сборки, программирования и управления роботом «Змея», обеспечивающим движение вперёд, назад и изменение траектории с помощью мотора постоянного тока, сервомоторов, рычажных и поворотных механизмов, зубчатых передач, а также использование ультразвукового датчика для обнаружения препятствий.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Двигатель постоянного тока − 1 шт.
- Сервомотор большой − 1 шт.
- Сервомотор малый − 1 шт.
- Конструктивные элементы.
- Модуль «Ультразвуковой дальномер» − 1 шт.
Данная модель представляет из себя Serpent-Robot (робот змея). приводимый в движение за счёт сервомоторов и мотора постоянного тока.
Эта модель познакомит с применением рычагов, поворотных механизмов, зубчатых передач. После завершения сборки модель будет устойчиво стоять на платформах и опираться на гусеничную платформу. Приводя в движения мотор — можно задать модели направление движения вперёд либо назад. Изменяя положение малого сервомотора — можно изменять траекторию движения робота влево или вправо. Ультразвуковой датчик позволяет фиксировать препятствия перед роботом. Большой сервомотор позволяет изменять положение датчика и имитировать атаку.
Для модели «Змея» используется зубчатая передача с соотношением 40 / 40.
Вращение от вала мотора передаётся на зубчатое колесо с 40 зубьями, которое находится в зацеплении с другим колесом с таким же числом зубьев. Поскольку количество зубьев у обоих колёс одинаковое, скорость вращения и крутящий момент сохраняются без изменений.
При этом направление вращения выходного вала становится противоположным направлению вращения мотора. Такая передача применяется в модели «Змея» для изменения направления движения без изменения его скорости и силы вращения.
Рычажный механизм используется для изменения положения (наклон) датчика ультразвукового.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
#include <Servo.h> // Подключаем библиотеку для работы с сервоприводами
// --- Пины для мотора постоянного тока (Движение) ---
const int dir_pin_M1 = 7; // Пин направления мотора
const int speed_pin_M1 = 6; // Пин ШИМ для скорости мотора
// --- Пины для УЗ датчика ---
const int trig_pin = 10;
const int echo_pin = 9;
// --- Пины для сервоприводов ---
const int big_servo_pin = 2; // Пин для "укуса"
const int steering_servo_pin = 1; // !!! НОВЫЙ ПИН: Пин для серво руля (поворота)
// --- Объекты ---
Servo bigServo; // Объект для серво "укуса"
Servo steeringServo; // Объект для серво руля
// --- Настройки ---
const int motor_speed = 100; // Скорость движения змеи (от 0 до 255)
const int detection_distance = 10; // Дистанция для срабатывания (в см)
// Настройки серво "укуса"
const int servo_up_pos = 90; // Положение "вверху" (нормальное)
const int servo_down_pos = 45; // Положение "внизу" (для укуса)
// !!! НОВЫЕ НАСТРОЙКИ: Положения рулевого серво (подберите свои значения)
const int steer_straight = 90; // Положение "прямо"
const int steer_right = 120; // Положение "направо"
const int steer_left = 60; // Положение "налево"
// !!! НОВЫЕ ПЕРЕМЕННЫЕ: Для управления движением по времени
unsigned long lastMoveTime = 0; // Время последнего изменения движения
const long moveInterval = 2000; // Интервал движения (2000 мс = 2 секунды)
int moveState = 0; // Текущее состояние движения (0=прямо, 1=направо, 2=налево)
void setup() {
// Настройка пинов мотора
pinMode(dir_pin_M1, OUTPUT);
pinMode(speed_pin_M1, OUTPUT);
// Настройка пинов УЗ датчика
pinMode(trig_pin, OUTPUT);
pinMode(echo_pin, INPUT);
// Присоединяем сервоприводы к пинам
bigServo.attach(big_servo_pin);
steeringServo.attach(steering_servo_pin); // Присоединяем рулевой серво
// Устанавливаем начальное положение серво
bigServo.write(servo_up_pos);
steeringServo.write(steer_straight); // Начинаем с движения прямо
delay(500); // Небольшая пауза для стабилизации серво
}
void loop() {
// 1. Всегда измеряем расстояние
long distance = getDistance();
unsigned long currentTime = millis(); // Получаем текущее время
// 2. ПРОВЕРКА ПРЕПЯТСТВИЯ (Главный приоритет)
if (distance > 0 && distance <= detection_distance) {
// Если видим препятствие, останавливаемся и выполняем "укус"
stopMotor();
performBite();
// Сбрасываем таймер и состояние движения
lastMoveTime = currentTime;
moveState = 0; // Начнем с движения прямо после укуса
steeringServo.write(steer_straight);
} else {
// 3. УПРАВЛЕНИЕ ДВИЖЕНИЕМ (Если нет препятствия)
// Проверяем, не пора ли изменить направление
if (currentTime - lastMoveTime >= moveInterval) {
lastMoveTime = currentTime; // Сбрасываем таймер
// Переключаем состояние (0 -> 1 -> 2 -> 0 ...)
moveState = (moveState + 1) % 3;
// Устанавливаем поворот в зависимости от состояния
switch (moveState) {
case 0: // Прямо
steeringServo.write(steer_straight);
break;
case 1: // Направо
steeringServo.write(steer_right);
break;
case 2: // Налево
steeringServo.write(steer_left);
break;
}
}
// В любом случае (если нет препятствия) - мотор должен ехать
moveForward();
}
}
// Функция "Укуса"
void performBite() {
// Мотор уже остановлен в loop()
delay(200); // Короткая пауза
// Опускаем серво вниз
bigServo.write(servo_down_pos);
delay(500); // Пауза в нижнем положении
// Поднимаем серво обратно
bigServo.write(servo_up_pos);
delay(500); // Пауза в верхнем положении
}
// Функция измерения дистанции
long getDistance() {
digitalWrite(trig_pin, LOW);
delayMicroseconds(2);
digitalWrite(trig_pin, HIGH);
delayMicroseconds(10);
digitalWrite(trig_pin, LOW);
long duration = pulseIn(echo_pin, HIGH);
return duration / 58.2;
}
// Функция движения вперед
void moveForward() {
digitalWrite(dir_pin_M1, LOW);
analogWrite(speed_pin_M1, motor_speed);
}
// Функция остановки
void stopMotor() {
analogWrite(speed_pin_M1, 0);
}Пример рабочей программы на графическом языке:



Все примеры кода в электронном виде можно скачать по ссылке
5.3 Модель «Шагающий робот»

Шагающий робот
Цель:
Сформировать навыки сборки, программирования и управления шагающим роботом на шести лапах для движения вперёд, назад и поворота с использованием моторов постоянного тока и рычажно-поступательных механизмов.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Двигатель постоянного тока − 2 шт.
- Конструктивные элементы.
Данная модель представляет из себя шагающего робота на 6-ти лапах, приводимые в движение за счёт двигателей постоянного тока.
Эта модель познакомит с применением рычагов. После завершения сборки модель будет устойчиво стоять на 6-ти лапах. Приводя в движения тот или иной мотор — можно заставить модель двигаться вперёд, назад или поворачиваться.
Рычажный механизм преобразует вращательное движение в сложное поступательное движение со смещением, за счёт чего механизм получает возможность шагать и обеспечивает передвижение робота.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
// --- Пины для Мотора 1 (правые лапы) ---
const int dir_pin_M1 = 7; // Направление мотора 1
const int speed_pin_M1 = 6; // ШИМ (скорость) мотора 1
// --- Пины для Мотора 2 (левые лапы) ---
const int dir_pin_M2 = 12; // Направление мотора 2
const int speed_pin_M2 = 11; // ШИМ (скорость) мотора 2
// --- Настройки движеия ---
const int motorSpeed = 100; // Скорость моторов (можно менять от 0 до 255)
const int moveDuration = 5000; // Длительность движения (5000 мс = 5 с)
// --- Прототипы функций (объявление) ---
void moveForward();
void moveBackward();
void stopMotors();
void setup() {
// Настраиваем все пины моторов как выходы (OUTPUT)
pinMode(dir_pin_M1, OUTPUT);
pinMode(speed_pin_M1, OUTPUT);
pinMode(dir_pin_M2, OUTPUT);
pinMode(speed_pin_M2, OUTPUT);
}
void loop() {
// Вызываем функцию движения вперед
moveForward();
// Ждем 5 секунд
delay(moveDuration);
// Вызываем функцию движения назад
moveBackward();
// Ждем 5 секунд
delay(moveDuration);
// *Полностью останавливает оба мотора.
stopMotors();
// Ждем 1 секунду
delay(1000); // Остановка на 1 секунду
}
// Включает оба мотора для движения вперед.
void moveForward() {
// Устанавливаем направление "вперед" для обоих моторов
digitalWrite(dir_pin_M1, LOW);
digitalWrite(dir_pin_M2, HIGH);
// Включаем моторы с заданной скоростью
analogWrite(speed_pin_M1, motorSpeed);
analogWrite(speed_pin_M2, motorSpeed);
}
// Включает оба мотора для движения назад.
void moveBackward() {
// Устанавливаем направление "назад" для обоих моторов
digitalWrite(dir_pin_M1, HIGH);
digitalWrite(dir_pin_M2, LOW);
// Включаем моторы с заданной скоростью
analogWrite(speed_pin_M1, motorSpeed);
analogWrite(speed_pin_M2, motorSpeed);
}
// Полностью останавливает оба мотора.
void stopMotors() {
// Выключаем скорость, моторы останавливаются
analogWrite(speed_pin_M1, 0);
analogWrite(speed_pin_M2, 0);
}Пример рабочей программы на графическом языке:





Все примеры кода в электронном виде можно скачать по ссылке
5.4 Модель «Шагоход ОТТО»

Шагоход ОТТО
Цель:
Сформировать навыки сборки, программирования и управления шагающим роботом типа «ОТТО», позволяющего перемещаться и изменять направление движения с помощью моторов постоянного тока, зубчатых передач и рычажно-поступательных механизмов.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Двигатель постоянного тока − 1 шт.
- Конструктивные элементы.
Данная модель представляет из себя шагающего робота, опирающегося на 2 ноги, приводимые в движение за счёт двух моторов постоянного тока.
Эта модель познакомит с применением рычагов. После завершения сборки модель будет устойчиво стоять на двух ногах. Приводя в движения моторы — можно заставить модель поворачиваться, двигаться вперёд или назад.
В шагоходе типа 1 (ОТТО), используется зубчатая передача с соотношением 24 / 24.
Вращение от вала мотора передаётся на зубчатое колесо с 24 зубьями, которое находится в зацеплении с другим колесом с таким же числом зубьев. При равном количестве зубьев скорость вращения и крутящий момент не изменяются.
При этом направление вращения выходного вала становится противоположным направлению вращения мотора. Такая передача применяется в данной модели для изменения направления движения механизма без изменения его скорости и силы вращения.
Рычажный механизм преобразует вращательное движение в сложное поступательное движение со смещением. За счёт этого обеспечивается шаговое перемещение робота. Дополнительно механизм используется как тяга, позволяя изменять наклон стопы в зависимости от положения ноги и повышая устойчивость при движении.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
// Переменные для управления скоростью движков
volatile int speed = 50;
// Пины куда подключены движки
const int dir_pin_M1 = 4;
const int speed_pin_M1 = 5;
const int dir_pin_M2 = 7;
const int speed_pin_M2 = 6;
void setup() {
// Настраиваем порты
pinMode(dir_pin_M1, OUTPUT);
pinMode(speed_pin_M1, OUTPUT);
pinMode(dir_pin_M2, OUTPUT);
pinMode(speed_pin_M2, OUTPUT);
}
void loop() {
delay(2000); // Пауза 2 секунды перед началом движения
forward(); // Команда движения вперёд
delay(2000); // Движение вперёд в течение 2 секунд
stop(); // Остановка моторов
}
// Функция движения вперёд
void forward(){
digitalWrite(dir_pin_M1, HIGH); // Задаём направление вращения первого мотора
digitalWrite(dir_pin_M2, LOW); // Задаём направление вращения второго мотора
analogWrite(speed_pin_M1, speed); // Устанавливаем скорость первого мотора
analogWrite(speed_pin_M2, speed); // Устанавливаем скорость второго мотора
}
// Функция движения назад
void back(){
digitalWrite(dir_pin_M1, LOW); // Меняем направление вращения первого мотора
digitalWrite(dir_pin_M2, HIGH); // Меняем направление вращения второго мотора
analogWrite(speed_pin_M1, speed); // Устанавливаем скорость первого мотора
analogWrite(speed_pin_M2, speed); // Устанавливаем скорость второго мотора
}
// Функция поворота направо
void turnright(){
digitalWrite(dir_pin_M1, HIGH); // Оба мотора вращаются в одном направлении
digitalWrite(dir_pin_M2, HIGH); // что приводит к повороту вправо
analogWrite(speed_pin_M1, speed); // Скорость первого мотора
analogWrite(speed_pin_M2, speed); // Скорость второго мотора
}
// Функция поворота налево
void turnleft(){
digitalWrite(dir_pin_M1, LOW);
// Оба мотора вращаются в противоположном направлении
digitalWrite(dir_pin_M2, LOW); // что приводит к повороту влево
analogWrite(speed_pin_M1, speed); // Скорость первого мотора
analogWrite(speed_pin_M2, speed); // Скорость второго мотора
}
// Функция полной остановки
void stop(){
digitalWrite(dir_pin_M1, HIGH);
// Направление не имеет значения при нулевой скорости
digitalWrite(dir_pin_M2, HIGH);
analogWrite(speed_pin_M1, 0); // Остановка первого мотора
analogWrite(speed_pin_M2, 0); // Остановка второго мотора
}Пример рабочей программы на графическом языке:
.png-768.webp)
.png-768.webp)
.png-766.webp)
.png-768.webp)
.png-768.webp)
.png-768.webp)
.png-768.webp)
Все примеры кода в электронном виде можно скачать по ссылке
5.5 Модель «Дифференциальная машинка для линии»

Дифференциальная машинка для линии
Цель:
Сформировать навыки сборки, программирования и управления дифференциальной машинкой для движения по линии и объезда препятствий с использованием моторов постоянного тока, датчиков линии и ультразвукового датчика.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Двигатель постоянного тока − 2 шт.
- Конструктивные элементы.
- Модуль «Ультразвуковой дальномер» − 1 шт.
- Модуль «Датчик линии» − 2 шт.
Данная модель представляет из себя соревновательный транспортировщик. приводимые в движение за счёт двух моторов постоянного тока.
Эта модель познакомит с применением датчиков линии. После завершения сборки модель будет устойчиво стоять на колёсах и шаровой опоре. Приводя в движения моторы — можно заставить модель поворачиваться и менять направление движения. Оснащённые датчики линии — позволяют детектировать линию. А установочный ультразвуковой датчик — объезжать препятствия.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
// --- Пины для датчиков ---
#define LINE_LEFT_PIN A4
#define LINE_RIGHT_PIN A5
#define ECHO_PIN A3
#define TRIG_PIN A2
// --- Пины для драйвера моторов (DIR + SPEED/PWM) ---
// Мотор M1 (Правый)
const int dir_pin_M1 = 7;
const int speed_pin_M1 = 6;
// Мотор M2 (Левый)
const int dir_pin_M2 = 12;
const int speed_pin_M2 = 11;
// --- Настройки и калибровка ---
#define LINE_THRESHOLD 500
#define MOTOR_SPEED 50 // Базовая скорость для движения прямо
// НОВЫЕ НАСТРОЙКИ ДЛЯ ПЛАВНЫХ ПОВОРОТОВ
#define TURN_OUTER_SPEED 50 // Скорость внешнего колеса при повороте (быстрее)
#define TURN_INNER_SPEED 30 // Скорость внутреннего колеса при повороте (медленнее)
#define STOP_DISTANCE 20
#define REVERSE_DISTANCE 8
// Направление движения. Если робот едет не туда, поменяйте HIGH и LOW местами.
#define FORWARD HIGH
#define BACKWARD LOW
void setup() {
// Инициализация последовательного порта для отладки
Serial.begin(9600);
// Настройка пинов датчиков линии
pinMode(LINE_LEFT_PIN, INPUT); // Левый датчик линии
pinMode(LINE_RIGHT_PIN, INPUT); // Правый датчик линии
// Настройка пинов ультразвукового дальномера
pinMode(TRIG_PIN, OUTPUT); // TRIG — выход
pinMode(ECHO_PIN, INPUT); // ECHO — вход
// Настройка пинов управления моторами
pinMode(dir_pin_M1, OUTPUT); // Направление мотора M1
pinMode(speed_pin_M1, OUTPUT); // Скорость мотора M1
pinMode(dir_pin_M2, OUTPUT); // Направление мотора M2
pinMode(speed_pin_M2, OUTPUT); // Скорость мотора M2
// Остановка моторов при старте
stopMotors();
}
void loop() {
// Измерение расстояния до препятствия
long distance = getDistance();
// Считывание состояния датчиков линии
// Если значение выше порога — линия не обнаружена (0)
// Если ниже порога — линия обнаружена (1)
int left_line = analogRead(LINE_LEFT_PIN) > LINE_THRESHOLD ? 0 : 1;
int right_line = analogRead(LINE_RIGHT_PIN) > LINE_THRESHOLD ? 0 : 1;
// --- Логика реакции на препятствие ---
if (distance > 0 && distance <= REVERSE_DISTANCE) {
// Препятствие слишком близко — отъезд назад
Serial.println("Obstacle too close! Reversing.");
moveBackward();
delay(300);
}
else if (distance > REVERSE_DISTANCE && distance <= STOP_DISTANCE) {
// Препятствие обнаружено — остановка
Serial.println("Obstacle detected! Stopping.");
stopMotors();
}
else {
// --- Логика движения по линии ---
if (left_line == 0 && right_line == 0) {
// Оба датчика не видят линию — движение вперёд
Serial.println("Forward");
moveForward();
}
else if (left_line == 1 && right_line == 0) {
// Линия под левым датчиком — плавный поворот направо
Serial.println("Smooth Turn Right");
turnRight(); // <--- Вызов функции поворота направо
}
else if (left_line == 0 && right_line == 1) {
// Линия под правым датчиком — плавный поворот налево
Serial.println("Smooth Turn Left");
turnLeft(); // <--- Вызов функции поворота налево
}
else {
// Перекрёсток или линия потеряна — остановка
Serial.println("Crossroad or line lost. Stop.");
stopMotors();
}
}
// Небольшая задержка для стабилизации работы
delay(50);
}
// --- Функции управления моторами (с изменениями) ---
void moveForward() {
digitalWrite(dir_pin_M1, BACKWARD);
digitalWrite(dir_pin_M2, FORWARD);
analogWrite(speed_pin_M1, MOTOR_SPEED);
analogWrite(speed_pin_M2, MOTOR_SPEED);
}
void moveBackward() {
digitalWrite(dir_pin_M1, FORWARD);
digitalWrite(dir_pin_M2, BACKWARD);
analogWrite(speed_pin_M1, MOTOR_SPEED);
analogWrite(speed_pin_M2, MOTOR_SPEED);
}
// Обновленная функция плавного поворота направо
void turnRight() {
// Оба мотора едут ВПЕРЕД
digitalWrite(dir_pin_M1, BACKWARD);
digitalWrite(dir_pin_M2, FORWARD);
// Но правый (внутренний) мотор медленнее, а левый (внешний) быстрее
analogWrite(speed_pin_M1, TURN_INNER_SPEED);
analogWrite(speed_pin_M2, TURN_OUTER_SPEED);
}
// Обновленная функция плавного поворота налево
void turnLeft() {
// Оба мотора едут ВПЕРЕД
digitalWrite(dir_pin_M1, BACKWARD);
digitalWrite(dir_pin_M2, FORWARD);
// Но левый (внутренний) мотор медленнее, а правый (внешний) быстрее
analogWrite(speed_pin_M1, TURN_OUTER_SPEED);
analogWrite(speed_pin_M2, TURN_INNER_SPEED);
}
void stopMotors() {
analogWrite(speed_pin_M1, 0);
analogWrite(speed_pin_M2, 0);
}
// --- Функция для получения дистанции (без изменений) ---
long getDistance() {
digitalWrite(TRIG_PIN, LOW);
delayMicroseconds(2);
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);
long duration = pulseIn(ECHO_PIN, HIGH);
return duration * 0.034 / 2;
}Пример рабочей программы на графическом языке:









Все примеры кода в электронном виде можно скачать по ссылке
5.6 Модель «Турель»

Турель
Цель:
Сформировать навыки сборки, программирования и управления моделью «Турель» для поворота платформы и выполнения выстрела с помощью мотора, сервомотора и рычажно-возвратно-поступательного механизма.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Двигатель постоянного тока − 1 шт.
- Сервомотор большой − 1 шт.
- Конструктивные элементы.
- Модуль «Ультразвуковой дальномер» − 1 шт.
Данная модель представляет из себя автоматическую пушку, приводимую в движение за счёт мотора постоянного тока и большого сервомотора.
Эта модель познакомит с применением рычагов, поворотных столов, возвратно-поступательных механизмами. После завершения сборки модель будет устойчиво стоять на платформе. Приводя в движения мотор — можно заставить модель поворачиваться. С помощью сервомотора — можно производить «выстрел».
Рычаг служит для преобразования вращательного движения в поступательное. За счёт этого механизма обеспечивается прямолинейное движение исполнительного элемента, что позволяет роботу выполнять действие выстрела.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
// --- Пины для мотора патрулирования (M1) ---
const int dir_pin_M1 = 7; // Направление мотора 1
const int speed_pin_M1 = 6; // ШИМ скорость мотора 1
// --- Пины для мотора стрельбы (M2) ---
const int dir_pin_M2 = 4; // Направление мотора 2
const int speed_pin_M2 = 5; // ШИМ скорость мотора 2
// --- Пины для УЗ датчика ---
const int trig_pin = A5;
const int echo_pin = A4;
// --- Настройки ---
const int patrol_speed = 50; // Скорость патрулирования (0-255)
const int fire_speed = 255; // Скорость мотора стрельбы (0-255)
const int fire_duration = 200; // Длительность "выстрела" (в миллисекундах)
const int detection_distance = 15; // Дистанция для срабатывания (в см)
// --- Переменные для логики кулдауна ---
unsigned long cooldownUntil = 0; // Время, до которого турель находится в "слепой зоне"
const long cooldownDuration = 1000; // Длительность кулдауна в миллисекундах (1 секунда)
void setup() {
Serial.begin(9600);
// Настройка пинов моторов
pinMode(dir_pin_M1, OUTPUT);
pinMode(speed_pin_M1, OUTPUT);
pinMode(dir_pin_M2, OUTPUT);
pinMode(speed_pin_M2, OUTPUT);
// Настройка пинов УЗ датчика
pinMode(trig_pin, OUTPUT);
pinMode(echo_pin, INPUT);
// Устанавливаем направление для мотора стрельбы (например, HIGH)
digitalWrite(dir_pin_M2, HIGH);
}
void loop() {
// 1. Проверка кулдауна
// Если текущее время меньше, чем время окончания кулдауна,
// то ничего не делаем и выходим из loop().
if (millis() < cooldownUntil) {
return; // Пропускаем итерацию, пока идет перезарядка
}
// Если мы здесь, значит кулдаун закончился.
// 2. Измеряем расстояние до объекта
long distance = getDistance();
// 3. Проверяем, если объект в зоне поражения
if (distance > 0 && distance <= detection_distance) {
// Объект обнаружен!
// 3а. Останавливаем патрулирование
stopPatrol();
// 3б. Стреляем!
fireWeapon();
// 3в. Выполняем короткое движение, чтобы сменить позицию
performEvasiveManeuver();
// 3г. Запускаем таймер кулдауна на 1 секунду
cooldownUntil = millis() + cooldownDuration;
Serial.println("Цель поражена! Начинаю перезарядку на 1 секунду...");
} else {
// 4. Если путь свободен, продолжаем патрулировать
patrol();
}
}
long getDistance() {
digitalWrite(trig_pin, LOW);
delayMicroseconds(2);
digitalWrite(trig_pin, HIGH);
delayMicroseconds(10);
digitalWrite(trig_pin, LOW);
long duration = pulseIn(echo_pin, HIGH, 30000);
return duration / 58.2;
}
void patrol() {
digitalWrite(dir_pin_M1, HIGH);
// Установите HIGH или LOW для нужного направления
analogWrite(speed_pin_M1, patrol_speed);
}
void stopPatrol() {
analogWrite(speed_pin_M1, 0);
}
void fireWeapon() {
Serial.println("Огонь!");
analogWrite(speed_pin_M2, fire_speed);
delay(fire_duration);
analogWrite(speed_pin_M2, 0);
stopPatrol();
delay(200);
}
void performEvasiveManeuver() {
// Двигаемся в том же направлении патрулирования короткое время
analogWrite(speed_pin_M1, patrol_speed);
delay(200); // Двигаемся 300 мс
}Пример рабочей программы на графическом языке:



Все примеры кода в электронном виде можно скачать по ссылке
5.7 Модель «Манипулятор»

Манипулятор
Цель:
Сформировать у обучающихся навыки сборки, программирования и эксплуатации модели «Манипулятор», включающей поворотный стол, рычаги, зажимы и зубчатые передачи, научить управлять мотором и сервомоторами для поворота манипулятора, изменения высоты и угла захвата, обеспечивая точное позиционирование рабочего элемента, развивать понимание работы рычажных механизмов и принципов взаимодействия приводов и конструктивных элементов в робототехнических системах.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Сервомотор большой − 1 шт.
- Сервомотор малый − 1 шт.
- Двигатель постоянного тока − 1 шт.
- Конструктивные элементы.
Данная модель представляет из себя манипулятор (это механическая рука). приводимые в движение за счёт сервомоторов.
Эта модель познакомит с применением рычагов, поворотных столов, зажимов, зубчатых передач. После завершения сборки модель будет устойчиво стоять на платформе. Приводя в движения мотор — можно заставить модель поворачиваться. С помощью сервомоторов — можно изменять высоту и степень захвата манипулятора.
Рычаг применяется для изменения положения манипулятора. За счёт его работы меняется угол наклона и высота захвата, что позволяет точно настраивать положение рабочего элемента при выполнении различных задач.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
#include <Servo.h> // Подключаем библиотеку для управления сервоприводами
// --- Пины устройств ---
// Сервоприводы
Servo myservo1; // Объект для сервопривода Руки/Стрелы
Servo myservo2; // Объект для сервопривода Захвата/Гриппера
// DC-двигатель платформы и энкодер
const int dir_pin = 4; // Пин для управления НАПРАВЛЕНИЕМ движения
const int speed_pin = 5; // Пин для управления СКОРОСТЬЮ (ШИМ/PWM)
const int encoderPinA = A2; // Пин A энкодера
const int encoderPinB = A3; // Пин B энкодера
// --- Переменные для управления ---
volatile int motor_speed = 50; // Установленная скорость мотора (от 0 до 255)
bool cycle_completed = false; // Флаг: false = цикл действий еще не выполнен, true = выполнен
// Переменные энкодера
volatile long encoderPosition = 0; // Текущая позиция, отслеживаемая энкодером
volatile int lastState = 0; // Последнее известное состояние пинов энкодера
// --- Константы ---
// !!! ВАЖНО: Это значение необходимо откалибровать для вашего мотора и редуктора!
// Запустите тестовый код, поверните вал вручную на 90 градусов и посмотрите,
// какое значение выведет энкодер в монитор порта.
const long NINETY_DEGREES_TICKS = 120;
// Количество "тиков" энкодера для поворота на 90°
/**
* @brief Плавно перемещает сервопривод из начального угла в конечный за заданное время.
* @param servo Сервопривод для управления (передается по ссылке).
* @param movingTime Общее время движения в миллисекундах.
* @param startAngle Начальный угол в градусах.
* @param stopAngle Конечный угол в градусах.
*/
void moveServo(Servo &servo, int movingTime, int startAngle, int stopAngle) {
if (startAngle == stopAngle) return;
// Расчет задержки между шагами для достижения нужного времени движения
int delayBetweenSteps = movingTime / abs(startAngle - stopAngle);
int currentAngle = startAngle;
int step = (startAngle < stopAngle) ? 1 : -1;
while (currentAngle != stopAngle) {
servo.write(currentAngle);
delay(delayBetweenSteps);
currentAngle += step;
}
// Финальная команда, чтобы гарантировать точное положение
servo.write(stopAngle);
}
/**
* @brief Полностью останавливает DC-двигатель платформы.
*/
void stopMotor() {
digitalWrite(dir_pin, LOW);
analogWrite(speed_pin, 0);
}
/**
* @brief Считывает состояние пинов энкодера и обновляет глобальную переменную encoderPosition.
*/
void updateEncoder() {
int stateA = digitalRead(encoderPinA);
int stateB = digitalRead(encoderPinB);
int currentState = (stateB << 1) | stateA; // Преобразуем два бита в одно число (0-3)
if (currentState != lastState) {
// Определяем направление вращения по последовательности состояний
if ((lastState == 0 && currentState == 1) || (lastState == 1 && currentState == 3) ||
(lastState == 3 && currentState == 2) || (lastState == 2 && currentState == 0)) {
encoderPosition++; // Вращение по часовой стрелке
} else {
encoderPosition--; // Вращение против часовой стрелки
}
lastState = currentState; // Сохраняем текущее состояние как последнее
}
}
/**
* @brief Вращает платформу до тех пор, пока энкодер не достигнет целевой позиции.
* @param targetPosition Целевое значение счетчика энкодера.
*/
void rotateToTarget(long targetPosition) {
// Определяем направление вращения
if (encoderPosition < targetPosition) {
digitalWrite(dir_pin, LOW); // Направление 1 (например, по часовой)
} else {
digitalWrite(dir_pin, HIGH); // Направление 2 (против часовой)
}
// Запускаем мотор
analogWrite(speed_pin, motor_speed);
// Вращаем, пока не достигнем цели. Условие проверяет, движемся ли мы все еще к цели.
while ((encoderPosition < targetPosition && digitalRead(dir_pin) == LOW) ||
(encoderPosition > targetPosition && digitalRead(dir_pin) == HIGH))
{
updateEncoder(); // Постоянно обновляем данные с энкодера
}
// Останавливаем мотор по достижении цели
stopMotor();
Serial.print("Позиция достигнута: ");
Serial.println(encoderPosition);
}
// --- ОСНОВНЫЕ ФУНКЦИИ ARDUINO ---
void setup() {
Serial.begin(9600);
// Инициализация сервоприводов
myservo1.attach(9);
myservo2.attach(10);
// Установка начальных положений
myservo1.write(25); // Рука поднята
myservo2.write(90); // Захват открыт
delay(1500);
// Инициализация DC-двигателя и энкодера
pinMode(dir_pin, OUTPUT);
pinMode(speed_pin, OUTPUT);
pinMode(encoderPinA, INPUT_PULLUP);
// Используем встроенные подтягивающие резисторы
pinMode(encoderPinB, INPUT_PULLUP);
stopMotor();
// Считываем начальное состояние энкодера для корректной работы
updateEncoder();
Serial.println("Манипулятор готов к работе!");
delay(1000);
}
void loop() {
// Весь цикл выполняется только один раз
if (!cycle_completed) {
Serial.println("--- Начало цикла ---");
// 1. Опустить руку для захвата
Serial.println("1. Опускаю руку...");
moveServo(myservo1, 2000, myservo1.read(), 65);
delay(500);
// 2. Схватить объект
Serial.println("2. Захватываю объект...");
moveServo(myservo2, 1000, myservo2.read(), 0);
delay(500);
// 3. Поднять руку с объектом
Serial.println("3. Поднимаю объект...");
moveServo(myservo1, 2000, myservo1.read(), 25);
delay(500);
// 4. Повернуть платформу на 90 градусов
Serial.println("4. Поворачиваю на 90 градусов...");
rotateToTarget(NINETY_DEGREES_TICKS);
// delay(1000);
// 5. Опустить руку, чтобы положить объект
Serial.println("5. Опускаю руку для сброса...");
moveServo(myservo1, 2000, myservo1.read(), 65);
delay(500);
// 6. Разжать захват
Serial.println("6. Сбрасываю объект...");
moveServo(myservo2, 1000, myservo2.read(), 90);
delay(500);
// 7. Поднять пустую руку
Serial.println("7. Поднимаю пустую руку...");
moveServo(myservo1, 2000, myservo1.read(), 25);
delay(500);
// 8. Вернуть платформу в исходное положение (в 0)
Serial.println("8. Возвращаюсь в исходное положение...");
rotateToTarget(0);
// delay(1000);
Serial.println("--- Цикл завершен ---");
cycle_completed = true; // Устанавливаем флаг, чтобы цикл не повторялся
}
}Пример рабочей программы на графическом языке:






Внимание:
Блок «выполнить» − «если» включает части 1-3. Часть 1:

Часть 2 (продолжение):

Часть 3 (заключение):

Внимание: Блок «повторить пока» включает части 1-3. Часть 1:

Часть 2 (продолжение):

Часть 3 (заключение):

Все примеры кода в электронном виде можно скачать по ссылке
5.8 Модель «Конвейер — Сортировщик»

Конвейер — Сортировщик
Цель:
Сформировать у обучающихся навыки сборки, программирования и эксплуатации модели «Конвейер-Сортировщик», включающей конвейерную ленту и поворотный сортировочный узел, научить управлять моторами постоянного тока для запуска, остановки и изменения направления движения ленты, регулировать положение сортировочного механизма, а также использовать датчики цвета и ультразвуковой датчик для обнаружения, распознавания и сортировки объектов, развивать понимание принципов работы конвейерных систем, поворотных узлов и базовых механизмов автоматизации.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Двигатель постоянного тока − 2 шт.
- Конструктивные элементы.
- Модуль «Датчик цвета» − 1 шт.
- Модуль «Ультразвуковой дальномер» − 1 шт.
Данная модель представляет из себя конвейерную ленту, и сортирующий аппарат. приводимые в движение за счёт моторов постоянного тока.
Эта модель познакомит с применением поворотных узлов и базовыми принципами конвейерных лент. После завершения сборки модель будет устойчиво стоять на платформе. Приводя в движения моторы — можно заставить модель поворачивать сортировочный узел, а с другим запускать, останавливать и запускать в обратном направлении «конвейерную ленту». С помощью датчиков — робот обнаруживает объекты и способен сортировать их по цвету.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
#include <Wire.h>
#include <Adafruit_TCS34725.h>
// Создание объекта TCS34725 с настройками по умолчанию
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_1X);
const int speedL = 45; // Постоянная скорость для мотора 2
// --- Пины для первого мотора ---
#define encoderPinA A2
#define encoderPinB A3
#define speedPin 5 // PWM для скорости мотора 1
#define dirPin 4 // Направление мотора 1 (LOW: CW, HIGH: CCW)
const int speed = 40; // Обновлённая скорость установлена на 40
// --- Пины для второго мотора ---
#define speedPin2 6 // PWM для скорости мотора 2
#define dirPin2 7 // Направление мотора 2 (LOW: forward)
// --- Константы позиций ---
const long pos_90 = 140; // 90 градусов
const long pos_180 = 290; // 180 градусов
const long pos_270 = 440; // 270 градусов
// --- Переменные для энкодера ---
long encoderPosition = 0;
int lastState = 0;
int lastDirection = 0; // 1: CW, -1: CCW
// --- Управление мотором ---
int phase = 0; // 1: до 90, 2: до 0, 3: до 180, 4: до 0, 5: до 270, 6: до 0, 0: стоп
long target = pos_90; // Начинаем с цели 90 градусов
// --- Переменные для сенсора ---
unsigned long lastPrint = 0;
bool phaseTriggered = false; // Флаг, чтобы не запускать фазу повторно
void setup() {
Serial.begin(9600);
if (tcs.begin()) {
Serial.println("TCS34725 sensor found");
} else {
Serial.println("TCS34725 sensor not found");
}
// Энкодер
pinMode(encoderPinA, INPUT_PULLUP);
pinMode(encoderPinB, INPUT_PULLUP);
// Мотор 1
pinMode(speedPin, OUTPUT);
pinMode(dirPin, OUTPUT);
analogWrite(speedPin, 0); // Остановить мотор
// Мотор 2
pinMode(speedPin2, OUTPUT);
pinMode(dirPin2, OUTPUT);
digitalWrite(dirPin2, HIGH); // CW направление
analogWrite(speedPin2, speedL); // Запустить мотор
// Инициализация энкодера
int a = digitalRead(encoderPinA);
int b = digitalRead(encoderPinB);
lastState = (b << 1) | a;
Serial.println("Старт. Мотор 2 работает. Сенсор определяет цвета и запускает фазы автоматически.");
}
void loop() {
// Обновление энкодера
int a = digitalRead(encoderPinA);
int b = digitalRead(encoderPinB);
int state = (b << 1) | a;
if (state != lastState) {
// Определение направления
if ((lastState == 0 && state == 1) || (lastState == 1 && state == 3) ||
(lastState == 3 && state == 2) || (lastState == 2 && state == 0)) {
encoderPosition++;
lastDirection = 1; // CW
} else if ((lastState == 0 && state == 2) || (lastState == 2 && state == 3) ||
(lastState == 3 && state == 1) || (lastState == 1 && state == 0)) {
encoderPosition--;
lastDirection = -1; // CCW
}
lastState = state;
}
// Расширенная машина состояний
if (phase == 1) { // Фаза 1: Движение к 90 (pos_90)
if (encoderPosition < target) {
// Вращать CW
digitalWrite(dirPin, LOW);
analogWrite(speedPin, speed);
} else {
// Достигли 90, остановить, активировать второй мотор, затем переключить фазу
analogWrite(speedPin, 0);
// Активация второго мотора на 1 секунду между фазой 1 и 2
digitalWrite(dirPin2, HIGH);
analogWrite(speedPin2, speedL);
delay(1000);
analogWrite(speedPin2, 0);
Serial.println("Второй мотор активирован на 1с между фазой 1 и 2.");
phase = 2;
delay(1000);
encoderPosition = target; // Сохраняем вашу логику "прилипания"
target = 0; // Новая цель - 0
Serial.println("Достигли 90. Возвращаемся в 0.");
}
} else if (phase == 2) { // Фаза 2: Возврат в 0, затем стоп и возобновление мотора 2
if (encoderPosition > target) {
// Вращать CCW
digitalWrite(dirPin, HIGH);
analogWrite(speedPin, speed);
} else {
// Достигли 0, остановить, возобновить мотор 2 и ожидать
analogWrite(speedPin, 0);
phase = 0;
delay(1000);
encoderPosition = target;
// Возобновить мотор 2
digitalWrite(dirPin2, HIGH);
analogWrite(speedPin2, speedL);
Serial.println("Фаза 2 завершена. Мотор 2 возобновлен.");
}
} else if (phase == 3) { // Фаза 3: Движение к 180 (pos_180)
if (encoderPosition < target) {
// Вращать CW
digitalWrite(dirPin, LOW);
analogWrite(speedPin, speed);
} else {
// Достигли 180, остановить, активировать второй мотор, затем переключить фазу
analogWrite(speedPin, 0);
// Активация второго мотора на 1 секунду между фазой 3 и 4
digitalWrite(dirPin2, HIGH);
analogWrite(speedPin2, speedL);
delay(1000);
analogWrite(speedPin2, 0);
Serial.println("Второй мотор активирован на 1с между фазой 3 и 4.");
phase = 4;
delay(1000);
encoderPosition = target;
target = 0; // Новая цель - 0
Serial.println("Достигли 180. Возвращаемся в 0.");
}
} else if (phase == 4) { // Фаза 4: Возврат в 0, затем стоп и возобновление мотора 2
if (encoderPosition > target) {
// Вращать CCW
digitalWrite(dirPin, HIGH);
analogWrite(speedPin, speed);
} else {
// Достигли 0, остановить, возобновить мотор 2 и ожидать
analogWrite(speedPin, 0);
phase = 0;
delay(1000);
encoderPosition = target;
// Возобновить мотор 2
digitalWrite(dirPin2, HIGH);
analogWrite(speedPin2, speedL);
Serial.println("Фаза 4 завершена. Мотор 2 возобновлен.");
}
} else if (phase == 5) { // Фаза 5: Движение к 270 (pos_270)
if (encoderPosition < target) {
// Вращать CW
digitalWrite(dirPin, LOW);
analogWrite(speedPin, speed);
} else {
// Достигли 270, остановить, активировать второй мотор, затем переключить фазу
analogWrite(speedPin, 0);
// Активация второго мотора на 1 секунду между фазой 5 и 6
digitalWrite(dirPin2, HIGH);
analogWrite(speedPin2, speedL);
delay(1000);
analogWrite(speedPin2, 0);
Serial.println("Второй мотор активирован на 1с между фазой 5 и 6.");
phase = 6;
delay(1000);
encoderPosition = target;
target = 0; // Новая цель - 0
Serial.println("Достигли 270. Возвращаемся в 0.");
}
} else if (phase == 6) { // Фаза 6: Финальный возврат в 0, затем стоп и возобновление мотора 2
if (encoderPosition > target) {
// Вращать CCW
digitalWrite(dirPin, HIGH);
analogWrite(speedPin, speed);
} else {
// Достигли 0, остановить, стоп фазы и возобновить мотор 2
analogWrite(speedPin, 0);
phase = 0; // Конец цикла
delay(1000);
encoderPosition = target;
// Возобновить мотор 2
digitalWrite(dirPin2, HIGH);
analogWrite(speedPin2, speedL);
Serial.println("Остановились в 0 после фазы 6. Алгоритм завершен. Мотор 2 возобновлен.");
}
} else if (phase == 0) {
// Фаза 0: Цикл завершен, мотор 2 работает, сбросить флаг
phaseTriggered = false;
}
// Логика сенсора - только если фаза завершена (phase == 0)
if (phase == 0) {
uint16_t clear, red, green, blue;
tcs.getRawData(&red, &green, &blue, &clear);
unsigned long now = millis();
if (now - lastPrint > 100) {
Serial.print("Red: ");
Serial.print(red);
Serial.print(", Green: ");
Serial.print(green);
Serial.print(", Blue: ");
Serial.print(blue);
Serial.print(", Clear: ");
Serial.print(clear);
Serial.print(", Color: ");
bool colorDetected = false;
if (clear > 40) {
if (red > 13 && green > 15 && blue > 12) {
Serial.println("БЕЛЫЙ");
colorDetected = true;
if (!phaseTriggered) {
phase = 5;
target = pos_270;
analogWrite(speedPin2, 0); // Остановить мотор 2
phaseTriggered = true;
Serial.println("Фаза 5 запущена по цвету БЕЛЫЙ.");
}
} else if (green > 18) {
Serial.println("Зеленый");
colorDetected = true;
if (!phaseTriggered) {
phase = 3;
target = pos_180;
analogWrite(speedPin2, 0); // Остановить мотор 2
phaseTriggered = true;
Serial.println("Фаза 3 запущена по цвету Зеленый.");
}
} else if (red > 19) {
Serial.println("КРАСНЫЙ");
colorDetected = true;
if (!phaseTriggered) {
phase = 1;
target = pos_90;
analogWrite(speedPin2, 0); // Остановить мотор 2
phaseTriggered = true;
Serial.println("Фаза 1 запущена по цвету КРАСНЫЙ.");
}
}
}
if (!colorDetected) {
Serial.println("СИНИЙ");
}
lastPrint = now;
}
}
// delay(10); // Короткая пауза для стабильности
}Пример рабочей программы на графическом языке:

Внимание:
Блоки «если выполнить» и «иначе если» включают части 1-3. Часть 1:

Часть 2 (продолжение):

Часть 3 (заключение):





Внимание:
Блок «выполнить если» включает части 1-2. Часть 1:
Часть 2 (заключение):

![]()

Все примеры кода в электронном виде можно скачать по ссылке
5.9 Модель «Дифференциальная машинка с захватом»

Дифференциальная машинка с захватом
Цель:
Сформировать навыки сборки, программирования и эксплуатации дифференциальной машинки с захватом, позволяющей двигаться по линии, распознавать и захватывать предметы с помощью моторов, сервомоторов, датчиков линии и цвета, а также использовать рычажные механизмы для регулировки положения и фиксации объектов.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Сервомотор большой − 1 шт.
- Сервомотор малый − 1 шт.
- Двигатель постоянного тока − 2 шт.
- Конструктивные элементы.
- Модуль «Датчик линии» − 2 шт.
- Модуль «Датчик цвета» − 1 шт.
Данная модель представляет из себя транспортёр с манипулятором(это механическая рука), приводимые в движение за счёт двигателей постоянного тока, и сервомоторами.
Эта модель познакомит с применением сразу двух сложных систем: управляема платформа и манипулятор. После завершения сборки модель будет устойчиво стоять на двух колёсах и двух шаровых опорах. Приводя в движения тот или иной мотор — можно заставить модель двигаться вперёд, назад или поворачиваться. С помощью сервомоторов — можно изменять высоту и степень захвата манипулятора. Робот оснащён датчиками линии и цвета. Таким образом, робот может определять цвета объекта который он захватил, и двигаться по линии.
В дифференциальной машинке с захватом рычажные механизмы используются как в конструкции манипулятора, так и в самом захвате. В манипуляторе они отвечают за изменение положения и угла наклона, что даёт возможность регулировать высоту и ориентацию захвата относительно объекта. В захвате рычажный механизм обеспечивает фиксацию предмета за счёт его сжатия, позволяя надёжно удерживать объект во время перемещения.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TCS34725.h>
#include <Servo.h>
// --- Пины устройств ---
// Моторы постоянного тока
const int dir_pin_M1 = 7; // Направление мотора 1
const int speed_pin_M1 = 6; // ШИМ скорость мотора 1
const int dir_pin_M2 = 4; // Направление мотора 2
const int speed_pin_M2 = 5; // ШИМ скорость мотора 2
// Датчики линии (аналоговые)
const int line_sensor_L = A0; // Левый датчик
const int line_sensor_R = A1; // Правый датчик
// Сервоприводы
const int servo_grab_pin = 10; // Маленький серво (клешня)
const int servo_lift_pin = 9; // Большой серво (подъем)
// --- Объекты классов ---
// Инициализация датчика цвета с настройками (время интеграции и усиление)
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
Servo servo_grab; // Объект для серво клешни
Servo servo_lift; // Объект для серво подъема
// --- Настройки и переменные ---
int base_speed = 50; // Базовая скорость движения (0-255)
int turn_speed = 30; // Скорость внешнего колеса при повороте
int turn_slow_speed = 50; // Скорость внутреннего колеса при повороте
int threshold = 500;
// Порог срабатывания датчиков линии (ОБЯЗАТЕЛЬНО НАСТРОЙТЕ!)
// Переменные для хранения цвета. Тип uint16_t, т.к. значения могут быть большими
uint16_t red_val, green_val, blue_val, clear_val;
void setup() {
Serial.begin(9600);
// Инициализация датчика цвета
if (tcs.begin()) {
Serial.println("Датчик цвета TCS34725 найден!");
} else {
Serial.println("Датчик цвета TCS34725 не найден ... зависание.");
while (1); // Если датчик не найден, останавливаем программу
}
// Настройка пинов моторов
pinMode(dir_pin_M1, OUTPUT);
pinMode(speed_pin_M1, OUTPUT);
pinMode(dir_pin_M2, OUTPUT);
pinMode(speed_pin_M2, OUTPUT);
// Присоединение сервоприводов
servo_grab.attach(servo_grab_pin);
servo_lift.attach(servo_lift_pin);
// Начальное положение серво
servo_grab.write(0); // Клешня открыта
servo_lift.write(90); // Подъемник опущен
delay(1000);
}
void loop() {
int left_sensor_val = analogRead(line_sensor_L);
int right_sensor_val = analogRead(line_sensor_R);
bool left_on_line = left_sensor_val > threshold;
bool right_on_line = right_sensor_val > threshold;
// --- Логика движения ---
if (left_on_line && right_on_line) {
move_forward(base_speed);
} else if (left_on_line && !right_on_line) {
turn_left_smooth();
} else if (!left_on_line && right_on_line) {
turn_right_smooth();
} else {
stop_motors();
grab_and_sense_procedure();
while (true) {} // Остановка после выполнения задачи
}
}
// --- Функции управления движением ---
void move_forward(int speed) {
digitalWrite(dir_pin_M1, HIGH);
digitalWrite(dir_pin_M2, LOW);
analogWrite(speed_pin_M1, speed);
analogWrite(speed_pin_M2, speed);
}
void turn_left_smooth() {
digitalWrite(dir_pin_M1, HIGH);
digitalWrite(dir_pin_M2, LOW);
analogWrite(speed_pin_M1, turn_speed);
analogWrite(speed_pin_M2, turn_slow_speed);
}
void turn_right_smooth() {
digitalWrite(dir_pin_M1, HIGH);
digitalWrite(dir_pin_M2, LOW);
analogWrite(speed_pin_M1, turn_slow_speed);
analogWrite(speed_pin_M2, turn_speed);
}
void stop_motors() {
analogWrite(speed_pin_M1, 0);
analogWrite(speed_pin_M2, 0);
}
// --- Процедура захвата и определения цвета ---
void grab_and_sense_procedure() {
delay(500);
servo_grab.write(45); // Подобрать угол для захвата
delay(1000);
servo_lift.write(125); // Подобрать угол для подъема
delay(1000);
// Определяем цвет
read_color();
Serial.print("R: "); Serial.print(red_val);
Serial.print(" G: "); Serial.print(green_val);
Serial.print(" B: "); Serial.println(blue_val);
// Логика определения цвета: ищем НАИБОЛЬШЕЕ значение
if (red_val > green_val && red_val > blue_val) {
Serial.println("Цвет: КРАСНЫЙ");
} else if (green_val > red_val && green_val > blue_val) {
Serial.println("Цвет: ЗЕЛЕНЫЙ");
} else if (blue_val > red_val && blue_val > green_val) {
Serial.println("Цвет: СИНИЙ");
} else {
Serial.println("Цвет не определен");
}
delay(2000);
// Кладем коробку обратно
servo_lift.write(90);
delay(1000);
servo_grab.write(0);
delay(1000);
}
// --- Новая функция для считывания цвета с tcs34725 ---
void read_color() {
// Выключаем светодиод датчика, если он есть, чтобы не мешал
tcs.setInterrupt(false);
delay(60); // Даем время для измерения (чуть больше времени интеграции 50ms)
// Считываем сырые данные
tcs.getRawData(&red_val, &green_val, &blue_val, &clear_val);
// Включаем светодиод обратно
tcs.setInterrupt(true);
}Пример рабочей программы на графическом языке:



Внимание:
Блоки «если» и «иначе если» включают части 1-2. Часть 1:

Часть 2 (заключение):



Все примеры кода в электронном виде можно скачать по ссылке
5.10 Модель «Гусеничный танк с захватом»

Гусеничный танк с захватом
Цель:
Сформировать навыки проектирования, сборки и программирования гусеничного робота с манипулятором для движения по линии, распознавания и захвата предметов с помощью моторов, сервоприводов и датчиков.
Состав и описание модели
- Блок-контроллер ЭДУино − 1 шт.
- Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
- Сервомотор большой − 1 шт.
- Сервомотор малый − 1 шт.
- Двигатель постоянного тока − 2 шт.
- Конструктивные элементы
- Модуль «Датчик линии» − 2 шт.
- Модуль «Датчик цвета» − 1 шт.
Данная модель представляет из себя транспортёр с манипулятором (это механическая рука), приводимые в движение за счёт двигателей постоянного тока, и сервомоторами.
Эта модель познакомит с применением сразу двух сложных систем: управляема платформа и манипулятор. После завершения сборки модель будет устойчиво стоять гусеницах. Приводя в движения тот или иной мотор — можно заставить модель двигаться вперёд, назад или поворачиваться. С помощью сервомоторов — можно изменять высоту и степень захвата манипулятора. Робот оснащён датчиками линии и цвета. Таким образом, робот может определять цвета объекта, который он захватил, и двигаться по линии.
В гусеничном танке с хваталкой рычажный механизм применяется в манипуляторе для изменения положения и наклона, что позволяет регулировать высоту и угол захвата предмета. В конструкции самого захвата он используется для фиксации объекта за счёт его сжатия, обеспечивая удержание предмета при движении и выполнении манипуляций.
Подключение компонентов

Схема расположения электронных компонентов

Схема подключения
Пример рабочей программы:
cpp
#include <Servo.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TCS34725.h>
// --- Пины для моторов ---
const int dir_pin_M1 = 7; // Направление правого мотора
const int speed_pin_M1 = 6; // ШИМ скорость правого мотора
const int dir_pin_M2 = 12; // Направление левого мотора
const int speed_pin_M2 = 11; // ШИМ скорость левого мотора
// --- Пины для датчиков линии ---
const int left_sensor_pin = A0;
const int right_sensor_pin = A1;
// --- Пины для сервоприводов ---
const int big_servo_pin = 9;
const int small_servo_pin = 10;
// --- Объекты ---
Servo bigServo;
Servo smallServo;
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
// --- Настройки ---
int base_speed = 50; // Базовая скорость движения
int turn_speed = 30; // Скорость для плавного поворота
int threshold = 500; // Порог для датчиков линии
void setup() {
// Инициализация Serial Monitor
Serial.begin(9600);
// Настройка пинов моторов
pinMode(dir_pin_M1, OUTPUT);
pinMode(speed_pin_M1, OUTPUT);
pinMode(dir_pin_M2, OUTPUT);
pinMode(speed_pin_M2, OUTPUT);
// Настройка пинов датчиков линии
pinMode(left_sensor_pin, INPUT);
pinMode(right_sensor_pin, INPUT);
// Присоединение сервоприводов
bigServo.attach(big_servo_pin);
smallServo.attach(small_servo_pin);
// Инициализация датчика цвета
if (tcs.begin()) {
Serial.println("Датчик цвета TCS34725 найден!");
} else {
Serial.println("Датчик цвета TCS34725 не найден... Проверьте подключение.");
while (1); // Остановка программы, если датчик не найден
}
// Начальное положение сервоприводов
smallServo.write(90); // Клешня открыта
bigServo.write(0); // Механизм опущен
delay(1000);
}
void loop() {
int left_sensor_val = analogRead(left_sensor_pin);
int right_sensor_val = analogRead(right_sensor_pin);
bool left_on_line = left_sensor_val > threshold;
bool right_on_line = right_sensor_val > threshold;
// 1. Движение по линии
if (left_on_line && right_on_line) {
moveForward(base_speed);
} else if (!left_on_line && right_on_line) {
turnLeft(turn_speed, base_speed);
} else if (left_on_line && !right_on_line) {
turnRight(base_speed, turn_speed);
} else {
// 2. Оба датчика не видят линию -> останавливаемся и выполняем действия
stopMotors();
handleBox();
delay(2000);
}
}
// --- Функции управления движением ---
void moveForward(int speed) {
digitalWrite(dir_pin_M1, HIGH);
digitalWrite(dir_pin_M2, LOW);
analogWrite(speed_pin_M1, speed);
analogWrite(speed_pin_M2, speed);
}
void moveBackward(int speed) {
digitalWrite(dir_pin_M1, LOW);
digitalWrite(dir_pin_M2, HIGH);
analogWrite(speed_pin_M1, speed);
analogWrite(speed_pin_M2, speed);
}
void turnLeft(int leftSpeed, int rightSpeed) {
digitalWrite(dir_pin_M1, HIGH);
digitalWrite(dir_pin_M2, LOW);
analogWrite(speed_pin_M1, rightSpeed);
analogWrite(speed_pin_M2, leftSpeed);
}
void turnRight(int leftSpeed, int rightSpeed) {
digitalWrite(dir_pin_M1, HIGH);
digitalWrite(dir_pin_M2, LOW);
analogWrite(speed_pin_M1, rightSpeed);
analogWrite(speed_pin_M2, leftSpeed);
}
void rotateOnAxis(int speed) {
digitalWrite(dir_pin_M1, LOW);
digitalWrite(dir_pin_M2, LOW);
analogWrite(speed_pin_M1, speed);
analogWrite(speed_pin_M2, speed);
}
void stopMotors() {
analogWrite(speed_pin_M1, 0);
analogWrite(speed_pin_M2, 0);
}
// --- Функция для работы с коробкой ---
void handleBox() {
Serial.println("Линия потеряна. Начинаю работу с коробкой...");
delay(500);
// 1. Схватить коробку
smallServo.write(0); // Закрыть клешню
delay(1000);
// 2. Поднять коробку
bigServo.write(90); // Поднять
delay(1000);
// 3. Узнать цвет и сохранить результат
char detectedColor = getColor();
// 4. ВЫПОЛНИТЬ ДЕЙСТВИЕ В ЗАВИСИМОСТИ ОТ ЦВЕТА
switch (detectedColor) {
case 'R': // Красный цвет
Serial.println("Действие: еду назад 2 секунды.");
moveBackward(base_speed);
delay(2000);
stopMotors();
break;
case 'G': // Зеленый цвет
Serial.println("Действие: вращаюсь на месте.");
rotateOnAxis(base_speed);
delay(2000);
stopMotors();
break;
case 'B': // Синий цвет
Serial.println("Действие: поворот налево, затем направо.");
turnLeft(0, base_speed); // Резкий поворот налево
delay(2000);
turnRight(base_speed, 0); // Резкий поворот направо
delay(2000);
stopMotors();
break;
default:
Serial.println("Нет специального действия для этого цвета.");
// Ничего не делаем
break;
}
delay(1000); // Пауза после маневра
// 5. Опустить коробку
bigServo.write(0); // Опустить
delay(1000);
// 6. Отпустить коробку
smallServo.write(90); // Открыть клешню
delay(1000);
Serial.println("Работа с коробкой завершена.");
}
char getColor() {
uint16_t r, g, b, c;
// Даем датчику немного времени на "успокоение" для стабильных показаний
tcs.setInterrupt(false); // Включаем светодиод датчика
delay(60); // Ждем стабилизации
tcs.getRawData(&r, &g, &b, &c);
tcs.setInterrupt(true); // Выключаем светодиод
Serial.print("R: "); Serial.print(r);
Serial.print(" G: "); Serial.print(g);
Serial.print(" B: "); Serial.print(b);
Serial.print(" C: "); Serial.println(c);
// Минимальная яркость, чтобы отсечь случайные показания в пустоте
if (c < 100) {
Serial.println("Цвет не определен (слишком темно)");
return 'U';
}
// 1. Проверяем, является ли КРАСНЫЙ доминирующим
if (r > g && r > b) {
Serial.println("Обнаружен цвет: КРАСНЫЙ");
return 'R';
}
// 2. Проверяем, является ли ЗЕЛЕНЫЙ доминирующим
// Для вашего "синего" объекта, который кажется зеленым, добавим проверку:
// если зеленый доминирует, но синий тоже очень близок, считаем это синим.
if (g > r && g > b) {
// Это специальная проверка для вашего случая, где синий отражает много зеленого.
// Если разница между G и B не очень большая, скорее всего это синий.
// Подберите значение "20" под себя.
if (g - b < 20) {
Serial.println("Обнаружен цвет: СИНИЙ (по скорректированной логике)");
return 'B';
} else {
Serial.println("Обнаружен цвет: ЗЕЛЕНЫЙ");
return 'G';
}
}
// 3. Проверяем, является ли СИНИЙ доминирующим
if (b > r && b > g) {
Serial.println("Обнаружен цвет: СИНИЙ");
return 'B';
}
// Если ни один цвет не доминирует (например, они равны), цвет не определен
Serial.println("Цвет не определен (слишком смешанный)");
return 'U';
}Пример рабочей программы на графическом языке:






Все примеры кода в электронном виде можно скачать по ссылке