Obsługa silnika krokowego, sterownik EasyDriver

Home | efekty | arduino | Obsługa silnika krokowego, sterownik EasyDriver

Obsługa silnika krokowego, sterownik EasyDriver

Tomasz Bartuś

2016-01-25

Obsługa silnika krokowego, sterownik EasyDriver

Wstęp

Wiele urządzeń talkich jak drukarki atramentowe, drukarki 3D, frezarki, maszyny CNC i inne, w swojej budowie wykorzystuje silniki krokowe. Z ich budową można zapoznać się tu. W kursie przedstawiam możliwość sterowania typowymi 4 i 6-wejściowymi silnikami krokowymi DC za pomocą popularnego sterownika EasyDriver v44.

Sterowanie silnikiem krokowym — Fig. 1. Układ obsługi silnika krokowego

Hardware

EasyDriver v44 (Fig. 1) to sterownik bipolarnych silników krokowych (schemat). Można go wykorzystać wraz z silnikami 4, 6 lub 8 przewodowymi. Umożliwia obsługę silników z obciążeniem 150-750 mA/cewkę. Domyślnie układ jest zasilany napięciem 5V, ale po zlutowaniu odpowiedniej zworki możliwa jest zmiana napięcia zasialnia na 3,3V. Sterownik umożliwia pracę w 4 trybach: pełny krok, 1/2, 1/4, 1/8. UWAGA! nie należy włączać, bądź wyłączać silników w trakcie zasilania układu. Grozi to jego zniszczeniem.

Sygnały niezbędne do uruchomienia silnika:

GND: EasyDriver posiada 3 wejścia GND (masa). Podłączamy tu "-" zasilania logiki i zasialnia silników.
M+: Pin zasilania układu EasyDriver. Podłączamy tu "+" zasilania. Pin umożliwia podanie napięcia 6-30V, 2A (lub więcej). Napięcie powinno być stabilizowane.
A, B: (4 piny wyjściowe, od lewej: A+, A-, B+, B-) służą do podłączenia silnika (Tab. 1). Litery A i B oznaczają dwie cewki silnika. Do wejścia A podłączamy jedną cewkę, a do wejścia B, drugą cewkę. Zmiana polaryzacji przewodów w cewce A lub B powoduje zminę kierunku obrotów silnika. Należy się upewnić, że złącze jest trwałe. Chwilowe odłączenie może spowodować spalenie układu sterownika.

Tab. 1. Podłączenie sterownika EasyDriver z typowym silnikiem 4-przewodowym
Piny	Podłączenia cewek	Standardowe kolory kabli silników
A1	A "+"	zielony
A2	A "-"	czerwony
B1	B "+"	niebieski
B2	B "-"	żółty

STEP: Wejście logiczne. Wymaga podania cyfrowego sygnału 0-5V (lub 0-3,3V jeżeli EasyDriver został skonfigurowany do pracy w logice 3,3V). Każde zbocze narastające sygnału spowoduje krok (lub mikrokrok) silnika.
DIR (kierunek, direction): Wejście logiczne. Wymaga podania cyfrowego sygnału 0-5V (lub 0-3,3V jeżeli EasyDriver został skonfigurowany do pracy w logice 3,3V). Poziom sygnału (wysoki/niski) jest próbkowany w trakcie każdego narastającego zbocza sygnału STEP w celu określenia kierunku ruchu (kroku lub mikrokroku) silnika.

Sygnały opcjonalne (używane do zmiany ustawień domyślnych sterownika EasyDriver):

MS1/MS2: Wejścia logiczne. Służą do kontroli trybu mikrokroków (Tab. 2)

Tab. 2. Regulacja kroku silnika za pomocą sygnałów MS1 i MS2
MS1	MS2	obroty
0	0	pełen krok
1	0	1/2 kroku
0	1	1/4 kroku
1	1	1/8 kroku

