Perbandingan Driver Motor: L298N, L293D, TB6612FNG, A4988
Perbandingan L298N, L293D, L9110S, TB6612FNG, dan A4988: arus, jatuh tegangan, efisiensi, dan kompatibilitas 3,3 V, plus pilihan untuk mobil robot dan motor stepper.
Ketika membandingkan driver motor, pertanyaan pertama yang perlu dijawab adalah: berapa arus yang ditarik motormu, di tegangan berapa motor itu bekerja, dan level logika berapa (5 V atau 3,3 V) yang dipakai board-mu? Lima driver yang paling sering dipakai para hobiis adalah L298N, L293D, L9110S, TB6612FNG, dan A4988. Jawaban singkatnya: TB6612FNG paling cocok untuk mobil robot kecil bertenaga baterai, L298N untuk motor 12 V yang menarik 1–2 A, L9110S untuk bujet paling hemat, shield L293D untuk menggerakkan empat motor dari satu board di Arduino Uno, dan A4988 untuk motor stepper bipolar seperti NEMA 17.
Di panduan ini kita akan melihat berapa arus yang benar-benar bisa diberikan tiap driver, berapa tegangan yang hilang di dalamnya, apa pengaruh kehilangan itu terhadap umur baterai dan panas, serta seberapa baik driver itu bekerja dengan board 3,3 V seperti ESP32 dan Raspberry Pi Pico. Kamu juga akan menemukan kode yang berfungsi untuk menggerakkan dua motor yang sama dengan Arduino, ESP32, dan Pico, contoh motor stepper dengan A4988, serta tabel pemilihan per proyek.

