Skip to content

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

2.1. Светодиод ​

Цель: ​

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

Оборудование: ​

  • светодиод;

  • резистор 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

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

Длинная ножка светодиода — это анод (плюс +). К ней подключают положительный полюс источника питания. Короткая – катод (минус -). К ней подключают отрицательный полюс (землю/GND), поэтому важно соблюдать полярность.

Если ножки светодиода уже обрезаны под один размер, можно определить стороны по другим признакам:

  1. Срез на корпусе**.** Если посмотреть на круглую пластиковую колбу светодиода сверху, с одной стороны у нее будет плоский срез. Этот срез всегда указывает на катод (минус).

  2. Внутренние контакты**.** Если колба прозрачная, смотрим внутрь на свет. Маленький внутренний флажок — это анод (+), а большой и широкий (похожий на флаг или чашу) — это катод (-).

Анод подключается к цифровому выводу, а катод через резистор к выводу GND.

Пины **(****порты)** — это ножки (выводы) на плате, через которые она взаимодействует с внешними устройствами: кнопками, светодиодами, датчиками и т.д.

Пины бывают двух типов:

  1. Цифровые пины (Digital pins**)**.

Обозначаются как D0, D1, D2... или просто (0, 1, 2, и тд**),** могут быть только в двух состояниях:

HIGH (вкл = 1 = 5В)

LOW (выкл = 0 = 0В)

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

Пример:

digitalWrite(13, HIGH); // включить светодиод на пин 13
  1. Аналоговые пины (Analog pins).

Обозначаются как A0, A1, A2… A5 и используются для приема аналогового напряжения в диапазоне от 0В до 5В.

Значение считывается функцией analogRead**(**), и возвращается число от 0 до 1023.

Подходят для подключения датчиков: температуры, освещенности, потенциометров и т.п.

Пример:

cpp
int value = analogRead(A0); // получить значение с датчика, подключенного к A0

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

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

image33

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

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

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

cpp
// объявление переменной pin и запись значения номера пина,
// работающего на выход
int pin = 12;

void setup() {
  // настройка пина на режим выхода
  pinMode(pin, OUTPUT);
}

void loop() {
  // передача на пин логической «1», рабочее напряжение 5В
  digitalWrite(pin, HIGH);
  // задержка микроконтроллера в этом состоянии на 100 мс
  delay(100);
  // передача на пин логического «0», приравнивание к земле
  digitalWrite(pin, LOW);
  // задержка микроконтроллера в этом состоянии на 900 мс
  delay(900);
}

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

image34

Микроконтроллер позволяет воспользоваться уже встроенным в плату светодиодом. На контроллере ЭДУино имеется один пользовательский встроенный светодиод, обозначенный буквой «L». В коде идет обращение к нему, он аппаратно подключен к 13 пину.

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

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

cpp
// объявление переменной pin и запись значения номера пина,
// работающего на выход (используем 13 пин для встроенного светодиода)
int pin = 13;

void setup() {
  // настройка пина на режим выхода
  pinMode(pin, OUTPUT);
}

void loop() {
  // передача на пин логической «1», рабочее напряжение 5В
  digitalWrite(pin, HIGH);
  // задержка микроконтроллера в этом состоянии на 100 мс
  delay(100);
  // передача на пин логического «0», приравнивание к земле
  digitalWrite(pin, LOW);
  // задержка микроконтроллера в этом состоянии на 900 мс
  delay(900);
}

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

image35

Контрольные вопросы ​

  1. Чем отличаются анод и катод светодиода и как определить их по выводам?

  2. Зачем в цепь со светодиодом ставят резистор и что произойдет без него?

  3. Какие состояния может принимать цифровой пин и каким командам они соответствуют?

  4. Чем цифровой пин отличается от аналогового?

2.2. Управление яркостью светодиода ​

Цель: ​

Освоить принцип работы широтно-импульсной модуляции (ШИМ) и научиться управлять яркостью светодиода.

Оборудование: ​

  • светодиод;

  • резистор 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

Широтно-импульсная модуляция (ШИМ) — это метод формирования выходного сигнала, при котором микроконтроллер, не способный генерировать произвольное напряжение в диапазоне от 0В до 5В, вместо этого выдает последовательность прямоугольных импульсов фиксированной амплитуды (5В) с переменной длительностью. Промежуточное напряжение, например 2 вольта, он выдать не может. При этом светодиод, подключенный к ЭДУино, может гореть не в полную силу. Для этого контроллер очень быстро включает и выключает напряжение на выводе, несколько сотен раз в секунду. Каждый импульс имеет одну и ту же высоту, 5 В, а меняется только его длительность. Глаз не различает отдельные переключения и воспринимает среднее значение: чем дольше в каждом цикле держится «включено», тем ярче светит светодиод. Моторы тоже не успевают отреагировать на каждый отдельный импульс, поэтому вращаются медленнее или быстрее. Долю времени, пока сигнал включен, называют коэффициентом заполнения и записывают в процентах. Рассчитаем среднее напряжение. При коэффициенте заполнения 50 % сигнал половину времени равен 5 В, половину времени нулю, в среднем получается 2,5 В. При 100 % на выводе постоянно 5 В, при 0 % напряжения нет.

image36

image37

В среде Arduino за ШИМ отвечает функция analogWrite**(**pin**,** value**)**, которая инициирует генерацию ШИМ-сигнала на заданном выводе с указанной шириной импульса (значение от 0 до 255 пропорционально коэффициенту заполнения); сгенерированный сигнал сохраняется на выходе до следующего вызова analogWrite или до сброса пина в цифровой режим.

Первым указываем номер вывода, вторым значение от 0 до 255. Ноль означает «всегда выключено», 255 означает «всегда включено», промежуточные числа дают пропорциональное заполнение.

Переведем число в вольты по пропорции: 255 соответствует 5 В, значит, значение 85 дает 5 × 85 / 255 ≈ 1,67 В.

ШИМ работает не на всех выводах, а только на отмеченных значком «~». Поэтому используем вывод 9.

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

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

image38

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

Разработаем программу, которая управляет яркостью светодиода.

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

cpp
// объявление переменной pin, и запись значения номера пина,
// работающего на выход (ВАЖНО: используем пин 9, так как он поддерживает ШИМ)
int pin = 9;

void setup() {
  // настройка пин на режим выхода
  pinMode(pin, OUTPUT);
}

void loop() {
  // выдача неполного напряжения на светодиод (ШИМ сигнал)
  // 85/255 = 1/3 * 5В = 1.66 В
  analogWrite(pin, 85);
  // задержка микроконтроллера в этом состоянии на 300 мс
  delay(300);

  // 170/255 = 2/3 * 5В = 3.33 В
  analogWrite(pin, 170);
  // задержка микроконтроллера в этом состоянии на 300 мс
  delay(300);

  // 5В - полное напряжение
  analogWrite(pin, 255);
  // задержка микроконтроллера в этом состоянии на 300 мс
  delay(300);
}

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

image39

Контрольные вопросы ​

  1. Что такое широтно-импульсная модуляция и как она регулирует яркость?

  2. В каком диапазоне задается значение в функции analogWrite()?

  3. Почему для ШИМ подходят не все пины контроллера?

2.3. Управление потенциометром ​

Цель: ​

Освоить функцию analogRead**(**) для считывания сигнала с потенциометра, научиться переводить полученные значения (0–1023) в диапазон ШИМ (0–255) и управлять яркостью светодиода через analogWrite**(**).

Оборудование: ​

  • светодиод;

  • резистор 220 Ом;

  • потенциометр;

  • макетная плата;

  • блок-контроллер ЭДУино.

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

Источником напряжения будет потенциометр, то есть резистор с поворотной ручкой. Два крайних вывода потенциометра подключаются к 5 В и к GND, а средний вывод соединен с подвижным контактом. При повороте ручки контакт перемещается по резистивному слою, и напряжение на среднем выводе плавно меняется от 0 В до 5 В.

Функция для приема аналогового сигнала – analogRead**(**pin**)**. Она работает с аналоговыми входами, на плате они подписаны буквой A: A0, A1 и далее. Внутри контроллера напряжение обрабатывает аналого-цифровой преобразователь (АЦП). Он переводит напряжение в целое число от 0 до 1023: 0 соответствует 0 В, 1023 соответствует напряжению около 5 В. Всего получается 1024 значения, и одно деление равно 5 / 1024 ≈ 0,0049 В, то есть примерно 5 милливольт.

Рассчитаем, какое число вернет analogRead, если на входе 2,5 В: 2,5 / 0,0049 ≈ 512. Это середина шкалы.

Пересч**е**т значений

Значение с потенциометра используем для управления яркостью светодиода. Здесь есть несоответствие: analogRead возвращает числа от 0 до 1023, а analogWrite принимает от 0 до 255. Второй диапазон в 4 раза меньше первого, поэтому разделим считанное значение на 4. Коэффициент 1/4 называется коэффициентом пересчета.

При делении целых чисел дробная часть отбрасывается. Например, 1023 / 4 дает 255, а не 255,75. Это удобно: результат никогда не выйдет за пределы 255.

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

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

image40

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

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

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

cpp
// Объявление переменной led_pin и pot_pin, пин светодиода
// и потенциометра соответственно.
// Запись значения номера для каждого пина (используем пин 9 для ШИМ).
int led_pin = 9;
int pot_pin = A0;

void setup() {
  // Настройка пина светодиода на режим выхода,
  pinMode(led_pin, OUTPUT);

  // а пина потенциометра на режим входа
  pinMode(pot_pin, INPUT);
}

void loop() {
  // Объявление локальных переменных rotation (поворот) и brightness (яркость).
  // При объявлении переменных одного типа не обязательно
  // каждый раз заново писать int, а можно написать через запятую.
  int rotation, brightness;

  // Считывание в rotation значения напряжения с потенциометра
  // пропорционально углу поворота ручки, запись в rotation
  // значения от 0 до 1023.
  rotation = analogRead(pot_pin);

  // Присваивание значению яркости значения с rotation,
  // деленное на 4, так как в rotation значения от функции
  // analogRead меняются от 0 до 1023, а в brightness от analogWrite
  // будут записаны значения от 0 до 255, так что 1/4 можно назвать
  // поправочным коэффициентом.
  brightness = rotation / 4;

  // Выдача значения яркости с переменной brightness на светодиод.
  analogWrite(led_pin, brightness);
}

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

image41

Контрольные вопросы ​

  1. Что возвращает функция analogRead() и в каком диапазоне лежит результат?

  2. Зачем и как значение 0–1023 преобразуется в диапазон 0–255?

  3. Какую роль в этом играет аналого-цифровой преобразователь?

2.4. Пьезоизлучатель ​

Цель: ​

Освоить генерацию прямоугольных импульсов функцией tone(), научиться переносить значения с потенциометра (0–1023) в диапазон частот (3500–4500 Гц) функцией map() и управлять высотой звука пьезоизлучателя.

Оборудование: ​

  • пьезоизлучатель;

  • потенциометр;

  • макетная плата;

  • блок-контроллер ЭДУино.

Звук — это колебания, которые распространяются в воздухе. Чем чаще колебания, тем выше звук. Частоту колебаний измеряют в герцах: 1 Гц соответствует одному колебанию в секунду. Человеческое ухо слышит звуки частотой примерно от 20 до 20 000 Гц.

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

Для создания кода понадобятся 2 новые функции – tone**(**) и map**(**).

Функция tone(**)**

Функция tone(**pin, frequency**) или **tone(****pin, frequency, duration)**. Данная функция генерирует на порту вход/выход прямоугольную волну, заданной частоты с 50% рабочим циклом. Это значит, что половину каждого периода на выводе 5 В, половину — 0 В. К выводу подключается пьезоизлучатель или другой динамик.

Функция записывается в одном из двух вариантов:

cpp
cpp
tone(pin, frequency)
tone(pin, frequency, duration)

Параметры:

pin — номер вывода;

frequency — частота сигнала в герцах;

duration — длительность сигнала в миллисекундах. Этот параметр можно не указывать, тогда сигнал звучит до вызова функции noTone**(**pin**).**

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

Функция map**(**)

В прошлой работе диапазон 0–1023 переводили в 0–255 делением на 4. Когда диапазоны не кратны друг другу или начинаются не с нуля, удобнее использовать функцию map**(**). Она пропорционально переносит число из одного диапазона в другой:

cpp
cpp
map(value, fromLow, fromHigh, toLow, toHigh)

Параметры:

  • value - значение для переноса;

  • fromLow - нижняя граница исходного диапазона;

  • fromHigh – верхняя граница исходного диапазона;

  • toLow - нижняя граница нового диапазона;

  • toHigh - верхняя граница нового диапазона.

Функция возвращает значение в новом диапазоне.

Рассчитаем пример. Потенциометр повернут до середины, analogRead вернул 512. Перенесем это значение из диапазона 0–1023 в диапазон 3500–4500:

map**(**512, 0, 1023, 3500, 4500) = 3500 + 512 × 1000 / 1023 ≈ 3500 + 500,5.

Функция map**(**) работает только с целыми числами, и дробная часть не округляется, а отбрасывается. Результат равен 4000 Гц.

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

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

image42

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

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

Разработаем программу, которая меняет частоту звучания пьезоизлучателя при повороте ручки потенциометра. Загрузим программу в контроллер и будем поворачивать ручку потенциометра. Высота звука будет меняться: в одном крайнем положении частота равна 3500 Гц, в другом 4500 Гц.

cpp
// Объявление переменной buzzer_pin и pot_pin, пин динамика
// и потенциометра соответственно,
// запись значения номера для каждого пина
int buzzer_pin = 12;
int pot_pin = A0;

void setup() {
  // Настройка пина динамика на режим выхода.
  pinMode(buzzer_pin, OUTPUT);

  // Уже изначально все пины настроены на вход, поэтому на вход
  // пин потенциометра можно не настраивать.
}

void loop() {
  // Объявление местных переменных rotation (поворот) и
  // frequency (частота).
  int rotation, frequency;

  // Считывание в rotation значения напряжения с потенциометра,
  // пропорционально углу поворота ручки, запись в rotation
  // значения от 0 до 1023
  rotation = analogRead(pot_pin);

  // Расчет частоты звучания динамика функцией map.
  frequency = map(rotation, 0, 1023, 3500, 4500);

  // Выдача пином звука на частоте, равной значению,
  // находящемуся в frequency 20 мс. При следующих loop tone будет
  // вызван снова, поэтому будет выдан непрерывный писк определенной частоты
  tone(buzzer_pin, frequency, 20);
}

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

image43

Схема подключения светодиода к контроллеру

Контрольные вопросы ​

  1. Как функция tone() формирует звук и от чего зависит его высота?

  2. Для чего в работе применяется функция map()?

  3. Как частота сигнала связана с воспринимаемым тоном?

2.5. Фоторезистор ​

Цель: ​

Освоить работу фоторезистора как датчика освещенности, научиться считывать с него сигнал функцией analogRead**(**) и включать или выключать светодиод по пороговому значению света с помощью условного оператора.

Оборудование: ​

  • Фоторезистор;

  • светодиод;

  • резистор 10кОм;

  • резистор 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

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

Контроллер не умеет измерять сопротивление напрямую, он измеряет только напряжение. Чтобы перевести изменение сопротивления в изменение напряжения, собирают делитель напряжения: фоторезистор и постоянный резистор на 10 кОм соединяют последовательно. Фоторезистор подключают к 5 В, постоянный резистор к GND, а точку между ними к аналоговому входу A0.

При последовательном соединении напряжение делится между резисторами пропорционально их сопротивлениям. Напряжение на входе A0 равно напряжению на постоянном резисторе:

U = 5 В × R / (R + Rф),

где R — сопротивление постоянного резистора (10 кОм), Rф — сопротивление фоторезистора.

Рассчитаем два случая. Допустим, на свету сопротивление фоторезистора 2 кОм.

U = 5 × 10 / (10 + 2) ≈ 4,2 В. В темноте сопротивление выросло, допустим, до 40 кОм. Тогда U = 5 × 10 / (10 + 40) = 1 В. Чем светлее, тем выше напряжение на входе.

Считывание сигнала

Напряжение с делителя считывает функция analogRead**(**). Она возвращает число от 0 до 1023: 0 соответствует 0 В, 1023 — опорному напряжению, по которому работает АЦП (обычно 5 В). В примере выше 4,2 В дадут около 853, а 1 В — около 205. Первое значение больше порога 600, и светодиод не горит; второе меньше, и светодиод включается.

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

Условный оператор if-else

Чтобы программа принимала решение, используется условный оператор if-else:

cpp
cpp
if (условие) {
  // выполняется, если условие верно
} else {
  // выполняется, если условие неверно
}

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

В программе порог равен 600, это примерно 600 × 5 / 1024 ≈ 2,9 В. Такое значение подходит не всегда: оно зависит от освещения в классе и от конкретного фоторезистора, поэтому порог подбирают экспериментально.

Задержка 200 мс в конце цикла означает, что контроллер проверяет освещенность пять раз в секунду. Так светодиод не переключается на каждую случайную тень. Если освещенность держится почти ровно на пороге, светодиод все равно может мигать.

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

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

image44

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

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

Загрузим программу в контроллер и закроем фоторезистор ладонью. Светодиод должен включиться, а когда ладонь убрана, погаснуть. Если светодиод не реагирует или горит постоянно, изменим порог 600 в большую или меньшую сторону и загрузим программу снова.

cpp
const int pinPhoto = A0;//объявление константы: пин фоторезистора (аналоговый вход А0)
const int led = 10;//объявление константы: пин светодиода (цифровой выход 10)
int raw = 0;//инициализация переменной освещенности

void setup() {
  pinMode(pinPhoto, INPUT);
  pinMode(led, OUTPUT);
}

void loop() {
  raw = analogRead(pinPhoto);
  if (raw < 600) {
    digitalWrite(led, HIGH);
  } else {
    digitalWrite(led, LOW);
  }
  delay(200);
}

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

image45

Контрольные вопросы ​

  1. Как меняется сопротивление фоторезистора при изменении освещенности?

  2. Как считать уровень освещенности и по какому принципу подбирается пороговое значение?

  3. Почему порог приходится подбирать экспериментально?

2.6. Светодиодная шкала ​

Цель: ​

Освоить работу со сборкой светодиодов, научиться перебирать пины циклом for**(**) и управлять временными интервалами через функцию millis**(**), создавая динамические световые эффекты.

Оборудование: ​

  • светодиодная шкала;

  • 10 резисторов 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

Светодиодная шкала — это 10 светодиодов в одном корпусе, расположенных в ряд. Каждый светодиод подключается к своему выводу контроллера через отдельный резистор 220 Ом. В этой работе шкала занимает выводы со 2 по 11, идущие подряд.

Для программы понадобятся цикл for и функция millis**(**).

Цикл for**(**) – конструкция, позволяющая многократно выполнять блок кода с изменением значения переменной-счетчика. Она состоит из трех частей: инициализация (задание начального значения), условие (проверка продолжения выполнения) и инкремент (изменение счетчика после каждой итерации). Настроить 10 выводов на выход можно, если написать pinMode**(**) десять раз подряд. Программа при этом получится длинной, а если шкалу перенести на другие выводы, придется исправлять каждую строку. Цикл for решает эту задачу одной конструкцией: он многократно выполняет блок кода и каждый раз меняет значение переменной-счетчика.

cpp
for (int pin = 2; pin <= 11; ++pin) {
  pinMode(pin, OUTPUT);
}

В круглых скобках записаны три части. Сначала задается начальное значение счетчика: int pin = 2. Затем условие, при котором цикл продолжается: pin <= 11. В конце — изменение счетчика после каждого повтора: **++****pin** увеличивает его на единицу. Увеличение на единицу называется инкрементом, а каждый повтор цикла — итерацией.

Проследим работу цикла. На первой итерации pin равен 2, и вывод 2 настраивается на выход. Затем pin становится равным 3, условие 3 ≤ 11 верно, настраивается вывод 3. Так продолжается до вывода 11. После него pin становится равным 12, условие 12 ≤ 11 неверно, и цикл завершается. Всего получается 10 итераций.

Функция millis**(**) возвращает количество миллисекунд, прошедших с момента включения контроллера. Через 3 секунды после запуска она вернет примерно 3000, через минуту — примерно 60 000.

Функция delay**(**) останавливает программу: пока идет пауза, контроллер ничего не делает.

Функция millis**(**) программу не останавливает, она только сообщает время. Поэтому с ней можно, например, одновременно отсчитывать время и опрашивать датчики.

Расч**е**т номера светодиода

Программа определяет, какой светодиод должен гореть в данный момент, по формуле:

cpp
cpp
first_pin + (ms / 500) % 10

Разберем ее по частям на примере. Допустим, с момента запуска прошло 7300 мс.

Сначала ms / 500. При делении целых чисел дробная часть отбрасывается: 7300 / 500 = 14. Это номер полусекундного интервала, который идет сейчас. Каждые 500 мс результат увеличивается на единицу.

Затем % 10. Оператор % дает остаток от деления: 14 % 10 = 4. Остаток от деления на 10 всегда лежит в пределах от 0 до 9, поэтому номера интервалов 0, 1, 2 … 9, 10, 11 … превращаются в повторяющийся ряд 0, 1, 2 … 9, 0, 1 …

В конце прибавляем номер первого вывода: 2 + 4 = 6. Сейчас горит светодиод на выводе 6.

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

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

image46

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

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

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

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

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

#define first_pin 2
#define last_pin 11

void setup() {
  // В сборке 10 светодиодов. Возможно написать pinMode 10 раз
  // для каждого из пинов, но это увеличивает код и
  // делает его изменение более проблематичным.
  // Поэтому для открытия каждого нужного пина на выход
  // используется цикл for. Тогда функция pinMode
  // циклично откроет каждый пин от первого (first_pin)
  // до последнего last_pin, увеличивая значения
  // pin на единицу (++pin)

  for (int pin = first_pin; pin <= last_pin; ++pin) {
    pinMode (pin, OUTPUT);
  }
}

void loop() {
  // Определение времени в миллисекундах с момента
  // включения микроконтроллера
  unsigned int ms = millis();

  // Вычисление, какой светодиод должен гореть
  // именно сейчас. Смена будет происходить
  // каждые 500 миллисекунд.
  int pin = first_pin + (ms / 500) % 10;

  // Включение нужного светодиода на 50 миллисекунд
  // с последующим выключением. На следующем проходе цикла
  // светодиод снова включится
  digitalWrite(pin, HIGH);
  delay(50);
  digitalWrite(pin, LOW);
}

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

image47

Скважность 50%

Контрольные вопросы ​

  1. Как оператор for() помогает поочередно управлять множеством светодиодов?

  2. Что задает скорость «бегущей» шкалы и как ее изменить?

  3. Как подключается сборка светодиодов к контроллеру?

2.7. Тактовая кнопка ​

Цель: ​