RST (reset): Wejście logiczne. Kiedy podamy na nie logiczne "0", polecenia STEP będą ignorowane. Aby zapewnić normalną pracę sterownika musi zostać podana logiczna "1".
SLP (sleep): Wejście logiczne. Kiedy podamy na nie logiczne "0", wyjścia zostają zablokowane i minimalizowane jest zużycie energii. W trakcie pracy w normalnym trybie, na wejście podawany jest wysoki poziom logiczny.
ENABLE: Wejście logiczne. W trakcie normalnej pracy, na wejście podajmy niski poziom logiczny. Kiedy na wejście zostanie podany wysoki poziom logiczny, sterowanie silnikiem zostanie wyłączone.
PFD: Skomplikowane, odsyłam do noty katalogowej.
5V: Pin wyjściowy. Jeżeli zworka APWR pozostaje rozwarta, może zostać wykorzystany do zasilania układów zewnętznych. Na pinie pojawia się napięcie +5V (lub 3,3V jeżeli EasyDriver został skonfigurowany do pracy w logice 3,3V). Aby zagwarantować poprawną pracę sterownika, max prąd obciążenia może wynosić do 70mA.

Potencjometr umożliwienie wybór max prądu dostarczonego do silnika w zakresie 150-750mA. Ustawienie wymaga znajomości parametrów silnika. Należy sprawdzić w jego nocie katalogowej jaki prąd obsługuje silnik. Jeżeli nie możemy zdobyć takiej informacji, poprawne ustawienie potencjometru należy ustawić ręcznie. Należy ustawić potencjometr w położeniu minimalnym. Następnie należy ostrożnie zmieniać położenie potencjometru. Poszukujemy położenia, w którym silnik będzie się płynnie kręcił ze stałą prędkością, bez szarpnięć i zatrzymań. Staramy się aby prąd był jak najmniejszy. Pozwoli to na ograniczenie ilości ciepła wydzielanego na układzie scalonym sterownika.

Silniki

Aby prawidłowo podłączyć silnik do sterownika musimy rozpoznać pary przewodów wejściowych silnika. Najwygodniejszym sposobem jest zapoznanie się z odpowiednią notą katalogową. Jeżeli nie znamy typu silnika i nie możemy skorzystać z jego dokumentacji, istnieje prosty sposób na określenie par jego przewodów.

Silniki 4-przewodowe

Weź dowolny przewód silnika i sprawdzić jego oporność względem trzech pozostałych wejść. Kabel, z którym pierwszy przewód wykazuje najniższą rezystancję stanowi parę (jest drugim końcem cewki). Pozostałe dwa przewody powinny wykazywać pomiędzy sobą podobną rezystancję jak para pierwsza.

Silniki 6-przewodowe

W silnikach 6-przewodowych, należy określić, które z trzech przewodów stanowią jedną cewkę. Wybierz jeden dowolny przewód i przetestuj jego rezystancję względem wszystkich pozostałych przewodów. Dwa przewody powinny wykazywać w stosunku do niego jakiś opór, a trzy pozostałe nie pokażą żadnego związku. W ten sposób określimy które z przewodów tworzą dwie cewki silnika. W drugim kroku musimy określić, które z trzech przewodów każdej cewki stanowią jej końce. Dla każdej cewki osobno sprawdzamy oporność pomiędzy poszczególnymi przewodami. Kable, pomiędzy którymi opór jest największy stanowią dwa końce cewki. Badanie należy powtórzyć dla drugiej cewki.

Schemat podłączenia typowych silników 4-przewodowych przedstawia Tab. 1.

Lista części

platforma prototypowa Arduino (tu Nano),
płytka prototypowa,
sterownik EasyDriver v44,
silnik krokowy (ze starego napędu DVD),
przewody/mostki,
zasilacz/bateria do zasilania silnika (max 36V).

Schemat ideowy

Silnik krokowy — Fig. 2. Podłączenie silnika krokowego i sterwonika EasyDriver do Arduino

Test 1

W pierwszym przykładzie spowodujemy ruch silnika krokowego najpierw w jedną stronę, a później w drugą. Do sterowania układem EasyDriver potrzebne nam będą dwa sygnały: DIR - wyznaczający kierunek ruchu oraz STEP - sterujący krokami silnika. Silnik od starego napędu DVD zasilano napięciem 6V. Przed przystąpieniem do testów, za pomocą potencjometra w sterowniku EasyDriver wykonano regulację prądu silnika. W tym przypadku obrócono potencjometr na pozycję minimum. Spowodowało to wyraźny spadek temperatury wydzielanej na układzie sterownika.

Kod 1

int stepPIN = 2;
int dirPIN = 3;

