В этой статье мы поговорим о шаговых двигателях в проектах Ардуино на примере очень популярной модели 28BYJ-48. Так же как и сервоприводы, шаговые моторы являются крайне важным элементом автоматизированных систем и робототехники.
Их можно найти во многих устройствах рядом: от CD-привода до 3D-принтера или робота-манипулятора.
В этой статье вы найдете описание схемы работы шаговых двигателей, пример подключения к Arduino с помощью драйверов на базе ULN2003 и примеры скетчей с использованием стандартной библиотеки Stepper.
Шаговый двигатель – принцип работы
Схема шагового двигателя
Шаговый двигатель – это мотор, перемещающий свой вал в зависимости от заданных в программе микроконтроллера шагов и направления. Подобные устройства чаще всего используются в робототехнике, принтерах, манипуляторах, различных станках и прочих электронных приборах. Большим преимуществом шаговых двигателей над двигателями постоянного вращения является обеспечение точного углового позиционирования ротора. Также в шаговых двигателях имеется возможность быстрого старта, остановки, реверса.
Шаговый двигатель обеспечивает вращения ротора на заданный угол при соответствующем управляющем сигнале. Благодаря этому можно контролировать положение узлов механизмов и выходить в заданную позицию.
Работа двигателя осуществляется следующим образом – в центральном вале имеется ряд магнитов и несколько катушек. При подаче питания создается магнитное поле, которое воздействует на магниты и заставляет вал вращаться.
Такие параметры как угол поворота (шаги), направление движения задаются в программе для микроконтроллера.
Упрощенные анимированные схемы работы шагового двигателя
Основные виды шаговых моторов:
- Двигатели с переменными магнитами (применяются довольно редко);
- Двигатели с постоянными магнитами;
- Гибридные двигатели (более сложные в изготовлении, стоят дороже, но являются самым распространенным видом шаговых двигателей).
Где купить шаговый двигатель
Самые простые двигатели Варианты на сайте AliExpress:
Драйвер для управления шаговым двигателем
Драйвер – это устройство, которое связывает контроллер и шаговый двигатель. Для управления биполярным шаговым двигателем чаще всего используется драйверы L298N и ULN2003.
Работа двигателя в биполярном режиме имеет несколько преимуществ:
- Увеличение крутящего момента на 40% по сравнению с униполярными двигателями;
- Возможность применения двигателей с любой конфигурацией фазной обмотки.
Но существенным минусов в биполярном режиме является сложность самого драйвера.
Драйвер униполярного привода требует всего 4 транзисторных ключа, для обеспечения работы драйвера биполярного привода требуется более сложная схема.
С каждой обмоткой отдельно нужно проводить различные действия – подключение к источнику питания, отключение. Для такой коммутации используется схема-мост с четырьмя ключами.
Драйвер шагового двигателя на базе L298N
Этот мостовой драйвер управляет двигателем с током до 2 А и питанием до 46В. Модуль на основе драйвера L298N состоит из микросхемы L298N, системы охлаждения, клеммных колодок, разъемов для подключения сигналов, стабилизатора напряжения и защитных диодов.
Драйвер двигателя L298N
Драйвер шагового двигателя ULN2003
Описание драйвера шаговых двигателей UNL2003
Шаговые двигателями с модулями драйверов на базе ULN2003 – частые гости в мастерских Ардуино благодаря своей дешевизне и доступности. Как правило, за это приходится платить не очень высокой надежностью и точностью.
Другие драйвера
Существует другой вид драйверов – STEP/DIR драйверы. Это аппаратные модули, которые работают по протоколу STEP/DIR для связи с микроконтроллером. STEP/DIR драйверы расширяют возможности:
- Они позволяют стабилизировать фазные токи;
- Возможность установки микрошагового режима;
- Обеспечение защиты ключа от замыкания;
- Защита от перегрева;
- Оптоизоляция сигнала управления, высокая защищенность от помех.
В STEP/DIR драйверах используется 3 сигнала:
- STEP – импульс, который инициирует поворот на шаг/часть шага в зависимости от режима. От частоты следования импульсов будет определяться скорость вращения двигателя.
- DIR – сигнал, который задает направление вращения. Обычно при подаче высокого сигнала производится вращение по часовой стрелке. Этот тип сигнала формируется перед импульсом STEP.
- ENABLE – разрешение/запрет работы драйвера. С помощью этого сигнала можно остановить работу двигателя в режиме без тока удержания.
Одним из самых недорогих STEP/DIR драйверов является модуль TB6560-V2. Этот драйвер обеспечивает все необходимые функции и режимы.
Подключение шагового двигателя к Ардуино
Подключение будет рассмотрено на примере униполярного двигателя 28BYj-48 и драйверов L298 и ULN2003. В качестве платы будет использоваться Arduino Uno.
Подключение шагового двигателя к Ардуино
Еще один вариант схемы с использованием L298:
Подключение шагового двигателя к Ардуино на базе L298
Схема подключения на базе ULN2003 изображена на рисунке ниже. Управляющие выходы с драйвера IN1-IN4 подключаются к любым цифровым контактам на Ардуино. В данном случае используются цифровые контакты 8-11. Питание подключается к 5В. Также для двигателя желательно использовать отдельный источник питания, чтобы не перегрелась плата Ардуино.
Подключение шагового двигателя к Ардуино
Принципиальная схема подключения.
Принципиальная схема подключения шагового двигателя
Еще одна схема подключения биполярного шагового двигателя Nema17 через драйвер L298 выглядит следующим образом.
Обзор основных моделей шаговых двигателей для ардуино
Nema 17 – биполярный шаговый двигатель, который чаще всего используется в 3D принтерах и ЧПУ станках. Серия 170хHSхххА мотора является универсальной.
Основные характеристики двигателя:
- Угловой шаг 1,8°, то есть на 1 оборот приходится 200 шагов;
- Двигатель – двухфазный;
- Рабочие температуры от -20С до 85С;
- Номинальный ток 1,7А;
- Момент удержания 2,8 кг х см;
- Оснащен фланцем 42 мм для легкого и качественного монтажа;
- Высокий крутящий момент – 5,5 кг х см.
28BYJ-48 – униполярный шаговый двигатель. Используется в небольших проектах роботов, сервоприводных устройствах, радиоуправляемых приборах.
Характеристики двигателя:
- Номинальное питание – 5В;
- 4-х фазный двигатель, 5 проводов;
- Число шагов: 64;
- Угол шага 5,625°;
- Скорость вращения: 15 оборотов в секунду
- Крутящий момент 450 г/сантиметр;
- Сопротивление постоянного тока 50Ω ± 7% (25 ℃).
Описание библиотеки для работы с шаговым двигателем
В среде разработки Ардуино IDE существует стандартная библиотека Strepper.h для написания программ шаговых двигателей. Основные функции в этой библиотеке:
- Stepper(количество шагов, номера контактов). Эта функция создает объект Stepper, которая соответствует подключенному к плате Ардуино двигателю. Аргумент – контакты на плате, к которым подключается двигатель, и количество шагов, которые совершаются для полного оборота вокруг своей оси. Информацию о количестве шагов можно посмотреть в документации к мотору. Вместо количества шагов может быть указан угол, который составляет один шаг. Для определения числа шагов, нужно разделить 360 градусов на это число.
- Set Speed(long rpms) – функция, в которой указывается скорость вращения. Аргументом является положительное целое число, в котором указано количество оборотов в минуту. Задается после функции Step().
- Step(Steps) –поворот на указанное количество шагов. Аргументом может быть либо положительное число – поворот двигателя по часовой стрелке, либо отрицательное – против часовой стрелки.
Пример скетча для управления
В наборе примеров библиотеки Stepper.h существует программа stepper_oneRevolution, в которой задаются все параметры для шагового двигателя – количество шагов, скорость, поворот.
#include
const int stepsPerRevolution = 200;
Stepper myStepper(stepsPerRevolution, 8,9,10,11); //подключение к пинам 8…11 на Ардуино
void setup() {
myStepper.setSpeed(60); //установка скорости вращения ротора
Serial.begin(9600);
}
void loop() {
//Функция ожидает, пока поступит команда, преобразовывает текст и подает сигнал на двигатель для его вращения на указанное число шагов.
Serial.println(«Move right»); //по часовой стрелке
myStepper.step(stepsPerRevolution);
delay(1000);
Serial.println(«Move left»); //против часовой стрелки
myStepper.step(-stepsPerRevolution);
delay(1000);
}
Заключение
В этой статье мы с вами узнали, что такое шаговый двигатель, как можно его подключить к ардуино, что такое драйвер шагового двигателя.
Мы также рассмотрели пример написания скетча, использующего встроенную библиотеку Stepper.
Как видим, ничего особенно сложного в работе с шаговыми моторами нет и мы рекомендуем вам обязательно поэкспериментировать самостоятельно и попробовать включить его в своих проектах Arduino.
Управление шаговым двигателем с помощью Arduino и потенциометра
Шаговые двигатели с каждым годом приобретают все большую популярность в мире электроники поскольку именно они обеспечивают превосходную точность позиционирования различных механизмов. В этой статье мы рассмотрим подключение одного из самых распространенных шаговых двигателей 28-BYJ48 к плате Arduino при помощи модуля ULN2003 и управление им с помощью потенциометра.
В нашей предыдущей статье про подключение шагового двигателя к плате Arduino мы управляли углом его поворота из она монитора последовательной связи, в этом же проекте мы будем управлять поворотом шагового двигателя вращая ручку потенциометра.
Если мы будем вращать ручку потенциометра по часовой стрелке, то и шаговый двигатель будет поворачиваться по часовой стрелке, а если мы ручку потенциометра будем поворачивать против часовой стрелки – то и шаговый двигатель будет вращаться против часовой стрелки.
Общие принципы работы шаговых двигателей
Внешний вид шагового двигателя 28-BYJ48 (купить на AliExpress) представлен на следующем рисунке:
Первый вопрос, который напрашивается при взгляде на этот рисунок – почему в отличие от обычного двигателя из этого шагового двигателя выходят 5 проводов различных цветов? Чтобы понять это давайте сначала разберемся с принципами работы шагового двигателя.
Начнем с того, что шаговые двигатели не вращаются, а “шагают”, поэтому они и называются шаговыми двигателями. То есть в один момент времени они будут передвигаться только на один шаг.
Чтобы добиться этого в устройстве шаговых двигателей присутствует несколько катушек и на эти катушки нужно подавать питание в определенной последовательности чтобы двигатель вращался (шагал).
При подаче питания на каждую катушку двигатель делает один шаг, при последовательной подаче питания на катушки двигатель будет совершать непрерывные шаги, то есть вращаться. Давайте более подробно рассмотрим катушки, присутствующие внутри шагового двигателя.
Как можно видеть из рисунка, двигатель имеет однополярную катушку с 5 выводами. Но фактически это 4 катушки, на которые нужно подавать питание в определенной последовательности. На красные провода необходимо подать +5V, на остальные 4 провода необходимо подать землю чтобы запустить в работу соответствующую катушку. Мы будем использовать плату Arduino чтобы подавать питание на эти катушки в определенной последовательности и тем самым заставлять двигатель вращаться. Более подробно ознакомиться с принципами работы шаговых двигателей можно в статье про подключение шагового двигателя к микроконтроллеру AVR.
Так почему же этот двигатель называется 28-BYJ48? Честно говоря, мы не знаем точного ответа на этот вопрос. Некоторые наиболее важные технические характеристики этого шагового двигателя приведены на следующем рисунке.
На первый взгляд от такого количества характеристик может закружиться голова, но давайте попробуем выделить из них самые важные, те, которые нам понадобятся для дальнейшей работы. Во-первых, мы знаем, что это шаговый двигатель 5V, поэтому необходимо подавать на красный провод 5V.
Также мы знаем что это четырехфазный шаговый двигатель поскольку в нем четыре катушки. Передаточное число этого двигателя — 1: 64. Это означает, что вал, который вы видите снаружи, сделает одно полное вращение в том случае, когда двигатель внутри сделает 64 оборота.
Это происходит благодаря шестерням, которые включены между двигателем и выходным валом. Эти шестерни помогают в увеличении крутящего момента.
Еще одним важным показателем, который нам следует знать, является угол шага: 5.625°/64. Это значит что когда двигатель сделает последовательность в 8 шагов он будет поворачиваться на 5.625° при каждом шаге и за один полный оборот он сделает 64 шага (5.625*64=360).
Расчет шагов на оборот для шагового двигателя
Важно знать, как рассчитать количество шагов за один оборот для вашего шагового двигателя, потому что только тогда вы можете эффективно его запрограммировать.
В Arduino для управления двигателем мы будем использовать 4-шаговую последовательность, поэтому угол шага будет составлять 11.25°. Поскольку изначально он равен 5.625°(приведен в даташите), то для 8 шаговой последовательности получим 11.25° (5.625*2=11.25).
Справедлива следующая формула:
Количество шагов за оборот = 360 / угол шага.
В нашем случае 360/11.25 = 32 шага за оборот.
Зачем нужен драйвер мотора для управления шаговым двигателем
Большинство шаговых двигателей будут работать только с помощью модуля драйвера мотора. Это связано с тем, что микроконтроллер (в нашем случае плата Arduino) не может обеспечить достаточный ток на своих контактах ввода/вывода для работы двигателя.
Поэтому мы будем использовать внешний драйвер мотора для управления нашим шаговым двигателем — модуль ULN2003 (купить на AliExpress). В сети интернет можно найти рейтинги эффективности различных драйверов мотора, но эти рейтинги будут меняться в зависимости от типа используемого шагового двигателя.
Основной принцип, которого следует придерживаться при выборе драйвера мотора – он должен обеспечивать достаточный ток для управления шаговым двигателем.
Работа схемы
Схема устройства представлена на следующем рисунке.
Чтобы подавать питание на соответствующие катушки шагового двигателя мы будем использовать цифровые контакты 8, 9, 10 и 11 платы Arduino, к которым подключены соответствующие контакты драйвера двигателей ULN2003. Потенциометр, с помощью которого мы будем управлять вращением шагового двигателя, подключен к аналоговому контакту A0 платы Arduino.
Драйвер мотора запитывается от контакта 5V платы Arduino. Но если вы будете подсоединять какую-нибудь нагрузку к шаговому двигателю, то вам потребуется внешний источник питания для драйвера мотора. Мы в нашем примере эксплуатируем шаговый двигатель без нагрузки, поэтому нам хватило питания от платы Arduino. И не забудьте соединить землю платы Arduino с землей драйвера мотора.
Объяснение программы для платы Arduino
Перед тем как начать писать программу для платы Arduino давайте разберемся что должно происходить внутри этой программы. Как мы уже говорили ранее, мы будем использовать метод 4-шаговой последовательности, то есть нам нужно будет сделать 4 шага чтобы выполнить один полный оборот двигателя.
| Номер шага | Контакты, на которое подается питание | Катушки, на которое подается питание |
| Шаг 1 | 8 и 9 | A и B |
| Шаг 2 | 9 и 10 | B и C |
| Шаг 3 | 10 и 11 | C и D |
| Шаг 4 | 11 и 8 | D и A |
На драйвере мотора есть 4 светодиода, по свечению которых можно судить о том, на какую катушку подается питание в конкретный момент. Более подробно все эти процессы можно посмотреть в видео, приведенном в конце статьи.
Мы напишем программу, в которой необходимое количество шагов для двигателя мы будем вводить в мониторе последовательного порта (serial monitor) платы Arduino. Полный текст программы приведен в конце статьи, здесь же мы рассмотрим наиболее важные его фрагменты.
- Как мы рассчитали ранее, полное число шагов для полного оборота нашего шагового двигателя, равно 32, пропишем это в следующей строчке кода:
- #define STEPS 32
- Далее мы должны сказать плате Arduino через какие ее контакты мы будем управлять шаговым двигателем (то есть к каким ее контактам подключен драйвер мотора).
- Stepper stepper (STEPS, 8, 10, 9, 11);
Примечание: последовательность номеров контактов, указанная в приведенной команде (8,10,9,11) – специально упорядочена таким образом чтобы подавать питание на катушки шагового двигателя в правильном порядке. Если вы измените номера контактов, к которым подключен шаговый двигатель, то вы соответствующим образом должны их упорядочить для подачи в приведенную команду.
- Мы будем использовать специальную библиотеку для работы с шаговыми двигателями, поэтому для задания скорости вращения шагового двигателя мы можем использовать команду вида:
- stepper.setSpeed(200);
- Для двигателя 28-BYJ48 скорость вращения можно установить в диапазоне от 0 до 200.
- Теперь, чтобы двигатель сделал один шаг, мы можем использовать следующую команду:
- stepper.step(val);
Количество шагов, которое должен сделать двигатель, определяется переменной “val”. Поскольку мы имеем 32 шага (для оборота) и передаточное число 64 мы должны сделать 2048 (32*64=2048) “шагов” в этой команде для совершения одного полного оборота двигателя.
- Соответственно, чтобы шаговый двигатель сделал один шаг по часовой стрелке, необходимо использовать команду:
- stepper.step(1);
- А один шаг против часовой стрелки:
- stepper.step(-1);
В нашей программе мы будем считывать значение на аналоговом контакте A0 платы Arduino и сравнивать его с предыдущим значением (Pval). Если оно увеличилось, то мы будем делать 5 шагов двигателем по часовой стрелке, а если уменьшилось – то 5 шагов двигателем против часовой стрелки.
potVal = map(analogRead(A0),0,1024,0,500);
if (potVal>Pval)
stepper.step(5);
if (potValPval)
stepper.step(5);
if (potVal
Урок 29. StepMotor — библиотека управления шаговыми двигателями в системе Ардуино. Библиотека прерывания по таймеру 1 TimerOne
- В уроке рассказываю о моей библиотеке StepMotor, предназначенной для управления униполярными и биполярными шаговыми двигателями.
- Предыдущий урок Список уроков Следующий урок
- Предыдущий урок был посвящен подключению униполярных шаговых двигателей к плате Ардуино и стандартной библиотеке Stepper.
На мой взгляд, библиотека Stepper может быть использована только для демонстрации и проверки работы двигателей. В практических приложениях применение этой библиотеки крайне ограничено из-за ряда недостатков:
- при управлении двигателем функции Stepper подвешивают программу, забирают все вычислительные ресурсы микроконтроллера;
- в один момент времени может работать только один двигатель;
- не поддерживаются все основные режимы коммутации обмоток;
- ограничены функциональные возможности.
Я написал свою библиотеку StepMotor, которая работает в параллельном процессе, может управлять одновременно несколькими шаговыми двигателями, поддерживает все возможные режимы. По сути это аналог моей библиотеки для системы управления шаговыми двигателями фасовочного оборудования.
StepMotor — библиотека управления шаговыми двигателями в системе Ардуино.
От стандартной библиотеки Stepper мою библиотеку отличает:
- работает в параллельном процессе, не блокирует выполнение программы;
- может управлять одновременно несколькими двигателями;
- поддерживает шаговый, полу шаговый и между шаговый режимы;
- при остановке двигателя поддерживает режимы: полное выключение фаз и с током удержания для фиксации положения ротора;
- использует минимум ресурсов производительности микроконтроллера;
- занимает мало программной и оперативной памяти.
Загрузить библиотеку StepMotor.h можно по этой ссылке:
Зарегистрируйтесь и оплатите. Всего 60 руб. в месяц за доступ ко всем ресурсам сайта!
- Как установить написано в нескольких предыдущих уроках, например, в уроке 9.
- Описание класса StepMotor.
- Я привожу только public методы.
- class StepMotor {
- public:
StepMotor(byte pinA, byte pinB, byte pinC, byte pinD); // конструктор
void control(); // управление, метод должен вызываться регулярно с максимальной частотой коммутации фаз
void step(int steps); // инициирует поворот двигателя на заданное число шагов
void setMode(byte stepMode, boolean fixStop); // задает режимы коммутации фаз и остановки
void setDivider(int divider); // установка делителя частоты для коммутации фаз
int readSteps(); // чтение оставшихся шагов
} - Описание методов класса StepMotor.
- void control()
Метод должен вызываться регулярно в параллельном процессе. Частота вызова метода определяет частоту коммутации фаз двигателя. Делитель частоты, устанавливаемый функцией setDivider, делит именно частоту вызова control().
// обработчик прерывания
void timerInterrupt() {
myMotor.control(); // управление двигателем
}
void step(int steps)
Инициирует поворот двигателя на заданное число шагов. При работе двигателя в полу шаговом режиме имеется в виду не физические шаги двигателя, а полушаги. Аргумент с положительным значением вызывает вращение против часовой стрелки, отрицательный аргумент приводит к вращению двигателя по часовой стрелке.
Запустив вращение двигателя функцией step(), например
myMotor.step(400); // сделать 400 шагов против часовой стрелки
программа может заниматься другими задачами. Двигатель остановится сам. При необходимости в любой момент можно остановить двигатель командой
- myMotor.step(0); // остановить двигатель
- Можно задать новое число шагов, не дожидаясь остановки двигателя. Например, для непрерывного вращения следует периодически посылать команду с большим числом шагов
- myMotor.step(32000); // постоянное вращение
- О том, что двигатель остановился, программа может узнать с помощью функции readSteps().
- void setMode(byte stepMode, boolean fixStop)
- Метод задает режим коммутации фаз двигателя и состояние остановленного двигателя.
- stepMode – режим управления двигателем.
| Значение stepMode | Режим |
| Шаговый | |
| 1 | Полу шаговый |
| 2 | Между шаговый |
О режимах коммутации обмоток шаговых двигателей можно посмотреть по этой ссылке.
fixStop – определяет режим остановленного двигателя.
| Значение fixStop | Состояние двигателя в остановленном состоянии |
| false | С обмоток снимается напряжение, двигатель разблокирован |
| true | Через обмотки продолжает течь ток удержания, ротор находится в фиксированном положении |
- myMotor.setMode(0, false); // шаговый режим, без фиксации при остановке
- myMotor.setMode(1, true); // полу шаговый режим, с фиксацией ротора при остановке
- void setDivider(int divider)
- Метод задает коэффициент деления частоты вызова функции control(), а значит, определяет скорость вращения двигателя. Для расчетов можно использовать следующую формулу:
- Rpm = 60 000 / ( divider * Tcontrol * Nдвигателя )
- Rpm – скорость вращения в оборотах в минуту;
- Tcontrol – период вызова метода control() в мс;
- Nдвигателя – число шагов двигателя на полный оборот.
- Для полу шагового режима формула несколько меняется.
- Rpm = 30 000 / ( divider * Tcontrol * Nдвигателя ).
- Например,
- myMotor.setDivider(21); // делитель частоты 21 (при прерывании 1 мс период коммутации фаз 21 мс)
- означает, что фазы будут коммутироваться через каждые 21 мс. Это соответствует скорости вращения:
Rpm = 60 000 / ( 21 * 1 * 48 ) = 59,5 об./мин или примерно один оборот в сек.
int readSteps()
Метод позволяет узнать количество шагов, оставшихся до остановки двигателя. Если он возвращает 0, то это означает, что двигатель остановился.
- if (myMotor.readSteps() == 0) {
- // двигатель остановился
- }
- Примеры использования библиотеки StepMotor.
- Библиотеку необходимо загрузить и установить (можно посмотреть в уроке 9).
Зарегистрируйтесь и оплатите. Всего 60 руб. в месяц за доступ ко всем ресурсам сайта!
Для проверки примеров я использовал драйвер и двигатель PM35S-048 из предыдущего урока. У двигателя 48 шагов на оборот.
- В следующем уроке подключу через этот же драйвер более мощный двигатель.
- Вот пример скетча программы, которая постоянно вращает двигатель.
// программа управления шаговым двигателем с помощью библиотеки StepMotor
// двигатель вращается постоянно против часовой стрелке со скоростью 60 об. в мин
#include
#include
StepMotor myMotor(10, 11, 12, 13); // создаем объект типа StepMotor, задаем выводы для фаз
void setup() {
MsTimer2::set(1, timerInterrupt); // задаем период прерывания по таймеру 1 мс
MsTimer2::start(); // разрешаем прерывание по таймеру
myMotor.
setMode(0, false); // шаговый режим, без фиксации при остановке
myMotor.setDivider(21); // делитель частоты 21 (при прерывании 1 мс период коммутации фаз 21 мс)
}
void loop() {
myMotor.step(1000);
}
//————————————— обработчик прерывания 1 мс
void timerInterrupt() {
myMotor.control(); // управвление двигателем
}
В цикле loop() надо периодически вызывать метод step() не позволяя, двигателю остановиться. Если число шагов в аргументе функции step() задавать большим, например, 30000, то вызывать метод достаточно раз в несколько секунд. Все остальное время можно использовать для других задач.
Вот скетч аналога программы из предыдущего урока. Двигатель делает 5 оборотов против часовой стрелки, затем пауза 1 сек. Еще 5 оборотов по часовой стрелки, пауза 1 сек и так в бесконечном цикле.
// программа управления шаговым двигателем с помощью библиотеки StepMotor
// двигатель вращается против часовой срелки 5 оборотов, пауза 1 сек,
// 5 оборотов по часовой стрелке, пауза 1 сек, и так в бесконечном цикле
#include
#include
StepMotor myMotor(10, 11, 12, 13); // создаем объект типа StepMotor, задаем выводы для фаз
unsigned int timeCounter; // счетчик времени
byte md; // режим: 0 — вращение против ч.с., 1 — пауза, 2 — вращение против ч.с., 3 — пауза
void setup() {
MsTimer2::set(1, timerInterrupt); // задаем период прерывания по таймеру 1 мс
MsTimer2::start(); // разрешаем прерывание по таймеру
myMotor.
setMode(0, false); // шаговый режим, без фиксации при остановке
myMotor.setDivider(21); // делитель частоты 21 (при прерывании 1 мс период коммутации фаз 21 мс)
md= 0; // начальный режим
myMotor.
step(240); // начальный запуск
}
void loop() {
// управление вращением двигателя
if (md == 0) {
// пять оборотов против часовой стрелки
if (myMotor.
readSteps() == 0) { md=1; timeCounter=0; }
}
else if (md == 1) {
// пауза 1 сек
if (timeCounter >= 1000) { md=2; myMotor.step(-240); }
}
else if (md == 2) {
// пять оборотов по часовой стрелке
if (myMotor.
readSteps() == 0) { md=3; timeCounter=0; }
}
else {
// пауза 1 сек
if (timeCounter >= 1000) { md=0; myMotor.step(240); }
}
}
//————————————— обработчик прерывания 1 мс
void timerInterrupt() {
myMotor.control(); // управление двигателем
timeCounter++; // счетчик времени
}
Программный блок управления двигателем размещен в цикле loop(), но он не подвешивает программу и занимает минимум времени. Все остальное время можно использовать для других задач. В принципе этот блок можно разместить в обработчике прерывания.
Библиотека StepMotor отсчитывает время переключения фаз от периода вызова функции control(). Функция control() обычно вызывается прерыванием от таймера. Период прерывания определяет скорость вращения двигателя по формуле, описанной выше:
Rpm = 60 000 / ( divider * Tcontrol * Nдвигателя ).
Видно, что зависимость скорости вращения от периода вызова метода control() нелинейная, с гиперболической зависимостью. Например, для двигателя из предыдущего урока (48 шагов на оборот) и периода вызова метода control() 1 мс получим следующие значения скоростей.
| divider | Скорость вращения, об. / мин |
| 1 | 1250 |
| 2 | 625 |
| 3 | 417 |
| 4 | 312 |
| 5 | 250 |
| 6 | 208 |
| 7 | 179 |
| 8 | 156 |
| . . . | . . . |
При малых значениях делителя divider скорость вращения задается со значительным шагом. При увеличении коэффициента divider шаг уменьшается. Т.е.
если необходима плавная регулировка скорости, следует уменьшить период вызова control() и увеличить значение делителя. А библиотека MsTimer2 позволяет формировать прерывание с минимальным периодом 1 мс.
Для прерываний с меньшим периодом существует другая библиотека управления таймером.
Библиотека TimerOne.
Библиотека использует таймер 1 контроллера Ардуино и позволяет формировать прерывания с периодом от 1 мкс до 8,4 сек. Дискретность установки времени — 1 мкс.
Кроме того она управляет режимами ШИМ на выводах микроконтроллера, но сейчас мы будем использовать TimerOne только для формирования временных интервалов.
Работать с библиотекой достаточно просто. Загрузить ее можно по этой ссылке TimerOne-r11.zip. Как установить, написано в уроке 9.
Методы TimerOne.
void initialize(long microseconds)
Метод инициализирует таймер. Должен быть вызван прежде использования любого другого метода.
Аргумент microseconds задает период таймера в мкс. По умолчанию задана 1 сек.
- Timer1.initialize(250); // инициализация таймера 1, период 250 мкс
- void setPeriod(long microseconds)
- Метод устанавливает период таймера в диапазоне 1 мкс … 8,4 сек.
- Timer1. setPeriod (250); // период 250 мкс
- void start()
Метод запускает таймер с нового периода. Следует использовать, если таймер был остановлен.
- void stop()
- Метод останавливает таймер.
- void restart()
- Перезапускает таймер с нового периода.
- void attachInterrupt(void (*isr)(), long microseconds)
- Метод вызывает функцию с заданным периодом прерывания.
- Timer1.attachInterrupt(timerInterrupt, 250); // задаем обработчик прерываний функции timerInterrupt
- void detachInterrupt()
- Метод запрещает прерывание.
- Timer1. detachInterrupt(); // запретить прерывание от таймера 1
- unsigned long read()
- Метод позволяет считать текущее время таймера.
- void pwm(char pin, int duty, long microseconds)
Генерирует сигнал ШИМ на выводе, заданном аргументом pin. На Ардуино могут использоваться выводы 9 и 10. Скважность задается аргументом duty в диапазоне 0 … 1023.
- void setPwmDuty(char pin, int duty)
- Задает значение ШИМ на выводе.
- void disablePwm(char pin)
- Выключает режим ШИМ для вывода.
- С использованием библиотеки TimerOne программа постоянного вращения двигателя выглядит так.
// программа управления шаговым двигателем с помощью библиотеки StepMotor
// двигатель вращается постоянно против часовой стрелке со скоростью 60 об. в мин
#include
#include
StepMotor myMotor(10, 11, 12, 13); // создаем объект типа StepMotor, задаем выводы для фаз
void setup() {
Timer1.initialize(250); // инициализация таймера 1, период 250 мкс
Timer1.attachInterrupt(timerInterrupt, 250); // задаем обработчик прерываний
myMotor.setMode(0, false); // шаговый режим, без фиксации при остановке
myMotor.setDivider(83); // делитель частоты 83
}
void loop() {
myMotor.step(1000);
}
//————————————— обработчик прерывания 1 мс
void timerInterrupt() {
myMotor.control(); // управление двигателем
}
Время периода прерывания по таймеру нельзя задавать слишком маленьким, иначе программа будет заниматься только обработкой прерываний. Для Arduino UNO R3 в простых приложениях я бы ограничил его значением 100 мкс. При более сложных задачах лучше период таймера увеличить.
Если одновременно требуются прерывания с более низкой частотой, например, для регенерации светодиодных индикаторов, то его можно реализовать программными таймерами в обработчике прерывания. Надо стремиться, чтобы в системе было только одно прерывание от таймера с самой высокой частотой, а остальные формировались программными таймерами.
В нескольких последующих уроках будем использовать библиотеку StepMotor для управления как униполярными, так и биполярными шаговыми двигателями. В следующем уроке напишем программу для драйвера шагового двигателя на Ардуино и научимся управлять им от компьютера.
Предыдущий урок Список уроков Следующий урок
Загрузка...