Освоить работу тактовой кнопки как дискретного датчика, научиться считывать ее состояние функцией digitalRead**(**) и включать или выключать светодиод по нажатию, используя флаг состояния.

Оборудование: ​

  • тактовая кнопка;

  • светодиод;

  • резистор 220 Ом;

  • резистор 10 кОм;

  • макетная плата;

  • блок-контроллер ЭДУино.

Тактовая кнопка – это механическое устройство, которое замыкает электрическую цепь при нажатии и размыкает при отпускании. Тактовая кнопка замыкает электрическую цепь, пока ее держат нажатой, и размыкает цепь, когда ее отпускают. Контроллер определяет состояние кнопки по напряжению на выводе, к которому она подключена. Для этого служит функция digitalRead**(**pin**)**. Она возвращает HIGH, если на выводе около 5 В, и **LOW**, если около 0 В.

Стягивающий резистор

Если кнопку подключить только между выводом и 5 В, возникнет проблема. Пока кнопка не нажата, вывод ни с чем не соединен. Такой вывод улавливает электрические помехи от проводов, соседних устройств и даже от руки, поднесенной к плате. digitalRead**(**) будет случайным образом возвращать то HIGH, то LOW. Это состояние называют «плавающим».

Чтобы вывод не «плавал», его соединяют с GND через резистор 10 кОм. Такой резистор называется стягивающим: он стягивает напряжение на выводе к нулю.

Разберем оба состояния схемы. Кнопка не нажата: вывод соединен с GND через резистор, напряжение на нем 0 В, digitalRead**(**) возвращает LOW. Кнопка нажата: вывод напрямую соединен с 5 В, digitalRead**(**) возвращает HIGH. Через резистор при этом течет ток I = U / R = 5 / 10 000 = 0,0005 А, то есть 0,5 мА. Ток маленький, поэтому схема не перегревается и почти не тратит энергию.

Обработка нажатия по фронту

Задача программы — переключать светодиод: одно нажатие включает его, следующее выключает. Проверять просто «нажата ли кнопка» для этого не подходит. Функция loop**(**) повторяется тысячи раз в секунду, и за время одного нажатия светодиод переключился бы сотни раз.

Поэтому программа отслеживает не само состояние кнопки, а момент его изменения. Сигнал с кнопки при нажатии переходит от LOW к HIGH. Такой переход называется передним фронтом сигнала. Чтобы его заметить, программа хранит предыдущее состояние кнопки и сравнивает его с текущим. Если раньше было LOW, а сейчас HIGH, значит, кнопку только что нажали.

Для хранения состояний используются булевы переменные (тип bool). Они принимают только два значения: true (истина, 1) и false (ложь, 0). Константы HIGH и LOW в Arduino тоже равны 1 и 0, поэтому их можно записывать в булевы переменные.

Переменная flag хранит состояние светодиода. При каждом нажатии ее значение меняется на противоположное с помощью оператора ! (логическое «НЕ»): !**true дает false, !**false дает true.

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

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

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

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

image48

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

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

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

#define button_pin 7
#define led_pin 8

// Булева переменная flag хранит состояние светодиода
// и меняется при каждом нажатии кнопки
bool flag = LOW;

// Булева переменная lastButton запоминает
// предыдущее состояние кнопки
bool lastButton = LOW;

void setup() {
  pinMode (led_pin, OUTPUT);
  pinMode (button_pin, INPUT); // Рекомендуется явно указывать режим входа
}

void loop() {
  // Считывание состояние кнопки
  int currentButton = digitalRead(button_pin);

  // Кнопка была отпущена, а теперь нажата:
  // это момент нажатия (передний фронт).
  if (lastButton == LOW && currentButton == HIGH) {
    // Меняем состояние флага на противоположное
    flag = !flag;
// Включаем или выключаем светодиод по значению флага
    digitalWrite(led_pin, flag);
  }

  // Запоминаем состояние кнопки для следующего повтора loop
  lastButton = currentButton;
}

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

image49

Контрольные вопросы ​

  1. Чем тактовая кнопка отличается от аналогового датчика?

  2. Что возвращает digitalRead() при нажатой и отпущенной кнопке?

  3. Зачем нужен резистор и что он предотвращает?

2.8. Синтезатор ​

Цель: ​

Освоить работу с несколькими тактовыми кнопками как музыкальными клавишами, научиться опрашивать их циклом for() и генерировать функцией tone() звуки разной частоты в зависимости от нажатой кнопки, собрав простейший синтезатор.

Оборудование: ​

  • 3 тактовых кнопки;

  • пьезодинамик;

  • 3 резистора 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

В этой работе соберем простейший синтезатор из трех клавиш. При нажатии на разные кнопки пьезодинамик звучит с разной частотой, то есть с разной высотой звука. Новых функций не понадобится: программа строится из уже знакомых tone**(**), digitalRead**(**) и цикла for.

Каждая кнопка подключается так же, как в прошлой работе: один контакт к 5 В, другой к выводу контроллера, и этот вывод соединен с GND через стягивающий резистор 220 Ом. Нажатая кнопка дает HIGH, отпущенная LOW. Кнопки подключены к выводам 8, 9 и 10, пьезодинамик к выводу 12.

Опрос кнопок в цикле. Программа должна постоянно проверять, какая из кнопок нажата. Проверку можно записать трижды, по одной на каждую кнопку, но удобнее использовать цикл for. На каждой итерации он проверяет одну кнопку, а номер ее вывода вычисляется из счетчика i:

cpp
buttonPin = first_pin + i

При i = 0 проверяется вывод 8, при i = 1 вывод 9, при i = 2 вывод 10. Функция loop() повторяется тысячи раз в секунду, поэтому все три кнопки опрашиваются практически непрерывно.

Расч**е**т частоты. Частота звука для каждой кнопки тоже вычисляется из счетчика:

cpp
frequency = 2000 + i × 1000
iВывод кнопкиЧастота
082000 Гц
193000 Гц
2104000 Гц

С точки зрения математики это линейная функция вида y = kx + b, где k = 1000, b = 2000. Каждая следующая кнопка звучит на 1000 Гц выше предыдущей.

С точки зрения музыки у этих частот есть связь. 4000 Гц ровно вдвое больше 2000 Гц. Такие звуки отличаются на октаву, и на слух воспринимаются как «одна и та же нота, только выше». Отношение 3000 к 2000 равно 3 : 2, этот интервал называется квинтой. При этом сами частоты 2000, 3000 и 4000 Гц не совпадают с нотами стандартного звукоряда. Чтобы синтезатор играл настоящие ноты, в программу пришлось бы записать точные частоты нот, а не вычислять их по формуле.

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

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

image50

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

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

cpp
Загрузим программу в контроллер и нажмем кнопки по очереди. Каждая кнопка должна давать свой звук, от низкого к высокому.
Нажмем две кнопки одновременно. Пьезодинамик воспроизведет только один звук, а не два.
Функция tone() генерирует один сигнал за раз, и каждый новый вызов просто меняет его частоту. Поэтому звучать будет кнопка, которую цикл проверяет последней.

// пин с пьезодинамиком
#define buz_pin 12

// первый пин с клавишей
#define first_pin 8

// общее количество клавиш
#define button_count 3

void setup() {
  pinMode(buz_pin, OUTPUT);
}

void loop() {
  // Создание цикла для того, чтобы управлять кнопками
  for (int i = 0; i < button_count; ++i) {

    // Вычисление кнопки, которая была нажата
    // При i=0 проверяем 8 пин, при i=1 -> 9 пин, при i=2 -> 10 пин
    int buttonPin = i + first_pin;

    // Считывание значения с кнопки.
    bool buttonUp = digitalRead(buttonPin);

    // Проверка условия нажатия кнопки.
    // Внимание: если используется стягивающий резистор к GND,
    // нажатая кнопка выдает HIGH (true).
    // Если кнопка нажата, условие выполняется:
    if (buttonUp == HIGH) {

      // Расчет высоты ноты в герцах
      // в зависимости от нажатой клавиши.
      // Получение значения 2000, 3000 или 4000
      int frequency = 2000 + i * 1000;

      // Пьезодинамик будет звучать в течение
      // 50 миллисекунд. Если клавиша зажата,
      // то издается непрерывный звук
      tone(buz_pin, frequency, 50);
    }
  }
}

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

image51

Контрольные вопросы ​

  1. Как организуется опрос нескольких кнопок в цикле?

  2. Как каждой кнопке сопоставляется своя частота звука?

  3. Что произойдет при одновременном нажатии двух клавиш?

2.9. Дребезг контактов ​

Цель: ​

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

Оборудование: ​

  • светодиод;

  • 2 тактовые кнопки;

  • резистор 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

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

Дребезг контактов – это явление, возникающее при нажатии или отпускании механической кнопки, когда контакты многократно замыкаются и размыкаются в течение короткого промежутка времени (обычно 5–30 мс) вместо одного стабильного переключения. Это происходит из-за упругости материала контактов и механических вибраций.

Если подключить кнопку к осциллографу (прибору, который рисует график изменения напряжения во времени), вместо одного четкого перепада от 0 до 5 В на экране появится серия коротких скачков. Контроллер воспринимает каждый скачок как отдельное нажатие. В этой работе это означало бы, что при одном нажатии яркость светодиода изменится на несколько шагов сразу. Это может привести к непредсказуемому поведению программы – например, при однократном нажатии кнопки яркость может измениться несколько раз.

Методы борьбы с дребезгом:

  1. Аппаратный метод – добавить в схему RC-цепочку из резистора и конденсатора. Конденсатор не может зарядиться или разрядиться мгновенно, поэтому короткие скачки напряжения сглаживаются.

  2. Программный метод не требует дополнительных деталей, и в этой работе используется именно он. Алгоритм такой:

  • Программа замечает, что кнопка перешла из отпущенного состояния в нажатое.

  • Программа делает паузу на 10–20 мс, пока контакты не перестанут прыгать.

  • Программа снова проверяет кнопку.

  • Если кнопка по-прежнему нажата, нажатие засчитывается. Если нет, первый сигнал был случайным скачком, и программа его игнорирует.

ШИМ-сигнал (PWM) – широтно-импульсная модуляция, метод управления яркостью светодиода или скоростью двигателя путем изменения длительности импульсов при постоянной частоте.

Функция analogWrite**(**pin**,** value**)** принимает значение от 0 до 255, где 0 – полностью выключено, 255 – полностью включено, а промежуточные значения соответствуют различным уровням яркости.

Одно нажатие меняет яркость на 35. Начальное значение 128, примерно половина. Рассчитаем, что происходит при нажатиях на кнопку «плюс»: 128 → 163 → 198 → 233 → 268. Последнее значение больше 255, а analogWrite**(**) таких чисел не принимает. Поэтому программа проверяет результат: если он больше 255, записывает 255, если меньше 0, записывает 0.

Внутренний подтягивающий резистор – резистор, встроенный в микроконтроллер, который подключается к пину при использовании режима INPUT_PULLUP. Это позволяет отказаться от внешнего резистора, упрощая схему подключения.

В прошлых работах кнопки подключались со стягивающим резистором к GND. В этой работе внешних резисторов для кнопок нет: используются резисторы, встроенные в микроконтроллер. Они включаются командой pinMode**(**pin**, INPUT_PULLUP)**. У микроконтроллеров семейства Arduino их сопротивление составляет от 20 до 50 кОм.

Встроенный резистор бывает только подтягивающим: он соединяет вывод с 5 В, а не с GND. Поэтому кнопку подключают между выводом и GND, и логика работы меняется на обратную:

КнопкаНапряжение на выводеdigitalRead()
не нажата5 В (через резистор)HIGH
нажата0 В (напрямую к GND)LOW

Это нужно помнить при чтении программы: нажатие — это LOW.

До сих пор в программах использовались готовые функции: digitalRead**(**), tone**(**), map**(**). В этой работе появляется функция, написанная самостоятельно, — handleClick**(**). Обе кнопки обрабатываются одинаково, и разница только в том, увеличивает кнопка яркость или уменьшает. Чтобы не писать один и тот же код дважды, его выносят в функцию и вызывают для каждой кнопки со своими значениями.

cpp
cpp
bool handleClick(int buttonPin, bool wasUp, int step)

Слово bool перед именем означает, что функция возвращает результат типа bool. В скобках перечислены параметры, то есть данные, которые функция получает при вызове:

  • buttonPin — номер вывода кнопки;

  • wasUp — была ли кнопка отпущена при прошлой проверке;

  • step — на сколько изменить яркость: +35 или −35.

Функция возвращает текущее состояние кнопки. В loop**(**) это значение сохраняется в переменную и при следующем вызове передается обратно как wasUp. Так программа помнит, в каком состоянии кнопка была в прошлый раз, как переменная lastButton в работе со светодиодом и кнопкой.

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

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

image52

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

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

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

cpp
#define led_pin 9
#define plus_button_pin 7
#define minus_button_pin 8

int brightness = 128; // Переменная для хранения текущей яркости (0-255)

// Переменные для хранения состояния кнопок (true = не нажата, false = нажата)
bool plusUp = true;
bool minusUp = true;

// Собственная функция для обработки нажатия с защитой от дребезга
bool handleClick(int buttonPin, bool wasUp, int step) {
  bool isUp = digitalRead(buttonPin); // Считываем текущее состояние

  // Если кнопка была не нажата, а теперь нажата (LOW из-за INPUT_PULLUP)
  if (wasUp && !isUp) {
    delay(10); // Программный антидребезг: ждем 10 мс

    // Снова проверяем состояние после паузы, чтобы убедиться, что это не случайный скачок
    bool isUpNow = digitalRead(buttonPin);
    if (!isUpNow) {
      brightness = brightness + step; // Изменяем яркость

      // Ограничиваем пределы ШИМ, чтобы яркость не вышла за границы 0-255
      if (brightness < 0) {
        brightness = 0;
      }
      if (brightness > 255) {
        brightness = 255;
      }
      return false;
    }
  }
  return isUp; // Возвращаем текущее состояние для следующего цикла
}

void setup() {
  pinMode(led_pin, OUTPUT);

  // Включаем встроенные подтягивающие резисторы для кнопок,
  // чтобы избежать наводок и отказаться от внешних резисторов
  pinMode(plus_button_pin, INPUT_PULLUP);
  pinMode(minus_button_pin, INPUT_PULLUP);
}

void loop() {
  analogWrite(led_pin, brightness);

  // Реакция на нажатие с помощью написанной функции
  plusUp = handleClick(plus_button_pin, plusUp, +35);
  minusUp = handleClick(minus_button_pin, minusUp, -35);
}

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

image53

image54

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

Контрольные вопросы ​

  1. Что такое дребезг контактов и почему он мешает?

  2. Чем аппаратный способ подавления дребезга отличается от программного?

  3. Как программная задержка помогает отличить реальное нажатие от ложного?

2.10. Семисегментный индикатор ​

Цель: ​

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

Оборудование: ​

  • семисегментный индикатор;

  • 7 резисторов 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

Семисегментный индикатор состоит из семи вытянутых светодиодов, расположенных в форме цифры 8. Их называют сегментами и обозначают латинскими буквами от A до G: A — верхний, дальше по часовой стрелке B, C, D, E, F, а G — средний. Зажигая разные сочетания сегментов, можно показать любую цифру от 0 до 9. Для цифры 1 нужны два сегмента, B и C, для цифры 8 все семь. У многих индикаторов есть еще восьмой элемент — точка (DP).

Каждый сегмент подключается к своему выводу контроллера через резистор 220 Ом. В этой работе используется индикатор с общим катодом: общий вывод всех сегментов соединен с GND, и сегмент загорается, когда на его вывод подается HIGH.

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

В программе двоичные числа записываются с префиксом 0b. Например, цифра 1 кодируется числом 0b00001010. Биты нумеруются справа налево, начиная с нуля. Здесь единицы стоят в битах 1 и 3, значит, горят два сегмента, подключенные к соответствующим выводам.

Какой бит за какой сегмент отвечает, зависит от того, как индикатор подключен к контроллеру. Для программы этой работы соответствие такое:

БитВывод контроллераСегмент
02E
13C
24D
35B
46A
57F
68G
79точка (не используется)

Проверим по таблице цифру 2: 0b01011101. Единицы стоят в битах 0, 2, 3, 4 и 6, то есть горят сегменты E, D, B, A и G. Если мысленно нарисовать эти сегменты, получится именно двойка.

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

Ниже приведены несколько корректных вариантов объявления массивов:

cpp
int myInts[6];
int myPins[] = {2, 4, 8, 3, 6};
int mySensVals[6] = {2, 4, -8, 3, 2};
char message[6] = "hello";

Массив myInts объявлен без значений: указан только размер, 6 элементов. У массива myPins размер не указан, компилятор сам сосчитает элементы в фигурных скобках и создаст массив из 5 элементов. У mySensVals размер 6, а значений в скобках 5. Недостающий последний элемент получит значение 0.

Массив message хранит строку из символов типа char. В слове “hello“ пять букв, а размер массива 6, потому что в конце строки всегда хранится дополнительный нулевой символ. По нему программа определяет, где строка заканчивается.

Индексы в массиве начинаются с 0. В массиве из 10 элементов первый элемент имеет индекс 0, а последний — индекс 9.

Запись значения в элемент массива:

cpp
mySensVals[0] = 10;

Чтение значения элемента массива:

cpp
cpp
x = mySensVals[4];

После выполнения второй строки переменная x будет равна 2: это пятый по счету элемент массива.

В программе коды цифр хранятся в массиве numberSegments. Индекс элемента совпадает с цифрой, которую он кодирует: numberSegments**[**0] — код нуля, numberSegments**[****7]** — код семерки.

Чтобы по коду цифры включить нужные сегменты, программе надо узнать значение каждого бита. Для этого служит функция bitRead**(**x, n):

  • x — число, из которого считывается бит;

  • n — номер бита. Нумерация начинается с младшего, крайнего правого бита с номером 0.

Функция возвращает 0 или 1. Например, bitRead**(**0b00001010, 1) вернет 1, а bitRead**(**0b00001010, 2) вернет 0.

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

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

image55

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

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

Разработаем программу, которая по очереди показывает на индикаторе цифры от 0 до 9, меняя их раз в секунду.

Номер цифры вычисляется так же, как номер светодиода в работе со светодиодной шкалой: (millis() / 1000) % 10. Деление на 1000 дает количество прошедших секунд, а остаток от деления на 10 превращает его в повторяющийся ряд от 0 до 9.

Загрузим программу в контроллер. Индикатор должен раз в секунду показывать следующую цифру, от 0 до 9, после чего счет начнется заново. Если какая-то цифра выглядит неправильно, сверим подключение сегментов с таблицей.

cpp
#define first_segment_pin 2
#define segment_count 8

// Префикс «0b» значит, что целое число в двоичном коде.
// Единицами обозначаются номера сегментов индикатора,
// включенные для отображения цифры.
// Так как всего цифр десять, в массиве необходимо
// иметь 10 чисел.
// Чтобы отобразить число 0, загораются все сегменты,
// поэтому в наборе шесть единиц.
byte numberSegments[10] =
{
  0b00111111, 0b00001010, 0b01011101, 0b01011110, 0b01101010,
  0b01110110, 0b01110111, 0b00011010, 0b01111111, 0b01111110,
};

void setup(){
  for (int i = 0; i < segment_count; ++i) pinMode(i + first_segment_pin, OUTPUT);
}

void loop(){
  // Определяется число, которое будет отображено.
  // С помощью деления на 10 с остатком, плата будет получать
  // каждую цифру по порядку, зацикленному на десятке.
  int number = (millis() / 1000) % 10;

  // Код, в котором закодирована цифра
  int mask = numberSegments[number];

  // для каждого из 7 сегментов индикатора...
  for (int i = 0; i < segment_count; ++i) {
    // ...определение, должен ли сегмент индикатора быть включен. Для
    // этого
    // считывается бит, соответствующий текущему сегменту.
    // Если сегмент установлен, значение - true (1), если нет – false (0)
    bool enableSegment = bitRead(mask, i);

    // Включение/выключение сегмента на основе полученного значения
    digitalWrite(i + first_segment_pin, enableSegment);
  }
}

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

image56

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

Контрольные вопросы ​

  1. Как устроен семисегментный индикатор и что такое общий анод/катод?

  2. Зачем коды цифр хранят в массиве?

  3. Как перебором пинов вывести нужную цифру?

2.11. Термометр ​

Цель: ​

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

Оборудование: ​

  • термистор;

  • 10 резисторов 220 Ом;

  • резистор 100 кОм;

  • светодиодная шкала;

  • макетная плата;

  • блок-контроллер ЭДУино.

Термистор — это резистор, сопротивление которого зависит от температуры. В этой работе используется термистор, у которого сопротивление при нагревании уменьшается, а при охлаждении увеличивается. Такие термисторы обозначают NTC (от английского negative temperature coefficient, «отрицательный температурный коэффициент»).

Как и фоторезистор, термистор подключается к контроллеру через делитель напряжения. Термистор соединяют с 5 В, постоянный резистор 100 кОм с GND, а точку между ними с аналоговым входом A0. При нагревании сопротивление термистора падает, и напряжение на входе A0 растет.

Программа переводит показание в градусы за три шага.

Первый шаг: число от analogRead**(**) переводится в вольты. Число 1023 соответствует 5 В, поэтому напряжение равно adc × 5 / 1023.

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

Rт = R × (5 − U) / U,

где R — сопротивление постоянного резистора (100 кОм), U — напряжение на входе A0.

Проверим формулу на примере. При 25 °C сопротивление этого термистора равно 100 кОм, то есть совпадает с постоянным резистором. Напряжение делится пополам, U = 2,5 В. Подставим: Rт = 100 × (5 − 2,5) / 2,5 = 100 кОм. Формула работает.

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

1 / T = 1 / T₀ + ln(Rт / R₀) / B

Здесь:

  • T — искомая температура;

  • T₀ = 298,15 — температура 25 °C, записанная в кельвинах;

  • R₀ = 100 кОм — сопротивление термистора при 25 °C;

  • B = 3950 — коэффициент, который показывает, насколько сильно сопротивление зависит от температуры. Его значение берут из описания термистора;

  • ln — натуральный логарифм.

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

Температура в этой формуле измеряется в кельвинах. Шкала Кельвина начинается с абсолютного нуля, самой низкой возможной температуры, а один кельвин равен одному градусу Цельсия. Чтобы перевести градусы Цельсия в кельвины, к ним прибавляют 273,15. Например, 25 °C = 298,15 К. В конце вычислений программа вычитает 273,15 и получает температуру в градусах Цельсия.

Для вычисления логарифма понадобится библиотека math.h. Библиотека — это набор готовых функций, которые можно использовать в своей программе. math.h входит в стандартную библиотеку языка C и содержит математические функции. Подключается она директивой:

cpp
cpp
#include <math.h>

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

Некоторые функции библиотеки math.h:

  • log**(x)** — натуральный логарифм числа x;

  • exp**(x)** — экспонента числа x;

  • sqrt**(x)** — квадратный корень из x;

  • pow**(**x, y) — число x в степени y.

