Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Введение

Этот курс учит работать с платой робота TurtleBro: управлять её светодиодами, кнопками и сервоприводом, а также обмениваться командами и данными с ROS 2 через библиотеку RosDuino. Сначала плата подключена к компьютеру по USB и выполняет обычные скетчи Arduino. Затем вы запустите агент RosDuino на компьютере, а в последнем уроке тот же агент будет работать уже на бортовом компьютере робота.

Курс построен вокруг практики. Результат каждого урока можно проверить: светодиод мигает, кнопки включают светодиоды по очереди, сервопривод поворачивается, а команда из ROS 2 меняет состояние платы.

Если вы уже знакомы с Arduino и ROS 2 и хотите сразу посмотреть примеры кода и команды запуска без пошаговой теории, перейдите в раздел «Быстрый старт».

Для кого этот курс

Опыт работы с Arduino и C++ для прохождения курса не требуется: устройство скетча и нужные конструкции языка подробно разбираются по ходу уроков. Однако вам понадобятся базовые знания в робототехнике и представления о работе с ROS.

Уроки 1–3 можно пройти на компьютере с Windows или Ubuntu: нужна Arduino IDE 2. С урока 4, когда начинается работа с агентом, нужен компьютер с Ubuntu и установленной ROS 2. Минимальные требования, ссылки на установку ROS 2 и инструкция по установке rosduino_agent приведены в уроке 4.

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

Разные версии плат TurtleBro

Примеры написаны для жёлтой платы TurtleBro (версия 2) с Arduino Due. В Arduino IDE выбирайте Arduino Due (Programming Port). Номера пинов в уроках относятся только к этой плате.

Если у вас синяя плата с Arduino Mega (версия 1), изучите страницу «Платы v1 и v2» и дальше подставляйте пины самостоятельно, исходя из задания. Обычно достаточно поменять номера пинов в константах в начале скетча.

Проекты и инструменты

В курсе используются:

Траектория курса

Восемь уроков идут от первого скетча до работы на роботе.

Этап 1. Плата TurtleBro по USB

  1. Подготовка рабочего места. Arduino IDE 2 в Windows или Ubuntu, выбор Arduino Due, установка библиотеки RosDuino и первый скетч на LED_BUILTIN.
  2. Светодиоды, кнопки и сервопривод. Светодиоды и кнопки платы, очередь включения светодиодов и сервопривод на штатных пинах подключения.
  3. Чтение данных, работа с Serial портом. Чтение аналогового сигнала, утилита мониторинга порта, плоттер графиков и замена блокирующего delay() неблокирующей логикой.

На этом этапе ROS 2 не нужен. Плата TurtleBro работает как обычная плата Arduino, подключённая по USB.

Этап 2. Агент на компьютере с Ubuntu

  1. Первый узел RosDuino. Установка rosduino_agent на компьютер с Ubuntu и связь с платой по USB.
  2. Топики в RosDuino. Публикация данных и приём команд без блокировки основного цикла.
  3. Сервисы в RosDuino. Работа платы в роли сервера сервиса (ros.service()) и клиента сервиса (ros.call()).
  4. Диагностика, время и узлы на Python. Журнал /rosout, синхронизация времени ros.now(), управляющий узел на Python и запуск через launch-файл.

Плата по-прежнему подключена к компьютеру кабелем USB. Агент работает на этом компьютере, а не на роботе.

Этап 3. Агент на роботе

  1. TurtleBro. Установка rosduino_agent на Raspberry Pi робота и совместная работа со штатными топиками. Справочные материалы по платформе приведены в документации TurtleBro.

Как устроены уроки

Каждый урок содержит:

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

В уроке 1 установка для Windows и Linux вынесена на отдельные страницы. Сначала прочитайте общую часть, затем выберите свою операционную систему. После настройки платы установите библиотеку RosDuino и перейдите к первому скетчу.

Как работать с курсом

Проверяйте результат каждого урока

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

Изменяйте по одному параметру

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

Проверяйте систему по уровням

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

  1. Скетч компилируется и работает на плате.
  2. Последовательный порт доступен.
  3. Агент rosduino_agent установил соединение.
  4. Узел и топики видны командами ROS 2.
  5. Управляющая программа получает данные и отправляет команды.

Если плата ещё не видна в ROS 2, не ищите причину в Python-узле: сначала убедитесь, что предыдущие уровни работают.

Фиксируйте ошибки

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

Для этого полезно вести короткий журнал:

  • версия платы TurtleBro и выбранный пункт в Arduino IDE;
  • имя порта;
  • версии пакета плат и библиотеки;
  • ожидаемый результат;
  • фактический результат;
  • полный текст ошибки.

Сначала решайте самостоятельно

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

Обозначения в командах

В уроках с ROS 2 несколько процессов работают одновременно:

  • Терминал 1 — агент rosduino_agent;
  • Терминал 2 — команды ROS 2 для просмотра топиков, публикации сообщений и вызова сервисов.

Команды приводятся без символа $, чтобы их можно было скопировать целиком.

Не закрывайте Терминал 1

Пока вы проверяете топики и сервисы в Терминале 2, агент rosduino_agent должен продолжать работать в Терминале 1.

Безопасность

Не перетыкайте сервопривод под нагрузкой

Перед тем как подключить или отключить сервопривод от разъёма на плате, остановите скетч и отключите USB. Сверьте маркировку −, +, S с цветами проводов и только затем подавайте питание.

Соблюдайте четыре правила:

  1. Не подавайте 5 В на цифровые и аналоговые входы: Arduino Due рассчитана на 3,3 В.
  2. Не соединяйте линию 5 В разъёма сервопривода с пинами питания сигнальной части платы.
  3. Подключайте сервопривод только к штатному разъёму сервопривода и проверяйте порядок −, +, S.
  4. Перед загрузкой скетча остановите процесс, который занимает тот же последовательный порт. В уроках с RosDuino это rosduino_agent.

Если плата, провод или сервопривод заметно нагрелись, сразу отключите питание и проверьте подключение сервопривода.

Результат курса

После прохождения курса вы сможете:

  • поручать плате TurtleBro работу с кнопками, светодиодами, аналоговыми сигналами и сервоприводом, а ROS 2 — обработку данных и принятие решений;
  • подключать плату через RosDuino и проверять её топики и сервисы;
  • разрабатывать управляющий узел на Python;
  • перенести агент на Raspberry Pi робота TurtleBro.

Готовы начать?

Подготовьте плату TurtleBro и USB-кабель. Для уроков 2 и 3 понадобится сервопривод с тремя проводами (потенциометр или аналоговый датчик для разъёма GPIO A8 в уроке 3 желателен, но не обязателен — чтение аналогового сигнала через analogRead() будет работать и на неподключённом разъёме).

Дальше: Быстрый старт, Платы v1 и v2 или Урок 1. Подготовка рабочего места.

Быстрый старт

Если вы уже знакомы с Arduino и у вас есть опыт, то для вас на этой странице собраны краткая теория работы RosDuino, ссылки на репозитории и документацию, а также готовые шаблоны всех базовых возможностей библиотеки без лишних деталей. Если у вас уже настроены Arduino IDE 2 и ROS 2, эту страницу можно использовать как шпаргалку по API RosDuino.


Репозитории и документация RosDuino

Все примеры ниже также доступны прямо в меню Arduino IDE: Файл → Примеры → RosDuino.


Как устроена работа RosDuino

Система состоит из двух частей, соединённых по последовательному порту USB (115200 бод):

  1. Библиотека rosduino_arduino на плате (#include <RosDuino.h>): превращает плату в узел ROS 2. Скетч объявляет имя узла в ros.begin("имя_узла"), а в loop() вызывает ros.update(). Подробная установка разобрана в уроке 1.
  2. Узел rosduino_agent на компьютере с Ubuntu: открывает порт платы и создаёт в графе ROS 2 её топики и сервисы. При подключении плата сама сообщает агенту, какие топики и сервисы ей нужны, поэтому пересобирать или перенастраивать агент при смене скетча не требуется. Сборка агента разобрана в уроке 4.
flowchart LR
    MCU["Плата + RosDuino.h"] <-.-> SP(["Serial порт (USB)"])
    SP <-.-> Agent
    subgraph PC["Компьютер с Ubuntu"]
        Agent["rosduino_agent"] <--> ROS2["Топики, сервисы и журнал ROS 2"]
    end
    style SP fill:#fef3c7,stroke:#d97706,stroke-width:2px,stroke-dasharray: 5 5,color:#78350f
    style PC fill:#f8fafc,stroke:#64748b,stroke-width:1.5px,color:#0f172a

Топики и сервисы: в чём разница

  • Топик (Topic) — непрерывный односторонний канал передачи сообщений (Message). Узел-издатель публикует данные в топик (ros.publish()), а узел-подписчик принимает их в функции-обработчике (ros.subscribe()). Используется для потока показаний датчиков и регулярных команд (подробнее в уроке 4 и уроке 5).
  • Сервис (Service) — удалённый вызов функции по схеме «запрос — ответ» (Request / Response). Клиент передаёт входные параметры в srv.request, а сервер выполняет функцию и возвращает результат в srv.response. Плата может быть как сервером (ros.service()), так и клиентом (ros.call()) (подробнее в уроке 6).

Запуск агента и три главных правила

Во всех примерах ниже агент запускается на компьютере в Терминале 1 (или через launch-файл rosduino_agent.launch.py):

ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
  1. Не используйте Serial.print() и держите закрытой утилиту мониторинга порта в Arduino IDE — порт занят протоколом RosDuino.
  2. Останавливайте агент (Ctrl+C) перед загрузкой нового скетча в плату.
  3. Не используйте delay() в loop() — вызывайте ros.update() на каждом проходе, а для периодических действий используйте rosduino::Timer.

Базовые примеры API RosDuino

1. Подписка на топик (ros.subscribe)

Исходник в библиотеке: examples/Simple/Led/Led.ino (расширенный вариант: examples/Full/Blink/Blink.ino), подробный разбор — в уроке 4.

Плата создаёт узел /led_board, подписывается на топик /led (std_msgs/msg/Bool) и управляет светодиодом D48. Тип топика определяется автоматически по аргументу функции onLed:

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>

const int LED_PIN = 48;

void onLed(std_msgs::Bool msg) {
  digitalWrite(LED_PIN, msg.data ? HIGH : LOW);
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  ros.begin("led_board");
  ros.subscribe("led", onLed);
}

void loop() {
  ros.update();
}

Проверка в Терминале 2:

ros2 topic pub --once /led std_msgs/msg/Bool "{data: true}"
ros2 topic pub --once /led std_msgs/msg/Bool "{data: false}"

2. Публикация показаний датчика по таймеру (ros.publish и rosduino::Timer)

Исходник в библиотеке: examples/Simple/LightSensor/LightSensor.ino (потоковый опрос кнопки: examples/Simple/ButtonSimple/ButtonSimple.ino; расширенные варианты: examples/Full/PubSub/PubSub.ino и examples/Full/NanoBasic/NanoBasic.ino), подробный разбор — в уроке 5.

Плата каждые 100 мс (10 Гц) по неблокирующему таймеру rosduino::Timer считывает сигнал на A8 и публикует его в топик /analog_signal (std_msgs/msg/Int32). Для периодического датчика отдельная регистрация не нужна: первый вызов ros.publish() создаёт топик (пропуская самый первый отсчёт), а все следующие показания сразу уходят в ROS 2:

#include <RosDuino.h>
#include <std_msgs/msg/Int32.h>

std_msgs::Int32 msg;
rosduino::Timer timer(100);  // каждые 100 мс (10 Гц)

void setup() {
  ros.begin("sensor_board");
}

void loop() {
  ros.update();
  if (timer.check()) {
    msg.data = analogRead(A8);
    ros.publish("analog_signal", msg);
  }
}

Проверка в Терминале 2:

ros2 topic echo /analog_signal
ros2 topic hz /analog_signal

3. Одиночные события кнопки (ros.advertise)

Исходник в библиотеке: examples/Simple/ButtonOnce/ButtonOnce.ino (расширенный вариант: examples/Full/ButtonPub/ButtonPub.ino), подробный разбор — в уроке 5.

Если скетч отправляет сообщение только при изменении состояния кнопки D28, в setup() после ros.begin() вызывается ros.advertise("button", pressed). Переменная pressed при этом не публикуется — она только задаёт тип топика (std_msgs/msg/Bool). Благодаря этому топик /button сразу виден в ros2 topic list, а самое первое нажатие не теряется:

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>

const int BUTTON_PIN = 28;

std_msgs::Bool pressed;
bool wasPressed = false;
rosduino::Timer timer(50);  // каждые 50 мс (антидребезг)

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  wasPressed = (digitalRead(BUTTON_PIN) == HIGH);
  ros.begin("button");
  ros.advertise("button", pressed);
}

void loop() {
  ros.update();
  if (timer.check()) {
    pressed.data = (digitalRead(BUTTON_PIN) == HIGH);
    if (pressed.data != wasPressed) {
      wasPressed = pressed.data;
      ros.publish("button", pressed);
    }
  }
}

Проверка в Терминале 2:

ros2 topic echo /button

4. Сервер сервиса на плате (ros.service)

Исходники в библиотеке: examples/Simple/LedService/LedService.ino и examples/Simple/AddServer/AddServer.ino (расширенный вариант: examples/Full/ServiceServer/ServiceServer.ino), подробный разбор — в уроке 6 (сервер сервиса).

Плата предоставляет сервис /set_led (std_srvs/srv/SetBool): принимает параметр в srv.request.data, включает или выключает светодиод D48 и записывает результат работы в srv.response:

#include <RosDuino.h>
#include <std_srvs/srv/SetBool.h>

const int LED_PIN = 48;

void onSetLed(std_srvs::SetBool& srv) {
  digitalWrite(LED_PIN, srv.request.data ? HIGH : LOW);
  srv.response.success = true;
  srv.response.message = "done";
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  ros.begin("led_service");
  ros.service("set_led", onSetLed);
}

void loop() {
  ros.update();
}

Проверка в Терминале 2:

ros2 service call /set_led std_srvs/srv/SetBool "{data: true}"

5. Клиент сервиса на плате (ros.call)

Исходник в библиотеке: examples/Simple/AddClient/AddClient.ino (расширенный вариант: examples/Full/ServiceClient/ServiceClient.ino), подробный разбор — в уроке 6 (клиент сервиса).

Плата раз в 2 с асинхронно вызывает внешний сервис /add_two_ints (example_interfaces/srv/AddTwoInts) на компьютере, передавая слагаемые в adder.request, и зажигает D48 при получении ответа в onAnswer:

#include <RosDuino.h>
#include <example_interfaces/srv/AddTwoInts.h>

const int LED_PIN = 48;
example_interfaces::AddTwoInts adder;
rosduino::Timer timer(2000);

void onAnswer(example_interfaces::AddTwoInts& srv) {
  digitalWrite(LED_PIN, (srv.response.sum == 5) ? HIGH : LOW);
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  ros.begin("add_client");
}

void loop() {
  ros.update();
  if (ros.connected() && timer.check()) {
    adder.request.a = 2;
    adder.request.b = 3;
    ros.call("add_two_ints", adder, onAnswer);
  }
}

Запуск тестового сервера в Терминале 2:

ros2 run demo_nodes_cpp add_two_ints_server

6. Журнал /rosout и время ROS 2 (ros.logInfo и ros.now)

Исходник в библиотеке: examples/Full/TimeAndLog/TimeAndLog.ino (отладка на втором порту Serial1: examples/Simple/LedSerial1/LedSerial1.ino), подробный разбор — в уроке 7.

Вместо Serial.println() отладочные сообщения отправляются в /rosout методами ros.logDebug(), ros.logInfo(), ros.logWarn(), ros.logError(), ros.logFatal(), а синхронизированное с компьютером время запрашивается через ros.now():

#include <RosDuino.h>

rosduino::Timer timer(1000);

void setup() {
  ros.begin("time_and_log");
}

void loop() {
  ros.update();
  if (ros.connected() && timer.check()) {
    builtin_interfaces::msg::Time t = ros.now();
    ros.logInfo(t.sec != 0 ? F("time ok") : F("time unset"));
  }
}

Просмотр журнала и диагностики связи в Терминале 2:

ros2 topic echo /rosout
ros2 topic echo /diagnostics --field status --once

Сводка основных функций простого API

Вызов в скетчеНазначениеГде разобрано в курсе
ros.begin("node_name")Инициализирует порт (115200 бод) и задаёт имя узла ROS 2Урок 4
ros.update()Обрабатывает входящие и исходящие пакеты в loop()Урок 4
ros.connected()Возвращает true, когда связь с rosduino_agent установленаУрок 5
ros.advertise("topic", msg)Заранее создаёт топик по типу переменной msg без отправки сообщенияУрок 5
ros.publish("topic", msg)Публикует сообщение msg в топикУрок 5
ros.subscribe("topic", cb)Подписывается на топик и вызывает функцию cb(msg)Урок 4
ros.service("srv_name", cb)Регистрирует сервер сервиса на плате с обработчиком cb(srv)Урок 6
ros.call("srv_name", srv, cb)Неблокирующе вызывает внешний сервис ROS 2Урок 6
ros.logInfo(F("text"))Отправляет запись в системный журнал /rosoutУрок 7
ros.now()Возвращает синхронизированное время builtin_interfaces::msg::TimeУрок 7
rosduino::Timer t(ms); t.check()Неблокирующий таймер с периодом ms миллисекундУрок 5

Назад: Введение.
Дальше: Платы v1 и v2 или Урок 1. Подготовка рабочего места.

Платы v1 и v2

У робота TurtleBro две версии пользовательской платы. Весь курс дальше написан для жёлтой платы v2 с микроконтроллером Arduino Due. На этой странице собрано, чем синяя плата v1 отличается от v2 и как адаптировать примеры самостоятельно.

Посмотрите цвет платы и сверьте её с описанием на сайтах ros1.turtlebro.ru и ros2.turtlebro.ru.

ПризнакTurtleBro v2TurtleBro v1
Цвет платыЖёлтаяСиняя
Плата ArduinoArduino DueArduino Mega 2560
Пункт в Arduino IDEArduino Due (Programming Port)Arduino Mega or Mega 2560
Пакет платArduino SAM Boards (32-bits ARM Cortex-M3)Arduino AVR Boards
Логические уровни3,3 В5 В
analogRead()0–10230–1023

Отличие плат при установке в Arduino IDE

Пакет плат устанавливается один раз через Инструменты → Плата → Менеджер плат (Tools → Board → Boards Manager). Для двух версий TurtleBro нужны разные пакеты.

Для жёлтой платы v2 с Arduino Due установите пакет Arduino SAM Boards (32-bits ARM Cortex-M3). В меню платы выберите Arduino Due (Programming Port). Именно этот вариант используется во всех уроках курса.

Для синей платы v1 с Arduino Mega 2560 используется пакет Arduino AVR Boards от Arduino. Обычно он уже установлен вместе с Arduino IDE. Если пункта Arduino Mega or Mega 2560 нет в меню Инструменты → Плата, наберите Arduino AVR Boards в поиске менеджера плат и установите пакет.

Пины, которые использует курс

В примерах указаны пины платы v2 (Arduino Due). Кнопки и переключатели уже распаяны на плате: нажатие кнопки или включение тумблера даёт уровень HIGH, поэтому пин настраивается как обычный вход INPUT. Светодиод LED_BUILTIN в уроке 1 общий для обеих плат, его менять не нужно. Со второго урока примеры переходят на четыре светодиода платы.

Что на платеПин в коде курса (v2)
КнопкиD28, D15
ПереключателиD16, D29
СветодиодыD48, D49, D50, D51
Разъёмы сервоприводовD2, D3, D4, D5, D6, D7
Разъёмы GPIOA8, A7, A6

В уроках чаще всего встречаются кнопки D28 и D15, светодиоды D48–D51, разъём сервопривода D2 и разъём GPIO A8.

У сервопривода три провода. Его подключают к трёхконтактному разъёму сервопривода на плате и сверяют маркировку −, +, S с цветами: тёмный провод (коричневый или чёрный) — к −, красный — к +, сигнальный (оранжевый, жёлтый или белый) — к S. Питание сервопривод берёт с контакта +. Эту линию 5 В нельзя соединять с питанием сигнальной части платы.

Разъём GPIO A8 на плате имеет 5 контактов: 3.3V, GND, SCL, SDA и GPIO. Аналоговый сигнал подаётся на контакт GPIO (A8), а питание потенциометра или датчика берётся с контактов 3.3V и GND. На Arduino Due напряжение на входе не должно превышать 3,3 В.

Как перенести пример на синюю плату v1

  1. В Arduino IDE выберите Arduino Mega or Mega 2560.
  2. В начале скетча замените номера пинов в константах по таблице ниже. Логику программы, длительности пауз и имена топиков оставьте без изменений.
  3. Скетч урока 1 со светодиодом LED_BUILTIN менять не нужно — достаточно выбрать плату Mega в меню IDE.
В коде курса (v2, Due)На синей плате (v1, Mega)Назначение в примерах
D28D23Первая кнопка
D15D24Вторая кнопка
D16D25Первый переключатель
D29D22Второй переключатель
D48D26Первый светодиод
D49D27Второй светодиод
D50D28Третий светодиод
D51D29Четвёртый светодиод
D2D46Первый разъём сервопривода
D3D45Второй разъём сервопривода
D4D44Третий разъём сервопривода
A8A12Первый разъём GPIO
A7A12Второй разъём GPIO (в документации v1 номер повторён)
A6A14Третий разъём GPIO

На синей плате v1 предусмотрены три разъёма для сервоприводов, а на жёлтой v2 — шесть. Все примеры курса используют первый разъём (D2 на v2, D46 на v1), поэтому переносятся напрямую.

Чтение кнопок при переносе не меняется: используется pinMode(..., INPUT) и уровень HIGH при нажатии.

Назад: Быстрый старт.
Дальше: Урок 1. Подготовка рабочего места.

Урок 1. Подготовка рабочего места

В этом уроке вы подготовите рабочее место и получите первый видимый результат: установите Arduino IDE 2 и библиотеку RosDuino, подключите плату TurtleBro и загрузите первый скетч, после чего встроенный светодиод LED_BUILTIN начнёт мигать.

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

В этом уроке вы научитесь

  • подключать плату TurtleBro к компьютеру;
  • выбирать в Arduino IDE модель платы и последовательный порт;
  • устанавливать библиотеку RosDuino;
  • загружать скетч в плату;
  • объяснять, как программа включает и выключает светодиод;
  • изменять длительность мигания.

Что понадобится

  • плата TurtleBro с Arduino Due;
  • USB-C кабель;
  • компьютер с Windows 10/11 или Ubuntu 22.04/24.04;
  • доступ в интернет для установки Arduino IDE, пакета плат и библиотеки RosDuino.

В Arduino IDE выберите Arduino Due

Пункт платы — Arduino Due (Programming Port). Подключайте USB-кабель к разъёму USB-C с надписью DUE.

Проверьте USB-кабель

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

Входы Arduino Due рассчитаны на 3,3 В

Не подавайте на них 5 В. В этом уроке внешние компоненты не подключаются. Для загрузки скетча подключайте USB-кабель к разъёму USB-C с надписью DUE.

Перед началом: три понятия

  • Плата TurtleBro — плата робота, которая в первых уроках работает как плата Arduino: выполняет скетч и управляет своими светодиодами, кнопками и разъёмами.
  • Скетч — программа для этой платы.
  • Arduino IDE 2 — программа для компьютера, в которой вы пишете скетч и загружаете его в плату по USB-кабелю.

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

Со следующего урока примеры перейдут на светодиоды, разведённые на плате: D48–D51.

Зачем плате TurtleBro отдельный микроконтроллер

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

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

Пока идут уроки 1–3, компьютер только загружает скетч в плату. Связь с ROS 2 через библиотеку RosDuino начнётся в уроке 4, но библиотеку мы установим сейчас, как часть подготовки рабочего места.

Порядок работы

  1. Установите Arduino IDE 2 для своей операционной системы.
  2. Установите пакет плат Arduino SAM Boards (32-bits ARM Cortex-M3) для поддержки Arduino Due.
  3. Подключите плату и выберите Arduino Due (Programming Port) и порт.
  4. Установите библиотеку RosDuino через менеджер библиотек.
  5. Загрузите первый скетч и убедитесь, что светодиод LED_BUILTIN мигает.

В Arduino IDE вам понадобятся две кнопки и один список:

  • Проверить (Verify) — проверяет скетч и подготавливает его к загрузке, но не записывает в плату;
  • Загрузить (Upload) — записывает скетч в плату;
  • список платы и порта — показывает, с каким устройством будет работать IDE.

Установите IDE

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

План урока

После выбора порта установите библиотеку RosDuino. Затем перейдите к странице «Загрузка первой программы». Когда светодиод начнёт мигать, выполните домашнее задание.

Справочный материал

Дополнительно: arduino-cli

arduino-cli позволяет загружать скетчи из командной строки. Для прохождения этого урока он не нужен: все действия выполняются в Arduino IDE 2. Но как один из способов работы с Arduino можно использовать его.

Назад: Введение.
Дальше: Установка в Windows или Установка в Linux.

Установка Arduino IDE 2 в Windows

На этой странице вы установите Arduino IDE 2 в Windows 10 или Windows 11, подключите плату TurtleBro, проверите её в «Диспетчере устройств» и выберете в программе плату Arduino Due (Programming Port) и порт COMx.

1. Скачайте установщик

Откройте страницу загрузки Arduino и выберите Windows Win 10 and newer, 64 bits. Сохраните установщик с расширением .msi.

ZIP-архив на той же странице — запасной вариант. Для обычной установки используйте .msi.

Официальная инструкция: Downloading and installing the Arduino IDE 2.

2. Установите Arduino IDE

  1. Запустите скачанный файл .msi.
  2. Разрешите установку драйверов USB: они нужны компьютеру для связи с платой.
  3. Дождитесь завершения установки и откройте Arduino IDE 2.
  4. При первом запуске дождитесь, пока среда загрузит базовые индексы пакетов.

3. Установите поддержку платы Arduino Due

В чистой установке Arduino IDE 2 поддержка Arduino Due не включена по умолчанию — её нужно установить через менеджер плат:

  1. Откройте Инструменты → Плата → Менеджер плат (Tools → Board → Boards Manager) или нажмите на значок платы на левой боковой панели.
  2. В поле поиска введите Arduino SAM Boards.
  3. Найдите пакет Arduino SAM Boards (32-bits ARM Cortex-M3) от Arduino и нажмите Установить (Install).
  4. Дождитесь окончания загрузки и установки пакета.

4. Подключите плату и найдите порт

Соедините плату TurtleBro с компьютером USB-кабелем. Подключайте его к разъёму USB-C с надписью DUE.

Последовательный порт — это подключение, через которое компьютер обменивается данными с платой. В Windows его имя начинается с COM, например COM3 или COM4.

Чтобы найти порт:

  1. Нажмите клавиши Win+X и выберите «Диспетчер устройств».
  2. Разверните раздел «Порты (COM и LPT)».
  3. Найдите новый порт COMx (обычно он подписывается как Arduino Due Programming Port или USB Serial Device). Номер порта на вашем компьютере может отличаться от примеров в курсе.

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

5. Выберите плату и порт в Arduino IDE

  1. Откройте Инструменты → Плата → Arduino SAM Boards (32-bits ARM Cortex-M3) и выберите Arduino Due (Programming Port).
  2. Откройте Инструменты → Порт (Tools → Port) и выберите тот же COMx, который отображается в «Диспетчере устройств».

Проверка

В верхней панели Arduino IDE отображаются Arduino Due (Programming Port) и порт COMx. После отключения кабеля этот порт исчезает из списка, а после повторного подключения появляется снова.

Справочный материал: если порт не появился

Основная причина — кабель, который поддерживает только зарядку. Если плата получает питание, но в «Диспетчере устройств» не появляется даже как неизвестное устройство, сначала замените USB-кабель.

Также убедитесь, что кабель вставлен именно в разъём USB-C с подписью DUE на плате TurtleBro.

Если устройство видно в «Диспетчере устройств» с жёлтым значком ошибки, проверьте, установились ли драйверы вместе с пакетом Arduino SAM Boards, или при необходимости установите драйвер USB-моста вручную:

  • для моста CP2102 / CP2102N — драйвер Silicon Labs CP210x;
  • для моста CH340 — драйвер WCH CH341SER.

После установки драйвера отключите кабель и подключите его снова. Затем повторите проверку порта в «Диспетчере устройств» и в Arduino IDE.

Назад: Урок 1. Подготовка рабочего места.
Дальше: Установка библиотеки RosDuino.

Установка Arduino IDE 2 в Linux

На этой странице вы установите и запустите Arduino IDE 2 в Ubuntu 22.04 или Ubuntu 24.04, добавите текущего пользователя в группу dialout для доступа к последовательному порту и выберете в программе плату Arduino Due (Programming Port) и её порт.

1. Скачайте AppImage

Откройте страницу загрузки Arduino и выберите Linux AppImage, 64 bits (X86-64).

AppImage — это файл с программой, который можно запустить без обычной установки. Сохраните его в папку ~/Downloads. Если ваш браузер использует папку ~/Загрузки, подставьте этот путь в командах ниже.

Официальная инструкция: Downloading and installing the Arduino IDE 2.

2. Запустите Arduino IDE

Откройте приложение «Терминал». Команды ниже нужно вводить в него по одной и после каждой нажимать Enter.

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

cd ~/Downloads

Разрешите запуск AppImage:

chmod +x arduino-ide_*.AppImage

Запустите Arduino IDE:

./arduino-ide_*.AppImage

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

3. Установите поддержку платы Arduino Due

По умолчанию пакет для Arduino Due не установлен — добавьте его через менеджер плат:

  1. В Arduino IDE откройте Инструменты → Плата → Менеджер плат (Tools → Board → Boards Manager) или нажмите на значок платы на левой панели.
  2. В поле поиска введите Arduino SAM Boards.
  3. Найдите пакет Arduino SAM Boards (32-bits ARM Cortex-M3) от Arduino и нажмите Установить (Install).
  4. Дождитесь завершения установки.

4. Разрешите доступ к последовательному порту

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

Добавьте текущего пользователя в эту группу:

sudo usermod -aG dialout "$USER"

Команда sudo выполняет действие с правами администратора. Если система попросит пароль, введите пароль своей учётной записи. Во время ввода символы пароля в терминале не отображаются.

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

Повторный вход обязателен

Если не выйти из системы и не войти снова, Arduino IDE может по-прежнему показывать ошибку Permission denied при загрузке скетча.

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

groups

В выводе команды должна быть группа dialout.

5. Подключите плату и выберите порт в Arduino IDE

Соедините плату TurtleBro с компьютером USB-кабелем. Подключайте его к разъёму USB-C с надписью DUE.

В Ubuntu порт платы обычно имеет имя /dev/ttyACM0 или /dev/ttyUSB0. Цифра в конце может отличаться. Вам не нужно запоминать полное имя: Arduino IDE покажет доступные порты в меню.

Если порт не появился, отключите кабель и подключите его снова. Затем попробуйте другой USB-кабель. Способ проверки порта через терминал приведён в справочном материале.

  1. Откройте Инструменты → Плата → Arduino SAM Boards (32-bits ARM Cortex-M3) и выберите Arduino Due (Programming Port).
  2. Откройте Инструменты → Порт (Tools → Port) и выберите появившийся порт.

