Драйвер шагового двигателя для ардуино

Содержание

Если вы планируете создать свой собственный 3D-принтер или станок с ЧПУ, вам нужно будет управлять несколькими шаговыми двигателями. Если использовать для этого только Arduino, то большая часть скетча будет занята кодом управления шаговыми двигателями и не останется много места для чего-то еще.

Данную проблему можно решить, использовав специальный автономный драйвер шагового двигателя — A4988.

Модуль A4988 может контролировать как скорость, так и направление вращения биполярного шагового двигателя, такого как NEMA 17, использую всего два вывода контроллера.

Последовательность импульсов определяет направление вращения двигателя.
Частота импульсов определяет скорость двигателя.
Количество импульсов определяет угол поворота.

Микросхема драйвера шагового двигателя A4988

Модуль собран на чипе A4988. Не смотря на свой малый размер (всего 0,8 ″ × 0,6 ″), но обладает хорошими характеристиками.

Драйвер шагового двигателя A4988 имеет высокую выходную мощность (до 35 В и 2 А) и позволяет управлять одним биполярным шаговым двигателем с выходным током до 2 А на катушку, например NEMA 17.

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

Драйвер предлагает 5 различных разрешений шага, а именно:

полный шаг
1/2 шага
1/4 шага
1/8 шага
1/16 шага

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

Плата Arduino Uno (купить на Aliexpress).
Драйвер шагового двигателя A4988 (купить на Aliexpress).
Шаговый двигатель.

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

Драйвер двигателя A4988 позволяет управлять на выходе напряжениями до 35V и токами до ±2A. Это позволяет управлять биполярными шаговыми двигателями такими, к примеру, как NEMA 17, с выходным током до 2А на катушку. На следующем видео показан принцип работы шагового двигателя.

Распиновка драйвера A4988

Драйвер шагового двигателя A4988 содержит 16 контактов, его распиновка показана на следующем рисунке.

VDD – контакт для подачи питания на модуль драйвера. От него запитывается внутренняя схема модуля. Можно использовать источник питания от 3.3V до 5.5V.

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

GND – контакт общего провода (земли) драйвера. Его необходимо подключить к контакту общего провода платы Arduino. Таких контакта у драйвера два – 9 и 16.

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

MS1, MS2, MS3 – контакты выбора разрешения микрошагов. С их помощью мы можем выбрать один из пяти режимов, представленных на следующем рисунке.

На контакты MS1, MS2, MS3 с помощью внутренних подтягивающих резисторов модуля подается уровень LOW, поэтому если вы оставите их неподключенными, то двигатель будет работать в режиме полного шага (full step).

STEP – управление микрошагами каждого подключенного двигателя. Каждый импульс с уровнем HIGH, подаваемый на данный контакт, будет поворачивать ось двигателя на число микрошагов, определяемое контактами выбора разрешения микрошагов (MS1, MS2, MS3). Чем выше будет частота импульсов, тем быстрее будет вращаться ось двигателя.

DIR – с помощью этого контакта происходит управление направлением вращения двигателя. Если на него подать HIGH, то двигатель будет вращаться по часовой стрелке, если LOW – то против часовой стрелки.

EN – контакт управления доступностью модуля драйвера. Если на нем LOW, то драйвер двигателя A4988 доступен (enabled). По умолчанию на этом контакте присутствует уровень LOW, поэтому драйвер модуля будет доступен (в активном состоянии) до тех пор пока вы не подадите на него HIGH. Данный контакт полезен, к примеру, когда необходимо экстренно остановить двигатель.

SLP – контакт управления спящим режимом модуля. Если на нем LOW, то модуль переходит в спящий режим, тем самым уменьшая до минимума потребление электроэнергии. Этот режим можно использовать для уменьшения потребления энергии вашим устройством.

RST – контакт сброса модуля драйвера. Когда на нем LOW, все входы STEP игнорируются. Также это приводит к сбросу модуля драйвера, устанавливая его внутренний преобразователь (translator) в значение по умолчанию “home” – это начальное состояние, с которого начинает вращение двигатель, и оно зависит от установленного разрешения по микрошагам (microstep resolution).

1B, 1A, 2A, 2B – выходные контакты драйвера двигателя A4988. Каждый из этих контактов выдерживает ток до 2 А, что позволяет подключать к ним электродвигатели средних размеров, например, NEMA 17.

Компоненты драйвера двигателя A4988

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

Как вы видите из представленного рисунка, его основным компонентом является контроллер шагового двигателя A4988.

Наиболее часто задаваемые вопросы про драйвер двигателя A4988

Какова спецификация драйвера двигателя A4988?
A4988 представляет собой законченный модуль управления двигателем с возможностью управления по микрошагам и встроенным преобразователем (транслятором). Он предназначен для управления биполярными шаговыми двигателями в режимах полного шага, 1/2, 1/4, 1/8 и 1/16 шага с поддержкой выходного напряжения до 35 V и выходного тока до 2 A.

