Generează impulsurile de acționare a motoarelor pas cu pas folosind o placă de dezvoltare cu procesor ATmega328. Funcții pentru toate modurile: wave drive, half drive și full drive
Motoarele pas cu pas sunt motoare fără perii care efectuează mișcări de rotație discrete în pași incrementali, spre deosebire de rotația continuă a unui motor electric obișnuit. Acest pot efectua un număr exact de pași, fiind construite din mai multe bobine alimentate într-o ordine specifică, de o secvență de impulsuri. Motoarele pas cu pas unipolare au două bobine, fiecare cu priză mediană. Aceste prize se conectează împreună la un pol al sursei de alimentare, iar cele patru terminale ale bobinelor sunt alimentate secvențial de driver (aceste motoare au minim 5 fire de conexiune). Celălalt tip de motor pas cu pas este motorul bipolar, cu două bobine, alimentate secvențial cu polaritate directă și apoi inversă (aceste motoare au 4 fire de conexiune).
Un driver cu tranzistoare pentru motoare pas cu pas unipolar și metode simple de generare a impulsurilor au fost prezentate în articolul anterior. Funcțiile de generare a impulsurilor din acel articol sunt mult prea simple și permit rotirea într-o singură direcție, în multipli de 4 pași. În acest articol voi exemplifica încă o dată modurile de acționare a bobinelor motoarelor pas cu pas și voi prezenta niște funcții care permit efectuarea de pași individuali și schimbarea direcției de rotație.
După cum am văzut în articolul anterior, există trei metode de acționare a motoarelor pas cu pas: wave drive, half drive și full drive. În modul wave drive, în orice moment, doar o singură bobină este alimentată, pe când în modul full drive, două bobine sunt alimentate. Modul half drive este o combinație între celelalte două moduri.
Spre deosebire de motoarele unipolare, cele bipolare au doar două bobine din punct de vedere electric. Conectorii A și A# sunt terminalele unei bobine, iar B și B# terminalele celeilalte. Toate modurile de acționare de la motoarele unipolare sunt valabile și la cele bipolare. Acest lucru este posibil pentru că o bobină poate fi nealimentată, alimentată cu o polaritate și alimentată cu polaritate inversă. În cazul în care ambele impulsuri pentru o bobină sunt simultan la nivelul logic 0, aceasta este nealimentată (diferență de potențial 0). Valabil și în cazul în care impulsurile aceleiași bobine ar fi simultan la nivelul logic 1, dar după cum putem observa în graficele de impulsuri, acest lucru nu se întâmplă. Vom afla mai multe despre motoarele bipolare într-un articol viitor.
Înainte de a implementa funcțiile de generare a impulsurilor, vom defini secvențele și vom scrie o funcție care să ușureze schimbarea stării pinilor aferenți. Am ales să modific direct registrul portului în articolul anterior și așa voi face și aici. Acest lucru înseamnă că nu poți schimba pinii pe care sunt generate impulsurile fără a modifica (uneori semnificativ) codul. La plăcile de dezvoltare Arduino cu ATmega328, poți folosi porturile B și D. Eu am ales biții 3:0 ai portului B, care reprezintă pinii digitali D8-D11.
const uint8_t wavePulse[4] = { B00000001, B00000010, B00000100, B00001000 };
const uint8_t halfPulse[8] = { B00000001, B00000011, B00000010, B00000110,
B00000100, B00001100, B00001000, B00001001
};
const uint8_t fullPulse[4] = { B00000011, B00000110, B00001100, B00001001 };
uint8_t stepIndex = 0;
void pulseWrite(const uint8_t currentPulse) {
uint8_t port = PORTB;
port &= 0xF0; // renunțare la biții 3:0, păstrare biți 7:4
port |= currentPulse;
PORTB = port;
}
Variabila stepIndex este necesară funcțiilor ce urmează. Dacă oprim motorul după un număr de pași care nu este multiplu de 4, la următoarea pornire trebuie să știm unde am rămas și să continuăm secvența de impulsuri.
Wave drive
O singură bobină este activă la orice moment în acest mod.
Impulsuri wave drive
Funcția care generează aceste impulsuri este următoarea:
void waveDrive(uint16_t numSteps, uint16_t stepDelayMs = 5, bool backwards = false) {
uint8_t sequence = 0;
numSteps += stepIndex;
for (uint16_t i = stepIndex; i < numSteps; i++) {
backwards ? sequence = wavePulse[3 - (i & 3)] : sequence = wavePulse[i & 3];
pulseWrite(sequence);
delay(stepDelayMs);
}
stepIndex = numSteps & 3;
}
Half drive
Jumătate din timp, doar o bobină este alimentată. Cealaltă jumătate, două bobine sunt alimentate.
Impulsuri half drive
Funcția care generează aceste impulsuri este următoarea:
void halfDrive(uint16_t numSteps, uint16_t stepDelayMs = 5, bool backwards = false) {
uint8_t sequence = 0;
numSteps += numSteps + stepIndex * 2;
for (uint16_t i = (stepIndex * 2); i < numSteps; i++) {
backwards ? sequence = halfPulse[7 - (i & 7)] : sequence = halfPulse[i & 7];
pulseWrite(sequence);
delay(stepDelayMs);
}
stepIndex = (numSteps / 2) & 3;
}
Full drive
În orice moment, două bobine sunt active în acest mod.
Impulsuri full drive
Funcția care generează aceste impulsuri este următoarea:
void fullDrive(uint16_t numSteps, uint16_t stepDelayMs = 5, bool backwards = false) {
uint8_t sequence = 0;
numSteps += stepIndex;
for (uint16_t i = stepIndex; i < numSteps; i++) {
backwards ? sequence = fullPulse[3 - (i & 3)] : sequence = fullPulse[i & 3];
pulseWrite(sequence);
delay(stepDelayMs);
}
stepIndex = numSteps & 3;
}
Concluzie
Nu este foarte greu să generezi impulsurile de acționare a unui motor pas cu pas, fără a folosi o bibliotecă Arduino. Cele trei funcții prezentate mai sus pot acționa atât motoare pas cu pas unipolare, cât și bipolare, permițând schimbarea direcției de rotație. Parametrul numSteps reprezintă numărul de pași de efectuat (de exemplu, pentru un motor cu 1,8 grade/pas, dacă numSteps este 200 se va efectua o rotație completă), stepDelayMs este durata unui impuls în milisecunde, iar backwards activează rotirea în sens opus. Pentru aceeași valoare a stepDelayMs, un motor acționat în modul half drive se va roti de două ori mai încet. Schița completă cu funcțiile de mai sus poate fi găsită pe GitHub.
Niciun comentariu :
Trimiteți un comentariu
Vă recomandăm să citiți regulamentul comentariilor înainte de a scrie un comentariu.