Представьте себе сцену из научной фантастики: робот-манипулятор, который не просто выполняет запрограммированные движения, а ведет себя естественно, плавно и предсказуемо. Когда вы берете его за руку, он не сопротивляется, не дрожит и не падает под собственным весом. Он словно «исчезает», позволяя вам направлять его с минимальным усилием. Это не магия, а результат сложнейших вычислений, выполняемых в реальном времени. В основе такого поведения лежит контур гравитационной компенсации (gravity compensation) — алгоритм, который непрерывно рассчитывает моменты сил, необходимые для противодействия гравитации, действующей на каждое звено робота.
Для разработчиков робототехники это не просто академическое упражнение. Это фундаментальный тест на зрелость как модели робота, так и среды выполнения (runtime), которая эти алгоритмы исполняет. Если модель неточна, робот будет провисать или, наоборот, выталкивать руку оператора. Если же среда выполнения имеет высокие задержки или джиттер, система станет нестабильной, что может привести к поломке оборудования или травмам при совместной работе с человеком (cobots).
В этой статье мы подробно разберем, как реализовать такой контур с использованием NVIDIA Holoscan 5, библиотеки кинематики Pinocchio и доступного манипулятора Seeed Studio reBot Arm B601-DM. Мы покажем, как использовать графовую модель Holoscan для создания высокопроизводительного цикла управления, как настроить очереди данных для предотвращения накопления устаревших команд и как с помощью встроенных инструментов профилирования Nsight Systems добиться снижения задержек в 5–10 раз за счет привязки процессов к ядрам CPU.

01Почему Holoscan 5? Архитектура для гибридных нагрузок
Традиционно разработка робототехнических приложений разделялась на две части: высокопроизводительное восприятие (perception), которое часто выполняется на GPU с использованием глубокого обучения, и управление (control), которое требует детерминированности и низкой задержки, обычно реализуясь на CPU. NVIDIA Holoscan 5 стирает эту границу, предлагая единую модель программирования, которая поддерживает как CPU, так и GPU рабочие нагрузки.
Ключевая философия Holoscan — прозрачность среды выполнения. Цель разработчиков SDK — минимизировать накладные расходы фреймворка, сделав выполнение приложения явным и наблюдаемым. Это особенно важно в робототехнике, где каждая миллисекунда имеет значение. Holoscan позволяет разработчикам и их AI-агентам четко выражать намерения выполнения, используя одни и те же операторы, порты и API графов, логически разделяя рабочие нагрузки на отдельные графы, которые могут сосуществовать.
Одной из важнейших особенностей Holoscan 5 является концепция Partition (Разделов). Разделы позволяют группировать цепочки операторов в одном потоке, избегая передач данных между потоками (cross-thread handoffs) и ненужных системных вызовов. Это критически снижает задержку и джиттер. Кроме того, Holoscan поддерживает привязку разделов к выделенным ядрам CPU, контекстам CUDA Green или даже выполнение в виде CUDA Graph, что дает разработчикам полный контроль над распределением ресурсов.
02Платформа для разработки: Seeed Studio reBot Arm B601-DM
Для демонстрации мы используем манипулятор Seeed Studio reBot Arm B601-DM. Почему именно он? Большинство недорогих платформ для разработки роботизированных рук используют сервоприводы с высоким передаточным числом (highly-geared hobby servos). Такие приводы подходят только для позиционного контроля, но они «глухие» к силам: вы не можете почувствовать, с каким усилием робот взаимодействует с объектом.
reBot Arm использует актуаторы с квази-прямым приводом (Quasi-Direct-Drive, QDD). Это обеспечивает высокую полосу пропускания момента (torque bandwidth), что критически важно для тактильных интерфейсов, коботов и проектов, ориентированных на управление моментом. QDD-приводы позволяют роботу не только точно позиционировать конечный захват, но и чувствовать внешние силы, что делает возможным реализацию гравитационной компенсации и мягкой импедансной регуляции.
Эта платформа доступна по цене и проста в настройке, что делает её идеальным стартовым полигоном для освоения современных методов управления роботами. В сочетании с Holoscan она позволяет перейти от простого позиционирования к сложному силовому взаимодействию.

