Sterownik unipolarnego mikrosilnika krokowego dla PI Pico

Niedziela, 02 Lipiec 2023

Silniki unipolarne to najprostsze i najtańsze spośród silników krokowych, pomimo to sprawdzają się w wielu aplikacjach. Zaprezentowany moduł umożliwia sterowanie silnikiem unipolarnym poprzez Raspberry Pi Pico.

Podstawowe parametry:

generowanie przebiegu sterującego odbywa się na drodze programowej,
współpracuje z silnikami unipolarnymi 5-przewodowymi,
współpracuje z silnikami o napięciu znamionowym 5...12 V.

Układ zrealizowany jest bez specjalizowanych sterowników silników krokowych, a generowanie przebiegu sterującego odbywa się programowo. Współpracuje z silnikami unipolarnymi 5-przewodowymi np. 25SPG lub 28BYJ.

Rysunek 1. Schemat ideowy modułu sterownika

Schemat modułu został pokazany na rysunku 1. Silnik dołączany jest do złącza MOUT. Każde z czterech uzwojeń silnika sterowane jest własnym tranzystorem MOSFET wchodzącym w strukturę podwójnego tranzystora Q1, Q2. Do wyprowadzenia wspólnego uzwojeń doprowadzone jest napięcie zasilania VM.

Napięcie zasilania silnika doprowadzone jest do złącza PWR, jego wartość powinna być dobrana do typu silnika i powinna mieścić się w zakresie 5...12 V. Należy też pamiętać o odpowiedniej wydajności prądowej źródła zasilania.

Układ U1 typu LVC125 zapewnia separację portów GPIO procesora i wysterowanie bramek tranzystorów wykonawczych. Zasilanie części logicznej pobierane jest z wbudowanej przetwornicy 3,3 V Pi Pico. Sterowanie silnikiem zajmuje cztery wyprowadzenia GPIO18...21. Układ uzupełnia złącze GPIO dla wyprowadzeń 12, 13 lub magistrali I²C w standardzie Grove, ułatwiające podłączenie zewnętrznych czujników w standardzie 3,3 V.

Montaż i uruchomienie

Sterownik zmontowany jest na dwustronnej płytce drukowanej zgodnej z Pi Pico, której schemat został pokazany na rysunku 2.

Rysunek 2. Schemat płytki PCB

Sposób montażu jest klasyczny i nie wymaga opisu. Zmontowany moduł nie wymaga uruchamiania. Do złącza MOUT należy podłączyć silnik, zachowując odpowiednią kolejność wyprowadzeń. Najważniejsze jest wyprowadzenie wspólne uzwojeń podłączone do VM, pozostałe wyprowadzenia mogą zostać podłączone dowolnie, gdyż zawsze można zmodyfikować sekwencję sterująca uzwojeniami.

Sterowanie silnikiem odbywa się poprzez generowanie sekwencji stanów wyprowadzeń GPIO. Szybkiego sprawdzenia modułu po podłączeniu silnika i zasilania można dokonać korzystając z IDE Thonny i micropythona. Należy najpierw zaimportować biblioteki Pin oraz sleep poleceniami:

from machine import Pin
from time import sleep

i zdefiniować wyjścia sterujące:

MA = Pin(21,Pin.OUT)
MB = Pin(20,Pin.OUT)
MC = Pin(19,Pin.OUT)
MD = Pin(18,Pin.OUT)
pins = [MA, MB, MC, MD]

Sekwencje sterujące dla różnych konfiguracji znajdują się na listingu 1, natomiast prosty skrypt do wygenerowania ciągu impulsów znajduje się na listingu 2.

Listing 1. Sekwencje sterujące dla różnych konfiguracji

#Wave CW
seqstep = [[0,0,0,1],[0,0,1,0],[0,1,0,0],[1,0,0,0]]
#Wave CCW
#seqstep = [[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]

#Full CW
#seqstep = [[1,0,0,1],[0,0,1,1],[0,1,1,0],[1,1,0,0],[1,0,0,1],[0,0,1,1],[0,1,1,0],[1,1,0,0],[1,0,0,0]]
#Full CCW
#seqstep = [[1,0,0,1],[1,1,0,0],[0,1,1,0],[0,0,1,1],[1,0,0,1],[1,1,0,0],[0,1,1,0],[0,0,1,1],[0,0,0,1]]

#Half CW
#seqstep = [[1,0,0,1],[0,0,0,1],[0,0,1,1],[0,0,1,0],[0,1,1,0],[0,1,0,0],[1,1,0,0],[1,0,0,0],[1,0,0,1],[0,0,0,1],[0,0,1,1],[0,0,0,0],[0,1,1,0],[0,1,0,0],[1,1,0,0],[1,0,0,0],[1,0,0,0]]
#Half CCW
#seqstep = [[1,0,0,1],[1,0,0,0],[1,1,0,0],[0,1,0,0],[0,1,1,0],[0,0,1,0],[0,0,1,1],[0,0,0,1],[1,0,0,1],[1,0,0,0],[1,1,0,0],[0,0,0,0],[0,1,1,0],[0,0,1,0],[0,0,1,1],[0,0,0,1],[0,0,0,1]]

Listing 2. Prosty skrypt do wygenerowania ciągu impulsów

while True:
for step in seqstep:
for i in range(len(pins)):
pins[i].value(step[i])
sleep(0.005)

Jeżeli po sprawdzeniu wszystko działa poprawnie można moduł zastosować we własnej aplikacji.

Adam Tatuś, EP

Wykaz elementów:

Rezystory: (SMD0603)