В этой работе используется только log**(**). Остальные функции пригодятся в следующих проектах.

До сих пор в программах использовались целые числа типа int. Напряжение, сопротивление и температура обычно получаются дробными, поэтому для них используется тип float — число с плавающей точкой. Поэтому же константы в программе записаны с точкой: 100000.0, 5.0. Если записать 5 вместо 5.0, при некоторых вычислениях дробная часть может отброситься, как это происходило при делении целых чисел в работе с потенциометром.

Шкала показывает температуру от 21 до 30 °C. Каждый светодиод соответствует одному градусу: первый загорается при 21 °C и выше, второй при 22 °C и выше, и так далее. Чем теплее, тем больше светодиодов горит. При 25 °C горят пять светодиодов.

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

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

image57

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

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

cpp
Разработаем программу, которая считывает показания термистора, переводит их в градусы Цельсия и показывает уровень температуры на светодиодной шкале.

#include <math.h>

#define FIRST_LED_PIN 2
#define LED_COUNT 10

// Параметры термистора
#define TERMIST_B 3950
#define R_FIXED 100000.0      // Постоянный резистор 100 кОм
#define R0 100000.0           // Сопротивление термистора при 25 °C
#define VIN 5.0

void setup()
{
    for (int i = 0; i < LED_COUNT; i++)
    {
        pinMode(FIRST_LED_PIN + i, OUTPUT);
    }
}

void loop()
{
    // Считываем АЦП
    int adc = analogRead(A0);

    // Переводим в напряжение
    float voltage = adc * VIN / 1023.0;

    // Вычисляем сопротивление термистора
    float rTherm = R_FIXED * (VIN - voltage) / voltage;

    // Вычисляем температуру
    float temperature =
        1.0 / (1.0 / (25.0 + 273.15) + log(rTherm / R0) / TERMIST_B)
        - 273.15;

    // Управление светодиодами
    for (int i = 0; i < LED_COUNT; i++)
    {
        bool enableSegment = (temperature >= (21 + i));
        digitalWrite(FIRST_LED_PIN + i, enableSegment);
    }

    delay(500);
}

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

image58

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

Контрольные вопросы ​

  1. Как по показаниям термистора вычисляется температура?

  2. Почему зависимость сопротивления от температуры нелинейна?

  3. Какие функции применяются для пересчета сигнала в градусы?

2.12. Передача данных на компьютер ​

Цель: ​

Освоить передачу данных с микроконтроллера на компьютер через последовательный порт (UART), научиться работать с функциями Serial.begin(), Serial.print() и Serial.println() и собирать температуру в виде временного ряда для последующего анализа.

Оборудование: ​

  • термистор;

  • резистор 100 кОм;

  • макетная плата;

  • Блок-контроллер ЭДУино.

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

Термистор подключается так же, как в прошлой работе: термистор к 5 В, резистор 100 кОм к GND, точка между ними к аналоговому входу A0. Температура вычисляется по тем же формулам с помощью analogRead**(**) и библиотеки math.h.

Контроллер обменивается данными с компьютером через последовательный порт, или UART (от английского Universal Asynchronous Receiver-Transmitter) – универсальный асинхронный приемопередатчик, интерфейс для обмена данными между устройствами. В ЭДУино связь с компьютером осуществляется через USB-кабель, который эмулирует последовательный порт. Это позволяет передавать данные в реальном времени и отображать их в мониторе последовательного порта.

Физически контроллер подключен к компьютеру USB-кабелем. Преобразователь на плате переводит сигналы USB в сигналы последовательного порта, и компьютер видит контроллер как последовательный порт. Все, что контроллер передает, можно увидеть в мониторе порта — окне среды Arduino, которое открывается через меню «Инструменты» → «Монитор порта».

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

Скорость передачи измеряется в бодах. Для последовательного порта 1 бод равен одному биту в секунду. Чаще всего используют скорости 9600 и 115 200 бод.

Рассчитаем, сколько символов в секунду передается на скорости 9600 бод. Каждый символ кодируется восемью битами, и еще два служебных бита отмечают его начало и конец. Итого 10 бит на символ, и за секунду передается 9600 / 10 = 960 символов. Для таблицы, в которую раз в минуту добавляется одна строка, этого более чем достаточно.

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

Функции для работы с последовательным портом:

  • Serial.begin**(**speed**)** – включает последовательный порт с заданной скоростью. Эту функцию вызывают один раз, в setup**(****)**. Наиболее распространенные скорости: 9600, 115200 бод. Скорость должна совпадать со скоростью, установленной в мониторе порта;

  • Serial.print**(**data**)** – передает данные, не переходя на новую строку. Передавать можно целые числа, дробные числа, символы и строки. Дробные числа по умолчанию выводятся с двумя знаками после запятой. Данные могут быть различных типов: int, float, char, **String**;

  • Serial.println**(**data**)** – передает данные и после них символы перевода строки. Следующее значение будет выведено уже с новой строки.

Для оформления таблицы используется специальный символ табуляции \t. Он работает как клавиша Tab на клавиатуре: сдвигает следующий текст к ближайшей позиции табуляции, и данные выстраиваются в столбцы. Передается он той же функцией Serial.print("\t").

Передача данных на ПК позволяет:

  • Отлаживать программу, выводя промежуточные значения переменных;

  • Визуализировать данные в реальном времени;

  • Создавать системы мониторинга и логирования.

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

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

image59

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

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

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

cpp
Загрузим программу в контроллер и откроем монитор порта, выбрав скорость 9600 бод. Сначала появится заголовок таблицы и первое показание, затем каждую минуту будет добавляться новая строка:
Minute  Temperature
1  23.41
2  23.45
3  23.38
Данные из монитора порта можно выделить, скопировать и вставить в электронную таблицу. Табуляция разложит их по двум столбцам, и по ним можно построить график изменения температуры со временем. Например, можно зажать термистор в пальцах на несколько минут, потом отпустить и по графику проследить, как он нагревался и остывал.

#include <math.h>

int minute = 1;

// Параметр конкретного типа термистора (из datasheet):
#define TERMIST_B 3950
#define R_FIXED 100000.0      // Постоянный резистор 100 кОм
#define R0 100000.0           // Сопротивление термистора при 25 °C
#define VIN 5.0

void setup()
{
  // Для передачи данных на ПК открывается канал передачи
  // данных через USB через последовательный порт.
  // Для этого используется команда начала передачи
  // с указанием скорости.
  Serial.begin(9600);

  // Передача заголовка таблицы в текстовом виде,
  // печать строки. Символ «\t» является табуляцией.
  Serial.println("Minute\tTemperature");
}

void loop()
{
  // Считываем АЦП
    int adc = analogRead(A0);

    // Переводим в напряжение
    float voltage = adc * VIN / 1023.0;

    // Вычисляем сопротивление термистора
    float rTherm = R_FIXED * (VIN - voltage) / voltage;

    // Вычисляем температуру
    float temperature = 1.0 / (1.0 / (25.0 + 273.15) + log(rTherm / R0) / TERMIST_B) - 273.15;

  // Печать минуты и температуры, разделяя их табом.
  // println переводит курсор на новую строку
  Serial.print(minute);
  Serial.print("\t");
  Serial.println(temperature);

  delay(60000);

  // Прибавление 1 к счетчику минут
  ++minute;
}

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

image60

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

Контрольные вопросы ​

  1. Что такое последовательный порт (UART) и для чего он нужен?

  2. Что задает скорость передачи в Serial.begin()?

  3. Чем Serial.print() отличается от Serial.println()?

2.13. Передача данных с компьютера ​

Цель: ​

Освоить прием данных с компьютера на микроконтроллер через последовательный порт (UART), научиться читать входящие данные функциями Serial.available() и Serial.read() и преобразовывать строку в число для управления яркостью светодиода.

Оборудование: ​

  • светодиод;

  • резистор 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

В прошлой работе контроллер передавал данные на компьютер. Теперь направление обратное: компьютер передает данные контроллеру. Число, набранное в мониторе порта, будет задавать яркость светодиода.

Монитор порта передает данные как текст, символ за символом. Число 128 уходит в контроллер не как одно число, а как три отдельных символа: '1', '2' и '8'. Программе нужно собрать эти символы в строку "128" и только потом превратить строку в число 128.

Внутри компьютера и контроллера каждый символ хранится как число, его код. Цифры имеют коды, идущие подряд: символ '0' имеет код 48, '1' — код 49, и так до '9' с кодом 57. Поэтому проверка «символ находится между '0' и '9'» позволяет отличить цифру от любого другого символа.

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

Функции для приема данных с ПК:

  • Serial.available**()** – возвращает количество байт (символов), доступных для чтения из буфера последовательного порта и еще не прочитаны. Если функция вернула 0, новых данных нет. Используется для проверки, пришли ли новые данные.

  • Serial.read**()** – считывает один байт (символ) из буфера последовательного порта, тот, что пришел раньше остальных. Возвращает первый доступный символ или -1, если данных нет.

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

cpp
cpp
while (условие) {
  // повторяется, пока условие верно
}

В отличие от цикла for, у while нет счетчика: он повторяется, пока выполняется условие. В программе условие — Serial.available**()**, то есть «в буфере еще есть символы». Когда буфер опустеет, функция вернет 0, и цикл завершится.

Для сборки символов в строку используется тип String. Это не просто переменная, а объект: у него есть собственные функции, которые называются методами. Метод записывается через точку после имени строки.

Позволяет:

  • Конкатенировать (складывать) строки с помощью оператора +.

Сложение строк называется конкатенацией: если к строке "12" прибавить символ '8', получится "128".

  • Определять длину строки с помощью метода .**length**()**.**

Метод .**length**() возвращает длину строки, то есть количество символов в ней. Для строки "128" это 3.

  • Преобразовывать строку в целое число с помощью метода .**toInt**()**.**

Метод .**toInt**() переводит строку в целое число: из "128" получится число 128.

Внимание**!** При передаче чисел через монитор порта данные передаются как текст (посимвольно). Например, число 128 передается как три символа: '1', '2', '8'. Программа собирает эти символы в строку "128", а затем преобразует ее в целое число 128.

Таких символов два:

  • \n — перевод строки (LF, Line Feed), код 10;

  • \r — возврат каретки (CR, Carriage Return), код 13.

Названия пришли от пишущих машинок. Возврат каретки перемещал печатающий механизм к началу строки, а перевод строки прокручивал лист на одну строку вниз.

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

Программа этой работы начинает обработку, как только получает \n или \r. Поэтому подходит любая настройка, кроме «без символа конца строки». Если выбрать ее, программа будет только накапливать цифры и ни разу не изменит яркость.

image61

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

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

image62

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

В данной работе разработаем программу, которая будет принимать данные с персонального компьютера через последовательный порт, преобразовывать их в числовое значение и управлять яркостью светодиода с помощью ШИМ-сигнала. Пользователь должен вводить числа в диапазоне от 0 до 255 в мониторе порта, и светодиод должен загораться с соответствующей яркостью.

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

Разработаем программу, которая принимает число от 0 до 255 из монитора порта и задает с его помощью яркость светодиода.

Загрузим программу в контроллер, откроем монитор порта и выберем скорость 9600 бод. Введем число 255 и нажмем Enter: светодиод загорится на полную яркость. Затем проверим 128, 20 и 0.

Проверим, как программа обрабатывает неправильный ввод. Число 300 не изменит яркость: оно больше 255 и не пройдет проверку. Текст «1а2» даст яркость 12, потому что буква не является цифрой, и программа ее пропустит. По той же причине «−50» превратится в 50: знак минус тоже не цифра.

cpp
#define LED_PIN 9   // пин светодиода (должен поддерживать ШИМ)

// Строка, в которую посимвольно собираются пришедшие цифры
String message;

void setup()
{
  pinMode(LED_PIN, OUTPUT);   // настраиваем пин светодиода на выход
  Serial.begin(9600);         // открываем последовательный порт на скорости 9600 бод
}

void loop()
{
  // Пока в буфере порта есть непрочитанные данные
  while (Serial.available())
  {
    // Считываем один символ из порта
    char incomingChar = Serial.read();

    // Если символ — это цифра (от '0' до '9')...
    if (incomingChar >= '0' && incomingChar <= '9')
    {
      // ...дописываем ее в конец строки message
      message = message + incomingChar;
    }
    // Иначе, если пришел символ конца строки (перевод строки или возврат каретки)...
    else if (incomingChar == '\n' || incomingChar == '\r')
    {
      // ...и в строке уже что-то накопилось
      if (message.length() > 0)
      {
        // Переводим собранную строку в целое число
        int value = message.toInt();

        // Проверяем, что число попадает в допустимый диапазон ШИМ (0–255)
        if (value >= 0 && value <= 255)
        {
          // Задаем яркость светодиода полученным значением
          analogWrite(LED_PIN, value);
        }

        // Очищаем строку, чтобы начать сбор следующего числа
        message = "";
      }
    }
  }
}

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

image63

Контрольные вопросы ​

  1. Как контроллер принимает данные, отправленные с компьютера?

  2. Как проверить, что в порт пришли новые данные?

  3. Как из принятой строки получить число?

2.14. Дисплей ​

Цель: ​

изучение принципа работы символьного LCD-дисплея с интерфейсом I2C, освоение подключения и инициализации дисплея с использованием библиотек Wire.h и LiquidCrystal_I2C.h, приобретение навыков вывода текстовой информации на дисплей с использованием функций setCursor() и print().

Оборудование: ​

  • LCD-дисплей 16×2 с интерфейсом I2C;

  • блок-контроллер ЭДУино.

В предыдущих работах индикация была через светодиоды, пьезоизлучатель, монитор порта. Для создания кода будут использоваться библиотеки для работы с LCD-дисплеем по интерфейсу I2C. Дисплей позволяет выводить текст и числа прямо на устройстве, без компьютера.

Обозначение 16×2 означает, что на дисплее 2 строки по 16 символов, всего 32 знакоместа. Каждое знакоместо имеет две координаты: номер колонки и номер строки. Колонки нумеруются от 0 до 15, строки от 0 до 1. Это похоже на координатную плоскость: сначала указывается положение по горизонтали, потом по вертикали. Левый верхний символ имеет координаты (0, 0), правый нижний — (15, 1).

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

Сам дисплей подключается к контроллеру большим количеством проводов: только для передачи данных нужно не меньше шести выводов контроллера. Чтобы сократить их число, на дисплей устанавливают I2C-адаптер — небольшую плату, которая принимает команды по интерфейсу I2C и передает их дисплею.

I2C (Inter-Integrated Circuit) – последовательный синхронный интерфейс для связи устройств, использующий всего две линии: SDA (данные) и SCL (синхронизация).

Дисплей с адаптером подключается четырьмя проводами: питание VCC, земля GND, SDA и SCL. Выводов контроллера для передачи данных при этом занято два, а не шесть. У контроллеров семейства Arduino линия SDA выведена на вывод A4, а SCL на A5.

В прошлых работах использовался последовательный порт UART. Он асинхронный: скорость передачи заранее задается одинаковой у обоих устройств, иначе данные искажаются. I2C — синхронный интерфейс. По линии SCL передаются тактовые импульсы, и каждый импульс отмечает момент, когда нужно считать очередной бит с линии SDA. Устройства не нуждаются в заранее согласованной скорости: темп задает тактовый сигнал.

К одним и тем же двум линиям I2C можно подключить несколько устройств: дисплей, датчики, часы. Чтобы контроллер различал их, у каждого устройства есть свой адрес. Адрес I2C-адаптера дисплея обычно 0x27 или 0x3F. Префикс 0x означает, что число записано в шестнадцатеричной системе счисления, так адреса принято указывать в документации.

Для работы с дисплеем понадобятся две библиотеки.

Библиотека Wire.h – встроенная библиотека Arduino для работы с устройствами по протоколу I2C. Она обеспечивает низкоуровневую передачу данных между микроконтроллером и периферийными устройствами. Отвечает за передачу отдельных битов и байтов по линиям SDA и SCL.

Библиотека LiquidCrystal_I2C.h – библиотека для управления LCD-дисплеями с I2C-адаптером. Упрощает вывод текста, управление курсором и подсветкой. Для работы требует предварительной установки через менеджера библиотек.

Функции библиотеки LiquidCrystal_I2C:

  • LiquidCrystal_I2C lcd (адрес, колонки, строки) — создает объект дисплея с именем lcd. Для дисплея 16×2 с адресом 0x27 запись будет такой: LiquidCrystal_I2C lcd**(**0x27, 16, 2);

  • lcd.init**()** — подготавливает дисплей к работе.

  • lcd.backlight**()** — включает подсветку.

  • lcd.noBacklight**()** — выключает подсветку.

  • lcd.setCursor(колонка, строка) — ставит курсор в указанное знакоместо. С этого места начнется вывод текста. Например, lcd.setCursor**(0, 1)** ставит курсор в начало второй строки.

  • lcd.print**(текст)** — выводит текст или число, начиная с текущего положения курсора.

  • lcd.clear**()** — стирает все с дисплея и возвращает курсор в положение **(0, 0).**

Если библиотека LiquidCrystal_I2C не установлена, ее необходимо добавить через менеджера библиотек:

  1. Откроем меню «Скетч» → «Подключить библиотеку» → «Управление библиотеками».

image64

Менеджер библиотек

  1. В строке поиска введем «LiquidCrystal I2C».

image65

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

  1. Выберем в списке библиотеку и нажмем «Установить».

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

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

image66

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

Подключим дисплей к контроллеру четырьмя проводами: VCC к 5 В, GND к GND, SDA к выводу SDA, SCL к выводу SCL.

В данной работе разработаем программу, которая будет выводить текстовую информацию на LCD-дисплей. На первой строке дисплея должно отображаться слово "**Applied**", на второй строке – "**Robotics**". Текст должен быть расположен по центру экрана (с отступом 4 пробела слева).

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

cpp
Чтобы надпись оказалась по центру, рассчитаем, с какой колонки начинать вывод. В строке 16 знакомест. Слово «Robotics» занимает 8 из них, свободными остаются 16 − 8 = 8. Разделим их поровну слева и справа: 8 / 2 = 4. Значит, слово начинается с колонки 4 и занимает колонки с 4 по 11.
Слово «Applied» короче, в нем 7 букв. Свободных знакомест 16 − 7 = 9, и поровну их не разделить: 9 / 2 = 4,5. Округлим до 4, тогда слева будет 4 свободных знакоместа, а справа 5. Оба слова начинаются с одной колонки и выровнены по левому краю, поэтому надпись выглядит аккуратно.

Функция setup() выполняется один раз при включении контроллера. Дисплей сам хранит выведенный текст, пока его не сотрут командой lcd.clear() или не отключат питание. Поэтому повторять вывод в loop() не нужно.
Загрузим программу в контроллер. На дисплее должна появиться надпись в две строки.
Если дисплей светится, но текста нет, возможны две причины. Первая — неподходящая контрастность. На обратной стороне I2C-адаптера есть подстроечный резистор. Повернем его отверткой, пока не появятся символы. Вторая — другой адрес адаптера. Заменим в программе 0x27 на 0x3F и загрузим программу снова.

#include <Wire.h>               // библиотека для обмена данными по интерфейсу I2C
#include <LiquidCrystal_I2C.h> // библиотека для управления LCD-дисплеем через I2C

// Создаем объект дисплея: адрес 0x27, 16 столбцов, 2 строки
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  lcd.init();       // инициализируем дисплей
  lcd.backlight();  // включаем подсветку

  // выводим наш нужный текст
  lcd.setCursor(4, 0);     // ставим курсор в 5-й столбец первой строки (нумерация с 0)
  lcd.print("Applied");    // печатаем слово Applied

  lcd.setCursor(4, 1);     // ставим курсор в 5-й столбец второй строки
  lcd.print("Robotics");   // печатаем слово Robotics
}

void loop() {
  // Текст выводится один раз в setup(), поэтому в цикле ничего не делаем
}

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

Контрольные вопросы ​

  1. Какие преимущества дает подключение дисплея по интерфейсу I2C?

  2. За что отвечают библиотеки Wire.h и LiquidCrystal_I2C.h?

  3. Как задать позицию вывода текста на дисплее?

2.15. Bluetooth модуль ​

Цель: ​

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

Оборудование: ​

  • bluetooth модуль HC-05;

  • светодиод;

  • резистор 220 Ом;

  • макетная плата;

  • блок-контроллер ЭДУино.

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

Bluetooth передает данные с помощью радиоволн частотой около 2,4 ГГц, то есть 2,4 миллиарда колебаний в секунду. Радиоволны — это электромагнитные волны, как и свет, только с гораздо большей длиной волны. Они проходят через стены и не требуют прямой видимости между устройствами.

Модуль HC-05 является одним из самых популярных модулей. Модуль HC-05 рассчитан на связь на расстоянии около 10 метров. Под него существует большое количество готовых программ на мобильные устройства, и обмен с ним реализуется очень просто. Одним из недостатком данного модуля является невозможность обмениваться с ним данными, используя платформу IOS.

Обмен данными устроен просто: для контроллера модуль выглядит как последовательный порт. Программа использует те же функции Serial.begin**(), Serial.available**() и Serial.read**()**, что и в работе с монитором порта. Для контроллера нет разницы, пришел символ с компьютера по USB-кабелю или со смартфона по радио.

Подключение смартфона

Подадим питание на плату и включим на смартфоне поиск Bluetooth-устройств. Модуль появится в списке под названием «HC-05». При подключении смартфон запросит PIN-код: введем «1234», а если он не подойдет, то «0000».

После подключения смартфону нужна программа, которая будет отправлять команды. Есть много приложений-пультов и Bluetooth-терминалов, которые работают с HC-05. С их помощью можно управлять не только светодиодом, но и робототехнической платформой.

Скорость обмена у HC-05 по умолчанию 9600 бод, но модуль мог быть заранее перенастроен на другую, например 115 200 бод. Скорость в программе должна совпадать со скоростью модуля, как совпадала скорость программы и монитора порта.

Скорость и другие параметры модуля меняют в режиме AT-команд. Чтобы войти в этот режим:

  1. Установим перемычку на джампер 25.

  2. Отключим и снова подключим питание контроллера.

  3. Загрузим в контроллер программу для работы в режиме AT-команд.

  4. Откроем монитор порта, выберем скорость 38 400 бод и настройку конца строки «Оба NL & CR».

  5. Отправим команду AT.

Если в ответ придет OK, модуль вошел в режим настройки.

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

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

image68

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

В данной работе разработаем программу, которая будет принимать команды с мобильного устройства через bluetooth-модуль и управлять светодиодом. При получении символа '1' светодиод должен включаться, при получении символа '0' – выключаться.

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

Разработаем программу, которая принимает команды со смартфона через Bluetooth-модуль и управляет светодиодом. Символ '1' включает светодиод, символ '0' выключает.

