Ардуино управление сервоприводом: Arduino для начинающих. Урок 4. Управление сервоприводом

Для данного примера устанавливать дополнительные библиотеки не нужно, так как библиотека servo устанавливается вместе с Arduino IDE.

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

Итог: Как видим из примеров, применение джойстика достаточно большое в разработке проектов на Arduino и в робототехнике.

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

Не забывайте подписываться на канал Youtube и вступайте в группы в Вконтакте и Facebook.

Всем Пока-Пока.

И до встречи в следующем уроке

Понравилась статья? Поделитесь ею с друзьями:

Файлы для скачивания

Подключения сервопривода к Arduino и управление им с помощью потенциометра.

2015-11-24

Автор Андрей Чепурко

Детали, требуемые для сборки:

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

Итак, приступим.

Для начала берем наш breadboard, потенциометр и провода. Как мы видим на картинке, потенциометр имеет три вывода, к которым мы присоединяем провода следующим образом: красный провод – к выводу 5V, черный к выводу GND, а синий – к выводу А0 . Обратные концы проводом присоединяем к макетной плате таким же образом.

5V иGND будут обеспечивать питание, а через выход А0 значения поворота потенциометра будут поступать на нашу плату. Напомним, гнезда-контакты на макетной плате размещены следующим образом:

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

Теперь пришло время для сервопривода. Он также имеет 3 вывода: черный – это минус питания, красный – плюс питания, и третий вывод, в данном примере – белого цвета, который мы подключаем на любой PWM(ШИМ) вывод Ардуино. В нашем случае мы подключим его к 11 выводу на плате. Таким образом, наше “создание” будет выглядеть примерно так:

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

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

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

Дякуємо Вам за звернення! Ваш відгук з’явиться після модерації адміністратором.

С помощью программы ServoStudio 12 и платы Arduino можно создать своего робота, не написав единой строчки кода

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

При необходимости, созданную последовательность движений можно экспортировать как скетч Arduino IDE, для автономной работы, без ПК. Либо просто как массив значений ключевых точек для дальнейшего использования в своей программе. ServoStudio 12 обладает интуитивно понятным интерфейсом и разобраться в ней может даже новичок. А использование платы Arduino в качестве исполнительного устройства управления – сделало данную систему легко доступной в повторении и изготовлении.

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

Сервопривод – в отличии от коллекторного мотора, позволяет делать поворот на определенный угол. Угол поворота задается шириной импульсов управляющего сигнала. Ширина этих импульсов может меняться в пределах 800 – 2300 мкс.

Для начала работы нам потребуется следующее:

• Плата Arduino Nano/Uno.
• Arduino IDE, чтоб запрограммировать данную плату.
• И ПО ServoStudio 12.

Схема подключения очень проста. Выводы D2-D13 подключаются к управляющим входам сервоприводов. Питание подключается к выводам питания Arduino.

Первым делом в меню программы ServoStudio 12 необходимо выбрать пункт «Генератор кода» и подпункт «Создать скетч ServoStudio HardWare», сохранить данный скетч на диск и открыть в Arduino IDE и залить в Arduino Nano/Uno. Все, аппаратная часть готова! Данное действие производится всего один раз, с новой платой Arduino.

Для начала работы необходимо создать новый проект (меню Файл / Новый). В диалоговом окне выбрать необходимое количество ШИМ каналов (количество сервоприводов), выбрать тип платы тестера и написать имя своего устройства (для удобства).

Теперь об интерфейсе программы

В нижней части расположены инструменты для создания последовательности ключевых точек. Перемещая ползунки регуляторов для соответствующих каналов задается значение ширины импульсов управляющего сигнала (угол поворота сервопривода) на соответствующем канале. Если установить флажок «управлять в реальном времени»- то при перемещении ползунка регулятора будет двигаться сервопривод, подключённый к данному каналу, что очень удобно, так как сразу наглядно видно положение привода в данной точке. После того как установили управляющий сигнал на всех необходимых каналах, нужно создать следующий «кадр» (следующую ключевую точку), при помощи кнопки «Добавить». И таким же образом, при помощи регуляторов, создать новую ключевую точку, и так сколько необходимо. Время, за которое сервоприводы должны повернуться на данный угол, выставляется для каждого кадра отдельно, в поле «время шага», время задается в миллисекундах. Чем больше данное значение– тем медленнее будет перемещение, чем меньше– тем быстрее. В поле «шаг» отображается текущий кадр последовательности. При необходимости, изменяя номер шага в данном поле, можно отредактировать предыдущие шаги. Для удобства, имена каналов можно менять, кликнув 2 раза на названии канала, слева от регулятора.

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

И когда создано какое-то законченное движение (например, шаг вперед), можно сохранить текущую последовательность как отдельную законченную последовательность, нажав кнопку «добавить» на панели «Последовательности», в правой части окна программы. Можно на пример создать несколько последовательностей, для движения вперед, назад, влево, вправо, итд. И эти последовательности можно воспроизводить независимо друг от друга, по двойному щелчку мыши, или из контекстного меню, а также из окна «пульт управления» (но об этом позже). Таким образом, воспроизводя эти последовательности, осуществляется управление устройством (роботом). Так же можно добавлять сохраненные последовательности в основную последовательность, создавая одну большую последовательность действий. Это может быть очень полезно для демонстрации работы устройства.

Так же основную последовательность (которая в данный момент открыта в редакторе), можно экспортировать как скетч для Arduino IDE, для автономного воспроизведения платой Arduino, без участия ПК. Для этого в меню «Генератор кода» необходимо выбрать пункт «Экспорт последовательности» и в диалоговом окне нажать кнопку «Генерировать», после чего данный скетч можно скопировать в буфер обмена, либо сохранить как скетч для Arduino IDE. Дальше этот скетч можно залить обычным образом в контроллер платы Arduino.

Есть возможность воспроизводить данную последовательность циклично либо только один раз, установкой или снятием флажка «повторять циклично». Так же есть возможность экспорта в массив ключевых точек, это может быть полезно, если у вас уже есть своя программа для микроконтроллера и Вам необходимо в ней задать движения, при чем опционально можно добавлять в массив значения времени установки позиции, при помощи установки соответствующего флажка. Если, после прошивки данным скетчем, плату Arduino нужно опять использовать с программой ServoStudio 12 то необходимо опять в меню выбрать пункт «Генератор кода» и подпункт «Создать скетч ServoStudio HardWare», сохранить данный скетч на диск и открыть в Arduino IDE и залить в Arduino Nano/Uno.

Окно «пульт управления»

Позволяет использовать горячие клавиши для воспроизведения отдельных последовательностей. Для начала нужно нажать кнопку «Назначить клавиши», выбрать из выпадающего списка необходимую последовательность и назначить ей горячую клавишу. Когда все установлено- необходимо нажать кнопку «Запомнить». Теперь, пока открыто это окно, при нажатии на горячую клавишу будет воспроизводится назначенная ей последовательность.

Не маловажным есть пункт меню «Исходная позиция» — это положение сервоприводов при включении, либо просто «нормальное положение» для угла поворота сервоприводов. Другими словами, если не хотите, чтоб вашего робота перекосило при включении нужно регуляторами выбрать для него оптимальное положение и выбрать пункт меню «Записать текущий кадр в EEPROM Arduino как исходную позицию», данная функция доступна только для плат Arduino. Так же есть пункты «Записать текущий кадр как исходную позицию» и «Вставить исходную позицию в текущий кадр», это будет очень полезно, если нужно начать новую последовательность и исходной точки. Исходная позиция сохраняется в файле проекта и доступна при открытии файла, так что её не нужно будет заново подбирать.

В программе есть так же возможность ассоциировать файлы проекта с ServoStudio 12. Для этого ее нужно 1 раз запустить с правами администратора. ServoStudio 12 – полностью Portable, состоит из 1 файла (при закрытии программы еще создается файл последнего открытого проекта) и не требует установки.

Более подробно о работе можно посмотреть в видео.

Ссылка на скачивание ПО ServoStudio 12

Немного о планах на будущее:

• Хочу создать приложение для Android, которое могла б открывать файл проекта и можно б было использовать телефон для управления роботом. Управление осуществлять по BlueTooth или WiFi через TCP-UART переходник.
• Так же хочу создать версию на большее количество каналов, для управления более сложными устройствами.
• Добавить обработку сигналов с подключённых датчиков (на пример если впереди препятствие- обойти его).
• Добавить возможность управления цифровыми выходами (на пример для включения светодиодов или чего-то другого)

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

Беспроводное управление механическими устройствами | Научно-технический журнал «ИТ Арктика»

Введение

В быту и на производстве часто встает задача не только автоматизировать некоторые механические операции, используя все преимущества современных микроконтроллеров (МК), но и иметь к ним удаленный доступ с целью управления и мониторинга. Удобно, когда такое соединение устанавливается по беспроводным каналам связи. В связи с высокой массовостью и доступностью технологии Wi-Fi, она во многих случаях является оптимальным решением для таких применений. Данная статья описывает принципы и примеры удаленного управления простыми механическими системами на примере популярного МК ESP8266 и сервиса Blynk.

Управляющий микроконтроллер

ESP8266 – 32-разрядный ARM-микроконтроллер фирмы Espressif. Ключевой особенностью является наличие встроенного интерфейса Wi-Fi. Вместе с тем, ESP8266 обладает полным набором «классической» периферии: АЦП, ШИМ, SPI, UART, I2C и т.д. В сочетании с необычно низкой стоимостью ESP8266 заслужил высокую популярность у широкого круга разработчиков. Следствием этого стало появление множества высокоуровневых надстроек-фреймворков над стандартным SDK – существуют привязки на языках JavaScript, Lua, Arduino С++ [1].

Blynk

Проект Blynk задумывался как быстрый и простой способ организовать удаленный доступ к микроконтроллерным и микрокомпьютерным устройствам со смартфона (по различным протоколам связи). В мобильном приложении Blynk (доступно для Android и iOS) с помощью готовых шаблонов и различных элементов управления и считывания (переключатели, слайдеры, табло, графики и т.д.) создается интерфейс управления удаленным устройством. В свою очередь в код программы МК должны быть внедрены специальные функции библиотеки Blynk [2].

Структура

Рассмотрим связку ESP8266 и Blynk для управления механическими устройствами на примере конструкции дистанционно управляемой по Wi-Fi машинки. Блок-схема тестового стенда приведена на рисунке 1.

Ведущим мотором, отвечающим за движение вперед и назад, выступает простой двигатель постоянного тока (DC motor). Драйвером послужит Н-мост (микросхема L298N или аналогичная), что позволит менять направление вращения без вмешательства в схему. Подавая ШИМ-сигнал на соответствующий вход, мы сможем регулировать обороты двигателя, а, значит, и скорость движения машинки. Важно не забыть установить защитные диоды на выходах драйвера, через которые будет «стекать» ток самоиндукции, возникающий каждый раз при размыкании цепи мотора ШИМ-сигналом. Многие готовые модули драйверов уже обладают подобным решением.

Поворот колес машинки можно осуществить при помощи сервопривода (servo). Современные сервомашинки с внутренней логикой управляются по одному сигнальному проводу так же с помощью ШИМ сигнала – длина импульса задает текущий угол поворота ротора. Важно учесть, что ESP8266 является представителем 3.3-вольтовой логики, поэтому в некоторых случаях может потребоваться какой-либо конвертер уровней (3.3 В в 5 В).

ESP8266 удобно использовать в составе какой-либо платы, например, Witty Cloud [1] или NodeMCU. В их состав, кроме непосредственно контроллера, входит программатор, разъем и преобразователь питания от USB, простейшая периферия.

Все устройство запитывается от 9 В. 5 В через преобразователь подаются на МК и сервопривод, 9 В без понижения служат для вращения DC-мотора.

Настройка Blynk

Управлять получившейся машинкой удобно виртуальным джойстиком на сенсорном экране смартфона, в котором угол отклонения определяет поворот колес (от 0° до 180°, 90° – среднее положение, верхняя и нижняя половины джойстика симметричны относительно данного параметра), а расстояние от центра джойстика пропорционально скорости езды.

Выберем элемент управления «joystick» в приложении Blynk (Рисунок 2) и выделим под него виртуальный пин V1. Границы значений определим следующим образом: по оси X – от 0 до 180, что соответствует предельным углам поворота; по оси Y – от -1023 до 1023, так как разрешение ШИМ – 10 бит, знак задает направление вращения. Интервал пересылки данных от смартфона к МК – каждые 100 мс.

Программа МК

Обратимся теперь к коду МК. Как было сказано в начале статьи, популярность ESP8266 привела к портированию множества высокоуровневых (по отношению к официальному SDK) фреймворков. Для данного проекта был выбран набор привязок Arduino. В ущерб максимальной производительности разработка ПО значительно упрощается как благодаря более простому синтаксису, так и наличию множества примеров от других платформ [3].

В первую очередь следует получить в мобильном приложении Blynk уникальный идентификатор (токен) для вашей программы с целью разграничения доступа к устройству. Вместе с именем и паролем локальной Wi-Fi сети его следует передать функциям библиотеки Blynk для успешного установления соединения. При инициализации МК в последовательный порт посылается служебная информация о статусе загрузки, например, назначенный IP-адрес.

В основной части программы мы пользуемся привычными функциями библиотеки Arduino, такими как analogWrite() для плавного регулирования тока нагрузки с помощью ШИМ и Servo.write() для управления сервоприводом. Главный бесконечный цикл loop() отдан на исполнение процессам Blynk.

Ключевое отличие сосредоточено в программном прерывании BLYNK_WRITE() по виртуальному порту V1, срабатывающем каждый раз при изменении положения джойстика на смартфоне. В первую очередь в обработчике интерпретируются входные значения и присваиваются локальным переменным, а затем с ними можно работать как с обычными данными.

Достоинства и недостатки

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

• Простота разработки: фреймворк Arduino для ESP8266 в связке с Blynk предоставляют действительно простой подход к разработке устройств «интернета вещей», экономя время за счет простого и знакомого синтаксиса и множества примеров;
• Производительность: традиционно надстройки над «родными» средствами разработки обладают более низкой производительностью, однако для многих применений не требуется максимальная вычислительная мощность;
• Blynk: несмотря на большую часть исходного кода в открытом доступе [2], Blynk является все же проприетарным решением, а также платным. По умолчанию пользователю предоставляется некоторый объем внутренней «валюты», за которую можно построить свой интерфейс. Различные элементы имеют разную стоимость. Впрочем, «стартового капитала» хватит на достаточно сложные проекты. Интересная функциональность платной подписки – свой интерфейс управления можно полностью кастомизировать и вынести в отдельное приложение со своей иконкой, логотипом, дизайном и т.д. Не является Blynk и эталоном скорости: максимальная частота обновления данных – раз в 100 мс – далеко не предел мечтаний.

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

— Ссылка Arduino

Позволяет платам Arduino управлять различными серводвигателями.
Эта библиотека может управлять большим количеством сервоприводов. Он осторожно использует таймеры: библиотека может управлять 12 сервоприводами, используя только 1 таймер. На Arduino Due вы можете контролировать до 60 сервоприводов.

Эта библиотека совместима с avr, megaavr, sam, samd, nrf52, stm32f4, mbed, mbed_nano, mbed_portenta, mbed_rp2040 архитектуры так что вы должен иметь возможность использовать его на следующие платы Arduino:

Чтобы использовать эту библиотеку, откройте Диспетчер библиотек в в Arduino IDE и установите ее оттуда.

Использование

Эта библиотека позволяет плате Arduino управлять серводвигателями RC (хобби). Сервоприводы имеют встроенные шестерни и вал, которым можно точно управлять. Стандартные сервоприводы позволяют располагать вал под разными углами, обычно от 0 до 180 градусов. Сервоприводы непрерывного вращения позволяют устанавливать различные скорости вращения вала.