03Основы гравитационной компенсации
Прежде чем добавлять сложные конвейеры восприятия или планировщики движений, полезно начать с базового контура гравитационной компенсации. Это своего рода «проверка здоровья» (sanity-check) вашей системы. Если ваша математическая модель робота (URDF-файл) точно описывает физические свойства звеньев — их массы, моменты инерции, длины и смещения осей — то робот сможет удерживать свое положение без активного участия моторов в поддержании статики.
В нашем примере мы комбинируем гравитационную компенсацию с легкой жесткостью (stiffness) и демпфированием (damping). Это означает, что робот поддерживает свой вес, но при этом податлив: если вы попытаетесь сдвинуть его руку, он мягко уступит, а не будет сопротивляться. Такая гибкость делает взаимодействие безопасным и естественным.
Для расчетов мы используем библиотеку Pinocchio. Она загружает URDF-модель робота и предоставляет решатель рекурсивного алгоритма Ньютона-Эйлера (RNEA). Этот алгоритм вычисляет моменты на сочленениях, необходимые для поддержания заданных положений, скоростей и ускорений. Параллельно мы используем библиотеку motorbridge для чтения обратной связи с энкодеров и отправки команд на моторы.
04Архитектура решения: Три оператора Holoscan
В Holoscan 5 приложение строится на двух концепциях: Operators (Операторы) и Graphs (Графы). Для реализации контура гравитационной компенсации мы разбиваем задачу на три логических оператора, которые соединяются в граф:
- JointStateSourceOp: Читает состояние всех суставов (углы, скорости) с моторов.
- PinocchioGravityOp: Принимает состояние, рассчитывает необходимый момент компенсации с помощью Pinocchio и добавляет демпфирующие коэффициенты.
- MotorCommandSinkOp: Отправляет рассчитанные команды на моторы.
Каждый оператор наследуется от базового класса Operator и реализует три ключевых метода:
setup(): Объявляет входные и выходные порты.contract(): Определяет, когда оператор должен запускаться (триггеры) и какие входные данные использовать.compute(): Основная логика: чтение входных данных, выполнение вычислений и публикация результатов.