Какие основные отличия между драйверами A4988 and DRV8825?
Драйвер DRV8825 обеспечивает более высокое напряжение на своих выходах (45V против 35V), что означает более безопасное использование DRV8825 при более высоких напряжениях и меньшую чувствительность к возможным выбросам напряжения. Более подробно про отличия между этими драйверами вы можете прочитать в этой статье.

Какие ограничения по току (лимит) у A4988?
Микросхема драйвера двигателя A4988 выдерживает максимальный ток до 2 A на каждую обмотку, но данное значение максимального выдерживаемого тока будет зависеть от того, насколько хорошо вы охлаждаете микросхему драйвера.

Почему драйверу A4988 необходим конденсатор?
Данный конденсатор защищает модуль драйвера от возможных выбросов напряжения и обеспечивает более стабильную подачу питания на модуль.

Схема драйвера двигателя A4988

Схема драйвера A4988 показана на следующем рисунке. Как вы можете видеть, она достаточно проста. Более подробно про ее функционирование вы можете прочитать в даташите на драйвер.

Схема проекта

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

Запитывать схему мы будем от лабораторного источника питания.

Распиновка драйвера A4988

Драйвер A4988 имеет всего 16 контактов, которые связывают его с внешним миром. Распиновка у A4988 следующая:

Давайте ознакомимся со всеми контактами по очереди.

Выводы питания

На самом деле A4988 требует подключения двух источников питания.

VDD и GND используется для управления внутренней логической схемой. Напряжение питания должно находиться в пределах от 3 до 5,5 В.

Vmot и GND для обеспечения питания шагового двигателя. Тут напряжение в пределах от 8 до 35 В.

Согласно datasheet, для питания двигателя требуется соответствующий разделительный конденсатор рядом с платой, способный выдерживать ток 4 А.

Предупреждение:
Этот драйвер имеет на плате керамические конденсаторы с низким ESR , что делает его уязвимым для скачков напряжения. В некоторых случаях эти выбросы могут превышать 35 В (максимальное номинальное напряжение A4988), и это может потенциально необратимо повредить плату и даже двигатель.
Один из способов защитить драйвер от таких скачков — подключить электролитический конденсатор емкостью 100 мкФ (или как минимум 47 мкФ) к контактам источника питания двигателя.

Выводы выбора микрошага

Драйвер A4988 допускает использование режима микрошага. Это достигается за счет подачи питания на катушки с промежуточными уровнями тока.

Например, если вы решите управлять шаговым двигателем NEMA 17 с шагом 1,8 градуса (200 шагов на оборот) в режиме 1/4 шага, то двигатель будет выдавать 800 микрошагов на оборот.

Драйвер A4988 имеет три вывода селектора размера шага (разрешения), а именно: MS1, MS2 и MS3. Установив соответствующие логические уровни на эти контакты, мы можем настроить двигатели на одно из пяти ступенчатых разрешений.

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

Выводы управления

Драйвер A4988 имеет два управляющих входа, а именно: STEP и DIR.

STEP — управляет микрошагом мотора. Каждый высокий импульс, отправляемый на этот вывод, приводит двигатель в действие на количество микрошагов, заданное выводами Microstep Selection (MS1, MS2 и MS3). Чем быстрее импульсы, тем быстрее будет вращаться двигатель.

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

Если вы просто хотите, чтобы двигатель вращался только в одном направлении, то вы можете соединить вывод DIR непосредственно с VCC или GND соответственно.

Выводы STEP и DIR не подтянуты внутренними резисторами, поэтому вы не должны оставлять их не подключенными.

Выводы управления питанием A4988

A4988 имеет три различных вывода для управления состоянием питания, а именно. EN, RST и SLP.

EN — вывод включения (0)/ выключения (1) драйвера A4988. По умолчанию на этом выводе установлен низкий уровень, поэтому драйвер всегда включен.

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

RST — при подаче сигнала низкого уровня все входные данные STEP игнорируются, до тех пор пока не будет установлен высокий уровень. Низкий уровень также сбрасывает драйвер, устанавливая внутренний транслятор в предопределенное состояние Home. Исходное состояние — это в основном начальное положение, с которого запускается двигатель, и оно различается в зависимости от разрешения микрошага.

Если вам не нужно использовать вывод RST, вы можете подключить его к соседнему контакту SLP / SLEEP, чтобы вывести его на высокий уровень и включить драйвер.

Выводы для подключения шагового двигателя

Выходные контакты: 1B, 1A, 2A и 2B.

К этим выводам можно подключить любой биполярный шаговый двигатель с напряжением питания от 8 до 35 В.

Каждый выходной контакт модуля может обеспечить ток до 2 А. Однако величина тока, подаваемого на двигатель, зависит от источника питания системы, системы охлаждения и настройки ограничения тока.

Система охлаждения — радиатор

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

Даже если микросхема драйвера A4988 имеет максимальный номинальный ток 2 А на катушку, микросхема может подавать только около 1 А на катушку без перегрева.

Для достижения более 1 А на катушку требуется радиатор или другой метод охлаждения.

Драйвер A4988 обычно поставляется с радиатором. Желательно установить его перед использованием драйвера.

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

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

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

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

#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().

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

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

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

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; >

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

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