Библиотека Servo поддерживает до 12 двигателей на большинстве плат Arduino и 48 на Arduino Mega. На платах, отличных от Mega, использование библиотеки отключает функцию analogWrite () (PWM) на контактах 9 и 10, независимо от того, есть ли на этих контактах сервопривод.На Mega можно использовать до 12 сервоприводов, не мешая функциональности ШИМ; использование двигателей от 12 до 23 отключит ШИМ на контактах 11 и 12.

Для использования этой библиотеки:

Схема

имеют три провода: питание, заземление и сигнал. Провод питания обычно красного цвета и должен быть подключен к выводу 5V на плате Arduino. Заземляющий провод обычно бывает черного или коричневого цвета и должен быть подключен к контакту заземления на плате Arduino. Сигнальный контакт обычно желтого, оранжевого или белого цвета и должен быть подключен к цифровому контакту на плате Arduino.Обратите внимание, что сервоприводы потребляют значительную мощность, поэтому, если вам нужно управлять более чем одним или двумя, вам, вероятно, потребуется запитать их от отдельного источника (то есть не от вывода 5 В на вашем Arduino). Обязательно соедините заземление Arduino и внешнего источника питания вместе.

Примеры

• Ручка: управление валом серводвигателя поворотом потенциометра
• Sweep: перемещает вал серводвигателя вперед и назад

Управление сервоприводом с помощью Arduino • AranaCorp

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

Предварительное условие: программирование с помощью Arduino

Материал

• Компьютер
• Ардуино UNO
• USB-кабель для подключения Arduino к компьютеру
• Кабель-перемычка 3x M / M
• 1x Серводвигатель

Серводвигатель

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

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

Электропроводка

получает питание через черный / коричневый кабель (GND) и красный кабель (+ 5 В) и получает сигнал PWM по желто-белому кабелю (контакт 9).В зависимости от количества или мощности серводвигателей, которые вы хотите использовать, серводвигатель может питаться от платы Arduino, но обычно имеется внешний источник питания. Плата питается от компьютера через USB-кабель.

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

Чтобы управлять серводвигателем в нужном положении, нам нужно только применить команду PWM, что легко сделать с помощью Arduino.

 // Константы
#define UPDATE_TIME 20

// Параметры
int servoPin = 9;
int pulse = 1500;

void setup () {
  // Инициализация
  pinMode (сервопин, ВЫХОД);
    Серийный .begin (9600);
}

void loop () {
  // главный
  digitalWrite (сервопин, ВЫСОКИЙ);
  delayMicroseconds (импульс);
  digitalWrite (сервопин, НИЗКИЙ);
  задержка (UPDATE_TIME);
}

 

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

• 5 В в течение 500 мкс (0,5 мс) соответствуют 0 градусам
• 5 В в течение 1500 мкс (1,5 мс) соответствуют 90 градусам
• 5 В в течение 2500 мкс (1,5 мс) соответствуют 180 градусам

Как только формула определится, мы можем внедрить функцию для преобразования положения в ширину импульса.

 // Константы
#define UPDATE_TIME 20

// Параметры
int servoPin = 9;
int angle = 1500;

void setup () {
  // Инициализация
  pinMode (сервопин, ВЫХОД);
    Серийный  .begin (9600);
}

void loop () {
  // главный
  digitalWrite (сервопин, ВЫСОКИЙ);
  delayMicroseconds (convertAngleToImp (угол));
  digitalWrite (сервопин, НИЗКИЙ);
  задержка (UPDATE_TIME);
}

// Объявить функцию
int convertAngleToImp (int ang) {
  float a = 2000/180;
  поплавок b = 500;

  вернуть int (a * ang + b);
}

 

Более сложные коды могут быть написаны в Arduino, используя эти базовые знания и некоторые библиотеки, такие как Servo.h библиотека.

В этом примере используется digitalWrite (), чтобы показать вам принцип сигнала PWM. Практически функция analogWrite () будет использоваться для активации сервопривода или светодиода.

 // Декларация констант
#define UPDATE_TIME 20

// Декларация параметров
int servoPin = 9;


void setup () {
 // Код инициализации
 pinMode (сервопин, ВЫХОД);
  Серийный  .begin (9600); // Инициализировать коммуникационную серию ПК / Arduino
}

void loop () {
 // Код участника
 for (int i = 0; i <180; i ++) {
 analogWrite (servoPin, convertirAngleEnPWM (i));
 задержка (UPDATE_TIME);
 }
задержка (200);
 for (int i = 180; i> = 0; i -) {
 analogWrite (servoPin, convertirAngleEnPWM (i));
 задержка (UPDATE_TIME);
 }
 задержка (200);
}

// Déclaration d'un sous fonction
int convertirAngleEnPWM (int ang) {
 поплавок a = 255.0 / 180,0;
 return (a * ang);
}

 

Сервоуправление с помощью Servo.h

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

 // Библиотеки
#include < Серво .h>

// Константы
#define UPDATE_TIME 15
#define MAX_POS 180
#define MIN_POS 0

// Параметры
int servoPin = 9;
int pulse = 1500;
char s = "1,5";

// Переменные
  Servo  myServo; // создаем сервообъект

int pos = 0; // переменная contenant la position du servomoteur

void setup () {
  myServo.attach (сервопин);
}

void loop () {
  for (pos = MIN_POS; pos <= MAX_POS; pos + = 1) {
    myServo.write (pos);
    задержка (UPDATE_TIME);
  }
  for (pos = MAX_POS; pos> = MIN_POS; pos - = 1) {
    myServo.написать (pos);
    задержка (UPDATE_TIME);
  }
}

 

Создайте свою собственную библиотеку ServoLib.h

может быть создана, когда один и тот же код используется для нескольких приложений. Для создания библиотеки необходимо написать два файла на языке C (файл .cpp и .h). Файл .H, называемый заголовком , заголовок , содержит объявления классов, переменных и функций. Эти файлы должны быть сохранены под тем же именем, что и родительская папка, и помещены в каталог: .Документы / Arduino / библиотеки .

Файл ServoLib.h

 #ifndef ServoLib_h
#define ServoLib_h

// Константы
#define UPDATE_TIME 15
#define MAX_POS 180
#define MIN_POS 0
#define MAX_PULSE_WIDTH 2500
#define MIN_PULSE_WIDTH 500

//Класс
класс ServoLib
{
 общественность:
  ServoLib (); // конструктор
  int servoPin; // broche du servomoteur
  void attach (int pin);
  void sendPosition (значение int);
  int convertAngleToImp (int ang);
  void applyImp (int pulse);
};

#endif

 

Файл ServoLib.cpp

 #include 

ServoLib :: ServoLib () {}

void ServoLib :: attach (int pin) {
  servoPin = штифт;
  pinMode (сервопин, ВЫХОД);
}

void ServoLib :: sendPosition (int value) {
  int pulse = 0;
  если (значение  MAX_POS)
    значение = MAX_POS;

  значение = карта (значение, MIN_POS, MAX_POS, MIN_PULSE_WIDTH, MAX_PULSE_WIDTH);
  pulse = this-> convertAngleToImp (значение);
  this-> applyImp (импульс);
}

void ServoLib :: applyImp (int pulse) {
  digitalWrite (сервопин, ВЫСОКИЙ);
  delayMicroseconds (импульс);
  digitalWrite (сервопин, НИЗКИЙ);
  задержка (UPDATE_TIME);
}

int ServoLb :: convertAngleToImp (int ang) {
  float a = 2500/180;
  поплавок b = 500;

  вернуть int (a * ang + b);
}

 

Можно добавить дополнительный файл.Он изменяет цвет имен функций в Arduino IDE.

 ################################################################################
# Карта раскраски синтаксиса ServoLib
#############################################################

#############################################################
# Типы данных (KEYWORD1)
#############################################################

ServoLib КЛЮЧЕВОЕ СЛОВО1 ServoLib

#############################################################
# Методы и функции (KEYWORD2)
#############################################################
прикрепить KEYWORD2
sendPosition KEYWORD2
convertAngleToImp KEYWORD2
applyImp KEYWORDS2

#############################################################
# Константы (LITERAL1)
#############################################################
UPDATE_TIME LITERAL1
MIN_POS LITERAL1
MAX_POS LITERAL1
MIN_PULSE_WIDTH LITERAL1
MAX_PULSE_WIDTH LITERAL1

 