Проверка

Команда groups показывает группу dialout, а в верхней панели Arduino IDE выбраны Arduino Due (Programming Port) и порт платы.

Справочный материал

Если Ubuntu сообщает об отсутствии FUSE

Установите необходимую библиотеку:

sudo apt install libfuse2

После этого снова запустите AppImage:

./arduino-ide_*.AppImage

Как найти порт через терминал

Подключите плату и выполните команду:

ls -l /dev/serial/by-id/

Каждая строка вывода указывает на порт вида /dev/ttyACM0 или /dev/ttyUSB0:

  • Arduino Due часто появляется как /dev/ttyACM*;
  • плата TurtleBro с мостом CP2102 обычно появляется как /dev/ttyUSB*.

Если каталог отсутствует или пуст, проверьте USB-кабель и подключение платы.

Устойчивое имя порта для следующих уроков

Полный путь из /dev/serial/by-id/ пригодится при запуске rosduino_agent. В отличие от номера ttyACM0 или ttyUSB0, такое имя обычно не меняется при подключении кабеля к другому разъёму USB. Для выбора платы в Arduino IDE использовать этот путь не обязательно.

Назад: Урок 1. Подготовка рабочего места.
Дальше: Установка библиотеки RosDuino.

Установка библиотеки RosDuino

Arduino IDE уже запущена, а плата TurtleBro выбрана в списке плат. Теперь установите библиотеку RosDuino. В уроках 1–3 она ещё не вызывается из скетча: мы ставим её заранее, чтобы к уроку 4 среда была готова.

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

1. Установка через менеджер библиотек

  1. В Arduino IDE 2 откройте менеджер библиотек. Его значок находится на левой панели. Тот же список открывается через Инструменты → Менеджер библиотек (Tools → Manage Libraries).
  2. В строке поиска введите RosDuino.
  3. В результатах выберите библиотеку RosDuino и нажмите Установить (Install).
  4. Дождитесь окончания загрузки.

Менеджер сам поместит файлы библиотеки в папку библиотек Arduino. Вручную копировать каталоги не нужно.

2. Проверьте, что библиотека видна

Откройте Файл → Примеры (File → Examples). В списке должен появиться раздел RosDuino.

Проверка

Раздел RosDuino есть в списке примеров. Открывать и загружать эти примеры пока не нужно: первый скетч урока их не использует.

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

Справочный материал: альтернативные способы установки

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

Способ А. Установка из архива ZIP

  1. Откройте релизы репозитория rosduino/rosduino_arduino и скачайте архив вида RosDuino-x.y.z.zip.
  2. В Arduino IDE откройте Скетч → Подключить библиотеку → Добавить .ZIP-библиотеку (Sketch → Include Library → Add .ZIP Library).
  3. Укажите скачанный архив и дождитесь сообщения об установке.
  4. Откройте Файл → Примеры и убедитесь, что раздел RosDuino появился.

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

Способ Б. Клонирование репозитория

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

В Ubuntu:

mkdir -p ~/Arduino/libraries
git clone https://github.com/rosduino/rosduino_arduino.git ~/Arduino/libraries/RosDuino

В Windows ту же команду выполните в PowerShell, подставив свою папку документов:

git clone https://github.com/rosduino/rosduino_arduino.git "$env:USERPROFILE\Documents\Arduino\libraries\RosDuino"

После клонирования перезапустите Arduino IDE и снова откройте Файл → Примеры.

Агент rosduino_agent этой страницей не устанавливается. Он нужен только с урока 4 и только на компьютере с Ubuntu. Сборку пакета rosduino_ros здесь не выполняйте.

Назад: Установка в Windows или Установка в Linux.
Дальше: Загрузка первой программы.

Загрузка первой программы

Arduino IDE установлена, библиотека RosDuino добавлена, а плата TurtleBro подключена к компьютеру. Теперь вы загрузите в плату первый скетч, после чего встроенный светодиод LED_BUILTIN начнёт коротко вспыхивать один раз в секунду.

Как устроен скетч

Скетч — это программа для платы Arduino. В нашем скетче есть две части:

  • setup() выполняется один раз после включения платы или нажатия кнопки Reset — здесь мы настраиваем плату;
  • loop() повторяется, пока плата включена, — здесь мы описываем действия, которые нужно выполнять снова и снова.

Для управления светодиодом используется контакт платы — пин. Имя LED_BUILTIN обозначает встроенный светодиод платы (рядом с ним на плате нанесена буква L), поэтому в этом уроке номер пина указывать не нужно. Со следующего урока скетчи перейдут на четыре пользовательских светодиода платы D48–D51.

Паузы в программе задаются в миллисекундах: 1000 мс — это 1 с.

Пошаговая практика: «Маячок»

1. Проверьте плату и порт

В верхней панели Arduino IDE должны быть выбраны Arduino Due (Programming Port) и порт платы. USB-кабель подключён к разъёму USB-C с надписью DUE.

2. Вставьте скетч

Создайте новый скетч и замените его содержимое следующим кодом:

void setup() {
  // Встроенный светодиод платы подключён к LED_BUILTIN.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(200);
  digitalWrite(LED_BUILTIN, LOW);
  delay(800);
}

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

3. Проверьте скетч

Нажмите Проверить (Verify). Arduino IDE проверит программу и преобразует её в команды, понятные микроконтроллеру. Этот процесс называется компиляцией. На этом шаге скетч ещё не записывается в плату.

Если в коде есть ошибка, IDE покажет сообщение в нижней панели. Сверьте скетч с примером и проверьте, не пропали ли скобки или точки с запятой при копировании.

4. Загрузите скетч

Нажмите Загрузить (Upload). Дождитесь сообщения об окончании загрузки. Во время записи светодиоды TX и RX на плате могут мигать.

Ожидаемый результат

Встроенный светодиод LED_BUILTIN (подписанный на плате буквой L) горит 200 мс, затем остаётся погашенным 800 мс. Весь цикл длится 1 с и повторяется, пока плата включена.

Если загрузка не началась, проверьте USB-кабель, выбранные модель платы и порт. Ещё раз убедитесь, что кабель стоит в разъёме USB-C с надписью DUE.

Что делает скетч

Теперь сопоставьте команды с увиденным результатом:

КомандаЧто делает
pinMode(LED_BUILTIN, OUTPUT)Настраивает пин встроенного светодиода как выход
digitalWrite(LED_BUILTIN, HIGH)Включает светодиод
digitalWrite(LED_BUILTIN, LOW)Выключает светодиод
delay(200)Сохраняет текущее состояние светодиода на 200 мс
delay(800)Сохраняет текущее состояние светодиода на 800 мс

HIGH и LOW — логические уровни цифрового пина, то есть два состояния сигнала. HIGH — высокий уровень, на Arduino Due около 3,3 В: светодиод горит. LOW — низкий уровень, около 0 В: светодиод погашен.

В setup() пин настраивается только один раз. Затем loop() многократно выполняет последовательность: включить, подождать, выключить, подождать.

Вопросы для самопроверки

  1. Что такое скетч?
  2. Зачем в Arduino IDE выбирать модель платы и порт?
  3. Сколько раз выполняется setup()?
  4. Какая команда включает светодиод?
  5. Что изменится, если заменить delay(200) на delay(1000), а остальной код оставить прежним?

Справочный материал

Этот раздел можно пропустить при первом прохождении. Он нужен, если загрузка на TurtleBro не начинается.

Названия плат в меню Arduino IDE

Откройте Инструменты → Плата (Tools → Board) и выберите Arduino Due (Programming Port).

Те же команды можно выполнить на обычной плате Arduino, если выбрать её модель в меню. Курс такой перенос не разбирает.

Что Arduino IDE добавляет к скетчу

Скетч сохраняется в файле с расширением .ino и использует язык C++. Среда Arduino сама добавляет служебную функцию main(), поэтому в скетче вы описываете только setup() и loop().

После компиляции в нижней панели появляется отчёт об использовании Flash и ОЗУ. Эти сведения полезны для больших программ, но для первого скетча точные значения не важны: они зависят от платы, версии пакета плат и компилятора.

Почему в следующих уроках не всегда подходит delay()

Пока выполняется delay(), программа не переходит к другим действиям. В этом примере это не мешает: кроме мигания светодиодом скетч ничего не делает.

В более сложных программах такая пауза может задержать чтение датчиков и обработку команд. Поэтому начиная с урока 3 вместо блокирующего ожидания используются millis() и rosduino::Timer. Эти инструменты разбираются в следующих уроках; для текущего примера их знать не нужно.

Назад: Установка библиотеки RosDuino.
Дальше: Домашнее задание.

Домашнее задание

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

Основное задание

Измените скетч «Маячок» так, чтобы светодиод горел одну секунду и следующую секунду оставался выключенным.

Порядок работы

  1. Откройте скетч, который вы загрузили на предыдущей странице.
  2. Найдите две команды delay(): одна задаёт длительность свечения, другая — длительность паузы.
  3. До изменения кода попробуйте предположить, какие значения понадобятся для интервалов в одну секунду.
  4. Измените скетч, нажмите Проверить, а затем Загрузить.

Подсказка

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

Как проверить результат

  • Скетч компилируется и загружается без ошибок.
  • Светодиод горит примерно одну секунду.
  • Затем светодиод остаётся выключенным примерно одну секунду.
  • Этот цикл повторяется, пока плата включена.

Дополнительное задание

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

Дополнительные компоненты не понадобятся: светодиод LED_BUILTIN уже есть на плате. Номера D48–D51 в этом задании не используются.

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

Требования

  1. Буква S передаётся тремя короткими вспышками. Каждая вспышка длится 150 мс, пауза после неё — 150 мс.
  2. Буква O передаётся тремя длинными вспышками. Каждая вспышка длится 500 мс, пауза после неё — 150 мс.
  3. После буквы O снова передаётся буква S.
  4. От выключения последней вспышки до включения первой вспышки следующего цикла должно пройти 1500 мс.
  5. Создайте функцию void flashLed(int duration_ms). Не копируйте пары digitalWrite() и delay() в loop() девять раз.

Как составить алгоритм

  1. Опишите одну вспышку: включить светодиод, выдержать заданное время, выключить его и сделать короткую паузу.
  2. Вызовите функцию три раза для коротких вспышек S.
  3. Вызовите её три раза для длинных вспышек O.
  4. Повторите три короткие вспышки S.
  5. Добавьте оставшуюся часть длинной паузы перед новым циклом.

Как проверить результат

  • Скетч компилируется и загружается без ошибок.
  • Функция flashLed() создана и вызывается из loop().
  • По светодиоду можно различить последовательность: три короткие вспышки, три длинные, снова три короткие, затем длинная пауза.
  • Сигнал повторяется, пока плата включена.

Справочный материал: как работает собственная функция

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

В записи void flashLed(int duration_ms):

  • flashLed — имя функции;
  • duration_ms — длительность вспышки, которую функция получает при вызове;
  • void означает, что функция выполняет действие, но не возвращает результат.

Вызов flashLed(150); создаёт короткую вспышку, а flashLed(500); — длинную.

Если самостоятельное решение пока не складывается, начните с этого опорного скетча. Он полностью готов к загрузке и повторяет одну короткую вспышку:

void flashLed(int duration_ms) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(duration_ms);
  digitalWrite(LED_BUILTIN, LOW);
  delay(150);
}

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

void loop() {
  flashLed(150);
}

Измените только loop(): соберите из вызовов flashLed() последовательность SOS и добавьте длинную паузу. В готовом решении дополнительно показан цикл for, который позволяет записать три одинаковых вызова короче. Для первого знакомства с функциями можно обойтись без него.

Посмотреть решение и разбор

Назад: Загрузка первой программы.
Дальше: Урок 2. Светодиоды, кнопки и сервопривод.

Урок 2. Светодиоды, кнопки и сервопривод

В уроке 1 вы загрузили первый скетч и мигали светодиодом LED_BUILTIN. Теперь мы научимся управлять компонентами, которые распаяны на плате TurtleBro: светодиодами D48–D51, кнопками D28 и D15 (с защитой от дребезга контактов) и сервоприводом на разъёме D2. Макетная плата и отдельные провода для светодиодов и кнопок не понадобятся.

В этом уроке вы научитесь

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

Пины, которые используются в уроке

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

Компонент на платеПинНазначение в уроке
Ряд светодиодовD48, D49, D50, D51Очередь светодиодов и индикация крайних положений
Первая кнопкаD28Уменьшение счёта и поворот влево
Вторая кнопкаD15Увеличение счёта и поворот вправо
Разъём сервоприводаD2Управление углом сервопривода

Как устроены кнопки на плате TurtleBro

У цифрового пина два логических уровня — два различимых состояния электрического сигнала:

  • HIGH — высокий уровень (на Arduino Due это напряжение около 3,3 В). Если программа подаёт HIGH на пин светодиода, светодиод загорается. Когда кнопка на плате TurtleBro нажата, чтение её пина также возвращает HIGH.
  • LOW — низкий уровень (около 0 В). На выходе светодиод при этом гаснет, а отпущенная кнопка читается как LOW.

На плате TurtleBro для кнопок уже установлены резисторы, которые удерживают на входе уровень LOW, пока кнопка отпущена, и подают HIGH при нажатии. Поэтому в скетче пин кнопки настраивается как обычный вход без внутренней подтяжки:

pinMode(28, INPUT);

Безопасность при подключении сервопривода

Подробная схема подключения приведена на странице работы с сервоприводом. Главное правило: подключайте трёхпроводной кабель сервопривода только к штатному разъёму D2 на плате и заранее сверяйте маркировку контактов −, +, S с цветами проводов. Линию питания 5 В этого разъёма нельзя соединять с сигнальными пинами микроконтроллера.

Не подключайте сервопривод под нагрузкой

Перед тем как подключить или отключить сервопривод, отсоедините USB-кабель от платы. Сначала сверьте контакты −, + и S с цветами проводов и только затем подавайте питание.

План урока

  1. Светодиод на плате — управление светодиодом D48.
  2. Кнопки и очередь светодиодов — чтение кнопки, защита от дребезга и массив пинов D48–D51.
  3. Управление сервоприводом — подключение к разъёму D2 и поворот между 0° и 90°.
  4. Домашнее задание — плавный поворот вала кнопками и индикация упоров.

Назад: Домашнее задание.
Дальше: Светодиод на плате.

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

В уроке 1 мигал встроенный светодиод LED_BUILTIN. Теперь применим тот же принцип к пользовательскому светодиоду D48, распаянному на плате TurtleBro, и заставим его включаться и выключаться с интервалом 500 мс. Отдельный светодиод, резистор и макетная плата не понадобятся — вся цепь уже собрана на плате.

Какой светодиод включаем

На плате TurtleBro распаяны четыре пользовательских светодиода: D48, D49, D50 и D51. В первом примере мы будем управлять светодиодом D48.

Чтобы не писать число 48 в каждой команде, сохраним номер пина в именованной константе const int LED_PIN = 48; в начале программы. Если позже вы захотите переключить скетч на другой светодиод, достаточно будет изменить число в одной строке.

Загрузите скетч

Создайте новый скетч и вставьте код:

// Первый пользовательский светодиод на плате TurtleBro.
const int LED_PIN = 48;

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

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

Нажмите Проверить, затем Загрузить.

Ожидаемый результат

Светодиод D48 горит 500 мс и затем 500 мс остаётся выключенным. Цикл повторяется, пока плата включена.

Что делают команды

Пин настроен как цифровой выход (OUTPUT): программа сама задаёт на нём один из двух уровней.

КомандаЧто происходит
const int LED_PIN = 48;Задаёт имя LED_PIN для пина 48, которое нельзя случайно изменить в ходе работы программы
pinMode(LED_PIN, OUTPUT)Настраивает пин как выход для управления светодиодом
digitalWrite(LED_PIN, HIGH)Подаёт высокий уровень (около 3,3 В) — светодиод загорается
digitalWrite(LED_PIN, LOW)Подаёт низкий уровень (около 0 В) — светодиод гаснет
delay(500)Удерживает текущее состояние в течение 500 мс

Если светодиод не мигает

НаблюдениеЧто проверить
Мигает только LED_BUILTIN или другой светодиодУбедитесь, что в константе LED_PIN указан пин 48
Скетч не загружаетсяПроверьте, что выбрана плата Arduino Due (Programming Port), а USB-кабель подключён к разъёму с надписью DUE
Светодиод горит постоянноПроверьте, что в loop() есть и HIGH, и LOW, а после каждой команды стоит delay(500)

Назад: Урок 2. Светодиоды, кнопки и сервопривод.
Дальше: Кнопки и очередь светодиодов.

Кнопки и очередь светодиодов

На предыдущем шаге светодиод D48 мигал по таймеру. Теперь свяжем его с кнопками на плате TurtleBro: начнём с простого включения светодиода при удержании кнопки, затем научимся отфильтровывать дребезг контактов для распознавания одиночного нажатия, а в третьем шаге используем массив пинов D48–D51 для поочерёдного включения четырёх светодиодов двумя кнопками.

Как считывается состояние кнопки

Кнопки D28 и D15 уже распаяны на плате вместе с подтягивающими резисторами к земле (GND). Поэтому включать внутреннюю подтяжку микроконтроллера (INPUT_PULLUP) не нужно — пин настраивается как обычный вход:

pinMode(28, INPUT);

Функция digitalRead(pin) проверяет состояние входа и возвращает один из двух логических уровней:

  • HIGH — кнопка нажата;
  • LOW — кнопка отпущена.

Шаг 1. Светодиод горит, пока удерживается кнопка

Чтобы программа принимала решение в зависимости от состояния кнопки, в C++ используется условная конструкция if ... else («если … иначе») и оператор сравнения на равенство ==:

if (digitalRead(BUTTON_PIN) == HIGH) {
  // Команды, если кнопка нажата
} else {
  // Команды, если кнопка отпущена
}

Обратите внимание: для проверки равенства пишутся два знака == (один знак = используется для присваивания значения переменной).

Загрузите первый проверочный скетч для кнопки D28 и светодиода D48:

const int BUTTON_PIN = 28;
const int LED_PIN = 48;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  if (digitalRead(BUTTON_PIN) == HIGH) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }
}

Нажмите Проверить, затем Загрузить.

Ожидаемый результат

Пока вы удерживаете кнопку D28, светодиод D48 горит. Как только вы отпускаете кнопку, светодиод гаснет.

Тот же код работает и с тумблерами платы, которые во включённом положении также дают уровень HIGH. Например, если заменить номер пина в BUTTON_PIN с 28 на 16 (первый переключатель платы v2), светодиод будет гореть всё время, пока тумблер включён.

Шаг 2. Одно нажатие — одно переключение (защита от дребезга)

Если мы хотим, чтобы первое нажатие кнопки включало светодиод, а второе выключало, нам нужно улавливать момент смены состояния кнопки с LOW на HIGH.

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

Чтобы избавиться от дребезга:

  1. Программа хранит последнее подтверждённое состояние кнопки в переменной lastButtonState.
  2. Если новое чтение пина отличается от lastButtonState (оператор != означает «не равно»), программа ждёт 30 мс и считывает пин повторно.
  3. Если после паузы новое состояние сохранилось, мы обновляем lastButtonState.
  4. Если подтверждённое состояние равно HIGH (кнопку именно нажали, а не отпустили), меняем состояние светодиода ledOn на противоположное.

В коде используются две новые конструкции C++:

  • тип bool хранит логическое значение: true (истина, включено) или false (ложь, выключено);
  • оператор ! меняет логическое значение на противоположное: запись ledOn = !ledOn; превращает false в true и наоборот.
const int BUTTON_PIN = 28;
const int LED_PIN = 48;

const int DEBOUNCE_DELAY_MS = 30;

bool ledOn = false;
int lastButtonState = LOW;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  // Запоминаем начальное состояние кнопки при включении платы.
  lastButtonState = digitalRead(BUTTON_PIN);
}

void loop() {
  int reading = digitalRead(BUTTON_PIN);

  // Если уровень изменился, ждём окончания дребезга и проверяем пин ещё раз.
  if (reading != lastButtonState) {
    delay(DEBOUNCE_DELAY_MS);
    reading = digitalRead(BUTTON_PIN);
  }

  // Если после паузы состояние действительно изменилось, запоминаем его.
  if (reading != lastButtonState) {
    lastButtonState = reading;

    // Переключаем светодиод только в момент нажатия (переход в HIGH).
    if (lastButtonState == HIGH) {
      ledOn = !ledOn;

      if (ledOn) {
        digitalWrite(LED_PIN, HIGH);
      } else {
        digitalWrite(LED_PIN, LOW);
      }
    }
  }
}

Ожидаемый результат

После загрузки D48 погашен. Первое нажатие кнопки D28 включает светодиод, следующее нажатие выключает его. Пока вы удерживаете кнопку нажатой, светодиод повторно не мигает.

Обратите внимание: переменная lastButtonState обновляется и при нажатии (HIGH), и при отпускании (LOW). Если не сохранить LOW, когда вы отпустили кнопку, в переменной lastButtonState навсегда останется HIGH, и следующее нажатие программа уже не заметит.

Почему здесь пока используется delay()

Короткая пауза 30 мс ненадолго приостанавливает программу только в момент нажатия или отпускания кнопки. Для знакомства с алгоритмом так нагляднее всего. В уроке 3 мы заменим блокирующие паузы отсчётом времени через millis(), чтобы плата могла выполнять несколько задач одновременно.

Шаг 3. Очередь из четырёх светодиодов и две кнопки

Теперь задействуем все четыре светодиода (D48, D49, D50, D51) и обе кнопки:

  • кнопка D15 будет зажигать следующий светодиод в ряду;
  • кнопка D28 будет гасить последний включённый светодиод.

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

const int LED_PINS[4] = {48, 49, 50, 51};

Номер элемента в массиве называется индексом и отсчитывается с нуля: LED_PINS[0] — это пин 48, LED_PINS[1] — пин 49, а LED_PINS[3] — пин 51.

Чтобы не писать pinMode() и digitalWrite() четыре раза подряд, по элементам массива проходят циклом for:

for (int i = 0; i < LED_COUNT; i++) {
  // Действие с элементом LED_PINS[i]
}

В круглых скобках цикла for записаны три шага:

  1. int i = 0 — создаём счётчик i и начинаем с нулевого индекса;
  2. i < LED_COUNT — повторяем цикл, пока индекс меньше 4 (то есть для 0, 1, 2 и 3);
  3. i++ — после каждого прохода увеличиваем счётчик i на единицу.

В программе ниже мы также используем оператор && («логическое И»): условие lastUpState == HIGH && litCount < LED_COUNT истинно только тогда, когда выполняются обе части одновременно — кнопка нажата и включены ещё не все четыре светодиода.

Поскольку кнопок теперь две, проверку антидребезга мы вынесли в отдельную функцию int confirmReading(int pin, int lastState). В отличие от функции void, она возвращает итоговый уровень пина (HIGH или LOW) с помощью команды return.

const int UP_BUTTON_PIN = 15;
const int DOWN_BUTTON_PIN = 28;
const int DEBOUNCE_DELAY_MS = 30;
const int LED_COUNT = 4;
const int LED_PINS[LED_COUNT] = {48, 49, 50, 51};

int litCount = 0;
int lastUpState;
int lastDownState;

// Включает первые count светодиодов массива и гасит остальные.
void showLitCount(int count) {
  for (int i = 0; i < LED_COUNT; i++) {
    if (i < count) {
      digitalWrite(LED_PINS[i], HIGH);
    } else {
      digitalWrite(LED_PINS[i], LOW);
    }
  }
}

// Возвращает устойчивый уровень пина: после изменения ждёт 30 мс и читает вход ещё раз.
int confirmReading(int pin, int lastState) {
  int reading = digitalRead(pin);

  if (reading != lastState) {
    delay(DEBOUNCE_DELAY_MS);
    reading = digitalRead(pin);
  }

  return reading;
}

void setup() {
  pinMode(UP_BUTTON_PIN, INPUT);
  pinMode(DOWN_BUTTON_PIN, INPUT);

  for (int i = 0; i < LED_COUNT; i++) {
    pinMode(LED_PINS[i], OUTPUT);
  }

  showLitCount(litCount);
  lastUpState = digitalRead(UP_BUTTON_PIN);
  lastDownState = digitalRead(DOWN_BUTTON_PIN);
}

void loop() {
  int upReading = confirmReading(UP_BUTTON_PIN, lastUpState);
  if (upReading != lastUpState) {
    lastUpState = upReading;
    if (lastUpState == HIGH && litCount < LED_COUNT) {
      litCount++;
      showLitCount(litCount);
    }
  }

  int downReading = confirmReading(DOWN_BUTTON_PIN, lastDownState);
  if (downReading != lastDownState) {
    lastDownState = downReading;
    if (lastDownState == HIGH && litCount > 0) {
      litCount--;
      showLitCount(litCount);
    }
  }
}

Нажмите Проверить, затем Загрузить.

Ожидаемый результат

После загрузки все четыре светодиода погашены. Каждое нажатие D15 зажигает следующий светодиод в ряду: D48, затем D49, D50 и D51. Каждое нажатие D28 гасит последний включённый светодиод. Когда горят все четыре, нажатие D15 ничего не меняет; когда все погашены, D28 не уводит счётчик в минус.

В функции showLitCount() индекс i сравнивается с текущим количеством count. Пока индекс меньше count, светодиод включается. Например, при litCount = 2 условие i < 2 выполняется для индексов 0 и 1, поэтому горят D48 и D49.

Если схема работает не так, как ожидалось

НаблюдениеЧто проверить
Светодиод горит при отпущенной кнопкеПроверьте, что в условии сравнивается HIGH, а в pinMode() указан режим INPUT, а не INPUT_PULLUP
Нажатие кнопок ничего не меняетПроверьте номера пинов: для кнопки «больше» — 15, для «меньше» — 28
Одно нажатие переключает сразу несколько светодиодовУбедитесь, что вызывается confirmReading() с паузой 30 мс, а состояние обновляется и при отпускании кнопки
Загорается не тот светодиодПроверьте порядок номеров в массиве {48, 49, 50, 51} и условие i < count в showLitCount()

Назад: Светодиод на плате.
Дальше: Управление сервоприводом.

Управление сервоприводом

В этой части урока мы подключим сервопривод к штатному разъёму D2 на плате TurtleBro. Сначала проверим движение вала между двумя углами по таймеру, а затем будем переключать положение сервопривода между 0° и 90° нажатием кнопки D28 с индикацией на светодиоде D48.

Подключение сервопривода к плате

У стандартного сервопривода трёхпроводной кабель с одной трёхконтактной колодкой. На плате TurtleBro предусмотрен ряд трёхконтактных разъёмов специально для сервоприводов (D2–D7). Макетная плата не нужна — колодка сервопривода надевается прямо на штырьки разъёма D2.

Перед подключением обязательно сверьте маркировку контактов −, +, S на плате с цветами проводов кабеля:

Маркировка на платеНазначение контактаСтандартный цвет провода
−Общий провод (GND)Коричневый или чёрный
+Питание сервопривода (5 В)Красный
SУправляющий сигналОранжевый, жёлтый или белый

Питание мотор сервопривода получает с контакта + своего разъёма. Не соединяйте эту силовую линию 5 В с сигнальными пинами или пинами питания 3,3 В микроконтроллера Arduino Due.

Сверьте контакты −, + и S до подачи питания

Неправильная ориентация разъёма может вывести из строя сервопривод или плату. Сначала отключите USB-кабель от платы, наденьте колодку сервопривода на разъём D2, проверьте совпадение маркировки −, +, S с цветами проводов и только после этого подключайте USB-кабель.

Не отключайте сервопривод под нагрузкой

Не снимайте и не переставляйте колодку сервопривода, пока плата подключена к питанию. Сначала отсоедините USB-кабель.

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

Шаг 1. Проверочное движение без кнопки

Для управления сервоприводом подключим стандартную библиотеку Servo.h директивой #include <Servo.h>. Она сама формирует управляющие сигналы на пине, а в скетче достаточно указать номер пина и нужный угол в градусах.

#include <Servo.h>

const int SERVO_PIN = 2;

Servo servo;

void setup() {
  servo.attach(SERVO_PIN);
}

void loop() {
  servo.write(45);
  delay(1000);
  servo.write(90);
  delay(1000);
}

Нажмите Проверить, затем Загрузить.

Ожидаемый результат

Вал сервопривода поочерёдно поворачивается на угол 45° и 90°, задерживаясь в каждом положении на 1 с. Плата не перезагружается, привод не дёргается и не гудит.

Если при компиляции Arduino IDE сообщает, что файл Servo.h не найден, откройте менеджер библиотек (Инструменты → Менеджер библиотек), введите в поиске Servo и установите стандартную библиотеку Servo от Arduino.

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

Разберём новые команды:

  • Servo servo; — создаёт объект для управления одним сервоприводом;
  • servo.attach(SERVO_PIN); — привязывает объект к разъёму D2;
  • servo.write(45); — даёт команду повернуть вал на угол 45°.

Как сервопривод понимает угол: сигнал ШИМ

По управляющему проводу S передаётся не постоянное напряжение, а периодические прямоугольные импульсы — широтно-импульсная модуляция (ШИМ, PWM).

Импульсы следуют с периодом около 20 мс (50 раз в секунду), а требуемый угол кодируется длительностью (шириной) каждого импульса: более короткий импульс поворачивает вал к 0°, более длинный — к 180° (по умолчанию библиотека Servo использует диапазон импульсов примерно от 544 до 2400 мкс).

В скетче рассчитывать микросекунды вручную не нужно: вы вызываете servo.write(90), а библиотека Servo сама поддерживает нужную последовательность импульсов на пине.

Шаг 2. Переключение между 0° и 90° по нажатию кнопки

Объединим управление сервоприводом с чтением кнопки D28 и защитой от дребезга из предыдущего раздела. Логическая переменная isOpen будет хранить текущее состояние механизма:

  • false — закрыто (0°, светодиод D48 погашен);
  • true — открыто (90°, светодиод D48 горит).
#include <Servo.h>

const int BUTTON_PIN = 28;
const int LED_PIN = 48;
const int SERVO_PIN = 2;

const int DEBOUNCE_DELAY_MS = 30;
const int CLOSED_ANGLE = 0;
const int OPEN_ANGLE = 90;

Servo servo;
bool isOpen = false;
int lastButtonState;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  servo.attach(SERVO_PIN);
  servo.write(CLOSED_ANGLE);

  lastButtonState = digitalRead(BUTTON_PIN);
}

void loop() {
  int reading = digitalRead(BUTTON_PIN);

  if (reading != lastButtonState) {
    delay(DEBOUNCE_DELAY_MS);
    reading = digitalRead(BUTTON_PIN);
  }

  if (reading != lastButtonState) {
    lastButtonState = reading;

    if (lastButtonState == HIGH) {
      if (isOpen) {
        servo.write(CLOSED_ANGLE);
        digitalWrite(LED_PIN, LOW);
        isOpen = false;
      } else {
        servo.write(OPEN_ANGLE);
        digitalWrite(LED_PIN, HIGH);
        isOpen = true;
      }
    }
  }
}

Нажимайте кнопку D28 и давайте валу сервопривода завершить поворот перед следующим нажатием.

Ожидаемый результат

После загрузки вал устанавливается в положение 0°, светодиод D48 погашен. Первое нажатие кнопки D28 поворачивает вал на 90° и зажигает светодиод D48. Следующее нажатие возвращает вал в 0° и гасит светодиод.

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

