Как подключить шаговый двигатель к ардуино уно

Управление шаговым двигателем с Ардуины

Для реализации проекта нам необходимо установить библиотеки:

Сборка:

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

Так же на драйвере есть 4 управляющих пина, который нужно подключить соответственно к 8 Pin ,9 Pin,10 Pin,11 Pin Ардуины.

Скетч:

#include // изменить количество шагов для вашего мотора #define STEPS 4078 Stepper_28BYJ stepper(STEPS, 8, 9, 10, 11); void setup() < // установим скорость вращения 3 об/мин stepper.setSpeed(13); >void loop() < stepper.step(4000); // Делаем 4000 шагов в одну строну stepper.step(-4000);// Делаем 4000 шагов в другую строну >

Подключение шагового двигателя к Ардуино

Шаговый двигатель Arduino предназначен для точного позиционирования или перемещения объекта за определенное количество шагов вала. Плата Ардуино может управлять шаговым двигателем с помощью драйвера и библиотеки stepper.h. Рассмотрим принцип работы stepper motor, схему подключения шагового двигателя к Arduino, разберем управление шаговым двигателем 28BYJ-48 с помощью модуля UNL2003.

Необходимые компоненты:

• Arduino Uno / Arduino Nano / Arduino Mega
• шаговый двигатель 28BYJ-48
• драйвер шагового двигателя ULN2003
• коннекторы
• библиотека Stepper.h

1. Управление шаговым двигателем от Shield L293D
2. Подключение и управление мотором от Ардуино
3. Подключение модуля MOSFET IRF520N к Ардуино

Двигатель 28BYJ-48 с модулем UNL2003 — это бесщеточный синхронный двигатель. Как и все двигатели, он преобразует электрическую энергию в механическую. В отличие от двигателя постоянного тока, в котором вращается вал, вал шагового двигателя совершает дискретные движения, т.е. вращается не непрерывно, а пошагово. Каждый шаг вала (ротора) у stepper motor представляет собой часть полного оборота.

Шаговый двигатель принцип работы, устройство

шаговый мотор 28BYJ-48 характеристики

• Напряжение питания: 5В или 12В
• Число фаз: 4
• Номинальная скорость вращения: 15 оборот/мин
• Коэффициент редукции: 1/63.68395
• Количество шагов ротора: 64
• Крутящий момент: 450 г*см
• Размеры (диаметр,высота): 25×18 мм

В зависимости от конструкции используются три типа двигателей: с постоянными магнитами, с переменными магнитами и гибридные. В двигателях с постоянными магнитами количество шагов на один оборот вала достигает 48, т.е. один шаг соответствует повороту вала на 7,5°. Гибридные двигатели обеспечивают 400 шагов, подсчитав количество сделанных шагов, можно определить угол поворота ротора.

Вал двигателя вращается под действием сигнала, который управляет магнитным полем катушек статора двигателя. Сигнал генерируется драйвером шагового двигателя 28BYJ-48 (stepper motor). Магнитное поле, создаваемое электрическим током в обмотках статора, вращает вал, на котором установлены магниты. Количество шагов определяется в программе с помощью команд библиотеки Stepper.h.

Как подключить шаговый двигатель к Ардуино

Шаговый двигатель 28BYJ-48 с модулем UNL2003 управляется от Ардуино путем подачи импульсов на обмотки двигателя в определенной последовательности. Для облегчения управления шаговыми двигателями были созданы специальные библиотеки, но вращать вал двигателя можно и без библиотек. Подключите шаговый двигатель к микроконтроллеру, как показано на схеме выше, и загрузите следующую программу в плату.

Скетч управление шаговым двигателем Ардуино

#define in1 8 #define in2 9 #define in3 10 #define in4 11 // пауза между шагами, минимум 10 мс int dl = 20; void setup() < pinMode(in1, OUTPUT); pinMode(in2, OUTPUT); pinMode(in3, OUTPUT); pinMode(in4, OUTPUT); >void loop()