В работе с монитором порта программа собирала число из нескольких символов и ждала символ конца строки. Здесь команда состоит из одного символа, поэтому собирать строку не нужно: каждый пришедший символ сразу проверяется. Если приложение на смартфоне добавляет после команды символы конца строки, программа их просто пропустит, потому что они не равны ни '1', ни '0'.

Загрузим программу в контроллер, подключим смартфон к модулю HC-05 и откроем приложение-терминал. Отправим символ 1: светодиод должен загореться. Отправим 0: светодиод погаснет. Затем отойдем от платы на несколько метров и проверим, на каком расстоянии связь еще работает.

cpp
#define BT_BAUD 9600 //задаем скорость Bluetooth модуля

// Пин, к которому подключен светодиод
const int ledPin = 2;

void setup() {
  // Запускаем связь с Bluetooth-модулем на стандартной скорости
  Serial.begin(BT_BAUD);     // настройка Bluetooth

  // Настраиваем 2-й пин на выдачу напряжения
  pinMode(ledPin, OUTPUT);

  // На всякий случай гасим диод при старте платы
  digitalWrite(ledPin, LOW);
}

void loop() {
  // Проверяем, пришли ли команды
  if (Serial.available()) {
    // Считываем один символ
    char command = Serial.read();

    // Включаем или выключаем светодиод в зависимости от команды
    if (command == '1') {
      digitalWrite(ledPin, HIGH);
    }
    else if (command == '0') {
      digitalWrite(ledPin, LOW);
    }
  }
}

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

image69

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

Контрольные вопросы ​

  1. Как модуль Bluetooth связывается с контроллером и по каким линиям?

  2. Чем режимы ведущего и ведомого (Master/Slave) отличаются?

  3. Как проверить прием команды по беспроводному каналу?

2.16. Ультразвуковой дальномер ​

Цель: ​

Освоить принцип работы ультразвукового дальномера HC-SR04, научиться генерировать и принимать ультразвуковые импульсы функциями digitalWrite() и pulseIn() и измерять расстояние до объектов с выводом данных в монитор порта.

Оборудование: ​

  • ультразвуковой дальномер;

  • блок-контроллер ЭДУино.

Ультразвуком называют звук с частотой выше 20 000 Гц. Человеческое ухо его не слышит, но по своей природе это такие же звуковые волны: они распространяются в воздухе и отражаются от препятствий. На этом принципе основана эхолокация. Летучие мыши издают ультразвуковые сигналы и по времени, через которое возвращается эхо, определяют расстояние до препятствий и добычи.

Ультразвуковой дальномер работает так же. На его плате расположены два цилиндра: излучатель и приемник. Распространенные дальномеры, например HC-SR04, излучают ультразвук частотой 40 000 Гц и измеряют расстояния примерно от 2 см до 4 м.

У дальномера два управляющих вывода: TRIG (запуск) и ECHO (эхо).

Контроллер подает на вывод TRIG импульс длительностью 10 микросекунд. Получив его, дальномер испускает короткую серию ультразвуковых колебаний. Затем он выставляет на выводе ECHO высокий уровень и держит его, пока не вернется отраженный сигнал. Чем дальше препятствие, тем дольше звук идет туда и обратно и тем длиннее импульс на выводе ECHO.

Так задача измерения расстояния сводится к задаче измерения времени.

Скорость звука в воздухе примерно 340 м/с. Длительность импульса измеряется в микросекундах, поэтому переведем скорость в сантиметры в микросекунду. 340 м = 34 000 см, 1 с = 1 000 000 мкс, значит, 340 м/с = 34 000 / 1 000 000 = 0,034 см/мкс.

За время импульса звук проходит путь до препятствия и обратно, то есть удвоенное расстояние. Поэтому произведение времени на скорость делят на 2:

расстояние = время × скорость звука / 2

Рассчитаем пример. Импульс на выводе ECHO длился 1000 мкс. Расстояние = 1000 × 0,034 / 2 = 17 см.

Решим обратную задачу. Препятствие находится в 1 м от дальномера. Звук проходит 200 см, и на это уходит 200 / 0,034 ≈ 5900 мкс, то есть меньше 6 миллисекунд.

Скорость звука зависит от температуры воздуха: при 0 °C она составляет около 331 м/с, при 20 °C около 343 м/с. Значение 340 м/с соответствует комнатной температуре. Для школьных измерений такой точности достаточно.

Для создания кода в данной работе используются уже изученные функции digitalWrite**(**) и digitalRead**(**), а также новая функция pulseIn**(**) для измерения длительности импульса.

delayMicroseconds**(**us**)** работает так же, как delay**(****)**, но пауза задается в микросекундах, а не в миллисекундах. Она нужна, чтобы сформировать на выводе TRIG импульс длительностью ровно 10 мкс.

Функция pulseIn**(**pin**,** value**)** измеряет длительность импульса на выводе. Параметр value указывает, какой импульс нужно измерить: HIGH или LOW. Функция ждет начала импульса, измеряет, сколько он длится, и возвращает результат в микросекундах. Если импульс не начался в течение 1 секунды, функция прекращает ожидание и возвращает 0. Время ожидания можно изменить третьим параметром**:** pulseIn**(**pin**,** value**,** timeout**)**.

Результат pulseIn**(**) записывается в переменную типа long. long вмещает числа больше двух миллиардов.

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

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

image70

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

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

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

Результат вычисления дробный, а переменная distance имеет тип int. При записи в нее дробная часть отбрасывается: 17,8 см превратится в 17 см.

Загрузим программу в контроллер, откроем монитор порта на скорости 9600 бод и поднесем ладонь к дальномеру. Будем медленно отводить руку и следить за показаниями. Затем проверим результат линейкой: положим книгу на известном расстоянии, например 30 см, и сравним с показанием дальномера.

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

cpp
// Цифровые пины для УЗ-дальномера
const int trigPin = 12;    // пин TRIG
const int echoPin = 11;   // пин ECHO
void setup() {
  // Настраиваем пины
  pinMode(trigPin, OUTPUT); //задаем выход для генерации УЗ-сигнала
  pinMode(echoPin, INPUT);  //задаем вход для приема отраженного сигнала
  Serial.begin(9600); //инициализация монитора порта
}
void loop() {
  // отправляем ультразвуковой импульс
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2); //гасим триггер УЗ дальномера на 2 мкс
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10); //подаем 10 мкс импульс
  digitalWrite(trigPin, LOW);
  // Ждем ответный сигнал
  long duration = pulseIn(echoPin, HIGH); //измеряем длительность на echoPin
  // Вычисляем расстояние (в сантиметрах)
  int distance = duration * 0.034 / 2; //расстояние=(время*скорость звука)/2. Скорость звука=340 м/с=0.034 см/мкс. Делим на 2, тк сигнал идет до объекта и обратно
  // выводим результат в монитор порта
  Serial.print("Расстояние: ");
  Serial.print(distance);
  Serial.println(" см");
  // пауза между измерениями
  delay(300);
}

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

image71

Настройки монитора порта

Контрольные вопросы ​

  1. На каком физическом принципе ультразвуковой дальномер измеряет расстояние?

  2. За что отвечают выводы Trig и Echo?

  3. Как из времени отклика получить расстояние в сантиметрах?

2.17. Инерциальный датчик ​

Цель: ​

Освоить принцип работы инерциального датчика MPU6050 (акселерометр и гироскоп), научиться подключать его по интерфейсу I2C с библиотеками Adafruit и считывать данные ускорения, угловой скорости и температуры.

Оборудование: ​

  • модуль «Инерциальный датчик»;

  • блок-контроллер ЭДУино.

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

Датчик измеряет величины вдоль трех взаимно перпендикулярных осей: X, Y и Z. Если модуль лежит на столе, оси X и Y направлены вдоль столешницы, а ось Z вертикально. Направления осей обычно нарисованы стрелками на плате модуля.

Акселерометр

Акселерометр измеряет ускорение вдоль каждой из осей. Вместе с ускорением от движения он всегда измеряет и ускорение свободного падения g ≈ 9,8 м/с². Поэтому неподвижный датчик, лежащий на столе, показывает по оси Z около 9,8 м/с², а по осям X и Y около нуля.

Если датчик наклонить, ускорение свободного падения распределится между осями: по Z показание уменьшится, а по X или Y появится. По тому, как g распределено между осями, определяют наклон устройства относительно горизонтали.

Гироскоп

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

Датчик температуры

Встроенный датчик измеряет температуру самой микросхемы. Микросхема во время работы немного нагревается, поэтому ее температура обычно выше температуры воздуха в комнате.

Настройка диапазонов

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

Для акселерометра можно выбрать диапазон ±2g, ±4g, ±8g или ±16g. Например, ±2g означает, что датчик измеряет ускорения до 2 × 9,8 = 19,6 м/с² в каждую сторону. Для медленных наклонов хватит ±2g, для робота, который резко трогается и тормозит, лучше взять диапазон шире.

Для гироскопа можно выбрать ±250, ±500, ±1000 или ±2000 градусов в секунду. Рассчитаем, что означает ±250 °/с: полный оборот — 360°, значит, 250 / 360 ≈ 0,7 оборота в секунду. Для большинства школьных задач этого достаточно.

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

Для создания кода в данной работе используются библиотеки Adafruit_MPU6050, Adafruit_Sensor и Wire для работы с инерциальным датчиком по интерфейсу I2C.

Датчик подключается по интерфейсу I2C, как LCD-дисплей: VCC к 5 В, GND к GND, SDA к выводу SDA, SCL к выводу SCL. Адрес датчика на шине I2C — 0x68.

Для работы с датчиком понадобятся три библиотеки. Wire уже знакома по работе с дисплеем. Adafruit_MPU6050 содержит функции для настройки датчика и чтения показаний. Adafruit_Sensor задает единый формат данных для датчиков фирмы Adafruit.

Библиотеки устанавливаются через менеджера библиотек так же, как в работе с дисплеем. Введем в поиске «Adafruit MPU6050» и нажмем «Установить». Среда предложит установить и библиотеки, от которых она зависит, в том числе Adafruit Unified Sensor. Согласимся на установку всех.

Функции библиотеки Adafruit_MPU6050

  • mpu.begin**()** — запускает датчик. Возвращает true, если датчик найден, и false, если нет.

  • mpu.setAccelerometerRange**(...)** — задает диапазон акселерометра, например MPU6050_RANGE_8_G для ±8g.

  • mpu.setGyroRange**(...)** — задает диапазон гироскопа, например MPU6050_RANGE_500_DEG для ±500 °/с.

  • mpu.setFilterBandwidth**(...)** — задает частоту фильтра, например MPU6050_BAND_21_HZ для 21 Гц.

  • mpu.getEvent**(&a, &g, &**temp**)** — считывает показания сразу всех трех приборов и записывает их в переменные a (акселерометр), g (гироскоп) и **temp** (температура). Знак & перед именем означает, что функции передается не значение переменной, а ее место в памяти. Так функция может записать результат прямо в эту переменную.

Библиотека выдает ускорение в м/с², температуру в градусах Цельсия, а угловую скорость в радианах в секунду. Радиан — единица измерения углов, которую изучают в старших классах. Для перевода в градусы показание умножают на встроенную константу RAD_TO_DEG, она примерно равна 57,3.

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

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

image72

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

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

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

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

Если датчик не найден, программа выводит сообщение и дальше не выполняется. Бесконечный цикл while (**true**) никогда не завершается, и до loop**(**) программа не доходит. Это сделано, чтобы не выводить бессмысленные числа от отсутствующего датчика. В таком случае проверим подключение проводов SDA и SCL.

Загрузим программу в контроллер и откроем монитор порта на скорости 9600 бод. Информация, приходящая в монитор порта, представлена ниже.

Положим датчик на стол. По оси Z акселерометр покажет около 9,8 м/с², по X и Y около нуля. Гироскоп по всем осям покажет почти ноль. Небольшие отклонения от нуля — это погрешность датчика, она есть у любого прибора.

Наклоним датчик на бок: показание по Z уменьшится, а по одной из осей X или Y вырастет. Затем повернем датчик на столе вокруг вертикальной оси: гироскоп по оси Z покажет угловую скорость, пока датчик вращается, и вернется к нулю, когда вращение прекратится.

cpp
#include <Adafruit_MPU6050.h> // драйвер MPU6050
#include <Adafruit_Sensor.h> // библиотека для датчиков
#include <Wire.h> // I2C-связь

Adafruit_MPU6050 mpu; // создание объекта датчика

void setup(void) {
  Serial.begin(115200); // открытие последовательного порта

  if (!mpu.begin()) { // инициализация датчика
    Serial.println("MPU6050 not found!");
    while (1);
  }

  // установка нужного диапазона
  mpu.setAccelerometerRange(MPU6050_RANGE_8_G); // диапазон акселерометра ±8g
  mpu.setGyroRange(MPU6050_RANGE_500_DEG); // диапазон гироскопа ±500°/c
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ); // полоса фильтра 21 Гц
}

void loop() {

  sensors_event_t a, g, temp; // создаем переменные структуры sensors_event_t для хранения данных акселерометра, гироскопа и температуры
  mpu.getEvent(&a, &g, &temp); // чтение данных

  // вывод в монитор порта ускорений по осям x, y, z
  Serial.print("Acceleration X: ");
  Serial.print(a.acceleration.x);
  Serial.print(", Y: ");
  Serial.print(a.acceleration.y);
  Serial.print(", Z: ");
  Serial.print(a.acceleration.z);
  Serial.println(" m/s^2");

  // вывод в монитор порта скоростей вращения вокруг осей x, y, z
  Serial.print("Rotation X: ");
  Serial.print(g.gyro.x);
  Serial.print(", Y: ");
  Serial.print(g.gyro.y);
  Serial.print(", Z: ");
  Serial.print(g.gyro.z);
  Serial.println(" rad/s");

  // вывод в монитор порта температуры
  Serial.print("Temperature: ");
  Serial.print(temp.temperature);
  Serial.println(" degC");

  Serial.println("");
  delay(500);
}

Информация, приходящая в монитор порта представлена на рисунке:

image73

Информация в мониторе порта

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

image74

Подключение библиотеки

image75

Поиск библиотеки

Контрольные вопросы ​

  1. Какие величины измеряют акселерометр, гироскоп и встроенный датчик температуры модуля MPU6050?

  2. Почему неподвижный датчик, лежащий на столе, показывает по оси Z около 9,8 м/с², а гироскоп — почти ноль?

  3. Как выбор диапазона акселерометра (±2g или ±16g) влияет на измерения?

2.18. Модель «Кролик» ​

Цель: ​

Освоить управление мобильным роботом через драйвер моторов MotorShield, научиться управлять двумя коллекторными моторами и сервоприводом и запрограммировать походку робота «Кролик» с эффектом переваливания.

Оборудование: ​

  • 2 двигателя постоянного тока;

  • сервопривод;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

image76

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

Робот «Кролик» — мобильная платформа с двумя ступнями. В каждой ступне стоит свой мотор, а сверху на корпусе закреплен сервопривод, который наклоняет корпус влево и вправо. Робот передвигается перевалистой походкой: наклоняется на одну сторону, делает шаг, наклоняется на другую и снова делает шаг.

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

Для программы понадобятся библиотека Servo.h и уже знакомые функции digitalWrite**(**) и analogWrite**(**) для управления моторами через драйвер MotorShield. Контроллер не может напрямую питать моторы: они потребляют слишком большой ток. Моторы подключаются через драйвер MotorShield, который управляет двумя коллекторными моторами постоянного тока. Для каждого мотора используются два сигнала.

Драйвер моторов MotorShield позволяет управлять двумя коллекторными моторами. Для каждого мотора используются два управляющих сигнала: DIR (направление вращения) и SPEED (скорость вращения). DIR задает направление вращения. На этот вывод подается LOW или HIGH функцией digitalWrite**(**). LOW и HIGH соответствуют противоположным направлениям вращения. SPEED задает скорость вращения. На этот вывод подается ШИМ-сигнал функцией analogWrite**(**), значение от 0 до 255. В программе скорость равна 70. Рассчитаем коэффициент заполнения: 70 / 255 ≈ 0,27, то есть около 27 % от полной мощности. Малая скорость нужна, чтобы робот не опрокидывался при шаге.

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

  • Servo servo1; — создает объект сервопривода с именем servo1.

  • servo1.attach(9) — связывает объект с выводом 9, к которому подключен сервопривод.

  • servo1.write(угол) — поворачивает вал на угол от 0 до 180 градусов.

Центральное положение сервопривода в этом роботе — 80°, а не 90°. Оно подобрано так, чтобы при этом угле корпус стоял ровно: точное значение зависит от того, как сервопривод закреплен при сборке. Отклонение от центра — 20°. Значит, при наклоне в одну сторону вал поворачивается на 80 + 20 = 100°, в другую на 80 − 20 = 60°.

У контроллеров библиотека Servo.h занимает таймер, который формирует ШИМ на выводах 9 и 10. Пока работает сервопривод, analogWrite**(**) на этих выводах не действует. Поэтому для скорости моторов используются выводы 5 и 6.

Программа разбита на несколько собственных функций: initMotors**(**), forward**(**) и backward**(**). В работе с двумя кнопками функция handleClick**(**) возвращала результат типа bool. Эти функции ничего не возвращают, они только выполняют действия. Перед их именем стоит слово void, что в переводе с английского означает «пустота».

Разбиение на функции делает программу понятнее: loop**(**) состоит всего из двух строк, и по названиям сразу видно, что робот сначала идет вперед, потом назад.

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

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

image77

image78

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

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

В начале подключается библиотека Servo.h и объявляются переменные: номера выводов моторов (DIR_M1, SPEED_M1, DIR_M2, SPEED_M2), центральное положение сервопривода AY, отклонение Y и скорость моторов WS. Все они сначала равны нулю, а настоящие значения получают в функции initMotors**(**).

Функция initMotors**(**) задает выводы моторов: мотор 1 управляется выводами 4 (DIR) и 5 (SPEED), мотор 2 — выводами 7 (DIR) и 6 (SPEED). Здесь же задаются угол 80°, отклонение 20° и скорость 70, а все выводы моторов настраиваются на выход.

Функция setup**(**) вызывает initMotors**(**), подключает сервопривод к выводу 9 и ставит его в центральное положение. Функция loop**(**) по очереди вызывает forward**(**) и backward**(**).

Шаги.

Функция forward**(**) повторяет шаг три раза. Цикл for здесь считает не вверх, а вниз: i принимает значения 3, 2, 1, а запись i -= 1 означает то же, что i = i - 1. Когда i становится равным 0, условие i > 0 перестает выполняться, и цикл завершается.

Один шаг состоит из двух половин:

  1. Сервопривод наклоняет корпус на угол AY + Y, робот ждет 1 с, пока корпус займет положение.

  2. Оба мотора вращаются в направлении LOW со скоростью WS в течение 1 с, затем останавливаются.

  3. Сервопривод наклоняет корпус в другую сторону, на угол AY − Y, робот ждет 1 с.

  4. Оба мотора вращаются в направлении HIGH в течение 1 с, затем останавливаются.

При смене наклона меняется и направление вращения моторов. Главное здесь — сочетание наклона и направления: при наклоне AY + Y моторы крутятся в одну сторону, при наклоне AY − Y в другую.

Функция backward**(**) устроена так же, но наклоны идут в обратном порядке: сначала AY − Y, затем AY + Y. Моторы при этом по-прежнему включаются сначала в направлении LOW, потом HIGH. В результате каждому наклону соответствует противоположное направление вращения по сравнению с forward**(**), и робот идет назад.

Рассчитаем, сколько времени занимает движение. Один шаг — четыре паузы по 1 с, то есть 4 с. Три шага вперед — 12 с, три шага назад — еще 12 с. Полный цикл loop**(**) длится 24 с, после чего все повторяется.

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

Разработаем программу, которая управляет роботом «Кролик»: робот делает три шага вперед и три шага назад, наклоняя корпус из стороны в сторону.

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

Затем изменим отклонение Y с 20 на 10 и снова загрузим программу. Проверим, как меньший наклон влияет на длину шага и насколько устойчиво робот идет.

cpp
#include "Servo.h"   // библиотека для управления сервоприводом

int DIR_M1 = 0;      // пин направления мотора 1
int SPEED_M1 = 0;    // пин скорости мотора 1
int DIR_M2 = 0;      // пин направления мотора 2
int SPEED_M2 = 0;    // пин скорости мотора 2
int AY = 0;          // центральное положение сервопривода
int Y = 0;           // величина отклонения сервопривода от центра
int WS = 0;          // рабочая скорость моторов
Servo servo1;        // объект сервопривода

void setup() {
    initMotors();          // настраиваем пины и параметры моторов
    pinMode(9, OUTPUT);    // пин 9 — на выход (для сервопривода)
    servo1.attach(9);      // подключаем сервопривод к пину 9
    servo1.write(AY);      // ставим сервопривод в центральное положение
}

void loop() {
    forward();     // движение вперед с переваливанием
    backward();    // движение назад с переваливанием
}

// Настройка пинов и параметров моторов
void initMotors() {
    DIR_M1 = (int)4;    // мотор 1: направление на пине 4
    SPEED_M1 = (int)5;  // мотор 1: скорость на пине 5
    DIR_M2 = (int)7;    // мотор 2: направление на пине 7
    SPEED_M2 = (int)6;  // мотор 2: скорость на пине 6
    AY = (int)80;       // центральное положение сервопривода — 80°
    Y = (int)20;        // отклонение в сторону — 20°
    WS = (int)70;       // скорость моторов — 70
    pinMode(DIR_M1, OUTPUT);    // все пины моторов настраиваем на выход
    pinMode(DIR_M2, OUTPUT);
    pinMode(SPEED_M1, OUTPUT);
    pinMode(SPEED_M2, OUTPUT);
}

// Движение вперед с эффектом переваливания
void forward() {
    for (int i = 3; i > 0; i -= 1){   // повторяем цикл 3 раза
      servo1.write((AY + Y));         // наклоняем корпус в одну сторону
      delay(1000);                    // ждем 1 секунду
      digitalWrite(DIR_M1, LOW);      // задаем направление моторов вперед
      analogWrite(SPEED_M1, WS);      // включаем мотор 1 на рабочей скорости
      digitalWrite(DIR_M2, LOW);
      analogWrite(SPEED_M2, WS);      // включаем мотор 2
      delay(1000);                    // едем 1 секунду
      digitalWrite(DIR_M1, HIGH);     // останавливаем моторы (скорость 0)
      analogWrite(SPEED_M1, 0);
      digitalWrite(DIR_M2, HIGH);
      analogWrite(SPEED_M2, 0);
      servo1.write((AY - Y));         // наклоняем корпус в другую сторону
      delay(1000);                    // ждем 1 секунду
      digitalWrite(DIR_M1, HIGH);     // снова едем вперед
      analogWrite(SPEED_M1, WS);
      digitalWrite(DIR_M2, HIGH);
      analogWrite(SPEED_M2, WS);
      delay(1000);                    // едем 1 секунду
      digitalWrite(DIR_M1, HIGH);     // останавливаем моторы
      analogWrite(SPEED_M1, 0);
      digitalWrite(DIR_M2, HIGH);
      analogWrite(SPEED_M2, 0);
  }
}