Если сервопривод работает не так, как ожидалось

НаблюдениеЧто проверить
Вал не двигаетсяПроверьте подключение к разъёму D2, соответствие проводов маркировке −, +, S и наличие вызова servo.attach(SERVO_PIN) в setup()
Привод дёргается или плата перезагружаетсяСразу отключите USB. Проверьте, что красный провод питания находится на центральном контакте +, а не перепутан с − или S
Кнопка не переключает уголПроверьте номер пина кнопки (28) и условие перехода lastButtonState == HIGH
Сервопривод гудит в крайнем положенииОтключите питание платы и проверьте, не мешает ли повороту механическое препятствие; при необходимости сузьте диапазон углов (например, 10°–170°)
Светодиод не загорается при 90°Проверьте номер пина светодиода (48) и вызов digitalWrite(LED_PIN, HIGH) в ветке else

Вопросы для самопроверки

  1. Почему нажатие кнопки на плате TurtleBro даёт уровень HIGH и почему в этих скетчах не используется режим INPUT_PULLUP?
  2. Какой параметр сигнала ШИМ определяет угол поворота сервопривода и почему в скетче не нужно формировать импульсы вручную?
  3. Каким цветам проводов сервопривода соответствуют контакты −, + и S на разъёме платы?
  4. Зачем при проверке кнопки ждать 30 мс после изменения сигнала и почему важно обновлять lastButtonState также при отпускании кнопки?
  5. Почему силовую линию 5 В на разъёме сервопривода нельзя соединять с сигнальными пинами платы Arduino Due?

Справочный материал: как устроен сервопривод

Внутри корпуса обычного хоббийного сервопривода находятся электродвигатель постоянного тока, редуктор, датчик угла поворота (потенциометр) и небольшая плата управления. Плата управления непрерывно сравнивает текущий угол вала с длительностью приходящего ШИМ-импульса и вращает мотор до тех пор, пока вал не займёт нужное положение. Если валу физически мешать повернуться, мотор будет пытаться преодолеть препятствие, а потребляемый ток резко вырастет — именно поэтому заблокированный и гудящий привод нужно сразу обесточить.

Назад: Кнопки и очередь светодиодов.
Дальше: Домашнее задание.

Домашнее задание

В практической части кнопка сразу переводила сервопривод из 0° в 90°. Теперь напишите программу, в которой сервопривод начинает работу со среднего положения 90°, плавно поворачивается влево при удержании кнопки D28 и вправо при удержании кнопки D15, а в крайних положениях зажигает светодиоды D48 и D51.

Сервопривод остаётся подключённым к разъёму D2 с тем же порядком проводов −, +, S.

Требования к работе устройства

  1. После включения или перезагрузки платы сервопривод устанавливается в среднее положение 90°, а светодиоды D48 и D51 погашены.
  2. Пока удерживается кнопка D28 и отпущена D15, угол уменьшается на 1° за шаг (поворот влево). Дойдя до 0°, сервопривод останавливается.
  3. Пока удерживается кнопка D15 и отпущена D28, угол увеличивается на 1° за шаг (поворот вправо). Дойдя до 180°, сервопривод останавливается.
  4. Пауза между шагами составляет 20 мс — благодаря этому вал поворачивается плавно.
  5. Если отпущены обе кнопки или нажаты обе кнопки одновременно, текущий угол не меняется.
  6. В крайнем левом положении (0°) горит светодиод D48. В крайнем правом положении (180°) горит светодиод D51. На всех промежуточных углах (1°–179°) оба светодиода выключены.

Требования к программе

  • Кнопки настроены как INPUT, нажатию соответствует уровень HIGH.
  • Текущий угол хранится в переменной (например, int angle = 90;).
  • За один шаг угол изменяется на 1°, после чего выполняется delay(20).
  • Программа не позволяет углу выйти за пределы диапазона 0°–180°.
  • Состояние светодиодов определяется текущим значением угла.

Как составить алгоритм

  1. Возьмите за основу скетч из предыдущего раздела, в котором сервопривод подключён к пину D2.
  2. В setup() настройте пины кнопок и светодиодов, привяжите сервопривод, установите начальный угол 90° и погасите светодиоды.
  3. В loop() считайте текущее состояние обеих кнопок.
  4. Если нажата только левая кнопка (D28) и angle > 0, уменьшите angle на 1, отправьте новый угол в servo.write(angle) и подождите 20 мс.
  5. Иначе, если нажата только правая кнопка (D15) и angle < 180, увеличьте angle на 1, отправьте угол в servo.write(angle) и подождите 20 мс.
  6. Обновите светодиоды: включите D48, только если angle == 0, и D51, только если angle == 180.

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

Как убедиться, что всё работает правильно

  • После загрузки вал встаёт посередине, оба светодиода не горят.
  • При удержании D28 вал плавно поворачивается к 0° примерно за 1,8 с, после чего останавливается и зажигает D48.
  • При начале движения обратно к 180° кнопкой D15 светодиод D48 сразу гаснет, а в конце хода на 180° загорается D51.
  • Одновременное нажатие двух кнопок останавливает движение.

Посмотреть решение и разбор

Назад: Управление сервоприводом.
Дальше: Урок 3. Чтение данных, работа с Serial портом.

Урок 3. Чтение данных, работа с Serial портом

В уроках 1 и 2 плата работала с цифровыми сигналами HIGH и LOW, а паузы задавались функцией delay(). Теперь вы научитесь читать аналоговый сигнал на разъёме GPIO A8 (с потенциометром или без датчика), выводить полученные значения в утилиту мониторинга порта и графики в плоттер графиков (инструменты Arduino IDE), принимать команды с компьютера через Serial и заменять блокирующий delay() неблокирующими таймерами на основе millis().

В этом уроке вы научитесь

  • подключать потенциометр к разъёму GPIO платы TurtleBro;
  • считывать и нормализовать аналоговый сигнал на пине A8;
  • передавать отладочные сообщения на компьютер и визуализировать сигналы в плоттере графиков (Serial Plotter);
  • отправлять команды с компьютера в плату через утилиту мониторинга порта (Serial Monitor);
  • объяснять, почему delay() мешает приёму команд и связи с ROS 2;
  • строить неблокирующие периодические задачи с помощью millis().

Урок можно пройти и без потенциометра

В первой части урока мы рассмотрим подключение потенциометра (10 кОм) к разъёму GPIO A8. Если у вас под рукой нет потенциометра или другого аналогового датчика, ничего подключать к разъёму GPIO A8 не нужно. Чтение аналогового сигнала через analogRead(A8) всё равно будет работать: на неподключённом («плавающем») контакте микроконтроллер измеряет слабые электрические наводки и возвращает меняющиеся значения. Во второй части урока для проверки команд из порта понадобится сервопривод на разъёме D2.

На разъём GPIO нельзя подавать больше 3,3 В

Входы микроконтроллера Arduino Due рассчитаны максимум на 3,3 В. Питайте потенциометр только от контакта 3.3V на разъёме GPIO A8. Подача 5 В на сигнальный контакт GPIO (A8) может повредить плату.

Пины, которые используются в уроке

КомпонентПин или контакт на платеНазначение в уроке
Разъём GPIO A83.3V, GND, GPIO (A8)Подключение потенциометра и чтение аналогового сигнала через analogRead(A8)
Светодиоды платыD48, D49Индикация порога и режимов работы
Кнопка платыD28Проверка мгновенного отклика без delay()
Разъём сервоприводаD2Поворот вала по команде из Serial и по сигналу A8

План урока

  1. Аналоговый сигнал и утилита мониторинга порта — чтение аналогового сигнала, подключение потенциометра к разъёму GPIO A8 (и работа без него), вывод текста в Serial Monitor и графиков в Serial Plotter.
  2. Таймер millis() и команды из порта — отказ от delay(), неблокирующий опрос и управление сервоприводом через Serial.
  3. Домашнее задание — фоновое мигание светодиода на millis(), подсчёт нажатий кнопки D28 и сброс счётчика командой '0' из утилиты мониторинга порта.

Назад: Домашнее задание.
Дальше: Аналоговый сигнал и утилита мониторинга порта.

Аналоговый сигнал и утилита мониторинга порта

Цифровой вход из урока 2 различает только два состояния: LOW и HIGH. Но многие датчики — положения ручки потенциометра, освещённости, расстояния — выдают плавно меняющееся напряжение. Такой сигнал называется аналоговым. В этой части урока мы разберём, как подключить потенциометр к разъёму GPIO A8, прочитаем аналоговый сигнал функцией analogRead(A8), выведем значения на компьютер через Serial и построим живой график в плоттере графиков.

Как подключить потенциометр к разъёму GPIO

На плате TurtleBro разъём GPIO A8 выполнен в виде 5-контактной колодки с подписями 3.3V, GND, SCL, SDA и GPIO:

  • 3.3V и GND — питание 3,3 В и общий провод (0 В);
  • SCL и SDA — линии цифровой шины I²C (при чтении аналогового сигнала они не используются и остаются свободными);
  • GPIO — сигнальный контакт разъёма, соединённый с пином A8 микроконтроллера.

Самый наглядный источник аналогового сигнала — потенциометр (переменный резистор, например номиналом 10 кОм). Внутри него расположена резистивная дорожка между двумя крайними выводами, а при вращении ручки по дорожке скользит средний вывод (движок).

Внешний вид потенциометра и назначение его выводов

Если подать на крайние выводы 3.3V и GND, потенциометр работает как регулируемый делитель напряжения:

  • в одном крайнем положении ручки на среднем выводе около 0 В;
  • посередине — около 1,65 В;
  • в другом крайнем положении — 3,3 В.

Схема подключения потенциометра к разъёму GPIO A8

Принципиальная электрическая схема делителя напряжения на переменном резисторе RP1:

Принципиальная схема подключения потенциометра к разъёму GPIO A8

Монтажная схема подключения потенциометра к 5-контактному разъёму GPIO A8:

Монтажная схема подключения потенциометра к разъёму GPIO A8

Контакт разъёма GPIO A8Вывод потенциометраЦвет провода на схемеНазначение
3.3VКрайний вывод 1КрасныйПитание делителя (3,3 В)
GNDКрайний вывод 2ЧёрныйОбщий провод (0 В)
SCLне подключается—Линия I²C (остаётся свободной)
SDAне подключается—Линия I²C (остаётся свободной)
GPIO (A8)Средний вывод (движок)ГолубойАналоговый сигнал 0–3,3 В

Средний вывод потенциометра — только на контакт GPIO

Если поменять местами провода на двух крайних выводах потенциометра (3.3V и GND), ничего страшного не произойдёт — просто направление отсчёта при повороте ручки сменится на противоположное. Но средний вывод (движок) обязательно должен идти к контакту GPIO: если ошибочно подключить к движку 3.3V или GND, то в крайнем положении ручки питание замкнётся накоротко.

Если потенциометр не подключён

Вы можете выполнять все примеры этого урока вообще без потенциометра. Когда к контакту GPIO (A8) ничего не подключено, он остаётся «висящим в воздухе» и улавливает слабые электромагнитные наводки. Поэтому analogRead(A8) будет исправно работать и возвращать какие-то меняющиеся значения (например, около 300–700). Если поднести палец к контакту GPIO на разъёме A8, показания заметно изменятся — так можно проверить реакцию программы и графика без датчика.

Как микроконтроллер переводит напряжение в цифровое значение

Внутри микроконтроллера работает АЦП — аналого-цифровой преобразователь. По умолчанию функция analogRead() использует 10-битную шкалу (1024 уровня) и возвращает полученное значение в диапазоне от 0 до 1023:

  • 0 соответствует напряжению около 0 В;
  • 512 — половине шкалы (около 1,65 В);
  • 1023 — полному напряжению 3,3 В.

Последовательный порт Serial: связь с компьютером

В уроках 1 и 2 кабель USB использовался только для загрузки скетча. По тому же кабелю плата может во время работы отправлять на компьютер текст и полученные значения, а также принимать ответные команды. В Arduino за этот канал обмена отвечает объект Serial:

  • Serial.begin(115200); — включает обмен данными на скорости 115200 бод (бит в секунду). Вызывается один раз в setup().
  • Serial.print(x); — отправляет текст или значение без перевода строки.
  • Serial.println(x); — отправляет значение и переходит на новую строку.

Шаг 1. Чтение A8 и вывод полученных значений в утилиту мониторинга порта

Соберём скетч, который считывает analogRead(A8), сравнивает полученное значение с порогом 512, зажигает светодиод D48 при превышении порога и выводит измерения на компьютер.

const int SENSOR_PIN = A8;
const int LED_PIN = 48;
const int THRESHOLD = 512;

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

  // Открываем последовательный порт на скорости 115200 бод.
  Serial.begin(115200);
}

void loop() {
  int rawValue = analogRead(SENSOR_PIN);

  if (rawValue > THRESHOLD) {
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }

  Serial.print("ADC: ");
  Serial.println(rawValue);

  delay(200);
}

Как посмотреть полученные значения в утилите мониторинга порта

  1. Нажмите Загрузить (Upload) и дождитесь окончания прошивки.
  2. Откройте утилиту мониторинга порта: Инструменты → Монитор порта (Tools → Serial Monitor) или нажмите значок лупы в правом верхнем углу Arduino IDE.
  3. В правом верхнем углу панели утилиты мониторинга порта выберите скорость 115200 baud.

Ожидаемый результат

В окне утилиты мониторинга порта пять раз в секунду появляются строки вида ADC: 480. Если подключён потенциометр — плавно поворачивайте его ручку от упора до упора и наблюдайте изменение полученных значений от 0 до 1023. Если потенциометр не подключён — поднесите палец к контакту A8: значения начнут меняться, а при переходе через 512 будет загораться и гаснуть светодиод D48.

Если вместо текста видны странные символы («кракозябры»)

Проверьте скорость в выпадающем списке утилиты мониторинга порта: она должна точно совпадать со скоростью в Serial.begin(115200). Если в скетче указано 115200, а в настройках окна выбрано 9600, компьютер будет неправильно расшифровывать биты.

Функции пересчёта: map() и constrain()

Сырое значение АЦП (0–1023) неудобно передавать напрямую в сервопривод, который ждёт угол от 0 до 180. Для линейного пересчёта одного диапазона в другой в Arduino есть две встроенные функции:

  1. map(value, fromLow, fromHigh, toLow, toHigh) — пропорционально переводит значение value из старого диапазона [fromLow, fromHigh] в новый [toLow, toHigh].
  2. constrain(value, minVal, maxVal) — ограничивает значение сверху и снизу: если оно меньше minVal, возвращает minVal; если больше maxVal, возвращает maxVal.

Например, перевод чтения A8 в градусы сервопривода записывается так:

int angle = map(rawValue, 0, 1023, 0, 180);
angle = constrain(angle, 0, 180);

Шаг 2. Живой график в плоттере графиков (Serial Plotter)

Когда показания быстро меняются, бегущий столбик строк трудно анализировать глазами. В Arduino IDE 2 встроен плоттер графиков (Serial Plotter): он строит линии графиков по значениям, которые плата выводит в одной строке через пробел в формате Имя:Значение.

Загрузите скетч, который выводит сразу три линии: сырое значение raw, опорный порог threshold и пересчитанный угол angle:

const int SENSOR_PIN = A8;
const int THRESHOLD = 512;
const int ADC_MAX = 1023;

void setup() {
  Serial.begin(115200);
}

void loop() {
  int rawValue = analogRead(SENSOR_PIN);
  int angle = map(rawValue, 0, ADC_MAX, 0, 180);
  angle = constrain(angle, 0, 180);

  // Формат для Serial Plotter: пары Имя:Значение через пробел.
  Serial.print("raw:");
  Serial.print(rawValue);
  Serial.print(" threshold:");
  Serial.print(THRESHOLD);
  Serial.print(" angle:");
  Serial.println(angle);

  delay(50);
}

Как открыть график

  1. Загрузите скетч в плату.
  2. Закройте вкладку утилиты мониторинга порта (Монитор порта), если она была открыта (обе утилиты используют один и тот же последовательный порт).
  3. Откройте Инструменты → Плоттер по последовательному соединению (Tools → Serial Plotter).
  4. Убедитесь, что в окне плоттера выбрана скорость 115200 baud.

Ожидаемый результат

На графике бегут три разноцветные линии: горизонтальная линия порога threshold на уровне 512, кривая raw аналогового сигнала с разъёма GPIO A8 (при вращении ручки потенциометра она плавно поднимается и опускается в пределах 0–1023, а без датчика показывает колебания наводок) и масштабированная линия angle в диапазоне 0–180.

Назад: Урок 3. Чтение данных, работа с Serial портом.
Дальше: Таймер millis() и команды из порта.

Таймер millis() и команды из порта

Во всех предыдущих скетчах мы использовали delay(). Пока программа выполняет только одно действие — например, мигает светодиодом или раз в 50 мс выводит график, — пауза не мешает. Но при управлении роботом плата должна одновременно опрашивать датчики, мигать индикаторами и без задержек принимать команды от компьютера. В этой части урока мы запустим несколько периодических задач в одном loop() с помощью таймера millis() без единого вызова delay() и будем управлять углом сервопривода командами из Serial Monitor.

Почему delay() мешает плате делать несколько дел сразу

Программа внутри loop() выполняется строго построчно — сверху вниз. Когда плата доходит до команды delay(1000), она буквально замирает на этой строке на целую секунду и ждёт, пока время выйдет.

Представьте, что вы поставили чайник и на минуту закрыли глаза и уши: пока минута не пройдёт, вы не ответите на звонок и не заметите, что вам кто-то машет рукой. Точно так же ведёт себя и плата во время delay():

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

Поэтому, когда плате нужно одновременно мигать светодиодом, следить за кнопками и принимать команды с компьютера, останавливать программу через delay() нельзя.

Правило курса начиная с этого раздела

Во всех следующих скетчах урока 3 и в уроках 4–8 внутри loop() не используется delay(). Вместо остановки программы мы будем проверять время по встроенному секундомеру millis().

Как работает секундомер millis()

Функция millis() возвращает количество миллисекунд, прошедших с момента включения или перезагрузки платы. Это встроенный секундомер, который тикает в фоновом режиме сам по себе и никогда не останавливает программу.

Вместо того чтобы «засыпать» на 500 мс, программа действует как человек, который поглядывает на часы:

  1. Запоминает время последнего действия в переменной unsigned long lastTime = 0;.
  2. На каждом проходе loop() вычисляет разницу millis() - lastTime.
  3. Если разница достигла нужного интервала (например, 500 мс), обновляет lastTime и выполняет действие. Если ещё не достигла — сразу переходит к следующим строкам loop().

Тип unsigned long используется потому, что счётчик миллисекунд быстро растёт и требует большого положительного целого числа без знака.

const unsigned long BLINK_PERIOD_MS = 500;
unsigned long lastBlinkTime = 0;

void loop() {
  unsigned long now = millis();

  if (now - lastBlinkTime >= BLINK_PERIOD_MS) {
    lastBlinkTime = now;
    // Это действие выполняется ровно раз в 500 мс, не задерживая loop()!
  }

  // Здесь без малейшей паузы проверяются кнопки и порт Serial.
}

Шаг 1. Два процесса одновременно: мигание и мгновенная кнопка

Проверим преимущество millis() на практике: пусть светодиод D48 размеренно мигает раз в 500 мс, а светодиод D49 мгновенно повторяет нажатие кнопки D28. Если бы мигание было написано через delay(500), кнопка реагировала бы с полусекундным опозданием.

const int BUTTON_PIN = 28;
const int BLINK_LED_PIN = 48;
const int BUTTON_LED_PIN = 49;

const unsigned long BLINK_PERIOD_MS = 500;

unsigned long lastBlinkTime = 0;
bool blinkState = false;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(BLINK_LED_PIN, OUTPUT);
  pinMode(BUTTON_LED_PIN, OUTPUT);
}

void loop() {
  unsigned long now = millis();

  // Задача 1: мигать светодиодом D48 каждые 500 мс.
  if (now - lastBlinkTime >= BLINK_PERIOD_MS) {
    lastBlinkTime = now;
    blinkState = !blinkState;
    digitalWrite(BLINK_LED_PIN, blinkState ? HIGH : LOW);
  }

  // Задача 2: без задержки включать D49, пока нажата кнопка D28.
  if (digitalRead(BUTTON_PIN) == HIGH) {
    digitalWrite(BUTTON_LED_PIN, HIGH);
  } else {
    digitalWrite(BUTTON_LED_PIN, LOW);
  }
}

Запись blinkState ? HIGH : LOW — это краткая форма условия: если blinkState равно true, выбирается HIGH, иначе — LOW.

Ожидаемый результат

Светодиод D48 ровно мигает раз в полсекунды. В любой момент нажмите кнопку D28 — светодиод D49 загорится мгновенно, не дожидаясь окончания полусекундного такта мигания.

Как принимать команды с компьютера через Serial

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

  • Serial.available() > 0 — сообщает, что в буфере появились новые символы от компьютера;
  • Serial.read() — забирает из буфера один символ (char), например букву команды;
  • Serial.parseInt() — считывает из потока целое число (например, 90).

Шаг 2. Опрос A8 по таймеру и поворот сервопривода командой из Serial

Подключите сервопривод к разъёму D2 (предварительно отключив USB и сверив контакты −, +, S). В этом скетче плата одновременно решает две задачи:

  1. Каждые 200 мс по таймеру millis() считывает analogRead(A8) (с датчиком или без него) и выводит текущее значение АЦП и угол сервопривода.
  2. Непрерывно проверяет Serial: если вы отправили из утилиты мониторинга порта число от 0 до 180, плата сразу поворачивает сервопривод на этот угол.
#include <Servo.h>

const int SENSOR_PIN = A8;
const int SERVO_PIN = 2;

const unsigned long REPORT_PERIOD_MS = 200;

Servo servo;
int currentAngle = 90;
unsigned long lastReportTime = 0;

void setup() {
  Serial.begin(115200);

  servo.attach(SERVO_PIN);
  servo.write(currentAngle);
}

void loop() {
  unsigned long now = millis();

  // Задача 1: приём угла (0..180) из утилиты мониторинга порта без задержек.
  if (Serial.available() > 0) {
    int requestedAngle = Serial.parseInt();

    // Очищаем остаток строки (перевод строки \n или \r).
    while (Serial.available() > 0) {
      Serial.read();
    }

    currentAngle = constrain(requestedAngle, 0, 180);
    servo.write(currentAngle);

    Serial.print("New angle set to: ");
    Serial.println(currentAngle);
  }

  // Задача 2: периодический вывод чтения A8 и текущего угла каждые 200 мс.
  if (now - lastReportTime >= REPORT_PERIOD_MS) {
    lastReportTime = now;
    int rawValue = analogRead(SENSOR_PIN);

    Serial.print("ADC: ");
    Serial.print(rawValue);
    Serial.print(" | Angle: ");
    Serial.println(currentAngle);
  }
}

Как отправить команду из утилиты мониторинга порта

  1. Загрузите скетч и откройте утилиту мониторинга порта (Монитор порта) на скорости 115200 baud.
  2. В верхнем поле ввода (Message) введите число 45 и нажмите Enter.
  3. Затем введите 135 и снова нажмите Enter.

Ожидаемый результат

В утилите мониторинга порта каждые 200 мс печатается строка ADC: ... | Angle: .... Как только вы отправляете число 45 или 135, сервопривод сразу поворачивается на заданный угол, а в журнале появляется подтверждение New angle set to: ....

Зачем нам понадобится библиотека RosDuino в уроке 4

Обратите внимание, как в loop() нам пришлось вручную разбирать числа из потока Serial, очищать символы перевода строки и склеивать текстовые ответы из кусочков Serial.print(). Когда у робота десятки датчиков и команд, такой ручной разбор текста быстро становится хрупким и громоздким. Начиная с урока 4 библиотека RosDuino возьмёт весь обмен по последовательному порту на себя и превратит функции платы в стандартные топики и сервисы ROS 2.

Вопросы для самопроверки

  1. Какое примерно значение вернёт analogRead(A8) при стандартной шкале 0–1023, если на вход подать напряжение 1,65 В? Что вернёт analogRead(A8), если к разъёму GPIO вообще не подключён датчик?
  2. Что произойдёт в окне утилиты мониторинга порта, если в скетче написано Serial.begin(115200), а в настройках утилиты выбрана скорость 9600 baud?
  3. Почему в программах для роботов нельзя использовать delay(1000) внутри loop() и какой конструкцией с millis() её заменяют?
  4. В чём разница между функциями map() и constrain()?

Назад: Аналоговый сигнал и утилита мониторинга порта.
Дальше: Домашнее задание.

Домашнее задание

В этом задании вы напишете неблокирующий скетч без использования delay(), в котором светодиод D48 равномерно мигает по таймеру millis(), каждое нажатие кнопки D28 увеличивает счётчик и выводит его в утилиту мониторинга порта, а команда '0' с компьютера сбрасывает счётчик в ноль. Для проверки не нужны ни потенциометр, ни сервопривод — достаточно самой платы TurtleBro, подключённой по USB.

Что должно получиться

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

  1. Фоновое мигание светодиода (D48):
    • светодиод D48 переключается каждые 500 мс с помощью таймера millis();
    • это индикатор того, что программа работает и не зависла в delay().
  2. Подсчёт нажатий кнопки (D28):
    • при каждом новом нажатии кнопки D28 переменная счётчика pressCount увеличивается на 1;
    • сразу после нажатия в утилиту мониторинга порта отправляется строка: Count: 1, затем Count: 2, Count: 3 и так далее;
    • пока кнопка удерживается нажатой, счётчик повторно не увеличивается.
  3. Сброс счётчика по команде из утилиты мониторинга порта:
    • если отправить из утилиты мониторинга порта символ '0', переменная pressCount обнуляется;
    • в утилиту мониторинга порта сразу выводится сообщение: Counter reset to 0.

Требования к программе

  • В функции loop() не используется delay().
  • Мигание светодиода D48 построено на проверке millis() - lastBlinkTime >= 500.
  • Чтобы исключить дребезг контактов кнопки D28 без delay(), проверяйте кнопку по millis() (например, опрашивайте состояние кнопки раз в 30 мс).
  • Скорость последовательного порта — 115200 бод.

Как составить алгоритм

  1. Объявите константы пинов (BUTTON_PIN = 28, LED_PIN = 48) и интервалов (BLINK_PERIOD_MS = 500, BUTTON_POLL_MS = 30).
  2. Создайте переменные состояния:
    • int pressCount = 0; — счётчик нажатий;
    • int lastButtonState = LOW; — предыдущее состояние кнопки;
    • bool ledState = false; — текущее состояние светодиода;
    • unsigned long lastBlinkTime = 0; и unsigned long lastButtonTime = 0; — переменные для двух таймеров millis().
  3. В setup() настройте пины, откройте Serial.begin(115200) и считайте начальное состояние кнопки в lastButtonState.
  4. В loop() выполните три независимых блока:
    • Блок 1 (таймер 500 мс): переключите ledState и обновите светодиод D48.
    • Блок 2 (таймер 30 мс): прочитайте кнопку D28. Если новое состояние отличается от lastButtonState, сохраните его. Если новое состояние равно HIGH, увеличьте pressCount на 1 и выведите Count: ... в Serial.
    • Блок 3 (чтение Serial): проверьте while (Serial.available() > 0). Если прочитанный символ Serial.read() равен '0', обнулите pressCount и выведите Counter reset to 0.

Как убедиться, что всё работает правильно

  • В коде нет ни одного вызова delay().
  • Светодиод D48 ровно мигает один раз в секунду (500 мс горит, 500 мс погашен).
  • Каждое нажатие кнопки D28 сразу выводит в утилиту мониторинга порта новое значение Count: ..., не сбивая ритм мигания светодиода.
  • Отправка цифры 0 из утилиты мониторинга порта мгновенно сбрасывает счётчик и печатает Counter reset to 0, а следующее нажатие кнопки снова начинает счёт с Count: 1.

Посмотреть решение и разбор

Назад: Таймер millis() и команды из порта.
Дальше: Урок 4. Первый узел RosDuino.

Урок 4. Первый узел RosDuino

В уроках 1–3 плата TurtleBro работала автономно и обменивалась с компьютером только сырыми строками через Serial. Теперь мы свяжем плату с ROS 2 через библиотеку RosDuino: вы установите на компьютер с Ubuntu агент rosduino_agent, загрузите в плату первый скетч с узлом ROS 2 и будете управлять светодиодом и сервоприводом стандартными командами ros2 topic.

В этом уроке вы научитесь

  • понимать, как взаимодействуют библиотека RosDuino на плате и узел rosduino_agent на компьютере;
  • собирать и запускать пакет rosduino_agent в рабочем пространстве ROS 2 на Ubuntu;
  • соблюдать правила работы с последовательным портом при совместном использовании Arduino IDE и агента ROS 2;
  • создавать в скетче узел ROS 2 и подписываться на топик с помощью ros.begin(), ros.subscribe() и ros.update();
  • проверять список узлов и топиков и отправлять команды на плату из терминала ROS 2.

Для работы с агентом нужен Ubuntu и ROS 2

Уроки 1–3 можно было проходить в Windows или Linux. Начиная с этого урока плата подключается к среде ROS 2, поэтому понадобится компьютер с Ubuntu и установленным дистрибутивом ROS 2. Плата по-прежнему соединяется с этим компьютером по USB-кабелю, а перенос агента на бортовой компьютер самого робота мы разберём в уроке 8.

Что подготовить перед уроком

Для выполнения уроков 4–7 понадобится:

  • 64-разрядный компьютер с Ubuntu 24.04 и ROS 2;
  • установка ROS 2 в варианте Desktop: рекомендуется ROS 2 Lyrical Luth, также можно использовать ROS 2 Jazzy или ROS 2 Rolling;
  • пакеты git и python3-colcon-common-extensions, доступ в интернет для загрузки rosduino_ros;
  • свободный USB-порт и USB-кабель для подключения платы TurtleBro;
  • возможность выполнять команды в терминале Ubuntu.

После установки откройте терминал и подключите окружение вашего дистрибутива:

source /opt/ros/$ROS_DISTRO/setup.bash

Затем проверьте инструменты:

echo $ROS_DISTRO
ros2 --help
colcon --help

Команда echo $ROS_DISTRO должна вывести имя установленного дистрибутива, например lyrical, jazzy или rolling, а команды ros2 --help и colcon --help — справку без сообщений об ошибках. Если colcon не найден, установите его:

sudo apt update
sudo apt install python3-colcon-common-extensions

Базовые понятия ROS 2: узлы, топики и сообщения

В ROS 2 программа робота не пишется одним огромным файлом, а делится на небольшие самостоятельные части, которые обмениваются данными по общим правилам:

  • Узел (Node) — отдельная программа в составе робота, которая отвечает за одну конкретную задачу: например, читает камеру, строит маршрут или управляет платой микроконтроллера. С библиотекой RosDuino ваша плата TurtleBro тоже становится полноценным узлом ROS 2 со своим именем (например, /led_board).
  • Топик (Topic, тема) — именованный канал связи, через который узлы передают данные друг другу (например, /led или /servo_angle).
    • Узел, который отправляет данные в топик, называется издателем (Publisher, публикует в топик).
    • Узел, который принимает данные из топика, называется подписчиком (Subscriber, подписывается на топик). Издателю и подписчику не нужно знать, как устроен собеседник, — достаточно использовать одно и то же имя топика.
  • Сообщение (Message) — пакет данных строго определённого типа, который пересылается внутри топика. У каждого топика всегда один фиксированный тип сообщения: например, std_msgs/msg/Bool передаёт логическое значение (true или false), а std_msgs/msg/Int32 — целое число (например, угол поворота сервопривода 90).