void setup(){
  pinMode(stepPIN, OUTPUT);
  pinMode(dirPIN, OUTPUT);
}

void loop(){
  digitalWrite(dirPIN, LOW);     // kierunek 1
  delay(100);
  
  for(int i=0; i<1000; i++){
    digitalWrite(stepPIN, LOW);  // krok do przodu
    digitalWrite(stepPIN, HIGH); // stop
    delayMicroseconds(500);
  }
  
  digitalWrite(dirPIN, HIGH);    // kierunek 2
  delay(100);
  
  for(int i=0; i<1000; i++){
    digitalWrite(stepPIN, LOW);  // krok do przodu
    digitalWrite(stepPIN, HIGH); // stop
    delayMicroseconds(500);
  }
}

Test 2

Drugi przykład przedstawia szereg opcji konfiguracyjnych sterownika EasyDriver. Pomysł szkicu zaczerpnięto z tutoriala Easy Driver Hook-up Guide. Szkic umożliwia sterowanie silnikiem za pomocą portu szeregowego. Program udostępnia testowanie ruchu silnika w następujących trybach:

pełnego kroku, ruch do przodu,
pełnego kroku, ruch do tylu,
mikrokroków: 1/2 kroku, ruch do przodu,
mikrokroków: 1/4 kroku, ruch do przodu,
mikrokroków: 1/8 kroku, ruch do przodu,
pełnego kroku, naprzemienny ruch w jedna i drugą strone.

Kod 2

#define Step 2
#define Dir 3
#define MS1 4
#define MS2 5
#define Enable 6

char user_input;
int state;

void setup() {
  pinMode(Step, OUTPUT);
  pinMode(Dir, OUTPUT);
  pinMode(MS1, OUTPUT);
  pinMode(MS2, OUTPUT);
  pinMode(Enable, OUTPUT);
  resetPins();          // Funkcja przywraca domyślne ustawienia pinów
  Serial.begin(9600);
  Serial.println("Sterowanie silnikiem krokowym");
  Serial.println();

  Serial.println("Wprowadz odpowiednia opcje:");
  Serial.println("1. Tryb mikrokrokow: 1/1 kroku (domyslny), ruch do przodu");
  Serial.println("2. Tryb mikrokrokow: 1/1 kroku (domyslny), ruch do tylu");
  Serial.println("3. Tryb mikrokrokow: 1/2 kroku");
  Serial.println("4. Tryb mikrokrokow: 1/4 kroku"); 
  Serial.println("5. Tryb mikrokrokow: 1/8 kroku");
  Serial.println("6. Ruch w jedna i druga strone (1/1 kroku)");
  Serial.println();
}

void loop() {
  while(Serial.available()){
    user_input = Serial.read();
    digitalWrite(Enable, LOW);       // Otwarcie możliwości obsługi sterownika EasyDriver
    if (user_input =='1') {
      StepMode_1_1();
    } 
    else if(user_input =='2') {
      StepReverse_1_1();
    } 
    else if(user_input =='3') {
      StepMode_1_2();
    } 
    else if(user_input =='4') {
      StepMode_1_4();
    } 
    else if(user_input =='5') {
      StepMode_1_8();
    } 
    else if(user_input =='6') {
      ForwardBackwardStep();
    } 
    else {
      Serial.println("Niepoprawny nr opcji");
    }
    resetPins();
  }
}

// OPCJA 1: Ruch do przodu w trybie pełnego kroku (tryb domyślny)
void StepMode_1_1(){
  Serial.println("Ruch do przodu w trybie pelnego kroku (tryb domyslny");
  digitalWrite(Dir, LOW);       // "0" logiczne na pin DIR: kierunek ruchu silnika (ruch do przodu)
  for(int x=1; x<200; x++)      // 200 kroków do przodu
  {
    digitalWrite(Step, HIGH);   // 1 krok do przodu
    delay(1);
    digitalWrite(Step, LOW);    // przerwa przed następnym krokiem
    delay(1);
  }
  Serial.println("Wprowadz nowa opcje");
  Serial.println();
}

