Skip to content

Глава 5 Практическая часть ​

5.1 Модель «Мотоцикл» ​

p901

Мотоцикл

Цель:

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

Состав и описание модели

  1. Блок-контроллер ЭДУино.
  2. Аккумуляторный иодуль PowerBank 9V 3A.
  3. Двигатель постоянного тока − 2 шт.
  4. Конструктивные элементы.
  5. Модуль «Ультразвуковой дальномер» − 1 шт.
  6. Модуль «Датчик линии» − 2 шт.

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

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

Для модели используется зубчатая передача с соотношением 40/24/24.

Вращение от вала мотора сначала передаётся на зубчатое колесо с 40 зубьями. Оно входит в зацепление с колесом на 24 зуба, за счёт чего скорость вращения увеличивается, а крутящий момент уменьшается примерно в 40/24, то есть в 5/3 раза. При этом направление вращения изменяется на противоположное.

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

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

Подключение компонентов

image92

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

image931

Схема подключения

Пример рабочей программы:

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;
}

Пример рабочей программы на графическом языке:

new94

new95

new96_97

new96_971

new98

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

5.2 Модель «Змея» ​

p103

Змея

Цель:

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

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Двигатель постоянного тока − 1 шт.
  4. Сервомотор большой − 1 шт.
  5. Сервомотор малый − 1 шт.
  6. Конструктивные элементы.
  7. Модуль «Ультразвуковой дальномер» − 1 шт.

Данная модель представляет из себя Serpent-­Robot (робот змея). приводимый в движение за счёт сервомоторов и мотора постоянного тока.

Эта модель познакомит с применением рычагов, поворотных механизмов, зубчатых передач. После завершения сборки модель будет устойчиво стоять на платформах и опираться на гусеничную платформу. Приводя в движения мотор — можно задать модели направление движения вперёд либо назад. Изменяя положение малого сервомотора — можно изменять траекторию движения робота влево или вправо. Ультразвуковой датчик позволяет фиксировать препятствия перед роботом. Большой сервомотор позволяет изменять положение датчика и имитировать атаку.

Для модели «Змея» используется зубчатая передача с соотношением 40 / 40.

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

При этом направление вращения выходного вала становится противоположным направлению вращения мотора. Такая передача применяется в модели «Змея» для изменения направления движения без изменения его скорости и силы вращения.

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

Подключение компонентов

image100

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

image101

Схема подключения

Пример рабочей программы:

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);
}

Пример рабочей программы на графическом языке:

new102

new103

new104

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

5.3 Модель «Шагающий робот» ​

p113

Шагающий робот

Цель:

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

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Двигатель постоянного тока − 2 шт.
  4. Конструктивные элементы.

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

Эта модель познакомит с применением рычагов. После завершения сборки модель будет устойчиво стоять на 6-ти лапах. Приводя в движения тот или иной мотор — можно заставить модель двигаться вперёд, назад или поворачиваться.

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

Подключение компонентов

image106

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

image107

Схема подключения

Пример рабочей программы:

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);
}

Пример рабочей программы на графическом языке:

new112

new108

new110

new109

new111

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

5.4 Модель «Шагоход ОТТО» ​

p119

Шагоход ОТТО

Цель:

Сформировать навыки сборки, программирования и управления шагающим роботом типа «ОТТО», позволяющего перемещаться и изменять направление движения с помощью моторов постоянного тока, зубчатых передач и рычажно-­поступательных механизмов.

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Двигатель постоянного тока − 1 шт.
  4. Конструктивные элементы.

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

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

В шагоходе типа 1 (ОТТО), используется зубчатая передача с соотношением 24 / 24.

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

При этом направление вращения выходного вала становится противоположным направлению вращения мотора. Такая передача применяется в данной модели для изменения направления движения механизма без изменения его скорости и силы вращения.

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

Подключение компонентов

image114

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

image115

Схема подключения

Пример рабочей программы:

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);     // Остановка второго мотора
}

Пример рабочей программы на графическом языке:

OTTO_(1)

OTTO_(2)

OTTO_(3)

OTTO_(4)

OTTO_(5)

OTTO_(6)

OTTO_(7)

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

5.5 Модель «Дифференциальная машинка для линии» ​

p127

Дифференциальная машинка для линии

Цель:

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

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Двигатель постоянного тока − 2 шт.
  4. Конструктивные элементы.
  5. Модуль «Ультразвуковой дальномер» − 1 шт.
  6. Модуль «Датчик линии» − 2 шт.

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

Эта модель познакомит с применением датчиков линии. После завершения сборки модель будет устойчиво стоять на колёсах и шаровой опоре. Приводя в движения моторы — можно заставить модель поворачиваться и менять направление движения. Оснащённые датчики линии — позволяют детектировать линию. А установочный ультразвуковой датчик — объезжать препятствия.

Подключение компонентов

image120

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

image121

Схема подключения

Пример рабочей программы:

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;
}

Пример рабочей программы на графическом языке:

new122

new123-124

new123-1241

new125_1

new125_2

new125_3

new126_1

new126_2

new126_3

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

5.6 Модель «Турель» ​

p140

Турель

Цель:

Сформировать навыки сборки, программирования и управления моделью «Турель» для поворота платформы и выполнения выстрела с помощью мотора, сервомотора и рычажно-­возвратно-поступательного механизма.

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Двигатель постоянного тока − 1 шт.
  4. Сервомотор большой − 1 шт.
  5. Конструктивные элементы.
  6. Модуль «Ультразвуковой дальномер» − 1 шт.

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