Пины, которые используются в уроке

Компонент на платеПинНазначение в уроке
Светодиод платыD48Включение и выключение по команде из топика /led и индикация выхода за границы угла
Разъём сервоприводаD2Управление углом поворота из топика /servo_angle в домашнем задании

План урока

  1. Установка и запуск агента RosDuino — как устроена связь платы с ROS 2, сборка rosduino_agent в Ubuntu и три правила работы с портом.
  2. Управление светодиодом из ROS — первый скетч с <RosDuino.h>, запуск агента и отправка сообщений в топик /led.
  3. Домашнее задание — приём угла из топика /servo_angle с проверкой допустимых границ 0°–180° и индикацией ошибки на D48.

Назад: Домашнее задание.
Дальше: Установка и запуск агента RosDuino.

Установка и запуск агента RosDuino

В уроке 3 для передачи всего одного числа с компьютера на плату нам пришлось вручную разбирать символы из потока Serial и очищать переводы строк. Когда в системе появляются десятки датчиков, приводов и команд, такой самодельный текстовый обмен быстро становится ненадёжным. В этой части урока мы разберём, как библиотека RosDuino берёт передачу данных по кабелю на себя, и подготовим агент rosduino_agent на компьютере с Ubuntu.

Как устроена связь между платой и ROS 2

Система RosDuino состоит из двух частей, которые работают в паре:

  1. Библиотека rosduino_arduino на плате (#include <RosDuino.h>): упаковывает данные датчиков и принимает команды в компактном двоичном виде с проверкой контрольной суммы. Вы уже установили эту библиотеку в Arduino IDE в уроке 1 (документация на русском языке: rosduino_arduino/README_RU.md).
  2. Узел-агент rosduino_agent на компьютере с Ubuntu: подключается к плате по USB-кабелю и создаёт в графе ROS 2 обычные узлы, топики и сервисы (общая документация: rosduino_ros/README_RU.md, описание самого агента: rosduino_agent/README_RU.md).
flowchart LR
    MCU["МК + RosDuino"] <-.-> SP(["Serial порт (USB)"])
    SP <-.-> Agent
    subgraph PC["Компьютер с Ubuntu"]
        Agent["rosduino_agent"] <--> ROS2["Система ROS 2"]
    end
    style SP fill:#fef3c7,stroke:#d97706,stroke-width:2px,stroke-dasharray: 5 5,color:#78350f
    style PC fill:#f8fafc,stroke:#64748b,stroke-width:1.5px,color:#0f172a

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

Три правила работы с Serial портом

Последовательный порт USB в каждый момент времени может занимать только одна программа. Чтобы загрузка скетчей и связь с ROS 2 не мешали друг другу, соблюдайте три правила:

  1. Не используйте Serial и закрывайте утилиту мониторинга порта
  2. Останавливайте rosduino_agent перед загрузкой скетча
  3. В функции loop() вызывайте ros.update() без delay()

Шаг 1. Проверьте библиотеку RosDuino в Arduino IDE

В уроке 1 вы уже устанавливали библиотеку RosDuino. Откройте Arduino IDE 2 и проверьте меню Файл → Примеры (File → Examples): в списке должен быть раздел RosDuino.

Если вы перешли на новый компьютер с Ubuntu и библиотеки ещё нет, установите её через Инструменты → Менеджер библиотек по запросу RosDuino (подробная инструкция приведена на странице «Установка библиотеки RosDuino»).

Шаг 2. Соберите rosduino_agent в рабочем пространстве ROS 2

Официальная инструкция по установке, параметрам запуска (--port, --baud, --namespace), диагностике и работе с несколькими платами приведена в репозитории пакета:

Откройте приложение «Терминал» в Ubuntu. Мы создадим рабочее пространство ~/ros2_ws, скачаем в него репозиторий rosduino_ros и соберём пакеты командой colcon build.

Создайте папку рабочего пространства и перейдите в каталог исходников src:

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src

Скачайте репозиторий rosduino_ros:

git clone https://github.com/rosduino/rosduino_ros.git

Перейдите в корень рабочего пространства, активируйте окружение ROS 2 и соберите пакеты:

cd ~/ros2_ws
source /opt/ros/$ROS_DISTRO/setup.bash
colcon build

Переменная окружения $ROS_DISTRO содержит имя установленного дистрибутива ROS 2, например lyrical, jazzy или rolling. Рекомендуемый вариант для курса — ROS 2 Lyrical Luth. Переменную задаёт сценарий setup.bash при подключении окружения ROS 2. Если в текущем терминале она ещё не задана, выполните source /opt/ros/lyrical/setup.bash. После этого значение можно проверить командой echo $ROS_DISTRO.

Шаг 3. Проверьте запуск агента

Подключите собранное рабочее пространство в текущем терминале и вызовите справку агента:

source ~/ros2_ws/install/setup.bash
ros2 run rosduino_agent rosduino_agent --help

Проверка

Команда ros2 run rosduino_agent rosduino_agent --help выводит список параметров запуска (--port, --baud и другие) без ошибок.

Чтобы не вводить source вручную в каждом новом окне терминала, можно один раз добавить автоподключение в конец файла ~/.bashrc:

echo "source /opt/ros/$ROS_DISTRO/setup.bash" >> ~/.bashrc
echo "source ~/ros2_ws/install/setup.bash" >> ~/.bashrc

Справочный материал: профили памяти плат в RosDuino

Этот раздел можно пропустить при первом прохождении. При компиляции скетча библиотека RosDuino автоматически определяет модель платы и выбирает подходящий профиль памяти:

ПрофильПлата ArduinoМаксимум топиков и сервисовМаксимальный размер пакета
LARGEArduino Due (плата TurtleBro v2)до 642040 байт
MEDIUMArduino Mega 2560 (плата TurtleBro v1)до 24504 байта
SMALLArduino Uno / Leonardo / Microдо 8152 байта
LITEArduino Nano (ATmega328P)до 388 байт

На плате TurtleBro с микроконтроллером Arduino Due автоматически включается профиль LARGE, поэтому запаса памяти с избытком хватает для всех задач курса.

Назад: Урок 4. Первый узел RosDuino.
Дальше: Управление светодиодом из ROS.

Управление светодиодом из ROS

Агент rosduino_agent собран и готов к работе. Теперь мы загрузим в плату TurtleBro первый скетч с библиотекой RosDuino, превратим плату в узел ROS 2 с именем /led_board и будем включать и выключать светодиод D48 командами из терминала.

Как устроен скетч с RosDuino

Посмотрите на полный код первого узла — он занимает меньше двадцати строк:

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>

const int LED_PIN = 48;

// Функция вызывается автоматически при получении сообщения из топика "led".
void onLed(std_msgs::Bool msg) {
  digitalWrite(LED_PIN, msg.data ? HIGH : LOW);
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  ros.begin("led_board");
  ros.subscribe("led", onLed);
}

void loop() {
  ros.update();
}

Разберём новые элементы по шагам:

  1. Заголовочные файлы:
    • #include <RosDuino.h> — подключает основную библиотеку и создаёт объект ros;
    • #include <std_msgs/msg/Bool.h> — подключает стандартный тип сообщения ROS 2 с одним логическим полем data (true или false).
  2. Функция-обработчик (onLed): Когда из ROS 2 в топик приходит новое сообщение, библиотека сама вызывает функцию onLed(std_msgs::Bool msg) и передаёт в неё полученное сообщение msg. Если msg.data равно true, на пин D48 подаётся HIGH, иначе — LOW.
  3. Регистрация узла и подписки в setup():
    • ros.begin("led_board"); — запускает обмен с агентом и задаёт имя узла ROS 2 (led_board);
    • ros.subscribe("led", onLed); — подписывает плату на топик led и связывает его с функцией onLed. Тип топика (std_msgs/msg/Bool) библиотека определяет автоматически по аргументу функции onLed.
  4. Обслуживание связи в loop(): Вызов ros.update() проверяет новые пакеты от агента, вызывает обработчики подписок и поддерживает связь с компьютером.

Пошаговая практика

1. Загрузите скетч в плату

  1. Убедитесь, что rosduino_agent ещё не запущен, а вкладка утилиты мониторинга порта в Arduino IDE закрыта.
  2. Скопируйте приведённый выше скетч в Arduino IDE 2.
  3. Проверьте, что выбрана плата Arduino Due (Programming Port) и нужный порт (например, /dev/ttyACM0 или /dev/ttyUSB0).
  4. Нажмите Загрузить (Upload) и дождитесь завершения записи.

2. Запустите агент в Терминале 1

Откройте первое окно терминала (Терминал 1), подключите окружение рабочего пространства и запустите rosduino_agent, указав порт вашей платы (тот же самый путь /dev/ttyACM0 или /dev/ttyUSB0, который был выбран в Arduino IDE):

Терминал 1:

source ~/ros2_ws/install/setup.bash
ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0

Если ваша плата определилась как /dev/ttyUSB0, укажите --port /dev/ttyUSB0. Напоминание о том, как посмотреть список портов через ls -l /dev/serial/by-id/, есть в справочном материале на странице «Установка в Linux».

Ожидаемый результат в Терминале 1

В журнале агента появится сообщение об успешном рукопожатии с узлом led_board и создании подписки на топик /led. Оставьте Терминал 1 открытым — агент должен продолжать работать.

3. Проверьте узел и топики в Терминале 2

Откройте второе окно терминала (Терминал 2) и проверьте, что плата появилась в графе ROS 2.

Терминал 2:

ros2 node list

Ожидаемый вывод:

/led_board

Посмотрите список доступных топиков вместе с их типами (флаг -t):

Терминал 2:

ros2 topic list -t

Ожидаемый вывод:

/diagnostics [diagnostic_msgs/msg/DiagnosticArray]
/led [std_msgs/msg/Bool]
/parameter_events [rcl_interfaces/msg/ParameterEvent]
/rosout [rcl_interfaces/msg/Log]

4. Включите и выключите светодиод D48 из ROS 2

Опубликуйте одно сообщение (--once) со значением true в топик /led:

Терминал 2:

ros2 topic pub --once /led std_msgs/msg/Bool "{data: true}"

Светодиод D48 на плате сразу загорится. Теперь отправьте false:

Терминал 2:

ros2 topic pub --once /led std_msgs/msg/Bool "{data: false}"

Светодиод D48 погаснет.

Автоматическое восстановление связи

Если во время работы нажать кнопку Reset на плате или на секунду переткнуть USB-кабель, перезапускать rosduino_agent не нужно: агент сам заметит перезагрузку платы, заново проведёт рукопожатие и восстановит топик /led.

Если узел или светодиод не работают

НаблюдениеЧто проверить
Ошибка Permission denied при запуске агентаПроверьте, что пользователь добавлен в группу dialout (см. урок 1, страница установки в Linux) и что утилита мониторинга порта в Arduino IDE закрыта
Arduino IDE не может загрузить скетч в платуВ Терминале 1 остановите rosduino_agent клавишами Ctrl+C, загрузите скетч и затем снова запустите агент
Команда ros2 node list не показывает /led_boardПроверьте, что в --port указан правильный порт платы, а скетч с ros.begin("led_board") успешно загружен
Топик /led виден, но светодиод не загораетсяПроверьте, что в скетче указан пин 48, а в команде терминала написано "{data: true}" с пробелом после двоеточия

Вопросы для самопроверки

  1. Какие две части входят в систему RosDuino и какая из них работает на микроконтроллере, а какая — на компьютере с Ubuntu?
  2. Почему в скетче с RosDuino нельзя одновременно использовать Serial.println() и держать открытой утилиту мониторинга порта в Arduino IDE?
  3. Что нужно сделать в терминале с rosduino_agent перед тем, как нажать кнопку Загрузить в Arduino IDE?
  4. Как агент rosduino_agent узнаёт, какое имя узла и какой тип топика нужно создать в ROS 2?

Назад: Установка и запуск агента RosDuino.
Дальше: Домашнее задание.

Домашнее задание

На предыдущей странице мы отправляли из ROS 2 логические значения true и false для включения светодиода. В этом задании вы создадите узел управления сервоприводом, который принимает целочисленный угол из топика /servo_angle, проверяет допустимые границы 0°–180° и зажигает светодиод D48, если присланный угол вышел за пределы диапазона.

Перед подключением сервопривода к разъёму D2 отключите USB-кабель от платы и сверьте контакты −, +, S с цветами проводов.

Что должно получиться

  1. Плата регистрирует в ROS 2 узел с именем servo_driver_node.
  2. Узел подписывается на топик servo_angle с типом сообщения std_msgs/msg/Int32 (заголовочный файл #include <std_msgs/msg/Int32.h>, число хранится в поле msg.data).
  3. После включения платы сервопривод на разъёме D2 встаёт в среднее положение 90°, а светодиод D48 погашен.
  4. Когда в топик /servo_angle приходит новое сообщение:
    • если значение msg.data находится в допустимых пределах от 0 до 180 включительно — сервопривод поворачивается на угол msg.data, а светодиод D48 выключается (LOW);
    • если значение msg.data меньше 0 или больше 180 (например, -30 или 220) — программа ограничивает угол безопасным пределом (0° или 180°) с помощью constrain(msg.data, 0, 180), поворачивает сервопривод на этот ограниченный угол и включает светодиод ошибки D48 (HIGH).

Требования к программе

  • Подключены библиотеки <Servo.h>, <RosDuino.h> и <std_msgs/msg/Int32.h>.
  • В функции loop() вызывается ros.update() без использования delay().
  • Перед загрузкой скетча агент rosduino_agent останавливается клавишами Ctrl+C.

Как составить алгоритм

  1. Возьмите за основу скетч со страницы управления светодиодом и добавьте подключение <Servo.h> и <std_msgs/msg/Int32.h>.
  2. Объявите константы SERVO_PIN = 2, ERROR_LED_PIN = 48 и объект Servo servo;.
  3. Напишите функцию-обработчик void onServoAngle(std_msgs::Int32 msg):
    • проверьте условие if (msg.data < 0 || msg.data > 180) (оператор || означает «логическое ИЛИ»);
    • если условие истинно — включите светодиод D48 (HIGH), иначе — выключите его (LOW);
    • вычислите безопасный угол int safeAngle = constrain(msg.data, 0, 180); и передайте его в servo.write(safeAngle);.
  4. В setup() настройте пин светодиода, привяжите сервопривод servo.attach(SERVO_PIN), поставьте начальный угол 90°, вызовите ros.begin("servo_driver_node") и зарегистрируйте подписку ros.subscribe("servo_angle", onServoAngle).
  5. В loop() оставьте вызов ros.update().

Как проверить результат из терминала ROS 2

  1. Загрузите скетч в плату и запустите rosduino_agent в Терминале 1.
  2. В Терминале 2 проверьте, что появились узел /servo_driver_node и топик /servo_angle с типом std_msgs/msg/Int32.
  3. Отправьте допустимый угол 45: Терминал 2:
    ros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: 45}"
    
    Сервопривод повернётся на 45°, светодиод D48 останется погашенным.
  4. Отправьте угол за пределами диапазона, например 220: Терминал 2:
    ros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: 220}"
    
    Сервопривод остановится на безопасной границе 180°, а светодиод D48 загорится, сигнализируя о некорректной команде.
  5. Снова отправьте допустимый угол 90 — сервопривод вернётся в середину, а светодиод ошибки D48 погаснет.

Посмотреть решение и разбор

Назад: Управление светодиодом из ROS.
Дальше: Урок 5. Топики в RosDuino.

Урок 5. Топики в RosDuino

В уроке 4 плата принимала команды из топика ROS 2 и включала светодиод или поворачивала сервопривод. Теперь мы настроим передачу данных в обратную сторону и в обе стороны сразу: вы научитесь периодически публиковать в ROS 2 полученные значения с разъёма GPIO A8 и состояние кнопок с помощью встроенного таймера rosduino::Timer, проверять частоту топиков в терминале и объединять издателей и подписчиков в одном скетче.

В этом уроке вы научитесь

  • публиковать данные с платы в топики ROS 2 функцией ros.publish() и заранее регистрировать топики событий кнопки через ros.advertise();
  • задавать частоту отправки сообщений без delay() и ручного подсчёта millis() с помощью таймера rosduino::Timer;
  • проверять поток сообщений и измерять частоту публикации командами ros2 topic echo и ros2 topic hz;
  • совмещать в одном узле отправку показаний датчиков и приём управляющих команд из ROS 2;
  • выбирать подходящие стандартные типы сообщений ROS 2 (std_msgs, sensor_msgs, geometry_msgs).

Пины, которые используются в уроке

Компонент на платеПин или контактНазначение в уроке
Разъём GPIO A83.3V, GND, GPIO (A8)Чтение аналогового сигнала и публикация в топик (работает как с потенциометром, так и без него)
Первая кнопкаD28Публикация состояния кнопки в топик
Светодиоды платыD48, D49, D50, D51Индикация команд, приходящих из ROS 2

План урока

  1. Публикация данных и таймер rosduino::Timer — отправка значений с разъёма GPIO A8 и кнопки D28 в ROS 2, проверка через ros2 topic echo и ros2 topic hz.
  2. Одновременная публикация и подписка — двусторонний обмен в одном узле и обзор типов сообщений ROS 2 в библиотеке RosDuino.
  3. Домашнее задание — узел мониторинга, который публикует аналоговый сигнал и нажатия кнопки, а по команде из топика зажигает шкалу из четырёх светодиодов D48–D51.

Назад: Домашнее задание.
Дальше: Публикация данных и таймер rosduino::Timer.

Публикация данных и таймер rosduino::Timer

Чтобы компьютер робота знал, что происходит вокруг платы, микроконтроллер должен регулярно отправлять полученные значения датчиков в топики ROS 2. В этой части урока мы опубликуем аналоговый сигнал с разъёма GPIO A8 с частотой 10 Гц и измерим эту частоту инструментами ROS 2.

Как работает таймер rosduino::Timer

В уроке 3 для запуска периодического действия без delay() мы создавали переменную unsigned long lastTime и вычисляли разницу millis() - lastTime >= PERIOD.

В библиотеке RosDuino эта проверка уже упакована в удобный класс rosduino::Timer:

rosduino::Timer sensorTimer(100); // период 100 мс (10 раз в секунду)

Внутри loop() достаточно вызвать метод sensorTimer.check(). Он возвращает true, когда прошло заданное количество миллисекунд. Во все остальные проходы цикла он мгновенно возвращает false, не задерживая выполнение ros.update().

Если в скетче нужны два или три разных интервала (например, 50 мс для кнопки и 100 мс для аналогового сигнала), достаточно создать несколько объектов rosduino::Timer с разными периодами.

Как устроена отправка сообщений ros.publish()

Для публикации данных в топик используется команда ros.publish("имя_топика", сообщение):

#include <RosDuino.h>
#include <std_msgs/msg/Int32.h>

std_msgs::Int32 signalMsg;
rosduino::Timer publishTimer(100);

void setup() {
  ros.begin("analog_publisher");
}

void loop() {
  ros.update();

  if (publishTimer.check()) {
    signalMsg.data = analogRead(A8);
    ros.publish("analog_signal", signalMsg);
  }
}

Обратите внимание на три особенности:

  1. Автоматическое создание топика при первом вызове: когда ros.publish("analog_signal", signalMsg) выполняется впервые, библиотека запрашивает у агента регистрацию нового топика. Пока топик регистрируется, само первое сообщение не отправляется. Для датчика, который передаёт измерения каждые 100 мс, потеря самого первого отсчёта при старте незаметна — уже через десятую долю секунды в топик пойдут следующие значения.
  2. Тип топика определяется автоматически: поскольку переменная signalMsg имеет тип std_msgs::Int32, в ROS 2 создаётся топик с типом std_msgs/msg/Int32.
  3. Безопасное поведение без агента: пока rosduino_agent на компьютере ещё не запущен, функция ros.publish() просто возвращает код rosduino::Result::NotConnected и не зависает. При желании связь можно проверить заранее условием if (ros.connected()).

Шаг 1. Публикация аналогового сигнала с частотой 10 Гц

Загрузим приведённый выше скетч в плату и проверим поток данных на компьютере. Напомним: если к разъёму GPIO A8 подключён потенциометр из урока 3, вы сможете плавно менять значения ручкой; если ничего не подключено — analogRead(A8) будет передавать меняющиеся значения электрических наводок.

  1. Если в Терминале 1 запущен rosduino_agent, остановите его клавишами Ctrl+C.
  2. Загрузите скетч в плату TurtleBro через Arduino IDE 2.
  3. Запустите агент в Терминале 1:

Терминал 1:

ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
  1. Во втором окне терминала (Терминал 2) посмотрите список топиков:

Терминал 2:

ros2 topic list -t

Ожидаемый вывод:

/analog_signal [std_msgs/msg/Int32]
/diagnostics [diagnostic_msgs/msg/DiagnosticArray]
/parameter_events [rcl_interfaces/msg/ParameterEvent]
/rosout [rcl_interfaces/msg/Log]
  1. Выведите приходящие сообщения на экран:

Терминал 2:

ros2 topic echo /analog_signal

Ожидаемый результат

В Терминале 2 бежит поток сообщений с полем data: ... в диапазоне 0–1023. Поверните ручку потенциометра или поднесите палец к разъёму GPIO A8 — полученные значения в топике сразу изменятся. Нажмите Ctrl+C, чтобы остановить вывод echo.

  1. Теперь проверим, действительно ли таймер rosduino::Timer(100) выдерживает частоту 10 раз в секунду (10 Гц). Выполните команду измерения частоты:

Терминал 2:

ros2 topic hz /analog_signal

Через пару секунд в терминале появятся расчёты:

average rate: 10.001
	min: 0.099s max: 0.101s std dev: 0.00045s window: 10

Остановите измерение клавишами Ctrl+C.

Шаг 2. Простой способ работы с кнопкой: отправка потока при нажатии

С кнопкой D28 можно начать работать так же просто, как с обычным датчиком — сразу вызывать ros.publish(). Будем проверять пин кнопки каждые 50 мс и, пока кнопка удерживается нажатой (HIGH), отправлять true в топик /button:

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>

const int BUTTON_PIN = 28;

std_msgs::Bool pressed;
rosduino::Timer buttonTimer(50);  // опрос каждые 50 мс (20 раз в секунду)

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  ros.begin("button_node");
}

void loop() {
  ros.update();

  if (buttonTimer.check()) {
    if (digitalRead(BUTTON_PIN) == HIGH) {
      pressed.data = true;
      ros.publish("button", pressed);
    }
  }
}

(Если убрать условие if (digitalRead(BUTTON_PIN) == HIGH) и передавать текущее состояние pressed.data = (digitalRead(BUTTON_PIN) == HIGH) при каждом срабатывании таймера, как в стандартном примере библиотеки Simple/ButtonSimple, плата будет непрерывно слать false и true 20 раз в секунду).

Посмотрим, как ведёт себя такой скетч на практике:

  1. Остановите агент в Терминале 1 (Ctrl+C), загрузите скетч в плату и запустите агент снова.
  2. Не нажимая кнопку D28, проверьте список топиков в Терминале 2:

Терминал 2:

ros2 topic list -t

Топика /button в списке ещё нет: программа ни разу не зашла внутрь блока if (digitalRead(BUTTON_PIN) == HIGH) и не вызвала ros.publish().

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

Терминал 2:

ros2 topic echo /button

Первый вызов ros.publish() в момент нажатия создал топик /button (потеряв при этом самое первое сообщение), а все последующие срабатывания таймера каждые 50 мс начали непрерывно заполнять топик сообщениями data: true, пока палец удерживает кнопку.

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

  • поток повторов вместо одного события: даже короткое нажатие длится 150–200 мс и отправляет в топик сразу несколько одинаковых сообщений data: true подряд;
  • топик не виден до нажатия и теряет первый вызов: если мы уберём повторы и будем вызывать ros.publish() ровно один раз при смене состояния кнопки, то до первого нажатия топика не будет в ros2 topic list, а само первое нажатие потратится на регистрацию топика и пропадёт.

Шаг 3. Одиночные события кнопки и регистрация топика ros.advertise()

Чтобы топик кнопки появился в ROS 2 сразу при подключении платы, а первое нажатие не терялось, перед началом работы с кнопкой — в функции setup() сразу после ros.begin() — вызывается ros.advertise("имя_топика", переменная_сообщения):

ros.begin("sensor_board");
ros.advertise("button_pressed", buttonMsg);

Разберём, что делает эта строка:

  • создаёт топик без отправки сообщения: переменная buttonMsg в этот момент никуда не пересылается — библиотека использует её только для того, чтобы узнать тип топика (std_msgs/msg/Bool);
  • делает топик видимым сразу: как только запускается rosduino_agent, топик /button_pressed сразу появляется в ros2 topic list -t, поэтому на него можно заранее подписаться через ros2 topic echo или из управляющего узла;
  • сохраняет первое нажатие: когда кнопка меняет состояние впервые, топик уже зарегистрирован, и первый же вызов ros.publish() доставляет сообщение без потерь.

Объединим периодическую публикацию аналогового сигнала A8 (для которого advertise не требуется) и отправку одиночных событий кнопки D28 (аналог стандартного примера Simple/ButtonOnce в меню Файл → Примеры → RosDuino):

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>
#include <std_msgs/msg/Int32.h>

const int SENSOR_PIN = A8;
const int BUTTON_PIN = 28;

std_msgs::Int32 signalMsg;
std_msgs::Bool buttonMsg;

rosduino::Timer analogTimer(100);  // 10 Гц для аналогового сигнала
rosduino::Timer buttonTimer(30);   // период опроса кнопки (антидребезг)

int lastButtonState = LOW;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  lastButtonState = digitalRead(BUTTON_PIN);

  ros.begin("sensor_board");
  // Заранее создаём топик кнопки, чтобы не потерять первое нажатие.
  ros.advertise("button_pressed", buttonMsg);
}

void loop() {
  ros.update();

  // Задача 1: каждые 100 мс публикуем значение с разъёма GPIO A8.
  if (analogTimer.check()) {
    signalMsg.data = analogRead(SENSOR_PIN);
    ros.publish("analog_signal", signalMsg);
  }

  // Задача 2: каждые 30 мс проверяем кнопку D28 и публикуем только изменения.
  if (buttonTimer.check()) {
    int reading = digitalRead(BUTTON_PIN);

    if (reading != lastButtonState) {
      lastButtonState = reading;
      buttonMsg.data = (lastButtonState == HIGH);
      ros.publish("button_pressed", buttonMsg);
    }
  }
}

Проверка в терминале

  1. Остановите агент в Терминале 1 (Ctrl+C), загрузите обновлённый скетч в плату и запустите агент снова.
  2. Не трогая кнопку D28, проверьте список топиков в Терминале 2:

Терминал 2:

ros2 topic list -t

Топик /button_pressed [std_msgs/msg/Bool] уже присутствует в списке вместе с /analog_signal [std_msgs/msg/Int32].

  1. В Терминале 2 заранее подпишитесь на события кнопки:

Терминал 2:

ros2 topic echo /button_pressed
  1. Нажмите и отпустите кнопку D28 на плате.

Ожидаемый результат

Пока вы не трогаете кнопку, в терминале тишина — лишние пакеты не передаются. При самом первом нажатии D28 без потерь приходит ровно одно сообщение data: true, а при отпускании — одно сообщение data: false. В топике /analog_signal параллельно продолжают идти измерения с частотой 10 Гц.

Назад: Урок 5. Топики в RosDuino.
Дальше: Одновременная публикация и подписка.

Одновременная публикация и подписка

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

Двусторонний узел: датчик + команда светодиоду

Объединим в одном скетче публикацию и подписку. Пусть плата:

  1. Каждые 100 мс считывает значение на разъёме GPIO A8, пересчитывает его в диапазон 0–100 (в процентах) и публикует в топик /sensor_percent.
  2. Слушает топик /alarm_led (std_msgs/msg/Bool) и по команде из ROS 2 включает или выключает светодиод D48.
#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>
#include <std_msgs/msg/Int32.h>

const int SENSOR_PIN = A8;
const int ALARM_LED_PIN = 48;

std_msgs::Int32 percentMsg;
rosduino::Timer sensorTimer(100);

// Обработчик входящих команд из топика "/alarm_led".
void onAlarmLed(std_msgs::Bool msg) {
  digitalWrite(ALARM_LED_PIN, msg.data ? HIGH : LOW);
}

void setup() {
  pinMode(ALARM_LED_PIN, OUTPUT);
  digitalWrite(ALARM_LED_PIN, LOW);

  ros.begin("io_board");
  ros.subscribe("alarm_led", onAlarmLed);
}

void loop() {
  ros.update();

  if (sensorTimer.check()) {
    int rawValue = analogRead(SENSOR_PIN);
    percentMsg.data = map(rawValue, 0, 1023, 0, 100);
    ros.publish("sensor_percent", percentMsg);
  }
}

Проверка двустороннего обмена

  1. Остановите rosduino_agent в Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент.
  2. В Терминале 2 проверьте, что данные от платы поступают:

Терминал 2:

ros2 topic echo /sensor_percent --once
  1. Не останавливая поток публикации, отправьте команду на включение светодиода D48:

Терминал 2:

ros2 topic pub --once /alarm_led std_msgs/msg/Bool "{data: true}"

Светодиод D48 сразу загорится, а плата продолжит публиковать /sensor_percent с частотой 10 Гц.

Какие типы сообщений ROS 2 есть в RosDuino

До сих пор мы использовали простые типы Bool и Int32 из пакета std_msgs. Но в ROS 2 для датчиков и движения робота приняты специальные стандартные сообщения, чтобы с вашей платой могли без переделок работать штатные программы визуализации (rviz2) и навигации.

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

Пакет ROS 2Основные типы сообщений в RosDuinoГде применяются
std_msgsBool, Int8…Int64, UInt8…UInt64, Float32, Float64, String, EmptyОдиночные флаги, счётчики, простые численные значения и текстовые статусы
sensor_msgsRange, Imu, Temperature, BatteryState, JoyПоказания дальномеров, инерциальных датчиков, температуры и состояния аккумулятора
geometry_msgsTwist, Pose, Point, Vector3, QuaternionКоманды линейной и угловой скорости робота (cmd_vel), координаты и ориентация
nav_msgsOdometryОдометрия колёсного робота

Все эти типы подключаются точно так же, как в обычных C++-узлах ROS 2. Например, для публикации показаний ультразвукового или инфракрасного дальномера в стандартном формате sensor_msgs/msg/Range:

#include <RosDuino.h>
#include <sensor_msgs/msg/Range.h>

sensor_msgs::Range rangeMsg;

void setup() {
  rangeMsg.radiation_type = sensor_msgs::msg::Range::ULTRASOUND;
  rangeMsg.min_range = 0.05f; // минимальная дистанция, м
  rangeMsg.max_range = 2.00f; // максимальная дистанция, м

  ros.begin("range_node");
}

