Категории публикаций
Подписка на рассылку по Email
новости (подписчиков: 3)
комментарии (подписчиков: 2)

Отменить подписку
Популярные публикации
Интересный опрос
Какую платежную систему вы предпочетаете?

Счет в Банке
Webmoney
PayPal
BitCoin и другие криптовалюты
okPay
ePayServices
AdvCash
Ее нет в списке
Поблагодарить автора
donate
1B4ZZ2PXUd9E7AqEB82AqFnkpk2bt5hQG7

Управляем шаговыми движками и DC моторами, L298 и Raspberry Pi

Размещено в категории: Железо

Рассмотрим драйвер электродвигателей на транзисторах и микросхеме L298, разберемся с принципом работы H-моста. Узнаем особенности подключения драйверов на L298 к разным двигателям и источникам питания, проведем простые эксперименты с шаговыми движками и двигателями постоянного напряжения. Подключение к Raspberry Pi и простейшие программы для теста управления драйвером.

Содержание:

  1. Что такое H-мост
  2. Схема простого H-моста на кремниевых транзисторах
  3. Микросхема L298, характеристики и возможности
  4. Схема драйвера на микросхеме L298
  5. Готовые модули на L298
  6. L298 + DC двигатели + Raspberry Pi
  7. Что такое шаговый двигатель, типы шаговиков
  8. L298 + шаговый двигатель + Raspberry Pi
  9. Заключение

 

Что такое H-мост

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

Почему такое название? - потому что схема включения двигателя и переключателей для коммутации напоминает латинскую букву H. Принципы работы H-моста показан нарисунке ниже.

Как работает H-мост

Рис. 1. Как работает H-мост, принцип коммутации двигателя для вращения в разные стороны.

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

Важно заметить что НЕЛЬЗЯ допускать замыкания двух ключей на одной стороне H-моста, поскольку получится короткое замыкание, при проектировании схемы моста нужно заложить это правило в логику и таким образом реализовать защиту.

 

Схема простого H-моста на кремниевых транзисторах

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

Принципиальная схема простого драйвера для электродвигателя

Рис. 2. Принципиальная схема простого драйвера электродвигателя на кремниевых транзисторах.

Такой драйвер позволяет управлять электродвигателем постоянного тока с питающим напряжением до 25В (для КТ817А, КТ816А) и до 45В (для КТ817Б-Г, КТ816Б-Г) с током не более 3А. При большом рабочем и нагрузочном токе двигателя выходные транзисторы КТ817 и КТ816 должны быть установлены на радиаторы достаточного размера.

Установка диодов VD1-VD2 обязательна, они нужны для защиты выходных транзисторов от обратного тока. На их место можно поставить отечественные КД105А или другие на больший ток.

Собрав две такие схемки (2х6 транзисторов) можно также управлять шаговым двигателем или же двумя двигателями постоянного тока.

Для того чтобы не городить огород из 12 транзисторов можно применить специализированные микросхемы, ниже мы рассмотрим пример с микросхемой L298 и готовым блоком на ее основе.

 

Микросхема L298, характеристики и возможности

Интегральная микросхема L298 - это мощный универсальный мостовой драйвер для управления двигателями постоянного тока, шаговыми движками, электромагнитными реле и электромагнитами (соленоидами). В микросхеме содержится два H-моста, выполненных на мощных транзисторах, а также логика совместимая с TTL.

Микросхема L298 в корпусах Multiwatt15 PowerSO20

Рис. 3. Микросхема L298 в корпусах Multiwatt15 PowerSO20.

Основные технические характеристики:

  • Рабочее напряжение - до 46В;
  • Максимальный постоянный ток - 4А (с радиатором);
  • Низкое напряжение насыщения;
  • Защита от перегрева;
  • Логический "0" = напряжение до 1,5В.

Где можно применить драйвер на микросхеме L298? - несколько идей:

  • Управление шаговым двигателем;
  • Управление двумя двигателями постоянного тока (DC motors);
  • Коммутация катушек мощных реле;
  • Управление соленоидами (электромагнитами).