Библиотека Stepper.h для шагового двигателя

Рассмотрим управление шаговыми двигателями с помощью стандартной библиотеки Stepper.h, в которой реализовано множество дополнительных команд и функций. Схема подключения двигателя остается прежней. Основные характеристики двигателя 28BYJ-48: питание 5 или 12 вольт, 4-фазный двигатель, угол шага 5,625°. Порты драйвера IN1 — IN4 подключаются к любому цифровому выводу микроконтроллера Arduino.

Скетч управление 28BYJ-48 stepper motor Ардуино

#include «Stepper.h» const int stepsPerRevolution = 200; Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11); void setup() < myStepper.setSpeed(60); >void loop()

Команды библиотеки Stepper.h Arduino

AccelStepper mystepper(DRIVER, step, direction); // Шаговый двигатель, управляемый платой
AccelStepper mystepper(FULL2WIRE, pinA, pinB); // Шаговый двигатель с Н-мостом
AccelStepper mystepper(FULL4WIRE, pinA1, pinA2, pinB1, pinB2); // Униполярный двигатель

mystepper.setMaxSpeed(stepsPerSecond); // Установка скорости оборотов в минуту
mystepper.setSpeed(stepsPerSecond); // Установка скорости в шагах за секунду
mystepper.setAcceleration(stepsPerSecondSquared); // Установка ускорения

mystepper.currentPosition(); // Возвращает текущее положение в шагах
mystepper.setCurrentPosition (long position); // Обнуляет текущую позицию до нуля
mystepper.targetPosition(); // Конечное положение в шагах
mystepper.distanceToGo(); // Вернуть расстояние до указанного положения
mystepper.moveTo(long absolute); // Переместиться в абсолютно указанное положение
mystepper.move(long relative); // Переместиться в относительно указанное положение

mystepper.run(); // Начать движение с ускорением, функцию следует вызывать повторно
mystepper.runToPosition(); // Начать движение до указанной точки
mystepper.runToNewPosition(); // Начать движение с ускорением до заданной позиции
mystepper.stop(); // Максимально быстрая остановка (без замедления)
mystepper.runSpeed(); // Начать движение с заданной скоростью без ускорения
mystepper.runSpeedToPosition(); // Начать движение без ускорения, до позиции

mystepper.disableOutputs(); // Деактивирует зарезервированные пины и устанавливает их в режим LOW. Снимает напряжение с обмоток двигателя, экономя энергию
mystepper.enableOutputs(); // Активирует зарезервированные пины и устанавливает их в режим OUTPUT. Вызывается автоматически при запуске двигателя

Заключение. Шаговый двигатель является идеальным приводом в 3D-принтерах, станках с ЧПУ и другом оборудовании. Соединение между модулем контроллера и двигателем 28BYJ-48 является простым, поскольку имеется разъем, который служит для направления соединения между устройствами. Модуль UNL2003 Arduino имеет четыре диода, которые показывают, какая катушка у stepper motor активна в каждый момент времени.

FAQ (часто задаваемые вопросы)

Какая используется библиотека для 28BYJ-48 ?

Для шагового двигателя 28BYJ-48 с модулем UNL2003 используется библиотека Stepper.h, ссылка на скачивание архива с библиотекой размещена в начале статьи.

Ошибка fatal error Stepper.h No such file or directory ?

Если при компиляции скетча появляется ошибка «Stepper.h No such file or directory», то это значит, что отсутствует библиотека Stepper.h в Arduino IDE. Следует скачать и установить библиотеку для двигателя, которая используется в программе.

Почему шаговый двигатель греется в состоянии покоя ?

При выключении двигателя с помощью команды mystepper.stop(); не все катушки двигателя отключаются от питания (на модуле UNL2003 будут гореть диоды). При остановке включается режим удержания положения ротора — это штатный режим работы библиотеки, но при этом шаговый двигатель будет греться и тратить энергию. Чтобы полностью отключить питание, следует перевести все пины Ардуино в режим LOW.