Без ключевых слов.txt

С keywords.txt

При перезагрузке программного обеспечения IDE только что созданная библиотека становится доступной в Меню> Эскиз> Включить библиотеку

Затем код можно упростить следующим образом:

 // Библиотека
#include "ServoLib.h"

// Параметры
int servoPin = 9;

// Переменные
ServoLib myServo;

int pos = 0;

void setup () {
  myServo.attach (сервопин);
}

void loop () {
  for (pos = MIN_POS; pos <= MAX_POS; pos + = 1) {
    myServo.sendPosition (pos);
    задержка (UPDATE_TIME);
  }
  for (pos = MAX_POS; pos> = MIN_POS; pos - = 1) {
    myServo.sendPosition (pos);
    задержка (UPDATE_TIME);
  }
}

 

Следующие шаги

Найдите другие примеры и руководства в нашем автоматическом генераторе кода
Code Architect

Создание сервомеханизма и управление им с помощью компьютера — Maker Challenge

Maker Time

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

В первом упражнении используйте монитор последовательного порта, чтобы начать обработку пользовательского ввода. Попросите учащихся разработать программу, которая «считывает» данные пользователя из входной линии последовательного монитора и выводит их обратно в окно вывода последовательного монитора. Хотя вы просто используете монитор последовательного порта на компьютере для просмотра как входных, так и выходных сигналов, для этого необходимо подключить Arduino.После того, как Arduino подключены через USB в эскизе, попросите учащихся выбрать правильную плату и порт для своих Arduino, используя этот путь: Инструменты> Плата: Arduino / Genuine Uno, затем Инструменты> Порт: COM #.

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

Рисунок 1. Серийный код.

Что происходит?

Когда учащиеся пишут свои имена и нажимают Enter, команда Serial.read () обрабатывает каждый ввод как символ. Поскольку Arduino не может говорить на нашем языке, и мы не можем говорить на его языке, система преобразует каждую букву в число, соответствующее символу. Код, который использует система, называется ASCII. У каждого символа есть уникальный номер, и как только учащиеся узнают код (см. Ресурсы), и они, и Arduino смогут понять вводимые пользователем данные!

Подсказка: Попробуйте ввести 100.Что происходит? Arduino обрабатывает эти числа как числовые символы и присваивает значение. Вы должны увидеть 49, за которыми следуют две 48. Опять же, если учащимся интересно, в разделе «Ресурсы» есть ссылка на таблицу кодов ASCII. А теперь попробуйте еще раз расшифровать код ASCII вашего имени!

Что делать студентам, если они хотят ввести 100 и увидеть на экране значение 100? Изучив команды Arduino, они могли бы выяснить логику этого. Однако существует существующая команда Arduino, чтобы сделать это быстро и легко:

Серийный.parseInt ().

Используя предыдущий код, попросите учащихся попробовать следующее:

1. Замените Serial.read () на Serial.parseInt ()

2. Убрать задержку.

Подсказка: Что происходит теперь, когда вы вводите 100 в окно последовательного порта? Ответ: Возвращается число 100. Подсказка: Что делать, если ввести 100,456? Ответ: 100 и 456 возвращаются в двух отдельных строках. Подсказка: Какие подводные камни при использовании Serial.parseInt ()?

Ловушка 1: несмотря на то, что задержка была удалена, частота обновления все еще составляет 1 секунду, что довольно медленно.

Ловушка 2: всегда возвращается ноль, за исключением ввода пользователя.

Чтобы решить ловушку 1 и включить более быстрые обновления, используйте команду Serial.setTimeout () (см. Ресурсы). Добавьте это в функцию «setup» сразу после команды Serial.begin (9600). Эта команда регулирует скорость обновления. Попросите учащихся попробовать установить это значение на 100 или даже на 50.

Решение Pitfall 2 требует другого уровня мышления. Нам нужно, чтобы система реагировала только на ввод пользователя. Попробуйте заключить все команды цикла в следующую командную строку:

Если (Serial.доступно ()> 0) {

// Все остальные команды цикла здесь

}

Serial.available () возвращает количество байтов, доступных для монитора последовательного порта. Если ничего нельзя вернуть, цикл продолжает цикл в поисках информации. Если информация существует, цикл обрабатывает информацию, как и раньше. Попросите студентов попробовать это! Возвращается ли ноль? Если это так, убедитесь, что вы заключили все команды в волнистые скобки Serial.available ().

Обладая твердыми знаниями о том, как работает последовательная связь, давайте применим полученные знания, чтобы сделать что-нибудь интересное!

Подсказка: Можно ли с помощью этих последовательных команд подключить сервопривод и управлять им с помощью компьютера?

Вот рецепт успеха:

1. Подключите сервопривод и проверьте его с помощью контура 8 в SIK Guide .
2. Заставить код Serial.parseInt работать так, чтобы он возвращал значение, введенное пользователем, в монитор последовательного порта. Совет: Если ваш код продолжает возвращать ноль в монитор последовательного порта, убедитесь, что у вас есть команда Serial.available (), которая соответствующим образом обертывает ваш код.
3. Когда у вас есть код, работающий индивидуально, объедините две программы, чтобы пользователь мог управлять сервоприводом с экрана. Совет : Используйте команду ограничения, чтобы убедиться, что пользователь не может вводить команды, которые могут нарушить работу сервопривода!

См. Код на рисунке 2.

Рисунок 2. Сервокод.

Когда у учащихся будет рабочий сервопривод, имейте:

• Прикрепите к сервоприводу палочку для мороженого, чтобы сделать рудиментарный рычаг, которым вы сможете управлять.
• Создайте команду из нескольких групп, чтобы сделать роботизированную руку (см. Рис. 3-5) или даже руку.
• Создайте робота, который может написать букву C. Какие еще буквы вы можете написать?

Рис. 3. Человеческая рука рядом с механической рукой из палочек для мороженого, движущейся на сервоприводах, управляемых Arduino.авторское право

Copyright © 2018 Рэйчел Шарп, Программа ITL, Колледж инженерии и прикладных наук, Университет Колорадо в Боулдере

Рис. 4. Увеличенный вид пяти сервоприводов и «пальцев» палочки для мороженого. Авторское право

Copyright © 2018 Рэйчел Шарп, Программа ITL, Колледж инженерии и прикладных наук, Университет Колорадо в Боулдере

Примечание: если учащиеся хотят использовать более двух микросервоприводов для создания руки, им необходимо использовать регулятор напряжения на 5 В и батарею на 9 В.Более двух сервоприводов потребляют больше тока, чем кабель питания USB может обеспечить от вывода 5V на Arduino, чтобы они могли двигаться и работать плавно. На рисунке 5 показано, как подключить регулятор напряжения в сочетании с батареей 9 В для питания пяти сервоприводов. (Для получения дополнительных сведений о том, где купить регулятор напряжения, а также технических характеристик для правильного использования, обратитесь к ресурсу регулятора напряжения SparkFun, указанному в разделе «Ссылки».)

Рис. 5. Полная установка из пяти сервоприводов с Arduino, батареей 9 В и регулятором напряжения.авторское право

Copyright © 2018 Рэйчел Шарп, Программа ITL, Колледж инженерии и прикладных наук, Университет Колорадо в Боулдере

Теперь, когда вы освоили основы последовательной связи, вы готовы «отрезать шнур» и перейти к задачам беспроводной связи! Двумя распространенными способами сделать это с Arduino являются компоненты Bluetooth и XBee. Более сложные задачи производителя:

Arduino — Робо Индия || Учебники || Изучите Arduino |

Пошаговое иллюстрированное базовое руководство по Arduino. В этом руководстве объясняется управление серводвигателем через Arduino. Мы включили в это руководство два примера.

Значение сервопривода — это обратная связь.Итак, сервопривод — это исполнительный механизм, который сам принимает обратную связь и точно перемещается. Пример точности и обратной связи можно понять на примере повседневной жизни: предположим, вы поднимаете / опускаете стекло окна автомобиля, нажимаете вверх / вниз кнопку электрического стеклоподъемника и продолжаете наблюдать за фактическим положением стекла, когда оно достигает желаемого значения. положение, вы отпускаете кнопку. Итак, это обратная связь, мы принимаем отзывы здесь, если бы это была система, основанная на обратной связи, мы должны были бы сообщать об открытии окна на 10% -20%.