Если посмотреть на структурную схему микросхему L298 то мы можем увидеть что-то на подобии схемы на рисунке 2, только с дополнительными логическими элементами.

Внутренняя схема микросхемы L298N

Рис. 4. Внутренняя схема микросхемы L298N - мощный двойной H-мост.

Для каждого H-моста мы имеем по 3 входа: In1 - для подачи напряжения в одном направлении, In2 - в противоположном, и еще один вход En для подачи питания на выходные транзисторы моста.

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

 

Схема драйвера на микросхеме L298

Ниже представлена простая схема для драйвера двигателей на микросхеме L298N. Управление осуществляется по четырем проводам (вместо шести у L298) благодаря использованию дополнительных инверторов в микросхеме CD4011.

Принципиальная схема драйвера электродвигателей на микросхеме L298N

Рис. 5. Принципиальная схема драйвера электродвигателей на микросхеме L298N.

Для питания логики обеих микросхем нужно стабилизированное напряжение +5В (P2), можно использовать интегральный стабилизатор, например L7805 или же питать логику от имеющейся линии питания +5В. Для подачи питающего напряжения на двигатели используется отдельная линия питания P1.

Выводы P4, P5 используются для установки полярности каждого из каналов, а выводы P6, P7 - разрешают подачу питания на  каскады (ключи) внутреннего H-моста для каждого канала.

Микросхему CD4011 можно заменить на отечественную К176ЛА7. Диоды Шоттки можно поставить другого номинала, на 35В/4А и более. Если не планируется ограничивать ток обмоток двигателя(двигателей) то низкоомные ограничивающие резисторы R9-R10 можно исключить из схемы, заменив их на перемычки.

 

Готовые модули на L298

В интернете можно заказать готовый модуль на L298, правда в нем будет 6 входов для управления.

Готовые модули на L298

Рис. 6. Готовые модули на L298.

Я для своих нужд приобрел готовый модуль по типу как на рисунке слева. В нем присутствует микросхема L298 и небольшой стабилизатор для подачи +5В на логику микросхемы.

Для подключения данной платки важно четко уяснить одну особенность:

  • Если для питания двигателей используется напряжение более чем 12В то перемычку нужно убрать и подавать отдельно 5В на выделенный для этого коннектор
  • Если питание двигателей будет осуществляться от напряжения 5-12В то перемычку нужно утсановить и дополнительное питание 5В не понадобится.

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

Для того чтобы сэкономить два входа при подключении такого блока к Arduino или Raspberry Pi можно добавить часть схемы на CD4001, как на рисунке 5.

 

L298 + DC двигатели + Raspberry Pi

Для данного эксперимента к модулю на L298 были подключены два двигателя постоянного тока. Питание всего модуля осуществляется от одного аккумулятора на 6В. Поскольку это напряжение меньше 12В (смотрим выше описание) то перемычку внутреннего стабилизатора оставляем установленной и дополнительное питание +5В для логики не потребуется.

Перемычки "ENA" и "ENB", которые разрешают подачу питания на выходные мосты, оставлены установленными. Таким образом, для управления каждым из двигателей используем оставшиеся четыре входа: IN1, IN2, IN3, IN4.

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

Где взять +5В? - в данном случае это напряжение присутствует на разъеме питания, справа возле GND. Для теста можно воспользоваться кусочком проволоки - перемычкой.

Теперь подключим наш модуль к Raspberry Pi и напишем простую тестовую программу на Python. Для подключения модуля я использовал выводы GPIO вот в таком соответствии:

Raspberry Pi GPIO Модуль L298
Вывод 7 (GPIO4) IN1
Вывод 9 (GND) GND (разъем питания)
Вывод 11 (GPIO17) IN2
Вывод 13 (GPIO27) IN3
Вывод 15 (GPIO22) IN4

L298 + Raspberry Pi + электродвигатели постоянного тока

Рис. 7. L298 + Raspberry Pi + электродвигатели постоянного тока.