// Движение назад с эффектом переваливания
void backward() {
    for (int i = 3; i > 0; i -= 1){   // повторяем цикл 3 раза
      servo1.write((AY - Y));         // наклоняем корпус в одну сторону
      delay(1000);
      digitalWrite(DIR_M1, LOW);      // задаем направление моторов назад
      analogWrite(SPEED_M1, WS);
      digitalWrite(DIR_M2, LOW);
      analogWrite(SPEED_M2, WS);
      delay(1000);                    // едем назад 1 секунду
      digitalWrite(DIR_M1, HIGH);     // останавливаем моторы
      analogWrite(SPEED_M1, 0);
      digitalWrite(DIR_M2, HIGH);
      analogWrite(SPEED_M2, 0);
      servo1.write((AY + Y));         // наклоняем корпус в другую сторону
      delay(1000);
      digitalWrite(DIR_M1, HIGH);     // снова едем назад
      analogWrite(SPEED_M1, WS);
      digitalWrite(DIR_M2, HIGH);
      analogWrite(SPEED_M2, WS);
      delay(1000);                    // едем 1 секунду
      digitalWrite(DIR_M1, HIGH);     // останавливаем моторы
      analogWrite(SPEED_M1, 0);
      digitalWrite(DIR_M2, HIGH);
      analogWrite(SPEED_M2, 0);
  }
}

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

image79

image80

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

image81

Контрольные вопросы ​

  1. Какими командами задается движение мобильного робота вперед и назад?

  2. Почему центральное положение сервопривода в программе робота «Кролик» равно 80°, а не 90°, и в какие положения поворачивается вал при наклонах корпуса?

  3. Что нужно проверить перед первым запуском модели?

2.19. Модель «Танк» ​

Цель: ​

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

Оборудование: ​

  • 3 двигателя постоянного тока;

  • модуль «Ультразвуковой дальномер»;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

image82

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

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

Для создания кода в данной работе используются уже изученные функции digitalWrite**(**), analogWrite**(**) для управления моторами, delay**(**) для пауз, pulseIn**(**) и delayMicroseconds**(**) для работы с ультразвуковым дальномером.

Моторы подключены через драйвер, как в роботе «Кролик»: для каждого мотора используются два сигнала. DIR задает направление вращения (LOW или HIGH), SPEED задает скорость ШИМ-сигналом от 0 до 255.

Моторы гусениц установлены зеркально: один смотрит валом влево, другой вправо. Чтобы обе гусеницы двигались вперед, валы моторов должны вращаться в противоположные стороны. Поэтому при движении вперед на один мотор подается HIGH, а на другой LOW. Для движения назад оба сигнала меняются на противоположные.

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

Если левая гусеница движется вперед, а правая назад, танк разворачивается направо на месте. Если наоборот, налево. Из-за зеркальной установки моторов для разворота на оба мотора подается один и тот же сигнал направления: при HIGH на обоих гусеницы движутся в разные стороны.

ДвижениеDIR мотора 1DIR мотора 2
впередHIGHLOW
назадLOWHIGH
направоHIGHHIGH
налевоLOWLOW

Даже одинаковые моторы вращаются с немного разной скоростью: сказываются погрешности изготовления и трение в редукторе. Из-за этого танк может уводить в сторону. В программе при движении вперед скорость левого мотора на единицу меньше: 59 вместо 60. Разница около 1,7 %, и ее подбирают опытным путем для конкретного танка.

Измерение расстояния ультразвуковым дальномером.

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

расстояние = время / 58

Сравним ее с прежней: расстояние = время × 0,034 / 2. Умножить на 0,034 и разделить на 2 — то же самое, что умножить на 0,017 или разделить на 1 / 0,017 ≈ 58,8. Число 58 соответствует скорости звука около 343 м/с, то есть при температуре примерно 20 °C. Оба способа дают почти одинаковый результат, но деление на целое число выполняется контроллером быстрее, чем умножение на дробное.

Дальномер подключен к выводам A4 (TRIG) и A5 (ECHO). Аналоговые входы контроллера умеют работать и как обычные цифровые выводы, поэтому их можно использовать для подачи и приема импульсов.

Если pulseIn**(**) не дождалась импульса, она возвращает 0. Поэтому программа реагирует на препятствие, только если расстояние больше нуля: иначе сбой измерения выглядел бы как препятствие вплотную.

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

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

image83

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

image84

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

Функция loop() вызывает одну функцию — ultraSound(). Она измеряет расстояние и выводит его в монитор порта, чтобы проверять работу дальномера. Затем программа решает, что делать дальше.

Если препятствие ближе 20 см, танк выполняет последовательность действий:

  1. Останавливается и ждет 1 с.

  2. Производит выстрел: третий мотор работает 1 с со скоростью 60 + 30 = 90.

  3. Отъезжает назад в течение 1 с.

  4. Разворачивается направо в течение 1,5 с.

  5. Останавливается на полсекунды.

После этого, как и в случае, когда препятствия нет, танк едет вперед.

Рассчитаем, сколько длится вся последовательность: 1 + 1 + 1 + 1,5 + 0,02 + 0,02 + 0,5 ≈ 5 с. Все это время дальномер не работает: функции delay**(**) останавливают программу.

В начале программы объявляются переменные для номеров выводов: DIR_M1, SPEED_M1, DIR_M2, SPEED_M2 для гусениц, DIR_M3, SPEED_M3 для мотора выстрела, trigPin, echoPin для дальномера. Там же объявлены переменные для скорости, длительности импульса и расстояния.

Функция initMotors**(**) задает номера выводов: гусеницы управляются выводами 4, 5, 6 и 7, мотор выстрела — выводами 8 и 3, дальномер — выводами A4 и A5. Все выводы моторов и TRIG настраиваются на выход, ECHO на вход. Функция carData**(**) задает базовую скорость движения 60, которая используется во всех режимах.

Функции forward**(**), backward**(**), turnRight**(**) и turnLeft**(**) задают движение по таблице выше. stopMoto**r**s(**)** останавливает оба мотора гусениц. shot**(****)** имитирует выстрел.

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

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

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

Затем проверим, на какой угол танк разворачивается за 1,5 с. Угол зависит от скорости моторов, заряда батареи и покрытия пола. Подберем время в строке delay(1500) так, чтобы танк разворачивался ровно на 90°, а затем на 180°.

cpp
int DIR_M1 = 0;      // пин направления мотора 1 (левая гусеница)
int SPEED_M1 = 0;    // пин скорости мотора 1
int DIR_M2 = 0;      // пин направления мотора 2 (правая гусеница)
int SPEED_M2 = 0;    // пин скорости мотора 2
int DIR_M3 = 0;      // пин направления мотора 3 (стрельба)
int SPEED_M3 = 0;    // пин скорости мотора 3
int trigPin = 0;     // пин TRIG ультразвукового дальномера
int echoPin = 0;     // пин ECHO ультразвукового дальномера
int speed = 0;       // базовая скорость движения
long duration = 0;   // длительность отраженного импульса
long distance = 0;   // расстояние до препятствия
cpp
void setup() {
    Serial.begin(9600);   // открываем последовательный порт для вывода расстояния
    initMotors();         // настраиваем пины моторов и дальномера
    carData();            // задаем базовую скорость
}
cpp
void loop() {
    ultraSound();   // измеряем расстояние и управляем поведением танка
}
cpp
// Настройка пинов моторов и ультразвукового дальномера
void initMotors() {
    DIR_M1 = (int)4;    // мотор 1: направление на пине 4
    SPEED_M1 = (int)5;  // мотор 1: скорость на пине 5
    DIR_M2 = (int)7;    // мотор 2: направление на пине 7
    SPEED_M2 = (int)6;  // мотор 2: скорость на пине 6
    DIR_M3 = (int)8;    // мотор 3: направление на пине 8
    SPEED_M3 = (int)3;  // мотор 3: скорость на пине 3
    trigPin = (int)A4;  // TRIG дальномера на пине A4
    echoPin = (int)A5;  // ECHO дальномера на пине A5
    pinMode(DIR_M1, OUTPUT);    // все пины моторов настраиваем на выход
    pinMode(DIR_M2, OUTPUT);
    pinMode(DIR_M3, OUTPUT);
    pinMode(SPEED_M1, OUTPUT);
    pinMode(SPEED_M2, OUTPUT);
    pinMode(SPEED_M3, OUTPUT);
    pinMode(trigPin, OUTPUT);   // TRIG — на выход (подаем импульс)
    pinMode(echoPin, INPUT);    // ECHO — на вход (принимаем отклик)
}
cpp
// Задание базовой скорости движения
void carData() {
    speed = (int)60;   // скорость 60
}
cpp
// Движение вперед (гусеницы крутятся в разные стороны драйвера)
void forward() {
    digitalWrite(DIR_M1, HIGH);
    analogWrite(SPEED_M1, (speed - 1));  // чуть медленнее, чтобы выровнять ход
    digitalWrite(DIR_M2, LOW);
    analogWrite(SPEED_M2, speed);
}
cpp
// Движение назад (направления моторов меняются на противоположные)
void backward() {
    digitalWrite(DIR_M1, LOW);
    analogWrite(SPEED_M1, speed);
    digitalWrite(DIR_M2, HIGH);
    analogWrite(SPEED_M2, speed);
}
cpp
// Остановка обоих гусеничных моторов
void stopMotors() {
    digitalWrite(DIR_M1, LOW);
    analogWrite(SPEED_M1, 0);
    digitalWrite(DIR_M2, LOW);
    analogWrite(SPEED_M2, 0);
}
cpp
// Разворот направо на месте (оба мотора в одном направлении)
void turnRight() {
    digitalWrite(DIR_M1, HIGH);
    analogWrite(SPEED_M1, speed);
    digitalWrite(DIR_M2, HIGH);
    analogWrite(SPEED_M2, speed);
}
cpp
// Разворот налево на месте (оба мотора в другом направлении)
void turnLeft() {
    digitalWrite(DIR_M1, LOW);
    analogWrite(SPEED_M1, speed);
    digitalWrite(DIR_M2, LOW);
    analogWrite(SPEED_M2, speed);
}
cpp
// Имитация выстрела: третий мотор на повышенной скорости в течение 1 секунды
void shot() {
    digitalWrite(DIR_M3, HIGH);
    analogWrite(SPEED_M3, (speed + 30));  // скорость выше базовой на 30
    delay(1000);                          // держим 1 секунду
    digitalWrite(DIR_M3, LOW);
    analogWrite(SPEED_M3, 0);             // выключаем мотор стрельбы
}
cpp
// Измерение расстояния и реакция на препятствие
void ultraSound() {
    delay(100);                     // небольшая пауза перед измерением
    digitalWrite(trigPin, LOW);
  delayMicroseconds(2);             // гасим триггер на 2 мкс
    digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);            // подаем импульс длиной 10 мкс
    digitalWrite(trigPin, LOW);
    duration = (long)pulseIn(echoPin, HIGH);  // измеряем длительность отклика
  ;
    distance = (long)(duration / 58);         // переводим время в сантиметры
cpp
    // Выводим измеренное расстояние в монитор порта
    Serial.println("Distance");
    Serial.println(distance);
    Serial.println("cm");
bash
    // Если препятствие ближе 20 см — выполняем боевую последовательность
    if (distance <= 20 && distance > 0) {
        stopMotors();       // останавливаемся
        delay(1000);        // ждем 1 секунду
        shot();             // производим выстрел
        backward();         // сдаем назад
        delay(1000);        // едем назад 1 секунду
        stopMotors();       // останавливаемся
        delay(20);
        turnRight();        // разворачиваемся направо
        delay(1500);        // крутимся 1,5 секунды
        stopMotors();       // останавливаемся
        delay(20);
        delay(500);         // небольшая пауза перед продолжением
  }
    forward();   // если препятствий нет — едем вперед
}

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

image85

image86

Модель робота «Кролик»

image87

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

image88

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

image89

image90

image91

image92

Модель робота «Танк»

Контрольные вопросы ​

  1. Почему при движении танка вперед на моторы гусениц подаются разные сигналы направления (HIGH и LOW), а при развороте на месте — одинаковые?

  2. Почему в программе танка расстояние вычисляется делением времени на 58, а в работе с ультразвуковым дальномером — по формуле время × 0,034 / 2? Дают ли эти формулы одинаковый результат?

  3. Зачем в условии реакции на препятствие стоит проверка distance > 0 и что произошло бы без нее?

2.20. Модель «Валли» ​

Цель: ​

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

Оборудование: ​

  • 2 двигателя постоянного тока;

  • сервопривод;

  • модуль «Ультразвуковой дальномер»;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

image93

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

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

Для создания кода в данной работе используется библиотека Servo.h для управления сервоприводом, а также функции digitalWrite**(**), analogWrite**(**) и pulseIn**(**) для работы с моторами и ультразвуковым дальномером.

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

Сервопривод поворачивает вал на заданный угол от 0 до 180 градусов. Угол задается ШИМ-сигналом: от длительности импульса зависит, в какое положение встанет вал. Формировать этот сигнал вручную не нужно, это делает библиотека Servo.h. Функция attach() связывает сервопривод с выводом контроллера, а функция write() задает угол.

Ультразвуковой дальномер HC-SR04 излучает ультразвуковой импульс и замеряет, через какое время вернется эхо. Функция pulseIn() измеряет длительность импульса на выводе ECHO, а по ней рассчитывается расстояние. Формула та же, что в работе с танком: время в микросекундах делится на 58, и получается расстояние в сантиметрах.

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

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

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

image94

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

image95

Разработаем программу для автономного управления роботом «Валли». Робот движется вперед. Обнаружив препятствие ближе 20 см, он останавливается, поднимает руки, отъезжает назад, разворачивается, опускает руки после маневра и продолжает движение в новом направлении.

В начале программы подключается библиотека Servo.h. Затем объявляются переменные для номеров выводов моторов (DIR_M1, SPEED_M1, DIR_M2, SPEED_M2) и дальномера (trigPin, echoPin), для скорости, длительности импульса и расстояния. Создается объект servo1 для управления сервоприводом.

В функции setup() вывод 9 настраивается для сервопривода, сервопривод подключается к нему и встает в начальное положение 10 градусов, руки опущены. Затем включается последовательный порт и вызываются функции initMotors() и carData().

Функция initMotors() задает выводы моторов: мотор 1 управляется выводами 4 (DIR) и 5 (SPEED), мотор 2 — выводами 7 (DIR) и 6 (SPEED). Дальномер подключен к выводам A4 (TRIG) и A5 (ECHO). Выводы моторов и TRIG работают на выход, ECHO на вход. Функция carData() задает базовую скорость движения 60.

Функция forward() отвечает за движение вперед. Чтобы робот ехал прямо, скорости моторов немного различаются: первый мотор получает полную скорость, второй на 13 единиц меньше. Так компенсируются механические различия моторов. Функция backward() отвечает за движение назад, stopMotors() останавливает оба мотора.

Функции turnRight() и turnLeft() разворачивают робота на месте, вращая гусеницы в разные стороны. Функции handsup() и handsdown() управляют сервоприводом: поднимают и опускают руки. При подъеме рук сервопривод поворачивается на 5 градусов, при опускании на 30 градусов. Задержка 750 мс дает сервоприводу время выполнить движение.

Основная логика находится в функции ultraSound(). Она измеряет расстояние до препятствия. Если оно меньше или равно 20 см, робот выполняет последовательность действий:

  1. Останавливается.

  2. Поднимает руки.

  3. Едет назад 1 с.

  4. Останавливается.

  5. Разворачивается направо в течение 1,5 с.

  6. Снова останавливается.

  7. Опускает руки.

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

Рассчитаем, сколько длится маневр. Сложим все паузы: 0,02 + 0,75 + 1 + 0,02 + 1,5 + 0,02 + 0,75 + 0,5 ≈ 4,6 с.

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

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

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

Затем проверим, едет ли робот прямо. Если его уводит в сторону, подберем значение 13 в строке analogWrite(SPEED_M2, (speed - 13)); так, чтобы робот двигался по прямой.

cpp
#include "Servo.h"   // библиотека для управления сервоприводом (руки робота)

int DIR_M1 = 0;      // пин направления мотора 1 (левая гусеница)
int SPEED_M1 = 0;    // пин скорости мотора 1
int DIR_M2 = 0;      // пин направления мотора 2 (правая гусеница)
int SPEED_M2 = 0;    // пин скорости мотора 2
int trigPin = 0;     // пин TRIG ультразвукового дальномера
int echoPin = 0;     // пин ECHO ультразвукового дальномера
int speed = 0;       // базовая скорость движения
long duration = 0;   // длительность отраженного импульса
long distance = 0;   // расстояние до препятствия
Servo servo1;        // объект сервопривода (руки)

void setup() {
    pinMode(9, OUTPUT);    // пин 9 — на выход (для сервопривода)
    servo1.attach(9);      // подключаем сервопривод к пину 9
    servo1.write(10);      // ставим руки в начальное положение (опущены)
    Serial.begin(9600);    // открываем последовательный порт для вывода расстояния
    initMotors();          // настраиваем пины моторов и дальномера
    carData();             // задаем базовую скорость
}

void loop() {
    ultraSound();   // измеряем расстояние и управляем поведением робота
}

// Настройка пинов моторов и ультразвукового дальномера
void initMotors() {
    DIR_M1 = (int)4;    // мотор 1: направление на пине 4
    SPEED_M1 = (int)5;  // мотор 1: скорость на пине 5
    DIR_M2 = (int)7;    // мотор 2: направление на пине 7
    SPEED_M2 = (int)6;  // мотор 2: скорость на пине 6
    trigPin = (int)A4;  // TRIG дальномера на пине A4
    echoPin = (int)A5;  // ECHO дальномера на пине A5
    pinMode(DIR_M1, OUTPUT);    // все пины моторов настраиваем на выход
    pinMode(DIR_M2, OUTPUT);
    pinMode(SPEED_M1, OUTPUT);
    pinMode(SPEED_M2, OUTPUT);
    pinMode(trigPin, OUTPUT);   // TRIG — на выход (подаем импульс)
    pinMode(echoPin, INPUT);    // ECHO — на вход (принимаем отклик)
}

// Задание базовой скорости движения
void carData() {
    speed = (int)60;   // скорость 60
}

// Движение вперед (скорости моторов немного разные для прямого хода)
void forward() {
    digitalWrite(DIR_M1, HIGH);
    analogWrite(SPEED_M1, speed);
    digitalWrite(DIR_M2, LOW);
    analogWrite(SPEED_M2, (speed - 13));  // второй мотор чуть медленнее — компенсация
}

// Движение назад (направления моторов противоположны)
void backward() {
    digitalWrite(DIR_M1, LOW);
    analogWrite(SPEED_M1, speed);
    digitalWrite(DIR_M2, HIGH);
    analogWrite(SPEED_M2, speed);
}

// Остановка обоих моторов
void stopMotors() {
    digitalWrite(DIR_M1, LOW);
    analogWrite(SPEED_M1, 0);
    digitalWrite(DIR_M2, LOW);
    analogWrite(SPEED_M2, 0);
}

// Разворот направо на месте (оба мотора в одном направлении)
void turnRight() {
    digitalWrite(DIR_M1, HIGH);
    analogWrite(SPEED_M1, speed);
    digitalWrite(DIR_M2, HIGH);
    analogWrite(SPEED_M2, speed);
}

// Опускание рук робота
void handsdown() {
    servo1.write(30);   // поворачиваем сервопривод на 30°
    delay(750);         // ждем завершения движения
}

// Разворот налево на месте (оба мотора в другом направлении)
void turnLeft() {
    digitalWrite(DIR_M1, LOW);
    analogWrite(SPEED_M1, speed);
    digitalWrite(DIR_M2, LOW);
    analogWrite(SPEED_M2, speed);
}

// Подъем рук робота
void handsup() {
    servo1.write(5);    // поворачиваем сервопривод на 5°
    delay(750);         // ждем завершения движения
}

// Измерение расстояния и реакция на препятствие
void ultraSound() {
    delay(100);                     // небольшая пауза перед измерением
    digitalWrite(trigPin, LOW);
  delayMicroseconds(2);             // гасим триггер на 2 мкс
    digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);            // подаем импульс длиной 10 мкс
    digitalWrite(trigPin, LOW);
    duration = (long)pulseIn(echoPin, HIGH);  // измеряем длительность отклика
    distance = (long)(duration / 58);         // переводим время в сантиметры

    // Выводим измеренное расстояние в монитор порта
    Serial.println("Distance");
    Serial.println(distance);
    Serial.println("cm");

    // Если препятствие ближе 20 см — реагируем «эмоционально»
    if (distance <= 20 && distance > 0) {
        stopMotors();       // останавливаемся
        delay(20);
        handsup();          // поднимаем руки (удивление)
        backward();         // сдаем назад
        delay(1000);        // едем назад 1 секунду
        stopMotors();       // останавливаемся
        delay(20);
        turnRight();        // разворачиваемся направо
        delay(1500);        // крутимся 1,5 секунды
        stopMotors();       // останавливаемся
        delay(20);
        handsdown();        // опускаем руки
        delay(500);         // небольшая пауза перед продолжением
  }
    forward();   // если препятствий нет — едем вперед
}

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

image96

image97

image98

image99

image100

image101

Контрольные вопросы ​

  1. Как реализуется поворот гусеничной платформы?

  2. Как ультразвуковой дальномер используется для объезда препятствий?

  3. Как согласовать работу нескольких моторов?

2.21. Модель «Балансировщик» ​

Цель: ​

Освоить построение балансирующего робота на двух колесах, научиться определять угол наклона с помощью инерциального датчика и применять ПИД-регулятор для удержания робота в вертикальном положении.

Оборудование: ​

  • 2 двигателя постоянного тока;

  • модуль «Инерциальный датчик»;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

image102

Двухколесный балансирующий робот удерживает вертикальное положение за счет его колес, которые постоянно движутся. Похожим образом удерживают на ладони поставленную вертикально ручку, палку: как только она начинает падать вперед, ладонь сдвигается вперед, под нее. Это классическая задача об инвертированном, то есть перевернутом, маятнике. Груз обычного маятника висит под точкой опоры и сам возвращается в нижнее положение. У перевернутого маятника груз находится над точкой опоры, и без постоянной подстройки он падает. Робот все время корректирует свое положение, чтобы не упасть. Основа управления — ПИД-регулятор. Он сравнивает текущий угол наклона с заданным, вертикальным, и по разнице между ними, сигналу ошибки, решает, как вращать колеса.

