L293D to prosty, niedrogi i popularny sterownik z dwoma mostkami H. Umożliwia sterowanie za pomocą Arduino kierunkiem obrotów i prędkością dwóch silników prądu stałego lub obsługę jednego niewielkiego, bipolarnego silnika krokowego.
Czym jest L293D i dlaczego warto go używać z Arduino?
L293D zawiera dwa niezależne mostki H. Każdy z nich może sterować jednym silnikiem DC w obu kierunkach lub jednym uzwojeniem silnika krokowego. Jeden układ pozwala więc obsługiwać dwa silniki DC albo jeden bipolarny silnik krokowy.
Sterownik współpracuje z logiką 5 V, dlatego można go bezpośrednio połączyć między innymi z Arduino Uno, Nano lub Leonardo. Napięcie zasilania silników może wynosić maksymalnie około 36 V. Wbudowane diody zabezpieczają układ przed przepięciami indukcyjnymi powstającymi podczas wyłączania silników.
Maksymalny ciągły prąd wyjściowy L293D wynosi około 600 mA na kanał, a krótkotrwały prąd szczytowy może sięgać około 1,2 A. Przed podłączeniem silnika należy sprawdzić nie tylko jego nominalny pobór prądu, lecz także znacznie wyższy prąd rozruchowy i prąd przy zatrzymanym wale.
L293D wykorzystuje tranzystory bipolarne, dlatego występuje na nim zauważalny spadek napięcia. Przy większym obciążeniu napięcie rzeczywiście docierające do silnika może być wyraźnie niższe od napięcia podanego na wejście zasilania VS.
Układ sprawdza się przede wszystkim w takich zastosowaniach jak:
- proste roboty mobilne z napędem różnicowym,
- małe platformy jeżdżące, roboty line follower i roboty sumo,
- projekty edukacyjne wymagające regulacji kierunku oraz prędkości silników DC.
Rozkład pinów L293D – opis wyprowadzeń
L293D ma 16 wyprowadzeń, które odpowiadają za zasilanie, sterowanie mostkami oraz podłączenie silników. Najważniejsze grupy pinów to:
- dwa piny zasilania części logicznej i silników,
- cztery piny masy,
- dwa wejścia ENABLE przeznaczone do włączania kanałów i sterowania sygnałem PWM,
- cztery wejścia INPUT odpowiadające za kierunek obrotów,
- cztery wyjścia OUTPUT przeznaczone do podłączenia silników.
Funkcje wyprowadzeń w standardowej obudowie DIP-16 przedstawia poniższa tabela:
| Pin | Oznaczenie | Funkcja |
|---|---|---|
| 1 | ENABLE 1,2 | Włącza pierwszy mostek obsługujący wyjścia 1Y i 2Y. Połączenie z pinem PWM Arduino umożliwia regulację prędkości. |
| 2 | INPUT 1 | Pierwsze wejście sterujące kierunkiem obrotów silnika 1. |
| 3 | OUTPUT 1 | Wyjście podłączane do pierwszego przewodu silnika 1. |
| 4 i 5 | GND | Masa układu, Arduino i zasilacza silników. |
| 6 | OUTPUT 2 | Wyjście podłączane do drugiego przewodu silnika 1. |
| 7 | INPUT 2 | Drugie wejście sterujące kierunkiem obrotów silnika 1. |
| 8 | VS lub VCC2 | Zasilanie silników, zwykle 6–12 V, maksymalnie około 36 V. |
| 9 | ENABLE 3,4 | Włącza drugi mostek obsługujący wyjścia 3Y i 4Y. Może odbierać sygnał PWM. |
| 10 | INPUT 3 | Pierwsze wejście sterujące kierunkiem obrotów silnika 2. |
| 11 | OUTPUT 3 | Wyjście podłączane do pierwszego przewodu silnika 2. |
| 12 i 13 | GND | Kolejne wyprowadzenia masy, połączone ze wspólną masą układu. |
| 14 | OUTPUT 4 | Wyjście podłączane do drugiego przewodu silnika 2. |
| 15 | INPUT 4 | Drugie wejście sterujące kierunkiem obrotów silnika 2. |
| 16 | VSS lub VCC1 | Zasilanie części logicznej, zwykle 5 V z Arduino. |
W konfiguracji z dwoma silnikami DC pierwszy silnik podłącza się do pinów 3 i 6, a drugi do pinów 11 i 14 układu L293D.
Zasilanie i wspólna masa – absolutna podstawa
L293D korzysta z dwóch niezależnych gałęzi zasilania:
| Wejście | Zastosowanie | Typowe napięcie |
|---|---|---|
| VSS, pin 16 | Zasilanie części logicznej | 5 V z Arduino |
| VS, pin 8 | Zasilanie silników | Zwykle 6–12 V, maksymalnie około 36 V |
Nie należy zasilać silników bezpośrednio z pinu 5V Arduino. Silniki powinny korzystać z osobnego źródła o napięciu i wydajności prądowej dopasowanych do ich parametrów.
Wszystkie elementy układu muszą mieć wspólną masę. Należy połączyć ze sobą:
- pin GND Arduino,
- ujemny biegun zasilacza silników,
- piny 4, 5, 12 i 13 układu L293D.
Bez wspólnej masy sygnały logiczne z Arduino nie mają prawidłowego punktu odniesienia. Sterownik może wtedy nie reagować, uruchamiać silnik niestabilnie albo działać w sposób nieprzewidywalny.
Dla zwiększenia stabilności zasilania warto zastosować:
- kondensator elektrolityczny 100 µF – między VS i GND, możliwie blisko sterownika, aby ograniczyć spadki napięcia podczas rozruchu;
- kondensatory ceramiczne 100 nF – przy pinach zasilania VSS i VS;
- kondensatory przeciwzakłóceniowe przy silnikach – szczególnie wtedy, gdy ich praca zakłóca działanie układu lub powoduje resetowanie Arduino.
Schemat podłączenia jednego silnika DC
Jeden silnik DC można połączyć z Arduino Uno i układem L293D w następującej kolejności:
- połącz masy – podłącz GND Arduino, ujemny biegun zasilacza silnika oraz piny 4, 5, 12 i 13 L293D do wspólnej szyny masy;
- podłącz zasilanie logiki – połącz pin 5V Arduino z pinem 16 VSS układu L293D;
- podłącz zasilanie silnika – połącz dodatni biegun zasilacza, na przykład 9 V, z pinem 8 VS i umieść kondensator 100 µF między VS a GND;
- podłącz silnik – połącz jego przewody z pinami 3 OUTPUT1 i 6 OUTPUT2;
- podłącz wejścia kierunku – połącz pin D8 Arduino z pinem 2 INPUT1, a pin D7 z pinem 7 INPUT2;
- podłącz wejście ENABLE – połącz pin D9 Arduino obsługujący PWM z pinem 1 ENABLE 1,2.
Sygnały z pinów D8 i D7 określają kierunek obrotów, natomiast PWM z pinu D9 reguluje prędkość silnika.
Schemat podłączenia dwóch silników DC
Aby wykorzystać oba mostki dostępne w L293D, wykonaj następujące połączenia:
- podłącz zasilanie i masę – połącz VSS z napięciem 5 V, VS z osobnym zasilaniem silników, a wszystkie piny GND ze wspólną masą Arduino i zasilacza;
- podłącz silnik 1 – przewody silnika połącz z pinami 3 i 6, wejścia kierunku z pinami 2 i 7, a pin 1 ENABLE z wyjściem PWM D9 Arduino;
- podłącz silnik 2 – przewody silnika połącz z pinami 11 i 14, wejścia kierunku z pinami 10 i 15, a pin 9 ENABLE z wyjściem PWM D5 Arduino.
W przedstawionej konfiguracji Arduino D8 steruje INPUT1, D7 steruje INPUT2, D12 steruje INPUT3, a D13 steruje INPUT4. Każdy silnik może mieć niezależnie ustawiony kierunek i prędkość obrotową.
Zależności logiczne – sterowanie kierunkiem silnika
Dla silnika podłączonego do OUTPUT1 i OUTPUT2 kierunek obrotów zależy od stanów INPUT1 i INPUT2. Poniższa tabela obowiązuje przy aktywnym wejściu ENABLE:
| INPUT1 | INPUT2 | Zachowanie silnika |
|---|---|---|
HIGH |
LOW |
Obrót w pierwszym kierunku |
LOW |
HIGH |
Obrót w przeciwnym kierunku |
LOW |
LOW |
Hamowanie dynamiczne |
HIGH |
HIGH |
Hamowanie dynamiczne |
Swobodny wybieg uzyskuje się przez ustawienie pinu ENABLE w stanie LOW. Wyjścia mostka przechodzą wtedy w stan wysokiej impedancji.
Określenia „do przodu” i „do tyłu” są umowne. Jeśli silnik obraca się w kierunku przeciwnym do oczekiwanego, można zamienić miejscami jego przewody albo odwrócić stany logiczne wejść.
Sterowanie prędkością – PWM na pinach ENABLE
Prędkość silnika reguluje się przez zmianę wypełnienia sygnału PWM podawanego na wejście ENABLE odpowiedniego mostka.
Typowa konfiguracja sterowania wygląda następująco:
- wejścia INPUT określają kierunek obrotów za pomocą stanów HIGH i LOW,
- wejście ENABLE jest połączone z wyjściem PWM Arduino, na przykład D3, D5, D6, D9, D10 lub D11 w Arduino Uno,
- funkcja
analogWrite()ustawia wypełnienie PWM w zakresie od 0 do 255.
Najczęściej stosowane wartości sterujące to:
analogWrite(EN, 0);– mostek jest wyłączony, a silnik swobodnie wytraca prędkość;analogWrite(EN, 128);– wypełnienie PWM wynosi około 50%;analogWrite(EN, 255);– mostek pozostaje stale włączony, zapewniając maksymalną dostępną prędkość.
Rzeczywista prędkość zależy również od napięcia zasilania, obciążenia mechanicznego, parametrów silnika i spadku napięcia na L293D. Przy bardzo małym wypełnieniu PWM silnik może nie ruszyć z powodu niewystarczającego momentu rozruchowego.
Przykładowy kod Arduino – sterowanie jednym silnikiem DC
Przykład zakłada następujące połączenia:
- ENABLE 1,2 z pinem D9 obsługującym PWM,
- INPUT1 z pinem D8,
- INPUT2 z pinem D7.
Kod uruchamia silnik w obu kierunkach, demonstruje hamowanie dynamiczne oraz swobodny wybieg:
// Konfiguracja pinów L293D
const int EN1 = 9; // ENABLE 1,2 – PWM
const int IN1 = 8; // INPUT1 – kierunek
const int IN2 = 7; // INPUT2 – kierunek
void setup() {
pinMode(EN1, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
// Początkowo wyłączamy mostek
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
analogWrite(EN1, 0);
}
void loop() {
// Obrót w pierwszym kierunku przy około 50% wypełnienia PWM
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
analogWrite(EN1, 128);
delay(2000);
// Hamowanie dynamiczne
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
analogWrite(EN1, 255);
delay(1000);
// Obrót w przeciwnym kierunku z maksymalnym wypełnieniem
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
analogWrite(EN1, 255);
delay(2000);
// Swobodny wybieg przez wyłączenie mostka
analogWrite(EN1, 0);
delay(2000);
}
Wejścia IN1 i IN2 sterują kierunkiem, a funkcja analogWrite() zmienia wypełnienie PWM na pinie EN1. Ustawienie obu wejść w takim samym stanie przy aktywnym ENABLE powoduje hamowanie dynamiczne. Wartość PWM równa 0 wyłącza mostek i pozwala silnikowi swobodnie wytracić prędkość.
Przed zmianą kierunku warto na krótko zatrzymać silnik. Natychmiastowe odwrócenie kierunku przy dużej prędkości może spowodować gwałtowny wzrost prądu, przeciążenie sterownika i szybsze zużycie elementów mechanicznych.
Przykładowy kod Arduino – dwa silniki z L293D
Do niezależnego sterowania dwoma silnikami potrzeba sześciu sygnałów: czterech wejść kierunku oraz dwóch wyjść PWM do regulacji prędkości.
Poniższy kod uruchamia oba silniki z różnymi prędkościami:
// Silnik 1
const int ENA = 9; // ENABLE 1,2 – PWM
const int IN1 = 8; // INPUT1
const int IN2 = 7; // INPUT2
// Silnik 2
const int ENB = 5; // ENABLE 3,4 – PWM
const int IN3 = 12; // INPUT3
const int IN4 = 13; // INPUT4
void setup() {
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(ENB, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
analogWrite(ENA, 0);
analogWrite(ENB, 0);
}
void forward(int speedA, int speedB) {
// Silnik 1 – pierwszy kierunek
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
analogWrite(ENA, speedA);
// Silnik 2 – pierwszy kierunek
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
analogWrite(ENB, speedB);
}
void loop() {
// Jazda z różnymi prędkościami silników
forward(200, 180);
delay(3000);
// Swobodny wybieg
analogWrite(ENA, 0);
analogWrite(ENB, 0);
delay(1000);
}
Wejścia IN1–IN4 odpowiadają za kierunek obrotów, natomiast ENA i ENB regulują prędkość silników. Różne wartości przekazane do funkcji forward() mogą wyrównać różnice między napędami albo umożliwić skręcanie robota z napędem różnicowym.
L293D a silniki krokowe
L293D może sterować niewielkimi bipolarnymi silnikami krokowymi. Oba mostki H obsługują wtedy dwa uzwojenia silnika: pierwszą cewkę podłącza się do OUTPUT1 i OUTPUT2, a drugą do OUTPUT3 i OUTPUT4.
Kolejne kroki są generowane przez odpowiednie sekwencje stanów na wejściach INPUT1–INPUT4. Sterowanie można zaprogramować samodzielnie lub zrealizować za pomocą odpowiedniej biblioteki Arduino.
Ze względu na ograniczoną wydajność prądową L293D nadaje się przede wszystkim do małych silników krokowych. W przypadku bardziej wymagających modeli lepszym wyborem będą dedykowane sterowniki, takie jak A4988, DRV8825 lub TMC2209, które oferują ograniczanie prądu i obsługę mikrokroków.
Typowe błędy przy podłączaniu L293D do Arduino
Nieprawidłowe zasilanie lub pomylenie wyprowadzeń może powodować niestabilną pracę, przegrzewanie sterownika, resetowanie Arduino, a nawet uszkodzenie podzespołów. Najczęstsze błędy to:
- brak wspólnej masy – bez połączenia mas Arduino, L293D i zasilacza sygnały sterujące nie mają wspólnego punktu odniesienia;
- zasilanie silnika z pinu 5V Arduino – może powodować spadki napięcia, resetowanie mikrokontrolera, przegrzewanie stabilizatora lub uszkodzenie płytki;
- brak kondensatorów filtrujących – zakłócenia i skoki poboru prądu podczas rozruchu mogą destabilizować cały układ;
- pomylenie wejść z wyjściami – piny 2 i 7 są wejściami sterującymi, natomiast 3 i 6 to wyjścia dla silnika;
- niepodłączone piny ENABLE – piny 1 i 9 należy połączyć z napięciem 5 V lub z wyjściami PWM Arduino, nie pozostawiając ich w stanie nieustalonym;
- przekroczenie dopuszczalnego prądu – szczególnie niebezpieczny jest wysoki prąd rozruchowy i prąd pobierany przez silnik z zablokowanym wałem;
- nieuwzględnienie spadku napięcia – silnik może otrzymywać wyraźnie niższe napięcie niż to podane na wejście VS.
Gotowe shieldy z L293D dla Arduino
Zamiast montować L293D na płytce stykowej, można użyć gotowej nakładki typu shield. Takie moduły często obsługują do czterech silników DC oznaczonych jako M1–M4 albo kilka niewielkich silników krokowych.
Shield upraszcza okablowanie, ponieważ może zawierać złącza śrubowe, elementy filtrujące oraz gotowe połączenia z pinami Arduino. Przed zakupem należy sprawdzić rozmieszczenie wykorzystywanych pinów, dostępność kompatybilnej biblioteki i maksymalny dopuszczalny prąd silników.
Gotowy shield nie zwiększa automatycznie wydajności prądowej układu L293D. Jeśli wykorzystuje standardowe sterowniki L293D, nadal obowiązują ich ograniczenia dotyczące prądu, napięcia i strat mocy.