Подключение шагового двигателя к Arduino Uno

Шаговые двигатели с каждым годом находят все большее применение в мире электроники. Начиная от обычной камеры наблюдения до сложных станков с ЧПУ и роботов шаговые двигатели используются в качестве исполнительных механизмов, поскольку они обеспечивают точное управление. В этом проекте мы рассмотрим один из наиболее распространенных шаговых двигателей 28BYJ-48 и его подключение к плате Arduino с помощью модуля ULN2003.

Общие принципы работы шаговых двигателей

Внешний вид шагового двигателя 28BYJ-48 представлен на следующем рисунке:

Первый вопрос, который напрашивается при взгляде на этот рисунок – почему в отличие от обычного двигателя из этого шагового двигателя выходят 5 проводов различных цветов? Чтобы понять это давайте сначала разберемся с принципами работы шагового двигателя.

Начнем с того, что шаговые двигатели не вращаются, а “шагают”, поэтому они и называются шаговыми двигателями. То есть в один момент времени они будут передвигаться только на один шаг. Чтобы добиться этого в устройстве шаговых двигателей присутствует несколько катушек и на эти катушки нужно подавать питание в определенной последовательности чтобы двигатель вращался (шагал). При подаче питания на каждую катушку двигатель делает один шаг, при последовательной подаче питания на катушки двигатель будет совершать непрерывные шаги, то есть вращаться. Давайте более подробно рассмотрим катушки, присутствующие внутри шагового двигателя.

Как можно видеть из рисунка, двигатель имеет однополярную катушку с 5 выводами. Но фактически это 4 катушки, на которые нужно подавать питание в определенной последовательности. На красные провода необходимо подать +5V, на остальные 4 провода необходимо подать землю чтобы запустить в работу соответствующую катушку. Мы будем использовать плату Arduino чтобы подавать питание на эти катушки в определенной последовательности и тем самым заставлять двигатель вращаться. Более подробно ознакомиться с принципами работы шаговых двигателей можно в статье про подключение шагового двигателя к микроконтроллеру AVR.

Так почему же этот двигатель называется 28BYJ-48? Честно говоря, мы не знаем точного ответа на этот вопрос. Некоторые наиболее важные технические характеристики этого шагового двигателя приведены на следующем рисунке.

На первый взгляд от такого количества характеристик может закружиться голова, но давайте попробуем выделить из них самые важные, те, которые нам понадобятся для дальнейшей работы. Во-первых, мы знаем, что это шаговый двигатель 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). В сети интернет можно найти рейтинги эффективности различных драйверов мотора, но эти рейтинги будут меняться в зависимости от типа используемого шагового двигателя. Основной принцип, которого следует придерживаться при выборе драйвера мотора – он должен обеспечивать достаточный ток для управления шаговым двигателем.

Работа схемы

Схема подключения шагового двигателя к плате Arduino представлена на следующем рисунке.

Мы использовали шаговый двигатель 28BYJ-48 и драйвер мотора ULN2003. Для подачи питания на 4 катушки шагового двигателя мы будем использовать контакты платы Arduino 8, 9, 10 и 11. Драйвер мотора запитывается от контакта 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) – специально упорядочена таким образом чтобы подавать питание на катушки шагового двигателя в правильном порядке. Если вы измените номера контактов, к которым подключен шаговый двигатель, то вы соответствующим образом должны их упорядочить для подачи в приведенную команду.

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

Для двигателя 28-BYJ48 скорость вращения можно установить в диапазоне от 0 до 200.

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

Количество шагов, которое должен сделать двигатель, определяется переменной “ val ”. Поскольку мы имеем 32 шага (для оборота) и передаточное число 64 мы должны сделать 2048 (32*64=2048) “шагов” в этой команде для совершения одного полного оборота двигателя.

Значение переменной “val” в нашей программе мы будем вводить из окна монитора последовательной связи.

Работа проекта

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