Вернемся к серводвигателю.Серводвигатель вращается от 0 до 180 градусов. Мы отправляем команду сервоприводу, когда он достигает заданного значения, на котором останавливается. На приведенной ниже диаграмме показано, как он вращается, и его проводной интерфейс.

Arduino имеет библиотеку для управления сервоприводом. Это — Servo.h.

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

Это руководство создано на оригинальной Arduino UNO и R-Board от Robo India (совместимо с UNO)

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

Это первый пример сервоуправления. Только сервопривод управляется через Arduino. В этом примере сервопривод совершает 5 движений —

1.От 0 до 45 градусов

2. От 46 до 90 градусов

3. От 91 до 135 градусов

4. От 136 до 180 градусов

5. От 180 градусов до 0 градусов (обратно в ноль)

После завершения каждого движения он останавливается на одну секунду.

Для запуска этого практического примера составьте следующую схему с помощью вышеупомянутых компонентов.

3.1 Вы можете использовать R-Board от Robo India (совместим с UNO) —

или

3.2 Вы можете использовать оригинальную плату Arduino UNO —

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

Вы можете скачать этот код (Arduino Sketch) отсюда.

// Учебное пособие по сервоуправлению №1
// Подготовлено Robo India
//  www.roboindia.com 

// Библиотека сервоприводов Arduino может добавить до 12 сервоприводов на большинстве плат Arduino.
#include < Servo  .h> // Включает библиотеку серво.
 
  Servo  servo_1; // Создание сервообъекта.
 
int servo_pos = 0; // Сохранение положения сервопривода (от 0 до 180 градусов)
 
установка void ()
{
 servo_1.attach (3); // Присоединение сервопривода к контакту № 3
}
 
 
пустой цикл ()
{

 for (servo_pos = 0; servo_pos <= 45; servo_pos ++) // цикл для перехода на 45 градусов от 0 градусов.
 {// приращение на 1 градус на каждом шаге
 серво_1.написать (servo_pos); // команда сервопривода достигнуть Servo_pos.
 задержка (15); // немного ждем, пока сервопривод достигнет заданной позиции.
 }
 задержка (1000); // Задержка в 1 секунду для наблюдения за остановкой сервопривода.
 for (servo_pos = 46; servo_pos <= 90; servo_pos ++) // цикл для перехода на 90 градусов с 46 градусов.
 {
 servo_1.write (servo_pos);
 задержка (15);
 }
 задержка (1000);
 for (servo_pos = 91; servo_pos <= 135; servo_pos ++) // цикл для перехода на 135 градусов с 91 градуса.{
 servo_1.write (servo_pos);
 задержка (15);
 }
 задержка (1000);
 for (servo_pos = 136; servo_pos <= 180; servo_pos ++) // цикл для перехода на 180 градусов от 136 градусов.
 {
 servo_1.write (servo_pos);
 задержка (15);
 }
 задержка (1000);
 for (servo_pos = 180; servo_pos> = 1; servo_pos--) // Цикл для возврата к 0 градусам.
 {
 серво_1.написать (servo_pos);
 задержка (15);
 }
 задержка (1000);
}

 

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

Сделайте следующую схему —

5.1 Вы можете использовать R-Board от Robo India (совместим с UNO) —

5.2 Или вы можете использовать оригинальную плату Arduino:

вот схема:

Вот например программирование — 2 (схема выше).

Указывает на понимание.

1. Аналоговый вход осуществляется через потенциометр на контакте A0. Это даст нам значение от 0 до 1023.

2. Библиотеке сервопривода требуется значение от 0 до 180, чтобы отдавать команду серво.

3. Итак, мы преобразуем наши входные значения (0-1023) в значение команды для сервопривода (0-180).

4. Это преобразованное значение отправляется на сервопривод через контакт 3.

Следующая программа объясняет все команды в разделах комментариев.

Вы можете скачать коды (Arduino Sketch) отсюда.

// Учебное пособие по сервоуправлению # 2
// Подготовлено Robo India
//  www.roboindia.com 

// Библиотека сервоприводов Arduino может добавить до 12 сервоприводов на большинстве плат Arduino.#include < Servo  .h> // Включает библиотеку серво.
 
  Servo  servo_1; // Создание сервообъекта.
 
int input_pin = A0; // Вывод аналогового входа (потенциометр)
int input_val; // для хранения аналогового входного значения (0-1023)
int servo_angle = 0; // Значение угла сервопривода (0-180 градусов)
 
установка void ()
{
 servo_1.attach (3); // Подключение вывода 3 Arduino к сервоприводу.
}
 
пустой цикл ()
{
 input_val = analogRead (input_pin); // Чтобы прочитать значение аналогового входа (0-1023)
 servo_angle = карта (input_val, 0, 1023, 0, 179); // Преобразование входного значения (0-1023) в угол сервопривода (0-180)
 серво_1.написать (серво_угол); // Команда сервопривода для достижения угла сервопривода
 задержка (15); // ждем, пока сервопривод достигнет заданного угла.
}

 

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

Ниже приводится один из реальных примеров серво движения. 5-осевой роботизированный манипулятор от Robo India.Такие роботизированные манипуляторы очень полезны в промышленности.

Если у вас есть какие-либо вопросы, напишите нам по адресу [email protected]

С уважением и уважением
Группа разработки контента
Robo India
http://roboindia.com

Урок Arduino — Управление серводвигателем с помощью ИК-пульта «osoyoo.com

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

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

• Плата Osoyoo UNO (полностью совместима с Arduino UNO rev.3) x 1
• Инфракрасный приемник x 1
• Пульт дистанционного управления x 1
• SG90 Сервопривод x 1
• Джемперы
• Кабель USB x 1
• шт x 1

Программное обеспечение

Мы используем Arduino UNO для управления серводвигателем и предоставления желаемой функциональности.Мы используем ИК-приемник для считывания ИК-сигналов с пульта дистанционного управления. Подключение ИК-приемника и серводвигателя показано на рисунках. Следуйте инструкциям по подключению, показанным на рисунках.

Использование библиотеки IRremote для управления сервоприводом

Сначала загрузите удаленную ИК-библиотеку для Arduino отсюда: ИК-библиотека Arduino

Откройте демонстрационный пример IRremote из Arduino IDE, затем загрузите его на плату Arduino.

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

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