Мини-компьютер у меня питается через понижающий импульсный стабилизатор от второго аккумулятора на 6В. Перейдем к написанию программы для нашего эксперимента, наша цель - управлять вращением вала каждого из двигателей при помощи клавиатуры, которая подключена к Raspberry Pi или же удаленно по SSH, VNC.

Загружаем малинку, открываем Терминал или же подключаемся к ней удаленно при помощи SSH. Создаем новый файл и открываем его для редактирования при помощи команды:

nano /home/pi/l298_dc_motors_test.py

Вставляем в редактор код скрипта на Python, который приведен ниже.

Внимание! Комментарии в коде приведены для его лучшего понимания и начинаются с символов решотки "#". Нужно удалить все комментарии с символами кириллици, иначе программа при запуске выдаст ошибку.

#!/usr/bin/env python

import os
import sys
import curses
import time
import RPi.GPIO as GPIO

# Установим номера пинов GPIO, с которыми будем работать
M1_RIGHT = 4
M1_LEFT = 17
M2_RIGHT = 27
M2_LEFT = 22

# Функция для подготовки пинов GPIO
def setup(*ports):
    GPIO.cleanup()
    # Режим именования пинов по названию, а не по номеру на плате 
    GPIO.setmode(GPIO.BCM)
    for port in ports:
        # Установка пина на вывод + низкий уровень "0"
        GPIO.setup(port, GPIO.OUT)
        GPIO.output(port, GPIO.LOW)

# Функция для установки низкого уровня на всех пинах (выключение)
def stop_all():
    GPIO.output(M1_LEFT, GPIO.LOW)
    GPIO.output(M1_RIGHT, GPIO.LOW)
    GPIO.output(M2_LEFT, GPIO.LOW)
    GPIO.output(M2_RIGHT, GPIO.LOW)

# Функция для управления вращением движков
def rotate(motor=1, mode='s'):
    # Выключаем все пины
    stop_all()
    # Для мотора 1
    if motor == 1:
        if mode == 'r':
	    # Устанавливаем высокий уровень на пине M1_RIGHT (4)
            GPIO.output(M1_RIGHT, GPIO.HIGH)
        elif mode == 'l':
	    # Устанавливаем высокий уровень на пине M1_LEFT (17)
            GPIO.output(M1_LEFT, GPIO.HIGH)
    # Для мотора 2
    elif motor == 2:
        if mode == 'r':
            GPIO.output(M2_RIGHT, GPIO.HIGH)
        elif mode == 'l':
            GPIO.output(M2_LEFT, GPIO.HIGH)

# Выполним инициализацию пинов GPIO
setup(M1_RIGHT, M1_LEFT, M2_RIGHT, M2_LEFT)

# Инициализация экрана (модуль curses)
stdscr = curses.initscr()
# Реагировать на нажатие клавиш без подтверждения при помощи ENTER
curses.cbreak()
# Разрешить использование стрелочек на клавиатуре
stdscr.keypad(1)
# Не блокировать программу по времени при опросе событий
stdscr.nodelay(1)

# Отобразим на экране данные по умолчанию
stdscr.addstr(0, 10, "Hit 'q' to quit")
stdscr.addstr(2, 10, "A - M1 Left, D - M1 Right")
stdscr.addstr(3, 10, "< - M2 Left, > - M2 Right")
stdscr.addstr(4, 10, "S - stop")
stdscr.refresh()