Корпус робота собран из деталей конструктора. По бокам расположены два колеса с резиновыми шинами, каждое колесо вращает свой двигатель постоянного тока. В центре корпуса закреплен блок-контроллер ЭДУино, спереди вертикально установлен модуль «Инерциальный датчик». Опоры, кроме двух колес, у робота нет: он касается пола только в двух точках, которые лежат на одной прямой. Стоять вертикально сам по себе такой робот не может. Держать равновесие его заставляет только верно написанная программа.

Угол наклона робота измеряет инерциальный датчик. Акселерометр определяет угол относительно земли, но его показания имеют погрешность: толчки и вибрации моторов искажают результат. Гироскоп измеряет угловую скорость. Если ее интегрировать, то есть складывать повороты за много малых промежутков времени, получится угол. Но при этом накапливается ошибка, и через некоторое время значение угла начинает «уплывать». Чтобы получить точный и стабильный угол, используется фильтр Калмана, который объединяет данные обоих приборов.

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

Энкодеры бывают оптическими и магнитными. Оптический энкодер — это диск с прорезями на валу мотора и датчик света: при вращении прорези по очереди пропускают и перекрывают свет, и датчик выдает импульсы. Магнитный энкодер работает так же, но вместо диска с прорезями на валу стоит магнит, а вместо датчика света — датчик магнитного поля.

Энкодер с двумя каналами, A и B, называют квадратурным. Датчики каналов расположены так, что их сигналы сдвинуты на четверть периода. Если колесо вращается в одну сторону, канал A переключается на четверть шага раньше канала B, если в другую — позже. Поэтому по двум сигналам можно определить не только, на сколько повернулось колесо, но и в какую сторону.

Для программы понадобятся библиотеки Adafruit_MPU6050 для работы с инерциальным датчиком, Wire для обмена данными по интерфейсу I2C и math.h для математических вычислений.

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

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

image103

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

image104

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

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

В начале программы подключаются необходимые библиотеки: Adafruit_MPU6050 для работы с инерциальным датчиком, Adafruit_Sensor для работы с сенсорами, Wire для I2C-обмена и math.h для математических вычислений. Затем задаются выводы моторов и энкодеров. Каждым мотором управляют два вывода: PWM задает скорость, DIR — направление вращения. Энкодеры подключены к аналоговым входам и отслеживают положение колес, это нужно для удержания робота на месте.

После выводов объявляются переменные для показаний энкодеров. У каждого энкодера два канала, A и B. Их сигналы сдвинуты относительно друг друга: при вращении в одну сторону первым переключается канал A, в другую — канал B. По тому, какой канал переключился раньше, программа определяет направление вращения. Переменные encoder**1**LastState и encoder**2**LastState хранят предыдущие состояния энкодеров, по ним вычисляется шаг поворота. В зависимости от направления вращения количество тиков увеличивается или уменьшается.

Далее объявляются переменные для работы с MPU6050. Показания акселерометра и гироскопа хранятся в переменных accX, accY, accZ и gyroY. Переменные accXCal, accYCal, accZCal и gyroYCal служат для калибровки датчика: они компенсируют смещение нуля, то есть ненулевые показания неподвижного датчика. Переменные kalmanAngle и kalmanUncertainty нужны для фильтра Калмана, который объединяет показания акселерометра и гироскопа и дает более точный и стабильный угол наклона.

ПИД-регулятор настраивается тремя константами: BALANCE_KP, BALANCE_KI и BALANCE_KD. Коэффициент KP отвечает за пропорциональную составляющую: чем больше робот отклонился от вертикали, тем сильнее моторы возвращают его в равновесие. Например, при отклонении на 2° пропорциональная составляющая равна 14 × 2 = 28. Коэффициент KI отвечает за интегральную составляющую. Она устраняет постоянную ошибку и помогает роботу держать вертикаль при внешних воздействиях. Коэффициент KD отвечает за дифференциальную составляющую, которая сглаживает колебания и не дает роботу проскакивать положение равновесия. Отдельно настраиваются параметры удержания позиции, которые не дают роботу уезжать в сторону.

В функции setup**(**) после настройки выводов запускается MPU6050. Если датчик не обнаружен, программа останавливается. Для датчика задаются диапазон акселерометра ±8G, диапазон гироскопа ±500 градусов в секунду и полоса фильтра 21 Гц. Затем гироскоп калибруется: программа 1000 раз считывает его показания и находит среднее. Это среднее вычитается из всех последующих показаний, чтобы компенсировать смещение нуля.

Функция loop**(**) работает непрерывно. На каждом повторе обновляются данные энкодеров и MPU6050, а показание гироскопа исправляется на калибровочное значение. По данным акселерометра вычисляется угол наклона робота с помощью функции atan2. Из курса геометрии известно, что тангенс острого угла прямоугольного треугольника равен отношению противолежащего катета к прилежащему. Арктангенс решает обратную задачу: по отношению сторон находит угол. Функция atan2 находит арктангенс отношения вертикальной и горизонтальной составляющих ускорения. Результат она выдает в радианах, поэтому в программе он умножается на 180 / π и переводится в градусы. Затем вызывается функция updateKalman, которая с помощью фильтра Калмана сглаживает показания и уточняет угол.

В основном цикле также отслеживается время для управляющих вычислений. Каждые 10 миллисекунд, то есть 100 раз в секунду, вызываются функции updateEncoders**(**) для обновления показаний энкодеров, updateWheelState**(**) для расчета скорости колес, updatePositionHold**(**) для удержания позиции и computeBalancePid**(**) для расчета управляющего сигнала. Так управление обновляется регулярно, с постоянной частотой.

Функция updateEncoders**(**) опрашивает энкодеры. Она считывает состояния двух каналов каждого энкодера и определяет, в какую сторону вращается колесо. Состояния двух каналов объединяются в одно двоичное число: запись (B << 1) | A сдвигает значение канала B на один разряд влево и дописывает справа значение канала A. Получается число от 0 до 3. Для определения направления используется таблица переходов между этими четырьмя состояниями. По текущему и предыдущему состоянию из таблицы выбирается шаг энкодера (+1 или −1), который прибавляется к общему счетчику тиков. Так программа все время знает, сколько оборотов сделало каждое колесо и в каком направлении.

Функция updateWheelState**(**) вычисляет скорость вращения колес. Она вычитает из текущих показаний энкодеров предыдущие и получает, на сколько тиков повернулись колеса за прошедший интервал. Эта разница делится на длительность интервала, и получается скорость в тиках в секунду. Чтобы скорость не менялась скачками, ее сглаживает фильтр: он усредняет текущее значение с предыдущим с заданным коэффициентом. Так управляющий сигнал не дергается.

Функция updatePositionHold**(**) удерживает робота на месте. Пока робот не встал устойчиво вертикально, она ждет, чтобы угол наклона продержался в допустимых пределах 500 миллисекунд. После этого программа запоминает текущее положение колес и включает режим удержания позиции. В этом режиме отслеживаются отклонение колес от запомненного положения и скорость их вращения. Если робот начинает уезжать, рассчитывается поправка к заданному углу наклона. Робот наклоняется в противоположную сторону и возвращается на место.

Функция computeBalancePid**(**) выполняет основной алгоритм балансировки. Она вычисляет ошибку — разницу между заданным углом (установочной точкой) и текущим углом наклона. Ошибка умножается на коэффициент KP, получается пропорциональная составляющая. Интегральная составляющая накапливает ошибку с течением времени и умножается на KI. Дифференциальная составляющая — это угловая скорость с гироскопа, умноженная на KD. Все три составляющие складываются, а результат ограничивается максимальным значением ШИМ. Положительное значение означает, что робот должен двигаться вперед, отрицательное — назад.

Функция driveMotors**(**) превращает рассчитанное значение в сигналы для моторов. Модуль числа задает скорость, знак — направление вращения. Для каждого мотора через вывод DIR задается направление, а на вывод PWM подается значение скорости. Если команда равна нулю, оба мотора останавливаются.

Функция readMpuData**(**) считывает данные с MPU6050. Показания акселерометра переводятся в единицы G делением на 9,81 и исправляются на калибровочные значения. Показания гироскопа переводятся из радиан в градусы, чтобы во всей остальной программе работать с углами в градусах.

Фильтр Калмана в функции updateKalman**()** работает так. На каждом шаге программа предсказывает текущий угол по предыдущему углу и показанию гироскопа. Затем она оценивает, насколько это предсказание может быть неточным. По соотношению неточности предсказания и шума измерений вычисляется коэффициент усиления Калмана. С этим коэффициентом угол исправляется по показанию акселерометра. Такой способ дает более точный угол наклона, чем один акселерометр или один гироскоп.

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

Загрузим программу в контроллер. После включения питания робот первые 3–4 секунды калибрует гироскоп: все это время он должен лежать неподвижно, иначе смещение нуля будет найдено неверно, и робот не сможет удержать равновесие. После калибровки поставим робота вертикально и придержим рукой. Когда угол наклона полсекунды продержится близким к вертикали, программа запомнит положение колес и включит удержание позиции. Отпустим робота: он должен стоять на месте, слегка покачиваясь.

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

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

Если робот постоянно уезжает в одну сторону или падает в одну сторону, значит, угол равновесия для этого экземпляра робота отличается от заданного. Изменим значение BASE_BALANCE_ANGLE на 0,5° в ту или другую сторону и снова проверим.

cpp
#include <Adafruit_MPU6050.h> // библиотека для работы с датчиком MPU6050
#include <Adafruit_Sensor.h>  // общая библиотека Adafruit для датчиков
#include <Wire.h>             // библиотека для обмена данными по I2C
#include <math.h>             // математические функции (atan2, sqrt и др.)

const int RIGHT_PWM_PIN = 5;  // пин скорости правого мотора (ШИМ)
const int LEFT_PWM_PIN = 6;   // пин скорости левого мотора (ШИМ)
const int RIGHT_DIR_PIN = 4;  // пин направления правого мотора
const int LEFT_DIR_PIN = 7;   // пин направления левого мотора

int encoder1PinA = A2;        // канал A энкодера 1 (правое колесо)
int encoder1PinB = A3;        // канал B энкодера 1

int encoder2PinA = A0;        // канал A энкодера 2 (левое колесо)
int encoder2PinB = A1;        // канал B энкодера 2

long encoder1Position = 0;    // накопленное число тиков энкодера 1
long encoder2Position = 0;    // накопленное число тиков энкодера 2

int encoder1LastState = 0;    // предыдущее состояние каналов энкодера 1
int encoder2LastState = 0;    // предыдущее состояние каналов энкодера 2

Adafruit_MPU6050 mpu;         // объект инерциального датчика

double accX = 0.0;            // ускорение по оси X
double accY = 0.0;            // ускорение по оси Y
double accZ = 0.0;            // ускорение по оси Z
double gyroY = 0.0;           // угловая скорость вокруг оси Y

double accXCal = 0.01;        // калибровочная поправка ускорения по X
double accYCal = 0.0;         // калибровочная поправка ускорения по Y
double accZCal = 0.05;        // калибровочная поправка ускорения по Z
double gyroYCal = 0.0;        // калибровочная поправка гироскопа (смещение нуля)

double kalmanAngle = 0.0;         // угол наклона после фильтра Калмана
double kalmanUncertainty = 0.25;  // текущая неопределенность оценки угла
double anglePitch = 0.0;          // рабочий угол наклона корпуса

const double MPU_SAMPLE_TIME = 0.004;   // шаг времени для предсказания угла (с)
const double BALANCE_KP = 14.0;         // пропорциональный коэффициент PID
const double BALANCE_KI = 0.03;         // интегральный коэффициент PID
const double BALANCE_KD = 0.36;         // дифференциальный коэффициент PID
const double MAX_BALANCE_I = 255.0;     // ограничение интегральной составляющей
const int MAX_MOTOR_PWM = 70;           // максимальный ШИМ на моторы
const double BASE_BALANCE_ANGLE = -11.7; // угол равновесия (вертикали) корпуса

double balanceIntegral = 0.0;   // накопитель интегральной составляющей

const double POSITION_KP = 0.006;            // коэффициент удержания позиции
const double SPEED_KD = 0.012;               // коэффициент по скорости колес
const double PREDICTION_TIME = 0.12;         // время предсказания положения (с)
const double MAX_ANGLE_CORRECTION = 2.2;     // макс. поправка к углу равновесия
const double CORRECTION_FILTER_ALPHA = 0.12; // коэффициент фильтра поправки
const double MAX_CORRECTION_RATE_DPS = 5.0;  // макс. скорость изменения поправки (°/с)
const double POSITION_CONTROL_SIGN = 1.0;    // знак направления коррекции
const double POSITION_DEADBAND_TICKS = 4.0;  // «мертвая зона» по позиции (тики)
const double SPEED_DEADBAND_TPS = 8.0;       // «мертвая зона» по скорости (тик/с)
const long HOLD_ARM_DELAY_MS = 500;          // время устойчивости перед включением удержания
const double HOLD_ARM_ANGLE_ERROR = 7.0;     // допустимая ошибка угла для включения удержания
const double SPEED_FILTER_ALPHA = 0.20;      // коэффициент фильтра скорости колес
const double POSITION_LOOP_DT = 0.01;        // период контура удержания позиции (с)

bool positionHoldArmed = false;          // включен ли режим удержания позиции
long stableSinceMs = 0;                  // момент, с которого корпус устойчив
double targetPositionTicks = 0.0;        // запомненная целевая позиция колес
double wheelPositionTicks = 0.0;         // текущая усредненная позиция колес
double wheelSpeedTicksPerSecond = 0.0;   // текущая скорость колес
double filteredWheelSpeed = 0.0;         // сглаженная скорость колес
double positionAngleCorrection = 0.0;    // текущая поправка к углу равновесия
double activeSetpoint = -11.7;           // рабочая установочная точка угла

long previousRightTicks = 0;    // тики правого колеса на прошлом шаге
long previousLeftTicks = 0;     // тики левого колеса на прошлом шаге
long previousControlUs = 0;     // время прошлого запуска контура управления (мкс)
long loopTimerUs = 0;           // таймер для выдержки частоты основного цикла

void setup() {
  Wire.begin();   // запускаем шину I2C

  pinMode(RIGHT_PWM_PIN, OUTPUT);   // все пины моторов настраиваем на выход
  pinMode(LEFT_PWM_PIN, OUTPUT);
  pinMode(RIGHT_DIR_PIN, OUTPUT);
  pinMode(LEFT_DIR_PIN, OUTPUT);

  initEncoders();   // настраиваем пины энкодеров и считываем их начальное состояние
  stopMotors();     // на старте моторы стоят

  // Если датчик не найден — крутимся на месте с остановленными моторами
  if (!mpu.begin()) {
    while (true) {
      stopMotors();
    }
  }

  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);   // диапазон акселерометра ±8G
  mpu.setGyroRange(MPU6050_RANGE_500_DEG);        // диапазон гироскопа ±500 °/с
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);     // полоса фильтра 21 Гц

  // Калибровка гироскопа: 1000 раз считываем и усредняем показания,
  // чтобы найти смещение нуля
  for (int i = 0; i < 1000; i++) {
    readMpuData();
    gyroYCal = gyroYCal + gyroY;
    delay(3);
  }
  gyroYCal = gyroYCal / 1000.0;   // среднее значение смещения

  previousRightTicks = encoder1Position;   // запоминаем стартовые значения энкодеров
  previousLeftTicks = encoder2Position;
  previousControlUs = micros();            // засекаем время для контуров управления
  loopTimerUs = micros();
}

void loop() {
  updateEncoders();   // опрашиваем энкодеры как можно чаще, чтобы не терять тики
  readMpuData();      // считываем свежие данные с MPU6050
  updateEncoders();
  gyroY = gyroY - gyroYCal;   // убираем смещение нуля гироскопа

  // Вычисляем угол наклона по акселерометру (в градусах)
  double accelerometerPitch = atan2(accZ, sqrt(accX * accX + accY * accY)) * 180.0 / PI;
  updateKalman(gyroY, accelerometerPitch);   // уточняем угол фильтром Калмана
  updateEncoders();
  anglePitch = kalmanAngle;   // берем отфильтрованный угол как рабочий

  long nowUs = micros();
  long elapsedUs = nowUs - previousControlUs;

  // Контур управления запускаем раз в 10 мс
  if (elapsedUs >= 10000) {
    double dt = elapsedUs / 1000000.0;   // прошедшее время в секундах
    previousControlUs = nowUs;

    updateEncoders();
    updateWheelState(dt);   // считаем позицию и скорость колес

    // Балансировочный PID работает непрерывно. Он не ждет достижения
    // порога падения и не отключается при отклонении корпуса.
    updatePositionHold();                    // корректируем удержание позиции
    updateEncoders();
    driveMotors(computeBalancePid(dt));      // считаем PID и подаем команду на моторы
  }

  // Держим частоту основного цикла ~4 мс, продолжая опрашивать энкодеры
  while (micros() - loopTimerUs < 4000) {
    updateEncoders();
  }
  loopTimerUs = micros();
}

// Настройка пинов энкодеров и чтение их начального состояния
void initEncoders() {
  pinMode(encoder1PinA, INPUT_PULLUP);   // входы с подтяжкой к питанию
  pinMode(encoder1PinB, INPUT_PULLUP);
  pinMode(encoder2PinA, INPUT_PULLUP);
  pinMode(encoder2PinB, INPUT_PULLUP);

  // Кодируем состояние двух каналов в одно число (0–3)
  int stateA1 = digitalRead(encoder1PinA);
  int stateB1 = digitalRead(encoder1PinB);
  encoder1LastState = (stateB1 << 1) | stateA1;

  int stateA2 = digitalRead(encoder2PinA);
  int stateB2 = digitalRead(encoder2PinB);
  encoder2LastState = (stateB2 << 1) | stateA2;
}

// Опрос энкодеров и подсчет тиков с учетом направления вращения
void updateEncoders() {
  int currentState1 = (digitalRead(encoder1PinB) << 1) | digitalRead(encoder1PinA);
  int currentState2 = (digitalRead(encoder2PinB) << 1) | digitalRead(encoder2PinA);

  // Таблица переходов: по паре «прошлое+текущее состояние» дает шаг +1, -1 или 0
  static const int8_t direction[] = {
     0,  1, -1,  0,
    -1,  0,  0,  1,
     1,  0,  0, -1,
     0, -1,  1,  0
  };

  // Прибавляем шаг, выбранный из таблицы по индексу (прошлое<<2 | текущее)
  encoder1Position += direction[(encoder1LastState << 2) | currentState1];
  encoder2Position += direction[(encoder2LastState << 2) | currentState2];
  encoder1LastState = currentState1;   // запоминаем текущее состояние как прошлое
  encoder2LastState = currentState2;
}

// Расчет позиции и скорости колес за прошедший интервал dt
void updateWheelState(double dt) {
  long rightTicks = encoder1Position;
  long leftTicks = encoder2Position;

  long rightDelta = rightTicks - previousRightTicks;   // прирост тиков справа
  long leftDelta = leftTicks - previousLeftTicks;      // прирост тиков слева

  previousRightTicks = rightTicks;
  previousLeftTicks = leftTicks;

  wheelPositionTicks = 0.5 * (rightTicks + leftTicks);   // средняя позиция двух колес

  double rawSpeed = 0.5 * (rightDelta / dt + leftDelta / dt);   // сырая средняя скорость
  // Сглаживаем скорость фильтром, чтобы убрать резкие скачки
  filteredWheelSpeed = filteredWheelSpeed + SPEED_FILTER_ALPHA * (rawSpeed - filteredWheelSpeed);
  wheelSpeedTicksPerSecond = filteredWheelSpeed;
}

// Удержание робота на месте: корректирует заданный угол наклона
void updatePositionHold() {
  double baseAngleError = BASE_BALANCE_ANGLE - anglePitch;   // отклонение от вертикали

  // Пока режим удержания не включен — ждем, когда робот устойчиво встанет
  if (!positionHoldArmed) {
    positionAngleCorrection = 0.0;
    activeSetpoint = BASE_BALANCE_ANGLE;

    // Если корпус близок к вертикали...
    if (abs(baseAngleError) <= HOLD_ARM_ANGLE_ERROR) {
      if (stableSinceMs == 0) {
        stableSinceMs = millis();   // засекаем начало устойчивости
      }

      // ...и держится так дольше заданного времени — включаем удержание позиции
      if (millis() - stableSinceMs >= HOLD_ARM_DELAY_MS) {
        targetPositionTicks = wheelPositionTicks;   // запоминаем текущее место
        positionHoldArmed = true;
        balanceIntegral = 0.0;
      }
    } else {
      stableSinceMs = 0;   // потеряли устойчивость — сбрасываем таймер
    }

    return;
  }

  double positionError = wheelPositionTicks - targetPositionTicks;   // насколько уехали
  double speed = wheelSpeedTicksPerSecond;

  // «Мертвая зона»: мелкие отклонения и скорости игнорируем
  if (abs(positionError) < POSITION_DEADBAND_TICKS) {
    positionError = 0.0;
  }

  if (abs(speed) < SPEED_DEADBAND_TPS) {
    speed = 0.0;
  }

  // Предсказываем будущее отклонение с учетом текущей скорости
  double predictedPositionError = positionError + speed * PREDICTION_TIME;
  double requestedCorrection = POSITION_CONTROL_SIGN * (POSITION_KP * predictedPositionError + SPEED_KD * speed);
  requestedCorrection = constrain(requestedCorrection, -MAX_ANGLE_CORRECTION, MAX_ANGLE_CORRECTION);

  // Сглаживаем поправку и ограничиваем скорость ее изменения
  double filteredCorrection = positionAngleCorrection + CORRECTION_FILTER_ALPHA * (requestedCorrection - positionAngleCorrection);
  double maxStep = MAX_CORRECTION_RATE_DPS * POSITION_LOOP_DT;
  double correctionStep = constrain(filteredCorrection - positionAngleCorrection, -maxStep, maxStep);

  positionAngleCorrection = positionAngleCorrection + correctionStep;
  activeSetpoint = BASE_BALANCE_ANGLE + positionAngleCorrection;   // новая цель по углу
}

// Основной PID-регулятор балансировки: возвращает команду на моторы
int computeBalancePid(double dt) {
  double error = activeSetpoint - anglePitch;   // ошибка по углу
  double proportional = BALANCE_KP * error;     // пропорциональная составляющая

  // Интегральная составляющая с ограничением
  balanceIntegral = balanceIntegral + BALANCE_KI * error * dt;
  balanceIntegral = constrain(balanceIntegral, -MAX_BALANCE_I, MAX_BALANCE_I);

  double derivative = -BALANCE_KD * gyroY;   // дифференциальная составляющая (по гироскопу)
  double output = proportional + balanceIntegral + derivative;   // суммируем три части
  double roundedOutput = round(output);
  // Ограничиваем результат допустимым диапазоном ШИМ
  double limitedOutput = constrain(roundedOutput, -MAX_MOTOR_PWM, MAX_MOTOR_PWM);
  return limitedOutput;
}