Вопросы для самопроверки

  1. Какую задачу решает класс rosduino::Timer и почему с ним не нужно вручную хранить переменную lastTime для millis()?
  2. Что происходит при самом первом вызове ros.publish() без предварительной регистрации и зачем для кнопки в setup() вызывают ros.advertise()?
  3. Какой командой в терминале можно измерить фактическую частоту публикации сообщений в топике /sensor_percent?
  4. Почему для события нажатия кнопки лучше вызывать ros.publish() только при смене состояния пина, а не отправлять поток сообщений при удержании или в каждом цикле loop()?

Справочный материал: расширенный (полный) API и профили QoS

Этот раздел можно пропустить при первом прохождении. Во всех уроках курса мы используем простой API через глобальный объект ros (ros.begin(), ros.advertise(), ros.publish(), ros.subscribe(), ros.update()).

Помимо него, в библиотеке есть расширенный (полный) API (examples/Full/), в котором узел, издатели и подписчики объявляются как отдельные объекты rosduino::Node<>, rosduino::Publisher<T> и rosduino::Subscriber<T>. Он полезен в двух случаях:

  1. Когда нужно явно задать профиль качества обслуживания QoS — например, rosduino::QoS::sensorData() (BestEffort) для высокочастотных потоков датчиков вместо стандартного надёжного профиля rosduino::QoS::defaults() (Reliable).
  2. Когда на младших платах (Arduino Nano / Uno) нужно хранить имена топиков во Flash-памяти с помощью макроса F("имя_топика"), чтобы сэкономить оперативную память.

Пример того же двустороннего узла на полном API:

#include <RosDuino.h>
#include <std_msgs/msg/Int32.h>

rosduino::Node<> node;
rosduino::Publisher<std_msgs::msg::Int32> pub;
rosduino::Subscriber<std_msgs::msg::Int32> sub;

void onIn(const std_msgs::msg::Int32& msg) {
  std_msgs::msg::Int32 out;
  out.data = msg.data + 1;
  pub.publish(out);
}

void setup() {
  node.begin(Serial, 115200, F("arduino_pubsub"));
  pub = rosduino::Publisher<std_msgs::msg::Int32>(F("echo_out"));
  sub = rosduino::Subscriber<std_msgs::msg::Int32>(F("echo_in"), onIn);
  node.advertise(pub, rosduino::QoS::sensorData());
  node.subscribe(sub);
}

void loop() {
  node.spinOnce();
}

Назад: Публикация данных и таймер rosduino::Timer.
Дальше: Домашнее задание.

Домашнее задание

В этом задании вы объедините публикацию данных по таймеру rosduino::Timer, отправку событий кнопки и управление массивом светодиодов D48–D51 из урока 2 в одном узле ROS 2. Внешние детали подключать не обязательно: все кнопки и светодиоды уже распаяны на плате TurtleBro, а analogRead(A8) работает как с потенциометром, так и без него.

Что должно получиться

Напишите скетч, который регистрирует узел board_monitor_node и выполняет три задачи одновременно:

  1. Публикация аналогового сигнала (10 Гц — каждые 100 мс):
    • по таймеру rosduino::Timer(100) считывает полученное значение analogRead(A8) (0–1023);
    • публикует его в топик /sensor_value с типом std_msgs/msg/Int32.
  2. Публикация нажатий кнопки D28 (с защитой от дребезга 30 мс):
    • заранее регистрирует в setup() топик /button_state (std_msgs/msg/Bool) с помощью ros.advertise(), чтобы топик был виден сразу и не терял первое нажатие;
    • опрашивает кнопку D28 по второму таймеру rosduino::Timer(30);
    • при каждом изменении состояния кнопки (нажата — true, отпущена — false) публикует сообщение std_msgs/msg/Bool в топик /button_state.
  3. Подписка на уровень светодиодной шкалы (D48–D51):
    • подписывается на топик /led_level с типом std_msgs/msg/Int32;
    • при получении сообщения ограничивает значение msg.data диапазоном от 0 до 4 через constrain(msg.data, 0, 4) и зажигает соответствующее количество светодиодов из массива {48, 49, 50, 51} (0 — все погашены, 1 — горит только D48, …, 4 — горят все четыре светодиода).

Требования к программе

  • В функции loop() вызывается ros.update() и не используется delay().
  • Топик кнопки предварительно регистрируется в setup() после ros.begin() вызовом ros.advertise("button_state", buttonMsg);.
  • Для периодического опроса применяются два объекта rosduino::Timer (100 мс и 30 мс).
  • Для управления четырьмя светодиодами используется массив пинов const int LED_PINS[4] = {48, 49, 50, 51}; и цикл for (как в уроке 2).

Как составить алгоритм

  1. Подключите <RosDuino.h>, <std_msgs/msg/Int32.h> и <std_msgs/msg/Bool.h>.
  2. Объявите константы пинов (SENSOR_PIN = A8, BUTTON_PIN = 28, массив LED_PINS[4] = {48, 49, 50, 51}), сообщения sensorMsg и buttonMsg, а также два таймера: rosduino::Timer sensorTimer(100); и rosduino::Timer buttonTimer(30);.
  3. Перенесите из урока 2 функцию void showLitCount(int count), которая в цикле for зажигает первые count светодиодов массива и гасит остальные.
  4. Напишите функцию-обработчик подписки void onLedLevel(std_msgs::Int32 msg):
    • ограничьте входное значение: int count = constrain(msg.data, 0, 4);;
    • вызовите showLitCount(count);.
  5. В setup() настройте пины кнопки и светодиодов, погасите все светодиоды, считайте начальное состояние кнопки, вызовите ros.begin("board_monitor_node"), зарегистрируйте топик кнопки ros.advertise("button_state", buttonMsg) и подписку ros.subscribe("led_level", onLedLevel).
  6. В loop() вызовите ros.update(), затем проверьте sensorTimer.check() и buttonTimer.check().

Как проверить результат из терминала ROS 2

  1. Остановите rosduino_agent в Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент.
  2. Не нажимая кнопку D28, убедитесь в Терминале 2, что топик /button_state уже виден в списке ros2 topic list -t, и проверьте частоту публикации /sensor_value:
    ros2 topic hz /sensor_value
    
    Частота должна составлять около 10 Гц. Остановите проверку клавишами Ctrl+C.
  3. В Терминале 2 запустите просмотр состояния кнопки и понажимайте D28 на плате:
    ros2 topic echo /button_state
    
    Уже с самого первого нажатия должно приходить одно сообщение data: true, а при отпускании — одно сообщение data: false.
  4. Проверьте управление светодиодной шкалой D48–D51 командами из Терминала 2:
    ros2 topic pub --once /led_level std_msgs/msg/Int32 "{data: 2}"
    ros2 topic pub --once /led_level std_msgs/msg/Int32 "{data: 4}"
    ros2 topic pub --once /led_level std_msgs/msg/Int32 "{data: 0}"
    
    При отправке 2 загорятся D48 и D49, при отправке 4 — все четыре светодиода, при отправке 0 — все погаснут.

Посмотреть решение и разбор

Назад: Одновременная публикация и подписка.
Дальше: Урок 6. Сервисы в RosDuino.

Урок 6. Сервисы в RosDuino

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

В этом уроке вы научитесь

  • понимать сервис ROS 2 как удалённый вызов функции с входными аргументами (request) и возвращаемым результатом (response);
  • создавать сервер сервиса на плате с помощью ros.service() и вызывать его из терминала командой ros2 service call;
  • передавать в один сервис параметры и получать обратно вычисленный результат без создания множества отдельных топиков;
  • вызывать внешний сервис ROS 2 с самой платы функцией ros.call() и обрабатывать полученный ответ;
  • совмещать работу топиков и сервисов в одном скетче.

Пины, которые используются в уроке

Компонент на платеПинНазначение в уроке
Светодиод платыD48Управление через сервис /set_led, индикация ответа клиента и статуса блокировки
Первая кнопкаD28Отправка запроса к сервису на компьютере по нажатию
Разъём сервоприводаD2Привод с блокировкой через сервис /set_drive_enable (понадобится в домашнем задании)

План урока

  1. Сервер сервиса на плате — сервис как удалённый вызов функции, создание /set_led через ros.service() и вызов ros2 service call.
  2. Клиент сервиса на плате — неблокирующий вызов внешнего сервиса /add_two_ints с платы через ros.call() по нажатию кнопки D28.
  3. Создание сообщений для сервисов (для дополнительного изучения) — обзор готовых типов std_srvs и example_interfaces, структура файлов .srv и генерация своих заголовков через rosduino-gen.
  4. Домашнее задание — узел управления сервоприводом с включением и отключением разрешения на движение через сервис /set_drive_enable.

Назад: Домашнее задание.
Дальше: Сервер сервиса на плате.

Сервер сервиса на плате

В обычном скетче на C++ вы вызываете функцию внутри одной программы: передаёте ей аргументы в скобках, она выполняет действия и возвращает ответ через return. Сервис (Service) в ROS 2 устроен точно так же, только это удалённый вызов функции: функция находится на одном устройстве (например, на плате TurtleBro), а вызывает её программа на другом устройстве (на компьютере).

Как устроен удалённый вызов функции

Любой вызов сервиса состоит из двух шагов:

  1. Передача входных параметров (Request — запрос): вызывающая сторона (клиент сервиса) отправляет данные, с которыми нужно выполнить функцию.
  2. Получение результата работы (Response — ответ): исполняющая сторона (сервер сервиса) принимает эти параметры, выполняет код функции и отправляет обратно готовый результат.
sequenceDiagram
    participant C as Клиент в ROS 2 (вызывает функцию)
    participant S as Сервер на плате TurtleBro (выполняет функцию)
    C->>S: 1. Запрос (Request): передаём входные параметры
    Note over S: Выполняет функцию с полученными параметрами
    S->>C: 2. Ответ (Response): возвращаем результат работы

В библиотеке RosDuino каждый тип сервиса объединяет оба шага в одной структуре srv:

  • srv.request — входные параметры функции;
  • srv.response — результат работы, который вернётся вызывающей стороне.

Пример использования: допустим, нужно узнать состояние одной из кнопок или переключателей на плате. Вместо того чтобы создавать отдельный топик для каждой кнопки, достаточно сделать один сервис: в параметрах запроса (request) компьютер передаёт номер нужной кнопки, а в ответе (response) получает её текущий статус. Один удалённый вызов функции заменяет десятки однотипных топиков.

Особенность работы сервера сервиса в разных версиях ROS 2

Создание сервера сервиса на самой плате (ros.service()) поддерживается в основном дистрибутиве проекта, но в ROS 2 Jazzy недоступно из-за ограничений универсального сервера сервисов внутри rclcpp. При этом вызов внешних сервисов с платы (ros.call(), который мы разберём на следующей странице) работает во всех версиях ROS 2, включая Jazzy.

Как устроен сервер сервиса ros.service()

Разберём стандартный тип сервиса std_srvs/srv/SetBool (#include <std_srvs/srv/SetBool.h>):

  • в запросе srv.request.data приходит логическое значение true или false;
  • в ответе плата заполняет два поля: логический флаг srv.response.success и строку srv.response.message.
#include <RosDuino.h>
#include <std_srvs/srv/SetBool.h>

const int LED_PIN = 48;

// Обработчик сервиса: принимает запрос и заполняет ответ.
void onSetLed(std_srvs::SetBool& srv) {
  if (srv.request.data) {
    digitalWrite(LED_PIN, HIGH);
    srv.response.message = "LED D48 turned ON";
  } else {
    digitalWrite(LED_PIN, LOW);
    srv.response.message = "LED D48 turned OFF";
  }

  srv.response.success = true;
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  ros.begin("led_service_node");
  ros.service("set_led", onSetLed);
}

void loop() {
  ros.update();
}

Обратите внимание на две важные детали:

  1. Передача параметра по ссылке (&): в заголовке void onSetLed(std_srvs::SetBool& srv) стоит знак амперсанда &. Благодаря этому функция записывает результат прямо в поля srv.response переданного объекта, и сразу после завершения функции библиотека отправляет этот ответ обратно клиенту в ROS 2.
  2. Быстрое выполнение обработчика: пока выполняется onSetLed(), плата не обрабатывает другие пакеты. Поэтому внутри функции сервиса нельзя использовать delay() или долгие циклы ожидания.

Пошаговая проверка из терминала ROS 2

  1. Если rosduino_agent запущен в Терминале 1, остановите его клавишами Ctrl+C, загрузите скетч в плату и снова запустите агент:

Терминал 1:

ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
  1. В Терминале 2 проверьте список доступных сервисов вместе с их типами (флаг -t):

Терминал 2:

ros2 service list -t

В списке появится сервис /set_led [std_srvs/srv/SetBool].

  1. Вызовите сервис /set_led, чтобы включить светодиод D48:

Терминал 2:

ros2 service call /set_led std_srvs/srv/SetBool "{data: true}"

Ожидаемый ответ в терминале:

waiting for service to become available...
requester: making request: std_srvs.srv.SetBool_Request(data=True)

response:
std_srvs.srv.SetBool_Response(success=True, message='LED D48 turned ON')

Светодиод D48 на плате загорится, а терминал покажет полученный от платы ответ success=True и сообщение 'LED D48 turned ON'.

  1. Выключите светодиод вторым запросом:

Терминал 2:

ros2 service call /set_led std_srvs/srv/SetBool "{data: false}"

Светодиод погаснет, а в ответе вернётся строка 'LED D48 turned OFF'.

Назад: Урок 6. Сервисы в RosDuino.
Дальше: Клиент сервиса на плате.

Клиент сервиса на плате

На предыдущей странице компьютер отправлял запрос, а плата его выполняла. Но роли могут поменяться: плата сама может выступить клиентом сервиса и обратиться с запросом к узлу ROS 2 на компьютере — например, попросить компьютер выполнить расчёт, сохранить точку маршрута или подтвердить готовность системы. В этой части урока мы научим плату вызывать сервис /add_two_ints на компьютере по нажатию кнопки D28.

Как устроен вызов сервиса с платы (ros.call())

Проверим работу клиента на стандартном сервисе сложения двух целых чисел example_interfaces/srv/AddTwoInts (#include <example_interfaces/srv/AddTwoInts.h>):

  • в запросе передаются два слагаемых: adder.request.a и adder.request.b;
  • в ответе компьютер возвращает их сумму: srv.response.sum.
sequenceDiagram
    participant B as Плата TurtleBro (клиент)
    participant PC as Узел на компьютере (сервер)
    Note over B: Нажата кнопка D28
    B->>PC: ros.call("add_two_ints") — запрос a=1, b=10
    Note over B: Цикл loop() продолжает работать без паузы
    PC->>B: Ответ sum=11
    Note over B: Вызывается onSumAnswer() — переключает D48

Для отправки запроса используется функция ros.call("имя_сервиса", объект_запроса, функция_ответа):

#include <RosDuino.h>
#include <example_interfaces/srv/AddTwoInts.h>

const int BUTTON_PIN = 28;
const int LED_PIN = 48;

example_interfaces::AddTwoInts adder;
rosduino::Timer buttonTimer(30);

int lastButtonState = LOW;
int counter = 1;

// Вызывается автоматически, когда от компьютера пришёл ответ сервиса.
void onSumAnswer(example_interfaces::AddTwoInts& srv) {
  if (srv.response.sum == srv.request.a + srv.request.b) {
    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
  }
}

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  lastButtonState = digitalRead(BUTTON_PIN);
  ros.begin("add_client_node");
}

void loop() {
  ros.update();

  if (ros.connected() && buttonTimer.check()) {
    int reading = digitalRead(BUTTON_PIN);

    if (reading != lastButtonState) {
      lastButtonState = reading;

      if (lastButtonState == HIGH) {
        adder.request.a = counter;
        adder.request.b = 10;
        counter++;

        // Отправляем неблокирующий запрос сервису "/add_two_ints".
        ros.call("add_two_ints", adder, onSumAnswer);
      }
    }
  }
}

Почему ros.call() не останавливает loop()

Вызов ros.call() работает асинхронно (неблокирующе):

  1. Плата отправляет пакет запроса агенту и сразу продолжает выполнять loop().
  2. Пока компьютер считает и отправляет ответ обратно, ros.update() продолжает обслуживать все остальные топики и таймеры платы.
  3. Как только ответ приходит по USB, библиотека автоматически вызывает функцию onSumAnswer(), передавая в неё структуру srv с заполненным полем srv.response.sum.

Если вызвать ros.call() повторно до того, как пришёл ответ на предыдущий запрос к тому же сервису, функция вернёт rosduino::Result::Busy. Если сервер на компьютере не ответит в течение 1 с, ожидание автоматически сбросится, и сервис можно будет вызвать снова.

Пошаговая проверка с сервером на компьютере

  1. Остановите rosduino_agent в Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент:

Терминал 1:

ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
  1. Во втором окне терминала (Терминал 2) запустите стандартный демонстрационный сервер сложения из комплекта ROS 2:

Терминал 2:

ros2 run demo_nodes_cpp add_two_ints_server
  1. Нажмите кнопку D28 на плате несколько раз.

Ожидаемый результат

При каждом нажатии кнопки D28 в окне Терминала 2 появляется строка Incoming request: [a: 1, b: 10], затем [a: 2, b: 10] и так далее. Светодиод D48 на плате сразу меняет своё состояние, подтверждая, что ответ от компьютера получен и сумма совпала.

Остановите демонстрационный сервер в Терминале 2 клавишами Ctrl+C.

Назад: Сервер сервиса на плате.
Дальше: Создание сообщений для сервисов.

Создание сообщений для сервисов

Материал для дополнительного изучения

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

В отличие от топиков (std_msgs), где существуют десятки готовых типов на все случаи жизни, стандартных сервисов в базовых пакетах ROS 2 совсем немного. Это связано с тем, что у каждой удалённой функции свои собственные входные параметры (request) и свой формат возвращаемого ответа (response). Ниже разобрано, какие готовые типы сервисов есть в std_srvs и RosDuino, какие сервисы встречаются в других пакетах ROS 2 и как при необходимости создавать заголовки для собственных сервисов .srv с помощью генератора rosduino-gen.

1. Стандартные сервисы пакета std_srvs

В стандартном пакете std_srvs в ROS 2 предусмотрены ровно три универсальных сервиса. Все три уже встроены в библиотеку RosDuino:

Тип сервисаЗаголовочный файл в скетчеВходные параметры (request)Результат работы (response)Когда применять
std_srvs/srv/Empty<std_srvs/srv/Empty.h>нет полейнет полейПростая команда без аргументов и без текстового отчёта (например, /reset_counter)
std_srvs/srv/Trigger<std_srvs/srv/Trigger.h>нет полейbool success
string message
Запуск действия без входных параметров (например, /calibrate) или опрос статуса с возвратом флага успеха и текста
std_srvs/srv/SetBool<std_srvs/srv/SetBool.h>bool databool success
string message
Включение или выключение устройства/режима (true / false) с подтверждением результата

Пример использования std_srvs/srv/Trigger, когда функция не требует входных аргументов, но возвращает текстовый отчёт о состоянии кнопки D28:

#include <RosDuino.h>
#include <std_srvs/srv/Trigger.h>

void onCheckButton(std_srvs::Trigger& srv) {
  bool pressed = (digitalRead(28) == HIGH);
  srv.response.success = pressed;
  srv.response.message = pressed ? "Button D28 is pressed" : "Button D28 is released";
}

2. Числовой сервис из пакета example_interfaces

Помимо std_srvs, в базовую поставку RosDuino включён пакет example_interfaces, содержащий сервис example_interfaces/srv/AddTwoInts (#include <example_interfaces/srv/AddTwoInts.h>):

  • Вход (request): два 64-битных целых числа int64 a и int64 b;
  • Выход (response): одно 64-битное целое число int64 sum.

Хотя он называется AddTwoInts, поля a, b и sum — это обычные целые числа. Поэтому в учебных задачах, когда не хочется создавать отдельный пакет с собственным .srv, его удобно использовать для любой удалённой функции с целочисленными параметрами: например, передавать в request.a номер кнопки или канала (1 или 2), а в response.sum возвращать измеренное значение.

3. Какие ещё сервисы есть в стандартных пакетах ROS 2

В профильных пакетах ROS 2 сервисы созданы под конкретные подсистемы робота:

  • rcl_interfaces/srv/... (GetParameters, SetParameters, ListParameters) — чтение и изменение настроек узлов;
  • nav_msgs/srv/... (GetMap, GetPlan, SetMap) — запрос карты помещения и расчёт маршрута навигации из начальной точки в целевую;
  • sensor_msgs/srv/SetCameraInfo — сохранение калибровочных параметров камеры;
  • diagnostic_msgs/srv/SelfTest — запуск самодиагностики оборудования;
  • std_srvs / turtlesim/srv/... (Spawn, TeleportAbsolute, SetPen) — управление учебным симулятором.

Посмотреть полный список всех типов сервисов и сообщений, установленных на вашем компьютере с ROS 2, можно командой:

ros2 run rosduino_gen rosduino-gen --list

4. Как устроен файл описания своего сервиса (.srv)

Когда вашей плате нужна удалённая функция со своими именами параметров — например, запросить состояние кнопки по её номеру button_id или повернуть сервопривод servo_id на угол angle, — в пакете интерфейсов ROS 2 создаётся текстовый файл с расширением .srv.

Файл .srv состоит из двух частей, разделённых строкой из трёх дефисов ---:

  • сверху описываются входные параметры запроса (Request);
  • снизу описываются поля возвращаемого результата (Response).

Например, файл srv/ReadButton.srv для чтения кнопки по её номеру выглядит так:

int32 button_id
---
bool pressed
string message

5. Генерация заголовков для Arduino с помощью rosduino-gen

После того как пакет с вашими .srv-файлами (например, my_robot_msgs) собран в рабочем пространстве ROS 2 через colcon build, утилита rosduino-gen из репозитория rosduino_ros переводит их в готовые C++-заголовки для Arduino IDE.

Выполните в терминале одну команду, указав имя пакета и путь к папке библиотеки RosDuino:

ros2 run rosduino_gen rosduino-gen --package my_robot_msgs --out "$HOME/Arduino/libraries/RosDuino/src"

Генератор создаст заголовочный файл my_robot_msgs/srv/ReadButton.h, который сразу можно подключить в скетче платы:

#include <RosDuino.h>
#include <my_robot_msgs/srv/ReadButton.h>

void onReadButton(my_robot_msgs::ReadButton& srv) {
  if (srv.request.button_id == 1) {
    srv.response.pressed = (digitalRead(28) == HIGH);
    srv.response.message = "Button 1 (D28)";
  } else if (srv.request.button_id == 2) {
    srv.response.pressed = (digitalRead(15) == HIGH);
    srv.response.message = "Button 2 (D15)";
  } else {
    srv.response.pressed = false;
    srv.response.message = "Unknown button_id";
  }
}

Если же вы хотите добавить стандартный пакет из комплекта ROS 2 (например, nav_msgs или diagnostic_msgs), укажите его имя во флаге --package или допишите нужный тип в файл rosduino_gen/arduino_types.txt и запустите ros2 run rosduino_gen rosduino-gen --all --out "$HOME/Arduino/libraries/RosDuino/src".

Вопросы для самопроверки

  1. Зачем в ROS 2 нужны сервисы, если в системе уже есть топики, и как один сервис с входным параметром помогает избежать создания множества топиков?
  2. Почему в обработчике сервера сервиса void onSetLed(std_srvs::SetBool& srv) параметр принимается по ссылке (&) и почему внутри этой функции нельзя делать долгие паузы?
  3. Чем отличается роль платы при вызове ros.service() от её роли при вызове ros.call()?
  4. Почему вызов ros.call("add_two_ints", adder, onSumAnswer) не останавливает работу loop() во время ожидания ответа от компьютера?

Назад: Клиент сервиса на плате.
Дальше: Домашнее задание.

Домашнее задание

В реальных роботах приводы часто снабжают программной блокировкой безопасности (предохранителем): пока привод заблокирован, он игнорирует случайные команды движения. В этом задании вы создадите узел безопасного управления сервоприводом, в котором разрешение на движение включается и выключается через сервис ROS 2 /set_drive_enable, целевой угол приходит из топика /target_angle, а текущий угол публикуется в /current_angle.

Перед подключением сервопривода к разъёму D2 отключите USB-кабель от платы и сверьте контакты −, +, S с цветами проводов.

Что должно получиться

Напишите скетч узла safe_servo_node, в котором хранится флаг разрешения работы bool driveEnabled = false;:

  1. Начальное состояние после включения:
    • привод заблокирован (driveEnabled = false), светодиод D48 погашен;
    • вал сервопривода на разъёме D2 установлен в начальное положение 90°.
  2. Сервис блокировки /set_drive_enable (std_srvs/srv/SetBool):
    • при вызове с data: true включает разрешение (driveEnabled = true), зажигает светодиод D48 и возвращает success = true, message = "Drive enabled";
    • при вызове с data: false выключает разрешение (driveEnabled = false), гасит светодиод D48 и возвращает success = true, message = "Drive disabled".
  3. Приём целевого угла из топика /target_angle (std_msgs/msg/Int32):
    • если driveEnabled == false — команда игнорируется, сервопривод остаётся на прежнем месте;
    • если driveEnabled == true — программа ограничивает угол диапазоном 0°–180° через constrain(msg.data, 0, 180) и поворачивает сервопривод.
  4. Публикация текущего угла (1 Гц — каждые 1000 мс):
    • по таймеру rosduino::Timer(1000) публикует текущий установленный угол сервопривода в топик /current_angle (std_msgs/msg/Int32).

Требования к программе

  • Подключены <Servo.h>, <RosDuino.h>, <std_msgs/msg/Int32.h> и <std_srvs/srv/SetBool.h>.
  • В функции loop() вызывается ros.update() и не используется delay().
  • Для публикации текущего угла раз в секунду используется объект rosduino::Timer(1000).

Как составить алгоритм

  1. Объявите константы SERVO_PIN = 2, STATUS_LED_PIN = 48, переменные bool driveEnabled = false; и int currentAngle = 90;, объект Servo servo; и таймер rosduino::Timer telemetryTimer(1000);.
  2. Напишите обработчик сервиса void onSetDriveEnable(std_srvs::SetBool& srv):
    • сохраните driveEnabled = srv.request.data;;
    • включите или выключите светодиод D48 в зависимости от driveEnabled;
    • заполните srv.response.success = true; и текстовое поле srv.response.message.
  3. Напишите обработчик подписки void onTargetAngle(std_msgs::Int32 msg):
    • если !driveEnabled, сразу выйдите из функции (return;);
    • иначе ограничьте угол currentAngle = constrain(msg.data, 0, 180); и вызовите servo.write(currentAngle);.
  4. В setup() настройте пин светодиода, привяжите сервопривод, установите начальный угол 90°, вызовите ros.begin("safe_servo_node"), зарегистрируйте подписку ros.subscribe("target_angle", onTargetAngle) и сервис ros.service("set_drive_enable", onSetDriveEnable).
  5. В loop() вызывайте ros.update() и по срабатыванию telemetryTimer.check() публикуйте currentAngle в топик "current_angle".

Как проверить результат из терминала ROS 2

  1. Загрузите скетч в плату и запустите rosduino_agent в Терминале 1. Светодиод D48 погашен (привод заблокирован).
  2. Попробуйте отправить команду поворота на 45° в Терминале 2:
    ros2 topic pub --once /target_angle std_msgs/msg/Int32 "{data: 45}"
    
    Сервопривод останется на месте (90°), так как разрешение ещё не включено.
  3. Разблокируйте привод вызовом сервиса в Терминале 2:
    ros2 service call /set_drive_enable std_srvs/srv/SetBool "{data: true}"
    
    Загорится светодиод D48, а в терминале вернётся ответ success=True, message='Drive enabled'.
  4. Снова отправьте угол 45°:
    ros2 topic pub --once /target_angle std_msgs/msg/Int32 "{data: 45}"
    
    Теперь сервопривод повернётся на 45°, а проверка ros2 topic echo /current_angle --once покажет data: 45.

Посмотреть решение и разбор

Назад: Создание сообщений для сервисов.
Дальше: Урок 7. Диагностика, время и узлы на Python.

Урок 7. Диагностика, время и узлы на Python

В уроках 4–6 мы обменивались с платой данными через топики и сервисы из командной строки. В этом уроке мы разберём две важные темы для полноценной работы с ROS 2: во-первых, как отлаживать скетч через системный журнал /rosout, синхронизировать время ros.now() и проверять связь в /diagnostics; во-вторых, как написать на компьютере собственный управляющий узел на языке Python (rclpy) и запустить его вместе с агентом через launch-файл.

В этом уроке вы научитесь

  • выводить отладочные сообщения со стороны платы в системный журнал ROS 2 (/rosout) с помощью ros.logDebug()…ros.logFatal();
  • получать синхронизированное с компьютером время ROS 2 функцией ros.now() и проверять состояние связи в топике /diagnostics;
  • создавать на компьютере управляющий узел на Python (rclpy), который подписывается на топик платы и отправляет команды для светодиода и сервопривода;
  • запускать rosduino_agent и управляющий Python-узел одной командой через launch-файл.

Пины, которые используются в уроке

Компонент на платеПин или контактНазначение в уроке
Первая кнопкаD28Отправка событий в журнал /rosout
Светодиод платыD48Индикация команд от Python-узла
Разъём GPIO A83.3V, GND, GPIO (A8)Чтение аналогового сигнала для передачи в Python-узел (работает с потенциометром и без него)
Разъём сервоприводаD2Поворот вала по командам от Python-узла (в третьей части урока и домашнем задании)

План урока

  1. Журнал событий /rosout — пять уровней важности сообщений (logDebug…logFatal) и просмотр журнала платы на компьютере.
  2. Синхронизация времени и диагностика связи — функция ros.now(), контроль состояния узла в /diagnostics и параметры запуска rosduino_agent.
  3. Управляющий узел на Python и launch-файл — универсальный скетч на плате, управляющий скрипт на Python (rclpy) и единый файл запуска bringup.launch.py.
  4. Домашнее задание — Python-узел сглаживания аналогового сигнала для плавного управления сервоприводом D2 и пороговым включением светодиода D48.

Назад: Домашнее задание.
Дальше: Журнал событий /rosout.

Журнал событий /rosout

В уроке 3 мы проверяли работу скетча с помощью Serial.println() и утилиты мониторинга порта. Но как только к плате подключается rosduino_agent, последовательный порт переходит в двоичный режим: любой посторонний текст из Serial.print() разрушит пакеты данных. Чтобы вы по-прежнему могли видеть, что происходит внутри программы на микроконтроллере, в RosDuino встроена отправка текстовых записей в общесистемный журнал ROS 2 — топик /rosout.

Пять уровней важности сообщений

Вместо Serial.println() в скетче вызываются методы объекта ros. Агент rosduino_agent принимает эти строки по тому же USB-кабелю, сразу выводит их в своём окне терминала и одновременно публикует в стандартный топик /rosout.

В ROS 2 все журнальные сообщения делятся на пять уровней важности:

Вызов в скетчеУровень в ROS 2Когда использовать
ros.logDebug("...")DEBUGПодробные технические детали при пошаговой отладке
ros.logInfo("...")INFOОбычные уведомления о штатной работе (запуск узла, переключение режима)
ros.logWarn("...")WARNПредупреждения: параметр приблизился к границе или команда проигнорирована
ros.logError("...")ERRORОшибки оборудования или датчика, требующие внимания
ros.logFatal("...")FATALКритический отказ, при котором дальнейшая работа невозможна

Чтобы постоянные текстовые строки хранились во Flash-памяти программ и не расходовали оперативную память микроконтроллера, их удобно оборачивать в макрос F("..."), например:

ros.logInfo(F("System started"));

Пошаговая практика: отправка сообщений в /rosout по кнопке

Соберём скетч, который считает нажатия кнопки D28, переключает светодиод D48 и в зависимости от числа нажатий отправляет в ROS 2 сообщения разных уровней важности (INFO, WARN и ERROR):

#include <RosDuino.h>

const int BUTTON_PIN = 28;
const int LED_PIN = 48;

rosduino::Timer buttonTimer(30);

int lastButtonState = LOW;
int pressCount = 0;
bool ledOn = false;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  lastButtonState = digitalRead(BUTTON_PIN);
  ros.begin("logger_node");
}

void loop() {
  ros.update();

  if (!ros.connected()) {
    return;
  }

  if (buttonTimer.check()) {
    int reading = digitalRead(BUTTON_PIN);

    if (reading != lastButtonState) {
      lastButtonState = reading;

      if (lastButtonState == HIGH) {
        pressCount++;
        ledOn = !ledOn;
        digitalWrite(LED_PIN, ledOn ? HIGH : LOW);

        if (pressCount < 3) {
          ros.logInfo(F("Button D28 pressed: normal operation"));
        } else if (pressCount < 5) {
          ros.logWarn(F("Button D28 pressed 3+ times: warning threshold"));
        } else {
          ros.logError(F("Button D28 pressed 5+ times: limit reached!"));
        }
      }
    }
  }
}

Как просматривать журнал /rosout на компьютере

  1. Если rosduino_agent запущен в Терминале 1, остановите его клавишами Ctrl+C, загрузите скетч в плату и снова запустите агент:

Терминал 1:

ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
  1. Нажмите кнопку D28 на плате пять раз подряд. Посмотрите в окно Терминала 1, где запущен агент: вы сразу увидите цветные строки журнала [INFO], [WARN] и [ERROR] от узла logger_node.

  2. Откройте Терминал 2 и подпишитесь на системный топик /rosout:

Терминал 2:

ros2 topic echo /rosout
  1. Нажмите кнопку D28 ещё раз. В Терминале 2 появится полная структура журнальной записи rcl_interfaces/msg/Log с меткой времени stamp, уровнем важности level, именем узла name: logger_node и текстом msg. Остановите просмотр клавишами Ctrl+C.

Назад: Урок 7. Диагностика, время и узлы на Python.
Дальше: Синхронизация времени и диагностика связи.

Синхронизация времени и диагностика связи

Помимо журнала событий, для работы в составе робота плате нужны ещё два инструмента: единое системное время с компьютером (ros.now()) и контроль исправности самого канала связи (/diagnostics). Кроме того, сам агент rosduino_agent поддерживает полезные параметры запуска. Разберём их на простых примерах.

Синхронизация времени ros.now()

Встроенный секундомер millis() считает миллисекунды только с момента включения самой платы и не знает, который сейчас час на компьютере. Чтобы все узлы робота жили по одним часам, rosduino_agent автоматически синхронизирует время микроконтроллера с часами компьютера.

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

Функция ros.now() возвращает структуру времени ROS 2 builtin_interfaces::msg::Time с двумя полями:

  • sec — целые секунды;
  • nanosec — наносекунды.

Пока плата ещё не соединилась с агентом, t.sec равно 0. Как только связь установлена, ros.now() возвращает текущее системное время.

Простой пример проверки времени и журнала

Загрузим короткий скетч (аналог стандартного примера TimeAndLog), который раз в секунду проверяет синхронизацию времени ros.now(), мигает светодиодом D48 и отправляет запись в журнал /rosout:

#include <RosDuino.h>

const int LED_PIN = 48;

rosduino::Timer timer(1000); // каждые 1000 мс (1 Гц)
bool ledState = false;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  ros.begin("time_demo_node");
}