Теперь загрузите код программы в плату Arduino UNO и откройте окно монитора последовательной связи (serial monitor). Как мы уже указывали, мы должны сделать 2048 шагов для совершения одного полного оборота, то есть если мы в окне монитора последовательной связи введем 2048, то вал шагового двигателя совершит один полный оборот по часовой стрелке, а сам двигатель в это время сделает 2048 шагов. Для вращения против часовой стрелки просто вводите нужное число шагов со знаком “–“. То есть если вы введете -1024, то вал мотора совершит пол-оборота против часовой стрелки. Чтобы протестировать работу проекта вы можете вводить любые числа.

Исходный код программы

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

#include // заголовочный файл библиотеки для работы с шаговыми двигателями
// измените необходимое число шагов в зависимости от модели вашего шагового двигателя
#define STEPS 32
// создайте класс для шагового двигателя и запишите для него правильную последовательность контактов
Stepper stepper(STEPS, 8, 10, 9, 11);
int val = 0;
void setup() <
Serial.begin(9600);
stepper.setSpeed(200);
>
void loop() <
if (Serial.available()>0)
<
val = Serial.parseInt();
stepper.step(val);
Serial.println(val); //for debugging
>
>

Управление шаговым двигателем NEMA17 с помощью Arduino

Биполярный шаговый двигатель используется в роботизированных механизмах, таких как 3D-принтеры, станки с ЧПУ, игрушки и так далее. Особенностью шагового двигателя является дискретное вращение. То есть, при подаче на обмотку двигателя импульса совершается небольшой поворот ротора. Шаговый двигатель износостойкий, потому что не имеет в своей конструкции щёток, которые соприкасаются с ротором. Биполярный двигатель имеет по одной обмотке для каждой фазы движения магнитного ротора.

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

Рис. 2 Драйвер шагового двигателя A4988 на плате расширения

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

В нашем проекте используются:

1. Шаговый двигатель NEMA17
2. Драйвер шагового двигателя A4988
3. Плата расширения для драйверов шаговых двигателей A4988/DRV8825
4. Микроконтроллер Arduino UNO R3
5. Тактовая кнопка на модуле KY-004

Подключение шагового двигателя к микроконтроллеру

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

Рис. 3 Подключённые устройства

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

• S – step – шаг,
• D – direction – направление,
• E – enable – включить-выключить двигатель (подача питания на его обмотки).

Так же на плате есть пины питания:

• 5В – напряжение питания логики,
• 9В – напряжение питания двигателя,
• GND – земля.

Не забудьте правильно подключить питание 5В и 9В платы расширения. Основное питание схемы происходит через штатный разъем Arduino блоком питания 9В с током не менее 1А. Ни в коем случае не запитывайте схему только от USB-разъема, т.к. это может привести к выходу контроллера из строя. Далее питание драйвера и двигателя производится с контроллера. 5В с пина на Arduino UNO, земля GND также подключается к микроконтроллеру к соответствующему пину. 9В подключаются к разъёму на контроллере, который обозначается как VIN. Управляющие пины платы расширения S, D, E в нашем проекте мы подключаем к цифровым пинам микроконтроллера D2, D3, D4. Проверьте подключение, сверившись с таблицей ниже.

Рис. 4 Таблица подключения платы расширения драйвера двигателя к Arduino UNO

Справка:

Двигатель NEMA17 сконструирован таким образом, что совершает 200 шагов за оборот в стандартном полношаговом режиме. Каждый шаг поворачивает ротор на 1,8 градуса.

Для обеспечения работы двигателя в разных режимах на плате расширения есть переключатели. Разное положение переключателей задаёт разный режим работы. Это удобно при решении некоторых задач. Режимы работы смотрите в таблице ниже:

Рис. 5 Режимы работы шагового двигателя в соответствии с расположением переключателей на плате расширения.

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

Примечание: Изменяя режим работы шагового двигателя можно менять скорость вращения и количество оборотов.

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

Кнопку подключаем двумя проводами. К шестому пину D6 на плате микроконтроллера подключаем управляющий разъем кнопки, обозначенный буквой S. Контакт, обозначенный «-» мы подключаем к GND на плате микроконтроллера.

