В робототехнике с управлением жестами традиционные кнопки и джойстики заменяются естественными движениями рук. Такой подход улучшает взаимодействие с пользователем и снижает механическую зависимость от физических контроллеров. Датчики фиксируют движение, преобразуют его в цифровые данные и в реальном времени переводят эти данные в движение робота.
В этом проекте демонстрируется робот с управлением жестами, использующий веб-камеру ноутбука, библиотеку OpenCV и MediaPipe для управления жестами рук в реальном времени. Управление жестами с помощью OpenCV позволяет системе обнаруживать и интерпретировать движения, захваченные камерой, для управления направлением движения робота, в то время как радиомодуль nRF24L01 передает команды по беспроводной связи от передатчика Arduino Nano к приемнику Arduino Nano, установленному на вездеходе. Драйвер двигателя L298N на стороне приемника преобразует эти команды в действия двигателя.
Исходный код проекта робота с управлением жестами рук разработан с учетом простоты, надежности и низкой стоимости компонентов, которые легко найти и собрать. Полный исходный код проекта робота с управлением жестами рук также доступен на GitHub, что упрощает его изучение и развитие другими разработчиками. Эта настройка робота с управлением жестами рук на основе OpenCV закладывает прочную основу для сложных проектов взаимодействия человека и машины. Для получения дополнительной информации о других интересных проектах с управлением жестами, ознакомьтесь с нашим проектом «Робот с управлением жестами на основе Arduino». Также на нашем сайте вы можете посмотреть все проекты, использующие библиотеку OpenCV.
Возможно, вас заинтересуют и другие проекты, посвященные управлению жестами:
- распознавание жестов рук с помощью ESP32, Python и OpenCV;
- распознавание жестов и его применение в машинном обучении;
- модуль распознавания жестов PAJ7620 и как его подключить к Arduino;
- управляемый жестами видеоплеер на Raspberry Pi и MediaPipe.
Этот робот с управлением жестами работает на основе трехкомпонентной беспроводной архитектуры управления. Программа на Python, работающая на ноутбуке, захватывает жесты рук через веб-камеру, распознает их с помощью OpenCV и MediaPipe и отправляет последовательные команды на передатчик Arduino Nano. Передатчик передает эти команды по беспроводной связи на приемник Nano на вездеходе, который управляет двигателями через драйвер L298N.
Приложение на Python обрабатывает каждый кадр с камеры в реальном времени. MediaPipe обнаруживает 21 ориентир на руке, и программа использует относительное положение кончиков пальцев и суставов для определения того, какие пальцы подняты. Каждый паттерн движения пальца соответствует определенной команде движения, такой как «Вперед», «Назад», «Влево», «Вправо» или «Стоп».
После определения необходимого действия Python отправляет односимвольную команду по USB-последовательному интерфейсу на передатчик Nano. Передатчик упаковывает данные и передает их по беспроводной связи через модуль nRF24L01. Приемник Nano постоянно находится в режиме прослушивания и выполняет подпрограмму управления двигателем, как только поступает действительная команда. Такая модель прямого выполнения минимизирует задержку и обеспечивает отзывчивость марсохода при управлении жестами рук в реальном времени.
Необходимые компоненты
- Плата Arduino Nano - 2 шт. (купить на AliExpress).
- Модуль nRF24L01 - 2 шт. (купить на AliExpress).
- Драйвер двигателя L298N (купить на AliExpress).
- Шасси с 4-колесным редукторным двигателем постоянного тока.
- Ноутбук с веб-камерой.
- Внешний аккумуляторный блок 12 В.
- Макетная плата.
- Соединительные провода.
Реклама: ООО "АЛИБАБА.КОМ (РУ)" ИНН: 7703380158
Внешний вид компонентов для сборки робота, управляемого жестами, представлен на следующем рисунке.
Как работает робот, управляющий жестами рук в реальном времени
Робот, управляющий жестами рук в реальном времени, использует трехступенчатую беспроводную архитектуру: система машинного зрения на ноутбуке, радиочастотная связь через nRF24L01 и управление двигателями на вездеходе.
Кратко алгоритм действий данного проекта выглядит следующим образом:
Скрипт на Python на вашем ноутбуке захватывает кадры с веб-камеры → OpenCV переворачивает и преобразует цвет каждого кадра → MediaPipe обнаруживает 21 ориентир на руке → шаблоны пальцев сопоставляются с командами (F / B / L / R / S) → PySerial отправляет команду на передатчик Arduino Nano → nRF24L01 передает данные по беспроводной связи на марсоход → приемник Nano управляет двигателями через L298N. Задержка между конечными точками составляет менее 150 мс.
Более подробно принцип дествия нашего робота представлен в следующей таблице:
Обзор беспроводного модуля nRF24L01
nRF24L01 — это маломощный беспроводной приемопередатчик, предназначенный для связи на коротких расстояниях. Он работает в диапазоне ISM 2,4 ГГц и поддерживает быструю и надежную передачу данных между микроконтроллерами. Модуль использует интерфейс SPI, что позволяет плате Arduino Nano отправлять и получать данные с точным контролем и синхронизацией. Небольшие размеры и низкая стоимость делают его популярным выбором для проектов беспроводной робототехники. Более подробно про взаимодействие данного модуля с платой Arduino вы можете прочитать в статье "Как работает модуль nRF24L01 и как его подключить к Arduino".
В этом проекте nRF24L01 работает в конфигурации «точка-точка». Один модуль находится в режиме передачи на стороне контроллера, а другой — в режиме приема на стороне робота. Фиксированная адресация и выбор канала гарантируют, что только предназначенный для приема модуль обрабатывает входящие команды.
Схема подключения контактов модуля nRF24L01 к плате Arduino Nano приведена в таблице ниже.
| Контакт nRF24L01 | Контакт Arduino Nano |
| GND | GND |
| VCC | 3.3V |
| CSN | D8 |
| CE | D9 |
| MOSI | D11 |
| MISO | D12 |
| SCK | D13 |
Теперь перейдем непосредственно к схемам передатчика и приемника для нашего проекта.
Схема передатчика
Передающий блок подключается к ноутбуку через USB. Он принимает односимвольные последовательные команды от скрипта управления жестами на Python и передает их по беспроводной связи на ровер с помощью модуля nRF24L01. Интерфейс SPI обеспечивает всю радиосвязь, а последовательный порт USB — связь с ноутбуком.
Поток данных на стороне передатчика выглядит следующим образом: ноутбук (с программным обеспечением Python) отправляет символ через USB на Arduino Nano TX, который считывает этот символ и передает его по беспроводной связи через nRF24L01 на марсоход.
Поток данных на стороне передатчика: ноутбук (Python) → USB-последовательный порт → Передатчик Arduino Nano → nRF24L01 → робот.
Схема передающего модуля приведена на следующем рисунке.
Схема приемника
Приёмный блок размещается на вездеходе и подключается к драйверу двигателя L298N. Он принимает беспроводные команды от передатчика nRF24L01 и управляет двигателями соответствующим образом. Контакт ENB подключен к D10, который является контактом с поддержкой ШИМ на Arduino Nano, что позволяет регулировать скорость обоих каналов двигателя.
| Контакт L298N | Контакт Arduino Nano | Функция |
| IN1 | D2 | Двигатель A Направление 1 |
| IN2 | D3 | Двигатель A Направление 2 |
| IN3 | D4 | Двигатель B, направление 1 |
| IN4 | D6 | Двигатель B, направление 2 |
| ENA | D5 (PWM) | Регулятор скорости двигателя А |
| ENB | D10 (PWM) | Регулировка скорости двигателя B |
| GND | GND | Общий провод (земля) |
| +12V | Внешний аккумулятор | Мощность двигателя |
| +5V | Nano VIN |
Схема приемного модуля приведена на следующем рисунке.
Установка Python, OpenCV и MediaPipe
OpenCV (Open Source Computer Vision Library) — это мощная библиотека для обработки изображений и видео в реальном времени. В сочетании с MediaPipe от Google она позволяет точно определять ключевые точки на руках непосредственно с веб-камеры ноутбука без необходимости использования дополнительного оборудования.
Шаг 1 ⇒ Установите Python
Загрузите Python 3.10 или 3.11 с сайта python.org. Во время установки установите флажок «Добавить Python в PATH». Это позволит запускать Python из командной строки в любом месте системы.
Шаг 2 ⇒ Создайте папку проекта и виртуальную среду
Откройте командную строку (не PowerShell) и выполните следующие команды:
|
1 2 3 4 |
mkdir hand_gesture_project cd hand_gesture_project python -m venv venv venv\Scripts\activate |
Виртуальная среда изолирует все зависимости проекта. Префикс (venv) в терминале подтверждает, что среда активна.
Шаг 3 ⇒ Установите необходимые библиотеки
Используйте приведенную ниже команду для установки opencv-python, mediapipe и pyserial.
|
1 |
pip install opencv-python mediapipe pyserial |
Список библиотек и их назначение приведены в таблице ниже.
| Библиотека | Функция |
| opencv-python | Захват изображения с камеры и обработка кадров изображения |
| mediapipe | Обнаружение ключевых точек на руке с помощью Google (21 точка на каждую руку) |
| pyserial | USB-последовательная связь с Arduino TX Nano |
Шаг 4 ⇒ Загрузите модель ручного ориентира MediaPipe
При первом запуске скрипт на Python автоматически загружает файл модели hand_landmarker.task (~9 МБ) с сайта Google. Подключение к интернету требуется только для этой одноразовой загрузки. Скрипт проверяет наличие файла перед загрузкой, чтобы избежать повторных загрузок.
Как OpenCV и MediaPipe взаимодействуют в конвейере управления жестами
OpenCV захватывает кадры с веб-камеры ноутбука в виде массивов NumPy в формате BGR. Каждый кадр зеркально отражается по горизонтали для создания естественного зеркального эффекта, затем преобразуется в RGB и передается в MediaPipe. MediaPipe обрабатывает кадр и возвращает координаты X и Y 21 контрольной точки руки. Код на Python сравнивает положения контрольных точек, чтобы определить, какие пальцы подняты, и сопоставляет рисунок пальцев с командой для робота.
| Указатель контрольной точки руки | Часть тела |
| 0 | Запястье |
| 4 | Кончик большого пальца |
| 8 | Кончик указательного пальца |
| 12 | Кончик среднего пальца |
| 16 | Кончик безымянного пальца |
| 20 | Кончик мизинца |
На изображении ниже показаны указательные точки кисти руки.
Сопоставление жестов и команд для управления жестами рук в реальном времени
Этот скрипт на Python определяет жесты рук, анализируя положение 21 контрольной точки, предоставленной MediaPipe. Палец считается поднятым, если координата Y его кончика на экране ниже, чем координата Y средней фаланги, поскольку в координатах изображения ось Y увеличивается вниз. Для сравнения используется ось X, поскольку большой палец движется горизонтально.
Каждый жест создает уникальную комбинацию поднятых пальцев, представленную в виде бинарного списка из пяти значений для большого, указательного, среднего, безымянного пальцев и мизинца. Этот список сопоставляется с предопределенными шаблонами жестов для назначения команды роботу. Полная логика является частью исходного кода проекта робота с управлением жестами рук.
| Жест | Пальцы вверх | Команда | Движение робота |
| Точка (только указатель) | [0,1,0,0,0] | F | Move Forward (движение вперед) |
| Знак мира / V | [0,1,1,0,0] | B | Move Backward (движение назад) |
| Пистолет (большой палец + указательный палец) | [1,1,0,0,0] | L | Turn Left (поворот налево) |
| Три пальца | [1,1,1,0,0] | R | Turn Right (поворот направо) |
| Открытая ладонь | [1,1,1,1,1] | S | Stop |
| Кулак | [0,0,0,0,0] | S | Stop |
Количество отправляемых команд ограничено до одного раза в 150 миллисекунд, чтобы предотвратить перегрузку последовательного порта. Если в кадре не обнаружена рука, автоматически отправляется команда «Стоп» для обеспечения безопасности марсохода.
Беспроводная связь между передатчиком и роботом с использованием nRF24L01
Модуль nRF24L01 обеспечивает всю беспроводную связь между передатчиком Nano и роботом. Оба модуля настроены с одинаковым адресом канала, самим каналом, скоростью передачи данных и уровнем мощности, чтобы гарантировать, что они обмениваются данными только друг с другом.
Python отправляет один символ, например F, B, L, R или S, по USB-последовательному интерфейсу на передатчик Nano. Nano считывает символ, упаковывает его в двухбайтовый пакет данных и передает через nRF24L01. Приемник Nano на ровере находится в режиме непрерывного прослушивания и немедленно запускает соответствующую функцию двигателя при получении действительной команды.
Использование уровня мощности RF24_PA_LOW повышает стабильность на малых расстояниях и снижает энергопотребление. Фиксированный канал на частоте 108 МГц предотвращает помехи от распространенных диапазонов Wi-Fi. Компактная односимвольная полезная нагрузка обеспечивает минимальное время передачи и низкую задержку ответа.
Объяснение кода проекта
Программы на Python
Скрипт распознавания жестов на Python (gesture.py)
Этот скрипт запускается на ноутбуке. Он захватывает кадры с веб-камеры, обнаруживает ориентиры рук с помощью MediaPipe, классифицирует жест и отправляет символ команды по последовательному порту на TX Nano. Это составляет основу робота, управляемого жестами рук, с использованием конвейера OpenCV. Первое, что делает этот скрипт, — это пытается установить последовательное соединение с платой Arduino, используя COM-порт и скорость передачи данных, определенные вверху. Двухсекундная задержка важна, потому что Arduino перезагружаются в момент установления последовательного соединения, и отправка данных до его завершения приведет к тому, что ничего не будет передано. Если соединение не удается, скрипт просто устанавливает Arduino в None и продолжает работу, поэтому вы можете протестировать систему машинного зрения без подключения какого-либо оборудования.
Последовательное соединение с Arduino
|
1 2 3 4 5 |
try: arduino = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1) time.sleep(2) except Exception as e: arduino = None |
Модель распознавания рук берет на себя всю основную работу по определению того, как выглядит ваша рука на камере. Вместо того чтобы заставлять пользователя вручную искать и скачивать файл, скрипт проверяет, существует ли он уже; если нет, он автоматически загружает его с серверов Google. Это упрощает процесс настройки и позволяет любому запустить скрипт без необходимости читать дополнительные инструкции.
Автоматическая загрузка модели
|
1 2 3 |
if not os.path.exists(MODEL_PATH): urllib. request.urlretrieve('https://storage.googleapis.com/mediapipe-models/ hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task', MODEL_PATH) |
Эта функция определяет, какие пальцы подняты, а какие согнуты, сравнивая положение кончика каждого пальца с положением сустава на два шага ниже. Если кончик на экране находится выше этого сустава, палец считается поднятым, в противном случае — получает 0. Большой палец обрабатывается отдельно, поскольку он сгибается вбок, поэтому сравнивается горизонтальное положение, а не вертикальное.
Обнаружение состояния пальцев
|
1 2 3 |
fingers.append(1 if landmarks[4].x < landmarks[3].x else 0) for tip in TIP_IDS[1:]: fingers.append(1 if landmarks[tip].y < landmarks[tip-2].y else 0) |
Как только список состояний пальцев будет готов, эта функция сопоставляет его с предопределенными шаблонами, чтобы определить, что должен делать марсоход. Каждый шаблон соответствует команде направления, короткому буквенному коду для отправки по последовательному порту и цвету для наложения на экран. Любая комбинация, не соответствующая известному жесту, по умолчанию приводит к остановке, что является разумным решением с точки зрения безопасности, чтобы марсоход никогда не продолжал движение, если сигнал руки неясен.
Сопоставление жестов и команд
|
1 2 3 |
if f == [0,1,0,0,0]: return ('FORWARD', 'F', (0,255,0)) if f == [0,1,1,0,0]: return ('BACKWARD', 'B', (0,0,255)) if f == [1,1,1,1,1]: return ('STOP', 'S', (0,255,255)) |
Основной цикл работает непрерывно, пока вы не нажмете Q для выхода. Каждый кадр переворачивается, как зеркало, и преобразуется в RGB, прежде чем передаваться на детектор, а результат управляет как отображением метки на экране, так и командой в последовательном порту. Проверка времени гарантирует, что Arduino не будет перегружен сотнями одинаковых сообщений в секунду, что могло бы привести к непредсказуемому поведению.
Код передатчика для Arduino (TX Nano)
Эта программа используется для отправки беспроводных команд с помощью радиочастотного модуля nRF24L01. Она считывает один символ из последовательного монитора и передает его на другой модуль nRF24. Основное назначение этого кода — выступать в качестве передатчика (TX), отправляющего команды управления, такие как «Вперед», «Назад», «Влево», «Вправо» и «Стоп».
|
1 2 3 4 |
#include <SPI.h> #include <RF24.h> RF24 radio(9, 8); // CE=D9, CSN=D8 const byte address[6] = "00001"; |
Во-первых, включены необходимые библиотеки. Библиотека SPI.h необходима, поскольку nRF24L01 использует протокол SPI для связи. RF24.h — это библиотека, упрощающая управление модулем nRF24. Строка RF24 radio(9, 8) создает объект radio и определяет контакты CE и CSN, подключенные к контактам 9 и 8 Arduino. Переменная address определяет адрес канала связи. И передатчик, и приемник должны использовать один и тот же адрес для корректной связи.
|
1 2 3 4 5 6 7 8 9 10 11 |
void setup() { Serial.begin(9600); if (!radio.begin()) { Serial.println("nRF24 not responding! Check wiring."); while (1) {} } radio.openWritingPipe(address); radio.setPALevel(RF24_PA_LOW); radio.stopListening(); Serial.println("TX Ready"); } |
Внутри функции setup() запускается последовательная связь со скоростью 9600 бод, чтобы можно было отправлять команды из последовательного монитора. Функция radio.begin() инициализирует модуль nRF24. Если модуль не отвечает, программа выводит сообщение об ошибке и останавливается, используя бесконечный цикл. Функция openWritingPipe(address) устанавливает адрес для передачи. Функция setPALevel(RF24_PA_LOW) устанавливает уровень мощности модуля на низкий, что подходит для связи на коротких расстояниях и снижает энергопотребление. Функция stopListening() переводит модуль в режим передатчика. Наконец, выводится сообщение «TX Ready», указывающее на готовность передатчика.
|
1 2 |
void loop() { if (Serial.available() > 0) { |
В функции loop() программа постоянно проверяет наличие данных в последовательном мониторе. Функция Serial.available() возвращает количество полученных байтов. Если оно больше нуля, это означает, что символ был введен и отправлен.
|
1 2 3 4 5 6 7 8 9 |
char cmd = Serial.read(); if (cmd=='F'||cmd=='B'||cmd=='L'||cmd=='R'||cmd=='S') { char payload[2]; payload[0] = cmd; payload[1] = '\0'; radio.write(&payload, sizeof(payload)); Serial.print("Sent: "); Serial.println(cmd); } |
В этой программе один символ считывается из последовательного монитора и сохраняется в переменной cmd. Она проверяет, является ли этот символ одной из разрешенных команд: 'F', 'B', 'L', 'R' или 'S'. Если совпадение найдено, создается небольшой массив символов, называемый payload. Символ команды сохраняется в первой позиции, а для корректного завершения строки добавляется нулевой символ ('\0'). Функция radio.write() отправляет этот массив по беспроводной связи приемнику. После отправки программа выводит отправленную команду в последовательный монитор для подтверждения.
Код приемника Arduino (RX Nano на марсоходе)
Этот скетч работает на Arduino Nano, установленном на вездеходе. Он принимает беспроводные команды и управляет двигателями со скоростью 50% через драйвер L298N. ENB подключен к выводу D10, поддерживающему ШИМ, для корректного управления скоростью на обоих каналах. Эта программа выступает в качестве беспроводного приемника, управляющего двумя двигателями постоянного тока с помощью команд, получаемых от модуля nRF24L01. Она в основном используется в простых проектах роботов-автомобилей, где движение управляется дистанционно. Приемник постоянно принимает односимвольные команды, такие как «F» (вперед), «B» (назад), «L» (влево), «R» (вправо) и «S» (стоп). При получении действительной команды он обрабатывает этот символ и управляет двигателями в нужном направлении. Общая структура проста: беспроводной прием данных, идентификация команды и соответствующее управление двигателями.
|
1 2 |
RF24 radio(9, 8); const byte address[6] = "00001"; |
Эти две строки создают объект радиосвязи и определяют беспроводной адрес. Строка RF24 radio(9, 8); инициализирует модуль nRF24L01, указывая, что вывод CE подключен к цифровому выводу 9, а вывод CSN — к цифровому выводу 8 Arduino. Эти выводы отвечают за управление связью между Arduino и радиочастотным модулем через SPI. Адрес, определенный в следующей строке, действует как имя канала связи. И передатчик, и приемник должны использовать один и тот же адрес; в противном случае они не смогут обмениваться данными друг с другом.
|
1 2 |
#define IN1 2 #define IN2 3 |
Эти строки определяют два цифровых контакта, подключенных к входам драйвера двигателя. Они управляют направлением вращения первого двигателя. Устанавливая эти контакты в состояние HIGH или LOW в различных комбинациях, двигатель может вращаться вперед или назад. Эти контакты не управляют скоростью; они управляют только направлением. Использование директивы #define упрощает чтение и модификацию кода, поскольку вы можете изменить контакт в одном месте, вместо того чтобы искать его по всей программе.
|
1 2 |
#define IN1 2 #define IN2 3 |
Эти линии определяют контакты управления направлением вращения второго двигателя. Как и контакты IN1 и IN2, эти контакты определяют, вращается ли второй двигатель вперед или назад. В двухколесном роботе-машине один двигатель управляет левым колесом, а другой — правым. Изменяя направление вращения каждого двигателя независимо, робот может двигаться вперед, назад, а также поворачивать влево и вправо.
|
1 2 |
#define ENA 5 #define ENB 10 |
Эти два контакта подключены к контактам разрешения драйвера двигателя. В отличие от контактов IN, контакты ENA и ENB используются для управления скоростью. Поскольку эти контакты поддерживают ШИМ (широтно-импульсную модуляцию), функция analogWrite() может использоваться для изменения напряжения, подаваемого на двигатели. Это позволяет плавно регулировать скорость вращения двигателей, вместо того чтобы запускать их только на полной скорости.
|
1 |
int motorSpeed = 128; |
Эта переменная хранит значение скорости, которое будет подаваться на оба двигателя. Значения ШИМ варьируются от 0 до 255, где 0 означает полное выключение, а 255 — максимальную скорость. Значение 128 соответствует примерно 50% коэффициенту заполнения, что обеспечивает умеренную скорость вращения двигателей. Это позволяет роботу двигаться стабильно и контролируемо, а не слишком быстро.
|
1 2 |
radio.begin(); radio.startListening(); |
Эти строки инициализируют модуль nRF24 и переводят его в режим приема. Функция radio.begin() начинает связь с модулем и подготавливает его к работе. Функция radio.startListening() переключает модуль в режим приемника, чтобы он мог непрерывно ожидать входящих данных от передатчика. Без этой функции модуль не будет принимать команды.
|
1 2 |
if (radio.available()) radio.read(&payload, sizeof(payload)); |
Эти строки проверяют, были ли получены какие-либо беспроводные данные. Функция radio.available() возвращает true, если в буфере ожидают новые данные. Если данные доступны, они считываются в массив полезной нагрузки с помощью функции radio.read(). Эта полезная нагрузка содержит символ команды, отправленный передатчиком. После считывания программа извлекает первый символ и использует его для определения направления движения двигателей.
|
1 2 |
if (cmd=='F') moveForward(); else if (cmd=='S') stopMotors(); |
Эти строки демонстрируют, как полученная команда управляет движением робота. Если получен символ «F», вызывается функция moveForward(), которая устанавливает контакты направления двигателя и регулирует скорость с помощью ШИМ. Если команда «S», выполняется функция stopMotors(), которая отключает движение двигателя, устанавливая скорость на ноль и отключая все контакты направления. Аналогичные условия существуют для движения назад и поворотов. Эта простая структура принятия решений позволяет роботу немедленно реагировать на беспроводные команды управления.
Тестирование работы проекта
Тестирование было направлено на проверку точности распознавания жестов, надежности последовательной связи, стабильности беспроводной связи и реакции моторики. Для надежного первого теста выполните следующие действия:
- Загрузите код TX в Nano, подключенный к ноутбуку. Откройте монитор последовательного порта (9600 бод) и введите F — подтвердите, что отобразилось сообщение Sent: F.
- Подключите RX Nano к ноутбуку отдельно. Откройте его последовательный монитор и убедитесь, что при передаче TX отображается сообщение Received: F.
- Перед запуском Python закройте ВСЕ последовательные мониторы.
- Установите RX Nano на марсоход и подключите его к L298N. Питайте марсоход от 12-вольтовой батареи.
- Запустите python gesture.py на ноутбуке. Покажите жесты рук камере и понаблюдайте за движением марсохода.
Ровер мгновенно реагирует на изменения жестов, обеспечивая плавные переходы между направлениями движения. На экране в режиме реального времени отображается название активного жеста, количество нажатий пальцами и статус последовательного соединения.
Применение робота, управляемого жестами рук
Роботы, управляемые жестами рук, обеспечивают интуитивно понятное управление без физических интерфейсов. Та же логика управления, которая используется в этом проекте, легко масштабируется для более сложных роботизированных систем.
- Роботизированные транспортные средства с дистанционным управлением и вездеходы для наблюдения.
- Роботы-помощники для выполнения основных задач, связанных с передвижением.
- Образовательные платформы для изучения компьютерного зрения и встроенных систем.
- Эксперименты с человеко-машинным интерфейсом.
- Бесконтактные системы управления для опасных сред.
- Прототипы моделей управления для промышленной робототехники и автоматизации.
Перспективы усовершенствования робота с управлением жестами с использованием OpenCV
Этот проект обеспечивает прочную основу, но ряд улучшений может повысить производительность, надежность и удобство его использования. Возможные улучшения:
- Добавить поддержку жестов двумя руками для одновременного управления скоростью и направлением.
- Реализовать регулировку скорости вращения двигателя в зависимости от количества пальцев или расстояния руки от камеры.
- Добавить функцию обнаружения препятствий с помощью ультразвуковых или инфракрасных датчиков на вездеходе.
- Для повышения эффективности заменить символьные команды структурированными пакетами данных.
- Использовать внешние антенные модули nRF24L01 для увеличения дальности беспроводной связи.
- Добавить видеопоток в реальном времени с камеры, установленной на марсоходе.
- Обучите собственный классификатор жестов с помощью scikit-learn для большего разнообразия жестов.
Часто задаваемые вопросы
⇥ Почему nRF24L01 требует питания 3,3 В?
В nRF24L01 используется внутренняя радиочастотная схема, работающая строго при напряжении 3,3 В; подача 5 В приводит к необратимому повреждению внутреннего приемопередатчика. Даже кратковременное воздействие более высокого напряжения вызывает нестабильную передачу или полный отказ модуля. Стабилизированное напряжение 3,3 В с надлежащим заземлением обеспечивает стабильную работу беспроводной связи.
⇥ Почему монитор последовательного порта закрывается перед запуском Python?
Python и монитор последовательного порта Arduino IDE не могут одновременно использовать один и тот же COM-порт. Тот, кто откроется первым, заблокирует порт, перекрыв другой. Всегда закрывайте монитор последовательного порта перед запуском скрипта Python, иначе подключение не удастся из-за ошибки «Отказано в доступе».
⇥ Почему скорость двигателя ограничена 50%?
Микросхема L298N и редукторные двигатели постоянного тока могут потреблять более 5 А на полной скорости под нагрузкой, что может привести к перегреву драйвера двигателя и быстрой разрядке батареи. Установка параметра motorSpeed на 128 из 255 ограничивает коэффициент заполнения ШИМ до 50%, поддерживая потребление тока в безопасных пределах и обеспечивая достаточный крутящий момент для движения.
⇥ Каков максимальный рабочий диапазон системы?
При использовании RF24_PA_LOW надежный диапазон обычно составляет от 10 до 30 метров в помещении, в зависимости от препятствий и помех. Переключение на RF24_PA_HIGH с развязывающим конденсатором между выводами VCC и GND nRF24 может еще больше увеличить диапазон. Открытые пространства обеспечивают лучшую производительность, чем закрытые помещения.
⇥ Можно ли это сделать без виртуальной среды?
Да, но виртуальная среда настоятельно рекомендуется. Она предотвращает конфликты версий библиотек между проектами. Если вы используете PowerShell, активируйте скрипт с помощью venv\Scripts\Activate.ps1 после разрешения выполнения скриптов или переключитесь на командную строку и используйте вместо этого venv\Scripts\activate.
⇥ Что если марсоход начнет двигаться в неправильном направлении?
Поменяйте местами определения IN1 и IN2 в коде Arduino для соответствующей стороны двигателя. В качестве альтернативы, физически поменяйте местами два провода двигателя, идущие к выходным клеммам L298N для этого канала. Обратная полярность двигателя не приведет к повреждению оборудования.
Заключение
Этот проект робота с управлением жестами рук на основе OpenCV представляет собой полноценную и практичную встроенную систему, объединяющую компьютерное зрение, последовательную связь и беспроводное управление двигателями в единую рабочую конструкцию. Скрипт на Python точно захватывает движения рук с помощью стандартной веб-камеры ноутбука, классифицирует жесты с использованием OpenCV и анализа ориентиров MediaPipe и надежно отправляет команды по последовательному интерфейсу USB. Передатчик Arduino Nano передает эти команды по беспроводной связи на робота через модуль nRF24L01, а приемник Nano преобразует их в плавные движения двигателей через драйвер L298N с безопасной скоростью 50%.
Конструкция позволяет избежать излишней сложности за счет использования простой логики жестов, стабильных настроек связи и прямого управления контактами, что делает систему простой для понимания, отладки и расширения. Этот проект служит мощной учебной платформой для компьютерного зрения, беспроводной робототехники и взаимодействия человека с машиной, а также обеспечивает прочную основу для будущих усовершенствований, таких как управление переменной скоростью, поддержка нескольких жестов и автономное предотвращение столкновений с препятствиями.
Репозиторий GitHub робота, управляемого жестами рук
Если вам нужны файлы проекта, схемы подключения или примеры видеороликов, они аккуратно хранятся в этом репозитории GitHub.
Похожие статьи
(Проголосуй первым!)
Загрузка...