void loop() {
  ros.update();

  if (ros.connected() && timer.check()) {
    ledState = !ledState;
    digitalWrite(LED_PIN, ledState ? HIGH : LOW);

    builtin_interfaces::msg::Time t = ros.now();
    if (t.sec != 0) {
      ros.logInfo(F("ROS 2 time is synchronized"));
    } else {
      ros.logWarn(F("Waiting for time sync"));
    }
  }
}

Если в скетче публикуются сообщения датчиков с заголовком header (например, sensor_msgs/msg/Range), то же самое время одной строкой записывается в метку измерения: msg.header.stamp = ros.now();.

Диагностика канала связи в топике /diagnostics

Как узнать, что плата стабильно держит связь, а на кабеле USB нет помех? Агент rosduino_agent каждую секунду публикует отчёт о состоянии соединения в стандартный топик /diagnostics.

Запустите агент в Терминале 1, а в Терминале 2 посмотрите одно сообщение диагностики:

Терминал 2:

ros2 topic echo /diagnostics --field status --once

В поле level агент передаёт один из трёх статусов:

  • OK (0) — плата на связи, все топики и сервисы успешно созданы;
  • WARN (1) — связь с платой потеряна (например, нажата кнопка Reset или выдернут кабель);
  • ERROR (2) — последовательный порт не удалось открыть.

В списке values этого же сообщения видны порт, выбранный профиль памяти платы (LARGE для Arduino Due), число созданных топиков и сервисов, а также счётчики принятых кадров и ошибок контрольной суммы (crc_errors).

Полезные параметры запуска rosduino_agent

До сих пор мы указывали агенту только порт (--port). При запуске из командной строки можно добавить и другие полезные флаги:

Флаг запускаЧто делаетПример
--portИмя последовательного порта платы (обязательный параметр)--port /dev/ttyACM0
--baudСкорость порта (по умолчанию 115200, должна совпадать со скетчем)--baud 115200
--namespaceПомещает все топики и сервисы платы в отдельное пространство имён--namespace front_mcu
--keep-on-disconnectНе удаляет топики из ROS 2 при кратковременной перезагрузке платы--keep-on-disconnect
--log-levelУровень подробности вывода в консоль (debug, info, warn, error)--log-level debug

Например, чтобы все топики платы автоматически получили префикс /tb_mcu/..., запустите агент так:

Терминал 1:

ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0 --namespace tb_mcu

Агент можно запускать и через готовый launch-файл из пакета rosduino_agent (это особенно удобно, когда нужно подключить сразу две платы через запятую в параметре ports):

Терминал 1:

ros2 launch rosduino_agent rosduino_agent.launch.py port:=/dev/ttyACM0

Справочный материал: отладка через Serial1

Этот раздел можно пропустить при первом прохождении. На микроконтроллере Arduino Due есть несколько аппаратных портов UART. Если в нестандартной задаче вам нужно оставить основной USB-порт Serial свободным для Serial.println(), связь с rosduino_agent можно перенести на второй порт Serial1 (пины 18 TX1 и 19 RX1 через внешний переходник USB-UART на 3,3 В):

void setup() {
  Serial.begin(115200);
  ros.begin(Serial1, "led_board");
}

При обычной работе с платой TurtleBro по одному USB-кабелю это не требуется — все отладочные сообщения передаются через ros.logInfo() в /rosout.

Назад: Журнал событий /rosout.
Дальше: Управляющий узел на Python и launch-файл.

Управляющий узел на Python и launch-файл

До сих пор мы проверяли работу платы вручную — вводили в терминале команды ros2 topic pub и ros2 topic echo. В реальном роботе решения принимает программа на компьютере. В этой части урока мы напишем простой управляющий узел на языке Python (rclpy), который получает данные от платы TurtleBro и отправляет ей команды в ответ, а также познакомимся с запуском через launch-файл.

Разделение задач между платой и компьютером

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

В ROS 2 задачи делят на два уровня:

  1. Скетч на плате («драйвер железа»): только считывает датчики и кнопки, публикует их значения в топики и слушает исполнительные топики для светодиодов и сервопривода. Такой скетч прошивается в плату один раз.
  2. Python-узел на компьютере («мозг»): подписывается на топики платы, проверяет условия и отправляет команды обратно в топики светодиодов или сервопривода. Поменять условие в Python-скрипте и перезапустить его можно за секунду без перепрошивки платы.
flowchart LR
    subgraph Board["Плата TurtleBro (скетч)"]
        S["Разъём GPIO A8 / кнопка D28"]
        A["Светодиод D48 / сервопривод D2"]
    end
    subgraph PC["Компьютер с Ubuntu"]
        Py["Управляющий узел на Python"]
    end
    S -- "/analog_signal" --> Py
    Py -- "/led, /servo_angle" --> A

Шаг 1. Универсальный скетч на плате

Загрузим в плату простой универсальный скетч io_board, который:

  • каждые 100 мс публикует полученное значение с разъёма GPIO A8 (0–1023) в топик /analog_signal (std_msgs/msg/Int32);
  • по подписке на /led (std_msgs/msg/Bool) включает или выключает светодиод D48;
  • по подписке на /servo_angle (std_msgs/msg/Int32) поворачивает сервопривод на разъёме D2 и пишет уведомление в /rosout.
#include <Servo.h>
#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>
#include <std_msgs/msg/Int32.h>

const int SENSOR_PIN = A8;
const int LED_PIN = 48;
const int SERVO_PIN = 2;

Servo servo;
std_msgs::Int32 signalMsg;
rosduino::Timer sensorTimer(100);  // 10 Гц

void onLed(std_msgs::Bool msg) {
  digitalWrite(LED_PIN, msg.data ? HIGH : LOW);
}

void onServoAngle(std_msgs::Int32 msg) {
  int safeAngle = constrain(msg.data, 0, 180);
  servo.write(safeAngle);
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  servo.attach(SERVO_PIN);
  servo.write(90);

  ros.begin("io_board");
  ros.subscribe("led", onLed);
  ros.subscribe("servo_angle", onServoAngle);
}

void loop() {
  ros.update();

  if (sensorTimer.check()) {
    signalMsg.data = analogRead(SENSOR_PIN);
    ros.publish("analog_signal", signalMsg);
  }
}

Загрузите этот скетч в плату. Больше менять прошивку платы в этом уроке не потребуется.

Шаг 2. Простой управляющий узел на Python (rclpy)

Напишем на компьютере короткий скрипт light_controller.py. Он подписывается на топик /analog_signal, и если полученное значение меньше порога 400, включает светодиод D48 (/led -> True) и ставит сервопривод в положение 180°, а иначе — выключает светодиод и возвращает сервопривод в 0°.

Создайте файл ~/ros2_ws/light_controller.py:

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from std_msgs.msg import Bool, Int32

THRESHOLD = 400


class LightController(Node):
    def __init__(self):
        super().__init__('light_controller')

        # Подписка на топик аналогового сигнала с платы
        self.sub = self.create_subscription(
            Int32,
            '/analog_signal',
            self.on_sensor,
            10
        )

        # Издатели для команд светодиоду и сервоприводу
        self.led_pub = self.create_publisher(Bool, '/led', 10)
        self.servo_pub = self.create_publisher(Int32, '/servo_angle', 10)
        self.last_active = None
        self.get_logger().info('Узел light_controller запущен')

    def on_sensor(self, msg: Int32):
        is_active = msg.data < THRESHOLD

        # Отправляем команду только при смене состояния
        if is_active != self.last_active:
            self.last_active = is_active

            led_msg = Bool()
            led_msg.data = is_active
            self.led_pub.publish(led_msg)

            servo_msg = Int32()
            servo_msg.data = 180 if is_active else 0
            self.servo_pub.publish(servo_msg)

            self.get_logger().info(
                f'Сигнал={msg.data}: LED={is_active}, угол={servo_msg.data}'
            )


def main(args=None):
    rclpy.init(args=args)
    node = LightController()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

Запуск и проверка

  1. В Терминале 1 запустите агент:

Терминал 1:

ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
  1. В Терминале 2 запустите ваш Python-узел:

Терминал 2:

python3 ~/ros2_ws/light_controller.py

Как только значение с разъёма GPIO A8 перейдёт через порог 400, Python-узел сам отправит команды в /led и /servo_angle, зажжёт светодиод D48 и повернёт сервопривод.

Шаг 3. Запуск одной командой через launch-файл

Чтобы не запускать rosduino_agent и Python-скрипт в двух разных терминалах вручную, в ROS 2 используют launch-файлы на языке Python.

Создайте файл ~/ros2_ws/bringup.launch.py, который запускает сразу оба процесса:

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument, ExecuteProcess
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node


def generate_launch_description():
    port_arg = DeclareLaunchArgument(
        'port',
        default_value='/dev/ttyACM0',
        description='Последовательный порт платы TurtleBro'
    )

    agent_node = Node(
        package='rosduino_agent',
        executable='rosduino_agent',
        name='rosduino_agent',
        parameters=[{'port': LaunchConfiguration('port')}]
    )

    controller_process = ExecuteProcess(
        cmd=['python3', '/home/' + __import__('os').environ['USER'] + '/ros2_ws/light_controller.py'],
        output='screen'
    )

    return LaunchDescription([
        port_arg,
        agent_node,
        controller_process,
    ])

Теперь остановите процессы в обоих терминалах (Ctrl+C) и запустите всю систему одной командой в Терминале 1:

Терминал 1:

ros2 launch ~/ros2_ws/bringup.launch.py port:=/dev/ttyACM0

И агент rosduino_agent, и ваш управляющий Python-узел стартуют одновременно в одном окне!

Вопросы для самопроверки

  1. Какими пятью функциями объекта ros можно отправить текстовое сообщение с платы в системный журнал /rosout?
  2. Зачем нужна функция ros.now() и чем возвращаемое ею время отличается от millis()?
  3. Какой топик ROS 2 позволяет проверить связь платы с rosduino_agent и что в нём означает статус WARN?
  4. В чём преимущество размещения пороговой логики и фильтрации сигнала в Python-узле на компьютере вместо скетча на плате?
  5. Зачем нужен launch-файл и какие два процесса запускает bringup.launch.py из этого урока?

Назад: Синхронизация времени и диагностика связи.
Дальше: Домашнее задание.

Домашнее задание

В этом задании менять скетч на плате не нужно — мы используем уже загруженную на предыдущем шаге универсальную прошивку io_board (которая публикует /analog_signal и слушает /servo_angle и /led). Ваша задача — написать на стороне компьютера Python-узел smooth_servo_controller.py, который усредняет последние измерения датчика, плавно поворачивает сервопривод D2 и зажигает светодиод D48 при превышении порога.

Зачем нужно усреднение сигнала в Python-узле

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

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

Что должно получиться

Напишите Python-скрипт ~/ros2_ws/smooth_servo_controller.py с узлом smooth_servo_controller:

  1. Подписка на /analog_signal (std_msgs/msg/Int32):
    • узел хранит последние 5 полученных значений (удобно использовать очередь фиксированной длины collections.deque(maxlen=5));
    • при каждом новом сообщении вычисляет среднее значение avg_val = sum(self.window) / len(self.window).
  2. Пропорциональное управление сервоприводом (/servo_angle, std_msgs/msg/Int32):
    • переводит сглаженное значение avg_val (0..1023) в угол от 0 до 180 градусов по формуле: angle = int(avg_val * 180 / 1023);
    • ограничивает угол пределами 0..180 и публикует его в топик /servo_angle.
  3. Пороговая сигнализация на светодиоде D48 (/led, std_msgs/msg/Bool):
    • если сглаженное значение avg_val > 700 — отправляет True в топик /led (зажигает светодиод D48) и выводит предупреждение в журнал self.get_logger().warn(...);
    • если avg_val <= 700 — отправляет False в топик /led (гасит светодиод D48).

Как составить алгоритм

  1. Импортируйте from collections import deque, rclpy, Node и сообщения Bool, Int32 из std_msgs.msg.
  2. В конструкторе __init__() создайте буфер self.window = deque(maxlen=5), подписку на /analog_signal и два издателя: для /servo_angle (Int32) и /led (Bool).
  3. В методе-обработчике on_sensor(self, msg: Int32):
    • добавьте новое измерение в буфер: self.window.append(msg.data);
    • посчитайте среднее: avg_val = sum(self.window) / len(self.window);
    • рассчитайте угол angle = max(0, min(180, int(avg_val * 180 / 1023))) и опубликуйте его в /servo_angle;
    • проверьте условие alarm = avg_val > 700 и при смене состояния отправьте Bool(data=alarm) в /led.

Как проверить результат

  1. Убедитесь, что в плату загружен скетч io_board со страницы «Управляющий узел на Python и launch-файл».
  2. В Терминале 1 запустите rosduino_agent:
    ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
    
  3. В Терминале 2 запустите ваш скрипт:
    python3 ~/ros2_ws/smooth_servo_controller.py
    
  4. Плавно вращайте ручку потенциометра на разъёме GPIO A8 (или поднесите палец к контакту GPIO): сервопривод на разъёме D2 будет мягко следовать за сглаженным значением сигнала, а при превышении уровня 700 загорится светодиод D48.

Посмотреть решение и разбор

Назад: Управляющий узел на Python и launch-файл.
Дальше: Урок 8. Работа на роботе TurtleBro.

Урок 8. Работа на роботе TurtleBro

В уроках 1–7 робота TurtleBro можно было не включать: мы работали только с его платой Arduino и подключали её через разъём DUE (Serial) к компьютеру для загрузки скетчей и обмена данными. В заключительном уроке мы разберём, как работать с платой Arduino уже в составе включённого робота.

В этом уроке вы научитесь

  • понимать устройство платы робота TurtleBro (разделение между системным микроконтроллером STM32 и пользовательским Arduino Due);
  • переключать скетч с порта загрузки Serial на рабочий канал связи с Raspberry Pi — ros.begin(Serial1, "имя_узла");
  • устанавливать и запускать rosduino_agent на Raspberry Pi робота по постоянному имени порта /dev/serial/by-id/...;
  • связывать кнопки и светодиоды платы с движением колёс робота (/cmd_vel) и запускать всю систему одним .launch.py-файлом;
  • генерировать C++-заголовки для собственных типов сообщений .msg и .srv с помощью пакета rosduino_gen.

Как устроена плата внутри робота TurtleBro

Для выполнения этого урока понадобится собранный робот TurtleBro с настроенным доступом к его бортовому компьютеру Raspberry Pi по Wi-Fi (SSH) и USB-кабель для загрузки скетчей с вашего компьютера через разъём DUE.

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

  1. Системный микроконтроллер STM32F4: отвечает за базовое движение шасси — вращает колёса, считывает энкодеры и инерциальный датчик (IMU), следит за зарядом батареи, публикует /odom, /imu, /bat и принимает команды скорости из /cmd_vel.
  2. Пользовательский микроконтроллер Arduino Due: управляет кнопками D28/D15, переключателями D16/D29, светодиодами D48–D51, разъёмами сервоприводов D2–D7 и разъёмами GPIO A8–A6. Он полностью предоставлен вам: любой скетч, загруженный в Arduino Due, никак не может повредить или нарушить базовую работу шасси робота.

Главная аппаратная особенность робота: разъём USB-C с надписью DUE (Serial, Programming Port) используется только для загрузки скетчей с вашего компьютера, а для постоянной связи с бортовым Raspberry Pi на самой плате уже разведён второй аппаратный порт микроконтроллера — Serial1. Поэтому переключать провода между ноутбуком и Raspberry Pi не нужно!

flowchart LR
    Laptop["Ваш компьютер<br/>(Arduino IDE 2)"] -. "Загрузка скетча<br/>разъём DUE (Serial)" .-> DUE
    subgraph Board["Системная плата TurtleBoard"]
        STM["МК STM32F4<br/>(колёса, IMU, энкодеры)"]
        DUE["МК Arduino Due<br/>(кнопки, светодиоды, серво, A8)"]
    end
    subgraph RPi["Raspberry Pi робота (Ubuntu + ROS 2)"]
        Base["Базовый сервис TurtleBro"]
        Agent["rosduino_agent"]
        ROS2["Единый граф топиков ROS 2<br/>(/cmd_vel, /odom, /scan + ваши топики)"]
        Base <--> ROS2
        Agent <--> ROS2
    end
    STM <--> Base
    DUE <-- "Связь на роботе (Serial1)" --> Agent
    style RPi fill:#f8fafc,stroke:#64748b,stroke-width:1.5px,color:#0f172a
    style Board fill:#fefce8,stroke:#ca8a04,stroke-width:1.5px,color:#713f12

План урока

  1. Отличия ПК и Raspberry Pi. Запуск агента на роботе — переход на Serial1 в скетче, почему не нужно переключать провода и не нужно останавливать агент при прошивке, запуск rosduino_agent на Raspberry Pi.
  2. Управление роботом кнопками и launch-файл — связь кнопок и светодиодов платы со штатным топиком скорости /cmd_vel и запуск всей связки одним .launch.py-файлом.
  3. Генерация собственных сообщений (rosduino_gen) — как создать свой пакет интерфейсов .msg/.srv и сгенерировать заголовки для Arduino.
  4. Домашнее задание — световой парктроник на четырёх светодиодах платы D48–D51 по данным лидара (/scan), управление движением кнопками D28/D15 и запуск единым launch-файлом.

Назад: Домашнее задание.
Дальше: Отличия ПК и Raspberry Pi. Запуск агента на роботе.

Отличия ПК и Raspberry Pi. Запуск агента на роботе

Ранее мы использовали встроенную плату Arduino без включения самого робота, поэтому и загрузка скетча, и связь с rosduino_agent шли через один и тот же разъём DUE (Serial). При работе на включённом роботе TurtleBro всё устроено ещё удобнее: для загрузки скетчей и для общения с бортовым компьютером Raspberry Pi используются два разных порта микроконтроллера.

Главные отличия работы на роботе от работы на настольном ПК

При переходе от прямого подключения к компьютеру на работу в составе робота меняются три момента:

  • Связь с Raspberry Pi идёт через порт Serial1. В предыдущих уроках мы вызывали ros.begin("имя_узла"), и обмен шёл через основной порт Serial (разъём DUE). На плате робота линия связи с бортовым компьютером Raspberry Pi разведена на второй аппаратный порт микроконтроллера — Serial1, поэтому в скетчах для робота первым аргументом передаётся Serial1:

    void setup() {
      // Было при подключении к ПК через разъём DUE (Serial):
      // ros.begin("led_board");
    
      // Стало при работе с Raspberry Pi внутри робота (Serial1):
      ros.begin(Serial1, "led_board");
    }
    
  • Не забывайте, что команды ROS 2 выполняются на роботе по SSH. У бортового Raspberry Pi нет монитора и клавиатуры, поэтому мы подключаемся к нему со своего компьютера по сети Wi-Fi через терминал (ssh pi@turtlebroXX.local).

  • Не нужно переключать провода и останавливать агент при прошивке. Разъём USB-C с надписью DUE используется только для загрузки скетчей с вашего компьютера, а rosduino_agent на роботе общается с платой по внутренней линии Serial1. Поскольку это два независимых порта, останавливать агент перед нажатием кнопки Загрузить не требуется, а основной порт Serial при желании можно даже использовать для вывода Serial.println().

Шаг 1. Загрузите скетч с Serial1 в плату робота

Обратите внимание на единственное, но ключевое изменение в функции setup(): вместо ros.begin("led_board") мы передаём первым аргументом порт Serial1:

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>

const int LED_PIN = 48;

void onLed(std_msgs::Bool msg) {
  digitalWrite(LED_PIN, msg.data ? HIGH : LOW);
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  // На роботе связь с Raspberry Pi идёт через аппаратный порт Serial1!
  ros.begin(Serial1, "led_board");
  ros.subscribe("led", onLed);
}

void loop() {
  ros.update();
}

Шаг 2. Подключитесь к Raspberry Pi по SSH и соберите rosduino_agent

Откройте терминал на своём компьютере и подключитесь к бортовому компьютеру робота по SSH (подставьте номер вашего робота, пароль по умолчанию — brobro):

ssh pi@turtlebro01.local

Если пакет rosduino_ros на Raspberry Pi робота ещё не установлен, соберите его один раз точно так же, как делали на ПК в уроке 4:

mkdir -p ~/ros2_ws/src
cd ~/ros2_ws/src
git clone https://github.com/rosduino/rosduino_ros.git
cd ~/ros2_ws
colcon build
source install/setup.bash

В штатном образе робота подключение ~/ros2_ws/install/setup.bash уже прописано в ~/.bashrc, поэтому во всех новых SSH-окнах выполнять source вручную не нужно.

Шаг 3. Найдите постоянное имя устройства USB-UART

На плате TurtleBoard аппаратный порт Serial1 микроконтроллера Arduino соединён с Raspberry Pi через встроенный USB-UART-мост (CP2102N). В Linux этот мост представлен устройством с постоянным путём /dev/serial/by-id/usb-Silicon_Labs_CP2102N_USB_to_UART_Bridge_Controller_0010-if00-port0. Доступные устройства можно посмотреть командой:

ls -l /dev/serial/by-id/

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

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

sudo systemctl stop turtlebro_micro_ros.service

Шаг 4. Запустите rosduino_agent на роботе

Запустите агент в SSH-сессии (Терминал 1 на роботе), передав параметру --port путь к устройству USB-UART-моста:

Терминал 1 (SSH на роботе):

ros2 run rosduino_agent rosduino_agent --port /dev/serial/by-id/usb-Silicon_Labs_CP2102N_USB_to_UART_Bridge_Controller_0010-if00-port0

Откройте второе окно терминала (Терминал 2 — по SSH на роботе или на своём компьютере в той же сети ROS 2) и проверьте список топиков:

Терминал 2:

ros2 topic list

Ожидаемый результат

В одном списке вы увидите и штатные топики робота TurtleBro (/cmd_vel, /odom, /imu, /scan), и топик вашей платы /led! Проверьте связь командой ros2 topic pub --once /led std_msgs/msg/Bool "{data: true}" — на плате робота загорится светодиод D48. При этом, если вы захотите изменить скетч и загрузить его с компьютера через разъём DUE, останавливать rosduino_agent на роботе даже не придётся: после перезагрузки платы агент на Serial1 подхватит новый скетч автоматически!

Назад: Урок 8. Работа на роботе TurtleBro.
Дальше: Управление роботом кнопками и launch-файл.

Управление роботом кнопками и launch-файл

Агент rosduino_agent уже работает на Raspberry Pi робота, а топики платы находятся в одной сети ROS 2 со штатными узлами шасси. Теперь свяжем физические кнопки на корпусе робота с его движением: нажимаем кнопку D28 — загорается светодиод D48 и робот плавно едет вперёд; нажимаем кнопку D15 — робот останавливается. А чтобы запускать агент и управляющий узел одной командой, соберём для робота готовый launch-файл.

Поставьте робота на подставку при первой проверке

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

Шаг 1. Скетч приборной панели (turtlebro_panel_node)

Загрузим в плату TurtleBro скетч, который:

  • опрашивает кнопку «Старт» (D28) и кнопку «Стоп» (D15) каждые 30 мс и при нажатии публикует события в топики /panel/btn_start и /panel/btn_stop (std_msgs/msg/Bool);
  • каждые 100 мс публикует аналоговый сигнал с разъёма GPIO A8 в топик /panel/sensor (std_msgs/msg/Int32);
  • слушает топики /panel/led (std_msgs/msg/Bool для светодиода D48) и /panel/servo (std_msgs/msg/Int32 для сервопривода D2).
#include <Servo.h>
#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>
#include <std_msgs/msg/Int32.h>

const int START_BTN_PIN = 28;
const int STOP_BTN_PIN = 15;
const int LED_PIN = 48;
const int SERVO_PIN = 2;
const int SENSOR_PIN = A8;

Servo servo;
std_msgs::Bool btnMsg;
std_msgs::Int32 sensorMsg;

rosduino::Timer buttonTimer(30);   // 30 мс для кнопок
rosduino::Timer sensorTimer(100);  // 10 Гц для датчика A8

int lastStartState = LOW;
int lastStopState = LOW;

void onLed(std_msgs::Bool msg) {
  digitalWrite(LED_PIN, msg.data ? HIGH : LOW);
}

void onServo(std_msgs::Int32 msg) {
  servo.write(constrain(msg.data, 0, 180));
}