Apa itu driver motor dan kenapa kamu membutuhkannya?
Satu pin digital Arduino hanya bisa memberikan arus maksimal sekitar 20–40 mA. Bahkan motor gearbox TT kecil menarik 150–250 mA ketika berputar dan hampir 1 A ketika macet (stall). Menghubungkan motor langsung ke pin akan merusak pin itu, dan lonjakan tegangan balik yang dihasilkan motor bisa membuat mikrokontroler reset. Driver motor adalah rangkaian sakelar yang menerima sinyal lemah dari mikrokontroler lalu memberi daya ke motor dari catu daya terpisah. Inti dari driver motor DC adalah H-bridge: dengan menyalakan dan mematikan empat sakelar secara berpasangan menyilang, polaritas di kedua ujung motor terbalik, sehingga motor berputar maju atau mundur. Kecepatan diatur dengan sinyal PWM yang menyalakan dan mematikan sakelar itu ribuan kali per detik. Driver stepper melangkah lebih jauh lagi: driver ini memberi energi ke kumparan secara berurutan sambil membatasi arus, sehingga motor berputar dengan sudut yang presisi.
Sekilas tentang lima driver
- L298N: H-bridge dua kanal bertransistor bipolar yang sudah tua tapi sangat umum. Driver ini tahan tegangan tinggi (5–35 V pada modul) dan bisa mencapai 2 A per kanal, tapi kehilangan 2–3 V dan jadi sangat panas. Untuk detailnya, lihat Mengendalikan Motor DC dengan L298N.
- L293D: Chip DIP 16 pin dengan arus kontinu 600 mA dan arus puncak 1,2 A per kanal, plus dioda proteksi bawaan. Chip ini terkenal lewat Motor Shield L293D, yang dibuat untuk Arduino Uno dan menggerakkan empat motor DC.
- L9110S: Pilihan paling murah dan paling kecil. Bekerja di 2,5–12 V dan memberikan sekitar 800 mA per kanal; tidak ada pin enable, jadi tiap motor dikendalikan dengan dua pin. Selengkapnya di artikel driver motor L9110S.
- TB6612FNG: H-bridge modern berbasis MOSFET. Memberikan arus kontinu 1,2 A dan arus puncak 3,2 A per kanal dengan hambatan nyala sekitar 0,5 ohm, jadi hampir tidak panas dan bekerja lancar dengan level logika mulai 2,7 V.
- A4988: Bukan driver motor DC, melainkan driver stepper bipolar. Menawarkan tegangan motor 8–35 V, batas arus yang bisa diatur, dan microstepping hingga 1/16. Cara pemasangannya dijelaskan langkah demi langkah di artikel driver motor stepper A4988.
Tabel perbandingan: arus, tegangan, kompatibilitas 3,3 V, dan harga
| Fitur | L298N | L293D | L9110S | TB6612FNG | A4988 |
|---|---|---|---|---|---|
| Jenis motor | 2 DC atau 1 stepper bipolar | 2 DC atau 1 stepper bipolar | 2 DC | 2 DC atau 1 stepper bipolar | 1 stepper bipolar |
| Tegangan motor | 5–35 V (modul) | 4,5–36 V | 2,5–12 V | 4,5–13,5 V (maksimum mutlak 15 V) | 8–35 V |
| Arus kontinu (per kanal) | 2 A (dengan heatsink) | 0,6 A | sekitar 0,8 A | 1,2 A | sekitar 1 A tanpa heatsink, 2 A dengan pendinginan |
| Arus puncak | 3 A | 1,2 A | sekitar 1,5 A | 3,2 A | 2 A |
| Teknologi sakelar | Transistor bipolar | Transistor bipolar | Transistor (saturasi rendah) | MOSFET | MOSFET + kendali arus |
| Jatuh tegangan | sekitar 2–3 V | sekitar 1,8–2,6 V | sekitar 1 V | sekitar 0,5 V (pada 1 A) | Dikendalikan arus, tidak jadi masalah |
| Efisiensi | Rendah | Rendah | Sedang | Tinggi | Tinggi |
| Catu logika | 5 V (regulator di modul) | 4,5–7 V (VCC1) | Bersama dengan catu motor | 2,7–5,5 V (VCC) | 3–5,5 V (VDD) |
| Kompatibilitas sinyal 3,3 V | Biasanya berfungsi | Input menerimanya, catu logika 5 V | Kompatibel penuh | Kompatibel penuh | Kompatibel penuh |
| Harga (relatif) | Rendah | Rendah | Sangat rendah | Sedang | Rendah |
Nilai arus di tabel adalah batas dari datasheet; dalam praktiknya, zona aman sekitar 70% dari nilai itu. Misalnya, 2 A pada L298N hanya mungkin dengan heatsink besar dan aliran udara yang baik; kalau modul tanpa heatsink terus-menerus dipaksa di atas 1 A, chip-nya cepat panas dan masuk proteksi termal. Untuk mengetahui kebutuhan nyata sebuah motor, jangan lihat arus kerjanya, tapi lihat arus stall (macet): ketika roda menabrak rintangan, motor menarik arus ini, dan driver harus bisa menahannya, setidaknya dalam waktu singkat. Kolom harga hanyalah urutan relatif: L9110S biasanya modul paling murah, sedangkan TB6612FNG sedikit lebih mahal tapi lebih dari sebanding berkat efisiensi dan ukurannya yang kecil.
Jatuh tegangan dan efisiensi: kenapa L298N sangat panas?
Pada driver bertransistor bipolar (L298N, L293D), arus melewati dua transistor sebelum sampai ke motor, dan di tiap transistor hilang sekitar 1–1,5 V. Kehilangan ini berubah menjadi panas: daya yang hilang dihitung dengan P = V_drop × I. Pada TB6612FNG yang berbasis MOSFET, sakelarnya berperilaku seperti resistor dan kehilangannya P = I² × R_on; untuk 0,5 ohm dan 1 A hasilnya hanya 0,5 W. Pada sistem baterai bertegangan rendah, perbedaannya sangat besar: kehilangan 2 V dari paket baterai 6 V berarti membuang sepertiga daya motor. Kamu bisa mengulang perhitungan untuk motormu sendiri dengan kalkulator hukum Ohm dan memperkirakan umur baterai dengan kalkulator umur baterai. Tabel di bawah menunjukkan nilai tipikal untuk catu 6 V dan arus motor 0,6 A:
| Driver | Kehilangan tegangan tipikal | Tegangan yang tersisa untuk motor | Daya yang terbuang jadi panas di driver | Perkiraan efisiensi |
|---|---|---|---|---|
| L298N | 1,8 V | 4,2 V | 1,08 W | 70% |
| L293D | 2,0 V | 4,0 V | 1,2 W | 67% |
| L9110S | 0,8 V | 5,2 V | 0,48 W | 87% |
| TB6612FNG | 0,3 V | 5,7 V | 0,18 W | 95% |
Kompatibilitas 3,3 V: driver mana untuk ESP32 dan Raspberry Pi Pico?
Pin ESP32 dan Pico mengeluarkan 3,3 V. Karena catu logika TB6612FNG (VCC) bisa langsung dihubungkan ke 3,3 V, driver ini adalah pasangan paling rapi untuk board-board tersebut. Input logika A4988 juga bekerja di 3–5,5 V, dan input L9110S membaca sinyal 3,3 V tanpa masalah. Pada L298N dan L293D, ambang input level tinggi minimal 2,3 V, jadi sinyal 3,3 V biasanya berfungsi, tapi bagian logika chip-nya butuh catu 5 V, dan bekerja terlalu dekat dengan ambang bisa memicu kesalahan di lingkungan yang banyak derau. Singkatnya: kalau kamu memulai proyek ESP32 atau Pico baru, mulailah dengan TB6612FNG; kalau kamu sudah punya L298N, biasanya itu juga bisa dipakai, tapi jangan pernah lupa menyambungkan ground bersama.
Pengkabelan: tabel pin L298N dan TB6612FNG
| Fungsi | Pin L298N | Pin TB6612FNG | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|---|---|
| Kecepatan motor A (PWM) | ENA | PWMA | D5 | GPIO 25 | GP16 |
| Arah motor A 1 | IN1 | AIN1 | D4 | GPIO 26 | GP17 |
| Arah motor A 2 | IN2 | AIN2 | D7 | GPIO 27 | GP18 |
| Kecepatan motor B (PWM) | ENB | PWMB | D6 | GPIO 13 | GP21 |
| Arah motor B 1 | IN3 | BIN1 | D8 | GPIO 33 | GP19 |
| Arah motor B 2 | IN4 | BIN2 | D9 | GPIO 32 | GP20 |
| Standby / pengaktif | Tidak ada | STBY | D10 | GPIO 4 | GP22 |
| Catu logika | +5V (output regulator) | VCC | 5V | 3V3 | 3V3 (OUT) |
| Catu motor | +12V | VM | Catu daya eksternal | Catu daya eksternal | Catu daya eksternal |
| Ground | GND | GND | GND | GND | GND |
Langkah demi langkah: menggerakkan dua motor DC dengan Arduino
- Hubungkan catu motor (misalnya 7,4 V dari dua sel 18650 atau 9 V dari 6×AA) ke input catu motor di driver: +12V pada L298N, VM pada TB6612FNG.
- Hubungkan terminal negatif catu daya ke GND driver sekaligus ke GND Arduino.
- Kalau kamu memakai L298N, lepas jumper di ENA dan ENB; kalau tidak, kecepatan tidak bisa diatur dan motor selalu berputar dengan kecepatan penuh.
- Hubungkan pin PWM ke D5 dan D6, serta pin arah ke D4, D7, D8, dan D9, seperti di tabel. Pada TB6612FNG, hubungkan STBY ke D10 dan VCC ke 5V Arduino.
- Pasang kabel motor ke output OUT1–OUT2 (A01–A02) dan OUT3–OUT4 (B01–B02). Kalau ada motor yang berputar ke arah salah, tukar kabelnya atau balik arahnya di kode.
- Upload kode di bawah dan lakukan tes pertama dengan roda terangkat dari lantai.
1// L298N ya da TB6612FNG ile iki DC motor / Two DC motors with L298N or TB6612FNG
2const int ENA = 5; // PWMA (PWM pini / PWM pin)
3const int IN1 = 4; // AIN1
4const int IN2 = 7; // AIN2
5const int ENB = 6; // PWMB (PWM pini / PWM pin)
6const int IN3 = 8; // BIN1
7const int IN4 = 9; // BIN2
8const int STBY = 10; // yalnız TB6612FNG / TB6612FNG only
9
10// hiz: -255 (tam geri) ... 255 (tam ileri) / speed: -255 (full reverse) ... 255 (full forward)
11void motorSur(int en, int inA, int inB, int hiz) {
12 hiz = constrain(hiz, -255, 255);
13 if (hiz > 0) {
14 digitalWrite(inA, HIGH);
15 digitalWrite(inB, LOW);
16 } else if (hiz < 0) {
17 digitalWrite(inA, LOW);
18 digitalWrite(inB, HIGH);
19 } else {
20 digitalWrite(inA, LOW); // dur / stop
21 digitalWrite(inB, LOW);
22 }
23 analogWrite(en, abs(hiz));
24}
25
26// Kısa devre freni: iki giriş HIGH / Short brake: both inputs HIGH
27void fren(int en, int inA, int inB) {
28 digitalWrite(inA, HIGH);
29 digitalWrite(inB, HIGH);
30 analogWrite(en, 255);
31}
32
33void setup() {
34 pinMode(ENA, OUTPUT);
35 pinMode(IN1, OUTPUT);
36 pinMode(IN2, OUTPUT);
37 pinMode(ENB, OUTPUT);
38 pinMode(IN3, OUTPUT);
39 pinMode(IN4, OUTPUT);
40 pinMode(STBY, OUTPUT);
41 digitalWrite(STBY, HIGH); // TB6612FNG'yi uyandır / wake up the TB6612FNG
42}
43
44void loop() {
45 motorSur(ENA, IN1, IN2, 180); // ileri / forward
46 motorSur(ENB, IN3, IN4, 180);
47 delay(2000);
48
49 fren(ENA, IN1, IN2); // fren / brake
50 fren(ENB, IN3, IN4);
51 delay(500);
52
53 motorSur(ENA, IN1, IN2, -180); // geri / reverse
54 motorSur(ENB, IN3, IN4, -180);
55 delay(2000);
56
57 motorSur(ENA, IN1, IN2, 180); // yerinde dönüş / spin in place
58 motorSur(ENB, IN3, IN4, -180);
59 delay(1000);
60
61 motorSur(ENA, IN1, IN2, 0); // dur / stop
62 motorSur(ENB, IN3, IN4, 0);
63 delay(1000);
64}Enaknya kode ini, susunan pinnya sama dan bisa dipakai untuk L298N maupun TB6612FNG; tabel logika kedua driver hampir identik. Ketika satu pin arah HIGH dan yang lain LOW, motor berputar; nilai PWM (0–255) menentukan kecepatannya. Ketika kedua pin arah dibuat HIGH, terminal motor terhubung singkat dan motor mengerem dengan tegangan yang dihasilkannya sendiri, sehingga robot bisa berhenti dalam jarak lebih pendek di tanjakan atau ketika melaju kencang. Pin D5 dan D6 pada Uno menghasilkan PWM sekitar 980 Hz; dengung halus dari motor di frekuensi ini wajar. Dengan L298N kamu akan melihat motor tidak berputar pada nilai PWM yang sangat rendah (di bawah sekitar 60), karena setelah dikurangi kehilangan di driver, tegangan rata-rata yang tersisa untuk motor tidak cukup untuk melawan gesekan.
ESP32 dengan TB6612FNG: PWM 20 kHz tanpa suara
Di ESP32, memakai unit PWM hardware LEDC alih-alih analogWrite membuatmu bisa memilih frekuensi sendiri. Karena TB6612FNG menerima PWM hingga 100 kHz, menaikkan frekuensi ke 20 kHz memindahkannya ke rentang yang tidak bisa didengar telinga manusia, dan dengung motor hilang sama sekali. Kode di bawah bisa dikompilasi di ESP32 Arduino core 2.x maupun 3.x; fungsi LEDC yang berbeda antarversi dipisahkan dengan blok kompilasi bersyarat. Jangan lupa menghubungkan pin VCC TB6612FNG ke pin 3V3 ESP32.
1#include <Arduino.h>
2
3// ESP32 + TB6612FNG pinleri / ESP32 + TB6612FNG pins
4const int PWMA = 25, AIN1 = 26, AIN2 = 27;
5const int PWMB = 13, BIN1 = 33, BIN2 = 32;
6const int STBY = 4;
7
8const int PWM_FREQ = 20000; // 20 kHz: duyulmayan PWM / inaudible PWM
9const int PWM_RES = 8; // 0-255 çözünürlük / 0-255 resolution
10
11void pwmBaslat(int pin, int kanal) {
12#if ESP_ARDUINO_VERSION_MAJOR >= 3
13 ledcAttach(pin, PWM_FREQ, PWM_RES); // core 3.x
14 (void)kanal;
15#else
16 ledcSetup(kanal, PWM_FREQ, PWM_RES); // core 2.x
17 ledcAttachPin(pin, kanal);
18#endif
19}
20
21void pwmYaz(int pin, int kanal, int deger) {
22#if ESP_ARDUINO_VERSION_MAJOR >= 3
23 ledcWrite(pin, deger);
24 (void)kanal;
25#else
26 ledcWrite(kanal, deger);
27 (void)pin;
28#endif
29}
30
31// hiz: -255 ... 255 / speed: -255 ... 255
32void motor(int pwmPin, int kanal, int in1, int in2, int hiz) {
33 hiz = constrain(hiz, -255, 255);
34 digitalWrite(in1, hiz > 0 ? HIGH : LOW);
35 digitalWrite(in2, hiz < 0 ? HIGH : LOW);
36 pwmYaz(pwmPin, kanal, abs(hiz));
37}
38
39void setup() {
40 pinMode(AIN1, OUTPUT);
41 pinMode(AIN2, OUTPUT);
42 pinMode(BIN1, OUTPUT);
43 pinMode(BIN2, OUTPUT);
44 pinMode(STBY, OUTPUT);
45 digitalWrite(STBY, HIGH); // sürücüyü etkinleştir / enable the driver
46 pwmBaslat(PWMA, 0);
47 pwmBaslat(PWMB, 1);
48}
49
50void loop() {
51 for (int h = 0; h <= 255; h += 5) { // yumuşak hızlanma / soft acceleration
52 motor(PWMA, 0, AIN1, AIN2, h);
53 motor(PWMB, 1, BIN1, BIN2, h);
54 delay(30);
55 }
56 delay(1500);
57 motor(PWMA, 0, AIN1, AIN2, -200); // geri / reverse
58 motor(PWMB, 1, BIN1, BIN2, -200);
59 delay(1500);
60 motor(PWMA, 0, AIN1, AIN2, 0); // dur / stop
61 motor(PWMB, 1, BIN1, BIN2, 0);
62 delay(1000);
63}Raspberry Pi Pico dan MicroPython dengan TB6612FNG
Semua pin GPIO Pico bisa menghasilkan PWM hardware, dan di MicroPython duty cycle diberikan sebagai angka 16-bit (0–65535). Pada contoh di bawah, kecepatan dimasukkan dalam persen (dari -100 sampai 100) dan fungsinya mengubah nilai itu menjadi nilai duty_u16. Karena GP16 dan GP21 berada di slice PWM yang berbeda, frekuensi kedua motor tidak saling memengaruhi. Hubungkan pin VCC TB6612FNG ke pin 3V3 (OUT) Pico dan pin VM ke catu motor eksternal; memberi daya ke motor dari pin VSYS Pico akan membuat board reset karena arus dari USB terbatas.
1from machine import Pin, PWM
2import time
3
4stby = Pin(22, Pin.OUT, value=1) # sürücüyü uyandır / wake the driver
5
6pwma = PWM(Pin(16))
7pwma.freq(20000) # 20 kHz sessiz PWM / quiet PWM
8ain1 = Pin(17, Pin.OUT)
9ain2 = Pin(18, Pin.OUT)
10
11pwmb = PWM(Pin(21))
12pwmb.freq(20000)
13bin1 = Pin(19, Pin.OUT)
14bin2 = Pin(20, Pin.OUT)
15
16def motor(pwm, in1, in2, hiz): # hiz: -100 ... 100 / speed in percent
17 hiz = max(-100, min(100, hiz))
18 in1.value(1 if hiz > 0 else 0)
19 in2.value(1 if hiz < 0 else 0)
20 pwm.duty_u16(int(abs(hiz) * 65535 / 100))
21
22while True:
23 motor(pwma, ain1, ain2, 70) # ileri / forward
24 motor(pwmb, bin1, bin2, 70)
25 time.sleep(2)
26 motor(pwma, ain1, ain2, -70) # geri / reverse
27 motor(pwmb, bin1, bin2, -70)
28 time.sleep(2)
29 motor(pwma, ain1, ain2, 0) # dur / stop
30 motor(pwmb, bin1, bin2, 0)
31 time.sleep(1)Motor stepper dengan A4988: batas arus dan pengaturan Vref
L298N dan L293D juga bisa menggerakkan stepper bipolar dengan dua H-bridge, tapi karena tidak bisa membatasi arus, motornya bisa kurang tenaga di tegangan rendah atau kepanasan di tegangan tinggi. A4988 terus-menerus mengukur arus kumparan dan menjaganya tetap konstan (penggerak chopper), sehingga motor NEMA 17 2,8 V pun bisa digerakkan dengan aman dan bertorsi tinggi dari catu 12 V atau 24 V. Batas arus diatur dengan trimpot kecil di board, dan rumusnya: I_max = Vref / (8 × Rs). Rs adalah resistor sensor arus di board; banyak board klon bertuliskan R100 (0,1 ohm), dan sebagian R068 (0,068 ohm). Misalnya, pada board 0,1 ohm, untuk 1 A kamu butuh Vref = 1 × 8 × 0,1 = 0,8 V; untuk menyisakan margin panas, sekitar 0,56 V (70%) adalah titik awal yang baik. A4988 dikendalikan hanya dengan dua pin: tiap pulsa di pin STEP berarti satu langkah, dan pin DIR menentukan arah. Dengan MS1, MS2, dan MS3 LOW, driver bekerja dalam langkah penuh, dan motor 1,8 derajat butuh 200 langkah per putaran. Ingat untuk menghubungkan SLEEP dan RESET satu sama lain, serta memasang kapasitor minimal 100 µF di antara VMOT dan GND.
1// A4988 ile NEMA 17 step motor / NEMA 17 stepper with A4988
2// MS1-MS3 LOW = tam adım, SLEEP ile RESET birbirine bağlı / MS1-MS3 LOW = full step, SLEEP tied to RESET
3const int DIR_PIN = 2;
4const int STEP_PIN = 3;
5const int ADIM_TUR = 200; // 1,8 derece motor / 1.8 degree motor
6
7void adimAt(int adim, bool yon, unsigned int bekleme) {
8 digitalWrite(DIR_PIN, yon ? HIGH : LOW);
9 for (int i = 0; i < adim; i++) {
10 digitalWrite(STEP_PIN, HIGH);
11 delayMicroseconds(bekleme);
12 digitalWrite(STEP_PIN, LOW);
13 delayMicroseconds(bekleme);
14 }
15}
16
17void setup() {
18 pinMode(DIR_PIN, OUTPUT);
19 pinMode(STEP_PIN, OUTPUT);
20}
21
22void loop() {
23 adimAt(ADIM_TUR, true, 800); // saat yönünde 1 tur / one turn clockwise
24 delay(1000);
25 adimAt(ADIM_TUR, false, 800); // ters yönde 1 tur / one turn counter-clockwise
26 delay(1000);
27}Driver mana untuk proyek apa?
| Proyek | Driver yang disarankan | Kenapa? |
|---|---|---|
| Mobil robot dengan 2 motor TT (bertenaga baterai) | TB6612FNG (L9110S kalau bujet terbatas) | Kehilangan rendah, umur baterai panjang, ukuran kecil |
| Mobil 4 roda dengan Arduino Uno | Shield L293D atau L298N | 4 motor di satu board; dengan L298N, 2 motor di tiap sisi dirangkai paralel |
| Motor bergearbox 12 V (1–2 A) | L298N (dengan heatsink) | Tahan tegangan dan arus tinggi; untuk motor yang lebih besar, beralih ke driver MOSFET seperti BTS7960 |
| Stepper NEMA 17 (printer 3D, CNC, slider) | A4988 | Batas arus dan microstepping |
| Stepper 28BYJ-48 | Board ULN2003 | Motor unipolar, langsung kompatibel dengan 5 V |
| Pompa air mini 6 V satu arah | MOSFET logic-level atau satu kanal L9110S | H-bridge tidak perlu kalau arahnya tidak pernah berubah |
| Pompa yang bisa berbalik arah atau pompa peristaltik | TB6612FNG | Perubahan arah dan PWM yang efisien |
| Semua proyek motor DC berbasis ESP32 atau Pico | TB6612FNG | Cocok penuh dengan logika 3,3 V |
Contoh pompa ini sangat penting: di sistem penyiraman, pompa selalu berputar ke arah yang sama, jadi satu MOSFET kanal-N dan satu dioda flyback sudah cukup; caranya bisa kamu temukan di artikel Memakai MOSFET dengan Arduino. Pada mobil robot, makin rendah tegangan baterai, makin besar keunggulan driver MOSFET; mobil yang diberi daya dua baterai 18650 akan terlihat jelas lebih cepat dan lebih lama berjalan dengan TB6612FNG dibanding dengan L298N.
Ide proyek dengan driver motor
- Mobil robot yang dikendalikan Bluetooth: Gerakkan dua motor dari ponselmu dengan TB6612FNG atau L298N; langkah-langkahnya ada di artikel Mobil Robot Arduino.
- Robot penghindar rintangan: Kendaraan yang mendeteksi rintangan di depannya dengan HC-SR04 lalu berganti arah; detailnya di artikel Robot Penghindar Rintangan.
- Robot pengikut garis: Di proyek yang butuh respons PWM cepat ini, efisiensi TB6612FNG sangat terasa; coba lihat artikel Robot Pengikut Garis.
- Penyiraman otomatis: Nyalakan pompa mini ketika kelembapan tanah turun; sambungan dayanya dijelaskan di artikel pompa air mini.
- Sistem pelacak matahari: Putar panel ke arah cahaya dengan motor stepper atau motor DC bergearbox; lihat artikel sistem pelacak matahari.
- Pemosisian presisi: Untuk slider kamera atau meja putar yang berputar dengan sudut kecil, mulailah dengan motor stepper 28BYJ-48, lalu naik ke A4988 dan NEMA 17.
Kesalahan umum dan cara memperbaikinya
| Masalah | Kemungkinan penyebab | Solusi |
|---|---|---|
| Arduino reset ketika motor berputar | Motor diberi daya dari 5V Arduino atau catu dayanya lemah | Pakai catu motor terpisah, satukan GND, tambahkan kapasitor 100–470 µF di catu daya |
| Motor sama sekali tidak merespons | Tidak ada GND bersama, atau STBY LOW pada TB6612FNG | Satukan GND, buat pin STBY HIGH |
| Kecepatan tidak berubah, motor selalu di kecepatan penuh | Jumper ENA/ENB masih terpasang di L298N | Lepas jumper-nya, hubungkan ENA/ENB ke pin PWM |
| Motor sangat lambat dan lemah dengan L298N | Kehilangan tegangan 2–3 V di driver | Naikkan tegangan catu atau beralih ke TB6612FNG |
| Motor berdenging nyaring | Frekuensi PWM berada di rentang yang bisa didengar | Naikkan PWM ke 20 kHz di ESP32 atau Pico |
| Stepper bergetar tapi tidak berputar | Pasangan kumparan tertukar atau Vref terlalu rendah | Cari pasangan kumparan dengan multimeter, atur Vref dengan rumus |
| Driver kepanasan lalu mati | Arus stall motor melebihi batas driver | Pilih driver yang lebih kuat, tambahkan heatsink, jangan memaksa motor |
Memilih driver motor yang tepat intinya adalah mengetahui arus motormu, tegangan catunya, dan level logika board-mu. Dengan tiga informasi itu, tabel-tabel di atas akan mengantarmu ke board yang tepat dalam hitungan detik, dan sekarang kamu juga tahu di mana L298N lama di laci masih bisa berguna. Di aplikasi BlueGrays, kamu bisa menjelajahi proyek mobil yang dikendalikan Bluetooth dengan L298N, robot penghindar rintangan, motor stepper, dan penyiraman pintar, lengkap dengan skema rangkaian langkah demi langkah dan kode siap pakai, lalu langsung mulai merakit.
Pertanyaan umum
Mana yang lebih baik, L298N atau TB6612FNG?
Untuk motor bertenaga baterai yang menarik arus di bawah 1 A, TB6612FNG lebih baik; berkat desain MOSFET-nya, driver ini hanya kehilangan sekitar 0,5 V dan hampir tidak panas. L298N lebih dipilih untuk tegangan di atas 13,5 V dan motor yang butuh 1–2 A per kanal. Singkatnya: TB6612FNG untuk robot kecil, L298N untuk motor 12–24 V yang lebih besar.
Kenapa L298N sangat panas?
Karena L298N memakai transistor bipolar, sekitar 2–3 V hilang di dalamnya ketika arus mengalir, dan kehilangan itu berubah menjadi panas. Pada arus 1 A, driver menghasilkan panas sekitar 2 W, itulah sebabnya modul ini dilengkapi heatsink besar. Untuk mengurangi panas, kamu bisa menjaga arus tetap rendah atau beralih ke driver berbasis MOSFET.
Apakah L298N bisa dipakai dengan ESP32?
Bisa. Input L298N menerima minimal 2,3 V sebagai level tinggi, jadi sinyal 3,3 V dari ESP32 biasanya berfungsi. Bagian logika modul harus diberi catu 5 V, dan GND ESP32 serta GND driver wajib disatukan. Tapi untuk proyek baru, TB6612FNG yang kompatibel penuh dengan 3,3 V adalah pilihan yang lebih aman.
Berapa ampere arus yang bisa diberikan L293D?
L293D bisa memberikan arus kontinu 600 mA dan arus puncak 1,2 A per kanal, dan punya dua kanal. Nilai ini cukup untuk motor mainan kecil dan robot ringan, tapi dengan motor yang arus stall-nya melebihi 1 A, chip-nya akan panas dan masuk proteksi termal. Untuk arus yang lebih tinggi, pertimbangkan L298N atau TB6612FNG.
Driver mana yang sebaiknya kupakai untuk motor stepper?
Untuk stepper bipolar 4 kabel seperti NEMA 17, pakai A4988 atau driver lain yang dikendalikan arus; kamu bisa mengatur batas arus dengan Vref dan memakai microstepping. Untuk motor unipolar 5 kabel seperti 28BYJ-48, board ULN2003 adalah solusi paling mudah. L298N bisa menggerakkan stepper bipolar, tapi tidak efisien karena tidak bisa membatasi arus.
Apakah pompa air butuh driver motor?
Kalau pompa hanya berputar ke satu arah, kamu tidak butuh driver motor H-bridge; satu MOSFET logic-level, satu dioda, dan satu resistor sudah cukup. Kalau kamu ingin membalik arah pompa atau mengatur kecepatannya dengan PWM, kamu bisa memakai satu kanal driver seperti L9110S atau TB6612FNG. Dalam semua kasus, beri daya ke pompa dari catu daya terpisah, bukan dari pin Arduino.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Mobil Kendali Bluetooth dengan L298N
Jadikan ponselmu remote dan kendarai mobil robotmu sendiri. Arduino menerima perintah dari aplikasi remote control di ponselmu lewat modul Bluetooth dan memutar roda dengan driver motor; mobil maju…