Питание микроконтроллера производится от блока питания 9В.

Далее подключаем микроконтроллер к компьютеру и переходим к его программированию.

Разбор скетча управления шаговым двигателем

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

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

//Пины управления шаговиком

#define STEP_PIN 2 #define DIR_PIN 3 #define ENABLE_PIN 4 //Пин кнопки #define start_button 6

Далее необходимо определить переменные для управления временем поворота и паузы, то есть задержки между импульсами. Задержка считается в микросекундах (1000 мксек = 1 мсек = 0.001 сек.). Обратите внимание, что, чем больше задержка между импульсами, тем медленнее вращается двигатель. И ещё один важный момент, не рекомендуется устанавливать время меньше 100 мксек.

В этой части кода можно настроить время поворота и паузы.

#define move_forward_time 3000 //время прямого хода в мсек #define move_back_time 3000 //время обратного хода в мсек #define pause_time 4000 //время паузы в мсек #define frequency 2250 //Время между импульсами в мксек.

Определяем переменную для хранения времени.

//Таймер для millis() uint32_t timer = 0;

Необходимо определить переменную для рабочего режима, чтобы программа понимала, когда двигатель включён, а когда нет, то есть эта переменная будет менять своё значение в зависимости от нажатия кнопки. Обратите внимание, что переменная может иметь всего два значения – один и ноль.

//Логический флаг для рабочего режима bool flag = 0;

После определения переменных необходимо настроить микроконтроллер для работы.

В разделе setup производится первичная настройка:

void setup()  pinMode(start_button, INPUT_PULLUP); //Подтягиваем кнопку к питанию pinMode(STEP_PIN , OUTPUT); //Настраиваем пины управления pinMode(DIR_PIN , OUTPUT); pinMode(ENABLE_PIN , OUTPUT); digitalWrite(ENABLE_PIN , HIGH); //Выключаем мотор, чтобы не грелся >

Здесь мы задаём режим работы пинов, к которым мы подключили кнопку и плату расширения драйвера двигателя. Обратите внимание на последнюю строчку кода, данной командой мы выключаем двигатель. Шаговик будет выключен тогда, когда мы подаём напряжение на Pin ENABLE. В противном случае мотор будет греться.

Далее в программе следует основной цикл loop, где происходит вся обработка событий. Напомню, что смысл нашей задачи сводится к тому, чтобы при нажатии на кнопку двигатель совершил вращение. Поэтому первым условием в основном цикле будет проверка нажата ли кнопка. Соответственно, если кнопка нажата, то переменная flag становится равна единице. Это будет означать, что у нас рабочий режим. В этом же условии мы включаем мотор и запускаем таймер присваивая переменной timer значение функции millis().

void loop ()  if (!digitalRead(start_button))  //Если нажали на кнопку digitalWrite(ENABLE_PIN , LOW); //Включаем мотор flag = 1; //Активируем флаг рабочего режима timer = millis(); //Запускаем таймер >

Управление по времени при нажатии на кнопку

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

Эти параметры мы настроили в самом начале программы:

• move_forward_time 3000 время прямого хода в мсек по часовой стрелке.
• define move_back_time 3000 время обратного хода в мсек против часовой стрелки.
• define pause_time 4000 время паузы в мсек.
• define frequency 2250 Время между импульсами в мксек.

Эти параметры можно менять в зависимости от условия задачи.

Далее будет следующий цикл:

if (flag)  //Если флаг активирован digitalWrite(DIR_PIN , HIGH); //Задаем направление вращения

Если мы нажали на кнопку и у нас включился рабочий режим, то есть переменная flag равна единице, то сначала задаём направление вращения двигателю подавая на управляющий Pin DIR напряжение.

Далее в цикле будем использовать ещё один цикл do while, условие которого проверяется в конце цикла.