# Главный цикл
while True:
    # Получаем код нажатия клавиши и проверяем его
    key = stdscr.getch()
    if key != -1:
        # Если клавиша "стрелка влево" то вращаем движок 2 влево
        if key == curses.KEY_LEFT:
	    # Выводим на экран строку "M2 <---" в позиции 6, 10
            stdscr.addstr(6, 10, "M2 <---")
            rotate(2, 'l')
        # Если клавиша "стрелка вправо" то вращаем движок 2 вправо
        elif key == curses.KEY_RIGHT:
            stdscr.addstr(6, 10, "M2 --->")
            rotate(2, 'r')
        # Если клавиша "а" то вращаем движок 1 влево
        elif key == ord('a'):
            stdscr.addstr(6, 10, "M1 <---")
            rotate(1, 'l')
        # Если клавиша "d" то вращаем движок 1 вправо
        elif key == ord('d'):
            stdscr.addstr(6, 10, "M1 --->")
            rotate(1, 'r')
        # Если клавиша "s" то останов всех движков
        elif key == ord('s'):
            stdscr.addstr(6, 10, "STOP 12")
            stop_all()
        # Если клавиша "s" то выходим из программы
        elif key == ord('q'):
	    # Восстановление прежних настроек терминала
            stdscr.keypad(0)
            curses.echo()
            curses.endwin()
            # Очистка и выход
            os.system('clear')
            sys.exit()
        # Обновляем текст на экране и делаем небольшую задержку
        stdscr.refresh()
        time.sleep(0.01)

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

chmod +x /home/pi/l298_dc_motors_test.py
/home/pi/l298_dc_motors_test.py

Теперь можно нажимать стрелочки влево и вправо, а также клавиши с буквами "A" и "D" - двигатели должны вращаться поочередно и в разные стороны, а программа будет отображать режим работы.

Программа на Python под Raspberry Pi для управления двигателями при помощи драйвера L298

Рис. 8. Программа на Python для управления двигателями при помощи драйвера L298 (терминал Konsole, KDE).

Краткая видео-демонстрация работы данного эксперимента приведена ниже:

 

Что такое шаговый двигатель, типы шаговиков

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

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

Такие двигатели бывают следующих видов:

  • Биполярный - 2 обмотки, по одной на каждую фазу, для управления можно использовать схему на 2 H-моста или один полу-мост с двуполярным питанием;
  • Униполярный  - 2 обмотки, каждая с отводом от середины, удобно переключать фазы сменой половинок каждой из обмоток, упрощает схему драйвера (4 ключа), а также использовать как быполярный без использования отводов от обмоток;
  • С четирьмя обмотками - универсальный, подключив обмотки соответствующим образом можно использовать как быполярный или униполярный движок.

Типы шаговых двигателей

Рис. 9. Типы шаговых двигателей: биполярный, униполярный, с четырьмя обмотками.

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

 

L298 + шаговый двигатель + Raspberry Pi

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

Для подключения одного биполярного двигателя потребуется два выхода драйвера на L298 (два H-моста). Для данного эксперимента модуль L298 нужно подключить к Raspberry Pi так же, как и в варианте с DC-двигателями.

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

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

Подключение биполярного шагового двигателя к L298, Raspberry Pi

Рис. 10. Подключение биполярного шагового двигателя к модулю L298 для управления через Raspberry Pi.

Если все уже подключено, то переходим к тестовой программе на Python, создадим файл для скрипта и откроем его для редактирования:

nano /home/pi/l298_stepper_motor_test.py

Вставляем в редактор следующий код скрипта на Python. Внимание! Комментарии в коде приведены для его лучшего понимания и начинаются с символов решотки "#". Нужно удалить все комментарии с символами кириллици, иначе программа при запуске выдаст ошибку.

#!/usr/bin/env python

import os
import sys
import curses
import time
import RPi.GPIO as GPIO

# Функция для подготовки пинов GPIO
def setup(*ports):
    GPIO.cleanup()
    # Режим именования пинов по названию, а не по номеру на плате
    GPIO.setmode(GPIO.BCM)
    for port in ports:
        # Установка пина на вывод + низкий уровень "0"
        GPIO.setup(port, GPIO.OUT)
        GPIO.output(port, GPIO.LOW)

# Функция для подачи импульса на пин с некоторой задержкой (1 шаг)
def impulse(port=0):
    GPIO.output(port, GPIO.HIGH)
    # Set the timeout value to be anough for one step
    time.sleep(0.008)
    GPIO.output(port, GPIO.LOW)
    time.sleep(timeout)

# Выполняем установку нужных нам пинов GPIO
setup(4, 17, 27, 22)

# Задержка между шагами (по умолчанию)
timeout = 0.0105
# Направление вращения (по умолчанию)
direction = 'r'