void setup() {
  pinMode(START_BTN_PIN, INPUT);
  pinMode(STOP_BTN_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  servo.attach(SERVO_PIN);
  servo.write(90);

  lastStartState = digitalRead(START_BTN_PIN);
  lastStopState = digitalRead(STOP_BTN_PIN);

  // Связь с Raspberry Pi робота идёт через аппаратный порт Serial1.
  ros.begin(Serial1, "turtlebro_panel_node");
  ros.advertise("panel/btn_start", btnMsg);
  ros.advertise("panel/btn_stop", btnMsg);
  ros.subscribe("panel/led", onLed);
  ros.subscribe("panel/servo", onServo);
}

void loop() {
  ros.update();

  if (buttonTimer.check()) {
    int startReading = digitalRead(START_BTN_PIN);
    if (startReading != lastStartState) {
      lastStartState = startReading;
      btnMsg.data = (lastStartState == HIGH);
      ros.publish("panel/btn_start", btnMsg);
    }

    int stopReading = digitalRead(STOP_BTN_PIN);
    if (stopReading != lastStopState) {
      lastStopState = stopReading;
      btnMsg.data = (lastStopState == HIGH);
      ros.publish("panel/btn_stop", btnMsg);
    }
  }

  if (sensorTimer.check()) {
    sensorMsg.data = analogRead(SENSOR_PIN);
    ros.publish("panel/sensor", sensorMsg);
  }
}

Загрузите этот скетч со своего компьютера через разъём DUE. Переключать провода или останавливать агент на роботе при этом не нужно. Обратите внимание на вызовы ros.advertise() в setup(): благодаря им оба топика кнопок создаются сразу при подключении агента, поэтому кнопки «Старт» и «Стоп» срабатывают с самого первого нажатия без потери первого сообщения.

Шаг 2. Управляющий Python-узел на Raspberry Pi

Напишем на Raspberry Pi скрипт ~/ros2_ws/panel_drive_node.py. Он подписывается на кнопки /panel/btn_start и /panel/btn_stop и управляет движением робота через его штатный топик скорости /cmd_vel (geometry_msgs/msg/Twist):

  • поле twist.linear.x задаёт скорость движения вперёд/назад в м/с (например, 0.10 м/с — медленное движение вперёд, 0.0 — полная остановка);
  • поле twist.angular.z задаёт скорость поворота вокруг своей оси в рад/с.

Создайте на Raspberry Pi файл ~/ros2_ws/panel_drive_node.py:

#!/usr/bin/env python3
import rclpy
from geometry_msgs.msg import Twist
from rclpy.node import Node
from std_msgs.msg import Bool


class PanelDriveNode(Node):
    def __init__(self):
        super().__init__('panel_drive_node')
        self.moving = False

        # Подписки на кнопки платы TurtleBro
        self.create_subscription(Bool, '/panel/btn_start', self.on_start, 10)
        self.create_subscription(Bool, '/panel/btn_stop', self.on_stop, 10)

        # Издатели: светодиод на плате и штатный топик скорости робота /cmd_vel
        self.led_pub = self.create_publisher(Bool, '/panel/led', 10)
        self.cmd_vel_pub = self.create_publisher(Twist, '/cmd_vel', 10)

        # Таймер 10 Гц для регулярной отправки скорости в /cmd_vel
        self.create_timer(0.1, self.publish_velocity)
        self.get_logger().info('Узел panel_drive_node готов. D28 — старт, D15 — стоп.')

    def set_moving(self, state: bool):
        self.moving = state
        led_msg = Bool()
        led_msg.data = state
        self.led_pub.publish(led_msg)

        if not state:
            self.cmd_vel_pub.publish(Twist())

    def on_start(self, msg: Bool):
        if msg.data and not self.moving:
            self.get_logger().info('Нажата кнопка Старт (D28): начинаем движение')
            self.set_moving(True)

    def on_stop(self, msg: Bool):
        if msg.data and self.moving:
            self.get_logger().warn('Нажата кнопка Стоп (D15): остановка!')
            self.set_moving(False)

    def publish_velocity(self):
        if self.moving:
            cmd = Twist()
            cmd.linear.x = 0.10
            self.cmd_vel_pub.publish(cmd)


def main(args=None):
    rclpy.init(args=args)
    node = PanelDriveNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.cmd_vel_pub.publish(Twist())
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

Шаг 3. Создание и запуск единого .launch.py-файла на роботе

При работе с роботом по SSH особенно неудобно открывать несколько окон терминала для каждого узла. Создадим на Raspberry Pi файл ~/ros2_ws/turtlebro_rosduino.launch.py, который одной командой запускает:

  1. Узел rosduino_agent с параметрами port и keep_on_disconnect: True (чтобы топики сохранялись при кратковременном сбросе платы);
  2. Наш управляющий узел panel_drive_node.py.

Создайте на Raspberry Pi файл ~/ros2_ws/turtlebro_rosduino.launch.py:

import os
from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument, ExecuteProcess
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node


def generate_launch_description():
    port_arg = DeclareLaunchArgument(
        'port',
        default_value='/dev/serial/by-id/usb-Silicon_Labs_CP2102N_USB_to_UART_Bridge_Controller_0010-if00-port0',
        description='Порт моста Serial1 пользовательского МК Arduino на роботе TurtleBro'
    )

    agent_node = Node(
        package='rosduino_agent',
        executable='rosduino_agent',
        name='rosduino_agent',
        output='screen',
        parameters=[{
            'port': LaunchConfiguration('port'),
            'baud': 115200,
            'keep_on_disconnect': True,
        }]
    )

    script_path = os.path.expanduser('~/ros2_ws/panel_drive_node.py')
    drive_controller = ExecuteProcess(
        cmd=['python3', script_path],
        output='screen'
    )

    return LaunchDescription([
        port_arg,
        agent_node,
        drive_controller,
    ])

Запуск на роботе одной командой

Подключитесь к роботу по SSH и запустите созданный launch-файл:

ros2 launch ~/ros2_ws/turtlebro_rosduino.launch.py

(Если вы тестируете на другом порту, например /dev/ttyUSB0, укажите port:=/dev/ttyUSB0).

Ожидаемый результат

Нажмите кнопку D28 на плате робота — загорится светодиод D48, и колёса робота начнут плавно вращаться вперёд (linear.x = 0.10 м/с). Нажмите кнопку D15 — светодиод погаснет, и робот мгновенно остановится.

Назад: Отличия ПК и Raspberry Pi. Запуск агента на роботе.
Дальше: Генерация собственных сообщений (rosduino_gen).

Генерация собственных сообщений (rosduino_gen)

В библиотеку RosDuino уже встроены стандартные типы std_msgs, std_srvs, sensor_msgs и geometry_msgs. Но при разработке робота часто хочется объединить несколько показателей платы в одно собственное сообщение — например, передавать состояние обеих кнопок и показание датчика в одной структуре PanelState.msg. Для этого в репозиторий rosduino_ros входит пакет rosduino_gen, который автоматически переводит файлы .msg и .srv в C++-заголовки для Arduino.

Полная документация генератора на русском языке: rosduino_gen/README_RU.md.

Как работает rosduino-gen

Утилита rosduino-gen берёт описание сообщений из любого пакета ROS 2 и создаёт компактные заголовочные файлы .h на чистом C++11 (без динамического выделения памяти), которые работают на всех платах Arduino:

flowchart LR
    Msg["Файлы .msg и .srv<br/>в пакете ROS 2"] --> Gen["Утилита rosduino-gen"]
    Gen --> Header["C++-заголовки .h<br/>в папке libraries/RosDuino/src"]
    Header --> Sketch["#include в скетче Arduino"]

Шаг 1. Посмотрите список доступных типов

Выведите список всех сообщений и сервисов, которые видит генератор в вашей системе ROS 2:

ros2 run rosduino_gen rosduino-gen --list

Чтобы посмотреть типы только одного конкретного пакета (например, sensor_msgs), добавьте флаг --package:

ros2 run rosduino_gen rosduino-gen --list --package sensor_msgs

Шаг 2. Сгенерируйте заголовки для своего пакета сообщений

Допустим, в вашем рабочем пространстве ~/ros2_ws/src создан пакет интерфейсов turtlebro_custom_msgs с файлом msg/PanelStatus.msg:

bool button_start
bool button_stop
int32 analog_value

После сборки пакета командой colcon build и подключения окружения source install/setup.bash запустите генератор, указав имя пакета во флаге --package и путь к папке src библиотеки Arduino во флаге --out:

ros2 run rosduino_gen rosduino-gen \
  --package turtlebro_custom_msgs \
  --out "$HOME/Arduino/libraries/RosDuino/src"

(Если вы прошиваете плату со своего ноутбука, скопируйте сгенерированную папку turtlebro_custom_msgs в каталог Arduino/libraries/RosDuino/src на том компьютере, где запущена Arduino IDE).

Шаг 3. Подключите сгенерированный тип в скетче

Генератор положит файл по пути turtlebro_custom_msgs/msg/PanelStatus.h. В скетче он подключается и используется точно так же, как стандартные сообщения:

#include <RosDuino.h>
#include <turtlebro_custom_msgs/msg/PanelStatus.h>

turtlebro_custom_msgs::PanelStatus statusMsg;
rosduino::Timer timer(100);

void setup() {
  pinMode(28, INPUT);
  pinMode(15, INPUT);
  ros.begin(Serial1, "custom_panel_node");
}

void loop() {
  ros.update();

  if (timer.check()) {
    statusMsg.button_start = (digitalRead(28) == HIGH);
    statusMsg.button_stop = (digitalRead(15) == HIGH);
    statusMsg.analog_value = analogRead(A8);

    ros.publish("panel_status", statusMsg);
  }
}

Основные флаги rosduino-gen

ФлагНазначение
--listПоказать список доступных интерфейсов .msg и .srv
--package PKGСгенерировать заголовки для указанного пакета ROS 2 (можно указать несколько раз)
--out DIRПапка, куда сохраняются .h-файлы (например, ~/Arduino/libraries/RosDuino/src)
--allЗаново пересобрать весь базовый набор типов из файла arduino_types.txt
--default-seq-cap NМаксимальная длина динамического массива в сообщении (по умолчанию 8)

Назад: Управление роботом кнопками и launch-файл.
Дальше: Домашнее задание.

Домашнее задание

В итоговом задании курса вы объедините все ключевые приёмы работы на роботе TurtleBro: обмен с Raspberry Pi через порт Serial1, предварительную регистрацию кнопок ros.advertise(), управление массивом из четырёх светодиодов D48–D51 (как в уроках 2 и 5) и обработку данных со штатного лазерного дальномера (лидара).

Вы соберёте световой парктроник с кнопочным управлением движением:

  • Python-узел на Raspberry Pi читает штатный топик лидара /scan, находит минимальное расстояние до препятствий и передаёт его в плату Arduino;
  • скетч на плате зажигает от 0 до 4 светодиодов D48–D51 по мере приближения препятствия;
  • кнопки «Старт» (D28) и «Стоп» (D15) включают и останавливают движение робота вперёд.

Поставьте робота на подставку при первой проверке

В этом задании движение включается и выключается только по нажатию кнопок (без автоматического торможения). Для первой проверки поставьте робота на коробку или подставку так, чтобы колёса свободно вращались в воздухе, а при заезде по полу держите руку наготове у кнопки «Стоп» (D15). Шкала парктроника работает постоянно — её удобно сначала испытать ладонью на стоящем роботе, не нажимая «Старт».

Как читать данные лидара из топика /scan

Лидар на верхней площадке TurtleBro непрерывно измеряет расстояния вокруг робота и публикует их в штатный топик /scan с типом sensor_msgs/msg/LaserScan.

В каждом сообщении LaserScan передаются:

  • msg.ranges — массив измеренных расстояний в метрах (0.30 соответствует 30 см, 1.0 — 1 м);
  • msg.range_min и msg.range_max — минимальная и максимальная рабочая дальность прибора.

Если луч не отразился от слишком далёкого или тёмного предмета, в msg.ranges попадают нули (0.0), бесконечность (inf) или nan. Поэтому перед поиском ближайшего объекта оставляют только конечные значения строго между msg.range_min и msg.range_max. Для подписки на поток лидара используют стандартный профиль качества обслуживания датчиков qos_profile_sensor_data, совместимый с любым драйвером лидара в ROS 2.

Пример узла на Raspberry Pi, который читает /scan и публикует минимальное расстояние (в метрах) в топик /panel/distance (std_msgs/msg/Float32):

#!/usr/bin/env python3
import math
import rclpy
from rclpy.node import Node
from rclpy.qos import qos_profile_sensor_data
from sensor_msgs.msg import LaserScan
from std_msgs.msg import Float32


class LidarMinExample(Node):
    def __init__(self):
        super().__init__('lidar_min_example')
        self.create_subscription(
            LaserScan,
            '/scan',
            self.on_scan,
            qos_profile_sensor_data
        )
        self.dist_pub = self.create_publisher(Float32, '/panel/distance', 10)

    def on_scan(self, msg: LaserScan):
        valid = [
            r for r in msg.ranges
            if math.isfinite(r) and msg.range_min < r < msg.range_max
        ]
        if not valid:
            return

        dist_msg = Float32()
        dist_msg.data = float(min(valid))
        self.dist_pub.publish(dist_msg)


def main(args=None):
    rclpy.init(args=args)
    node = LidarMinExample()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

Если запустить такой скрипт на роботе и выполнить ros2 topic echo /panel/distance, при приближении ладони к лидару число в метрах будет плавно уменьшаться (например, с 1.20 до 0.20).

Что должно получиться

Вам нужно доработать и скетч на плате Arduino, и управляющий Python-узел на Raspberry Pi, а также собрать для них единый launch-файл:

  1. Скетч на плате Arduino (turtlebro_parktronic_node):

    • открывает связь с Raspberry Pi на порту Serial1: ros.begin(Serial1, "turtlebro_parktronic_node");
    • заранее регистрирует в setup() топики кнопок /panel/btn_start и /panel/btn_stop (std_msgs/msg/Bool) через ros.advertise() и публикует в них события смены состояния кнопок D28 и D15 с периодом опроса 30 мс;
    • подписывается на топик /panel/distance (std_msgs/msg/Float32) и зажигает шкалу из четырёх светодиодов {48, 49, 50, 51} в зависимости от расстояния d (в метрах):
    Расстояние d в /panel/distanceКоличество горящих светодиодовВключённые пины на плате
    d >= 1.00 (свободно)все погашены
    0.7 <= d < 1.01D48
    0.5 <= d < 0.72D48, D49
    0.3 <= d < 0.53D48, D49, D50
    d < 0.3 (ближе 30 см)4 (вплотную)D48, D49, D50, D51
  2. Python-узел на Raspberry Pi (~/ros2_ws/parktronic_drive_node.py):

    • читает топик лидара /scan (sensor_msgs/msg/LaserScan), вычисляет минимальное корректное расстояние в метрах и отправляет его в плату через топик /panel/distance (std_msgs/msg/Float32);
    • подписывается на кнопки /panel/btn_start и /panel/btn_stop (std_msgs/msg/Bool) и управляет движением в топике /cmd_vel (geometry_msgs/msg/Twist) только по кнопкам:
      • по нажатию кнопки «Старт» (D28) робот начинает плавно ехать вперёд (linear.x = 0.10 м/с с частотой 10 Гц);
      • по нажатию кнопки «Стоп» (D15) робот останавливается (linear.x = 0.0 м/с) и не едет до нового нажатия «Старт».
  3. Файл запуска (~/ros2_ws/parktronic.launch.py):

    • запускает одной командой rosduino_agent (на порту моста Serial1 с параметром keep_on_disconnect: True) и узел parktronic_drive_node.py.

Требования к программе

  • В скетче Arduino не используется delay(), в loop() вызывается ros.update(), а опрос кнопок выполняется через rosduino::Timer(30).
  • Для зажигания линейки светодиодов используется массив const int LED_PINS[4] = {48, 49, 50, 51}; и цикл for.
  • Топики кнопок предварительно регистрируются в setup() после ros.begin(Serial1, ...) с помощью ros.advertise().

Как составить алгоритм

Шаг 1. Доработайте скетч для платы Arduino

  1. Возьмите за основу скетч turtlebro_panel_node из раздела «Управление роботом кнопками и launch-файл» и подключите заголовок <std_msgs/msg/Float32.h>.
  2. Замените одиночный пин светодиода на массив const int LED_PINS[4] = {48, 49, 50, 51}; и перенесите из урока 5 вспомогательную функцию void showLitCount(int count).
  3. Напишите обработчик подписки void onDistance(std_msgs::Float32 msg):
    • по цепочке if / else if / else переведите значение msg.data (в метрах) в число светодиодов level от 0 до 4 согласно таблице выше;
    • вызовите showLitCount(level);.
  4. В setup() настройте пины кнопок и четырёх светодиодов, погасите шкалу showLitCount(0), вызовите ros.begin(Serial1, "turtlebro_parktronic_node"), зарегистрируйте ros.advertise() для обеих кнопок и подписку ros.subscribe("panel/distance", onDistance).
  5. Загрузите скетч со своего компьютера через разъём DUE.

Шаг 2. Напишите Python-узел и launch-файл на Raspberry Pi

  1. Возьмите за основу скрипт ~/ros2_ws/panel_drive_node.py из урока (убрав из него публикацию в старый топик /panel/led).
  2. Добавьте в конструктор подписку на /scan (LaserScan, профиль qos_profile_sensor_data) и издателя /panel/distance (Float32) из опорного примера выше.
  3. Оставьте управление флагом self.moving и публикацией скорости в /cmd_vel только в обработчиках кнопок on_start и on_stop.
  4. Создайте ~/ros2_ws/parktronic.launch.py по образцу turtlebro_rosduino.launch.py, указав в нём путь ~/ros2_ws/parktronic_drive_node.py.

Как проверить результат

  1. Запустите систему на Raspberry Pi робота по SSH:
    ros2 launch ~/ros2_ws/parktronic.launch.py
    
  2. Проверка парктроника без движения: не нажимая кнопок, плавно приближайте ладонь к лидару с расстояния 1,2 м до 20 см. На плате последовательно загорятся один (D48), два (D48–D49), три (D48–D50) и все четыре светодиода (D48–D51). Уберите руку — светодиоды погаснут в обратном порядке.
  3. Проверка кнопок Старт и Стоп: поставьте робота на подставку (или на свободный пол) и нажмите кнопку D28 — колёса начнут вращаться вперёд (linear.x = 0.10 м/с), при этом шкала светодиодов продолжит в реальном времени показывать расстояние до препятствий.
  4. Нажмите кнопку D15 — колёса сразу остановятся (linear.x = 0.0 м/с), и робот останется на месте до следующего нажатия D28.

Посмотреть решение и разбор

Назад: Генерация собственных сообщений (rosduino_gen).
Дальше: Урок 8. Решение задания.

Урок 1. Решения заданий

На этой странице разобраны основное и дополнительное задания урока. Скетчи используют LED_BUILTIN. Сначала сравните своё решение с приведённым кодом, затем проверьте работу скетча на плате.

Основное задание

Чтобы светодиод горел одну секунду и следующую секунду оставался выключенным, задайте обе паузы по 1000 мс:

void setup() {
  // Встроенный светодиод платы подключён к LED_BUILTIN.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000);
}

В исходном скетче изменились только два значения: delay(200) заменено на delay(1000), а delay(800) — на delay(1000). Команды настройки пина и переключения светодиода остались прежними.

Как проверить решение

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

Дополнительное задание

Сигнал SOS состоит из трёх коротких вспышек, трёх длинных и ещё трёх коротких: ... --- ....

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

  • DOT_MS — длительность точки;
  • DASH_MS — длительность тире;
  • SYMBOL_GAP_MS — пауза после каждой вспышки;
  • WORD_GAP_MS — полная пауза между циклами SOS.
const int DOT_MS = 150;
const int DASH_MS = 500;
const int SYMBOL_GAP_MS = 150;
const int WORD_GAP_MS = 1500;

// Формирует одну вспышку и паузу между знаками.
void flashLed(int duration_ms) {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(duration_ms);
  digitalWrite(LED_BUILTIN, LOW);
  delay(SYMBOL_GAP_MS);
}

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

void loop() {
  for (int i = 0; i < 3; i++) {
    flashLed(DOT_MS);
  }

  for (int i = 0; i < 3; i++) {
    flashLed(DASH_MS);
  }

  for (int i = 0; i < 3; i++) {
    flashLed(DOT_MS);
  }

  // Последняя flashLed() уже выдержала SYMBOL_GAP_MS.
  delay(WORD_GAP_MS - SYMBOL_GAP_MS);
}

Как устроено решение

  1. Функция flashLed() включает светодиод на время duration_ms, выключает его и выдерживает паузу SYMBOL_GAP_MS. Благодаря этому команды одной вспышки не повторяются девять раз.
  2. Первый цикл for три раза вызывает flashLed(DOT_MS) и передаёт три точки — букву S.
  3. Второй цикл три раза вызывает flashLed(DASH_MS) и передаёт три тире — букву O.
  4. Третий цикл снова передаёт букву S.
  5. После последней вспышки функция уже выдержала паузу 150 мс. Поэтому перед новым циклом нужна дополнительная задержка 1500 - 150 = 1350 мс. Тогда полная пауза между циклами составит ровно 1500 мс.

Каждый цикл for повторяет вызов функции три раза. Если вы пока не разбираете циклы, их можно заменить последовательными вызовами: три раза flashLed(DOT_MS);, три раза flashLed(DASH_MS);, затем ещё три раза flashLed(DOT_MS);. Остальной код остаётся прежним.

Как проверить решение

  • На светодиоде последовательно появляются три короткие вспышки, три длинные и снова три короткие.
  • Между вспышками соблюдается пауза 150 мс.
  • От выключения последней вспышки до включения первой вспышки следующего цикла проходит 1500 мс.
  • Последовательность повторяется, пока плата включена.

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

  1. Что такое скетч?
    Скетч — это программа для платы Arduino.
  2. Зачем в Arduino IDE выбирать модель платы и порт?
    Модель платы сообщает Arduino IDE, для какого устройства нужно скомпилировать скетч. Через выбранный порт IDE загружает программу в подключённую плату.
  3. Сколько раз выполняется setup()?
    setup() выполняется один раз после включения платы или сброса. Затем многократно выполняется loop().
  4. Какая команда включает светодиод?
    Команда digitalWrite(LED_BUILTIN, HIGH) включает светодиод, а digitalWrite(LED_BUILTIN, LOW) выключает его.
  5. Что изменится, если заменить delay(200) на delay(1000), а остальной код оставить прежним?
    Светодиод будет гореть 1000 мс вместо 200 мс. Пауза 800 мс сохранится, поэтому полный цикл станет равен 1800 мс.

Назад: Домашнее задание.
Дальше: Урок 2. Светодиоды, кнопки и сервопривод.

Урок 2. Решение задания

На этой странице разобрано задание с плавным поворотом сервопривода. Сервопривод подключён к разъёму D2. Кнопка D28 поворачивает вал влево (к 0°), кнопка D15 — вправо (к 180°). В крайнем левом положении (0°) загорается светодиод D48, в крайнем правом (180°) — светодиод D51.

Полный код скетча

#include <Servo.h>

const int LEFT_BUTTON_PIN = 28;
const int RIGHT_BUTTON_PIN = 15;
const int SERVO_PIN = 2;
const int LEFT_LED_PIN = 48;
const int RIGHT_LED_PIN = 51;

const int STEP_DELAY_MS = 20;
const int CENTER_ANGLE = 90;
const int MIN_ANGLE = 0;
const int MAX_ANGLE = 180;

Servo servo;
int angle = CENTER_ANGLE;

// Включает светодиоды только в крайних положениях вала (0° и 180°).
void updateLeds() {
  if (angle == MIN_ANGLE) {
    digitalWrite(LEFT_LED_PIN, HIGH);
  } else {
    digitalWrite(LEFT_LED_PIN, LOW);
  }

  if (angle == MAX_ANGLE) {
    digitalWrite(RIGHT_LED_PIN, HIGH);
  } else {
    digitalWrite(RIGHT_LED_PIN, LOW);
  }
}

void setup() {
  pinMode(LEFT_BUTTON_PIN, INPUT);
  pinMode(RIGHT_BUTTON_PIN, INPUT);
  pinMode(LEFT_LED_PIN, OUTPUT);
  pinMode(RIGHT_LED_PIN, OUTPUT);

  servo.attach(SERVO_PIN);
  servo.write(angle);
  updateLeds();
}

void loop() {
  bool leftPressed = digitalRead(LEFT_BUTTON_PIN) == HIGH;
  bool rightPressed = digitalRead(RIGHT_BUTTON_PIN) == HIGH;

  if (leftPressed && !rightPressed && angle > MIN_ANGLE) {
    angle = angle - 1;
    servo.write(angle);
    delay(STEP_DELAY_MS);
  } else if (rightPressed && !leftPressed && angle < MAX_ANGLE) {
    angle = angle + 1;
    servo.write(angle);
    delay(STEP_DELAY_MS);
  }

  updateLeds();
}

Как устроено решение

  1. После запуска angle равен 90, поэтому оба условия angle == MIN_ANGLE и angle == MAX_ANGLE ложны, и оба светодиода погашены.
  2. В начале loop() считываются состояния обеих кнопок в логические переменные leftPressed и rightPressed.
  3. Шаг влево выполняется только тогда, когда нажата D28 (leftPressed), не нажата D15 (!rightPressed) и текущий угол больше 0. Шаг вправо — когда нажата только D15 и угол меньше 180. Если нажаты обе кнопки одновременно или обе отпущены, ни одно из условий не срабатывает, и угол остаётся прежним.
  4. Пауза 20 мс стоит внутри ветки шага. Пока кнопка удерживается, каждые 20 мс угол меняется на 1°. Полный поворот от середины (90°) до упора занимает около 1,8 с.
  5. Функция updateLeds() проверяет текущий угол на каждом проходе цикла: как только вал уходит с 0° на 1°, левый светодиод D48 сразу гаснет.

Как проверить решение

  1. При отключённом USB-кабеле проверьте подключение сервопривода к разъёму D2 и совпадение маркировки −, +, S с цветами проводов.
  2. Подключите плату и загрузите скетч. Вал должен встать в среднее положение (90°), оба светодиода погашены.
  3. Удерживайте кнопку D28. Вал плавно повернётся влево и остановится на 0°, после чего загорится светодиод D48.
  4. Отпустите кнопку — вал останется в положении 0°, а D48 продолжит гореть.
  5. Удерживайте кнопку D15. Светодиод D48 погаснет сразу после первого шага. Дойдя до 180°, вал остановится, и загорится светодиод D51.
  6. Попробуйте зажать обе кнопки во время движения — сервопривод должен остановиться.

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

  1. Почему нажатие кнопки на плате TurtleBro даёт уровень HIGH и почему в этих скетчах не используется режим INPUT_PULLUP?
    На плате TurtleBro кнопки уже снабжены внешними стягивающими резисторами к земле (GND), а при нажатии подают на пин напряжение питания (HIGH). Внутренняя подтяжка INPUT_PULLUP подтягивает вход к питанию внутри микроконтроллера, что мешало бы работе внешней схемы платы, поэтому используется режим INPUT.

  2. Какой параметр сигнала ШИМ определяет угол поворота сервопривода и почему в скетче не нужно формировать импульсы вручную?
    Угол определяется длительностью (шириной) управляющего импульса, который повторяется примерно каждые 20 мс. Вручную формировать импульсы не нужно, потому что эту работу выполняет библиотека Servo: в скетче достаточно передать желаемый угол в градусах вызовом servo.write().

  3. Каким цветам проводов сервопривода соответствуют контакты −, + и S на разъёме платы?
    Тёмный провод (коричневый или чёрный) подключается к − (GND), красный провод питания — к + (5 В), а светлый сигнальный провод (оранжевый, жёлтый или белый) — к S.

  4. Зачем при проверке кнопки ждать 30 мс после изменения сигнала и почему важно обновлять lastButtonState также при отпускании кнопки?
    За 30 мс механический дребезг контактов заканчивается, и повторное чтение пина подтверждает устойчивое состояние кнопки. Запоминать отпускание (LOW) в lastButtonState необходимо для того, чтобы при следующем нажатии программа снова увидела смену состояния с LOW на HIGH. Если не сохранять LOW при отпускании, в lastButtonState навсегда останется HIGH, и кнопка сработает только один раз.

  5. Почему силовую линию 5 В на разъёме сервопривода нельзя соединять с сигнальными пинами платы Arduino Due?
    Контакт + на разъёме сервопривода выдаёт 5 В для питания электродвигателя привода, тогда как логические входы микроконтроллера Arduino Due рассчитаны максимум на 3,3 В. Подача 5 В на пины Due может вывести микроконтроллер из строя.

Назад: Домашнее задание.
Дальше: Урок 3. Чтение данных, работа с Serial портом.

Урок 3. Решение задания

На этой странице разобрано решение задания «Счётчик нажатий со сбросом через Serial». Программа одновременно мигает светодиодом D48, считает нажатия кнопки D28 без дребезга и сбрасывает счётчик при получении символа '0' из утилиты мониторинга порта — и всё это без единого вызова delay().

Полный код скетча

const int BUTTON_PIN = 28;
const int LED_PIN = 48;

const unsigned long BLINK_PERIOD_MS = 500;
const unsigned long BUTTON_POLL_MS = 30;

int pressCount = 0;
int lastButtonState = LOW;
bool ledState = false;

unsigned long lastBlinkTime = 0;
unsigned long lastButtonTime = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  lastButtonState = digitalRead(BUTTON_PIN);

  Serial.begin(115200);
  Serial.println("Ready! Press D28 to count, send '0' to reset.");
}

void loop() {
  unsigned long now = millis();

  // Задача 1: мигание светодиода D48 каждые 500 мс.
  if (now - lastBlinkTime >= BLINK_PERIOD_MS) {
    lastBlinkTime = now;
    ledState = !ledState;
    digitalWrite(LED_PIN, ledState ? HIGH : LOW);
  }

  // Задача 2: опрос кнопки D28 каждые 30 мс (неблокирующая защита от дребезга).
  if (now - lastButtonTime >= BUTTON_POLL_MS) {
    lastButtonTime = now;
    int reading = digitalRead(BUTTON_PIN);

    if (reading != lastButtonState) {
      lastButtonState = reading;

      if (lastButtonState == HIGH) {
        pressCount++;
        Serial.print("Count: ");
        Serial.println(pressCount);
      }
    }
  }

  // Задача 3: мгновенный приём команды '0' из утилиты мониторинга порта.
  while (Serial.available() > 0) {
    char cmd = Serial.read();

    if (cmd == '0') {
      pressCount = 0;
      Serial.println("Counter reset to 0");
    }
  }
}

Как устроено решение

  1. Фоновое мигание (lastBlinkTime): каждые 500 мс переменная ledState меняет значение на противоположное, а светодиод D48 включается или выключается. Поскольку delay() не используется, проверка занимает всего несколько микросекунд.
  2. Неблокирующий антидребезг кнопки (lastButtonTime): в уроке 2 мы подавляли дребезг с помощью delay(30). Здесь тот же интервал 30 мс отсчитывается через millis(). Микроконтроллер считывает пин кнопки не чаще одного раза в 30 мс, поэтому быстрые колебания контактов остаются незамеченными, а основной цикл loop() ни на миллисекунду не останавливается.
  3. Сброс по команде '0': цикл while (Serial.available() > 0) забирает пришедшие символы из входного буфера. Если пришёл символ '0', переменная pressCount обнуляется, а символы перевода строки ('\n', '\r') просто игнорируются.

Как проверить решение

  1. Загрузите скетч в плату и откройте утилиту мониторинга порта (Монитор порта) на скорости 115200 baud.
  2. В окне появится приветственная строка Ready! Press D28 to count, send '0' to reset., а светодиод D48 на плате начнёт равномерно мигать.
  3. Нажмите кнопку D28 несколько раз. На каждое нажатие в утилите мониторинга порта сразу появится строка:
    Count: 1
    Count: 2
    Count: 3
    
  4. Введите в поле отправки утилиты мониторинга порта цифру 0 и нажмите Enter. В окне появится строка Counter reset to 0.
  5. Нажмите кнопку D28 ещё раз — счёт продолжится с Count: 1.

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

  1. Какое примерно значение вернёт analogRead(A8) при стандартной шкале 0–1023, если на вход подать напряжение 1,65 В? Что вернёт analogRead(A8), если к разъёму GPIO вообще не подключён датчик?
    Напряжение 1,65 В — это ровно половина от максимального напряжения 3,3 В, поэтому АЦП вернёт значение около середины шкалы: примерно 511–512. Если датчик не подключён, контакт остаётся неподключённым («плавающим»), улавливает случайные электрические наводки, и analogRead(A8) возвращает произвольные меняющиеся значения.

  2. Что произойдёт в окне утилиты мониторинга порта, если в скетче написано Serial.begin(115200), а в настройках утилиты выбрана скорость 9600 baud?
    Плата и компьютер будут использовать разную длительность одного бита при передаче, поэтому в окне утилиты мониторинга порта вместо читаемого текста появятся нечитаемые символы («кракозябры») или пустой вывод.

  3. Почему в программах для роботов нельзя использовать delay(1000) внутри loop() и какой конструкцией с millis() её заменяют?
    Во время delay(1000) микроконтроллер полностью приостанавливает выполнение цикла loop(): он не может опрашивать кнопки и датчики, не читает входящие команды из Serial и не обслуживает обмен данными с ROS 2. Вместо этого запоминают время последнего срабатывания lastTime и проверяют условие if (millis() - lastTime >= 1000).

  4. В чём разница между функциями map() и constrain()?
    Функция map() пропорционально пересчитывает значение из одного диапазона в другой (но не запрещает выход за границы, если входное значение вышло за пределы исходного диапазона), а функция constrain() жёстко ограничивает значение по заданному минимуму и максимуму.

Назад: Домашнее задание.
Дальше: Урок 4. Первый узел RosDuino.

Урок 4. Решение задания

На этой странице разобрано решение задания «Управление сервоприводом через топик». Узел /servo_driver_node принимает желаемый угол поворота из топика /servo_angle (std_msgs/msg/Int32), защищает сервопривод на разъёме D2 от выхода за пределы 0°–180° и сигнализирует о некорректных командах светодиодом D48.

Полный код скетча

#include <Servo.h>
#include <RosDuino.h>
#include <std_msgs/msg/Int32.h>

const int SERVO_PIN = 2;
const int ERROR_LED_PIN = 48;

const int MIN_ANGLE = 0;
const int MAX_ANGLE = 180;
const int START_ANGLE = 90;

