Управляем шаговыми движками и 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-мост, принцип коммутации двигателя для вращения в разные стороны.

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

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

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

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

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

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

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

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

Максимальная мощность нагрузки при использовании транзисторов КТ817 и КТ816 не должна превышать 25 Ватт, иначе последние выйдут из строя.

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

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

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

Собирать схему из 12-ти транзисторов, 8 из которых нужно установить на радиаторы - не всегда удобно и выгодно. Вместо этого можно применить современные специализированные микросхемы.

Ниже мы рассмотрим пример с микросхемой L298 и готовым блоком на ее основе.

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

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

В ней содержится совместимая с TTL логика управления, а также собраны два H-моста, которые выполнены на мощных транзисторах.

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

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

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

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

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

Смотря на структурную схему микросхему L298 можно видеть что она по принципу соединений напоминает схему на рисунке 2, только с дополнительными логическими элементами.

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

Для каждого H-моста мы имеем по 3 входа:

1. In1 - для подачи напряжения в одном направлении;
2. In2 - в противоположном;
3. En - для подачи питания на выходные транзисторы моста.

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

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

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

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

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

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

Интегральную цифровую микросхему CD4011 можно заменить на отечественную К176ЛА7. Диоды Шоттки можно использовать любые с напряжением 35В и ток от 4А и более.

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

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

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

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

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

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

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

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

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

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

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

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

Для данного эксперимента к модулю на L298 были подключены два двигателя постоянного тока. Питание всего модуля осуществляется от одного аккумулятора на +6В.

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

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

Таким образом, для управления каждым из двигателей используем оставшиеся четыре входа: 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

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

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

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

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

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

nano /home/pi/l298_dc_motors_test.py

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import time
import RPi.GPIO as GPIO

# Подготавливаем пины GPIO.
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)

GPIO.setup(4, GPIO.OUT)
GPIO.output(4, GPIO.LOW)

GPIO.setup(17, GPIO.OUT)
GPIO.output(17, GPIO.LOW)

# Включаем вращение двигателя 1 в одну сторону.
GPIO.output(4, GPIO.HIGH)

# ждем 5 секунд.
time.sleep(5)

# Выключаем двигатель 1.
GPIO.output(4, GPIO.LOW)

# ждем 10 секунд.
time.sleep(10)

# Включаем вращение двигателя 1 в другую сторону.
GPIO.output(17, GPIO.HIGH)

# ждем 5 секунд.
time.sleep(5)

# Выключаем двигатель 1.
GPIO.output(17, GPIO.LOW)

Выходим из редактора (CTRL+X) перед этим подтвердив запись содержимого в файл (жмем "Y" - yes). Делаем скрипт исполняемым и запускаем его:

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

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

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

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

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

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)

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

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

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

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

О том как использовать этот метод для GPIO вы можете узнать из подробной статьи, посвященной модулю "RPi.GPIO".

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Если все уже подключено, то переходим к экспериментам с простой тестовой программой на Python, которая поможет понять как работать с шаговыми двигателем используя L298 + Raspberry Pi.

Создадим файл для скрипта и откроем его для редактирования:

nano /home/pi/l298_stepper_motor_test.py

Вставляем в редактор следующий код скрипта на Python:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import time
import RPi.GPIO as GPIO

# Подготавливаем пины GPIO.
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)

GPIO.setup(4, GPIO.OUT)
GPIO.output(4, GPIO.LOW)

GPIO.setup(17, GPIO.OUT)
GPIO.output(17, GPIO.LOW)

GPIO.setup(27, GPIO.OUT)
GPIO.output(27, GPIO.LOW)

GPIO.setup(22, GPIO.OUT)
GPIO.output(22, GPIO.LOW)

# Временная задержка между шагами, сек.
step_timeout = 0.0105
# Длительность импульса, сек.
impulse_timeout = 0.008

# Шаг 1.
GPIO.output(4, GPIO.HIGH)
time.sleep(impulse_timeout)
GPIO.output(4, GPIO.LOW)
time.sleep(step_timeout)

# Шаг 2.
GPIO.output(17, GPIO.HIGH)
time.sleep(impulse_timeout)
GPIO.output(17, GPIO.LOW)
time.sleep(step_timeout)

# Шаг 3.
GPIO.output(27, GPIO.HIGH)
time.sleep(impulse_timeout)
GPIO.output(27, GPIO.LOW)
time.sleep(step_timeout)

# Шаг 4.
GPIO.output(22, GPIO.HIGH)
time.sleep(impulse_timeout)
GPIO.output(22, GPIO.LOW)
time.sleep(step_timeout)

# Ждем 10 секунд.
time.sleep(10)

# 20 раз по 4 шага в цикле.
for i in range(0,20):
    GPIO.output(4, GPIO.HIGH)
    time.sleep(impulse_timeout)
    GPIO.output(4, GPIO.LOW)
    time.sleep(step_timeout)

    GPIO.output(17, GPIO.HIGH)
    time.sleep(impulse_timeout)
    GPIO.output(17, GPIO.LOW)
    time.sleep(step_timeout)

    GPIO.output(27, GPIO.HIGH)
    time.sleep(impulse_timeout)
    GPIO.output(27, GPIO.LOW)
    time.sleep(step_timeout)

    GPIO.output(22, GPIO.HIGH)
    time.sleep(impulse_timeout)
    GPIO.output(22, GPIO.LOW)
    time.sleep(step_timeout)

Делаем файл со скриптом исполняемым и запускаем его на исполнение:

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

После запуска скрипта шаговый двигатель должен совершить 4 шага (вращение в одну сторону), потом подождав 10 секунд он снова начнет свое вращение и сделает уже 20 итераций по 4 шагов в каждой.

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

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

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

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)

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

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

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

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

Заключение

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

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

Литература:

• Даташит на микросхему L298N Скачать (190 КБ)

Если статья оказалась полезной - помочь проекту можно тут: → 👍 ПОМОЩЬ, 🎁 DONATE