// OPCJA 2: Ruch do tylu w trybie pełnego kroku
void StepReverse_1_1(){
  Serial.println("Ruch do tyłu w trybie pelnego kroku");
  digitalWrite(Dir, HIGH);      // "1" logiczna na pin DIR: kierunek ruchu silnika (ruch do tyłu)
  for(int x=1; x<200; x++)      // 200 kroków do tyłu
  {
    digitalWrite(Step, HIGH);   // 1 krok do tyłu
    delay(1);
    digitalWrite(Step, LOW);    // przerwa przed następnym krokiem
    delay(1);
  }
  Serial.println("Wprowadz nowa opcje");
  Serial.println();
}

// OPCJA 3: Tryb mikrokroków: (1/2 kroku)
void StepMode_1_2(){
  Serial.println("Tryb mikrokrokow (1/2 kroku)");
  digitalWrite(Dir, LOW);       // "0" logiczne na pin DIR: kierunek ruchu silnika (ruch do przodu)
  digitalWrite(MS1, HIGH);      // MS1 = "1" ustawienie trybu o rozdzielczości 1/2 kroku
  digitalWrite(MS2, LOW);       // MS2 = "0" ustawienie trybu o rozdzielczości 1/2 kroku
  for(int x=1; x<400; x++)      // 400 kroków
  {
    digitalWrite(Step, HIGH);   // 1 krok do przodu
    delay(1);
    digitalWrite(Step, LOW);    // przerwa przed następnym krokiem
    delay(1);
  }
  Serial.println("Wprowadz nowa opcje");
  Serial.println();
}

// OPCJA 4: Tryb mikrokroków: (1/4 kroku)
void StepMode_1_4(){
  Serial.println("Tryb mikrokrokow (1/4 kroku)");
  digitalWrite(Dir, LOW);       // "0" logiczne na pin DIR: kierunek ruchu silnika (ruch do przodu)
  digitalWrite(MS1, LOW);       // MS1 = "0" ustawienie trybu o rozdzielczości 1/4 kroku
  digitalWrite(MS2, HIGH);      // MS2 = "1" ustawienie trybu o rozdzielczości 1/4 kroku
  for(int x=1; x<800; x++)      // 800 kroków
  {
    digitalWrite(Step, HIGH);   // 1 krok do przodu
    delay(1);
    digitalWrite(Step, LOW);    // przerwa przed następnym krokiem
    delay(1);
  }
  Serial.println("Wprowadz nowa opcje");
  Serial.println();
}

// OPCJA 5: Tryb mikrokroków: (1/8 kroku)
void StepMode_1_8(){
  Serial.println("Tryb mikrokrokow (1/8 kroku)");
  digitalWrite(Dir, LOW);        // "0" logiczne na pin DIR: kierunek ruchu silnika (ruch do przodu)
  digitalWrite(MS1, HIGH);       // MS1 = "1" ustawienie trybu o rozdzielczości 1/8 kroku
  digitalWrite(MS2, HIGH);       // MS1 = "1" ustawienie trybu o rozdzielczości 1/8 kroku
  for(int x=0; x<1600; x++)      // 1600 kroków
  {
    digitalWrite(Step, HIGH);    // 1 krok do przodu
    delay(1);
    digitalWrite(Step, LOW);     // przerwa przed następnym krokiem
    delay(1);
  }
  Serial.println("Wprowadz nowa opcje");
  Serial.println();
}

// OPCJA 6: Naprzemienny ruch do przodu i do tylu
void ForwardBackwardStep(){
  Serial.println("NaprzemiEnableny ruch do przodu i do tylu");
  for(int x=0; x<10; x++)
  {
    state=digitalRead(Dir);        // Sczytanie stanu pinu DIR
    if(state == HIGH) {            // zmiana stanu pinu DIR
      digitalWrite(Dir, LOW);
    } 
    else if(state == LOW) {
      digitalWrite(Dir, HIGH);
    }
    for(int y=0; y<200; y++) {     // 201 kroków
      digitalWrite(Step, HIGH);    // 1 krok do przodu
      delay(1);
      digitalWrite(Step, LOW);     // przerwa przed następnym krokiem
      delay(1);
    }
  }
  Serial.println("Wprowadz nowa opcje:");
  Serial.println();
}

// Przywracanie ustawień domyslnych
void resetPins(){
  digitalWrite(Step, LOW);
  digitalWrite(Dir, LOW);
  digitalWrite(MS1, LOW);
  digitalWrite(MS2, LOW);
  digitalWrite(Enable, HIGH);
}

Tomasz Bartuś