// Подача команды на моторы: знак задает направление, модуль — скорость
void driveMotors(int command) {
  int pwm = abs(command);   // скорость — модуль команды

  if (command > 0) {                          // едем вперед
    digitalWrite(RIGHT_DIR_PIN, HIGH);
    digitalWrite(LEFT_DIR_PIN, LOW);
  } else {
    if (command < 0) {                        // едем назад
      digitalWrite(RIGHT_DIR_PIN, LOW);
      digitalWrite(LEFT_DIR_PIN, HIGH);
    } else {                                  // команда 0 — стоим
      analogWrite(RIGHT_PWM_PIN, 0);
      analogWrite(LEFT_PWM_PIN, 0);
      return;
    }
  }

  analogWrite(RIGHT_PWM_PIN, pwm);   // подаем скорость на оба мотора
  analogWrite(LEFT_PWM_PIN, pwm);
}

// Полная остановка моторов
void stopMotors() {
  analogWrite(RIGHT_PWM_PIN, 0);
  analogWrite(LEFT_PWM_PIN, 0);
  digitalWrite(RIGHT_DIR_PIN, LOW);
  digitalWrite(LEFT_DIR_PIN, LOW);
}

// Считывание данных с MPU6050 и приведение к удобным единицам
void readMpuData() {
  sensors_event_t acceleration;   // структуры для показаний датчика
  sensors_event_t gyro;
  sensors_event_t temperature;
  mpu.getEvent(&acceleration, &gyro, &temperature);

  // Ускорение переводим в единицы G (деля на 9.81) и вычитаем калибровку
  accX = acceleration.acceleration.x / 9.81 - accXCal;
  accY = acceleration.acceleration.y / 9.81 - accYCal;
  accZ = acceleration.acceleration.z / 9.81 - accZCal;
  gyroY = gyro.gyro.y * 180.0 / PI;   // угловую скорость переводим из рад/с в °/с
}

// Фильтр Калмана: объединяет данные гироскопа и акселерометра
void updateKalman(double gyroInput, double accelerometerMeasurement) {
  kalmanAngle = kalmanAngle + MPU_SAMPLE_TIME * gyroInput;   // предсказание угла по гироскопу
  kalmanUncertainty = kalmanUncertainty + 0.002;             // растет неопределенность

  // Коэффициент усиления Калмана (баланс между предсказанием и измерением)
  double gain = kalmanUncertainty / (kalmanUncertainty + 1.5 * 1.5);
  // Корректируем угол показанием акселерометра
  kalmanAngle = kalmanAngle + gain * (accelerometerMeasurement - kalmanAngle);
  kalmanUncertainty = kalmanUncertainty * (1.0 - gain);   // уменьшаем неопределенность
}

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

image105

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

image106

image107

image108

image109

image110

image111

image112

Модель робота «Балансировщик»

image113

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

image114

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

image115

image116

image117

Контрольные вопросы ​

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

  2. Почему угол наклона нельзя точно определить только акселерометром или только гироскопом, и как эту задачу решает фильтр Калмана?

  3. За что отвечает каждая из трёх составляющих ПИД-регулятора?

2.22. Модель «Платформа всенаправленного движения» ​

Цель: ​

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

Оборудование: ​

  • 4 двигателя постоянного тока;

  • сервопривод большой;

  • сервопривод малый;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

image118

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

Модель оснащена четырьмя независимыми моторами, что обеспечивает высокую маневренность и проходимость. Каждым мотором управляют два сигнала: DIR задает направление вращения, SPEED — скорость. Дифференциальное управление позволяет платформе двигаться вперед и назад, а также разворачиваться на месте за счет вращения колес в разные стороны.

Колесо всенаправленного движения (**Mecanum**) изобрел шведский инженер Бенгт Илон в 1973 году, когда работал в компании Mecanum AB. По ободу такого колеса вместо сплошной шины расположены небольшие ролики, которые свободно вращаются на своих осях. Оси роликов повернуты на 45° к оси колеса.

Обычное колесо толкает робота вдоль своего направления, вперед или назад. Колесо всенаправленного движения из-за наклонных роликов толкает его под углом 45°: частично вперед, частично вбок. Колеса на платформе устанавливают так, чтобы ролики левого переднего и правого заднего колеса были наклонены в одну сторону, а правого переднего и левого заднего — в другую. Если посмотреть на платформу сверху, ролики образуют букву X.

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

Движение платформыЛевое переднееПравое переднееЛевое заднееПравое заднее
впередвпередвпередвпередвперед
вправо, бокомвпередназадназадвперед
разворот направовпередназадвпередназад

В таблице направления указаны для колес, а не для сигналов DIR. Какой сигнал соответствует вращению колеса вперед, зависит от того, как установлен мотор: как у танка, моторы на левой и правой стороне стоят зеркально.

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

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

Манипулятор — устройство, которое выполняет движения, похожие на движения человеческой руки. Независимые движения, которые может выполнять манипулятор, называют степенями подвижности. У манипулятора этого робота две степени подвижности: подъем и сжатие захвата. Промышленные роботы-манипуляторы на автомобильных заводах обычно имеют шесть степеней подвижности. Этого достаточно, чтобы поднести инструмент к любой точке рабочей зоны под любым углом.

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

Для создания кода в данной работе используется библиотека Servo.h для управления двумя сервоприводами, а также функции digitalWrite() и analogWrite() для управления четырьмя моторами через драйвер.

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

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

image119

image120

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

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

В начале программы подключается библиотека Servo.h для управления двумя сервоприводами. Объявляются переменные для пинов четырех моторов, скорости и объектов сервоприводов.

Функция initMotors() настраивает пины моторов: моторы 1 и 2 подключаются к пинам 4, 5, 7, 6, моторы 3 и 4 – к пинам 8, 3, 12, 11. Все пины настраиваются на выход.

Функция carData() устанавливает базовую скорость движения.

Функции движения forward(), backward(), turnRight(), turnLeft() и stopMotors() управляют четырьмя моторами. При движении вперед моторы 1 и 3 вращаются в одном направлении, а моторы 2 и 4 – в противоположном, что обеспечивает движение по прямой. При поворотах все моторы вращаются в одном направлении, что позволяет разворачиваться на месте.

Функции управления манипулятором: grabItem() сжимает захват (угол 30 градусов), releaseItem() разжимает (угол 40 градусов), gripperDown() опускает манипулятор (угол 40 градусов), gripperUp() поднимает манипулятор (угол 200 градусов). Все функции содержат задержку 750 мс для выполнения движения.

В функции loop() запрограммирована сложная последовательность действий: захват объекта, транспортировка, развороты, освобождение объекта в другой зоне и возврат. Эта последовательность демонстрирует возможности робота по выполнению автоматизированных операций.

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

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

Проверим, на какой угол робот поворачивает за 1065 мс и за 1060 мс. Если угол отличается от нужного, изменим время в строках delay(1065); и delay(1060);. Затем понаблюдаем, возвращается ли робот после полного повтора loop() в исходную точку или с каждым повтором смещается.

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

cpp
#include "Servo.h"   // библиотека для управления сервоприводами (захват и подъем)

int DIR_M1 = 0;      // пин направления мотора 1
int SPEED_M1 = 0;    // пин скорости мотора 1
int DIR_M2 = 0;      // пин направления мотора 2
int SPEED_M2 = 0;    // пин скорости мотора 2
int DIR_M3 = 0;      // пин направления мотора 3
int SPEED_M3 = 0;    // пин скорости мотора 3
int DIR_M4 = 0;      // пин направления мотора 4
int SPEED_M4 = 0;    // пин скорости мотора 4
int speed = 0;       // базовая скорость движения
Servo servo1;        // сервопривод захвата (сжатие/разжатие)
Servo servo2;        // сервопривод подъема манипулятора (вверх/вниз)

void setup() {
  pinMode(9, OUTPUT);     // пин 9 — на выход (сервопривод захвата)
  servo1.attach(9);       // подключаем сервопривод захвата к пину 9
  pinMode(10, OUTPUT);    // пин 10 — на выход (сервопривод подъема)
  servo2.attach(10);      // подключаем сервопривод подъема к пину 10
  servo2.write(40);       // ставим манипулятор в начальное положение
  initMotors();           // настраиваем пины моторов
  carData();              // задаем базовую скорость
}

void loop() {
  // Последовательность: подъезд, захват объекта, подъем, перенос и освобождение
  forward();          // едем вперед
  delay(1000);
  stopMotors();       // останавливаемся
  delay(1000);
  gripperDown();      // опускаем манипулятор
  releaseItem();      // раскрываем захват
  delay(1000);
  grabItem();         // зажимаем объект
  delay(1000);
  gripperUp();        // поднимаем манипулятор с объектом
  delay(1000);

  releaseItem();      // раскрываем захват
  delay(1000);

  backward();         // сдаем назад
  delay(1000);
  stopMotors();
  delay(1000);
  turnRight();        // разворачиваемся направо
  delay(1065);        // время подобрано под нужный угол
  stopMotors();
  delay(1000);
  forward();          // подъезжаем к новой точке
  delay(955);
  stopMotors();
  gripperDown();      // опускаем манипулятор
  releaseItem();      // раскрываем захват
  delay(1000);
  grabItem();         // зажимаем объект
  gripperUp();        // поднимаем манипулятор

  releaseItem();      // раскрываем захват (оставляем объект)
  delay(1000);

  backward();         // сдаем назад
  delay(1000);
  stopMotors();
  delay(1000);
  turnLeft();         // разворачиваемся налево
  delay(1060);        // время подобрано под нужный угол
  stopMotors();
  delay(1000);
}

// Настройка пинов моторов
void initMotors() {
  DIR_M1 = (int)4;    // мотор 1: направление на пине 4
  SPEED_M1 = (int)5;  // мотор 1: скорость на пине 5
  DIR_M2 = (int)7;    // мотор 2: направление на пине 7
  SPEED_M2 = (int)6;  // мотор 2: скорость на пине 6
  DIR_M3 = (int)8;    // мотор 3: направление на пине 8
  SPEED_M3 = (int)3;  // мотор 3: скорость на пине 3
  DIR_M4 = (int)12;   // мотор 4: направление на пине 12
  SPEED_M4 = (int)11; // мотор 4: скорость на пине 11
  pinMode(DIR_M1, OUTPUT);    // все пины моторов настраиваем на выход
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);
  pinMode(SPEED_M1, OUTPUT);
  pinMode(SPEED_M2, OUTPUT);
  pinMode(SPEED_M3, OUTPUT);
  pinMode(SPEED_M4, OUTPUT);
}

// Задание базовой скорости движения
void carData() {
  speed = (int)50;   // скорость 50
}

// Движение вперед: моторы 1 и 3 в одну сторону, 2 и 4 — в противоположную
void forward() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, (speed + 0));
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, (speed + 0));
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, (speed + 0));
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, (speed + 0));
}

// Движение назад: направления моторов меняются на противоположные
void backward() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, (speed + 0));
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, (speed + 0));
  digitalWrite(DIR_M2, HIGH);
  analogWrite(SPEED_M2, (speed + 0));
  digitalWrite(DIR_M4, HIGH);
  analogWrite(SPEED_M4, (speed + 0));
}

// Остановка всех четырех моторов
void stopMotors() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, 0);
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, 0);
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, 0);
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, 0);
}

// Разворот направо на месте: все моторы в одном направлении
void turnRight() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, speed);
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, speed);
  digitalWrite(DIR_M2, HIGH);
  analogWrite(SPEED_M2, speed);
  digitalWrite(DIR_M4, HIGH);
  analogWrite(SPEED_M4, speed);
}

// Сжатие захвата (берем объект)
void grabItem() {
  servo1.write(30);   // поворачиваем сервопривод захвата на 30°
  delay(750);         // ждем завершения движения
}

// Разворот налево на месте: все моторы в другом направлении
void turnLeft() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, speed);
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, speed);
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, speed);
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, speed);
}

// Разжатие захвата (отпускаем объект)
void releaseItem() {
  servo1.write(40);   // поворачиваем сервопривод захвата на 40°
  delay(750);         // ждем завершения движения
}

// Опускание манипулятора вниз
void gripperDown() {
  servo2.write(40);   // поворачиваем сервопривод подъема на 40°
  delay(750);         // ждем завершения движения
}

// Подъем манипулятора вверх
void gripperUp() {
  servo2.write(180);  // поворачиваем сервопривод подъема на 180°
  delay(750);         // ждем завершения движения
}

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

image121

image122

image123

image124

image125

image126

image127

image128

Модель робота «Четырехколесная меканум-платформа»

image129

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

image130

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

image131

Контрольные вопросы ​

  1. Чем колесо всенаправленного движения отличается от обычного и какие движения оно позволяет выполнять платформе?

  2. За что отвечает каждый из двух сервоприводов манипулятора и в какой последовательности они работают при захвате предмета?

  3. Почему при движении вперёд моторы 1 и 3 получают одно направление, а моторы 2 и 4 — противоположное, а при развороте все четыре мотора получают одинаковый сигнал?

2.23. Модель «Платформа всенаправленного движения». Движение по квадрату ​

Цель: ​

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

Оборудование: ​

  • 4 двигателя постоянного тока;

  • сервопривод большой;

  • сервопривод малый;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

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

Энкодеры — это датчики, которые отслеживают вращение колес. Они работают на оптическом или магнитном принципе и выдают два сигнала, каналы A и B, сдвинутые по фазе на 90 градусов. Сдвиг на 90 градусов означает, что один сигнал отстает от другого на четверть периода. Благодаря этому можно определить не только количество оборотов, но и направление вращения. В этой работе энкодеры подключены к аналоговым входам A0–A3.

Направление вращения определяется по последовательности состояний сигналов A и B. Как и в работе с балансирующим роботом, состояния двух каналов объединяются в одно число от 0 до 3. При вращении в одну сторону состояния сменяют друг друга по одному шаблону: 0 → 1 → 3 → 2 → 0. При вращении в другую — по обратному: 0 → 2 → 3 → 1 → 0. Так программа точно подсчитывает тики (импульсы) энкодера и определяет угол поворота колеса.

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

В прошлых работах роботы поворачивали по времени: turnRight**(**), затем delay**(**1065). Такой способ называют управлением без обратной связи. Программа не знает, на какой угол робот повернул на самом деле: она только держит моторы включенными заданное время. Если батарея разрядилась и моторы крутятся медленнее, или пол стал более скользким, робот повернет на другой угол, а программа этого не заметит.

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

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

Рассчитаем, сколько тиков нужно для поворота. Когда платформа разворачивается на месте, каждое колесо движется по окружности вокруг центра платформы. Допустим, расстояние от центра платформы до колеса 10 см. Длина такой окружности C = 2πr = 2 × 3,14 × 10 ≈ 62,8 см. Поворот на 90° — четверть окружности, то есть колесо должно проехать 62,8 / 4 ≈ 15,7 см. Допустим, диаметр колеса 6 см. Тогда за один оборот колесо проезжает π × 6 ≈ 18,8 см, и для поворота нужно 15,7 / 18,8 ≈ 0,84 оборота. Зная, сколько тиков выдает энкодер за один оборот колеса, можно получить нужное число тиков. Формулы длины окружности изучают на уроках математики в 6 классе.

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

Для проезда по квадрату, роботу нужно четыре раза проехать одинаковое расстояние и четыре раза повернуть на 90°. Сумма поворотов: 4 × 90° = 360°, то есть робот делает полный оборот и оказывается в исходной точке, развернутым так же, как в начале. Любая ошибка в угле накапливается: если каждый поворот на 2° меньше, после четырех поворотов робот будет развернут на 8° от исходного направления и не вернется в начальную точку.

Для создания кода в данной работе используются энкодеры для измерения положения колес, а также функции digitalRead**(**) и analogWrite**(**) для управления моторами.

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

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

image119

image132

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

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

В начале программы задаются выводы моторов и энкодеров. Моторы подключены к выводам 3, 4, 5, 6, 7, 8, 11, 12, энкодеры — к аналоговым входам A0, A1, A2, A3. Объявляются переменные для положения энкодеров (encoder1Position, encoder2Position) и их предыдущих состояний. Задаются константы: скорость движения прямо (50), скорость поворота (60), время движения прямо (3000 мс), количество тиков для поворота на 90 градусов (540) и предельное время поворота (5000 мс).

В функции setup(), функции initMotors() и initEncoders() настраивают выводы, моторы останавливаются, и в монитор порта выводится сообщение о готовности. В основном цикле loop() робот едет прямо заданное время, постоянно обновляя показания энкодеров, затем останавливается и поворачивает на 90 градусов, после чего цикл повторяется.

Функция initEncoders() настраивает выводы энкодеров на вход с подтяжкой к питанию и считывает начальные состояния обоих энкодеров. Функции updateEncoder1() и updateEncoder2() определяют направление вращения по последовательности состояний каналов A и B. Если состояния сменяются в прямом порядке (0 → 1 → 3 → 2 → 0), позиция увеличивается, если в обратном — уменьшается.

Функция rotate90() поворачивает робота на 90 градусов с контролем по энкодерам. Сначала она обнуляет показания энкодеров и обновляет их начальные состояния. Затем робот начинает поворачивать направо с заданной скоростью. В цикле программа постоянно обновляет показания энкодеров и проверяет, насчитали ли оба энкодера заданное количество тиков (540). Если насчитали, поворот завершается. На случай, если поворот не может завершиться, предусмотрена защита: если он длится больше 5 секунд, цикл прерывается с сообщением об ошибке. Во время поворота в монитор порта выводятся текущие показания энкодеров для отладки.

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

Загрузим программу в контроллер и откроем монитор порта на скорости 9600 бод. Отключим USB-кабель, подключим аккумуляторный модуль и поставим робота на ровный пол. Удобно отметить стартовую точку и направление робота малярным скотчем.

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

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

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

cpp
const int DIR_M1 = 4;      // мотор 1: направление
const int SPEED_M1 = 5;    // мотор 1: скорость
const int DIR_M2 = 7;      // мотор 2: направление
const int SPEED_M2 = 6;    // мотор 2: скорость
const int DIR_M3 = 8;      // мотор 3: направление
const int SPEED_M3 = 3;    // мотор 3: скорость
const int DIR_M4 = 12;     // мотор 4: направление
const int SPEED_M4 = 11;   // мотор 4: скорость
const int encoder1PinA = A2;   // канал A энкодера 1
const int encoder1PinB = A3;   // канал B энкодера 1
const int encoder2PinA = A0;   // канал A энкодера 2
const int encoder2PinB = A1;   // канал B энкодера 2

long encoder1Position = 0;   // накопленное число тиков энкодера 1
long encoder2Position = 0;   // накопленное число тиков энкодера 2

int encoder1LastState = 0;   // предыдущее состояние каналов энкодера 1
int encoder2LastState = 0;   // предыдущее состояние каналов энкодера 2

int speed = 0;   // скорость движения
// Время движения прямо
const unsigned long forwardTime = 3000;   // 3 секунды едем вперед
// Примерно 560 тиков = 90 градусов
const long TURN_90_TICKS = 540;           // сколько тиков нужно на поворот в 90°
// Максимальное время поворота
const unsigned long TURN_TIMEOUT = 5000;  // защита от зависания: не крутимся дольше 5 с

void setup() {
  Serial.begin(9600);   // открываем последовательный порт
  initMotors();         // настраиваем пины моторов
  initEncoders();       // настраиваем пины энкодеров и читаем начальное состояние
  stopMotors();         // на старте моторы стоят
  carData();            // задаем скорость
  Serial.println("Платформа готова!");
  delay(1000);
}

void loop() {
  Serial.println();
  Serial.println("Едем прямо");
  unsigned long startTime = millis();   // засекаем время начала движения

  // Едем вперед заданное время, не переставая опрашивать энкодеры
  while (millis() - startTime < forwardTime) {
    forward();
    // Постоянно обновляем энкодеры
    updateEncoders();
  }
  stopMotors();
  Serial.println("Остановка");
  delay(500);
  rotate90();   // поворот на 90° с контролем по энкодерам
  delay(500);
}

// Настройка пинов моторов на выход
void initMotors() {
  pinMode(DIR_M1, OUTPUT);
  pinMode(SPEED_M1, OUTPUT);

  pinMode(DIR_M2, OUTPUT);
  pinMode(SPEED_M2, OUTPUT);

  pinMode(DIR_M3, OUTPUT);
  pinMode(SPEED_M3, OUTPUT);

  pinMode(DIR_M4, OUTPUT);
  pinMode(SPEED_M4, OUTPUT);
}

// Задание скорости движения
void carData() {
  speed = (int)50;   // скорость 50
}

// Настройка пинов энкодеров и чтение начального состояния
void initEncoders() {
  pinMode(encoder1PinA, INPUT_PULLUP);   // входы с подтяжкой к питанию
  pinMode(encoder1PinB, INPUT_PULLUP);

  pinMode(encoder2PinA, INPUT_PULLUP);
  pinMode(encoder2PinB, INPUT_PULLUP);

  // Кодируем состояние двух каналов в одно число (0–3)
  int stateA1 = digitalRead(encoder1PinA);
  int stateB1 = digitalRead(encoder1PinB);

  encoder1LastState = (stateB1 << 1) | stateA1;

  int stateA2 = digitalRead(encoder2PinA);
  int stateB2 = digitalRead(encoder2PinB);

  encoder2LastState = (stateB2 << 1) | stateA2;
}

// Опрос энкодера 1 и подсчет тиков с учетом направления
void updateEncoder1() {
  int stateA = digitalRead(encoder1PinA);
  int stateB = digitalRead(encoder1PinB);

  int currentState = (stateB << 1) | stateA;   // текущее состояние каналов (0–3)

  // Если состояние изменилось — определяем, в какую сторону крутится колесо
  if (currentState != encoder1LastState) {
    // Прямая последовательность состояний (0→1→3→2→0) — позиция растет
    if (
      (encoder1LastState == 0 && currentState == 1) ||
      (encoder1LastState == 1 && currentState == 3) ||
      (encoder1LastState == 3 && currentState == 2) ||
      (encoder1LastState == 2 && currentState == 0)
    ) {
      encoder1Position++;
    }
    else {   // иначе вращение в обратную сторону — позиция уменьшается
      encoder1Position--;
    }
    encoder1LastState = currentState;   // запоминаем состояние как предыдущее
  }
}

// Опрос энкодера 2 (аналогично энкодеру 1)
void updateEncoder2() {

  int stateA = digitalRead(encoder2PinA);
  int stateB = digitalRead(encoder2PinB);

  int currentState = (stateB << 1) | stateA;

  if (currentState != encoder2LastState) {
    if (
      (encoder2LastState == 0 && currentState == 1) ||
      (encoder2LastState == 1 && currentState == 3) ||
      (encoder2LastState == 3 && currentState == 2) ||
      (encoder2LastState == 2 && currentState == 0)
    ) {
      encoder2Position++;
    }
    else {
      encoder2Position--;
    }
    encoder2LastState = currentState;
  }
}

// Опрос обоих энкодеров за один вызов
void updateEncoders() {
  updateEncoder1();
  updateEncoder2();
}