# Инициализация экрана (модуль curses)
stdscr = curses.initscr()
# Реагировать на нажатие клавиш без подтверждения при помощи ENTER
curses.cbreak()
# Разрешить использование стрелочек на клавиатуре
stdscr.keypad(1)
# Не блокировать программу по времени при опросе событий
stdscr.nodelay(1)

# Отобразим на экране данные по умолчанию
stdscr.addstr(0, 10, "Hit 'q' to quit")
stdscr.addstr(2, 10, "--->")
stdscr.addstr(3, 10, "Timeout: " + str(timeout))
stdscr.refresh()

# Главный цикл
while True:
    # Набор импульсов для вращения вала мотора вправо
    if direction == 'r':
        impulse(4)
        impulse(17)
        impulse(27)
        impulse(22)
    # Набор импульсов для вращения вала мотора влево
    elif direction == 'l':
        impulse(22)
        impulse(27)
        impulse(17)
        impulse(4)
    # Считываем код нажатия клавиши и проверяем его
    key = stdscr.getch()
    if key != -1:
        # Клавиша "влево" меняет направление вращения: ВЛЕВО
       if key == curses.KEY_LEFT:
	    # отображаем текст "<---" в позиции экрана 2, 10
            stdscr.addstr(2, 10, "<---")
            # Изменим значение переменной с направлением вращения
            direction = 'l'
        # Клавиша "вправо" меняет направление вращения: ВПРАВО
        elif key == curses.KEY_RIGHT:
            stdscr.addstr(2, 10, "--->")
            direction = 'r'
        # Клавиша "вверх" ускоряет вращение
        elif key == curses.KEY_UP:
	    # Уменьшаем задержку между шагами
            timeout = timeout - 0.0005
        # Клавиша "вниз" замедляет вращение
        elif key == curses.KEY_DOWN:
	    # Увеличиваем задержку между шагами
            timeout = timeout + 0.0005
        # Клавиша "q" выполняет выход из программы
        elif key == ord('q'):
            stdscr.keypad(0)
            curses.echo()
            curses.endwin()
            os.system('clear')
            sys.exit()
        # Смотрим чтобы время задержки не перешло границу 0 
        if timeout <= 0:
            timeout = 0.0005
        # Обновляем текст на экране
        stdscr.addstr(3, 10, "Timeout: " + str(timeout))
        stdscr.refresh()
        time.sleep(0.01)

Запускаем программу:

chmod +x /home/pi/l298_stepper_motor_test.py
/home/pi/l298_stepper_motor_test.py

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

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

Программа управления биполярным шаговым двигателем, L298, Raspberry Pi

Рис. 11. Программа управления биполярным шаговым двигателем, L298, Raspberry Pi.

Видео-демонстрация работы шагового двигателя:

 

Заключение

Надеюсь вы получили ответ на вопрос "что такое H-мост и как он работает", из экспериментов должно быть понятно как применять драйвер на микросхеме L298 и подключать к нему разные движки.

Важно заметить что в интернете можно найти готовые библиотеки и скрипты на Python для удобного управления двигателями при помощи H-моста на L298 с использованием Raspberry Pi.

Литература:

 (0/5) голосов: 0   просмотров: 600


Тематика:  L298  Raspberry Pi  Python  GPIO  двигатель

Комментарии к публикации (2)
Александр 1 Александр 
14 Март 2017 22:13

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

0 
ph0en1x 2 ph0en1x 
14 Март 2017 22:42

В моем эксперименте малинка запитана от одного аккумулятора через DC-DC преобразователь, а модуль на L298 питается от другого аккумулятора.
"Земля" малинки и модуля L298 должны быть соединены, иначе при подаче с GPIO пина малинки высокого уровня модуль на L298 его просто не "почувствует". Чтобы не соединять минусы батарей (по сути землю малинки и модуля) отдельным проводом я просто подсоединил вывод GPIO 9 (GND) к клеме GND на модуле, вот и весь сакральный смысл.

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

0 

Добавить комментарий captcha