Pada artikel ini, Anda akan belajar mengontrol motor DC menggunakan papan ESP32 dan ESP8266 NodeMCU yang diprogram dengan MicroPython. Anda akan mempelajari cara membuat motor berputar maju, mundur, berhenti, serta mengatur kecepatannya dengan membuat modul MicroPython khusus. Kita akan menggunakan driver motor L298N, namun driver motor sejenis lainnya juga seharusnya kompatibel.
Komponen yang Diperlukan
Untuk menyelesaikan tutorial ini, Anda memerlukan komponen-komponen berikut:
Gambar
- ESP32 atau ESP8266
- Motor DC mini
- Driver motor L298N
- Sumber daya: 4x baterai AA 1.5V atau bench power supply
- Kapasitor keramik 100nF (opsional)
- 1x sakelar geser SPDT (opsional)
- Kabel jumper
Mengenal Driver Motor L298N
Ada beberapa cara untuk mengontrol motor DC. Metode yang akan kita gunakan di sini cocok untuk kebanyakan motor DC hobi yang memerlukan tegangan operasi 6V atau 12V.
Kita akan menggunakan driver motor L298N yang mampu menangani arus hingga 3A pada 35V. Selain itu, driver ini memungkinkan kita mengendalikan dua motor DC secara bersamaan, sehingga ideal untuk membangun robot. Driver motor L298N ditunjukkan pada gambar berikut:
Pinout Driver Motor L298N
Driver motor ini memiliki blok terminal dua pin di setiap sisinya untuk masing-masing motor: OUT1 dan OUT2 di kiri, serta OUT3 dan OUT4 di kanan.
- OUT1: Terminal + motor DC A
- OUT2: Terminal - motor DC A
- OUT3: Terminal + motor DC B
- OUT4: Terminal - motor DC B
Di bagian bawah, terdapat blok terminal tiga pin: +12V, GND, dan +5V.
- Terminal +12V digunakan untuk memberi daya pada motor.
- Terminal +5V digunakan untuk memberi daya pada chip L298N. Namun, jika jumper terpasang, chip akan dialiri daya dari catu motor, sehingga Anda tidak perlu memasok 5V melalui terminal +5V.
Penting: Meski dinamai terminal +12V, Anda dapat memasok tegangan apa pun antara 5V hingga 35V (namun rentang 6V hingga 12V adalah rekomendasi).
Catatan: Jika Anda memasok lebih dari 12V, Anda harus melepas jumper dan memasok 5V ke terminal +5V.
Dalam tutorial ini, kami akan menggunakan 4 baterai AA 1.5V yang digabungkan menghasilkan sekitar 6V, tetapi Anda dapat menggunakan catu daya lain yang sesuai. Misalnya, Anda dapat menggunakan bench power supply untuk menguji tutorial ini.
Secara ringkas:
- +12V: Terminal tempat Anda menghubungkan catu daya motor.
- GND: Ground dari catu daya.
- +5V: Berikan 5V jika jumper dilepas. Berfungsi sebagai output 5V jika jumper terpasang.
- Jumper: Jika terpasang – menggunakan catu daya motor untuk menyalakan chip. Jika dilepas – Anda perlu menyediakan 5V ke terminal +5V. Jika Anda memasok lebih dari 12V, jumper harus dilepas.
Di kanan bawah, terdapat empat pin input dan dua terminal enable. Pin input digunakan untuk mengontrol arah putaran motor DC, sedangkan pin enable digunakan untuk mengatur kecepatan masing-masing motor.
- IN1: Input 1 untuk Motor A
- IN2: Input 2 untuk Motor A
- IN3: Input 1 untuk Motor B
- IN4: Input 2 untuk Motor B
- EN1: Pin Enable untuk Motor A
- EN2: Pin Enable untuk Motor B
Secara default, terdapat jumper cap pada pin enable. Anda perlu melepas jumper cap tersebut untuk dapat mengontrol kecepatan motor. Jika tidak, motor akan diam atau berputar pada kecepatan maksimum secara konstan.
Baca juga: MicroPython - Sensor Cahaya Lingkungan BH1750 dengan ESP32/ESP8266
Mengontrol Motor DC dengan Driver Motor L298N
Setelah Anda familiar dengan driver motor L298N, mari kita lihat cara menggunakannya untuk mengontrol motor DC.
Pin Enable
Pin enable berfungsi seperti sakelar ON/OFF untuk motor Anda. Contohnya:
- Jika Anda mengirim sinyal HIGH ke pin enable 1, Motor A siap dikendalikan dan berputar pada kecepatan maksimum.
- Jika Anda mengirim sinyal LOW ke pin enable 1, Motor A akan mati.
- Jika Anda mengirim sinyal PWM, Anda dapat mengatur kecepatan motor. Kecepatan motor sebanding dengan duty cycle sinyal PWM. Namun, perlu diingat bahwa untuk duty cycle yang sangat kecil, motor mungkin tidak berputar dan hanya menghasilkan bunyi dengungan (buzz) yang terus-menerus.
Pin Input
Pin input mengontrol arah putaran motor. Input 1 dan input 2 mengontrol Motor A, sedangkan input 3 dan input 4 mengontrol Motor B.
- Jika Anda memberikan LOW ke input1 dan HIGH ke input2, motor akan berputar maju.
- Jika Anda memberikan HIGH ke input1 dan LOW ke input2, motor akan berputar mundur.
Motor B dapat dikontrol dengan metode yang sama, tetapi menggunakan input3 dan input4.
Sebagai contoh, untuk Motor A, logikanya adalah sebagai berikut:
Mengontrol 2 Motor DC – Cocok untuk Membangun Robot
Jika Anda ingin membuat mobil robot dengan 2 motor DC, kedua motor harus berputar ke arah yang spesifik agar robot dapat bergerak maju, mundur, belok kiri, atau belok kanan.
- Untuk membuat robot maju, kedua motor harus berputar maju.
- Untuk membuat robot mundur, kedua motor harus berputar mundur.
- Untuk belok, Anda perlu memutar motor di sisi yang berlawanan lebih cepat. Misalnya, untuk belok kanan, motor kiri diaktifkan (berputar maju/mundur), sedangkan motor kanan dimatikan atau diputar ke arah sebaliknya.
Tabel berikut menunjukkan kombinasi status pin input untuk berbagai arah gerakan robot:
Mengontrol Motor DC dengan ESP32/ESP8266 – Kecepatan dan Arah
Setelah memahami cara mengontrol motor DC menggunakan driver L298N, mari kita buat contoh sederhana untuk mengatur kecepatan dan arah satu motor DC.
Menghubungkan Motor DC ke ESP32 (Driver Motor L298N)
Motor yang akan kita kendalikan terhubung ke output motor A. Oleh karena itu, kita perlu menghubungkan pin ENABLEA (EN1), INPUT1, dan INPUT2 dari driver motor ke ESP32. Ikuti diagram skematik berikut untuk menghubungkan motor DC dan driver L298N ke ESP32.
Kami menggunakan GPIO dari tabel sebelumnya untuk terhubung ke driver motor. Anda dapat menggunakan GPIO lain yang sesuai, asalkan menyesuaikan kodenya.
Menghubungkan Motor DC ke ESP8266 NodeMCU (Driver Motor L298N)
Motor yang akan kita kendalikan juga terhubung ke output motor A. Oleh karena itu, kita perlu menghubungkan pin ENABLEA (EN1), INPUT1, dan INPUT2 dari driver motor ke ESP8266. Ikuti diagram skematik berikut untuk menghubungkan motor DC dan driver L298N ke ESP8266.
Kami menggunakan GPIO dari tabel sebelumnya untuk terhubung ke driver motor. Anda dapat menggunakan GPIO lain yang sesuai, asalkan menyesuaikan kodenya. Pelajari lebih lanjut tentang GPIO ESP8266: [Referensi Pinout ESP8266: GPIO mana yang bisa digunakan?](tautankembali).
Memberi Daya pada Driver Motor L298N
Motor DC memerlukan lonjakan arus yang besar untuk bergerak, sehingga motor harus dialiri daya dari sumber eksternal (terpisah dari ESP). Sebagai contoh, kami menggunakan 4 baterai AA, tetapi Anda dapat menggunakan catu daya lain yang sesuai. Dalam konfigurasi ini, Anda dapat menggunakan catu daya dengan rentang 6V hingga 12V.
Sakelar antara tempat baterai dan driver motor bersifat opsional, namun sangat berguna untuk memutus dan menyambungkan daya dengan mudah. Dengan demikian, Anda tidak perlu terus-menerus mencabut dan memasang kabel untuk menghemat daya.
Kami menyarankan untuk menyolder sebuah kapasitor keramik 0.1µF (100nF) pada terminal positif dan negatif motor DC, seperti yang ditunjukkan pada diagram, untuk membantu meratakan lonjakan tegangan. (Catatan: motor tetap dapat bekerja tanpa kapasitor ini.)
Membuat Modul MicroPython untuk Mengontrol Motor DC
Menulis kode untuk mengontrol motor DC tidaklah sulit, tetapi memerlukan beberapa perintah yang berulang. Akan lebih baik jika kita memiliki sebuah modul (pustaka) yang memungkinkan kita mengontrol kecepatan dan arah motor dengan satu perintah sederhana.
Dengan pemikiran tersebut, kami akan membuat sebuah modul Python sederhana yang berisi perintah-perintah dasar untuk menginisialisasi motor serta mengontrol kecepatan dan arahnya.
Membuat Modul dcmotor
Sebelum menulis kode untuk modul ini, penting untuk mendefinisikan fungsionalitasnya terlebih dahulu:
1. Pustaka ini akan bernama `dcmotor.py`, dan berisi satu kelas utama bernama `DCMotor` dengan beberapa metode.
2. Kita harus dapat menginisialisasi motor menggunakan pin input 1, pin input 2, dan pin enable, seperti contoh berikut:
motor1 = DCMotor(Pin1, Pin2, enable)
Pin1 dan Pin2 harus diinisialisasi sebagai pin output, dan pin enable harus diinisialisasi sebagai pin PWM.
3. Untuk menggerakkan motor maju, kita ingin menggunakan metode bernama `forward()` pada objek `DCMotor` yang menerima kecepatan (speed) sebagai parameter. Contohnya:
motor1.forward(speed)
Nilai kecepatan (speed) harus berupa bilangan bulat antara 0 dan 100, di mana 0 berarti motor berhenti dan 100 berarti kecepatan maksimum.
4. Demikian pula, untuk membuat motor berputar mundur:
motor1.backwards(speed)
Akan sangat berguna juga untuk memiliki perintah guna menghentikan motor, seperti berikut:
motor1.stop()
Mengimpor Modul dcmotor.py
Buat file baru bernama `dcmotor.py` dan salin kode berikut ke dalam file tersebut.
class DCMotor:
#the min_duty and max_duty are defined for 15000Hz frequency
#you can pass as arguments
def __init__(self, pin1, pin2, enable_pin, min_duty=750, max_duty=1023):
self.pin1 = pin1
self.pin2= pin2
self.enable_pin = enable_pin
self.min_duty = min_duty
self.max_duty = max_duty
#speed value can be between 0 and 100
def forward(self, speed):
self.speed = speed
self.enable_pin.duty(self.duty_cycle(self.speed))
self.pin1.value(1)
self.pin2.value(0)
def backwards(self, speed):
self.speed = speed
self.enable_pin.duty(self.duty_cycle(self.speed))
self.pin1.value(0)
self.pin2.value(1)
def stop(self):
self.enable_pin.duty(0)
self.pin1.value(0)
self.pin2.value(0)
def duty_cycle(self, speed):
if self.speed <= 0 or self.speed > 100:
duty_cycle = 0
else:
duty_cycle = int (self.min_duty + (self.max_duty - self.min_duty)*((self.speed - 1)/(100-1)))
return duty_cycle
Unggah file tersebut ke papan ESP32 atau ESP8266 Anda dengan nama: `dcmotor.py`.
Jika Anda menggunakan Thonny IDE, ikuti langkah-langkah berikut:
1. Salin kode yang disediakan ke file baru di Thonny IDE.
2. Unggah kode ke papan Anda. Di Thonny IDE, buka File > Save as… lalu pilih MicroPython device.
3) Simpan file Anda dengan nama `dcmotor.py`. Di dalam papan, seharusnya sudah ada file bernama `boot.py`. File tersebut dibuat secara otomatis saat Anda meng-flash firmware MicroPython.
4) Terakhir, klik OK untuk melanjutkan. Modul `dcmotor.py` seharusnya telah berhasil diunggah ke papan Anda.
Cara Kerja Modul dcmotor
Modul `dcmotor` berisi satu kelas bernama `DCMotor`.
class DCMotor:
Kami menggunakan metode konstruktor (`__init__`) untuk menginisialisasi data segera setelah sebuah objek dari kelas `DCMotor` dibuat.
def __init__(self, pin1, pin2, enable_pin, min_duty=750, max_duty=1023):
self.pin1 = pin1
self.pin2= pin2
self.enable_pin = enable_pin
self.min_duty = min_duty
self.max_duty = max_duty
Sebuah objek `DCMotor` menerima parameter berikut:
- `pin1`: GPIO (sebagai output) yang terhubung ke pin input 1 L298N.
- `pin2`: GPIO (sebagai output) yang terhubung ke pin input 2 L298N.
- `enable_pin`: GPIO (sebagai pin PWM) yang terhubung ke pin enable 1 L298N.
- `min_duty`: duty cycle minimum untuk membuat motor bergerak (opsional, default 750). Anda mungkin perlu mengubah parameter ini tergantung pada frekuensi yang dibutuhkan untuk mengontrol motor DC Anda.
- `max_duty`: duty cycle maksimum untuk membuat motor bergerak (opsional, default 1023).
Kemudian, beberapa metode dibuat untuk mengontrol motor DC: `forward()` (maju), `backwards()` (mundur), dan `stop()` (berhenti).
Metode `forward()` dan `backwards()` masing-masing membuat motor berputar maju dan mundur. Metode `stop()` menghentikan motor.
Metode `forward()` dan `backwards()` menerima parameter `speed` (kecepatan). Nilai kecepatan harus berupa bilangan bulat antara 0 dan 100.
Mari kita lihat lebih dekat metode `forward()`:
def forward(self, speed):
self.speed = speed
self.enable_pin.duty(self.duty_cycle(self.speed))
self.pin1.value(1)
self.pin2.value(0)
Untuk membuat motor bergerak maju, atur `pin1` ke 1 (HIGH) dan `pin2` ke 0 (LOW). Duty cycle pin enable diatur sesuai dengan kecepatan yang diinginkan. Kecepatan adalah bilangan bulat antara 0 dan 100, tetapi duty cycle harus berada di antara nilai `max_duty` dan `min_duty`. Oleh karena itu, terdapat metode lain di akhir kode bernama `duty_cycle()` yang bertugas menghitung nilai duty cycle berdasarkan kecepatan yang diberikan.
def duty_cycle(self, speed):
if self.speed <= 0 or self.speed > 100:
duty_cycle = 0
else:
duty_cycle = int (self.min_duty + (self.max_duty - self.min_duty)*((self.speed - 1)/(100-1)))
return duty_cycle
Metode `backwards()` bekerja dengan cara serupa, namun `pin1` diatur ke 0 (LOW) dan `pin2` diatur ke 1 (HIGH).
def backwards(self, speed):
self.speed = speed
self.enable_pin.duty(self.duty_cycle(self.speed))
self.pin1.value(0)
self.pin2.value(1)
Mengontrol Motor DC
Setelah memahami cara kerja modul `dcmotor.py` dan modul tersebut telah berhasil diunggah ke papan ESP32 atau ESP8266 Anda, kita dapat membuat skrip baru untuk mengontrol motor DC menggunakan fungsionalitas pustaka tersebut.
Kode berikut mendemonstrasikan cara menggunakan fungsionalitas pustaka untuk mengontrol motor DC. Kode ini kompatibel untuk papan ESP32 maupun ESP8266.
from dcmotor import DCMotor
from machine import Pin, PWM
from time import sleep
frequency = 15000
pin1 = Pin(12, Pin.OUT)
pin2 = Pin(14, Pin.OUT)
enable = PWM(Pin(13), frequency)
dc_motor = DCMotor(pin1, pin2, enable)
#Set min duty cycle (350) and max duty cycle (1023)
#dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)
dc_motor.forward(50)
sleep(2)
dc_motor.stop()
sleep(3)
dc_motor.backwards(100)
sleep(2)
dc_motor.forward(5)
sleep(5)
dc_motor.stop()
Mengimpor Libraries
Untuk menggunakan fungsionalitas pustaka, Anda perlu mengimpornya ke dalam kode Anda. Kami mengimpor kelas `DCMotor` dari pustaka `dcmotor` yang telah kita buat sebelumnya.
from dcmotor import DCMotor
Anda juga perlu mengimpor kelas `Pin` dan `PWM` untuk mengontrol GPIO, serta metode `sleep()` untuk memberikan jeda waktu.
from machine import Pin, PWM
from time import sleep
Mengatur Frekuensi
Atur frekuensi sinyal PWM ke 15000 Hz. Anda dapat memilih nilai frekuensi lain. Perhatikan bahwa untuk nilai frekuensi yang lebih rendah, motor mungkin tidak berputar dan menghasilkan suara bip yang aneh.
frequency = 15000
Menginisialisasi GPIO
Kami membuat tiga variabel yang merujuk ke pin1, pin2, dan enable driver motor. Pin-pin ini masing-masing terhubung ke GPIO 12, 14, dan 13. `pin1` dan `pin2` adalah pin output, sedangkan `enable` adalah pin PWM.
pin1 = Pin(12, Pin.OUT)
pin2 = Pin(14, Pin.OUT)
enable = PWM(Pin(13), frequency)
Kemudian, inisialisasi sebuah objek `DCMotor` dengan `pin1`, `pin2`, dan `enable` yang telah didefinisikan sebelumnya:
dc_motor = DCMotor(pin1, pin2, enable)
Catatan: Anda mungkin perlu memberikan parameter `min_duty` dan `max_duty` tergantung pada motor dan papan yang Anda gunakan. Contohnya:
dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)
Sekarang Anda memiliki objek `DCMotor` bernama `dc_motor`. Anda dapat menggunakan metodenya untuk mengontrol motor. Misalnya, untuk membuat motor berputar maju dengan kecepatan 50%:
dc_motor.forward(50)
Hentikan motor:
dc_motor.stop()
Putar motor mundur dengan kecepatan maksimum:
dc_motor.backwards(100)
Putar motor maju dengan kecepatan 5%:
dc_motor.forward(5)
Demonstrasi
Jalankan kode sebelumnya di papan ESP32 atau ESP8266 Anda. Motor akan:
1. Bergerak maju dengan kecepatan 50%,
2. Bergerak mundur dengan kecepatan 100%,
3. Kemudian bergerak maju lagi dengan kecepatan 5%.
Anda dapat bereksperimen dengan metode-metode tersebut dan memberikan nilai kecepatan yang berbeda sebagai argumen untuk melihat respons motor DC Anda.
Baca juga: Panduan Lengkap Bluetooth Low Energy (BLE) ESP32 Menggunakan MicroPython
Siap Untuk Membuat Proyek Impianmu Menjadi Kenyataan?
Klik di sini untuk chat langsung via WhatsApp dan dapatkan dukungan langsung dari tim ahli kami!
0 on: "MicroPython - Mengontrol Motor DC dengan Driver L298N pada ESP32/ESP8266 "