Подключение драйвера шагового двигателя A4988 и DRV8825 с помощью модуля.

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

Внимание! При установке драйвера на модуль будьте осторожны.Драйвер может сгореть, если не правильно установить его на модуль.

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

Код для Arduino и A4988 (DRV8825),который позволяет вращать шаговым двигателем без библиотеки.

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

const int dirPin = 2; const int stepPin = 3; const int stepsPerRevolution = 200; void setup() < pinMode(stepPin, OUTPUT); pinMode(dirPin, OUTPUT); >void loop() < digitalWrite(dirPin, HIGH); // Установка вращения по часовой стрелки for(int x = 0; x >stepsPerRevolution; x++) < digitalWrite(stepPin, HIGH); delayMicroseconds(2000); digitalWrite(stepPin, LOW); delayMicroseconds(2000); >delay(1000); digitalWrite(dirPin, LOW); // Установка вращения против часовой стрелки for(int x = 0; x < stepsPerRevolution; x++) < digitalWrite(stepPin, HIGH); delayMicroseconds(1000); digitalWrite(stepPin, LOW); delayMicroseconds(1000); >delay(1000); >

Пояснение к коду:

Скетч начинается с определения выводов Arduino, к которым подключены выводы STEP и DIR драйвера A4988. Здесь также определяем stepsPerRevolution – количество шагов на оборот. Установите данное значение в соответствии со спецификациями шагового двигателя 200 (поскольку NEMA 17 делает 200 шагов за оборот).

const int dirPin = 2; const int stepPin = 3; const int stepsPerRevolution = 200;

В разделе настройки кода setup(), все контакты управления двигателем объявлены как цифровой выход ( OUTPUT ).

pinMode(stepPin, OUTPUT); pinMode(dirPin, OUTPUT);

В основном цикле loop() будем медленно вращать двигатель по часовой стрелке, а затем быстро вращать его против часовой стрелки, с интервалом в секунду.

Управление направлением вращения.

Для управления направлением вращения двигателя мы устанавливаем контакт DIR на высокий уровень HIGH, или низкий LOW. При значении HIGH — вращает двигатель по часовой стрелке, а LOW — против часовой стрелки.

digitalWrite(dirPin, HIGH);

Управление скоростью шагового двигателя.

Скорость двигателя определяется частотой импульсов, которые мы посылаем на вывод STEP . Чем чаше импульсы, тем быстрее работает двигатель. Импульсы — это не что иное, как подтягивание выхода к высокому уровню HIGH , некоторое ожидание, затем подтягивание его к низкому уровню LOW и снова ожидание. Изменяя задержку между двумя импульсами, вы изменяете частоту импульсов и следовательно, скорость вращения двигателя.

