Введение
Этот курс учит работать с платой робота 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» и дальше подставляйте пины самостоятельно, исходя из задания. Обычно достаточно поменять номера пинов в константах в начале скетча.
Проекты и инструменты
В курсе используются:
- плата TurtleBro и Arduino IDE 2;
- ROS 2 на компьютере с Ubuntu, а в последнем уроке — на компьютере робота;
rosduino_arduino(инструкция на русском) — библиотека RosDuino для микроконтроллера;rosduino_ros(инструкция на русском) — агентrosduino_agentи инструменты RosDuino на стороне ROS 2.
Траектория курса
Восемь уроков идут от первого скетча до работы на роботе.
Этап 1. Плата TurtleBro по USB
- Подготовка рабочего места. Arduino IDE 2 в Windows или Ubuntu, выбор Arduino Due, установка библиотеки RosDuino и первый скетч на
LED_BUILTIN. - Светодиоды, кнопки и сервопривод. Светодиоды и кнопки платы, очередь включения светодиодов и сервопривод на штатных пинах подключения.
- Чтение данных, работа с Serial портом. Чтение аналогового сигнала, утилита мониторинга порта, плоттер графиков и замена блокирующего
delay()неблокирующей логикой.
На этом этапе ROS 2 не нужен. Плата TurtleBro работает как обычная плата Arduino, подключённая по USB.
Этап 2. Агент на компьютере с Ubuntu
- Первый узел RosDuino. Установка
rosduino_agentна компьютер с Ubuntu и связь с платой по USB. - Топики в RosDuino. Публикация данных и приём команд без блокировки основного цикла.
- Сервисы в RosDuino. Работа платы в роли сервера сервиса (
ros.service()) и клиента сервиса (ros.call()). - Диагностика, время и узлы на Python. Журнал
/rosout, синхронизация времениros.now(), управляющий узел на Python и запуск через launch-файл.
Плата по-прежнему подключена к компьютеру кабелем USB. Агент работает на этом компьютере, а не на роботе.
Этап 3. Агент на роботе
- TurtleBro. Установка
rosduino_agentна Raspberry Pi робота и совместная работа со штатными топиками. Справочные материалы по платформе приведены в документации TurtleBro.
Как устроены уроки
Каждый урок содержит:
- описание задания и список того, что нужно подготовить;
- теорию, которая нужна для практики;
- таблицу пинов, если пример использует контакты платы;
- полный скетч, который можно собрать и запустить;
- пошаговую проверку результата;
- вопросы для самопроверки;
- самостоятельное задание и ссылку на разбор решения.
В уроке 1 установка для Windows и Linux вынесена на отдельные страницы. Сначала прочитайте общую часть, затем выберите свою операционную систему. После настройки платы установите библиотеку RosDuino и перейдите к первому скетчу.
Как работать с курсом
Проверяйте результат каждого урока
Переходите к следующему уроку только после успешной проверки текущего результата. Если скетч не загружается в уроке 1, следующие примеры только усложнят поиск причины. Если связь с агентом нестабильна, сначала восстановите её и только затем запускайте управляющий узел.
Изменяйте по одному параметру
Сначала соберите и проверьте приведённый пример без изменений. После успешного запуска меняйте только один параметр за раз: номер пина, длительность паузы или порог. Так проще понять, какое изменение привело к новому результату.
Проверяйте систему по уровням
Когда в курсе появляется агент, проверяйте каждый уровень по очереди:
- Скетч компилируется и работает на плате.
- Последовательный порт доступен.
- Агент
rosduino_agentустановил соединение. - Узел и топики видны командами ROS 2.
- Управляющая программа получает данные и отправляет команды.
Если плата ещё не видна в ROS 2, не ищите причину в Python-узле: сначала убедитесь, что предыдущие уровни работают.
Фиксируйте ошибки
Сообщения компилятора, имя порта и журнал агента помогают найти причину. Запишите, на каком шаге возникла ошибка и какое сообщение вывел инструмент.
Для этого полезно вести короткий журнал:
- версия платы TurtleBro и выбранный пункт в Arduino IDE;
- имя порта;
- версии пакета плат и библиотеки;
- ожидаемый результат;
- фактический результат;
- полный текст ошибки.
Сначала решайте самостоятельно
Готовое решение помогает сравнить подходы, но не заменяет практику. Сначала составьте алгоритм и попробуйте написать скетч самостоятельно. Если решение не получается, сравните отдельный фрагмент с разбором, исправьте свою версию и снова проверьте плату.
Обозначения в командах
В уроках с ROS 2 несколько процессов работают одновременно:
- Терминал 1 — агент
rosduino_agent; - Терминал 2 — команды ROS 2 для просмотра топиков, публикации сообщений и вызова сервисов.
Команды приводятся без символа $, чтобы их можно было скопировать целиком.
Пока вы проверяете топики и сервисы в Терминале 2, агент rosduino_agent должен продолжать работать в Терминале 1.
Безопасность
Перед тем как подключить или отключить сервопривод от разъёма на плате, остановите скетч и отключите USB. Сверьте маркировку −, +, S с цветами проводов и только затем подавайте питание.
Соблюдайте четыре правила:
- Не подавайте
5 Вна цифровые и аналоговые входы: Arduino Due рассчитана на3,3 В. - Не соединяйте линию
5 Вразъёма сервопривода с пинами питания сигнальной части платы. - Подключайте сервопривод только к штатному разъёму сервопривода и проверяйте порядок
−,+,S. - Перед загрузкой скетча остановите процесс, который занимает тот же последовательный порт. В уроках с 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 | rosduino/rosduino_arduino (релизы .zip) | Описание библиотеки (README_RU.md)Разбор всех скетчей ( docs/examples_RU.md)Каталог примеров examples/ |
| Пакеты для ROS 2 | rosduino/rosduino_ros | Обзор и установка (README_RU.md)Узел-агент rosduino_agentГенератор заголовков rosduino_genСписок встроенных типов ( arduino_types.txt) |
Все примеры ниже также доступны прямо в меню Arduino IDE: Файл → Примеры → RosDuino.
Как устроена работа RosDuino
Система состоит из двух частей, соединённых по последовательному порту USB (115200 бод):
- Библиотека
rosduino_arduinoна плате (#include <RosDuino.h>): превращает плату в узел ROS 2. Скетч объявляет имя узла вros.begin("имя_узла"), а вloop()вызываетros.update(). Подробная установка разобрана в уроке 1. - Узел
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
- Не используйте
Serial.print()и держите закрытой утилиту мониторинга порта в Arduino IDE — порт занят протоколомRosDuino. - Останавливайте агент (
Ctrl+C) перед загрузкой нового скетча в плату. - Не используйте
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 v2 | TurtleBro v1 |
|---|---|---|
| Цвет платы | Жёлтая | Синяя |
| Плата Arduino | Arduino Due | Arduino Mega 2560 |
| Пункт в Arduino IDE | Arduino Due (Programming Port) | Arduino Mega or Mega 2560 |
| Пакет плат | Arduino SAM Boards (32-bits ARM Cortex-M3) | Arduino AVR Boards |
| Логические уровни | 3,3 В | 5 В |
analogRead() | 0–1023 | 0–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 |
| Разъёмы GPIO | A8, 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
- В Arduino IDE выберите Arduino Mega or Mega 2560.
- В начале скетча замените номера пинов в константах по таблице ниже. Логику программы, длительности пауз и имена топиков оставьте без изменений.
- Скетч урока 1 со светодиодом
LED_BUILTINменять не нужно — достаточно выбрать плату Mega в меню IDE.
| В коде курса (v2, Due) | На синей плате (v1, Mega) | Назначение в примерах |
|---|---|---|
D28 | D23 | Первая кнопка |
D15 | D24 | Вторая кнопка |
D16 | D25 | Первый переключатель |
D29 | D22 | Второй переключатель |
D48 | D26 | Первый светодиод |
D49 | D27 | Второй светодиод |
D50 | D28 | Третий светодиод |
D51 | D29 | Четвёртый светодиод |
D2 | D46 | Первый разъём сервопривода |
D3 | D45 | Второй разъём сервопривода |
D4 | D44 | Третий разъём сервопривода |
A8 | A12 | Первый разъём GPIO |
A7 | A12 | Второй разъём GPIO (в документации v1 номер повторён) |
A6 | A14 | Третий разъём 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 Due (Programming Port). Подключайте USB-кабель к разъёму USB-C с надписью DUE.
Некоторые USB-кабели предназначены только для зарядки. С таким кабелем плата получит питание, но компьютер не сможет загрузить в неё скетч. Если плата не появляется в списке портов, прежде всего попробуйте другой USB-кабель.
Не подавайте на них 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, но библиотеку мы установим сейчас, как часть подготовки рабочего места.
Порядок работы
- Установите Arduino IDE 2 для своей операционной системы.
- Установите пакет плат
Arduino SAM Boards (32-bits ARM Cortex-M3)для поддержки Arduino Due. - Подключите плату и выберите Arduino Due (Programming Port) и порт.
- Установите библиотеку RosDuino через менеджер библиотек.
- Загрузите первый скетч и убедитесь, что светодиод
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
- Запустите скачанный файл
.msi. - Разрешите установку драйверов USB: они нужны компьютеру для связи с платой.
- Дождитесь завершения установки и откройте Arduino IDE 2.
- При первом запуске дождитесь, пока среда загрузит базовые индексы пакетов.
3. Установите поддержку платы Arduino Due
В чистой установке Arduino IDE 2 поддержка Arduino Due не включена по умолчанию — её нужно установить через менеджер плат:
- Откройте Инструменты → Плата → Менеджер плат (
Tools → Board → Boards Manager) или нажмите на значок платы на левой боковой панели. - В поле поиска введите
Arduino SAM Boards. - Найдите пакет Arduino SAM Boards (32-bits ARM Cortex-M3) от Arduino и нажмите Установить (
Install). - Дождитесь окончания загрузки и установки пакета.
4. Подключите плату и найдите порт
Соедините плату TurtleBro с компьютером USB-кабелем. Подключайте его к разъёму USB-C с надписью DUE.
Последовательный порт — это подключение, через которое компьютер обменивается данными с платой. В Windows его имя начинается с COM, например COM3 или COM4.
Чтобы найти порт:
- Нажмите клавиши
Win+Xи выберите «Диспетчер устройств». - Разверните раздел «Порты (COM и LPT)».
- Найдите новый порт
COMx(обычно он подписывается какArduino Due Programming PortилиUSB Serial Device). Номер порта на вашем компьютере может отличаться от примеров в курсе.
Если порт не появился, отключите кабель и подключите его снова. Затем попробуйте другой USB-кабель. Если рядом с устройством отображается жёлтый предупреждающий значок, воспользуйтесь справочным материалом ниже.
5. Выберите плату и порт в Arduino IDE
- Откройте Инструменты → Плата → Arduino SAM Boards (32-bits ARM Cortex-M3) и выберите Arduino Due (Programming Port).
- Откройте Инструменты → Порт (
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— драйвер WCHCH341SER.
После установки драйвера отключите кабель и подключите его снова. Затем повторите проверку порта в «Диспетчере устройств» и в 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 не установлен — добавьте его через менеджер плат:
- В Arduino IDE откройте Инструменты → Плата → Менеджер плат (
Tools → Board → Boards Manager) или нажмите на значок платы на левой панели. - В поле поиска введите
Arduino SAM Boards. - Найдите пакет Arduino SAM Boards (32-bits ARM Cortex-M3) от Arduino и нажмите Установить (
Install). - Дождитесь завершения установки.
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-кабель. Способ проверки порта через терминал приведён в справочном материале.
- Откройте Инструменты → Плата → Arduino SAM Boards (32-bits ARM Cortex-M3) и выберите Arduino Due (Programming Port).
- Откройте Инструменты → Порт (
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. Установка через менеджер библиотек
- В Arduino IDE 2 откройте менеджер библиотек. Его значок находится на левой панели. Тот же список открывается через Инструменты → Менеджер библиотек (
Tools → Manage Libraries). - В строке поиска введите
RosDuino. - В результатах выберите библиотеку RosDuino и нажмите Установить (
Install). - Дождитесь окончания загрузки.
Менеджер сам поместит файлы библиотеки в папку библиотек Arduino. Вручную копировать каталоги не нужно.
2. Проверьте, что библиотека видна
Откройте Файл → Примеры (File → Examples). В списке должен появиться раздел RosDuino.
Раздел RosDuino есть в списке примеров. Открывать и загружать эти примеры пока не нужно: первый скетч урока их не использует.
Если раздел появился, переходите к загрузке первой программы. Если поиск ничего не находит или установка заканчивается ошибкой сети, воспользуйтесь одним из запасных способов в справочном материале ниже.
Справочный материал: альтернативные способы установки
Этот раздел можно пропустить, если вы уже установили библиотеку через менеджер библиотек. Используйте один из двух способов ниже только в том случае, если основной способ не сработал.
Способ А. Установка из архива ZIP
- Откройте релизы репозитория
rosduino/rosduino_arduinoи скачайте архив видаRosDuino-x.y.z.zip. - В Arduino IDE откройте Скетч → Подключить библиотеку → Добавить .ZIP-библиотеку (
Sketch → Include Library → Add .ZIP Library). - Укажите скачанный архив и дождитесь сообщения об установке.
- Откройте Файл → Примеры и убедитесь, что раздел 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() многократно выполняет последовательность: включить, подождать, выключить, подождать.
Вопросы для самопроверки
- Что такое скетч?
- Зачем в Arduino IDE выбирать модель платы и порт?
- Сколько раз выполняется
setup()? - Какая команда включает светодиод?
- Что изменится, если заменить
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.
Основное задание
Измените скетч «Маячок» так, чтобы светодиод горел одну секунду и следующую секунду оставался выключенным.
Порядок работы
- Откройте скетч, который вы загрузили на предыдущей странице.
- Найдите две команды
delay(): одна задаёт длительность свечения, другая — длительность паузы. - До изменения кода попробуйте предположить, какие значения понадобятся для интервалов в одну секунду.
- Измените скетч, нажмите Проверить, а затем Загрузить.
Одна секунда равна 1000 мс. Изменить нужно только длительности двух пауз; команды включения и выключения светодиода остаются прежними.
Как проверить результат
- Скетч компилируется и загружается без ошибок.
- Светодиод горит примерно одну секунду.
- Затем светодиод остаётся выключенным примерно одну секунду.
- Этот цикл повторяется, пока плата включена.
Дополнительное задание
Напишите скетч, который передаёт международный сигнал бедствия SOS (... --- ...) с помощью встроенного светодиода LED_BUILTIN. Вы научитесь объединять вспышки разной длительности в последовательность и выносить повторяющиеся команды в собственную функцию.
Дополнительные компоненты не понадобятся: светодиод LED_BUILTIN уже есть на плате. Номера D48–D51 в этом задании не используются.
Если создание функций пока кажется сложным, используйте справочный материал ниже или отложите дополнительное задание и вернитесь к нему позже.
Требования
- Буква
Sпередаётся тремя короткими вспышками. Каждая вспышка длится 150 мс, пауза после неё — 150 мс. - Буква
Oпередаётся тремя длинными вспышками. Каждая вспышка длится 500 мс, пауза после неё — 150 мс. - После буквы
Oснова передаётся букваS. - От выключения последней вспышки до включения первой вспышки следующего цикла должно пройти 1500 мс.
- Создайте функцию
void flashLed(int duration_ms). Не копируйте парыdigitalWrite()иdelay()вloop()девять раз.
Как составить алгоритм
- Опишите одну вспышку: включить светодиод, выдержать заданное время, выключить его и сделать короткую паузу.
- Вызовите функцию три раза для коротких вспышек
S. - Вызовите её три раза для длинных вспышек
O. - Повторите три короткие вспышки
S. - Добавьте оставшуюся часть длинной паузы перед новым циклом.
Как проверить результат
- Скетч компилируется и загружается без ошибок.
- Функция
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 с цветами проводов и только затем подавайте питание.
План урока
- Светодиод на плате — управление светодиодом
D48. - Кнопки и очередь светодиодов — чтение кнопки, защита от дребезга и массив пинов
D48–D51. - Управление сервоприводом — подключение к разъёму
D2и поворот между0°и90°. - Домашнее задание — плавный поворот вала кнопками и индикация упоров.
Назад: Домашнее задание.
Дальше: Светодиод на плате.
Светодиод на плате
В уроке 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.
Здесь возникает физическая особенность любой механической кнопки — дребезг контактов. В момент нажатия или отпускания металлические пластины внутри кнопки несколько миллисекунд соударяются, быстро замыкая и размыкая цепь. Вы нажали кнопку один раз, а микроконтроллер успевает увидеть несколько переключений подряд.
Чтобы избавиться от дребезга:
- Программа хранит последнее подтверждённое состояние кнопки в переменной
lastButtonState. - Если новое чтение пина отличается от
lastButtonState(оператор!=означает «не равно»), программа ждёт30 мси считывает пин повторно. - Если после паузы новое состояние сохранилось, мы обновляем
lastButtonState. - Если подтверждённое состояние равно
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, и следующее нажатие программа уже не заметит.
Короткая пауза 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 записаны три шага:
int i = 0— создаём счётчикiи начинаем с нулевого индекса;i < LED_COUNT— повторяем цикл, пока индекс меньше4(то есть для0,1,2и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.
Неправильная ориентация разъёма может вывести из строя сервопривод или плату. Сначала отключите 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 |
Вопросы для самопроверки
- Почему нажатие кнопки на плате TurtleBro даёт уровень
HIGHи почему в этих скетчах не используется режимINPUT_PULLUP? - Какой параметр сигнала ШИМ определяет угол поворота сервопривода и почему в скетче не нужно формировать импульсы вручную?
- Каким цветам проводов сервопривода соответствуют контакты
−,+иSна разъёме платы? - Зачем при проверке кнопки ждать 30 мс после изменения сигнала и почему важно обновлять
lastButtonStateтакже при отпускании кнопки? - Почему силовую линию
5 Вна разъёме сервопривода нельзя соединять с сигнальными пинами платы Arduino Due?
Справочный материал: как устроен сервопривод
Внутри корпуса обычного хоббийного сервопривода находятся электродвигатель постоянного тока, редуктор, датчик угла поворота (потенциометр) и небольшая плата управления. Плата управления непрерывно сравнивает текущий угол вала с длительностью приходящего ШИМ-импульса и вращает мотор до тех пор, пока вал не займёт нужное положение. Если валу физически мешать повернуться, мотор будет пытаться преодолеть препятствие, а потребляемый ток резко вырастет — именно поэтому заблокированный и гудящий привод нужно сразу обесточить.
Назад: Кнопки и очередь светодиодов.
Дальше: Домашнее задание.
Домашнее задание
В практической части кнопка сразу переводила сервопривод из 0° в 90°. Теперь напишите программу, в которой сервопривод начинает работу со среднего положения 90°, плавно поворачивается влево при удержании кнопки D28 и вправо при удержании кнопки D15, а в крайних положениях зажигает светодиоды D48 и D51.
Сервопривод остаётся подключённым к разъёму D2 с тем же порядком проводов −, +, S.
Требования к работе устройства
- После включения или перезагрузки платы сервопривод устанавливается в среднее положение
90°, а светодиодыD48иD51погашены. - Пока удерживается кнопка
D28и отпущенаD15, угол уменьшается на1°за шаг (поворот влево). Дойдя до0°, сервопривод останавливается. - Пока удерживается кнопка
D15и отпущенаD28, угол увеличивается на1°за шаг (поворот вправо). Дойдя до180°, сервопривод останавливается. - Пауза между шагами составляет
20 мс— благодаря этому вал поворачивается плавно. - Если отпущены обе кнопки или нажаты обе кнопки одновременно, текущий угол не меняется.
- В крайнем левом положении (
0°) горит светодиодD48. В крайнем правом положении (180°) горит светодиодD51. На всех промежуточных углах (1°–179°) оба светодиода выключены.
Требования к программе
- Кнопки настроены как
INPUT, нажатию соответствует уровеньHIGH. - Текущий угол хранится в переменной (например,
int angle = 90;). - За один шаг угол изменяется на
1°, после чего выполняетсяdelay(20). - Программа не позволяет углу выйти за пределы диапазона
0°–180°. - Состояние светодиодов определяется текущим значением угла.
Как составить алгоритм
- Возьмите за основу скетч из предыдущего раздела, в котором сервопривод подключён к пину
D2. - В
setup()настройте пины кнопок и светодиодов, привяжите сервопривод, установите начальный угол90°и погасите светодиоды. - В
loop()считайте текущее состояние обеих кнопок. - Если нажата только левая кнопка (
D28) иangle > 0, уменьшитеangleна1, отправьте новый угол вservo.write(angle)и подождите20 мс. - Иначе, если нажата только правая кнопка (
D15) иangle < 180, увеличьтеangleна1, отправьте угол вservo.write(angle)и подождите20 мс. - Обновите светодиоды: включите
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.
Входы микроконтроллера Arduino Due рассчитаны максимум на 3,3 В. Питайте потенциометр только от контакта 3.3V на разъёме GPIO A8. Подача 5 В на сигнальный контакт GPIO (A8) может повредить плату.
Пины, которые используются в уроке
| Компонент | Пин или контакт на плате | Назначение в уроке |
|---|---|---|
Разъём GPIO A8 | 3.3V, GND, GPIO (A8) | Подключение потенциометра и чтение аналогового сигнала через analogRead(A8) |
| Светодиоды платы | D48, D49 | Индикация порога и режимов работы |
| Кнопка платы | D28 | Проверка мгновенного отклика без delay() |
| Разъём сервопривода | D2 | Поворот вала по команде из Serial и по сигналу A8 |
План урока
- Аналоговый сигнал и утилита мониторинга порта — чтение аналогового сигнала, подключение потенциометра к разъёму GPIO
A8(и работа без него), вывод текста вSerial Monitorи графиков вSerial Plotter. - Таймер millis() и команды из порта — отказ от
delay(), неблокирующий опрос и управление сервоприводом черезSerial. - Домашнее задание — фоновое мигание светодиода на
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:
Монтажная схема подключения потенциометра к 5-контактному разъёму GPIO A8:
Контакт разъёма GPIO A8 | Вывод потенциометра | Цвет провода на схеме | Назначение |
|---|---|---|---|
3.3V | Крайний вывод 1 | Красный | Питание делителя (3,3 В) |
GND | Крайний вывод 2 | Чёрный | Общий провод (0 В) |
SCL | не подключается | — | Линия I²C (остаётся свободной) |
SDA | не подключается | — | Линия I²C (остаётся свободной) |
GPIO (A8) | Средний вывод (движок) | Голубой | Аналоговый сигнал 0–3,3 В |
Если поменять местами провода на двух крайних выводах потенциометра (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);
}
Как посмотреть полученные значения в утилите мониторинга порта
- Нажмите Загрузить (
Upload) и дождитесь окончания прошивки. - Откройте утилиту мониторинга порта: Инструменты → Монитор порта (
Tools → Serial Monitor) или нажмите значок лупы в правом верхнем углу Arduino IDE. - В правом верхнем углу панели утилиты мониторинга порта выберите скорость
115200 baud.
В окне утилиты мониторинга порта пять раз в секунду появляются строки вида ADC: 480. Если подключён потенциометр — плавно поворачивайте его ручку от упора до упора и наблюдайте изменение полученных значений от 0 до 1023. Если потенциометр не подключён — поднесите палец к контакту A8: значения начнут меняться, а при переходе через 512 будет загораться и гаснуть светодиод D48.
Проверьте скорость в выпадающем списке утилиты мониторинга порта: она должна точно совпадать со скоростью в Serial.begin(115200). Если в скетче указано 115200, а в настройках окна выбрано 9600, компьютер будет неправильно расшифровывать биты.
Функции пересчёта: map() и constrain()
Сырое значение АЦП (0–1023) неудобно передавать напрямую в сервопривод, который ждёт угол от 0 до 180. Для линейного пересчёта одного диапазона в другой в Arduino есть две встроенные функции:
map(value, fromLow, fromHigh, toLow, toHigh)— пропорционально переводит значениеvalueиз старого диапазона[fromLow, fromHigh]в новый[toLow, toHigh].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);
}
Как открыть график
- Загрузите скетч в плату.
- Закройте вкладку утилиты мониторинга порта (Монитор порта), если она была открыта (обе утилиты используют один и тот же последовательный порт).
- Откройте Инструменты → Плоттер по последовательному соединению (
Tools → Serial Plotter). - Убедитесь, что в окне плоттера выбрана скорость
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 мс, программа действует как человек, который поглядывает на часы:
- Запоминает время последнего действия в переменной
unsigned long lastTime = 0;. - На каждом проходе
loop()вычисляет разницуmillis() - lastTime. - Если разница достигла нужного интервала (например,
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). В этом скетче плата одновременно решает две задачи:
- Каждые
200 мспо таймеруmillis()считываетanalogRead(A8)(с датчиком или без него) и выводит текущее значение АЦП и угол сервопривода. - Непрерывно проверяет
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);
}
}
Как отправить команду из утилиты мониторинга порта
- Загрузите скетч и откройте утилиту мониторинга порта (Монитор порта) на скорости
115200 baud. - В верхнем поле ввода (
Message) введите число45и нажмитеEnter. - Затем введите
135и снова нажмитеEnter.
В утилите мониторинга порта каждые 200 мс печатается строка ADC: ... | Angle: .... Как только вы отправляете число 45 или 135, сервопривод сразу поворачивается на заданный угол, а в журнале появляется подтверждение New angle set to: ....
Обратите внимание, как в loop() нам пришлось вручную разбирать числа из потока Serial, очищать символы перевода строки и склеивать текстовые ответы из кусочков Serial.print(). Когда у робота десятки датчиков и команд, такой ручной разбор текста быстро становится хрупким и громоздким. Начиная с урока 4 библиотека RosDuino возьмёт весь обмен по последовательному порту на себя и превратит функции платы в стандартные топики и сервисы ROS 2.
Вопросы для самопроверки
- Какое примерно значение вернёт
analogRead(A8)при стандартной шкале0–1023, если на вход подать напряжение1,65 В? Что вернётanalogRead(A8), если к разъёму GPIO вообще не подключён датчик? - Что произойдёт в окне утилиты мониторинга порта, если в скетче написано
Serial.begin(115200), а в настройках утилиты выбрана скорость9600 baud? - Почему в программах для роботов нельзя использовать
delay(1000)внутриloop()и какой конструкцией сmillis()её заменяют? - В чём разница между функциями
map()иconstrain()?
Назад: Аналоговый сигнал и утилита мониторинга порта.
Дальше: Домашнее задание.
Домашнее задание
В этом задании вы напишете неблокирующий скетч без использования delay(), в котором светодиод D48 равномерно мигает по таймеру millis(), каждое нажатие кнопки D28 увеличивает счётчик и выводит его в утилиту мониторинга порта, а команда '0' с компьютера сбрасывает счётчик в ноль. Для проверки не нужны ни потенциометр, ни сервопривод — достаточно самой платы TurtleBro, подключённой по USB.
Что должно получиться
Программа выполняет три действия одновременно, не мешая друг другу:
- Фоновое мигание светодиода (
D48):- светодиод
D48переключается каждые500 мсс помощью таймераmillis(); - это индикатор того, что программа работает и не зависла в
delay().
- светодиод
- Подсчёт нажатий кнопки (
D28):- при каждом новом нажатии кнопки
D28переменная счётчикаpressCountувеличивается на1; - сразу после нажатия в утилиту мониторинга порта отправляется строка:
Count: 1, затемCount: 2,Count: 3и так далее; - пока кнопка удерживается нажатой, счётчик повторно не увеличивается.
- при каждом новом нажатии кнопки
- Сброс счётчика по команде из утилиты мониторинга порта:
- если отправить из утилиты мониторинга порта символ
'0', переменнаяpressCountобнуляется; - в утилиту мониторинга порта сразу выводится сообщение:
Counter reset to 0.
- если отправить из утилиты мониторинга порта символ
Требования к программе
- В функции
loop()не используетсяdelay(). - Мигание светодиода
D48построено на проверкеmillis() - lastBlinkTime >= 500. - Чтобы исключить дребезг контактов кнопки
D28безdelay(), проверяйте кнопку поmillis()(например, опрашивайте состояние кнопки раз в30 мс). - Скорость последовательного порта —
115200 бод.
Как составить алгоритм
- Объявите константы пинов (
BUTTON_PIN = 28,LED_PIN = 48) и интервалов (BLINK_PERIOD_MS = 500,BUTTON_POLL_MS = 30). - Создайте переменные состояния:
int pressCount = 0;— счётчик нажатий;int lastButtonState = LOW;— предыдущее состояние кнопки;bool ledState = false;— текущее состояние светодиода;unsigned long lastBlinkTime = 0;иunsigned long lastButtonTime = 0;— переменные для двух таймеровmillis().
- В
setup()настройте пины, откройтеSerial.begin(115200)и считайте начальное состояние кнопки вlastButtonState. - В
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.
- Блок 1 (таймер 500 мс): переключите
Как убедиться, что всё работает правильно
- В коде нет ни одного вызова
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.
Уроки 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 в домашнем задании |
План урока
- Установка и запуск агента RosDuino — как устроена связь платы с ROS 2, сборка
rosduino_agentв Ubuntu и три правила работы с портом. - Управление светодиодом из ROS — первый скетч с
<RosDuino.h>, запуск агента и отправка сообщений в топик/led. - Домашнее задание — приём угла из топика
/servo_angleс проверкой допустимых границ0°–180°и индикацией ошибки наD48.
Назад: Домашнее задание.
Дальше: Установка и запуск агента RosDuino.
Установка и запуск агента RosDuino
В уроке 3 для передачи всего одного числа с компьютера на плату нам пришлось вручную разбирать символы из потока Serial и очищать переводы строк. Когда в системе появляются десятки датчиков, приводов и команд, такой самодельный текстовый обмен быстро становится ненадёжным. В этой части урока мы разберём, как библиотека RosDuino берёт передачу данных по кабелю на себя, и подготовим агент rosduino_agent на компьютере с Ubuntu.
Как устроена связь между платой и ROS 2
Система RosDuino состоит из двух частей, которые работают в паре:
- Библиотека
rosduino_arduinoна плате (#include <RosDuino.h>): упаковывает данные датчиков и принимает команды в компактном двоичном виде с проверкой контрольной суммы. Вы уже установили эту библиотеку в Arduino IDE в уроке 1 (документация на русском языке:rosduino_arduino/README_RU.md). - Узел-агент
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 не мешали друг другу, соблюдайте три правила:
- Не используйте
Serialи закрывайте утилиту мониторинга порта - Останавливайте
rosduino_agentперед загрузкой скетча - В функции
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), диагностике и работе с несколькими платами приведена в репозитории пакета:
- Общее руководство
rosduino_rosи установка (на русском); - Подробная документация узла
rosduino_agent(на русском); - Генератор заголовков своих типов сообщений
rosduino_gen.
Откройте приложение «Терминал» в 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 | Максимум топиков и сервисов | Максимальный размер пакета |
|---|---|---|---|
LARGE | Arduino Due (плата TurtleBro v2) | до 64 | 2040 байт |
MEDIUM | Arduino Mega 2560 (плата TurtleBro v1) | до 24 | 504 байта |
SMALL | Arduino Uno / Leonardo / Micro | до 8 | 152 байта |
LITE | Arduino Nano (ATmega328P) | до 3 | 88 байт |
На плате 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();
}
Разберём новые элементы по шагам:
- Заголовочные файлы:
#include <RosDuino.h>— подключает основную библиотеку и создаёт объектros;#include <std_msgs/msg/Bool.h>— подключает стандартный тип сообщения ROS 2 с одним логическим полемdata(trueилиfalse).
- Функция-обработчик (
onLed): Когда из ROS 2 в топик приходит новое сообщение, библиотека сама вызывает функциюonLed(std_msgs::Bool msg)и передаёт в неё полученное сообщениеmsg. Еслиmsg.dataравноtrue, на пинD48подаётсяHIGH, иначе —LOW. - Регистрация узла и подписки в
setup():ros.begin("led_board");— запускает обмен с агентом и задаёт имя узла ROS 2 (led_board);ros.subscribe("led", onLed);— подписывает плату на топикledи связывает его с функциейonLed. Тип топика (std_msgs/msg/Bool) библиотека определяет автоматически по аргументу функцииonLed.
- Обслуживание связи в
loop(): Вызовros.update()проверяет новые пакеты от агента, вызывает обработчики подписок и поддерживает связь с компьютером.
Пошаговая практика
1. Загрузите скетч в плату
- Убедитесь, что
rosduino_agentещё не запущен, а вкладка утилиты мониторинга порта в Arduino IDE закрыта. - Скопируйте приведённый выше скетч в Arduino IDE 2.
- Проверьте, что выбрана плата Arduino Due (Programming Port) и нужный порт (например,
/dev/ttyACM0или/dev/ttyUSB0). - Нажмите Загрузить (
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».
В журнале агента появится сообщение об успешном рукопожатии с узлом 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}" с пробелом после двоеточия |
Вопросы для самопроверки
- Какие две части входят в систему
RosDuinoи какая из них работает на микроконтроллере, а какая — на компьютере с Ubuntu? - Почему в скетче с
RosDuinoнельзя одновременно использоватьSerial.println()и держать открытой утилиту мониторинга порта в Arduino IDE? - Что нужно сделать в терминале с
rosduino_agentперед тем, как нажать кнопку Загрузить в Arduino IDE? - Как агент
rosduino_agentузнаёт, какое имя узла и какой тип топика нужно создать в ROS 2?
Назад: Установка и запуск агента RosDuino.
Дальше: Домашнее задание.
Домашнее задание
На предыдущей странице мы отправляли из ROS 2 логические значения true и false для включения светодиода. В этом задании вы создадите узел управления сервоприводом, который принимает целочисленный угол из топика /servo_angle, проверяет допустимые границы 0°–180° и зажигает светодиод D48, если присланный угол вышел за пределы диапазона.
Перед подключением сервопривода к разъёму D2 отключите USB-кабель от платы и сверьте контакты −, +, S с цветами проводов.
Что должно получиться
- Плата регистрирует в ROS 2 узел с именем
servo_driver_node. - Узел подписывается на топик
servo_angleс типом сообщенияstd_msgs/msg/Int32(заголовочный файл#include <std_msgs/msg/Int32.h>, число хранится в полеmsg.data). - После включения платы сервопривод на разъёме
D2встаёт в среднее положение90°, а светодиодD48погашен. - Когда в топик
/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.
Как составить алгоритм
- Возьмите за основу скетч со страницы управления светодиодом и добавьте подключение
<Servo.h>и<std_msgs/msg/Int32.h>. - Объявите константы
SERVO_PIN = 2,ERROR_LED_PIN = 48и объектServo servo;. - Напишите функцию-обработчик
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);.
- проверьте условие
- В
setup()настройте пин светодиода, привяжите сервоприводservo.attach(SERVO_PIN), поставьте начальный угол90°, вызовитеros.begin("servo_driver_node")и зарегистрируйте подпискуros.subscribe("servo_angle", onServoAngle). - В
loop()оставьте вызовros.update().
Как проверить результат из терминала ROS 2
- Загрузите скетч в плату и запустите
rosduino_agentв Терминале 1. - В Терминале 2 проверьте, что появились узел
/servo_driver_nodeи топик/servo_angleс типомstd_msgs/msg/Int32. - Отправьте допустимый угол
45: Терминал 2:
Сервопривод повернётся наros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: 45}"45°, светодиодD48останется погашенным. - Отправьте угол за пределами диапазона, например
220: Терминал 2:
Сервопривод остановится на безопасной границеros2 topic pub --once /servo_angle std_msgs/msg/Int32 "{data: 220}"180°, а светодиодD48загорится, сигнализируя о некорректной команде. - Снова отправьте допустимый угол
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 A8 | 3.3V, GND, GPIO (A8) | Чтение аналогового сигнала и публикация в топик (работает как с потенциометром, так и без него) |
| Первая кнопка | D28 | Публикация состояния кнопки в топик |
| Светодиоды платы | D48, D49, D50, D51 | Индикация команд, приходящих из ROS 2 |
План урока
- Публикация данных и таймер rosduino::Timer — отправка значений с разъёма GPIO
A8и кнопкиD28в ROS 2, проверка черезros2 topic echoиros2 topic hz. - Одновременная публикация и подписка — двусторонний обмен в одном узле и обзор типов сообщений ROS 2 в библиотеке
RosDuino. - Домашнее задание — узел мониторинга, который публикует аналоговый сигнал и нажатия кнопки, а по команде из топика зажигает шкалу из четырёх светодиодов
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);
}
}
Обратите внимание на три особенности:
- Автоматическое создание топика при первом вызове: когда
ros.publish("analog_signal", signalMsg)выполняется впервые, библиотека запрашивает у агента регистрацию нового топика. Пока топик регистрируется, само первое сообщение не отправляется. Для датчика, который передаёт измерения каждые100 мс, потеря самого первого отсчёта при старте незаметна — уже через десятую долю секунды в топик пойдут следующие значения. - Тип топика определяется автоматически: поскольку переменная
signalMsgимеет типstd_msgs::Int32, в ROS 2 создаётся топик с типомstd_msgs/msg/Int32. - Безопасное поведение без агента: пока
rosduino_agentна компьютере ещё не запущен, функцияros.publish()просто возвращает кодrosduino::Result::NotConnectedи не зависает. При желании связь можно проверить заранее условиемif (ros.connected()).
Шаг 1. Публикация аналогового сигнала с частотой 10 Гц
Загрузим приведённый выше скетч в плату и проверим поток данных на компьютере. Напомним: если к разъёму GPIO A8 подключён потенциометр из урока 3, вы сможете плавно менять значения ручкой; если ничего не подключено — analogRead(A8) будет передавать меняющиеся значения электрических наводок.
- Если в Терминале 1 запущен
rosduino_agent, остановите его клавишамиCtrl+C. - Загрузите скетч в плату TurtleBro через Arduino IDE 2.
- Запустите агент в Терминале 1:
Терминал 1:
ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
- Во втором окне терминала (Терминал 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]
- Выведите приходящие сообщения на экран:
Терминал 2:
ros2 topic echo /analog_signal
В Терминале 2 бежит поток сообщений с полем data: ... в диапазоне 0–1023. Поверните ручку потенциометра или поднесите палец к разъёму GPIO A8 — полученные значения в топике сразу изменятся. Нажмите Ctrl+C, чтобы остановить вывод echo.
- Теперь проверим, действительно ли таймер
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 (
Ctrl+C), загрузите скетч в плату и запустите агент снова. - Не нажимая кнопку
D28, проверьте список топиков в Терминале 2:
Терминал 2:
ros2 topic list -t
Топика /button в списке ещё нет: программа ни разу не зашла внутрь блока if (digitalRead(BUTTON_PIN) == HIGH) и не вызвала ros.publish().
- Теперь нажмите и удерживайте кнопку
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 (
Ctrl+C), загрузите обновлённый скетч в плату и запустите агент снова. - Не трогая кнопку
D28, проверьте список топиков в Терминале 2:
Терминал 2:
ros2 topic list -t
Топик /button_pressed [std_msgs/msg/Bool] уже присутствует в списке вместе с /analog_signal [std_msgs/msg/Int32].
- В Терминале 2 заранее подпишитесь на события кнопки:
Терминал 2:
ros2 topic echo /button_pressed
- Нажмите и отпустите кнопку
D28на плате.
Пока вы не трогаете кнопку, в терминале тишина — лишние пакеты не передаются. При самом первом нажатии D28 без потерь приходит ровно одно сообщение data: true, а при отпускании — одно сообщение data: false. В топике /analog_signal параллельно продолжают идти измерения с частотой 10 Гц.
Назад: Урок 5. Топики в RosDuino.
Дальше: Одновременная публикация и подписка.
Одновременная публикация и подписка
В реальных задачах плата микроконтроллера работает в обе стороны одновременно: отправляет в ROS 2 полученные значения датчиков и тут же принимает от компьютера управляющие команды. В этой части урока мы соберём двусторонний узел и познакомимся со стандартными типами сообщений ROS 2, которые входят в комплект RosDuino.
Двусторонний узел: датчик + команда светодиоду
Объединим в одном скетче публикацию и подписку. Пусть плата:
- Каждые
100 мссчитывает значение на разъёме GPIOA8, пересчитывает его в диапазон0–100(в процентах) и публикует в топик/sensor_percent. - Слушает топик
/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);
}
}
Проверка двустороннего обмена
- Остановите
rosduino_agentв Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент. - В Терминале 2 проверьте, что данные от платы поступают:
Терминал 2:
ros2 topic echo /sensor_percent --once
- Не останавливая поток публикации, отправьте команду на включение светодиода
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_msgs | Bool, Int8…Int64, UInt8…UInt64, Float32, Float64, String, Empty | Одиночные флаги, счётчики, простые численные значения и текстовые статусы |
sensor_msgs | Range, Imu, Temperature, BatteryState, Joy | Показания дальномеров, инерциальных датчиков, температуры и состояния аккумулятора |
geometry_msgs | Twist, Pose, Point, Vector3, Quaternion | Команды линейной и угловой скорости робота (cmd_vel), координаты и ориентация |
nav_msgs | Odometry | Одометрия колёсного робота |
Все эти типы подключаются точно так же, как в обычных 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");
}
Вопросы для самопроверки
- Какую задачу решает класс
rosduino::Timerи почему с ним не нужно вручную хранить переменнуюlastTimeдляmillis()? - Что происходит при самом первом вызове
ros.publish()без предварительной регистрации и зачем для кнопки вsetup()вызываютros.advertise()? - Какой командой в терминале можно измерить фактическую частоту публикации сообщений в топике
/sensor_percent? - Почему для события нажатия кнопки лучше вызывать
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>. Он полезен в двух случаях:
- Когда нужно явно задать профиль качества обслуживания QoS — например,
rosduino::QoS::sensorData()(BestEffort) для высокочастотных потоков датчиков вместо стандартного надёжного профиляrosduino::QoS::defaults()(Reliable). - Когда на младших платах (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 и выполняет три задачи одновременно:
- Публикация аналогового сигнала (10 Гц — каждые
100 мс):- по таймеру
rosduino::Timer(100)считывает полученное значениеanalogRead(A8)(0–1023); - публикует его в топик
/sensor_valueс типомstd_msgs/msg/Int32.
- по таймеру
- Публикация нажатий кнопки
D28(с защитой от дребезга30 мс):- заранее регистрирует в
setup()топик/button_state(std_msgs/msg/Bool) с помощьюros.advertise(), чтобы топик был виден сразу и не терял первое нажатие; - опрашивает кнопку
D28по второму таймеруrosduino::Timer(30); - при каждом изменении состояния кнопки (нажата —
true, отпущена —false) публикует сообщениеstd_msgs/msg/Boolв топик/button_state.
- заранее регистрирует в
- Подписка на уровень светодиодной шкалы (
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).
Как составить алгоритм
- Подключите
<RosDuino.h>,<std_msgs/msg/Int32.h>и<std_msgs/msg/Bool.h>. - Объявите константы пинов (
SENSOR_PIN = A8,BUTTON_PIN = 28, массивLED_PINS[4] = {48, 49, 50, 51}), сообщенияsensorMsgиbuttonMsg, а также два таймера:rosduino::Timer sensorTimer(100);иrosduino::Timer buttonTimer(30);. - Перенесите из урока 2 функцию
void showLitCount(int count), которая в циклеforзажигает первыеcountсветодиодов массива и гасит остальные. - Напишите функцию-обработчик подписки
void onLedLevel(std_msgs::Int32 msg):- ограничьте входное значение:
int count = constrain(msg.data, 0, 4);; - вызовите
showLitCount(count);.
- ограничьте входное значение:
- В
setup()настройте пины кнопки и светодиодов, погасите все светодиоды, считайте начальное состояние кнопки, вызовитеros.begin("board_monitor_node"), зарегистрируйте топик кнопкиros.advertise("button_state", buttonMsg)и подпискуros.subscribe("led_level", onLedLevel). - В
loop()вызовитеros.update(), затем проверьтеsensorTimer.check()иbuttonTimer.check().
Как проверить результат из терминала ROS 2
- Остановите
rosduino_agentв Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент. - Не нажимая кнопку
D28, убедитесь в Терминале 2, что топик/button_stateуже виден в спискеros2 topic list -t, и проверьте частоту публикации/sensor_value:
Частота должна составлять околоros2 topic hz /sensor_value10 Гц. Остановите проверку клавишамиCtrl+C. - В Терминале 2 запустите просмотр состояния кнопки и понажимайте
D28на плате:
Уже с самого первого нажатия должно приходить одно сообщениеros2 topic echo /button_statedata: true, а при отпускании — одно сообщениеdata: false. - Проверьте управление светодиодной шкалой
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 (понадобится в домашнем задании) |
План урока
- Сервер сервиса на плате — сервис как удалённый вызов функции, создание
/set_ledчерезros.service()и вызовros2 service call. - Клиент сервиса на плате — неблокирующий вызов внешнего сервиса
/add_two_intsс платы черезros.call()по нажатию кнопкиD28. - Создание сообщений для сервисов (для дополнительного изучения) — обзор готовых типов
std_srvsиexample_interfaces, структура файлов.srvи генерация своих заголовков черезrosduino-gen. - Домашнее задание — узел управления сервоприводом с включением и отключением разрешения на движение через сервис
/set_drive_enable.
Назад: Домашнее задание.
Дальше: Сервер сервиса на плате.
Сервер сервиса на плате
В обычном скетче на C++ вы вызываете функцию внутри одной программы: передаёте ей аргументы в скобках, она выполняет действия и возвращает ответ через return. Сервис (Service) в ROS 2 устроен точно так же, только это удалённый вызов функции: функция находится на одном устройстве (например, на плате TurtleBro), а вызывает её программа на другом устройстве (на компьютере).
Как устроен удалённый вызов функции
Любой вызов сервиса состоит из двух шагов:
- Передача входных параметров (
Request— запрос): вызывающая сторона (клиент сервиса) отправляет данные, с которыми нужно выполнить функцию. - Получение результата работы (
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.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();
}
Обратите внимание на две важные детали:
- Передача параметра по ссылке (
&): в заголовкеvoid onSetLed(std_srvs::SetBool& srv)стоит знак амперсанда&. Благодаря этому функция записывает результат прямо в поляsrv.responseпереданного объекта, и сразу после завершения функции библиотека отправляет этот ответ обратно клиенту в ROS 2. - Быстрое выполнение обработчика: пока выполняется
onSetLed(), плата не обрабатывает другие пакеты. Поэтому внутри функции сервиса нельзя использоватьdelay()или долгие циклы ожидания.
Пошаговая проверка из терминала ROS 2
- Если
rosduino_agentзапущен в Терминале 1, остановите его клавишамиCtrl+C, загрузите скетч в плату и снова запустите агент:
Терминал 1:
ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
- В Терминале 2 проверьте список доступных сервисов вместе с их типами (флаг
-t):
Терминал 2:
ros2 service list -t
В списке появится сервис /set_led [std_srvs/srv/SetBool].
- Вызовите сервис
/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'.
- Выключите светодиод вторым запросом:
Терминал 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() работает асинхронно (неблокирующе):
- Плата отправляет пакет запроса агенту и сразу продолжает выполнять
loop(). - Пока компьютер считает и отправляет ответ обратно,
ros.update()продолжает обслуживать все остальные топики и таймеры платы. - Как только ответ приходит по USB, библиотека автоматически вызывает функцию
onSumAnswer(), передавая в неё структуруsrvс заполненным полемsrv.response.sum.
Если вызвать ros.call() повторно до того, как пришёл ответ на предыдущий запрос к тому же сервису, функция вернёт rosduino::Result::Busy. Если сервер на компьютере не ответит в течение 1 с, ожидание автоматически сбросится, и сервис можно будет вызвать снова.
Пошаговая проверка с сервером на компьютере
- Остановите
rosduino_agentв Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент:
Терминал 1:
ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
- Во втором окне терминала (Терминал 2) запустите стандартный демонстрационный сервер сложения из комплекта ROS 2:
Терминал 2:
ros2 run demo_nodes_cpp add_two_ints_server
- Нажмите кнопку
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 successstring message | Запуск действия без входных параметров (например, /calibrate) или опрос статуса с возвратом флага успеха и текста |
std_srvs/srv/SetBool | <std_srvs/srv/SetBool.h> | bool data | bool successstring 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".
Вопросы для самопроверки
- Зачем в ROS 2 нужны сервисы, если в системе уже есть топики, и как один сервис с входным параметром помогает избежать создания множества топиков?
- Почему в обработчике сервера сервиса
void onSetLed(std_srvs::SetBool& srv)параметр принимается по ссылке (&) и почему внутри этой функции нельзя делать долгие паузы? - Чем отличается роль платы при вызове
ros.service()от её роли при вызовеros.call()? - Почему вызов
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;:
- Начальное состояние после включения:
- привод заблокирован (
driveEnabled = false), светодиодD48погашен; - вал сервопривода на разъёме
D2установлен в начальное положение90°.
- привод заблокирован (
- Сервис блокировки
/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".
- при вызове с
- Приём целевого угла из топика
/target_angle(std_msgs/msg/Int32):- если
driveEnabled == false— команда игнорируется, сервопривод остаётся на прежнем месте; - если
driveEnabled == true— программа ограничивает угол диапазоном0°–180°черезconstrain(msg.data, 0, 180)и поворачивает сервопривод.
- если
- Публикация текущего угла (
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).
Как составить алгоритм
- Объявите константы
SERVO_PIN = 2,STATUS_LED_PIN = 48, переменныеbool driveEnabled = false;иint currentAngle = 90;, объектServo servo;и таймерrosduino::Timer telemetryTimer(1000);. - Напишите обработчик сервиса
void onSetDriveEnable(std_srvs::SetBool& srv):- сохраните
driveEnabled = srv.request.data;; - включите или выключите светодиод
D48в зависимости отdriveEnabled; - заполните
srv.response.success = true;и текстовое полеsrv.response.message.
- сохраните
- Напишите обработчик подписки
void onTargetAngle(std_msgs::Int32 msg):- если
!driveEnabled, сразу выйдите из функции (return;); - иначе ограничьте угол
currentAngle = constrain(msg.data, 0, 180);и вызовитеservo.write(currentAngle);.
- если
- В
setup()настройте пин светодиода, привяжите сервопривод, установите начальный угол90°, вызовитеros.begin("safe_servo_node"), зарегистрируйте подпискуros.subscribe("target_angle", onTargetAngle)и сервисros.service("set_drive_enable", onSetDriveEnable). - В
loop()вызывайтеros.update()и по срабатываниюtelemetryTimer.check()публикуйтеcurrentAngleв топик"current_angle".
Как проверить результат из терминала ROS 2
- Загрузите скетч в плату и запустите
rosduino_agentв Терминале 1. СветодиодD48погашен (привод заблокирован). - Попробуйте отправить команду поворота на
45°в Терминале 2:
Сервопривод останется на месте (ros2 topic pub --once /target_angle std_msgs/msg/Int32 "{data: 45}"90°), так как разрешение ещё не включено. - Разблокируйте привод вызовом сервиса в Терминале 2:
Загорится светодиодros2 service call /set_drive_enable std_srvs/srv/SetBool "{data: true}"D48, а в терминале вернётся ответsuccess=True, message='Drive enabled'. - Снова отправьте угол
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 A8 | 3.3V, GND, GPIO (A8) | Чтение аналогового сигнала для передачи в Python-узел (работает с потенциометром и без него) |
| Разъём сервопривода | D2 | Поворот вала по командам от Python-узла (в третьей части урока и домашнем задании) |
План урока
- Журнал событий /rosout — пять уровней важности сообщений (
logDebug…logFatal) и просмотр журнала платы на компьютере. - Синхронизация времени и диагностика связи — функция
ros.now(), контроль состояния узла в/diagnosticsи параметры запускаrosduino_agent. - Управляющий узел на Python и launch-файл — универсальный скетч на плате, управляющий скрипт на Python (
rclpy) и единый файл запускаbringup.launch.py. - Домашнее задание — 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 на компьютере
- Если
rosduino_agentзапущен в Терминале 1, остановите его клавишамиCtrl+C, загрузите скетч в плату и снова запустите агент:
Терминал 1:
ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
-
Нажмите кнопку
D28на плате пять раз подряд. Посмотрите в окно Терминала 1, где запущен агент: вы сразу увидите цветные строки журнала[INFO],[WARN]и[ERROR]от узлаlogger_node. -
Откройте Терминал 2 и подпишитесь на системный топик
/rosout:
Терминал 2:
ros2 topic echo /rosout
- Нажмите кнопку
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 задачи делят на два уровня:
- Скетч на плате («драйвер железа»): только считывает датчики и кнопки, публикует их значения в топики и слушает исполнительные топики для светодиодов и сервопривода. Такой скетч прошивается в плату один раз.
- 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 мспубликует полученное значение с разъёма GPIOA8(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:
ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0
- В Терминале 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-узел стартуют одновременно в одном окне!
Вопросы для самопроверки
- Какими пятью функциями объекта
rosможно отправить текстовое сообщение с платы в системный журнал/rosout? - Зачем нужна функция
ros.now()и чем возвращаемое ею время отличается отmillis()? - Какой топик ROS 2 позволяет проверить связь платы с
rosduino_agentи что в нём означает статусWARN? - В чём преимущество размещения пороговой логики и фильтрации сигнала в Python-узле на компьютере вместо скетча на плате?
- Зачем нужен 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:
- Подписка на
/analog_signal(std_msgs/msg/Int32):- узел хранит последние
5полученных значений (удобно использовать очередь фиксированной длиныcollections.deque(maxlen=5)); - при каждом новом сообщении вычисляет среднее значение
avg_val = sum(self.window) / len(self.window).
- узел хранит последние
- Пропорциональное управление сервоприводом (
/servo_angle,std_msgs/msg/Int32):- переводит сглаженное значение
avg_val(0..1023) в угол от0до180градусов по формуле:angle = int(avg_val * 180 / 1023); - ограничивает угол пределами
0..180и публикует его в топик/servo_angle.
- переводит сглаженное значение
- Пороговая сигнализация на светодиоде
D48(/led,std_msgs/msg/Bool):- если сглаженное значение
avg_val > 700— отправляетTrueв топик/led(зажигает светодиодD48) и выводит предупреждение в журналself.get_logger().warn(...); - если
avg_val <= 700— отправляетFalseв топик/led(гасит светодиодD48).
- если сглаженное значение
Как составить алгоритм
- Импортируйте
from collections import deque,rclpy,Nodeи сообщенияBool, Int32изstd_msgs.msg. - В конструкторе
__init__()создайте буферself.window = deque(maxlen=5), подписку на/analog_signalи два издателя: для/servo_angle(Int32) и/led(Bool). - В методе-обработчике
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.
- добавьте новое измерение в буфер:
Как проверить результат
- Убедитесь, что в плату загружен скетч
io_boardсо страницы «Управляющий узел на Python и launch-файл». - В Терминале 1 запустите
rosduino_agent:ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0 - В Терминале 2 запустите ваш скрипт:
python3 ~/ros2_ws/smooth_servo_controller.py - Плавно вращайте ручку потенциометра на разъёме 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 установлены сразу два микроконтроллера, и у каждого своя зона ответственности:
- Системный микроконтроллер
STM32F4: отвечает за базовое движение шасси — вращает колёса, считывает энкодеры и инерциальный датчик (IMU), следит за зарядом батареи, публикует/odom,/imu,/batи принимает команды скорости из/cmd_vel. - Пользовательский микроконтроллер
Arduino Due: управляет кнопкамиD28/D15, переключателямиD16/D29, светодиодамиD48–D51, разъёмами сервоприводовD2–D7и разъёмами GPIOA8–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
План урока
- Отличия ПК и Raspberry Pi. Запуск агента на роботе — переход на
Serial1в скетче, почему не нужно переключать провода и не нужно останавливать агент при прошивке, запускrosduino_agentна Raspberry Pi. - Управление роботом кнопками и launch-файл — связь кнопок и светодиодов платы со штатным топиком скорости
/cmd_velи запуск всей связки одним.launch.py-файлом. - Генерация собственных сообщений (rosduino_gen) — как создать свой пакет интерфейсов
.msg/.srvи сгенерировать заголовки для Arduino. - Домашнее задание — световой парктроник на четырёх светодиодах платы
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 мспубликует аналоговый сигнал с разъёма GPIOA8в топик/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, который одной командой запускает:
- Узел
rosduino_agentс параметрамиportиkeep_on_disconnect: True(чтобы топики сохранялись при кратковременном сбросе платы); - Наш управляющий узел
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-файл:
-
Скетч на плате 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.01D480.5 <= d < 0.72D48,D490.3 <= d < 0.53D48,D49,D50d < 0.3(ближе30 см)4(вплотную)D48,D49,D50,D51 - открывает связь с Raspberry Pi на порту
-
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м/с) и не едет до нового нажатия «Старт».
- по нажатию кнопки «Старт» (
- читает топик лидара
-
Файл запуска (
~/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
- Возьмите за основу скетч
turtlebro_panel_nodeиз раздела «Управление роботом кнопками и launch-файл» и подключите заголовок<std_msgs/msg/Float32.h>. - Замените одиночный пин светодиода на массив
const int LED_PINS[4] = {48, 49, 50, 51};и перенесите из урока 5 вспомогательную функциюvoid showLitCount(int count). - Напишите обработчик подписки
void onDistance(std_msgs::Float32 msg):- по цепочке
if / else if / elseпереведите значениеmsg.data(в метрах) в число светодиодовlevelот0до4согласно таблице выше; - вызовите
showLitCount(level);.
- по цепочке
- В
setup()настройте пины кнопок и четырёх светодиодов, погасите шкалуshowLitCount(0), вызовитеros.begin(Serial1, "turtlebro_parktronic_node"), зарегистрируйтеros.advertise()для обеих кнопок и подпискуros.subscribe("panel/distance", onDistance). - Загрузите скетч со своего компьютера через разъём DUE.
Шаг 2. Напишите Python-узел и launch-файл на Raspberry Pi
- Возьмите за основу скрипт
~/ros2_ws/panel_drive_node.pyиз урока (убрав из него публикацию в старый топик/panel/led). - Добавьте в конструктор подписку на
/scan(LaserScan, профильqos_profile_sensor_data) и издателя/panel/distance(Float32) из опорного примера выше. - Оставьте управление флагом
self.movingи публикацией скорости в/cmd_velтолько в обработчиках кнопокon_startиon_stop. - Создайте
~/ros2_ws/parktronic.launch.pyпо образцуturtlebro_rosduino.launch.py, указав в нём путь~/ros2_ws/parktronic_drive_node.py.
Как проверить результат
- Запустите систему на Raspberry Pi робота по SSH:
ros2 launch ~/ros2_ws/parktronic.launch.py - Проверка парктроника без движения: не нажимая кнопок, плавно приближайте ладонь к лидару с расстояния
1,2 мдо20 см. На плате последовательно загорятся один (D48), два (D48–D49), три (D48–D50) и все четыре светодиода (D48–D51). Уберите руку — светодиоды погаснут в обратном порядке. - Проверка кнопок Старт и Стоп: поставьте робота на подставку (или на свободный пол) и нажмите кнопку
D28— колёса начнут вращаться вперёд (linear.x = 0.10м/с), при этом шкала светодиодов продолжит в реальном времени показывать расстояние до препятствий. - Нажмите кнопку
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);
}
Как устроено решение
- Функция
flashLed()включает светодиод на времяduration_ms, выключает его и выдерживает паузуSYMBOL_GAP_MS. Благодаря этому команды одной вспышки не повторяются девять раз. - Первый цикл
forтри раза вызываетflashLed(DOT_MS)и передаёт три точки — буквуS. - Второй цикл три раза вызывает
flashLed(DASH_MS)и передаёт три тире — буквуO. - Третий цикл снова передаёт букву
S. - После последней вспышки функция уже выдержала паузу 150 мс. Поэтому перед новым циклом нужна дополнительная задержка
1500 - 150 = 1350мс. Тогда полная пауза между циклами составит ровно 1500 мс.
Каждый цикл for повторяет вызов функции три раза. Если вы пока не разбираете циклы, их можно заменить последовательными вызовами: три раза flashLed(DOT_MS);, три раза flashLed(DASH_MS);, затем ещё три раза flashLed(DOT_MS);. Остальной код остаётся прежним.
Как проверить решение
- На светодиоде последовательно появляются три короткие вспышки, три длинные и снова три короткие.
- Между вспышками соблюдается пауза 150 мс.
- От выключения последней вспышки до включения первой вспышки следующего цикла проходит 1500 мс.
- Последовательность повторяется, пока плата включена.
Ответы на вопросы для самопроверки
- Что такое скетч?
Скетч — это программа для платы Arduino. - Зачем в Arduino IDE выбирать модель платы и порт?
Модель платы сообщает Arduino IDE, для какого устройства нужно скомпилировать скетч. Через выбранный порт IDE загружает программу в подключённую плату. - Сколько раз выполняется
setup()?
setup()выполняется один раз после включения платы или сброса. Затем многократно выполняетсяloop(). - Какая команда включает светодиод?
КомандаdigitalWrite(LED_BUILTIN, HIGH)включает светодиод, аdigitalWrite(LED_BUILTIN, LOW)выключает его. - Что изменится, если заменить
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();
}
Как устроено решение
- После запуска
angleравен90, поэтому оба условияangle == MIN_ANGLEиangle == MAX_ANGLEложны, и оба светодиода погашены. - В начале
loop()считываются состояния обеих кнопок в логические переменныеleftPressedиrightPressed. - Шаг влево выполняется только тогда, когда нажата
D28(leftPressed), не нажатаD15(!rightPressed) и текущий угол больше0. Шаг вправо — когда нажата толькоD15и угол меньше180. Если нажаты обе кнопки одновременно или обе отпущены, ни одно из условий не срабатывает, и угол остаётся прежним. - Пауза
20 мсстоит внутри ветки шага. Пока кнопка удерживается, каждые20 мсугол меняется на1°. Полный поворот от середины (90°) до упора занимает около1,8 с. - Функция
updateLeds()проверяет текущий угол на каждом проходе цикла: как только вал уходит с0°на1°, левый светодиодD48сразу гаснет.
Как проверить решение
- При отключённом USB-кабеле проверьте подключение сервопривода к разъёму
D2и совпадение маркировки−,+,Sс цветами проводов. - Подключите плату и загрузите скетч. Вал должен встать в среднее положение (
90°), оба светодиода погашены. - Удерживайте кнопку
D28. Вал плавно повернётся влево и остановится на0°, после чего загорится светодиодD48. - Отпустите кнопку — вал останется в положении
0°, аD48продолжит гореть. - Удерживайте кнопку
D15. СветодиодD48погаснет сразу после первого шага. Дойдя до180°, вал остановится, и загорится светодиодD51. - Попробуйте зажать обе кнопки во время движения — сервопривод должен остановиться.
Ответы на вопросы для самопроверки
-
Почему нажатие кнопки на плате TurtleBro даёт уровень
HIGHи почему в этих скетчах не используется режимINPUT_PULLUP?
На плате TurtleBro кнопки уже снабжены внешними стягивающими резисторами к земле (GND), а при нажатии подают на пин напряжение питания (HIGH). Внутренняя подтяжкаINPUT_PULLUPподтягивает вход к питанию внутри микроконтроллера, что мешало бы работе внешней схемы платы, поэтому используется режимINPUT. -
Какой параметр сигнала ШИМ определяет угол поворота сервопривода и почему в скетче не нужно формировать импульсы вручную?
Угол определяется длительностью (шириной) управляющего импульса, который повторяется примерно каждые20 мс. Вручную формировать импульсы не нужно, потому что эту работу выполняет библиотекаServo: в скетче достаточно передать желаемый угол в градусах вызовомservo.write(). -
Каким цветам проводов сервопривода соответствуют контакты
−,+иSна разъёме платы?
Тёмный провод (коричневый или чёрный) подключается к−(GND), красный провод питания — к+(5 В), а светлый сигнальный провод (оранжевый, жёлтый или белый) — кS. -
Зачем при проверке кнопки ждать 30 мс после изменения сигнала и почему важно обновлять
lastButtonStateтакже при отпускании кнопки?
За30 мсмеханический дребезг контактов заканчивается, и повторное чтение пина подтверждает устойчивое состояние кнопки. Запоминать отпускание (LOW) вlastButtonStateнеобходимо для того, чтобы при следующем нажатии программа снова увидела смену состояния сLOWнаHIGH. Если не сохранятьLOWпри отпускании, вlastButtonStateнавсегда останетсяHIGH, и кнопка сработает только один раз. -
Почему силовую линию
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");
}
}
}
Как устроено решение
- Фоновое мигание (
lastBlinkTime): каждые500 мспеременнаяledStateменяет значение на противоположное, а светодиодD48включается или выключается. Посколькуdelay()не используется, проверка занимает всего несколько микросекунд. - Неблокирующий антидребезг кнопки (
lastButtonTime): в уроке 2 мы подавляли дребезг с помощьюdelay(30). Здесь тот же интервал30 мсотсчитывается черезmillis(). Микроконтроллер считывает пин кнопки не чаще одного раза в30 мс, поэтому быстрые колебания контактов остаются незамеченными, а основной циклloop()ни на миллисекунду не останавливается. - Сброс по команде
'0': циклwhile (Serial.available() > 0)забирает пришедшие символы из входного буфера. Если пришёл символ'0', переменнаяpressCountобнуляется, а символы перевода строки ('\n','\r') просто игнорируются.
Как проверить решение
- Загрузите скетч в плату и откройте утилиту мониторинга порта (Монитор порта) на скорости
115200 baud. - В окне появится приветственная строка
Ready! Press D28 to count, send '0' to reset., а светодиодD48на плате начнёт равномерно мигать. - Нажмите кнопку
D28несколько раз. На каждое нажатие в утилите мониторинга порта сразу появится строка:Count: 1 Count: 2 Count: 3 - Введите в поле отправки утилиты мониторинга порта цифру
0и нажмитеEnter. В окне появится строкаCounter reset to 0. - Нажмите кнопку
D28ещё раз — счёт продолжится сCount: 1.
Ответы на вопросы для самопроверки
-
Какое примерно значение вернёт
analogRead(A8)при стандартной шкале0–1023, если на вход подать напряжение1,65 В? Что вернётanalogRead(A8), если к разъёму GPIO вообще не подключён датчик?
Напряжение1,65 В— это ровно половина от максимального напряжения3,3 В, поэтому АЦП вернёт значение около середины шкалы: примерно511–512. Если датчик не подключён, контакт остаётся неподключённым («плавающим»), улавливает случайные электрические наводки, иanalogRead(A8)возвращает произвольные меняющиеся значения. -
Что произойдёт в окне утилиты мониторинга порта, если в скетче написано
Serial.begin(115200), а в настройках утилиты выбрана скорость9600 baud?
Плата и компьютер будут использовать разную длительность одного бита при передаче, поэтому в окне утилиты мониторинга порта вместо читаемого текста появятся нечитаемые символы («кракозябры») или пустой вывод. -
Почему в программах для роботов нельзя использовать
delay(1000)внутриloop()и какой конструкцией сmillis()её заменяют?
Во времяdelay(1000)микроконтроллер полностью приостанавливает выполнение циклаloop(): он не может опрашивать кнопки и датчики, не читает входящие команды изSerialи не обслуживает обмен данными с ROS 2. Вместо этого запоминают время последнего срабатыванияlastTimeи проверяют условиеif (millis() - lastTime >= 1000). -
В чём разница между функциями
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();
}
Как устроено решение
- Тип сообщения
std_msgs::Int32: в отличие от логическогоBool, сообщениеInt32передаёт знаковое целое число в полеmsg.data. Поэтому оно может содержать как корректные углы (0..180), так и ошибочные отрицательные или слишком большие значения (-45,250). - Проверка границ (
||— логическое ИЛИ): условиеrequestedAngle < MIN_ANGLE || requestedAngle > MAX_ANGLEсрабатывает, если нарушена хотя бы одна из двух границ. В этом случае зажигается светодиод ошибкиD48. Как только в следующем сообщении приходит допустимый угол, веткаelseгасит светодиод. - Защита привода (
constrain): функцияconstrain()обрезает любое значение меньше0до0, а больше180— до180. Благодаря этому на сервопривод никогда не подаётся команда за пределами его механического хода.
Как проверить решение
- Если
rosduino_agentзапущен в Терминале 1, остановите его клавишамиCtrl+C. - Загрузите скетч в плату TurtleBro через Arduino IDE 2. Вал сервопривода встанет в среднее положение
90°, светодиодD48погашен. - Запустите агент в Терминале 1:
ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0 - В Терминале 2 проверьте узел и тип топика:
ros2 node list # Вывод: /servo_driver_node ros2 topic info /servo_angle # Вывод: # Type: std_msgs/msg/Int32 # Publisher count: 0 # Subscription count: 1 - Протестируйте допустимые и выходящие за границы значения в Терминале 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гаснет.
Ответы на вопросы для самопроверки
-
Какие две части входят в систему
RosDuinoи какая из них работает на микроконтроллере, а какая — на компьютере с Ubuntu?
На микроконтроллере работает библиотекаrosduino_arduino(#include <RosDuino.h>), а на компьютере с Ubuntu — узел-агентrosduino_agentиз пакетаrosduino_ros. -
Почему в скетче с
RosDuinoнельзя одновременно использоватьSerial.println()и держать открытой утилиту мониторинга порта в Arduino IDE?
Потому что последовательный порт уже занят двоичным протоколом обмена междуRosDuinoиrosduino_agent. Посторонний текст изSerial.println()повредит пакеты данных, а открытая утилита мониторинга порта заблокирует доступ к порту для агента. -
Что нужно сделать в терминале с
rosduino_agentперед тем, как нажать кнопку «Загрузить» в Arduino IDE?
Нужно остановитьrosduino_agentсочетанием клавишCtrl+C, чтобы освободить последовательный порт для загрузчика Arduino IDE. -
Как агент
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);
}
}
}
Как устроено решение
- Два независимых таймера
rosduino::Timer: объектsensorTimer(100)отвечает за равномерную отправку значенийanalogRead(A8)10 раз в секунду, аbuttonTimer(30)считывает кнопку раз в 30 мс, отсекая механический дребезг контактов без остановкиloop(). - Предварительная регистрация и экономия канала для кнопки: вызов
ros.advertise("button_state", buttonMsg)вsetup()создаёт топик/button_stateсразу при подключении агента, не отправляя сообщение. А вloop()вызовros.publish("button_state", buttonMsg)находится внутри проверкиif (reading != lastButtonState): пакеты уходят в ROS 2 только в момент нажатия (true) и отпускания (false), причём самое первое нажатие доставляется без потерь. - Управление линейкой светодиодов (
onLedLevel): когда из ROS 2 приходит сообщение в топик/led_level, функцияconstrain(msg.data, 0, LED_COUNT)защищает программу от чисел меньше0и больше4, а знакомая по уроку 2 функцияshowLitCount()включает нужное число светодиодов.
Как проверить решение
- Остановите
rosduino_agentв Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент:ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0 - Не нажимая кнопку
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] - Запустите просмотр
ros2 topic echo /button_stateи нажмите кнопкуD28— уже первое нажатие выведетdata: true, а отпускание —data: false. Затем проверьте частоту публикации аналогового сигнала:ros2 topic hz /sensor_value - Проверьте зажигание светодиодов
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}"
Ответы на вопросы для самопроверки
-
Какую задачу решает класс
rosduino::Timerи почему с ним не нужно вручную хранить переменнуюlastTimeдляmillis()?
Классrosduino::Timerхранит интервал и время последнего срабатывания внутри самого объекта. Методtimer.check()сам сравнивает текущее времяmillis()с сохранённым и возвращаетtrue, когда интервал истёк, поэтому код остаётся коротким и не блокируетros.update(). -
Что происходит при самом первом вызове
ros.publish()без предварительной регистрации и зачем для кнопки вsetup()вызываютros.advertise()?
Без предварительной регистрации первый вызовros.publish("имя_топика", msg)только регистрирует издателя в агенте (по типу переменнойmsg), поэтому до этого вызова топика не видно вros2 topic list, а само первое сообщение теряется. Для периодического датчика это не страшно, так как следом сразу идут новые измерения. Для кнопки же вызовros.advertise("button", pressed)вsetup()создаёт топик сразу при подключении агента без отправки сообщения, благодаря чему топик сразу виден в ROS 2 и первое нажатие не пропадает. -
Какой командой в терминале можно измерить фактическую частоту публикации сообщений в топике
/sensor_percent?
Командойros2 topic hz /sensor_percent. -
Почему для события нажатия кнопки лучше вызывать
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);
}
}
Как устроено решение
- Сервис как переключатель режима (
onSetDriveEnable): команда включения или блокировки привода подаётся редко, но требует стопроцентной уверенности, что плата её приняла. Поэтому для неё выбран сервисstd_srvs/srv/SetBool, который сразу меняет флагdriveEnabled, зажигает или гасит светодиодD48и возвращает текстовое подтверждение. - Топик для команд угла (
onTargetAngle): целевой угол приходит через топик/target_angle. ЕслиdriveEnabled == false, функция сразу завершается (return;), не меняяcurrentAngleи не трогая сервопривод. - Периодическая телеметрия (
telemetryTimer): раз в секунду узел публикует фактический уголcurrentAngleв топик/current_angle, чтобы другие узлы ROS 2 всегда знали текущее положение механизма.
Как проверить решение
- Остановите
rosduino_agentв Терминале 1 (Ctrl+C), загрузите скетч в плату и снова запустите агент:ros2 run rosduino_agent rosduino_agent --port /dev/ttyACM0 - Во втором окне терминала (Терминал 2) отправьте команду угла при заблокированном приводе:
Вал не повернётся, аros2 topic pub --once /target_angle std_msgs/msg/Int32 "{data: 30}"ros2 topic echo /current_angle --onceпо-прежнему покажетdata: 90. - Разблокируйте привод через сервис:
Светодиодros2 service call /set_drive_enable std_srvs/srv/SetBool "{data: true}"D48загорится, а сервис вернётsuccess=True, message='Drive enabled'. - Повторите отправку угла
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.
Ответы на вопросы для самопроверки
-
Зачем в ROS 2 нужны сервисы, если в системе уже есть топики, и как один сервис с входным параметром помогает избежать создания множества топиков?
Сервис работает как удалённый вызов функции: клиент передаёт входные аргументы вrequest(например, номер кнопки, пина или числа для расчёта) и получает вычисленный результат вresponse. Благодаря передаче параметров один сервис может обслуживать сразу все кнопки или режимы платы, избавляя от необходимости создавать отдельный топик под каждый запрос и каждый ответ. -
Почему в обработчике сервера сервиса
void onSetLed(std_srvs::SetBool& srv)параметр принимается по ссылке (&) и почему внутри этой функции нельзя делать долгие паузы?
Передача по ссылке (&) позволяет функции записать результат прямо в поляsrv.response, которые библиотека сразу после выхода из функции отправит клиенту. Долгие паузы внутри обработчика остановят вызовros.update(), из-за чего плата перестанет принимать пакеты и сервис завершится ошибкой по тайм-ауту. -
Чем отличается роль платы при вызове
ros.service()от её роли при вызовеros.call()?
При использованииros.service()плата выступает сервером сервиса (ждёт запросов от компьютера и выполняет их), а при вызовеros.call()плата выступает клиентом сервиса (сама отправляет запрос узлу ROS 2 на компьютере и получает от него ответ). -
Почему вызов
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()
Как устроено решение
- Скользящее среднее (
deque(maxlen=5)): когда в очередьself.windowдобавляется шестой элемент, самый старый первый элемент автоматически удаляется. Поэтомуsum(self.window) / len(self.window)всегда возвращает среднее арифметическое за последние полсекунды (5 измерений по 100 мс), убирая резкие рывки сервопривода. - Экономия команд для светодиода (
self.last_alarm): угол сервопривода обновляется плавно при каждом измерении, а команда включения или выключения светодиода/ledи запись в журнал отправляются только тогда, когда статус тревоги изменился.
Ответы на вопросы для самопроверки
-
Какими пятью функциями объекта
rosможно отправить текстовое сообщение с платы в системный журнал/rosout?
Функциямиros.logDebug(),ros.logInfo(),ros.logWarn(),ros.logError()иros.logFatal(). -
Зачем нужна функция
ros.now()и чем возвращаемое ею время отличается отmillis()?
Функцияmillis()отсчитывает миллисекунды с момента включения самой платы, тогда какros.now()возвращает структуруbuiltin_interfaces::msg::Time(секунды и наносекунды), синхронизированную черезrosduino_agentс системными часами компьютера ROS 2. Единое время позволяет узлам робота отбрасывать устаревшие сообщения, которые при задержке связи могли бы привести к аварии. -
Какой топик ROS 2 позволяет проверить связь платы с
rosduino_agentи что в нём означает статусWARN? Стандартный диагностический топик/diagnostics. СтатусWARNозначает, что связь с платой временно потеряна (например, плата перезагружается или отключён кабель) либо одна из объявленных в скетче сущностей не зарегистрировалась. -
В чём преимущество размещения пороговой логики и фильтрации сигнала в Python-узле на компьютере вместо скетча на плате? Скетч на микроконтроллере остаётся простым и прошивается всего один раз, а все пороги, фильтры и алгоритмы принятия решений на Python можно менять, отлаживать и перезапускать за секунду без остановки агента и без перепрошивки платы.
-
Зачем нужен 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,
])
Как устроено решение
- Сжатие данных лидара для микроконтроллера (
/scan→/panel/distance): сообщениеsensor_msgs/msg/LaserScanсодержит сотни чисел с плавающей точкой, которые избыточны для индикации на плате. Python-узел на Raspberry Pi отбрасывает некорректные лучи за пределами(msg.range_min, msg.range_max), находит одно минимальное числоmin(valid)и передаёт его в компактном сообщенииstd_msgs/msg/Float32(всего4 байта). - Шкала парктроника на стороне Arduino (
onDistance): плата принимает расстояние в метрах и через функциюshowLitCount()включает от0до4светодиодовD48–D51. Индикация работает непрерывно даже тогда, когда робот стоит на месте. - Надёжный старт и стоп по кнопкам: благодаря вызовам
ros.advertise()вsetup()топики/panel/btn_startи/panel/btn_stopсоздаются сразу при запуске агента, поэтому и старт по кнопкеD28, и остановка по кнопкеD15срабатывают с первого нажатия. При получении сигнала «Стоп» (а также при остановке скрипта поCtrl+C) в/cmd_velсразу отправляется пустое сообщениеTwist()с нулевой скоростью.
Как проверить решение
- Загрузите скетч в плату через разъём DUE, затем по SSH запустите связку на Raspberry Pi:
ros2 launch ~/ros2_ws/parktronic.launch.py - Поднесите ладонь к лидару и плавно меняйте расстояние от
1 мдо20 см— светодиодыD48–D51на плате будут загораться и гаснуть ступенями от0до4. - Поставьте робота на подставку и нажмите кнопку
D28— колёса начнут плавно вращаться вперёд (linear.x = 0.10), а светодиоды продолжат показывать дистанцию по лидару. - Нажмите кнопку
D15— колёса мгновенно остановятся (linear.x = 0.0).
Ответы на вопросы для самопроверки
-
Какие два микроконтроллера установлены на плате робота TurtleBro и почему загрузка собственного скетча в Arduino Due не может нарушить работу приводов шасси?
На плате установлены системный микроконтроллерSTM32F4(отвечает за колёса, энкодеры, IMU и базовые топики движения) и пользовательский микроконтроллерArduino Due(отвечает за кнопки, светодиоды, сервоприводы и разъёмы GPIO). Они работают независимо и подключены к разным USB-портам, поэтому прошивкаArduino Dueникак не затрагивает программу управления шасси. -
Через какой порт микроконтроллера (
SerialилиSerial1) плата общается с Raspberry Pi на роботе и почему при прошивке с компьютера через разъём DUE не нужно переключать провода?
На роботе связь микроконтроллера с Raspberry Pi разведена на плате через второй аппаратный портSerial1(ros.begin(Serial1, "имя_узла")), а разъём USB-C с надписью DUE (Serial, Programming Port) используется только для загрузки скетчей с компьютера. Поскольку это два разных независимых порта, переключать провода или останавливать агент на роботе во время прошивки не нужно. -
В какой штатный топик робота TurtleBro нужно публиковать сообщения
geometry_msgs/msg/Twist, чтобы управлять его движением?
В топик/cmd_vel(twist.linear.xзадаёт линейную скорость вперёд/назад в м/с, аtwist.angular.z— угловую скорость поворота в рад/с). -
Какой командой с помощью
rosduino-genможно создать заголовочные файлы для Arduino из собственного пакета сообщенийmy_robot_msgs?
Командойros2 run rosduino_gen rosduino-gen --package my_robot_msgs --out "$HOME/Arduino/libraries/RosDuino/src".
Назад: Домашнее задание.