Servo servo;

// Вызывается при получении нового угла из топика "servo_angle".
void onServoAngle(std_msgs::Int32 msg) {
  int requestedAngle = msg.data;

  if (requestedAngle < MIN_ANGLE || requestedAngle > MAX_ANGLE) {
    digitalWrite(ERROR_LED_PIN, HIGH);
  } else {
    digitalWrite(ERROR_LED_PIN, LOW);
  }

  int safeAngle = constrain(requestedAngle, MIN_ANGLE, MAX_ANGLE);
  servo.write(safeAngle);
}

void setup() {
  pinMode(ERROR_LED_PIN, OUTPUT);
  digitalWrite(ERROR_LED_PIN, LOW);

  servo.attach(SERVO_PIN);
  servo.write(START_ANGLE);

  ros.begin("servo_driver_node");
  ros.subscribe("servo_angle", onServoAngle);
}

void loop() {
  ros.update();
}

Как устроено решение

  1. Тип сообщения std_msgs::Int32: в отличие от логического Bool, сообщение Int32 передаёт знаковое целое число в поле msg.data. Поэтому оно может содержать как корректные углы (0..180), так и ошибочные отрицательные или слишком большие значения (-45, 250).
  2. Проверка границ (|| — логическое ИЛИ): условие requestedAngle < MIN_ANGLE || requestedAngle > MAX_ANGLE срабатывает, если нарушена хотя бы одна из двух границ. В этом случае зажигается светодиод ошибки D48. Как только в следующем сообщении приходит допустимый угол, ветка else гасит светодиод.
  3. Защита привода (constrain): функция constrain() обрезает любое значение меньше 0 до 0, а больше 180 — до 180. Благодаря этому на сервопривод никогда не подаётся команда за пределами его механического хода.

Как проверить решение

  1. Если rosduino_agent запущен в Терминале 1, остановите его клавишами Ctrl+C.
  2. Загрузите скетч в плату TurtleBro через Arduino IDE 2. Вал сервопривода встанет в среднее положение 90°, светодиод D48 погашен.
  3. Запустите агент в Терминале 1:
    ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
    
  4. В Терминале 2 проверьте узел и тип топика:
    ros2 node list
    # Вывод: /servo_driver_node
    
    ros2 topic info /servo_angle
    # Вывод:
    # Type: std_msgs/msg/Int32
    # Publisher count: 0
    # Subscription count: 1
    
  5. Протестируйте допустимые и выходящие за границы значения в Терминале 2:
    ros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: 45}"
    ros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: 220}"
    ros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: -30}"
    ros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: 90}"
    
    При отправке 220 и -30 светодиод D48 загорается, а вал останавливается на 180° и 0°. При отправке 45 и 90 светодиод D48 гаснет.

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

  1. Какие две части входят в систему RosDuino и какая из них работает на микроконтроллере, а какая — на компьютере с Ubuntu?
    На микроконтроллере работает библиотека rosduino_arduino (#include <RosDuino.h>), а на компьютере с Ubuntu — узел-агент rosduino_agent из пакета rosduino_ros.

  2. Почему в скетче с RosDuino нельзя одновременно использовать Serial.println() и держать открытой утилиту мониторинга порта в Arduino IDE?
    Потому что последовательный порт уже занят двоичным протоколом обмена между RosDuino и rosduino_agent. Посторонний текст из Serial.println() повредит пакеты данных, а открытая утилита мониторинга порта заблокирует доступ к порту для агента.

  3. Что нужно сделать в терминале с rosduino_agent перед тем, как нажать кнопку «Загрузить» в Arduino IDE?
    Нужно остановить rosduino_agent сочетанием клавиш Ctrl+C, чтобы освободить последовательный порт для загрузчика Arduino IDE.

  4. Как агент rosduino_agent узнаёт, какое имя узла и какой тип топика нужно создать в ROS 2?
    При установлении соединения плата сама передаёт агенту служебное сообщение с именем узла из ros.begin() и списком всех зарегистрированных топиков и сервисов, а тип топика в скетче автоматически определяется по типу аргумента функции-обработчика в ros.subscribe().

Назад: Домашнее задание.
Дальше: Урок 5. Топики в RosDuino.

Урок 5. Решение задания

На этой странице разобрано решение домашнего задания урока 5. Узел /board_monitor_node одновременно публикует аналоговый сигнал с разъёма GPIO A8 с частотой 10 Гц, отправляет события нажатия кнопки D28 и управляет шкалой из четырёх светодиодов D48–D51 по командам из топика /led_level.

Полный код скетча

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>
#include <std_msgs/msg/Int32.h>

const int SENSOR_PIN = A8;
const int BUTTON_PIN = 28;
const int LED_COUNT = 4;
const int LED_PINS[LED_COUNT] = {48, 49, 50, 51};

std_msgs::Int32 sensorMsg;
std_msgs::Bool buttonMsg;

rosduino::Timer sensorTimer(100);  // 10 Гц для аналогового сигнала
rosduino::Timer buttonTimer(30);   // 30 мс для опроса кнопки без дребезга

int lastButtonState = LOW;

// Включает первые count светодиодов массива и гасит остальные.
void showLitCount(int count) {
  for (int i = 0; i < LED_COUNT; i++) {
    if (i < count) {
      digitalWrite(LED_PINS[i], HIGH);
    } else {
      digitalWrite(LED_PINS[i], LOW);
    }
  }
}

// Обработчик команд из топика "/led_level".
void onLedLevel(std_msgs::Int32 msg) {
  int level = constrain(msg.data, 0, LED_COUNT);
  showLitCount(level);
}

void setup() {
  pinMode(BUTTON_PIN, INPUT);

  for (int i = 0; i < LED_COUNT; i++) {
    pinMode(LED_PINS[i], OUTPUT);
  }

  showLitCount(0);
  lastButtonState = digitalRead(BUTTON_PIN);

  ros.begin("board_monitor_node");
  ros.advertise("button_state", buttonMsg);
  ros.subscribe("led_level", onLedLevel);
}

void loop() {
  ros.update();

  // Задача 1: публикация аналогового сигнала каждые 100 мс (10 Гц).
  if (sensorTimer.check()) {
    sensorMsg.data = analogRead(SENSOR_PIN);
    ros.publish("sensor_value", sensorMsg);
  }

  // Задача 2: опрос кнопки каждые 30 мс и публикация при смене состояния.
  if (buttonTimer.check()) {
    int reading = digitalRead(BUTTON_PIN);

    if (reading != lastButtonState) {
      lastButtonState = reading;
      buttonMsg.data = (lastButtonState == HIGH);
      ros.publish("button_state", buttonMsg);
    }
  }
}

Как устроено решение

  1. Два независимых таймера rosduino::Timer: объект sensorTimer(100) отвечает за равномерную отправку значений analogRead(A8) 10 раз в секунду, а buttonTimer(30) считывает кнопку раз в 30 мс, отсекая механический дребезг контактов без остановки loop().
  2. Предварительная регистрация и экономия канала для кнопки: вызов ros.advertise("button_state", buttonMsg) в setup() создаёт топик /button_state сразу при подключении агента, не отправляя сообщение. А в loop() вызов ros.publish("button_state", buttonMsg) находится внутри проверки if (reading != lastButtonState): пакеты уходят в ROS 2 только в момент нажатия (true) и отпускания (false), причём самое первое нажатие доставляется без потерь.
  3. Управление линейкой светодиодов (onLedLevel): когда из ROS 2 приходит сообщение в топик /led_level, функция constrain(msg.data, 0, LED_COUNT) защищает программу от чисел меньше 0 и больше 4, а знакомая по уроку 2 функция showLitCount() включает нужное число светодиодов.

Как проверить решение

  1. Остановите rosduino_agent в Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент:
    ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
    
  2. Не нажимая кнопку D28, проверьте список топиков в Терминале 2 — благодаря ros.advertise() топик /button_state появляется сразу после подключения агента:
    ros2 topic list -t
    # Ожидаемые пользовательские топики:
    # /button_state [std_msgs/msg/Bool]
    # /led_level [std_msgs/msg/Int32]
    # /sensor_value [std_msgs/msg/Int32]
    
  3. Запустите просмотр ros2 topic echo /button_state и нажмите кнопку D28 — уже первое нажатие выведет data: true, а отпускание — data: false. Затем проверьте частоту публикации аналогового сигнала:
    ros2 topic hz /sensor_value
    
  4. Проверьте зажигание светодиодов D48–D51 командами из Терминала 2:
    ros2 topic pub --once /led_level std_msgs/msg/Int32 "{data: 1}"
    ros2 topic pub --once /led_level std_msgs/msg/Int32 "{data: 3}"
    ros2 topic pub --once /led_level std_msgs/msg/Int32 "{data: 4}"
    ros2 topic pub --once /led_level std_msgs/msg/Int32 "{data: 0}"
    

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

  1. Какую задачу решает класс rosduino::Timer и почему с ним не нужно вручную хранить переменную lastTime для millis()?
    Класс rosduino::Timer хранит интервал и время последнего срабатывания внутри самого объекта. Метод timer.check() сам сравнивает текущее время millis() с сохранённым и возвращает true, когда интервал истёк, поэтому код остаётся коротким и не блокирует ros.update().

  2. Что происходит при самом первом вызове ros.publish() без предварительной регистрации и зачем для кнопки в setup() вызывают ros.advertise()?
    Без предварительной регистрации первый вызов ros.publish("имя_топика", msg) только регистрирует издателя в агенте (по типу переменной msg), поэтому до этого вызова топика не видно в ros2 topic list, а само первое сообщение теряется. Для периодического датчика это не страшно, так как следом сразу идут новые измерения. Для кнопки же вызов ros.advertise("button", pressed) в setup() создаёт топик сразу при подключении агента без отправки сообщения, благодаря чему топик сразу виден в ROS 2 и первое нажатие не пропадает.

  3. Какой командой в терминале можно измерить фактическую частоту публикации сообщений в топике /sensor_percent?
    Командой ros2 topic hz /sensor_percent.

  4. Почему для события нажатия кнопки лучше вызывать ros.publish() только при смене состояния пина, а не отправлять поток сообщений при удержании или в каждом цикле loop()?
    При отправке в каждом loop() плата перегрузит последовательный порт сотнями одинаковых пакетов в секунду, а при отправке по таймеру во время удержания даже одно короткое нажатие породит несколько дублирующих сообщений подряд. Публикация только при смене состояния передаёт ровно одно сообщение в момент нажатия и одно в момент отпускания.

Назад: Домашнее задание.
Дальше: Урок 6. Сервисы в RosDuino.

Урок 6. Решение задания

На этой странице разобрано решение домашнего задания урока 6. Узел /safe_servo_node управляет сервоприводом на разъёме D2 с защитной блокировкой: разрешение на движение включается и выключается через сервис /set_drive_enable, светодиод D48 показывает состояние блокировки, а текущий угол раз в секунду публикуется в топик /current_angle.

Полный код скетча

#include <Servo.h>
#include <RosDuino.h>
#include <std_msgs/msg/Int32.h>
#include <std_srvs/srv/SetBool.h>

const int SERVO_PIN = 2;
const int STATUS_LED_PIN = 48;

const int MIN_ANGLE = 0;
const int MAX_ANGLE = 180;

Servo servo;
std_msgs::Int32 angleMsg;
rosduino::Timer telemetryTimer(1000);  // публикация угла (1 Гц)

bool driveEnabled = false;
int currentAngle = 90;

// Обработчик сервиса "/set_drive_enable".
void onSetDriveEnable(std_srvs::SetBool& srv) {
  driveEnabled = srv.request.data;
  digitalWrite(STATUS_LED_PIN, driveEnabled ? HIGH : LOW);

  srv.response.success = true;
  if (driveEnabled) {
    srv.response.message = "Drive enabled";
  } else {
    srv.response.message = "Drive disabled";
  }
}

// Обработчик целевого угла из топика "/target_angle".
void onTargetAngle(std_msgs::Int32 msg) {
  if (!driveEnabled) {
    return;
  }

  currentAngle = constrain(msg.data, MIN_ANGLE, MAX_ANGLE);
  servo.write(currentAngle);
}

void setup() {
  pinMode(STATUS_LED_PIN, OUTPUT);
  digitalWrite(STATUS_LED_PIN, LOW);

  servo.attach(SERVO_PIN);
  servo.write(currentAngle);

  ros.begin("safe_servo_node");
  ros.subscribe("target_angle", onTargetAngle);
  ros.service("set_drive_enable", onSetDriveEnable);
}

void loop() {
  ros.update();

  // Публикация текущего угла раз в секунду (1 Гц).
  if (telemetryTimer.check()) {
    angleMsg.data = currentAngle;
    ros.publish("current_angle", angleMsg);
  }
}

Как устроено решение

  1. Сервис как переключатель режима (onSetDriveEnable): команда включения или блокировки привода подаётся редко, но требует стопроцентной уверенности, что плата её приняла. Поэтому для неё выбран сервис std_srvs/srv/SetBool, который сразу меняет флаг driveEnabled, зажигает или гасит светодиод D48 и возвращает текстовое подтверждение.
  2. Топик для команд угла (onTargetAngle): целевой угол приходит через топик /target_angle. Если driveEnabled == false, функция сразу завершается (return;), не меняя currentAngle и не трогая сервопривод.
  3. Периодическая телеметрия (telemetryTimer): раз в секунду узел публикует фактический угол currentAngle в топик /current_angle, чтобы другие узлы ROS 2 всегда знали текущее положение механизма.

Как проверить решение

  1. Остановите rosduino_agent в Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент:
    ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
    
  2. Во втором окне терминала (Терминал 2) отправьте команду угла при заблокированном приводе:
    ros2 topic pub --once /target_angle std_msgs/msg/Int32 "{data: 30}"
    
    Вал не повернётся, а ros2 topic echo /current_angle --once по-прежнему покажет data: 90.
  3. Разблокируйте привод через сервис:
    ros2 service call /set_drive_enable std_srvs/srv/SetBool "{data: true}"
    
    Светодиод D48 загорится, а сервис вернёт success=True, message='Drive enabled'.
  4. Повторите отправку угла 30, а затем 150:
    ros2 topic pub --once /target_angle std_msgs/msg/Int32 "{data: 30}"
    ros2 topic pub --once /target_angle std_msgs/msg/Int32 "{data: 150}"
    
    Сервопривод повернётся в заданное положение, а топик /current_angle покажет data: 150.

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

  1. Зачем в ROS 2 нужны сервисы, если в системе уже есть топики, и как один сервис с входным параметром помогает избежать создания множества топиков?
    Сервис работает как удалённый вызов функции: клиент передаёт входные аргументы в request (например, номер кнопки, пина или числа для расчёта) и получает вычисленный результат в response. Благодаря передаче параметров один сервис может обслуживать сразу все кнопки или режимы платы, избавляя от необходимости создавать отдельный топик под каждый запрос и каждый ответ.

  2. Почему в обработчике сервера сервиса void onSetLed(std_srvs::SetBool& srv) параметр принимается по ссылке (&) и почему внутри этой функции нельзя делать долгие паузы?
    Передача по ссылке (&) позволяет функции записать результат прямо в поля srv.response, которые библиотека сразу после выхода из функции отправит клиенту. Долгие паузы внутри обработчика остановят вызов ros.update(), из-за чего плата перестанет принимать пакеты и сервис завершится ошибкой по тайм-ауту.

  3. Чем отличается роль платы при вызове ros.service() от её роли при вызове ros.call()?
    При использовании ros.service() плата выступает сервером сервиса (ждёт запросов от компьютера и выполняет их), а при вызове ros.call() плата выступает клиентом сервиса (сама отправляет запрос узлу ROS 2 на компьютере и получает от него ответ).

  4. Почему вызов ros.call("add_two_ints", adder, onSumAnswer) не останавливает работу loop() во время ожидания ответа от компьютера?
    Потому что ros.call() работает асинхронно: он лишь отправляет пакет запроса в порт и сразу возвращает управление в loop(). Когда ответ от компьютера приходит позже, библиотека сама обнаруживает его внутри ros.update() и вызывает функцию-обработчик onSumAnswer().

Назад: Домашнее задание.
Дальше: Урок 7. Диагностика, время и узлы на Python.

Урок 7. Решение задания

На этой странице разобрано решение домашнего задания урока 7. Плата TurtleBro работает со стандартной прошивкой ввода-вывода io_board, а вся математика — сглаживание сигнала скользящим средним по 5 точкам, расчёт угла сервопривода и проверка порога тревоги — выполняется в Python-узле smooth_servo_controller.py на компьютере.

1. Скетч на плате TurtleBro (io_board.ino)

Этот скетч уже был загружен в плату в практической части урока:

#include <Servo.h>
#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>
#include <std_msgs/msg/Int32.h>

const int SENSOR_PIN = A8;
const int LED_PIN = 48;
const int SERVO_PIN = 2;

Servo servo;
std_msgs::Int32 signalMsg;
rosduino::Timer sensorTimer(100);  // 10 Гц

void onLed(std_msgs::Bool msg) {
  digitalWrite(LED_PIN, msg.data ? HIGH : LOW);
}

void onServoAngle(std_msgs::Int32 msg) {
  int safeAngle = constrain(msg.data, 0, 180);
  servo.write(safeAngle);
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  servo.attach(SERVO_PIN);
  servo.write(90);

  ros.begin("io_board");
  ros.subscribe("led", onLed);
  ros.subscribe("servo_angle", onServoAngle);
}

void loop() {
  ros.update();

  if (sensorTimer.check()) {
    signalMsg.data = analogRead(SENSOR_PIN);
    ros.publish("analog_signal", signalMsg);
  }
}

2. Управляющий узел на Python (~/ros2_ws/smooth_servo_controller.py)

#!/usr/bin/env python3
from collections import deque

import rclpy
from rclpy.node import Node
from std_msgs.msg import Bool, Int32

WINDOW_SIZE = 5
ALARM_THRESHOLD = 700


class SmoothServoController(Node):
    def __init__(self):
        super().__init__('smooth_servo_controller')

        # Очередь из последних 5 измерений для расчёта скользящего среднего
        self.window = deque(maxlen=WINDOW_SIZE)
        self.last_alarm = None

        self.sub = self.create_subscription(
            Int32,
            '/analog_signal',
            self.on_sensor,
            10
        )

        self.servo_pub = self.create_publisher(Int32, '/servo_angle', 10)
        self.led_pub = self.create_publisher(Bool, '/led', 10)
        self.get_logger().info('Узел smooth_servo_controller запущен')

    def on_sensor(self, msg: Int32):
        # 1. Добавляем новое значение в окно и считаем среднее
        self.window.append(msg.data)
        avg_val = sum(self.window) / len(self.window)

        # 2. Переводим среднее (0..1023) в угол сервопривода (0..180)
        angle = int(avg_val * 180 / 1023)
        angle = max(0, min(180, angle))

        angle_msg = Int32()
        angle_msg.data = angle
        self.servo_pub.publish(angle_msg)

        # 3. Включаем светодиод D48 при превышении порога 700
        alarm = avg_val > ALARM_THRESHOLD
        if alarm != self.last_alarm:
            self.last_alarm = alarm
            led_msg = Bool()
            led_msg.data = alarm
            self.led_pub.publish(led_msg)

            if alarm:
                self.get_logger().warn(f'Порог превышен! Среднее={avg_val:.1f}, угол={angle}')
            else:
                self.get_logger().info(f'Сигнал в норме. Среднее={avg_val:.1f}, угол={angle}')


def main(args=None):
    rclpy.init(args=args)
    node = SmoothServoController()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

Как устроено решение

  1. Скользящее среднее (deque(maxlen=5)): когда в очередь self.window добавляется шестой элемент, самый старый первый элемент автоматически удаляется. Поэтому sum(self.window) / len(self.window) всегда возвращает среднее арифметическое за последние полсекунды (5 измерений по 100 мс), убирая резкие рывки сервопривода.
  2. Экономия команд для светодиода (self.last_alarm): угол сервопривода обновляется плавно при каждом измерении, а команда включения или выключения светодиода /led и запись в журнал отправляются только тогда, когда статус тревоги изменился.

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

  1. Какими пятью функциями объекта ros можно отправить текстовое сообщение с платы в системный журнал /rosout?
    Функциями ros.logDebug(), ros.logInfo(), ros.logWarn(), ros.logError() и ros.logFatal().

  2. Зачем нужна функция ros.now() и чем возвращаемое ею время отличается от millis()?
    Функция millis() отсчитывает миллисекунды с момента включения самой платы, тогда как ros.now() возвращает структуру builtin_interfaces::msg::Time (секунды и наносекунды), синхронизированную через rosduino_agent с системными часами компьютера ROS 2. Единое время позволяет узлам робота отбрасывать устаревшие сообщения, которые при задержке связи могли бы привести к аварии.

  3. Какой топик ROS 2 позволяет проверить связь платы с rosduino_agent и что в нём означает статус WARN? Стандартный диагностический топик /diagnostics. Статус WARN означает, что связь с платой временно потеряна (например, плата перезагружается или отключён кабель) либо одна из объявленных в скетче сущностей не зарегистрировалась.

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

  5. Зачем нужен launch-файл и какие два процесса запускает bringup.launch.py из этого урока? Launch-файл позволяет одной командой запустить связанные компоненты системы с согласованными параметрами. bringup.launch.py запускает узел rosduino_agent с выбранным последовательным портом и Python-скрипт light_controller.py.

Назад: Домашнее задание.
Дальше: Урок 8. Работа на роботе TurtleBro.

Урок 8. Решение задания

На этой странице приведено полное решение итогового задания курса: скетч светового парктроника с кнопками на плате TurtleBro, управляющий Python-узел parktronic_drive_node.py для чтения лидара /scan и управления движением /cmd_vel, а также файл единого запуска parktronic.launch.py.

1. Скетч на плате TurtleBro (turtlebro_parktronic_node.ino)

Загрузите этот скетч в плату робота со своего компьютера через разъём DUE:

#include <RosDuino.h>
#include <std_msgs/msg/Bool.h>
#include <std_msgs/msg/Float32.h>

const int START_BTN_PIN = 28;
const int STOP_BTN_PIN = 15;
const int LED_COUNT = 4;
const int LED_PINS[LED_COUNT] = {48, 49, 50, 51};

std_msgs::Bool btnMsg;
rosduino::Timer buttonTimer(30);  // 30 мс для защиты кнопок от дребезга

int lastStartState = LOW;
int lastStopState = LOW;

// Зажигает первые count светодиодов шкалы и гасит остальные.
void showLitCount(int count) {
  for (int i = 0; i < LED_COUNT; i++) {
    digitalWrite(LED_PINS[i], (i < count) ? HIGH : LOW);
  }
}

// Переводит минимальную дистанцию лидара (в метрах) в число светодиодов 0..4.
void onDistance(std_msgs::Float32 msg) {
  float d = msg.data;
  int level = 0;

  if (d < 0.30f) {
    level = 4;
  } else if (d < 0.50f) {
    level = 3;
  } else if (d < 0.70f) {
    level = 2;
  } else if (d < 1.00f) {
    level = 1;
  } else {
    level = 0;
  }

  showLitCount(level);
}

void setup() {
  pinMode(START_BTN_PIN, INPUT);
  pinMode(STOP_BTN_PIN, INPUT);

  for (int i = 0; i < LED_COUNT; i++) {
    pinMode(LED_PINS[i], OUTPUT);
  }
  showLitCount(0);

  lastStartState = digitalRead(START_BTN_PIN);
  lastStopState = digitalRead(STOP_BTN_PIN);

  // На роботе связь с Raspberry Pi идёт через аппаратный порт Serial1.
  ros.begin(Serial1, "turtlebro_parktronic_node");
  ros.advertise("panel/btn_start", btnMsg);
  ros.advertise("panel/btn_stop", btnMsg);
  ros.subscribe("panel/distance", onDistance);
}

void loop() {
  ros.update();

  if (buttonTimer.check()) {
    int startReading = digitalRead(START_BTN_PIN);
    if (startReading != lastStartState) {
      lastStartState = startReading;
      btnMsg.data = (lastStartState == HIGH);
      ros.publish("panel/btn_start", btnMsg);
    }

    int stopReading = digitalRead(STOP_BTN_PIN);
    if (stopReading != lastStopState) {
      lastStopState = stopReading;
      btnMsg.data = (lastStopState == HIGH);
      ros.publish("panel/btn_stop", btnMsg);
    }
  }
}

2. Управляющий Python-узел (~/ros2_ws/parktronic_drive_node.py)

Создайте этот файл на Raspberry Pi робота:

#!/usr/bin/env python3
import math
import rclpy
from geometry_msgs.msg import Twist
from rclpy.node import Node
from rclpy.qos import qos_profile_sensor_data
from sensor_msgs.msg import LaserScan
from std_msgs.msg import Bool, Float32

FORWARD_SPEED = 0.10  # скорость движения вперёд, м/с


class ParktronicDriveNode(Node):
    def __init__(self):
        super().__init__('parktronic_drive_node')
        self.moving = False

        # Подписки на кнопки платы и штатный топик лидара /scan
        self.create_subscription(Bool, '/panel/btn_start', self.on_start, 10)
        self.create_subscription(Bool, '/panel/btn_stop', self.on_stop, 10)
        self.create_subscription(
            LaserScan,
            '/scan',
            self.on_scan,
            qos_profile_sensor_data
        )

        # Издатели: минимальная дистанция для платы и скорость робота /cmd_vel
        self.dist_pub = self.create_publisher(Float32, '/panel/distance', 10)
        self.cmd_vel_pub = self.create_publisher(Twist, '/cmd_vel', 10)

        # Таймер 10 Гц для регулярной публикации скорости во время движения
        self.create_timer(0.1, self.publish_velocity)
        self.get_logger().info(
            'Узел parktronic_drive_node запущен. D28 — старт, D15 — стоп.'
        )

    def on_scan(self, msg: LaserScan):
        valid = [
            r for r in msg.ranges
            if math.isfinite(r) and msg.range_min < r < msg.range_max
        ]
        if not valid:
            return

        dist_msg = Float32()
        dist_msg.data = float(min(valid))
        self.dist_pub.publish(dist_msg)

    def on_start(self, msg: Bool):
        if msg.data and not self.moving:
            self.moving = True
            self.get_logger().info('Кнопка Старт (D28): начинаем движение вперёд')

    def on_stop(self, msg: Bool):
        if msg.data and self.moving:
            self.moving = False
            self.cmd_vel_pub.publish(Twist())
            self.get_logger().warn('Кнопка Стоп (D15): остановка робота!')

    def publish_velocity(self):
        if self.moving:
            cmd = Twist()
            cmd.linear.x = FORWARD_SPEED
            self.cmd_vel_pub.publish(cmd)


def main(args=None):
    rclpy.init(args=args)
    node = ParktronicDriveNode()
    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.cmd_vel_pub.publish(Twist())
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

3. Launch-файл (~/ros2_ws/parktronic.launch.py)

import os
from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument, ExecuteProcess
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node


def generate_launch_description():
    port_arg = DeclareLaunchArgument(
        'port',
        default_value='/dev/serial/by-id/usb-Silicon_Labs_CP2102N_USB_to_UART_Bridge_Controller_0010-if00-port0',
        description='Порт моста Serial1 пользовательского МК Arduino на роботе TurtleBro'
    )

    agent_node = Node(
        package='rosduino_agent',
        executable='rosduino_agent',
        name='rosduino_agent',
        output='screen',
        parameters=[{
            'port': LaunchConfiguration('port'),
            'baud': 115200,
            'keep_on_disconnect': True,
        }]
    )

    script_path = os.path.expanduser('~/ros2_ws/parktronic_drive_node.py')
    drive_controller = ExecuteProcess(
        cmd=['python3', script_path],
        output='screen'
    )

    return LaunchDescription([
        port_arg,
        agent_node,
        drive_controller,
    ])

Как устроено решение

  1. Сжатие данных лидара для микроконтроллера (/scan → /panel/distance): сообщение sensor_msgs/msg/LaserScan содержит сотни чисел с плавающей точкой, которые избыточны для индикации на плате. Python-узел на Raspberry Pi отбрасывает некорректные лучи за пределами (msg.range_min, msg.range_max), находит одно минимальное число min(valid) и передаёт его в компактном сообщении std_msgs/msg/Float32 (всего 4 байта).
  2. Шкала парктроника на стороне Arduino (onDistance): плата принимает расстояние в метрах и через функцию showLitCount() включает от 0 до 4 светодиодов D48–D51. Индикация работает непрерывно даже тогда, когда робот стоит на месте.
  3. Надёжный старт и стоп по кнопкам: благодаря вызовам ros.advertise() в setup() топики /panel/btn_start и /panel/btn_stop создаются сразу при запуске агента, поэтому и старт по кнопке D28, и остановка по кнопке D15 срабатывают с первого нажатия. При получении сигнала «Стоп» (а также при остановке скрипта по Ctrl+C) в /cmd_vel сразу отправляется пустое сообщение Twist() с нулевой скоростью.

Как проверить решение

  1. Загрузите скетч в плату через разъём DUE, затем по SSH запустите связку на Raspberry Pi:
    ros2 launch ~/ros2_ws/parktronic.launch.py
    
  2. Поднесите ладонь к лидару и плавно меняйте расстояние от 1 м до 20 см — светодиоды D48–D51 на плате будут загораться и гаснуть ступенями от 0 до 4.
  3. Поставьте робота на подставку и нажмите кнопку D28 — колёса начнут плавно вращаться вперёд (linear.x = 0.10), а светодиоды продолжат показывать дистанцию по лидару.
  4. Нажмите кнопку D15 — колёса мгновенно остановятся (linear.x = 0.0).

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

  1. Какие два микроконтроллера установлены на плате робота TurtleBro и почему загрузка собственного скетча в Arduino Due не может нарушить работу приводов шасси?
    На плате установлены системный микроконтроллер STM32F4 (отвечает за колёса, энкодеры, IMU и базовые топики движения) и пользовательский микроконтроллер Arduino Due (отвечает за кнопки, светодиоды, сервоприводы и разъёмы GPIO). Они работают независимо и подключены к разным USB-портам, поэтому прошивка Arduino Due никак не затрагивает программу управления шасси.

  2. Через какой порт микроконтроллера (Serial или Serial1) плата общается с Raspberry Pi на роботе и почему при прошивке с компьютера через разъём DUE не нужно переключать провода?
    На роботе связь микроконтроллера с Raspberry Pi разведена на плате через второй аппаратный порт Serial1 (ros.begin(Serial1, "имя_узла")), а разъём USB-C с надписью DUE (Serial, Programming Port) используется только для загрузки скетчей с компьютера. Поскольку это два разных независимых порта, переключать провода или останавливать агент на роботе во время прошивки не нужно.

  3. В какой штатный топик робота TurtleBro нужно публиковать сообщения geometry_msgs/msg/Twist, чтобы управлять его движением?
    В топик /cmd_vel (twist.linear.x задаёт линейную скорость вперёд/назад в м/с, а twist.angular.z — угловую скорость поворота в рад/с).

  4. Какой командой с помощью rosduino-gen можно создать заголовочные файлы для Arduino из собственного пакета сообщений my_robot_msgs?
    Командой ros2 run rosduino_gen rosduino-gen --package my_robot_msgs --out "$HOME/Arduino/libraries/RosDuino/src".

Назад: Домашнее задание.