1. Источник состояния суставов (JointStateSourceOp)
Этот оператор работает по таймеру. Мы устанавливаем частоту обновления в 400 Гц, что соответствует периоду 2.5 мс. Это высокая частота, необходимая для стабильного управления моментом. Метод OnClock гарантирует, что оператор будет вызываться строго через заданные интервалы.
import holoscan as hsdk
class JointStateSourceOp(hsdk.Operator):
state = hsdk.Output("state", hsdk.pyobject)
def setup(self, spec):
spec.output(self.state)
def contract(self):
# Запуск каждые 2.5 мкс (400 Гц)
return hsdk.Contract().trigger(hsdk.OnClock(period=hsdk.time.us(2500)))
def start(self):
self.sequence = 0
def compute(self, ctx):
self.sequence += 1
# Чтение состояния всех 7 моторов
self.state.emit(robot.read_state(self.sequence))2. Оператор гравитационной компенсации (PinocchioGravityOp)
Это «мозг» системы. Он запускается каждый раз, когда поступает новое состояние от первого оператора (триггер OnEach). Здесь мы используем параметры Param для настройки коэффициентов усиления (kp, kd) и масштабирования момента. Внутри метода compute вызывается функция computeGeneralizedGravity из Pinocchio, которая возвращает вектор моментов, необходимых для компенсации гравитации в текущей конфигурации робота.
class PinocchioGravityOp(hsdk.Operator):
state = hsdk.Input("state", hsdk.pyobject)
command = hsdk.Output("command", hsdk.pyobject)
# Параметры настройки
kp = hsdk.Param(1.5, range=(0.0, 500.0))
kd = hsdk.Param(1.0, range=(0.0, 5.0))
tau_scale = hsdk.Param([1.0] * 6)
joint_direction = hsdk.Param([1.0] * 6)
def setup(self, spec):
spec.input(self.state, queue_depth=1)
spec.output(self.command)
def contract(self):
# Запуск при поступлении каждого нового состояния
return hsdk.Contract().trigger(hsdk.OnEach(self.state))
def compute(self, ctx):
state = self.state.receive_data()
# Расчет момента с учетом гравитации, жесткости и демпфирования
command = controller.compute(
state,
kp=self.kp,
kd=self.kd,
tau_scale=self.tau_scale,
joint_direction=self.joint_direction
)
self.command.emit(command)3. Спуск команд на моторы (MotorCommandSinkOp)
Этот оператор принимает рассчитанные команды и отправляет их на драйверы моторов. Важно отметить, что он также реализует метод stop(), который отключает моторы при завершении работы программы. Это критически важно для безопасности: если программа аварийно завершится, робот не должен оставаться в активном состоянии.
class MotorCommandSinkOp(hsdk.Operator):
command = hsdk.Input("command", hsdk.pyobject)
def setup(self, spec):
spec.input(self.command, queue_depth=1)
def contract(self):
return hsdk.Contract().trigger(hsdk.OnEach(self.command))
def compute(self, ctx):
# Отправка команды на моторы
robot.send_command(self.command.receive_data())
def stop(self):
# Безопасное отключение моторов
robot.disable()05Сборка графа и управление очередями
После определения операторов их необходимо соединить в граф. В Holoscan это делается с помощью метода add_flow. Здесь мы используем две важные настройки:
- queue_depth=1: Очередь глубиной в один элемент. Это означает, что если новый пакет данных приходит, а предыдущий еще не обработан, новый пакет просто заменяет старый. Это предотвращает накопление «хвоста» устаревших данных.
- queue_policy=hsdk.QueuePolicy.DROP_OLDEST: Явное указание отбрасывать самые старые данные. В управлении роботами старая информация о положении бесполезна и даже вредна, так как приводит к задержкам и нестабильности. Нам всегда нужна самая свежая информация.
Далее мы создаем Partition с именем «control» и добавляем в него все три оператора. Это гарантирует, что они будут выполняться последовательно в одном потоке, принадлежащем среде выполнения Holoscan. Это устраняет накладные расходы на синхронизацию между потоками.
graph = hsdk.Graph("rebot-gravity", default_clock=hsdk.RealtimeClock)
source = graph.op(JointStateSourceOp, "joint_feedback")
gravity = graph.op(PinocchioGravityOp, "gravity", **controller.parameters.operator_kwargs())
sink = graph.op(MotorCommandSinkOp, "motor_commands")
# Связывание операторов с очередями глубиной 1
graph.add_flow(source.state, gravity.state, queue_depth=1, queue_policy=hsdk.QueuePolicy.DROP_OLDEST)
graph.add_flow(gravity.command, sink.command, queue_depth=1, queue_policy=hsdk.QueuePolicy.DROP_OLDEST)
# Группировка в один раздел (partition)
graph.partition("control").add(source).add(gravity).add(sink)
# Компиляция графа
plan = hsdk.compile(build_graph(robot, controller))
if not plan:
raise RuntimeError(plan.summary())
# Подготовка и запуск
prepare_gravity_compensation(robot, controller)
hsdk.run_async(plan)06Профилирование и оптимизация задержек с Nsight Systems
Одна из сильных сторон Holoscan — бесшовная интеграция с NVIDIA Nsight Systems. Вам не нужно добавлять декораторы тайминга или писать кастомный код для замеров. Достаточно запустить профилировщик поверх обычного приложения.
Для запуска профилирования используется команда nsys. Флаг -t nvtx включает захват событий NVTX, которые Holoscan автоматически вставляет в код операторов. Это позволяет увидеть в timeline Nsight Systems, как долго выполнялся каждый оператор и как долго данные передавались между ними.
mkdir -p build/profiles
nsys profile -t nvtx --sample=none --backtrace=none --cpuctxsw=none \
-o build/profiles/gravity-python \
build/python-venv/bin/python python/gravity_compensation.pyПосле запуска откройте полученный файл в Nsight Systems. Вы увидите временную шкалу, где четко обозначены этапы: чтение состояния, вычисление в Pinocchio и отправка команды. Это позволяет быстро найти узкие места.
Эффект привязки к ядрам (Core Pinning)
Самое интересное открытие было сделано при тестировании производительности. Мы сравнили четыре конфигурации: C++ и Python, каждая из которых запускалась с привязкой к выделенным ядрам CPU (pinned) и без привязки (unpinned). Для изоляции ядер использовалась временная группа Linux (cgroup), которая резервировала физические ядра и их SMT-побратимов, исключая из них другие процессы.
Результаты оказались впечатляющими. Привязка и изоляция ядер снизили задержку p99.99 (99.99-й перцентиль, то есть худшие 0.01% случаев) примерно в 5 раз для C++ и в 9.6 раз для Python.