Эта модель познакомит с применением рычагов, поворотных столов, возвратно-­поступательных механизмами. После завершения сборки модель будет устойчиво стоять на платформе. Приводя в движения мотор — можно заставить модель поворачиваться. С помощью сервомотора — можно производить «выстрел».

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

Подключение компонентов

image128

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

image129

Схема подключения

Пример рабочей программы:

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 мс
}

Пример рабочей программы на графическом языке:

new130

new131

new132

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

5.7 Модель «Манипулятор» ​

p81-1501

Манипулятор

Цель:

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

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Сервомотор большой − 1 шт.
  4. Сервомотор малый − 1 шт.
  5. Двигатель постоянного тока − 1 шт.
  6. Конструктивные элементы.

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

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

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

Подключение компонентов

image133

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

image134

Схема подключения

Пример рабочей программы:

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; // Устанавливаем флаг, чтобы цикл не повторялся
    }
}

Пример рабочей программы на графическом языке:

new5.7-01

new5.7-02_01

new5.7-02_02

new135-136

new135-1361

new137

Внимание:

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

new138

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

new1381

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

new1382

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

new1383

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

new1384

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

new1385

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

5.8 Модель «Конвейер — Сортировщик» ​

p167

Конвейер — Сортировщик

Цель:

Сформировать у обучающихся навыки сборки, программирования и эксплуатации модели «Конвейер-­Сортировщик», включающей конвейерную ленту и поворотный сортировочный узел, научить управлять моторами постоянного тока для запуска, остановки и изменения направления движения ленты, регулировать положение сортировочного механизма, а также использовать датчики цвета и ультразвуковой датчик для обнаружения, распознавания и сортировки объектов, развивать понимание принципов работы конвейерных систем, поворотных узлов и базовых механизмов автоматизации.

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Двигатель постоянного тока − 2 шт.
  4. Конструктивные элементы.
  5. Модуль «Датчик цвета» − 1 шт.
  6. Модуль «Ультразвуковой дальномер» − 1 шт.

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

Эта модель познакомит с применением поворотных узлов и базовыми принципами конвейерных лент. После завершения сборки модель будет устойчиво стоять на платформе. Приводя в движения моторы — можно заставить модель поворачивать сортировочный узел, а с другим запускать, останавливать и запускать в обратном направлении «конвейерную ленту». С помощью датчиков — робот обнаруживает объекты и способен сортировать их по цвету.

Подключение компонентов

image141

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

image142

Схема подключения

Пример рабочей программы:

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); // Короткая пауза для стабильности
}

Пример рабочей программы на графическом языке:

new143

Внимание:

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

new144_1

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

new144_2

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

new144_3

new145

new146-147

new148-149

new150

Внимание:

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

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

new151

new1511

new152

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

5.9 Модель «Дифференциальная машинка с захватом» ​

p186

Дифференциальная машинка с захватом

Цель:

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

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Сервомотор большой − 1 шт.
  4. Сервомотор малый − 1 шт.
  5. Двигатель постоянного тока − 2 шт.
  6. Конструктивные элементы.
  7. Модуль «Датчик линии» − 2 шт.
  8. Модуль «Датчик цвета» − 1 шт.

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

Эта модель познакомит с применением сразу двух сложных систем: управляема платформа и манипулятор. После завершения сборки модель будет устойчиво стоять на двух колёсах и двух шаровых опорах. Приводя в движения тот или иной мотор — можно заставить модель двигаться вперёд, назад или поворачиваться. С помощью сервомоторов — можно изменять высоту и степень захвата манипулятора. Робот оснащён датчиками линии и цвета. Таким образом, робот может определять цвета объекта который он захватил, и двигаться по линии.

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

Подключение компонентов

image154

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

image155

Схема подключения

Пример рабочей программы:

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);
}

Пример рабочей программы на графическом языке:

new156_157

new156_1571

new158

Внимание:

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

new159

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

new1591

new1592

new161

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

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

p200

Гусеничный танк с захватом

Цель:

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

Состав и описание модели

  1. Блок-контроллер ЭДУино − 1 шт.
  2. Аккумуляторный модуль PowerBank 9V 3A − 1 шт.
  3. Сервомотор большой − 1 шт.
  4. Сервомотор малый − 1 шт.
  5. Двигатель постоянного тока − 2 шт.
  6. Конструктивные элементы
  7. Модуль «Датчик линии» − 2 шт.
  8. Модуль «Датчик цвета» − 1 шт.

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

Эта модель познакомит с применением сразу двух сложных систем: управляема платформа и манипулятор. После завершения сборки модель будет устойчиво стоять гусеницах. Приводя в движения тот или иной мотор — можно заставить модель двигаться вперёд, назад или поворачиваться. С помощью сервомоторов — можно изменять высоту и степень захвата манипулятора. Робот оснащён датчиками линии и цвета. Таким образом, робот может определять цвета объекта, который он захватил, и двигаться по линии.

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

Подключение компонентов

image166

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

image167

Схема подключения

Пример рабочей программы:

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';
}

Пример рабочей программы на графическом языке:

new168_169

new168_1691

new170_171

new170_1711

new172

new173

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