do  //Крутим движок move_forward_time мсек digitalWrite(STEP_PIN , HIGH); delayMicroseconds(frequency); digitalWrite(STEP_PIN , LOW); > while (millis() - timer  move_forward_time);

Задача этого цикла заставить двигатель вращаться три секунды по часовой стрелке. Мы попеременно подаём и отключаем напряжение на управляющем Pin STEP с задержкой frequency = 2250 микросекунд. Это примерно соответствует 10 оборотам в минуту для двигателя NEMA17, который мы используем в проекте. Чем меньше частота задержки, тем быстрее будет вращаться двигатель. Цикл будет работать до тех пор, пока заданное время в переменной move_forward_time будет больше величины millis() – timer. Такая формула применяется по причине того, что функция millis() уже запущена и в момент нажатия кнопки мы фиксируем её значение записывая в переменную timer. Именно от этого значения нам нужно отсчитать время три секунды. Таким образом функция millis() всё время увеличивает своё значение, а timer остаётся постоянной. Когда разница между millis() – timer составит три секунды, условие сработает и цикл завершится.

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

delay(pause_time); //Пауза pause_time мсек timer = millis(); //Снова запускаем таймер digitalWrite(DIR_PIN , LOW); //Крутим движок move_back_time мсек

Пауза у нас задавалась переменной pause_time. Для паузы используем функцию delay. Далее снова фиксируем новое значение функции millis() в момент начала следующего цикла. Теперь нам необходимо поменять направление вращения двигателя подавая на управляющий Pin DIR сигнал LOW – это будет соответствовать вращению двигателя против часовой стрелки.

do  digitalWrite(STEP_PIN , HIGH); delayMicroseconds(frequency); digitalWrite(STEP_PIN , LOW); > while (millis() - timer  move_back_time); flag = 0; //Гасим флаг digitalWrite(ENABLE_PIN , HIGH); //Выключаем движок, чтобы не грелся > >

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

Поздравляем! Вы научились управлять шаговым двигателем задавая ему параметры времени и направление вращения.

Управление по числу шагов

А теперь научимся управлять двигателем с заданным количеством шагов. Для этого поменяем основный цикл программы на такой:

void loop ()  if (!digitalRead(start_button))  //Если нажали на кнопку digitalWrite(ENABLE_PIN , LOW); //Включаем мотор flag = 1; //Активируем флаг рабочего режима timer = millis(); //Запускаем таймер > if (flag)  //Если флаг активирован digitalWrite(DIR_PIN , HIGH); //Задаем направление вращения for (int i = 0; i  200; i++)  //Выполняем нужное число шагов 200*16 = 3200 шагов оборот digitalWrite(STEP_PIN , HIGH); delayMicroseconds(frequency); digitalWrite(STEP_PIN , LOW); > flag = 0; > >

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

if (flag)  //Если флаг активирован digitalWrite(DIR_PIN , HIGH); //Задаем направление вращения

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

 for (int i = 0; i  3200; i++)  

Цикл for будет выполняться до тех пор, пока переменная i будет меньше 3200. Откуда взялась цифра 3200 и что она означает? Наш двигатель работает с расчётом, что один шаг равен 1,8 градуса. Соответственно полный оборот двигателя (360 градусов) будет совершён за 200 шагов. Поскольку мы переключили режим работы двигателя в микрошаговый режим, а это 1/16 шага, то, соответственно, умножаем 200 шагов на 16 и получаем 3200 шагов за оборот. Таким образом нижеследующий код, который попеременно подаёт и отключает напряжение на управляющем Pin STEP с задержкой frequency = 2250 микросекунд, будет выполнен 3200 раз и цикл for завершится, а двигатель совершит один оборот.

digitalWrite(STEP_PIN , HIGH); delayMicroseconds(frequency); digitalWrite(STEP_PIN , LOW); >

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

flag = 0; > 

Теперь вы научились управлять шаговым двигателем задавая количество шагов!

Для работы данного скетча не нужно устанавливать дополнительных библиотек. Скетч вы можете скачать по этой ссылке.