Управление маленьким двигателем может быть может осуществляться довольно просто. Если двигатель достаточно маленький, он может быть непосредственно соединен с выводом Arduino, и просто изменяя уровень управляющего сигнала от логической единицы до нуля будем контролировать моторчик.
Этот проект раскроет вам основную логику в управлении электродвигателем; однако, это не является стандартным способом подключения двигателей к Arduino. Мы рекомендуем, вам изучить данный способ, а затем перейти на следующую ступень — заняться управлением двигателями при помощи транзисторов.
Подключим миниатюрный вибромоторчик к нашему Arduino.
Миниатюрный вибромоторчик (можно найти в старой ненужной мобилке, или в магазине электроники)
1. У вибромоторчика есть два провода питания. Соедините один его провод с нулевым выводом (GND) питания контроллера. Не имеет значения какой из двух проводов.
2. Подключите резистор между выбранным дискретным выходом контроллера и оставшимся неподключенным проводом моторчика. Подключение резистора ограничит ток и гарантирует нам целостность и сохранность Ардуины, так как она не проектировалась для прямого контроля электродвигателями без преобразователей.
Приводим схему, где для мотора выбран второй дискретный вывод платы контроллера:
А вот примеры, как всё можно соединить при помощи макетной платы:
- Следующий скетч запустит моторчик на 1 секунду, и остановит его на такое же время и так далее по кругу:
- // Декларируем номер дискретного выхода
- int motorPin = 2;
- void setup() {
- //Назначаем второй дискретный вывод как выход
- pinMode(motorPin, OUTPUT);
- }
- void loop(){
- // Включить мотор
- digitalWrite(motorPin, HIGH);
- // Подождать 1000 мс
- delay(1000);
- // Выключить мотор
- digitalWrite(motorPin, LOW);
- // Подождать 1000 мс
- delay(1000);
- }
Всякий раз, когда программа будет подавать логическую единицу на наш выход, ток будет течь через резистор, через мотор (М), и на землю. Если М действительно маломощный, он начнет вращаться, если это стандартный двигатель постоянного тока; иначе он начнет вибрировать, если это вибромоторчик. Резистор очень важен для этой схемы. Каждый дискретный выход Arduino рассчитан на ток только до 40 мА, при чем рекомендуется не превышать 20 мА. Выбранное значение резистора 220 Ом ограничит ток до 22 мА, и потому, что М включен с ним последовательно, ток будет даже меньше. Если общее сопротивление движка выше, чем 200 Ом, то можно с уверенностью убрать резистор и напрямую подключить моторчик к цифровому выводу и GND.
В этом проекте мы напрямую к контроллеру подключили один вибромоторчик, но никто нам не запрещает подключить их несколько.
Несколько двигателей могут быть подключены на разные цифровые выводы платы контроллера. Например, выходы 2, 3, и 4 могут независимо управлять различными тремя электродвигателями.
Каждый дискретный вывод, на Arduino может управлять отдельным движком. Хотя вообщето, так делать не рекомендуется, так как это увеличит ток, проходящий через Arduino.
Давайте пока ограничимся одним двигателем в данной реализации.
Каждый электродвигатель постоянного тока является катушкой индуктивности. Когда мы снимаем с него ток, или когда мы вращаем М вручную, он будет генерировать обратное напряжение. Что может подпалить подключенный к нему электронный компонент.
Чтобы избежать этого, мы можем подключить диод между дискретным выходом и выводом питания 5В. Всякий раз, когда М будет отдавать паразитное обратное напряжение, диод будет соединять его с плюсом питания. К счастью, Ардуино имеет встроенный защитный диод на каждом выводе.
И нам нет необходимости его дублировать внешним диодом.
Мы конечно можем управлять миниатюрным электродвигателем непосредственно подключив его к выходу Arduino; однако, дискретный выход не потянет двигатели, потребляющие больше 40 мА.
Выход заключается в использовании простого усиливающего устройства, транзистора, чтобы иметь возможность управлять электродвигателями постоянного тока любой мощности.
Рассмотрим на примере, как управлять большими электродвигателями, используя два транзистора npn и pnp структуры.
Для этого проекта нам понадобятся следующие электронные компонеты:
- Плата Arduino, подключенная к USB-порту компьютера
- Моторчик постоянного тока
- Резистор сопротивлением между 220 Ом и 10 кОм
- npn транзистор(BC547, 2N3904, N2222A, TIP120)
- Диод (1N4148, 1N4001)
- Ниже приведены шаги, при подключении двигателей с помощью транзистора:
- Подключите ноль питания Arduino GND к минусовой шине макетной платы.
- Подключите один из проводов двигателя к плюсу питания +5В платы контроллера. Мы будем использовать 5В питания USB-порта. Если нужна большая мощность, то нужно использовать внешний источник питания, такой как например батарея. Пока рассмотрим питание именно от USB.
- Другой провод двигателя соединяем с коллектором транзистора npn. По спецификации на ваш транзистор определите какой из трех его выводов коллектор, какой база и какой эмиттер.
- Подключите эмиттер транзистора к минусу питания GND, используя минусовую шину питания макетной платы.
- Установите резистор между базой транзистора и дискретным выходом платы Arduino.
- Включите защитный диод параллельно с движком. Минус диода должен быть подключен к плюсу питания 5В.
Это одна из возможных реализаций с использованием девятого цифрового выхода. Arduino может быть запитан от внешнего источника питания. А если нет, мы можем подключить движок отдельно к внешнему питанию 5В, а Ардуино к своему питанию. Но ноль питания у них должен быть объединен.
А вот один из способов соединения элементов схемы на макетной плате:
- Этот скетч ничем не отличается от предыдущего. Всё так же программа запускает движок на секунду, потом останавливает его на секунду и так далее:
- // Декларируем номер дискретного управляющего выхода
- int motorPin = 2;
- void setup() {
- // Назначаем второй дискретный канал как выход
- pinMode(motorPin, OUTPUT);
- }
- void loop(){
- // Включаем мотор
- digitalWrite(motorPin, HIGH);
- // Ждем 1000 мс
- delay(1000);
- // выключаем мотор
- digitalWrite(motorPin, LOW);
- // Ждем 1000 мс
- delay(1000);
- }
Транзисторы это очень полезные компоненты, которые, к сожалению, трудно понять. Мы можем представить транзистор как электрический клапан: чем больший ток подать на клапан, тем больше воды через него потечет.
То же самое происходит с транзистором, только вместо воды течет ток. Если мы подадим ток на базу транзистора, пропорциональный ток потечет от коллектора к эмиттеру, в случае транзистора типа npn.
Чем больший ток подать на базу, тем большая сила тока будет через два остальных вывода.
Когда мы подаем логическую единицу на выход Arduino, ток проходит от вывода через базу транзистора NPN, что заставляет ток проходить и через другие две ноги транзистора. Когда мы выставляем ноль на выходе, ток не идет через базу и не будет проходить через остальные две ноги.
Транзисторы интересны в том, что с очень малым током базы, мы можем контролировать очень большой ток через коллектор к эмиттеру. Обычный коэффициент усиления обозначается hб для транзистора составляет порядка 200. Это означает, что для тока базы 1 мА, транзистор через коллектор к эмиттеру пропустит 200 мА.
Важным компонентом проекта является диод, о котором не стоит забывать. Как уже было сказано, движок имеет индуктивную составляющую, которая может генерировать большие всплески напряжения, опасные для транзистора. Диод гарантирует, что все паразитные возмущения от двигателя погасятся на нем, а не на транзисторе.
База транзистора очень чувствительна. Даже касание ее пальцем может провернуть электродвигатель. Во избежание нежелательных шумов и непредсказуемого запуска двигателей является подключение подтягивающего резистора на базе, как показано на рисунке. Значение его сопротивления около 10K. Он будет предохранять транзистор от случайного запуска.
pnp транзистор понять еще труднее. Он использует тот же принцип, но в обратном направлении.
Ток течет от базы к цифровому выводу Arduino; если допустить, что протекание тока базы заставляет ток проходить от эмиттера к коллектору (противоположно направлению тока в транзисторе npn).
Другое важное отличие в том, что pnp-транзистор установлен между плюсом источника питания и контролируемой нами нагрузкой. Нагрузка же, в данном случае, это двигатель, будет подключена между коллектором pnp-транзистора и землей.
Ключевой момент на заметку разработчикам ещё и в том, что при использовании транзисторов pnp с Arduino максимальное напряжение на эмиттер 5 В, и при этом мы на двигатель не сможем подать больше, чем 5 В.
Если использовать внешний источник питания для питания двигателей с большим напряжением чем 5В, на базе появится потенциал выше пяти вольт и Arduino подгорит.
Одно из возможных решений, которое усложнит схему на 3 элемента, показано показано на следующей схеме.
Давайте посмотрим правде в глаза: применение обычных биполярных транзисторов для манипулирования моторчиками уже давно не в моде. Есть более простые и удобные в использовании вещи в наши дни, которые могут обеспечить гораздо большую мощность управления. Их называют MOSFET транзисторы.
Люди просто называют их мосфетами. База, коллектор и эмиттер у MOSFETа называются так затвор, сток и исток. Функционально их используют точно так же, как и обычные транзисторы. При подаче напряжения на натвор, ток будет проходить с истока на сток в случае N-канального МОП-транзистора.
P-канал является эквивалентом транзистора pnp.
Тем не менее, есть некоторые важные различия в работе MOSFET по сравнению с обычным транзистором. Не все MOSFET-транзисторы могут должным образом работать с Arduino. Обычно дискретные транзисторы работают нормально.
Некоторые из известных N-канальных MOSFET имеют маркировку: FQP30N06, IRF510 и IRF520. Первый может выдерживать до 30 А и 60 В то время как следующие два могут отдавать 5,6 А и 10 А, соответственно, при 100 В.
Вот пример схемы управления мотором с помощью N-канального MOSFET:
Мы также можем использовать следующий вариант монтажа проекта на макетной плате:
Двигатель — ещё не все, чем мы можем управлять через транзистор. Любой вид нагрузки постоянного тока может управляться таким образом. Светодиоды, лампочки или другие потребители, даже другой Arduino может быть запитан подобным макаром.
Управление серводвигателем с помощью Arduino
Вы можете подключить маленькие серводвигатели непосредственно к Arduino для очень точного управления положением вала.
Поскольку серводвигатели используют обратную связь для определения положения вала, вы можете управлять этим положением с высокой точностью.
В результате серводвигатели используются для управления положением объектов, поворотом объектов, движением рук и ног роботов, движением датчиков и т.д. с большой точностью.
Серводвигатели обладают небольшими размерами, и так как цепи, управляющие их движением, уже встроены в них, то они могут быть подключены напрямую к Arduino.
Большинство серводвигателей имеют три контакта для подключения:
- черный/коричневый провод корпуса;
- красный провод питания (около 5 вольт);
- желтый или белый провод ШИМ.
Эксперимент 1
В этом эксперименте мы подключим выводы питания и корпуса непосредственно к выводам Arduino 5V и GND. Вход ШИМ подключим к одному из цифровых выходов Arduino.
Необходимые компоненты
- 1 x серводвигатель TowerPro SG90
- 1 x Arduino Mega2560
- 3 x перемычка
Схема соединений
Самое лучшее в серводвигателе – это то, что его можно подключить непосредственно к Arduino. Подключите двигатель к Arduino, как показано на рисунке ниже:
Схема соединений
Код программы
Когда программа запустится, серводвигатель начнет медленно вращаться от положения 0 градусов к положению 180 градусов с шагом в один градус. Когда двигатель повернется на 180 градусов, он начнет поворачиваться в противоположном направлении, пока не вернется в исходное положение.
#include // библиотека Servo
Servo servo_test; // инициализировать объект сервопривода
// для подключенного серводвигателя
int angle = 0;
void setup()
{
servo_test.attach(9); // прикрепить сигнальный вывод серводвигателя
// к выводу 9 Arduino
}
void loop()
{
for(angle = 0; angle < 180; angle += 1) // двигаться от 0 к 180 градусам
{
servo_test.write(angle); // повернуть сервопривод на заданный угол
delay(15);
}
delay(1000);
for(angle = 180; angle>=1; angle-=5) // двигаться от 180 к 0 градусам
{
servo_test.write(angle); // повернуть сервопривод на заданный угол
delay(5);
}
delay(1000);
}
Видео
Эксперимент 2
Данный эксперимент, по сути, является таким же, как и Эксперимент 1, за исключением того, что мы добавили потенциометр для управления положением. Arduino будет считывать напряжение на среднем выводе потенциометра и подстраивать положение вала серводвигателя.
Необходимые компоненты
Схема соединений
Соедините схему, как показано на рисунке ниже:
- красный провод серводвигателя – вывод 5V Arduino;
- коричневый провод серводвигателя – вывод корпуса Arduino;
- желтый провод серводвигателя – вывод ШИМ (9) Arduino;
- вывод 1 потенциометра – вывод 5V Arduino;
- вывод 3 потенциометра – вывод корпуса Arduino;
- вывод 2 потенциометра – вывод аналогового входа (A0) Arduino.
Код программы
После запуска программы вращение потенциометра должно заставлять вращаться вал серводвигателя.
#include // библиотека Servo
Servo servo_test; // инициализировать объект сервопривода
// для подключенного серводвигателя
int angle = 0;
int potentio = A0; // инициализировать аналоговый вывод A0 для потенциометра
void setup()
{
servo_test.attach(9); // прикрепить сигнальный вывод серводвигателя
// к выводу 9 Arduino
}
void loop()
{
angle = analogRead(potentio); // прочитать значение потенциометра от 0 до 1023
angle = map(angle, 0, 1023, 0, 179); // сопоставить значение потенциометра со значением
// в градусах для серводвигателя от 0 до 180
servo_test.write(angle); // повернуть сервопривод на заданный угол
delay(5);
}
Видео
Оригинал статьи:
- Editorial Team. Servo Motor Control with an Arduino
Теги
ArduinoСерводвигательСервопривод
На сайте работает сервис комментирования DISQUS, который позволяет вам оставлять комментарии на множестве сайтов, имея лишь один аккаунт на Disqus.com.
В случае комментирования в качестве гостя (без регистрации на disqus.com) для публикации требуется время на премодерацию.
Подключение драйвера двигателей Motor Shield L293D к плате Arduino
Рассмотрим сегодня примеры использования одного из самых популярных драйверов двигателей Motor Shield L293D, разработанного в свое время компанией Adafruit.
Драйвер позволяет одновременно управлять четырьмя коллекторными двигателя и двумя сервоприводами. Вместо четырех коллекторных двигателей можно подключить два шаговых биполярных двигателя или, к примеру, оставить два коллекторных двигателя и подключить один шаговый двигатель.
Каждый силовой канал рассчитан на нагрузку в 0,6А, поэтому каждый ваш моторчик должен потреблять ток не более 0,6А. Данный Motor Shield полностью совмести с платами Arduino Mega 2560 и Arduino Uno, то есть вставляется в них прямо сверху.
При использовании с другими платами соединение происходит стандартно с помощью проводов.
Стоит обратить внимание на один момент. Если вы будете использовать Motor Shield L293D вместе с платой Arduino Uno, он перекроет вам доступ ко всем пинам платы.
Для подсоединения других датчиков вам придется поработать с паяльником, припаяв гребенку в предусмотренном месте на драйвере двигателей для доступа к аналоговым пинам (которые можно использовать как цифровые).
Или вам придется подсоединять Motor Shield с помощью проводов для макетирования к плате Arduino Uno, чтобы оставить доступ к свободным пинам.
Подумайте, нужны ли вам эти лишние телодвижения, связанные с дополнительной пайкой или кучей лишних проводов? Если вы читаете эту статью, значит, скорей всего находитесь на стадии обучения, и подобные неудобства будут лишние для вас. Поэтому повторюсь ещё раз и в этой статье. Если вы только начинаете изучать работу с микроконтроллерами, берите плату Arduino Mega 2560, чтобы случайно не столкнуться с ситуацией, когда вам не будет хватать пинов для подключения дополнительных датчиков.
И так приступим. Возьмем плату Arduino Mega 2560 и сверху аккуратно вставляем Motor Shield L293D, после чего подключаем двигатели как показано на рисунке.
Обратите внимание на подключение питания к внешнему клеммнику (+M GND) и на замкнутый джампер PWR. При таком подключении, мы одновременно подаем энергию, как на силовую часть драйвера двигателей, так и на саму плату Ардуино.
Подключая питание, не перепутайте плюс с минусом, так как на плате драйвера двигателей нет защитного диода, и подобные действия её быстро выведут из строя.
Джампер PWR соединяет внешний клеммник драйвера двигателей с входом VIN платы Arduino, поэтому если вы подключите питание к разъему 2,1мм платы Arduino, вы также обеспечите совместное питание обоих плат.
Подобное совместное питание не совсем практично, что может вызывать некорректную работу, как подключенных устройств, так и самого микроконтроллера, особенно при максимальных нагрузках. Использовать такое питание лучше только для кратковременной предварительной отладки отдельных силовых узлов.
Правильным решением будет раздельное питание. То есть мозги и силовая часть должны питаться от разных источников питания.
Плату Arduino мы питаем через разъем 2,1мм (к примеру, от батарейки крона или от сети через блок питания). А силовую часть Motor Shield L293D мы питаем через клеммник (+M GND), при этом необходимо снять джампер PWR.
Двигатели мы подсоединяем к клеммникам M1, M2, M3, M4, как показано на рисунке. Между клеммниками M1 и M2, как и между клеммниками M3 и M4 расположены клеммники GND, предназначены они исключительно для удобства при подключении пяти проводных шаговых двигателей.
В совмещенном состоянии с платами Arduino Mega 2560 и Arduino Uno, пины плат задействованы следующим образом:
пины управления скоростью вращения двигателей
- пин 11 платы Ардуино -> Мотор №1 / Шаговый двигатель №1
- пин 3 платы Ардуино -> Мотор №2 / Шаговый двигатель №1
- пин 5 платы Ардуино -> Мотор №3 / Шаговый двигатель №2
- пин 6 платы Ардуино -> Мотор №4 / Шаговый двигатель №2
пины управления отвечающие за направление вращения двигателей
- пин 4 платы Ардуино -> Мотор №1 / Шаговый двигатель №1
- пин 7 платы Ардуино -> Мотор №2 / Шаговый двигатель №1
- пин 8 платы Ардуино -> Мотор №3 / Шаговый двигатель №2
- пин 12 платы Ардуино -> Мотор №4 / Шаговый двигатель №2
пины управления сервоприводами
- пин 9 платы Ардуино — Сервопривод №1
- пин 10 платы Ардуино — Сервопривод №2
С питанием разобрались, моторы подключили, перейдем к написанию простейшего скетча для управления нашими двигателями. Для начала нам необходимо скачать и установить специально разработанную библиотеку AFMotor.
h предназначенную для работы с Motor Shield L293D. Разархивируем скачанный архив в папку libraries программы Arduino IDE, перезагружаем программу.
Всё готово, библиотека установлена, можно приступать к написанию скетча.
Напишем минимальный скетч для управления всего одним двигателем, чтобы было понятней.
#include // Подключаем библиотеку для работы с Motor Shield L293D
// Придумываем имя мотору и объявляем клеммник к которому он подсоединен
AF_DCMotor my_motor1(1);
void setup() // НАСТРОЙКИ
{
my_motor1.setSpeed(250); // задаем скорость вращения двигателя
}
void loop() // ОСНОВНОЙ ЦИКЛ
{
my_motor1.run(FORWARD); // вращаем вперед
delay(5000); // делаем 5 секунд
my_motor1.run(RELEASE); // остановка
delay(3000); // делаем 3 секунды
my_motor1.run(BACKWARD); // вращаем назад
delay(5000); // делаем 5 секунд
my_motor1.run(RELEASE); // остановка
delay(3000); // делаем 3 секунды
}
Ну тут вроде все должно быть понятно, не знаю даже что добавить. Читайте комментарии к коду.
Давайте теперь усложним задачу и напишем скетч для управления всеми четырьмя двигателями, а также научимся создавать функции для более комфортной работы с повторяющимися действиями.
#include // Подключаем библиотеку для работы с Motor Shield L293D
// Придумываем имена моторам и объявляем клеммники к которым они подсоединены
AF_DCMotor my_motor1(1);
AF_DCMotor my_motor2(2);
AF_DCMotor my_motor3(3);
AF_DCMotor my_motor4(4);
// Чтобы код не получался слишком громоздким, лучше всего создавать функции
// для тех действий, которые будут применяться в нашем скетче неоднократно
void set_speed(int speed) // функция СКОРОСТЬ
{
my_motor1.setSpeed(speed);
my_motor2.setSpeed(speed);
my_motor3.setSpeed(speed);
my_motor4.setSpeed(speed);
}
void motor_forward() // функция ПЕРЕДНИЙ ХОД
{
my_motor1.run(FORWARD);
my_motor2.run(FORWARD);
my_motor3.run(FORWARD);
my_motor4.run(FORWARD);
delay(100);
}
void motor_backward() // функция ЗАДНИЙ ХОД
{
my_motor1.run(BACKWARD);
my_motor2.run(BACKWARD);
my_motor3.run(BACKWARD);
my_motor4.run(BACKWARD);
delay(100);
}
void motor_release() // функция ОСТАНОВКА ДВИГАТЕЛЕЙ
{
my_motor1.run(RELEASE);
my_motor2.run(RELEASE);
my_motor3.run(RELEASE);
my_motor4.run(RELEASE);
delay(100);
}
void setup() // НАСТРОЙКИ
{
// Посмотрите насколько проще работать с кодом после создания функций
// нам нужна всего лишь одна строка вызова нужной функции, с помощью которой мы дадим команду сразу четырем двигателям
set_speed(200); // вызываем функцию СКОРОСТЬ — устанавливаем начальную скорость двигателей
}
void loop() // ОСНОВНОЙ ЦИКЛ
{
motor_forward(); // вызываем функцию ПЕРЕДНИЙ ХОД
delay(5000); // выполняем функцию ПЕРЕДНИЙ ХОД в течение 5 секунд
motor_release(); // вызываем функцию ОСТАНОВКИ ДВИГАТЕЛЕЙ
delay(3000); // держим остановленными двигатели в течении 3 секунд
set_speed(255); // вызываем функцию СКОРОСТЬ — увеличиваем скорость двигателей до 255
motor_backward(); // вызываем функцию ЗАДНИЙ ХОД
delay(5000); // выполняем функцию ЗАДНИЙ ХОД в течение 5 секунд
motor_release(); // вызываем функцию ОСТАНОВКИ ДВИГАТЕЛЕЙ
delay(3000); // держим остановленными двигатели в течении 3 секунд
}
Данный код демонстрирует пример создания и применения собственных функций для управления двигателями, что впоследствии существенно сократит количество строк в вашем скетче. Проще один раз прописать какое-то действие в функции и вызывать её потом постоянно с помощью одной строки, чем постоянно писать одни и те же строки с кодом для повторяющихся действий.
- С подсоединением и управлением коллекторных двигателей вроде разобрались, если что-то не понятно, задавайте вопросы в х под этой статьей.
- Давайте теперь подключим шаговый двигатель и напишем для него скетч управления.
При подключении шагового двигателя применяем опять же раздельное питание, чтобы не напрягать сильно плату Ардуино и в тоже время быть уверенными в корректной работе шаговика. К клеммам расположенным с левой стороны аналогично можно подключить еще один шаговый двигатель. Теперь напишем простейший скетч управления нашим шаговиком.
#include // Подключаем библиотеку для работы с Motor Shield L293D
// Придумываем имя шаговому двигателю (например: stepper_motor),
// указываем количество шагов для полного оборота (48) и номер порта к которому подсоединен шаговик
// порт №1 — клеммы M1 и M2, порт №2 клеммы M3 и M4
AF_Stepper stepper_motor(48, 2);
void setup() // НАСТРОЙКИ
{
// можем ничего здесь не писать, если нет необходимости задать какие-то предварительные настройки
// но сама функция void setup() должна присутствовать в коде в любом случае, даже пустая
}
int s; // объявляем переменную, которая нам будет служить в качестве счетчика шагов (имя переменной можете придумать любое)
void loop() // ОСНОВНОЙ ЦИКЛ
{
// Делаем вращение в одном направлении
// SINGLE — тип шага
for (s=0; s
Управление сервоприводом ардуино
Сервопривод Ардуино (англ. — arduino servo) — устройство с электрическим мотором, которое можно повернуть на определенный угол и оставить в этом положении на определенное время.
Сервомоторы Ардуино по сути своей отличные устройства, которые могут поворачиваться в указанное положение и могут применяться в огромном количестве областей. Особенно сейчас их чаще всего применяют в робототехнике.
Обычно у них есть выходной вал, который может поворачиваться на 180 градусов. Используя Arduino мы можем задать сервомотору определенное положение в которое он перейдет.
Изначально сервоприводы начали использовать еще задолго до появления Ардуино, скажем так, в мире пультов дистанционного управления (RC), как правило, для управления рулевым колесом игрушечных машинок или крыльями самолетов. Со временем они нашли свое применение в робототехнике, автоматизации и, конечно же, в мире Ардуино.
В нашем материале мы увидим как подключить сервопривод Ардуино, а затем как управлять этим полезным механизмом и поворачивать его в определенные положения.
Скетч для сервопривода Ардуино
- Скетч ниже заставит сервопривод переместиться в позицию 0 градусов, подождать 1 секунду, затем повернуться на 90 градусов, подождать еще одну секунду, после повернуться на 180 градусов и перейти в первоначальное положение.
- Также дополнительно мы используем библиотеку servo — скачайте ниже или в нашем разделе Библиотеки.
- Содержимое zip-файла размещается в папку arduino-xxxx/hardware/liraries.
// Подклоючаем библиотеку Servo #include // Пин для сервопривода int servoPin = 3; // Создаем объект Servo Servo1; void setup() { // Нам нужно подключить сервопривод к используемому номеру пина Servo1.attach(servoPin); } void loop(){ // 0 градусов Servo1.
write(0); delay(1000); // 90 градусов Servo1.write(90); delay(1000); // 180 градусов Servo1.write(180); delay(1000); }
Если сервомотор подключен к другому цифровому контакту, просто измените значение servoPin на значение используемого цифрового вывода.
Помните, что использование библиотеки Servo автоматически отключает функцию PWM для PWM-контактов 9 и 10 на Arduino UNO и аналогичных платах.
Наш код просто объявляет объект и затем инициализирует сервопривод с помощью функции servo.attach(). Мы не должны забывать подключать серво библиотеку. В цикле мы устанавливаем сервопривод на 0 градусов, ждем, а затем устанавливаем его на 90, а затем на 180 градусов.
- Второй скетч для варианта с Arduino Diecimilia ниже.
- Нам достаточно будет скачать и подключить библиотеку из архива:
- Сам код такой:
#include Servo servo1; Servo servo2; void setup() { pinMode(1,OUTPUT); servo1.attach(14); //analog pin 0 //servo1.setMaximumPulse(2000); //servo1.setMinimumPulse(700); servo2.attach(15); //analog pin 1 Serial.begin(19200); Serial.
println(«Ready»); } void loop() { static int v = 0; if ( Serial.available()) { char ch = Serial.read(); switch(ch) { case ‘0’…’9′: v = v * 10 + ch — ‘0’; break; case ‘s’: servo1.write(v); v = 0; break; case ‘w’: servo2.write(v); v = 0; break; case ‘d’: servo2.
detach(); break; case ‘a’: servo2.attach(15); break; } } Servo::refresh(); }
Стандартные методы серво-библиотеки
attach(int)
Соединение пина и сервопривода. Вызывает pinMode. Возвращает 0 при ошибке.
- detach()
- Отсоединение пина от сервопривода.
- write(int)
- Установка угла сервопривода в градусах, от 0 до 180.
- read()
- Возвращает значение, установленное write(int).
- attached()
- Возвращает 1, если серво в настоящее время подключен.
Дополнительные примеры скетчей
Следующий код позволяет вам контролировать серводвигатель на пине 2 с помощью потенциометра на аналоговом 0.
#include SoftwareServo myservo; // create servo object to control a servo int potpin = 0; // analog pin used to connect the potentiometer int val; // variable to read the value from the analog pin void setup() { myservo.
attach(2); // attaches the servo on pin 2 to the servo object } void loop() { val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023) val = map(val, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180) myservo.
write(val); // sets the servo position according to the scaled value delay(15); // waits for the servo to get there SoftwareServo::refresh(); }
Следующий код — это поворот (пинг/понг) на выводе A0 с переменной скоростью.
#include SoftwareServo myservo; // create servo object to control a servo #define pinServo A0 int speed = 1; int limits = {30,150}; // set limitations (min/max: 0->180) boolean refresh = false; // toggle refresh on/off void setup() { Serial.
begin(9600); // attaches the servo on pin to the servo object myservo.attach(pinServo); // init angle of servo inbetween two limitations myservo.write((limits-limits)/2); } void loop() { // refresh angle int angle = myservo.
read(); // change direction when limits if (angle >= limits || angle 0) { String s = Serial.readString(); Speed = s.
toInt(); // преобразуем считанную строку в число } if (Speed > 0) { // если число положительное, вращаем в одну сторону analogWrite(IA1, Speed); analogWrite(IA2, LOW); } else { // иначе вращаем ротор в другую сторону analogWrite(IA1, LOW); analogWrite(IA2, -Speed); } }
Максимальная скорость вращения – при наибольшем значении напряжения, которое может выдать драйвер двигателя. Мы можем управлять скоростью вращения, подавая напряжения в диапазоне от 0 до 5 Вольт.
Так как мы используем цифровые ножки с ШИМ, напряжение на них регулируется командой analogWtirte(pin, value), где pin – номер вывода, на котором мы хотим задать напряжение, а аргумент value – коэффициент, пропорциональный значению напряжения, принимающий значения в диапазоне от 0 (напряжение на выводе равно нулю) до 255 (напряжение на выводе равно 5 В).