| Реализация | p50 (мкс) | p99.99 (мкс) | p99.999 (мкс) |
|---|---|---|---|
| HSDK C++ pinned | 7.1 | 17.2 | 20.7 |
| HSDK C++ unpinned | 15.3 | 86.6 | 133.4 |
| HSDK Python pinned | 93.0 | 142.6 | 1,014.0 |
| HSDK Python unpinned | 113.8 | 1,373.5 | 3,134.1 |
Как видно из таблицы, даже Python-реализация с привязкой к ядрам демонстрирует задержку p99.99 на уровне 142.6 мкс, что вполне приемлемо для многих задач управления. Без привязки этот показатель вырастает до 1.37 мс, что может привести к нестабильности системы. C++ обеспечивает еще более низкие задержки, что делает его предпочтительным выбором для критически важных контуров управления.
07Запуск и тестирование
После компиляции и настройки графа можно запустить приложение. Убедитесь, что робот находится в безопасном домашнем положении (home position). Запустите скрипт:
build/python-venv/bin/python python/gravity_compensation.pyКогда появится сообщение "Gravity compensation active", попробуйте взять руку робота и медленно переместить её. Вы должны почувствовать, что робот поддерживает свой вес, но не сопротивляется вашим движениям. Если робот провисает или, наоборот, выталкивает руку, проверьте URDF-модель и параметры масс/инерции. После тестирования верните робота в домашнее положение и нажмите Ctrl+C для безопасного отключения моторов.
08Что это значит на практике
Этот пример демонстрирует, как NVIDIA Holoscan 5 упрощает разработку сложных робототехнических приложений. Вместо того чтобы писать разрозненные скрипты для чтения сенсоров, математических расчетов и управления моторами, разработчики получают единую, оптимизированную среду. Ключевые выводы:
- Единая модель программирования: Возможность использовать одни и те же API для CPU и GPU задач упрощает архитектуру приложений.
- Детерминированность: Механизмы Partition и Drop-oldest очередей обеспечивают предсказуемость задержек, что критично для управления.
- Инструменты отладки: Встроенная интеграция с Nsight Systems позволяет быстро находить узкие места без написания дополнительного кода.
- Доступность: Использование открытых библиотек (Pinocchio) и доступного железа (reBot Arm) делает передовые технологии управления моментом доступными для широкого круга разработчиков.
Для разработчиков в России и СНГ это особенно актуально, так как Holoscan SDK поддерживает локальный запуск на x86 и Jetson-платформах, что позволяет обходить некоторые ограничения и продолжать разработку робототехнических решений. Скачайте Holoscan 5 SDK, следуйте руководству по гравитационной компенсации и начните создавать роботов, которые чувствуют себя «весомыми» только в вашем воображении.
Скачать Holoscan 5 SDK можно на официальном сайте NVIDIA. Полное руководство по настройке гравитационной компенсации доступно в репозитории Holoscan.
Источник: NVIDIA Developer ↗