// Движение вперед: моторы 1 и 3 в одну сторону, 2 и 4 — в противоположную
void forward() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, (speed + 0));
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, (speed + 0));
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, (speed + 0));
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, (speed + 0));
}

// Остановка всех четырех моторов
void stopMotors() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, 0);
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, 0);
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, 0);
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, 0);
}

// Разворот направо на месте: все моторы в одном направлении
void turnRight() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, speed);
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, speed);
  digitalWrite(DIR_M2, HIGH);
  analogWrite(SPEED_M2, speed);
  digitalWrite(DIR_M4, HIGH);
  analogWrite(SPEED_M4, speed);
}

// Поворот на 90° с контролем по энкодерам
void rotate90() {
  Serial.println();
  Serial.println("Начинаю поворот на 90 градусов");
  // Сбрасываем энкодеры
  encoder1Position = 0;
  encoder2Position = 0;
  // Обновляем начальное состояние
  int stateA1 = digitalRead(encoder1PinA);
  int stateB1 = digitalRead(encoder1PinB);

  encoder1LastState = (stateB1 << 1) | stateA1;

  int stateA2 = digitalRead(encoder2PinA);
  int stateB2 = digitalRead(encoder2PinB);

  encoder2LastState = (stateB2 << 1) | stateA2;

  // Время начала поворота
  unsigned long turnStartTime = millis();

  // Время последнего вывода в Serial
  unsigned long printTime = millis();

  turnRight();   // начинаем крутиться направо

  bool turning = true;   // флаг: поворот продолжается

  while (turning) {
    // энкодеры обновляются постоянно
    updateEncoders();
    // Берем абсолютные значения
    long ticks1 = abs(encoder1Position);
    long ticks2 = abs(encoder2Position);

    // Раз в 200 мс выводим показания энкодеров для отладки
    if (millis() - printTime >= 200) {
      printTime = millis();
      Serial.print("Encoder 1: ");
      Serial.print(encoder1Position);
      Serial.print(" | Encoder 2: ");
      Serial.print(encoder2Position);
      Serial.print(" | Ticks: ");
      Serial.print(ticks1);
      Serial.print(" / ");
      Serial.println(ticks2);
    }
    // Проверяем достижение условленного количества тиков
    if (
      ticks1 >= TURN_90_TICKS &&
      ticks2 >= TURN_90_TICKS
    ) {
      Serial.println("90 градусов достигнуто");
      turning = false;   // цель достигнута — выходим из цикла
    }

    // Защита от зависания

    // Если поворот занял больше допустимого времени — прерываем с ошибкой
    if (millis() - turnStartTime >= TURN_TIMEOUT) {

      Serial.println();
      Serial.println("ОШИБКА: превышено время поворота");
      turning = false;
    }
  }

  // Остановка
  stopMotors();

  Serial.println();
  Serial.println("Поворот завершен");
  Serial.print("Encoder 1 = ");
  Serial.println(encoder1Position);
  Serial.print("Encoder 2 = ");
  Serial.println(encoder2Position);
  Serial.println();
}

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

image133

image134

image135

image136

image137

image138

image139

image140

image141

Контрольные вопросы ​

  1. Что такое энкодер и что он измеряет?

  2. Как обратная связь позволяет проехать заданное расстояние?

  3. Как из движения по отрезкам складывается траектория-квадрат?

2.24. Модель «Платформа всенаправленного движения». Подключение модулей «Ультразвуковой дальномер» и «Датчика цвета» ​

Цель: ​

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

Оборудование: ​

  • 4 двигателя постоянного тока;

  • сервопривод большой;

  • сервопривод малый;

  • модуль «Ультразвуковой дальномер»;

  • модуль «Датчик цвета»;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

image142

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

Робот собран на той же платформе, что и в предыдущих работах. Спереди установлен захват с двумя лапами, его сжимает и разжимает один сервопривод, а поднимает и опускает другой. Над захватом закреплен модуль «Ультразвуковой дальномер», который направлен вперед по ходу движения. Модуль «Датчик цвета» расположен в нижней части захвата, между лапами: так он оказывается ближе всего к предмету, который робот собирается взять. Теперь робот не только чувствует, что впереди что-то есть, но и различает, что именно.

Датчик цвета распознает цвет объекта, измеряя, насколько ярки красная, зеленая и синяя (RGB) составляющие отраженного света. Внутри датчика находятся фотодиоды с цветовыми фильтрами и встроенный АЦП, который превращает световой сигнал в цифровое значение. Датчик работает по интерфейсу I2C, поэтому подключается всего четырьмя проводами. У датчика есть встроенный источник света, белый светодиод, который включается для подсветки объекта при недостаточном освещении.

Из курса физики 8 класса известно, что белый свет состоит из света разных цветов. Это впервые показал Исаак Ньютон: пропустив солнечный луч через стеклянную призму, он получил на стене полосу из всех цветов радуги. Такое разложение света называется дисперсией.

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

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

Как работает датчик цвета? Глаз человека различает цвета с помощью трех видов светочувствительных клеток, колбочек. Одни сильнее реагируют на красный свет, другие на зеленый, третьи на синий. Мозг сравнивает их сигналы и определяет цвет.

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

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

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

В этой работе время интеграции 50 мс, усиление четырехкратное.

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

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

  1. Впереди ничего нет ближе 15 см — ехать дальше.

  2. Впереди объект, и он красный — это стена, объехать.

  3. Впереди объект, и он зеленый — это предмет, взять.

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

Чтобы робот запомнил, что предмет уже взят, используется флаг — булева переменная hasItem, как flag в работе с кнопкой и светодиодом. Пока она равна false, робот ищет предметы. После захвата она становится true.

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

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

image143

image144

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

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

В начале программы подключаются библиотеки для работы с датчиком цвета (Wire.h**,** Adafruit_Sensor.h**, Adafruit_TCS34725.h**) и сервоприводами (Servo.h). Создается объект tcs для управления датчиком цвета, время интеграции 50 мс, усиление четырехкратное. Задаются выводы ультразвукового дальномера (TRIG на выводе 10, ECHO на выводе 9) и моторов. Объявляется переменная **hasItem** для хранения состояния захвата.

В функции setup**(**) настраиваются выводы дальномера и проверяется, подключен ли датчик цвета. Если датчик не найден, программа останавливается. Затем настраиваются сервоприводы (захват на выводе 2, подъем на выводе 13), вызываются функции initMoto**r**s(**)** и carData**(****)** для настройки моторов, и робот начинает движение вперед.

Функция UltraSound**(**) измеряет расстояние до объекта с помощью ультразвукового дальномера и возвращает его в сантиметрах. Алгоритм такой же, как в работе с дальномером: импульс на TRIG, измерение длительности импульса на ECHO и расчет расстояния.

Функция RGB(**)** определяет цвет метки. Она отключает прерывания датчика, ждет 60 мс, пока идет измерение, считывает значения красного, зеленого, синего и прозрачного каналов и снова включает прерывания. Цвет определяется по пороговым значениям: красный (**R >** 200, G < 100, B < 100), зеленый (G > 100, R < 100, B < 100), синий (B > 100, R < 100). Пороговые значения подбираются опытным путем в зависимости от освещения. Функция возвращает число: 1 для красного, 2 для зеленого, 3 для синего и 0, если цвет не определен.

В основном цикле loop**(**) робот непрерывно едет вперед и измеряет расстояние. Если объект ближе 15 см, а предмет еще не захвачен, робот останавливается и определяет цвет метки перед объектом. Если метка красная, робот считает объект перед ним стеной: едет назад 1 секунду, останавливается и поворачивает направо. Если метка зеленая, робот считает объект предметом для захвата: зажимает захват, поднимает манипулятор, продолжает движение и устанавливает флаг hasItem, чтобы не пытаться захватывать другие объекты.

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

Перед запуском установим библиотеку Adafruit TCS34725 через менеджер библиотек, как в работе с LCD-дисплеем.

Подготовим два объекта и две цветовые метки: красную метку положим перед одним объектом, изображающим стену, а зеленую перед вторым, изображающим предмет для захвата. Загрузим программу в контроллер и откроем монитор порта на скорости 9600 бод. Если датчик цвета подключен правильно, появится сообщение Found sensor.

Сначала определим, какие числа датчик выдает на наших объектах. Для этого временно добавим в функцию RGB() после строки с getRawData() вывод значений red, green и blue в монитор порта. Поднесем к датчику по очереди красный объект, зеленый объект и белый лист бумаги, запишем значения в таблицу. По таблице выберем пороги так, чтобы красный и зеленый объекты уверенно различались, и исправим их в условиях функции RGB().

Затем отключим USB-кабель, подключим аккумуляторный модуль и поставим робота на пол перед объектом с красной меткой. Робот должен остановиться, отъехать и повернуть. Повторим опыт с объектом с зеленой меткой: робот должен взять его и поднять. Сравним результаты при дневном свете и при искусственном освещении.

cpp
#include "Servo.h"
#include <Wire.h> // Подключаем библиотеку для работы с I2C (шина для связи с датчиком)
#include <Adafruit_Sensor.h> // Библиотека Adafruit для работы с датчиками
#include <Adafruit_TCS34725.h> // Библиотека для работы с датчиком цвета TCS34725
cpp
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
cpp
// Цифровые пины для УЗ-дальномера
const int trigPin = 10;    // пин TRIG 10
const int echoPin = 9;   // пин ECHO 9
cpp
// пины для моторов
int DIR_M1 = 0;
int SPEED_M1 = 0;
int DIR_M2 = 0;
int SPEED_M2 = 0;
int DIR_M3 = 0;
int SPEED_M3 = 0;
int DIR_M4 = 0;
int SPEED_M4 = 0;
int speed = 0;
Servo servo1;
Servo servo2;
cpp
unsigned long previousMillis = 0;
unsigned long currentMillis = 0;
cpp
bool hasItem = false;
cpp
void setup() {
  Serial.begin(9600);  // Запускаем последовательный порт для вывода данных на компьютер

  pinMode(trigPin, OUTPUT); //задаем выход для генерации УЗ-сигнала
  pinMode(echoPin, INPUT);  //задаем вход для приема отраженного сигнала
  // Проверяем, подключен ли датчик
  if (tcs.begin()) {
    Serial.println("Found sensor");  // Датчик найден, продолжаем работу
  } else {
    Serial.println("No TCS34725 found ... check your connections"); // Датчик не найден
    while (1); // Останавливаем программу, чтобы не продолжать работу без датчика
  }
cpp
  pinMode(2, OUTPUT);
  servo1.attach(2);
  servo1.write(70);
  pinMode(13, OUTPUT);
  servo2.attach(13);
  servo2.write(45);
  delay(500);
  initMotors();
  carData();
  delay(100);
  forward();
}
cpp
void loop() {
  forward();
  int distance = UltraSound();
  if (distance != 0 && distance < 15 && !hasItem) {
    stopMotors();
    int color = RGB();
    // Красный -> стена
    if (color == 1) {
      backward();
      delay(1000);
      stopMotors();
      delay(500);
      turnRight();
      delay(1100);      // подобрать под 90°
      stopMotors();
      delay(200);
    }
    // Зеленый -> предмет
    else if (color == 2) {
      stopMotors();
      // gripperDown();
      grabItem();
      gripperUp();
      forward();
      hasItem = true;
      delay(500);
    }
  }
}
cpp
int UltraSound() {
  // отправляем ультразвуковой импульс
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2); //гасим триггер УЗ дальномера на 2 мкс
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10); //подаем 10 мкс импульс
  digitalWrite(trigPin, LOW);
  // Ждем ответный сигнал
  long duration = pulseIn(echoPin, HIGH); //измеряем длительность на echoPin
  // Вычисляем расстояние (в сантиметрах)
  int distance = duration * 0.034 / 2; //расстояние=(время*скорость звука)/2. Скорость звука=340 м/с=0.034 см/мкс. Делим на 2, тк сигнал идет до объекта и обратно
  return distance;
}
cpp
int RGB() {
  // Переменные для хранения значений цвета
  uint16_t clear, red, green, blue;
  // Включаем режим измерения (отключаем прерывания)
  tcs.setInterrupt(false);
  delay(60);  // Ждем 60 мс, чтобы датчик успел измерить цвет
  // Считываем сырые данные с датчика
  tcs.getRawData(&red, &green, &blue, &clear);
  // Включаем прерывания, чтобы датчик мог перейти в спящий режим между измерениями
  tcs.setInterrupt(true);
bash
  // подобрать
  if (red > 200 && green < 100 && blue < 100)
    return 1;      // красный
bash
  if (green > 100 && red < 100 && blue < 100)
    return 2;      // зеленый
bash
  if (blue > 100 && red < 100)
    return 3;      // синий
bash
  return 0;        // цвет не определен
}
cpp
void initMotors() {
  DIR_M1 = (int)4;
  SPEED_M1 = (int)5;
  DIR_M2 = (int)7;
  SPEED_M2 = (int)6;
  DIR_M3 = (int)8;
  SPEED_M3 = (int)3;
  DIR_M4 = (int)12;
  SPEED_M4 = (int)11;
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);
  pinMode(SPEED_M1, OUTPUT);
  pinMode(SPEED_M2, OUTPUT);
  pinMode(SPEED_M3, OUTPUT);
  pinMode(SPEED_M4, OUTPUT);
}
cpp
void carData() {
  speed = (int)50;
}
cpp
void forward() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, (speed + 0));
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, (speed + 0));
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, (speed + 0));
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, (speed + 0));
}
cpp
void backward() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, (speed + 0));
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, (speed + 0));
  digitalWrite(DIR_M2, HIGH);
  analogWrite(SPEED_M2, (speed + 0));
  digitalWrite(DIR_M4, HIGH);
  analogWrite(SPEED_M4, (speed + 0));
}
cpp
void stopMotors() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, 0);
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, 0);
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, 0);
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, 0);
}
cpp
void turnRight() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, speed);
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, speed);
  digitalWrite(DIR_M2, HIGH);
  analogWrite(SPEED_M2, speed);
  digitalWrite(DIR_M4, HIGH);
  analogWrite(SPEED_M4, speed);
}
cpp
void grabItem() {
  servo1.write(20);
  delay(750);
}
cpp
void gripperDown() {
  servo2.write(45);
  delay(750);
}
cpp
void gripperUp() {
  servo2.write(150);
  delay(750);
}

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

image145

image146

image147

image148

image149

image150image151image152

Модель робота «Четырехколесная меканум-платформа» с модулем «Ультразвуковой дальномер» и датчиком цвета

image153

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

image154

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

image155

image156

Контрольные вопросы ​

  1. Как работает датчик цвета TCS34725?

  2. Как объединяются данные дальномера и датчика цвета в одном алгоритме?

  3. Как реакция робота зависит от распознанного цвета?

2.25. Модель «Платформа всенаправленного движения». Подключение модуля «Датчик линии" ​

Цель: ​

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

Оборудование: ​

  • 4 двигателя постоянного тока;

  • сервопривод большой;

  • сервопривод малый;

  • модуль «Датчик линии»;

  • блок-контроллер ЭДУино;

  • аккумуляторный модуль PowerBank 9V 3A.

image157

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

Для создания кода в данной работе используется функция analogRead**(**) для считывания показаний с оптических датчиков линии, а также условные операторы для принятия решений о направлении движения.

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

Инфракрасное излучение — это электромагнитные волны, длина которых больше, чем у красного света. Глаз человека их не видит, но кожа чувствует их как тепло: так греет солнце, батарея отопления или угли костра. Тема излучения как вида теплопередачи изучается в курсе физики 8 класса.

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

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

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

Функция analogRead**(**) возвращает число от 0 до 1023, как в работе с фоторезистором. Программе же нужно знать только одно: линия под датчиком или нет. Поэтому число сравнивается с порогом и превращается в одно из двух значений, 0 или 1. Такое преобразование называется бинаризацией.

Два датчика, каждый из которых может показывать 0 или 1, дают 2 × 2 = 4 возможных сочетания. Их удобно записать таблицей, похожей на таблицы истинности из курса информатики:

Левый датчикПравый датчикЧто это значитДействие
0 (светлое)0 (светлое)линия между датчикамипрямо
1 (черное)0 (светлое)робот сместился вправоналево
0 (светлое)1 (черное)робот сместился влевонаправо
1 (черное)1 (черное)перекресток или конец линиистоп

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

Чтобы такой алгоритм работал, расстояние между датчиками должно быть немного больше ширины линии. Например, если линия сделана из черной изоленты шириной 19 мм, датчики можно расположить на расстоянии 2,5–3 см друг от друга. Если датчики стоят слишком близко, оба окажутся над линией, и робот остановится. Если слишком далеко, робот успеет сильно уйти в сторону, прежде чем датчик заметит линию.

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

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

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

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

image158

image159

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

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

В начале программы директивами #define задаются выводы датчиков линии: левый датчик на входе A4, правый на A5. Подключается библиотека Servo.h для управления сервоприводами. Объявляются переменные для выводов четырех моторов, скорости, объекты сервоприводов, а также переменные для показаний датчиков. Переменные is_left и is_right имеют тип uint8_t. Это целое число без знака, которое занимает один байт и может принимать значения от 0 до 255. Для хранения 0 или 1 его вполне достаточно.

В функции setup**(**) настраиваются выводы сервоприводов и моторов, функции initMoto**r**s**(**) и carData**(**) задают выводы и параметры движения, выводы датчиков настраиваются на вход, и платформа начинает двигаться вперед.

Функции readleft**sensor**(**)** и readright**sensor**(**)** считывают аналоговые значения с датчиков и превращают их в двоичное состояние. Если значение меньше 100, датчик видит светлую поверхность, и функция возвращает 0. Если значение больше 1000, датчик видит черную линию, и функция возвращает 1. Пороговые значения подбираются опытным путем, в зависимости от освещения и от того, насколько хорошо поверхность отражает свет.

В основном цикле loop**(**) программа считывает состояния датчиков и по ним выбирает движение. Если оба датчика видят светлую поверхность, платформа едет прямо. Если левый датчик видит черную линию, платформа поворачивает налево. Если правый, направо. Если оба датчика видят черную линию, платформа останавливается: это может означать перекресток или конец линии.

Функции управления моторами такие же, как в предыдущих работах: forward**(**) для движения прямо, turnLeft**(**) и turnRight**(**) для разворота, stopMotors**(**) для остановки. Скорость движения равна 20, чтобы робот плавно следовал по линии.

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

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

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

Затем определим, какие числа датчики выдают над белой поверхностью и над линией. Для этого временно добавим в setup**(**) строку Serial.begin**(9600**);, а в функции чтения датчиков вывод значений line_left_data и line_right_data в монитор порта. Поставим робота так, чтобы датчики оказались сначала над белым, потом над черным, и запишем показания в таблицу. По таблице выберем пороги.

Загрузим программу в контроллер, отключим USB-кабель, подключим аккумуляторный модуль и поставим робота так, чтобы линия проходила между датчиками. Понаблюдаем, как робот едет по прямому участку и проходит поворот. Если робот не успевает поворачивать и съезжает с линии, попробуем уменьшить время в строках delay**(**1000**)**;.

cpp
#define LINE_LEFT   A4  // Левый датчик подключен к аналоговому входу A4
#define LINE_RIGHT  A5  // Правый датчик подключен к аналоговому входу A5

#include "Servo.h"
int DIR_M1 = 0;
int SPEED_M1 = 0;
int DIR_M2 = 0;
int SPEED_M2 = 0;
int DIR_M3 = 0;
int SPEED_M3 = 0;
int DIR_M4 = 0;
int SPEED_M4 = 0;
int speed = 0;
Servo servo1;
Servo servo2;

// Переменные для хранения данных, считанных с датчиков линии
int line_left_data;
int line_right_data;
uint8_t is_left;
uint8_t is_right;

void setup()
{
  //настраиваем моторы
  initMotors();
  carData();
  // Настраиваем пины, к которым подключены датчики, как входы
  pinMode(LINE_LEFT, INPUT);
  pinMode(LINE_RIGHT, INPUT);
  forward();
}

void loop() {
  //функция чтения данных с датчиков
  is_left = read_left_sensor();
  is_right = read_right_sensor();

  if (is_left == 0 && is_right == 0){ //если под левым и под правым белое пространство(0), то движение вперед
    forward();
    delay(1000);
  }

  else if (is_left == 1 && is_right == 0) { // если левый = 1 (черный), то поворот налево
    turnLeft();
    delay(1000);
  }

  else if (is_right == 1 && is_left == 0) { // если правый = 1 (черный), то поворот направо
    turnRight();
    delay(1000);
  }

  else if (is_right == 1 && is_left == 1) { // если правый и левый = 1 (перекресток), то остановка
    stopMotors();
  }
}

int read_left_sensor() {
  line_left_data = analogRead(LINE_LEFT);
  if (line_left_data < 100)
    return 0; // white
  if (line_left_data > 1000)
    return 1; // black
}

int read_right_sensor() {
  line_right_data = analogRead(LINE_RIGHT);
  if (line_right_data < 100)
    return 0; // white
  if (line_right_data > 1000)
    return 1; // black
}

void initMotors() {
  DIR_M1 = (int)4;
  SPEED_M1 = (int)5;
  DIR_M2 = (int)7;
  SPEED_M2 = (int)6;
  DIR_M3 = (int)8;
  SPEED_M3 = (int)3;
  DIR_M4 = (int)12;
  SPEED_M4 = (int)11;
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);
  pinMode(SPEED_M1, OUTPUT);
  pinMode(SPEED_M2, OUTPUT);
  pinMode(SPEED_M3, OUTPUT);
  pinMode(SPEED_M4, OUTPUT);
}

void carData() {
  speed = (int)20;
}

void forward() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, (speed + 0));
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, (speed + 0));
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, (speed + 0));
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, (speed + 0));
}

void stopMotors() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, 0);
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, 0);
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, 0);
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, 0);
}

void turnRight() {
  digitalWrite(DIR_M1, HIGH);
  analogWrite(SPEED_M1, speed);
  digitalWrite(DIR_M3, HIGH);
  analogWrite(SPEED_M3, speed);
  digitalWrite(DIR_M2, HIGH);
  analogWrite(SPEED_M2, speed);
  digitalWrite(DIR_M4, HIGH);
  analogWrite(SPEED_M4, speed);
}

void turnLeft() {
  digitalWrite(DIR_M1, LOW);
  analogWrite(SPEED_M1, speed);
  digitalWrite(DIR_M3, LOW);
  analogWrite(SPEED_M3, speed);
  digitalWrite(DIR_M2, LOW);
  analogWrite(SPEED_M2, speed);
  digitalWrite(DIR_M4, LOW);
  analogWrite(SPEED_M4, speed);
}

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

image160

image161

image162

image163

image164

image165

image166

Контрольные вопросы ​

  1. По какому принципу оптический датчик отличает линию от фона?

  2. Как по показаниям датчиков строится следование по траектории?

  3. Как робот ведет себя при потере линии?