for(int x = 0; x

Код для Arduino управления драйвером A4988 (DRV8825)с использованием библиотеки AccelStepper.

Управление шаговым двигателем без библиотеки идеально подходит для простых проектов на Arduino с одним двигателем. Но если вы хотите управлять несколькими шаговыми двигателями, вам понадобится библиотека. Итак, для нашего следующего примера будем использовать библиотеку шаговых двигателей под названием AccelStepper library.

AccelStepper library поддерживает.

Ускорение и замедление. Несколько одновременных шаговых двигателей с независимыми одновременными шагами на каждом шаговом двигателе. Эта библиотека не включена в IDE Arduino, поэтому вам необходимо сначала установить ее.

Установка библиотеки AccelStepper.

Чтобы установить библиотеку, перейдите в «Скетч» -> «Подключить библиотеку» -> «Управление» библиотеками. Подождите, пока диспетчер библиотек загрузит индекс библиотек и обновит список установленных библиотек.

Отфильтруйте свой поиск, набрав «Accelstepper». Щелкните первую запись и выберите «Установка».

Код Arduino с использованием библиотеки AccelStepper.

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

// Подключаем библиотеку AccelStepper #include // Устанавливаем выводы const int dirPin = 2; const int stepPin = 3; int i = 0; // Определение тип интерфейса двигателя #define motorInterfaceType 1 // Создаем экземпляр AccelStepper myStepper(motorInterfaceType, stepPin, dirPin); void setup() < // Устанавливаем максимальную скорость, коэффициент ускорения, // начальную скорость и целевую позицию myStepper.setMaxSpeed(1000); myStepper.setAcceleration(50); myStepper.setSpeed(200); myStepper.moveTo(100); >void loop() < // Изменение направления вращения, когда двигатель достигнет заданного положения if (myStepper.distanceToGo() == 0) < myStepper.moveTo(-myStepper.currentPosition()); >// Передвинуть на 1 шаг myStepper.run(); >

Пояснение к коду:

Подключаем библиотеку AccelStepper.

#include

Дальше определяем выводы Arduino, к которым подключаются выводы STEP и DIR A4988. Мы также устанавливаем motorInterfaceType на 1. (1 означает внешний шаговый драйвер с выводами Step и Direction).

const int dirPin = 2; const int stepPin = 3; int i = 0; // Определение тип интерфейса двигателя #define motorInterfaceType 1

Затем мы создаем экземпляр библиотеки под названием myStepper .

// Создаем экземпляр AccelStepper myStepper(motorInterfaceType, stepPin, dirPin);

В функции настройки мы сначала устанавливаем максимальную скорость двигателя равной тысяче. Затем мы устанавливаем коэффициент ускорения для двигателя, чтобы добавить ускорение и замедление к движениям шагового двигателя. Дальше устанавливаем обычную скорость 200 и количество шагов, которое мы собираемся переместить, например, 200 (поскольку NEMA 17 делает 200 шагов за оборот).

void setup()

В основном цикле loop() используем оператор if , чтобы проверить, как далеко двигателю нужно проехать (путем чтения свойства distanceToGo ), пока он не достигнет целевой позиции (установленной moveTo ). Как только distanceToGo достигнет нуля, поменяем направление вращения двигателя в противоположном направлении, изменив значение moveTo на отрицательное по отношению к его текущему значению. Теперь вы заметите, что в конце цикла мы вызвали функцию run () . Это самая важная функция, потому что шаговый двигатель не будет работать, пока эта функция не будет выполнена.

void loop()

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

Мы рады объявить о нашем присутствии на Boosty! Arduino-Tex приглашает всех наших друзей и последователей поддержать нас на этой замечательной платформе. Здесь вы найдете эксклюзивный контент, уникальные проекты и возможность стать частью нашей творческой команды. Присоединяйтесь к нам на Boosty и вместе мы сделаем мир Arduino еще удивительнее!

Понравился Урок 2. Как подключить A4988 (DRV8825) к Arduino? Скетч, библиотека? Не забудь поделиться с друзьями в соц. сетях.

А также подписаться на наш канал на YouTube, вступить в группу Вконтакте, в группу на Facebook.

Спасибо за внимание!

Технологии начинаются с простого!

Общие сведения

Драйвер шагового двигателя A4988 — предназначен для управления биполярными шаговыми двигателями, работающими от напряжения 8 — 35 В и потребляющими до 2 А на каждую обмотку двигателя. Драйвер построен на базе одноимённого чипа A4988 производства Allegro, он получил широкое распространение (в роботостроении, станках ЧПУ, 3D принтерах и т.д) благодаря простоте подключения и широкому функционалу.

С принципом работы шаговых двигателей можно ознакомиться в разделе Wiki — Шаговые двигатели .

Характеристики

Напряжение питания двигателя: 8 . 35 В.
Максимальный ток на одну обмотку двигателя: 1 А без радиатора, (2 А с радиатором)*.
Напряжение питания логической части драйвера: 3 . 5,5 В.
Размер одного шага двигателя: от 1 до 1/16 полного шага.
Защита: от перегрева, от перегрузки по току, от короткого замыкания, от пониженного питания.
Габариты платы драйвера: 20×15 мм.
Габариты радиатора: 9x5x9 мм.

Для удобства подключения к Arduino воспользуйтесь Trema Shield, Trema Power Shield, Motor Shield или Trema Set Shield.

Назначение выводов драйвера

«ENABLE» — Разрешение работы чипа («0» — разрешить работу, «1» — выключить чип).
«MS1» . «MS3» — Выбор размера шага (устанавливает кратность угла поворота двигателя за 1 шаг).
«RESET» — Перезагрузка логики чипа («0» — перезагрузить, «1» — обычный режим работы).
«SLEEP» — Перевод чипа в спящий режим («0» — сон, «1» — обычный режим работы).
«STEP» — Вход тактовых импульсов (за один импульс двигатель поворачивается на один шаг).
«DIR» — Выбор направления вращения двигателя («0» — в одну сторону, «1» — в другую сторону).
«VMOT» — Питание двигателя (8 . 35 В).
«VLOG» — Питание логики чипа (3 . 5,5 В).
«1A», «1B» — Подключение первой обмотки двигателя.
«2A», «2B» — Подключение второй обмотки двигателя.

На шине питания двигателя (между выводами VMOT и GND) рекомендуется установить электролитический конденсатор, как можно ближе к плате драйвера. Ёмкость конденсатора должна быть не ниже 1000 мкФ, а его рабочее напряжение должно превышать напряжение в шине питания двигателя минимум на 25%.

Двигатель подключается следующим образом: провода первой обмотки подключаются к выводам 1A, 1B драйвера, провода второй обмотки подключаются к выводам 2A, 2B драйвера. Если вы перепутаете обмотки двигателя (1, 2) или перепутаете начало и конец обмотки (A, B) то двигатель всё равно будет работать. Если двигатель будет вращаться в другую сторону, то поменяйте местами начало и конец (A и B) одной из обмоток (1 или 2).

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

Почему на схеме соединены выводы «RESET» и «SLEEP» драйвера? Дело в том, что вход «SLEEP» драйвера A4988 внутрисхемно подтянут к уровню логической «1» (спящий режим отключён), а вход «RESET» находится в состоянии высокого импеданса («висит», не подтянут к «1» и не прижат к «0»). Соединение выводов «SLEEP» и «RESET» приведёт к тому, что логическая «1» со входа «SLEEP» попадёт и на вход «RESET» драйвера (тот же результат можно достичь просто подав «1» на вход «RESET»). Значит и спящий режим, и перезагрузка, будут отключены, и недоступны.

Примечание

Подключение и отключение двигателя от выводов «1A», «1B», «2A», «2B» при наличии питания двигателя VMOT может вывести драйвер из строя.
У платы драйвера по 8 выводов с каждой стороны, если подключить питание перепутав стороны платы (повернуть плату драйвера на 180°), то она точно выйдет из строя.

Управление двигателем

Шаговый двигатель это бесколлекторный двигатель, ротор которого вращается не плавно, а шагами (дискретно). Один оборот ротора (360°) состоит из определённого количества шагов. Количество полных шагов в одном обороте указывается в технической документации двигателя.

Управление шаговым двигателем осуществляется через входы «ENABLE», «STEP» и «DIR» драйвера (если считать, что выводы «RESET» и «SLEEP» соединены как на схеме). Подача логического «0» на вход «ENABLE» разрешает работу драйвера. С каждым фронтом импульса на входе «STEP», ротор двигателя будет поворачиваться на один шаг, направление поворота которого будет зависеть от логического уровня на входе «DIR».

Пример для двигателя 17HS1352-P4130 в полношаговом режиме:

Для разрешения работы драйвера, необходимо установить уровень логического «0» на входе «ENABLE» (так как вход инверсный).
У двигателя 17HS1352-P4130, один оборот ротора состоит из 200 полных шагов, значит за один полный шаг ротор повернётся на 1,8° (360° / 200 шагов).
Если подать на вход «STEP» 400 импульсов, при наличии логической «1» на входе «DIR», то ротор двигателя совершит два полных оборота в одну сторону.
Если подать на вход «STEP» 400 импульсов, при наличии логического «0» на входе «DIR», то ротор двигателя совершит два полных оборота в другую сторону.
Чем выше частота следования импульсов на входе «STEP», тем быстрее будет осуществляться поворот ротора.
Если работа драйвера разрешена (на входе «ENABLE» уровень логического «0») и на вход «STEP» не поступают импульсы, то ротор двигателя будет удерживаться в одном и том же положении, вне зависимости от уровня на входе «DIR». Удержание ротора означает что его трудно (или невозможно) повернуть прикладывая внешнюю физическую силу.
При подаче логической «1» на вход «ENABEL», драйвер отключится и ротор двигателя освободится, вне зависимости от состояния на остальных входах драйвера.

Примечание

Входы «STEP» и «DIR» не имеют внутрисхемной подтяжки к «1» или «0». Значит их нельзя оставлять не подключёнными.

Выбор размера шага двигателя

В предыдущем разделе указано, что один оборот ротора осуществляется за определённое количество шагов. Но шаговыми двигателями можно управлять не только в полношаговом режиме (1 шаг за такт), а еще и в полушаговом (1/2 шага за такт), и микрошаговом (1/4, 1/8, 1/16 . шага за такт). Подробнее о режимах управления шаговыми двигателями смотрите в разделе Wiki — Шаговые двигатели .

200 шагов в полношаговом режиме (1,8° за такт)
400 шагов в полушаговом режиме = 1/2 шага (0,9° за такт)
800 шагов при размере шага 1/4 (0,45° за такт)
1600 шагов при размере шага 1/8 (0,225° за такт)
3200 шагов при размере шага 1/16 (0,1125° за такт)
Чем больше шагов в полном обороте ротора двигателя, тем плавнее он вращается, но при этом уменьшается крутящий момент (сила вращения).

Драйвер A4988 позволяет выбрать 1 из 5 вариантов размера шага двигателя. Выбор размера шага осуществляется установкой логических уровней на входах драйвера MS3, MS2, MS1, в соответствии с таблицей:

Размер шагаMS-3MS-2MS-1

Полношаговый режим	0	0	0
1/2 шага	0	0	1
1/4 шага	0	1	0
1/8 шага	0	1	1
1/16 шага	1	1	1

Примечание

Входы MS3, MS2 и MS1 драйвера, внутрисхемно прижаты к GND (через сопротивления в несколько десятков кОм). Так что если их оставить не подключёнными, то драйвер будет работать в полношаговом режиме.

Драйвер L298N

Драйвер L298N используется радиолюбителями для многофункционального управления двигателями постоянного тока. Схема модуля, состоящая из двух H-мостов, позволяет подключать к нему один биполярный шаговый двигатель или одновременно два щёточных двигателя постоянного тока. При этом есть возможность изменять скорость и направление вращения моторов. Управление осуществляется путём подачи соответствующих сигналов на командные входы, выполненные в виде штыревых контактов. На рисунке ниже показан внешний вид модуля с кратким описанием всех его составляющих.

Внешний вид модуля L298N

OUT1 и OUT2 – разъёмы для подключения первого щёточного двигателя или первой обмотки шагового двигателя;
OUT3 и OUT4 – разъёмы для подключения второго щёточного двигателя или второй обмотки шагового двигателя;
VSS – вход для питания двигателей (максимальный уровень +35V);
GND – общий провод (не забываем соединить с аналогичным входом Arduino. );
Vs – вход для питания логики +5V. Через него непосредственно запитывается сама микросхема L298N. Есть ещё второй способ питания, при котором 5V для L298N берётся от встроенного в модуль стабилизатора напряжения. В таком случае на разъём подаётся только питание для двигателей (Vss), контакт Vs остаётся не подключенным, а на плате устанавливается перемычка питания от стабилизатора, который ограничит питающее моторы напряжение до приемлемых 5V.
IN1, IN2 – контакты управления первым щёточным двигателем или первой обмоткой шагового двигателя.
IN3, IN4 – контакты управления вторым щёточным двигателем или второй обмоткой шагового двигателя.
ENA, ENB – контакты для активации/деактивации первого и второго двигателей или соответствующих обмоток ШД. Подача логической единицы на эти контакты разрешает вращение двигателей, а логический ноль – запрещает. Для изменения скорости вращения щёточных моторов на эти контакты подаётся ШИМ-сигнал. Для работы с шаговым двигателям, как правило, на эти контакты ставят перемычки, обеспечивающие постоянную подтяжку к +5V.

Электрическая схема модуля L298N

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

Транзисторные мосты Н-типа

На рисунке изображены два транзисторных моста Н-типа. В первом случае на вход IN1 подаётся логическая единица, а на вход IN2 – логический ноль. Так как транзисторы в схеме моста имеют разный тип проводимости, то при таком входном сигнале транзисторы Т1 и Т4 останутся в закрытом состоянии, в то время, как через транзисторы Т2 и Т3 потечёт ток. Ввиду того, что единственный путь протекания тока лежит через обмотку двигателя, то последний окажется подключен правой клеммой к плюсу питания, а левой к минусу. Всё это приведёт к вращению мотора в определённом направлении. Абсолютно противоположная картина показана на нижнем рисунке. Здесь IN3 установлен в логический ноль, а IN4 в логическую единицу. Теперь ток течёт в обратном направлении (левая клемма – плюс, правая – минус), заставляя второй двигатель крутиться в противоположную сторону.

Технические характеристики

Напряжение питания логики: 5В
Потребляемый логикой ток: 36мА
Напряжение питания моторов: от 5 до 35В
Рабочий ток драйвера: 2А
Пиковый ток драйвера 3А
Максимальная мощность: 20Вт (при температуре 75 о С)
Диапазон рабочих температур: -25 о С…+135 о С
Размеры модуля: 43.5 х 43.2 х 29.4мм

Подключение L298N к плате Arduino

Работать с модулем L298N довольно просто и комфортно. Здесь не придётся изучать тонны литературы с описанием замороченных протоколов. Все сводится к простому переключению логических уровней на выводах Arduino плюс к генерации ШИМ, если требуется управлять скоростью вращения.
Так как драйвер способен управлять двумя типами моторов (щёточным или шаговым), то и работа с ним строится по-разному. Рассмотрим для начала подключение обычных щёточных моторов постоянного тока и управление ими с помощью платы Arduino Nano. На рисунке показана соответствующая схема подключения.

Схема подключения двух щёточных двигателей постоянного тока

Следует обратить внимание, что в схеме предусмотрена возможность управления скоростью вращения, поэтому выводы ENA и ENB драйвера подключены к пинам Arduino, способным выдавать ШИМ-сигнал. Arduino питается от отдельного источника 7-12В. Если напряжение питания моторов лежит в этом же диапазоне, то можно объединить питающие цепи в одну общую. Также необходимо следить за тем, чтобы минусовые провода всех элементов схемы были соединены между собой.
Для демонстрации возможностей модуля, напишем скетч, который будет вращать моторы с различной скоростью и периодически менять направления их вращения. Ниже приведена программа с подробными комментариями, которая реализует задуманный алгоритм.

#define PIN_ENA 9 // Вывод управления скоростью вращения мотора №1 #define PIN_ENB 3 // Вывод управления скоростью вращения мотора №2 #define PIN_IN1 7 // Вывод управления направлением вращения мотора №1 #define PIN_IN2 6 // Вывод управления направлением вращения мотора №1 #define PIN_IN3 5 // Вывод управления направлением вращения мотора №2 #define PIN_IN4 4 // Вывод управления направлением вращения мотора №2 uint8_t power = 105; // Значение ШИМ (или скорости вращения) void setup() < // Установка всех управляющих пинов в режим выхода pinMode(PIN_ENA, OUTPUT); pinMode(PIN_ENB, OUTPUT); pinMode(PIN_IN1, OUTPUT); pinMode(PIN_IN2, OUTPUT); pinMode(PIN_IN3, OUTPUT); pinMode(PIN_IN4, OUTPUT); // Команда остановки двум моторам digitalWrite(PIN_IN1, LOW); digitalWrite(PIN_IN2, LOW); digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN4, LOW); >void loop() < // Вращаем моторы в одну сторону с разной скоростью while(power < 255) < analogWrite(PIN_ENA, power); // Устанавливаем скорость 1-го мотора analogWrite(PIN_ENB, power); // Устанавливаем скорость 2-го мотора // Задаём направление для 1-го мотора digitalWrite(PIN_IN1, HIGH); digitalWrite(PIN_IN2, LOW); // Задаём направление для 2-го мотора digitalWrite(PIN_IN3, HIGH); digitalWrite(PIN_IN4, LOW); delay(3000); // Пауза 3 секунды power += 30; // Увеличиваем скорость >power = 225; // Вращаем моторы в другую сторону с разной скоростью while(power > 105) < analogWrite(PIN_ENA, power); // Устанавливаем скорость 1-го мотора analogWrite(PIN_ENB, power); // Устанавливаем скорость 2-го мотора // Задаём направление для 1-го мотора digitalWrite(PIN_IN1, LOW); digitalWrite(PIN_IN2, HIGH); // Задаём направление для 2-го мотора digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN4, HIGH); delay(3000); // Пауза 3 секунды power -= 30; // Уменьшаем скорость >power = 105; >

В самом верху программы задаются макроопределения всех выводов, используемых в проекте. В функции Setup() все выводы Arduino Nano, участвующие в управлении, задаются в качестве выхода. На выводах IN1-IN4 выставляются логические нули, чтобы двигатели гарантированно не вращались в момент старта программы. В главном цикле, программа обеспечивает вращение двигателей в одном направлении, увеличивая их скорость каждые 3 секунды. Когда разгон вырастает до максимального, моторы начинают вращаться в обратном направлении, постепенно замедляя скорость. На пике сбавления скорости, алгоритм повторяется заново. Как видим, сложного здесь ничего нет. Теперь разберёмся с шаговым двигателем и его подключением к плате Arduino Nano.

Схема подключения шагового двигателя к Arduino Nano

В качестве демонстрационной модели использован популярный шаговый двигатель NEMA17. Он способен вращаться с частотой до 60 оборотов в минуту и имеет разрешающую способность 200 шагов на один оборот. Следует обратить внимание, что выводы ENA и ENB должны быть подтянуты к +5V путём установки перемычек на самом модуле. Таким образом управляющему сигналу будет разрешено проходить на обмотки шагового двигателя. Также, в случае использования двигателя NEMA17, напряжение его питания не должно превышать 12V. Ниже приведён пример кода с комментариями, который заставит двигатель вращаться в разные стороны, меняя своё направление после каждого полного оборота. В программе использована стандартная библиотека Stepper.h, которая значительно упрощает процесс разработки ПО для проектов с шаговыми двигателями.

#include // Подключение библиотеки для работы с ШД #define steps 200 // Количество шагов на один оборот // Создание экземпляра класса для работы с ШД. указываем кол-во шагов на один оборот // и пины Arduino, к которым подключены обмотки двигателя Stepper myStepper(steps, 7, 6, 5, 4); void setup() < myStepper.setSpeed(60); // Устанавливаем скорость вращения об./мин. >void loop() < myStepper.step(steps); // Вращаем двигатель в одну сторону на 200 шагов delay(1000); // Ждём одну секунду myStepper.step(-steps); // Вращаем двигатель в обратную сторону на 200 шагов delay(1000); // Ждём одну секунду >

Пример использования

Модуль L298N применяется в устройствах, где есть необходимость управления двигателями. Такими устройствами могут быть различного рода ЧПУ, 3D принтеры, роботы, механизмы вендинговых аппаратов и т.п. Для того, чтобы глубже вникнуть в тему работы с драйвером, создадим небольшой проект роботизированной платформы, которая будет передвигаться по командам с любого ИК-пульта дистанционного управления. Робот будет иметь два мотор-редуктора, связанных напрямую с колёсами, а также ИК-приёмник, способный воспринимать команды пульта ДУ. В качестве “мозга” выступит плата Arduino Nano.

Электрическая схема робота-машинки

Для приёма управляющих сигналов с ИК-пульта, в проекте будет использоваться популярная микросхема TSOP-1738. Удобство её заключается в том, что она напрямую подключается к плате Arduino и поддерживает большое разнообразие пультов управления. Цифра 38 в конце маркировки означает несущую частоту (кГц), с которой ваш пульт передаёт сигнал. Существует несколько модификаций данной микросхемы на разные несущие частоты. Ниже приведён список возможных вариантов.

TSOP-1730 (30 кГц)
TSOP-1733 (33 кГц)
TSOP-1736 (36 кГц)
TSOP-1737 (37.6 кГц)
TSOP-1738 (38 кГц)
TSOP-1740 (40 кГц)
TSOP-1756 (56 кГц)

Следует помнить, что помимо несущей частоты, каждая кнопка пульта дистанционного управления имеет свой уникальный код, который предварительно необходимо считать и вставить в текст основного скетча. В данном проекте будет использоваться всего 4 кнопки: “вперёд”, “назад”, “вправо” и “влево”. Определить коды поможет библиотека IRremote.
Итак, собираем всё по вышеприведенной схеме, устанавливаем библиотеку IRremote, и для начала заливаем в Arduino этот скетч.

#include #define RECV_PIN 13; IRrecv irrecv(RECV_PIN); decode_results results; void setup() < Serial.begin(9600); irrecv.enableIRIn(); >void loop() < if (irrecv.decode( Serial.println(results.value, HEX); irrecv.resume(); >delay(100); >

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

Кнопка “Вперёд” — 0xB4B4E21D
Кнопка “Назад” — 0xB4B412ED
Кнопка “Вправо” — 0xB4B45AA5
Кнопка “Влево” — 0xB4B49A65

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

Пример реализации шасси для робота

В пластиковом корпусе удалось разместить все необходимые элементы схемы, а именно: источник питания, Arduino Nano и модуль L298N. ИК-приемник TSOP-1738 был вынесен на верх корпуса, чтобы обеспечить надёжную связь с пультом ДУ. Ведущие колёса с моторами закреплены снизу при помощи двухстороннего скотча. В качестве переднего колеса используется поворотный ролик от кресла.

Робот готов к программированию

Ниже приведён исходный код управления роботом-машинкой с подробными комментариями.

#define PIN_RECV 13 // Вывод, к которому подключен ИК-приёмник #define PIN_IN1 7 // Вывод управления правого колеса #define PIN_IN2 6 // Вывод управления правого колеса #define PIN_IN3 5 // Вывод управления левого колеса #define PIN_IN4 4 // Вывод управления левого колеса #define PIN_ENA 9 // Вывод управления скоростью правого колеса #define PIN_ENB 3 // Вывод управления скоростью левого колеса #define SPEED 255 // Скорость бобо-машинки (0-255) // Коды с пульта управления (необходимо вставить свои. ) #define BUTTON_FORWARD 0xB4B4E21D // Код кнопки ВПЕРЁД #define BUTTON_LEFT 0xB4B49A65 // Код кнопки ВЛЕВО #define BUTTON_RIGHT 0xB4B45AA5 // Код кнопки ВПРАВО #define BUTTON_BACK 0xB4B412ED // Код кнопки НАЗАД #include // Библиотека для работы с ИК-приёмником IRrecv irrecv(PIN_RECV); // Создание объекта работы с ИК-приёмником decode_results results; // Переменная для хранения результата декодирования void setup() < irrecv.enableIRIn(); // Инициализация ИК-приёмника // Настройка на выход всех управляющих пинов Arduino pinMode(PIN_IN1, OUTPUT); pinMode(PIN_IN2, OUTPUT); pinMode(PIN_IN3, OUTPUT); pinMode(PIN_IN4, OUTPUT); pinMode(PIN_ENA, OUTPUT); pinMode(PIN_ENB, OUTPUT); // Остановка моторов digitalWrite(PIN_IN1, LOW); digitalWrite(PIN_IN2, LOW); digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN4, LOW); analogWrite(PIN_ENA, SPEED); analogWrite(PIN_ENB, SPEED); >void loop() < // Ждём поступления сигнала с пульта ДУ if (irrecv.decode( // Анализируем полученный результат switch(results.value) < case BUTTON_FORWARD: // Движение ВПЕРЁД digitalWrite(PIN_IN1, HIGH); digitalWrite(PIN_IN2, LOW); digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN2, HIGH); break; case BUTTON_LEFT: // Поворот ВЛЕВО digitalWrite(PIN_IN1, HIGH); digitalWrite(PIN_IN2, LOW); digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN2, LOW); break; case BUTTON_RIGHT: // Поворот ВПРАВО digitalWrite(PIN_IN1, LOW); digitalWrite(PIN_IN2, LOW); digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN2, HIGH); break; case BUTTON_BACK: // Движение НАЗАД digitalWrite(PIN_IN1, LOW); digitalWrite(PIN_IN2, HIGH); digitalWrite(PIN_IN3, HIGH); digitalWrite(PIN_IN2, LOW); break; >irrecv.resume(); > >

Часто задаваемые вопросы

Какое минимальное напряжение можно подавать на вход питания двигателей модуля?

Напряжение питания силовой части не рекомендуется опускать ниже 7В. Согласно документации, оно должно быть выше напряжения логики на 2,5В.

Какой ток может обеспечить внутренний стабилизатор 5В?

Внутренний 5-вольтовый стабилизатор модуля может выдать ток до 0.5А.

Можно ли управлять выводами ENA и ENB без использования ШИМ?

Можно управлять функцией digitalWrite, но в таком случае регулировка скорости будет невозможна. Управление будет сводиться к двум состояниям: вкл./выкл.

Почему двигатель начинает вращаться при ШИМ больше чем 97, а до этого просто стоит на месте? Как сделать так, чтобы скорость могла регулироваться от 0?
Разные двигатели имеют разные технические характеристики и как следствие разную стартовую мощность. Поэтому для каждого конкретного случая будет своё минимальное значение ШИМ, при котором двигатель начнёт вращаться с начальной скоростью. Фактическая регулировка от 0 невозможна, так как двигатель попросту не хватит энергии. В таких случаях очень удобно использовать функцию map(). Например, оформить регулировку от 0 до 100% можно следующим образом:

uint8_t speed = 90; // Скорость двигателя в процентах speed = map(speed, 96, 255, 0, 100); // Диапазон ШИМ 97-255 преобразуем в проценты 0-100 analogWrite(speed);