Например, используйте (▲) для вращения по часовой стрелке и (▼ для против часовой стрелки, поэтому вам нужно получить их HEX-коды.

Кодовая программа

После завершения вышеуказанных операций подключите плату Arduino к компьютеру с помощью кабеля USB. Зеленый светодиодный индикатор питания (с надписью PWR ) должен загореться.Откройте IDE Arduino и выберите соответствующий тип платы и тип порта для вашего проекта. Затем загрузите следующий скетч на свой Arduino.

 #include IRremote.h> // необходимо скопировать библиотеку IRremote в библиотеки arduino
#include  Servo  .h>
#define plus 0xFF18E7 // кнопка вращения по часовой стрелке
#define minus 0xFF4AB5 // кнопка вращения против часовой стрелки

int RECV_PIN = 3; // вывод ИК-приемника
 Сервопривод  Сервопривод ;
int val; //угол поворота
bool cwRotation, ccwRotation; // состояния вращения

  IRrecv  irrecv (RECV_PIN);

  decode_results  результатов;

установка void ()
{
  Серийный .begin (9600);
 irrecv.enableIRIn (); // Запускаем приемник
 сервопривод (9); // серво штифт
}

пустой цикл ()
{
 if (irrecv.decode (& результаты)) {
  Серийный  .println (results.value, HEX);
 irrecv.resume (); // Получаем следующее значение

 если (results.value == плюс)
 {
 cwRotation =! cwRotation; // переключаем значение поворота
 ccwRotation = false; // без вращения в этом направлении
 }

 если (results.значение == минус)
 {
 ccwRotation =! ccwRotation; // переключаем значение поворота
 cwRotation = false; // без вращения в этом направлении
 }
 }
 if (cwRotation && (val! = 175)) {
 val ++; // для кнопки colockwise
 }
 if (ccwRotation && (val! = 0)) {
 val--; // для кнопки против часовой стрелки
 }
 servo.write (val);
 задержка (20); // Общая скорость
}

 

Текущий результат

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

Использование библиотеки IRLibAll для управления сервоприводом

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

Соединение

Как и на картинке выше, у нас есть ИК-приемник, подключенный к +3.3v, земля и контакт 3. Еще у нас есть сервопривод с тремя проводами. Красный провод + 5В. Черный или темно-коричневый провод — это земля, а оставшийся провод, обычно желтый, — это сигнальный провод, который мы подключили к контакту 9, хотя это может быть любой цифровой выходной контакт.

Установка ИК-библиотеки IRLibAll

Для установки ИК-библиотеки:

1. Загрузите ИК-библиотеку, нажав кнопку выше, или загрузите ее прямо из библиотеки IRLib 2.x с Github.
2. Распакуйте ZIP-файл после завершения загрузки.
3. Убедитесь, что несжатая папка содержит пяти отдельных папок. IRLib 2.x содержит несколько библиотек, которые работают вместе.
4. Скопируйте все пять в корневой каталог папки библиотеки Arduino. Путь обычно находится в (домашняя страница) / Documents / Arduino / Libraries . Если вы не видите папку / Libraries /, возможно, вам придется создать ее самостоятельно.
5. Перезапустите IDE Arduino.

Загрузить код

Ниже представлена ​​версия скетча servo.ino из папки «IRLib2 / examples». Он был модифицирован для использования с пультом дистанционного управления OSOYOO Smart Car V1. Если вы используете другой пульт дистанционного управления, вам нужно будет собрать информацию о ваших кодах для различных кнопок с помощью dump.ino и изменить скетч, указав правильное имя протокола и коды.

 #include IRLibAll.h>
#include  Servo  .h>

// Вам нужно будет установить эти значения в зависимости от протокола
// и удаленные коды, которые вы используете.Это для адафрута
// Мини-пульт
#define MY_PROTOCOL NEC
#define RIGHT_ARROW 0xFF5AA5 // Сдвинуть несколько по часовой стрелке
#define LEFT_ARROW 0xFF10EF // Перемещение сервопривода против часовой стрелки
#define SELECT_BUTTON 0xFF38C7 ​​// Центрировать сервопривод
#define UP_ARROW 0xFF18E7 // Увеличенное количество градусов сервоприводов
#define DOWN_ARROW 0xFF4AB5 // Уменьшить количество градусов сервоприводов
#define BUTTON_0 0xFF9867 // Нажатие кнопок 0-9 перемещает в фиксированные положения
#define BUTTON_1 0xFFA25D // на каждые 20 градусов больше
#define BUTTON_2 0xFF629D
#define BUTTON_3 0xFFE21D
#define BUTTON_4 0xFF22DD
#define BUTTON_5 0xFF02FD
#define BUTTON_6 0xFFC23D
#define BUTTON_7 0xFFE01F
#define BUTTON_8 0xFFA857
#define BUTTON_9 0xFF906F

  IRrecv  myReceiver (2); // номер пина для приемника
IRdecode myDecoder;

  Servo  myServo; // создаем сервообъект для управления сервоприводом
int16_t pos; // переменная для хранения положения сервопривода
int16_t Speed; // Количество градусов для перемещения при каждом нажатии кнопки влево / вправо
uint32_t Previous; // обрабатывает повторяющиеся коды NEC

void setup () {
 myServo.прикрепить (9); // присоединяет сервопривод на выводе 9 к сервообъекту
 pos = 90; // начинаем с середины 90 градусов
 Скорость = 3; // сервопривод перемещается на 3 градуса при каждом нажатии влево / вправо
 myServo.write (pos); // Устанавливаем начальную позицию
 myReceiver.enableIRIn (); // Запускаем приемник
}
 
пустой цикл ()
{
 if (myReceiver.getResults ()) {
 myDecoder.decode ();
 если (myDecoder.protocolNum == MY_PROTOCOL) {
 если (myDecoder.значение == 0xFFFFFFFF)
 myDecoder.value = Предыдущий;
 switch (myDecoder.value) {
 case LEFT_ARROW: pos = min (180, pos + Speed); перерыв;
 case RIGHT_ARROW: pos = max (0, pos-скорость); перерыв;
 case SELECT_BUTTON: pos = 90; перерыв;
 case UP_ARROW: Speed ​​= min (10, Speed ​​+ 1); перерыв;
 case DOWN_ARROW: Speed ​​= max (1, Speed-1); перерыв;
 case BUTTON_0: pos = 0 * 20; перерыв;
 case BUTTON_1: pos = 1 * 20; перерыв;
 case BUTTON_2: pos = 2 * 20; перерыв;
 case BUTTON_3: pos = 3 * 20; перерыв;
 case BUTTON_4: pos = 4 * 20; перерыв;
 case BUTTON_5: pos = 5 * 20; перерыв;
 case BUTTON_6: pos = 6 * 20; перерыв;
 case BUTTON_7: pos = 7 * 20; перерыв;
 case BUTTON_8: pos = 8 * 20; перерыв;
 case BUTTON_9: pos = 9 * 20; перерыв;
 }
 myServo.написать (pos); // сообщаем сервоприводу перейти в позицию в переменной 'pos'
 Предыдущий = myDecoder.value;
 }
 myReceiver.enableIRIn ();
 }
}

 

Специальные инструкции для систем на базе ATmega32u4

Пример, представленный здесь, должен нормально работать на Arduino Uno или Mega, однако, если вы используете Arduino Leonardo, Arduino Micro, Arduino Yun или другие системы на базе ATmega32u4, вам придется немного изменить IRLib.

IRLib использует встроенные аппаратные таймеры Arduino для генерации прерывания каждые 50 мкс, чтобы он мог опрашивать входной вывод, чтобы увидеть, изменилось ли оно.По умолчанию он использует TIMER2. Библиотека сервоприводов Arduino также использует аппаратные прерывания с использованием TIMER1. Однако процессор ATmega32u4 не имеет TIMER2, поэтому IRLib по умолчанию использует TIMER1 в системах, использующих этот процессор. Вам нужно будет изменить «IRLibProtocols / IRLibHardware.h», чтобы изменить таймер по умолчанию. В этом файле примерно в строке 56 вы увидите что-то вроде этого:

 #elif defined (__ AVR_ATmega32U4__)
 #ifdef CORE_TEENSY
 // это Teensy 2.0
 // # определение IR_SEND_TIMER1 14
 // # определить IR_SEND_TIMER3 9
 #define IR_SEND_TIMER4_HS 10
 #еще
 / * вероятно, это Леонардо * /
 #define IR_SEND_TIMER1 9
 // # определить IR_SEND_TIMER3 5
 // # определение IR_SEND_TIMER4_HS 13
 #endif

 

Вам нужно будет поставить // перед #define IR_SEND_TIMER1, чтобы закомментировать эту строку.Затем удалите косую черту перед одним из двух других вариантов TIMER3 или TIMER4_HS. Обратите внимание, что в этих определениях говорится «IR_SEND_TIMERxx». Позже в файле мы копируем это значение, чтобы также использовать его в качестве таймера приема. Если вы используете Леонардо, а позже используете IRLib для отправки ИК-сигналов, вам нужно будет записать числа после этих определений. Хотя мы можем подключить приемник к любому цифровому входному контакту, IRLib требует, чтобы вы использовали определенные выходные контакты в зависимости от того, какой таймер вы используете. Я расскажу об этом позже в разделе об отправке.

Текущий результат

Загрузите эскиз и попробуйте нажимать кнопки со стрелками влево и вправо. Сервопривод должен поворачиваться влево и вправо. Нажатие кнопки ввода должно центрировать сервопривод. Нажатие кнопок со стрелками вверх или вниз не будет иметь видимого эффекта, но изменит скорость движения, которую вы нажимаете влево или вправо. Пронумерованные кнопки от нуля до девяти перемещают сервопривод в 10 различных фиксированных положений с интервалом 20 °.

Если сервопривод работает нестабильно, это может быть проблема с источником питания.Некоторые порты USB не обеспечивают достаточный ток для управления Arduino и перемещения сервопривода. Возможно, вам потребуется добавить внешний источник питания на 5 В.

Как управлять несколькими серводвигателями с помощью Arduino

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

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

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

Серводвигатель — это двигатель постоянного тока, который состоит из 5 следующих частей:

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

Обмотка ротора: Это намотка на вращающуюся часть двигателя.Она также известна как обмотка якоря двигателя.

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

Вал: Обмотка якоря соединена на железном стержне, известном как вал двигателя.

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

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

Входной сигнал для двигателя называется сигналом обратной связи. На основании сигнала обратной связи мотор начинает работать. Сигнал компаратора называется логическим сигналом двигателя.Двигатель включается на желаемое время, когда логическая разница выше, и двигатель выключается на желаемое время, когда логическая разница меньше. Таким образом, компаратор используется для определения положения ВКЛ / ВЫКЛ.

Серводвигатели могут управляться широтно-импульсной модуляцией (ШИМ). Они посылают на двигатель электрические сигналы непостоянной ширины. Ширина импульса изменяется в диапазоне от 1 миллисекунды до 2 миллисекунд и передается на серводвигатели с повторением 50 раз в секунду.Ширина импульса определяет угловое положение вращающегося вала. Для управления серводвигателем используются 3 термина:

Сервопривод перемещается с импульсом в 1 миллисекунду, чтобы повернуть двигатель в сторону 0 °, тогда как импульс в 2 миллисекунды для поворота двигателя в сторону 180 °. Сервопривод поворачивается на 90 ° с импульсом длительностью 1,5 миллисекунды.

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

Здесь мы собираемся показать вам, как управлять несколькими сервомоторами с помощью Arduino. Соединение нескольких сервомоторов с Arduino кажется простым.Но если мы подключим все сервоприводы к источнику питания Arduino, они не будут работать правильно. Это связано с отсутствием тока, достаточного для привода всех двигателей. Поэтому вам нужно использовать отдельный внешний источник питания для двигателей, таких как адаптеры (5 В 2 А) или батареи 9 В.

Мы используем три серводвигателя SG-90 для практической демонстрации. Ниже представлена ​​принципиальная схема.

Скопируйте и загрузите этот исходный код / ​​программу для управления несколькими серводвигателями с помощью Arduino.

Arduino имеет библиотеку для сервомоторов, и она обрабатывает все вещи, связанные с ШИМ, для вращения сервопривода.

Итак, мы начинаем с определения библиотеки для серводвигателя.

Затем мы инициализируем все три сервопривода как Servo1, Servo2, Servo3.

И затем мы устанавливаем настройку всех входных контактов сервопривода с помощью Arduino.

В функции void loop () мы просто поворачиваем все сервоприводы от 0 до 180 градусов, а затем с 180 до 0 градусов. Задержка, используемая в приведенном ниже коде, используется для увеличения или уменьшения скорости сервопривода с помощью переменной «i».

ESP32 против Arduino: сервоуправление!

Привет, ребята! Нам было так весело общаться со всеми производителями, которые наслаждаются нашими новыми робототехническими комплектами «Вояджер» и «Исследователь». Благодаря высокоскоростным двигателям постоянного тока и роботизированной руке с высоким крутящим моментом, он обладает массой функций! Сегодня я хотел бы рассказать всем, кто может быть заинтересован в программировании ESP32, но может немного нервничать из-за его различий с Arduino.Хотя в некоторых случаях ESP32 может быть немного сложнее, сегодня я хотел показать вам различия между базовым движением сервопривода с Arduino и базовым движением сервопривода с ESP32! Это проще, чем вы думаете! Как всегда, это руководство также доступно на нашем канале YouTube. Перво-наперво, давайте посмотрим, насколько легко заставить Arduino перемещать сервопривод.

Часть первая: простое серво-движение с использованием Arduino

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

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

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

 #include 
Servo servoOne;

void setup () {
servoOne.attach (3);
}

void loop () {
servoOne.write (0);
задержка (500);
servoOne.write (0);
задержка (500);
} 

Довольно просто, правда? Нашим первым шагом является вызов библиотеки сервоприводов Arduino, которая встроена в IDE Arduino и не требует от вас дополнительной загрузки. следующий шаг — объявление нашего объекта Servo, но с вводом

 Servo servoOne; 

Затем в нашей настройке void нам нужно прикрепить наш сервообъект (servoOne) к выводу ШИМ на Arduino.У нас есть возможность использовать контакты 3,5,6,9,10 или 11. В этом случае мы выберем контакт D3.

 servoOne.attach (3); 

Когда у нас есть вся эта настройка, все, что нам нужно сделать, это сказать нашим сервоприводам, что делать! В этом случае в нашем пустом цикле сервопривод вращается от 0 до 180 градусов каждые полсекунды.

Часть вторая: давайте добавим немного контроля!

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

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

 #include 
Servo servoOne;
int posX = 90;
int joyX;

void setup () {
  servoOne.прикрепить (3);
  servoOne.write (posX);
}

void loop () {
joyX = analogRead (A1);
если (joyX> 800)
{
  posX ++;
  servoOne.write (posX);
  задержка (20);
}
иначе, если (joyX <200)
{
  posX--;
  servoOne.write (posX);
  задержка (20);
}
} 

Первое большое отличие в нашем примере кода - это две новые переменные.

 int posX = 90;
int joyX; 

Нашей переменной позиции (posX) присвоено значение 90, и она представляет начальную позицию для нашего сервопривода в 90 градусов. Именно эту переменную мы собираемся увеличивать и уменьшать с помощью джойстика, чтобы переместить сервопривод вниз в пустом цикле.Наша вторая новая переменная предназначена для данных джойстика. Мы собираемся читать данные с нашего джойстика в цикле void, и нам понадобится переменная для хранения этой информации!

Далее идет установка void. Мы добавили только одну строку кода в наш исходный пример.

 servoOne.write (posX); 

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

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

 joyX = analogRead (A1); 

Джойстики - увлекательные и удивительно простые устройства. Чтобы включить питание и считать джойстик, все, что вам нужно сделать, это подать 5 вольт, подключить GND, а затем прочитать изменение напряжений по осям X и Y. Джойстик состоит из двух устройств, известных как потенциометры.Потенциометр - это устройство, которое действует как резистор, сопротивляясь потоку электричества, но способное изменять свои резистивные свойства в зависимости от положения! Итак, подается 5 вольт, и когда вы перемещаете джойстик влево и вправо, это выходное напряжение изменяется. Команда "analogRead", давайте прочитаем это изменение напряжения как строку чисел. В этом случае мы прочитаем 1023, если джойстик был нажат в одну крайность, и 0, если он был нажат в противоположную крайность. Это приводит нас к нашему первому условному выражению.

 if (joyX> 800) {
posX ++;
servoOne.write (posX);
задержка (20);
} 

Итак, мы уже установили, что перемещение джойстика в одном направлении вперед и назад даст нам диапазон от 0 до 1023, и поэтому наше условие is основано на том, превышает ли это значение 800. Поскольку 1023 - это значение джойстика в одном крайнем положении, и около 500 будет нейтральным положением прямо посередине, тогда, если вы прочитаете значение 800, джойстик должен быть сдвинут в сторону одного крайнего положения.

Итак, если это так, мы хотим начать движение нашего сервопривода. Мы делаем это, сначала добавляя к значению нашей переменной позиции строку «posX ++». В большинстве языков программирования «++» - это сокращение от «добавить один», поэтому, если джойстик нажимается в определенном направлении (в нашем случае вправо), наша программа добавит единицу к значению posX. Следующая строка кода говорит нашему сервоприводу двигаться к тому, чем может быть значение posX, поэтому, когда число posX становится больше, сервопривод будет двигаться вправо! Вначале это будет 90, но если вы продолжите удерживать джойстик, вы продолжите увеличивать значение posX, и ваш сервопривод будет продолжать двигаться!

Arduino может думать очень быстро, намного быстрее, чем мы, люди.Таким образом, последняя строка кода «delay (20)» гарантирует, что мы добавляем только единицу к значению posX каждые 20 миллисекунд. В противном случае наши сервоприводы двигались бы слишком быстро! В этом примере замечательно то, что если вы хотите, чтобы ваши сервоприводы двигались быстрее, просто уменьшите задержку!

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

 else if (joyX <200) {
  posX--;
  servoOne.write (posX);
  задержка (20);
  } 

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

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

 #include 
Servo servoOne;
int posX = 90;
int joyX;

void setup () {
  servoOne.attach (3);
  servoOne.write (posX);
}

пустой цикл ()
{
joyX = analogWrite (A1);
если (joyX> 800 && posX <180)
{
  posX ++;
  servoOne.написать (posX);
  задержка (20);
}
иначе, если (joyX <200 && posX> 0)
{
  posX--;
  servoOne.write (posX);
  задержка (20);
} 

Все, что мы сделали, это добавили второе условие к нашим операторам if! Итак, когда мы перемещаем джойстик влево и вправо, выполняется первое условие, что значение joyX превышает 800 и ниже 200. Второе условие - только всегда увеличение и уменьшение переменной posX, если оно еще не было. достигло 180 или 0. Разве это не крутой трюк? Без второго условия вы можете удерживать джойстик, и переменная posX будет становиться все больше и больше, но на самом деле может пройти вправо на 180 и продолжать считать.Поэтому, когда вы перемещаете джойстик в обратном направлении, значение posX может исчисляться тысячами, и на обратный отсчет диапазона продаж потребуется целая вечность. Это будет выглядеть так, как будто ваши сервоприводы перестали работать! Это небольшое дополнение очень полезно, но не обязательно. Хорошо, хватит примеров Arduino, перейдем к ESP32!

Часть третья: Простое движение сервопривода с использованием ESP32

Итак, мы увидели, насколько легко использовать Arduino для выполнения некоторых основных движений сервопривода.Пришло время взглянуть на ESP32. Я бы солгал, если бы сказал, что это то же самое, в конце концов, в этом весь смысл этого урока! Есть несколько дополнительных шагов, но в конце концов это почти так же просто! Давайте посмотрим на пример, который позволит нам делать то же самое, что и в нашем самом первом примере, перемещая одиночный сервопривод назад и вперед от 0 градусов до 180 градусов.

Чтобы продемонстрировать это, я подумал, что сейчас самое время рассказать вам, ребята, о нашем новом наборе роботизированной руки ESP32! Он имеет 4 серворазъема и все необходимое оборудование для управления одной из наших меньших роботизированных рук MeArm, как показано здесь, или даже большей цельнометаллической роботизированной рукой, используемой в наших роботах ESP32 Voyager и Explorer!

Вот наш первый пример!

 #include "esp32-hal-ledc.час"

void setup () {
   ledcSetup (1, 50, 16); // канал 1, 50 Гц, ширина 16 бит
   ledcAttachPin (23, 1); // GPIO 23 назначен каналу 1
}

void loop () {
      ledcWrite (1, 1638); // 0 градусов
      задержка (3000);
      ledcWrite (1, 7864); // 180 градусов
      задержка (3000);
} 

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

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

 #include "esp32-hal-ledc.h" 

Далее у нас есть настройка void. Здесь две строки, и первая представляет собой самую большую разницу между сервоуправлением с использованием Arduino и ESP32.

 ledcSetup (1, 50, 16); // канал 1, 50 Гц, ширина 16 бит 

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

Может показаться, что это больше работы, но на самом деле это дает нам гораздо больше контроля. В то время как Arduino имеет 6 контактов PWM, которые можно использовать (3,5,6,9,10,11), ESP32 имеет 16 каналов PWM.

С ESP32 почти любой из контактов может быть подключен к каналу ШИМ. Вы даже можете подключить несколько контактов к одному каналу. Эта первая строка кода устанавливает канал номер один. В этом случае мы устанавливаем канал 1 ШИМ с частотой 50 Гц и разрешением 16 бит.Если вы не знакомы с этими двумя последними концепциями, не переживайте! Все, что вам нужно знать прямо сейчас, это то, что это отличные настройки для большинства сервоприводов. Если вы добавляете дополнительные каналы для управления дополнительными сервоприводами, вы можете использовать те же самые настройки, настройка второго канала будет выглядеть примерно так: «ledcSetup (2,50,16):», который настроит второй канал с такими же настройками. который можно использовать для управления вторым сервоприводом. Следующая строка кода сообщит нашему ESP32, какой вывод мы хотели бы подключить к нашему недавно созданному каналу PWM, каналу номер один.

 ledcAttachPin (23, 1); // GPIO 23 назначен каналу 1 

В этом случае мы собираемся использовать контакт номер 23, так как комплект роботизированной руки ESP32 имеет серворазъем с пометкой «база», подключенный к контакту 23 GPIO на нашем ESP32.

Далее у нас есть цикл void! Теперь в нашем примере с Arduino мы просто записали позицию, которую мы хотели, чтобы наш сервопривод удерживал в градусах, а с ESP32 нам нужно записать ее в микросекундах, но они означают то же самое!

 ledcWrite (1, 1638); // 0 градусов
      задержка (3000);
      ledcWrite (1, 7864); // 180 градусов
      задержка (3000); 

В нашем пустом цикле наша первая строка кода создает импульс ШИМ длительностью 1638 микросекунд на канале ШИМ 1, который сообщает нашему сервоприводу перейти на ноль градусов.Затем мы ждем три секунды, затем создаем импульс в 7864 микросекунды на канале 1, который сообщает нашему сервоприводу повернуться на 180 градусов! С 4 строками кода здесь, в нашем цикле void, мы можем выполнить то же самое, что и наш простой эскиз Arduino, мы просто используем немного более практический подход.

Часть четвертая: давайте добавим немного контроля!

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

 #include 
#include 
int rX;
int posOne = 5000;

void setup () {
    Serial.begin (115200);
    Ps3.begin ("01: 02: 03: 04: 05: 06");
    Serial.println («Готово»);
    ledcSetup (1, 50, 16); // канал 15, 50 Гц, ширина 16 бит
    ledcAttachPin (23, 1); // GPIO 23 назначен каналу 1
    ledcWrite (1, posOne);
}

void loop () {
 if (Ps3.isConnected ()) {
 задержка (10);
 rX = (Ps3.data.analog.stick.rx);
 
 if (rX <-5 && posOne <8000) {
  ledcWrite (1, posOne);
  posOne + = 25;
 }
 else if (rX> 5 && posOne> 1500) {
  ledcWrite (1, posOne);
  posOne- = 25;
 }
 }} 

Самое большое изменение в нашем коде, касающееся цикла void, - это наша новая переменная позиции. Если вы посмотрите на переменную положения, которую мы использовали во втором примере Arduino (posX), мы использовали число 90. Теперь, поскольку мы выражаем градусы в микросекундах, 1600-ish - это 0 градусов, а 8000-ish - 180. градусов, начиная с импульса в 5000 микросекунд, это довольно близко к 90 градусам.

В нашей настройке void код почти такой же! Единственная разница в том, что мы добавили код для подключения нашего контроллера PS3. Наш цикл void на самом деле почти такой же, как и раньше! Единственная разница - это числа, которые мы используем! Мы добавляем и вычитаем 25 микросекунд, когда нажимаем джойстик вперед и назад, мы используем 5 и -5 в качестве триггеров для условий работы джойстика, и мы устанавливаем наш минимум и максимум на 8000 и 1500 вместо 0 и 180.

Часть Пятый: Взломайте!

Хорошо, теперь я надеюсь, что вы хорошо понимаете различия в сервоуправлении между Arduino и ESP32, теперь все, что осталось, - это использовать эту информацию для создания некоторых потрясающих проектов! Если вам нужен пример того, как управлять всей роботизированной рукой с помощью библиотеки ESP32 Servo, перейдите к одному из наших других руководств, которые подробно рассматривают этот процесс здесь! Если у вас есть какие-либо вопросы, напишите нам! Мы здесь, чтобы помочь!