Robot Penghindar Rintangan
Bagaimana kalau membuat kendaraan pintar yang mencari jalannya sendiri? Robot Penghindar Rintangan terus memindai sekelilingnya berkat sensor ultrasonik di depannya.

Menggunakan Motor Stepper
Motor yang berputar selangkah demi selangkah, persis sejauh yang kamu mau, seperti jarum jam.

Servo 360 Derajat dari Motor Stepper
Ajari motor stepper biasa untuk pergi ke sudut mana pun yang kamu mau, satu lingkaran penuh.

Stasiun Penyiraman Pintar
Tukang kebun yang menyiram tanamanmu sendiri, supaya tanaman tidak kering ketika kamu berlibur.

LED Fade dengan PWM ESP32
Mengubah kecerahan LED secara halus dari 0 ke maksimum, dan dari maksimum ke 0. Kita mengendalikan PWM dengan analogWrite() seperti di Arduino; sintaks yang sama bekerja tanpa masalah di ESP32 Arduino Core 3.0+. Definisi pin + pinMode + analogWrite sudah cukup.

LED Fade PWM Raspberry Pi Pico (Efek Bernapas)
LED tidak lagi sekadar berkedip, ia bernapas! Dengan PWM (Pulse Width Modulation) Pico, kecerahan LED naik lalu turun perlahan, seperti lampu MacBook yang tidur. Pelajari kelas machine.PWM, duty_u16() (kecerahan 16-bit 0–65535), frekuensi PWM (freq(1000): 1000 siklus per detik, tanpa kedipan terlihat), loop range() bertahap, dan output mirip analog dari pin digital. PWM juga dipakai untuk warna RGB, motor, servo, dan buzzer.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

