ESP32 PWM dengan Arduino IDE

Tutorial ini membahas cara menghasilkan sinyal PWM dengan ESP32 menggunakan Arduino IDE. Kami akan menjelaskan dua metode berbeda: menggunakan analogWrite dan menggunakan LEDC API. Sebagai contoh, kita akan membuat rangkaian sederhana untuk meredupkan LED.

PWM (Pulse Width Modulation) pada ESP32 adalah teknik untuk mengontrol sinyal digital sehingga dapat mengatur tingkat daya atau kecerahan perangkat seperti LED, motor, atau komponen lainnya. Prinsip dasar PWM adalah dengan mengubah durasi “on” (nyala) dan “off” (mati) pada sinyal digital dalam periode waktu tertentu.

Cara Kerja PWM

• Duty Cycle: Ini adalah rasio antara durasi “on” dan durasi total siklus sinyal. Semakin tinggi nilai duty cycle, semakin lama sinyal berada dalam keadaan “on”, yang menyebabkan perangkat seperti LED menjadi lebih terang atau motor berputar lebih cepat.
  • Contoh: Jika duty cycle 50%, maka sinyal akan menyala selama setengah siklus waktu dan mati selama setengah lainnya.
• Frekuensi: Ini adalah seberapa cepat siklus PWM terjadi, yaitu jumlah siklus per detik. Frekuensi ini mempengaruhi seberapa halus perubahan yang terjadi pada perangkat yang dikendalikan.

Menggunakan PWM pada ESP32

ESP32 memiliki fitur PWM yang dapat digunakan untuk berbagai tujuan, seperti mengatur kecerahan LED atau kecepatan motor. Ada dua cara utama untuk menghasilkan PWM di ESP32:

1. Menggunakan fungsi analogWrite():
   • Fungsi ini sederhana dan sering digunakan pada platform seperti Arduino. Anda hanya perlu mengatur pin dan duty cycle untuk menghasilkan sinyal PWM.
2. Menggunakan LEDC API:
   • ESP32 menyediakan API khusus yang lebih fleksibel dan kuat, yaitu LEDC (LED Controller). Dengan LEDC, kita bisa mengatur frekuensi dan resolusi PWM dengan lebih baik dan mengontrol beberapa channel PWM secara independen.

Contoh Penggunaan PWM

Misalnya, untuk mengontrol kecerahan LED:

• Anda dapat menghubungkan LED ke pin ESP32 dan mengatur duty cycle untuk membuat LED lebih terang atau lebih redup.
  • Duty Cycle 0%: LED mati
  • Duty Cycle 100%: LED menyala penuh
  • Duty Cycle 50%: LED akan menyala setengah waktu dan mati setengah waktu, menciptakan efek redup.

Kelebihan PWM pada ESP32

• Fleksibilitas: Anda bisa mengontrol banyak perangkat sekaligus dengan berbagai channel PWM.
• Efisiensi: Menggunakan PWM lebih efisien daripada mengubah daya langsung karena sinyal yang digunakan adalah sinyal digital (hanya ON/OFF).
• Kontrol Presisi: Anda bisa mengatur kecerahan atau kecepatan dengan tingkat presisi yang tinggi melalui pengaturan duty cycle.

Secara keseluruhan, PWM di ESP32 memungkinkan pengendalian yang efisien dan presisi terhadap perangkat yang menggunakan sinyal daya, seperti LED, motor, dan lainnya.

Mengontrol Nyala LED menggunakan PWM pada ESP32

ESP32 dilengkapi dengan pengontrol LED PWM yang memiliki 6 hingga 16 saluran independen (tergantung pada model ESP32) yang dapat dikonfigurasi untuk menghasilkan sinyal PWM dengan berbagai karakteristik.

Terdapat beberapa fungsi yang dapat digunakan untuk menghasilkan sinyal PWM dan mencapai hasil yang sama. Anda dapat menggunakan fungsi analogWrite (seperti pada papan Arduino) atau menggunakan fungsi LEDC.

Fungsi analogWrite

Fungsi paling dasar adalah analogWrite, yang menerima dua argumen: GPIO tempat Anda ingin menghasilkan sinyal PWM dan nilai duty cycle (berkisar dari 0 hingga 255).

void analogWrite(uint8_t pin, int value);

Sebagai contoh:

analogWrite(2, 180);

Mengatur Frekuensi dan Resolusi

Anda dapat mengatur resolusi dan frekuensi sinyal PWM pada pin yang dipilih menggunakan fungsi analogWriteResolution dan analogWriteFrequency.

Untuk mengatur resolusi:

void analogWriteResolution(uint8_t pin, uint8_t resolution);

Untuk mengatur frekuensi:

void analogWriteFrequency(uint8_t pin, uint32_t freq);

Fungsi LEDC

Sebagai alternatif, Anda dapat menggunakan API LEDC Arduino-ESP32. Pertama, Anda perlu mengatur pin LEDC. Anda bisa menggunakan fungsi ledcAttach atau ledcAttachChannel.

ledcAttach

Fungsi ledcAttach digunakan untuk mengatur pin LEDC dengan frekuensi dan resolusi tertentu. Saluran LEDC akan dipilih secara otomatis.

bool ledcAttach(uint8_t pin, uint32_t freq, uint8_t resolution);

Fungsi ini akan mengembalikan nilai true jika konfigurasi berhasil. Jika nilai false dikembalikan, berarti terjadi kesalahan dan saluran LEDC tidak berhasil dikonfigurasi.

ledcAttachChannel

Jika Anda lebih memilih untuk mengatur saluran LEDC secara manual, Anda dapat menggunakan fungsi ledcAttachChannel sebagai gantinya.

bool ledcAttachChannel(uint8_t pin, uint32_t freq, uint8_t resolution, uint8_t channel);

Fungsi ini akan mengembalikan nilai true jika konfigurasi berhasil. Jika nilai false dikembalikan, berarti terjadi kesalahan dan saluran LEDC tidak berhasil dikonfigurasi.

ledcWrite

Setelah mengatur pin LEDC menggunakan salah satu dari dua fungsi sebelumnya, Anda dapat menggunakan fungsi ledcWrite untuk mengatur duty cycle sinyal PWM.

void ledcWrite(uint8_t pin, uint32_t duty);

Fungsi ini akan mengembalikan nilai true jika pengaturan duty cycle berhasil. Jika nilai false dikembalikan, berarti terjadi kesalahan dan duty cycle tidak berhasil diatur.

Untuk informasi lebih lanjut dan semua fungsi dari pengontrol PWM LEDC, silakan cek dokumentasi resmi.

Meredupkan LED dengan ESP32

Untuk menunjukkan cara menghasilkan sinyal PWM dengan ESP32, kami akan membuat dua contoh sederhana yang meredupkan kecerahan LED (meningkatkan dan menurunkan kecerahan seiring waktu). Kami akan memberikan contoh menggunakan analogWrite dan yang lainnya menggunakan fungsi LEDC.

Skematik

Sambungkan LED ke ESP32 Anda seperti yang ditunjukkan dalam diagram skematik berikut. LED harus dihubungkan ke GPIO 16.

Contoh PWM ESP32 menggunakan analogWrite – Kode

Buka Arduino IDE Anda dan salin kode berikut. Contoh ini akan meningkatkan dan menurunkan kecerahan LED seiring waktu menggunakan fungsi analogWrite.

const int ledPin = 16;  // 16 corresponds to GPIO 16

void setup() {
  // set the LED as an output
  pinMode(ledPin, OUTPUT);
}

void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    analogWrite(ledPin, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
    // changing the LED brightness with PWM
    analogWrite(ledPin, dutyCycle);
    delay(15);
  }
}

Anda mulai dengan mendefinisikan pin tempat LED terhubung. Dalam contoh ini, LED terhubung ke GPIO 16.

const int ledPin = 16; // 16 corresponds to GPIO 16

Di dalam fungsi setup(), Anda perlu mengonfigurasi LED sebagai output menggunakan fungsi pinMode().

pinMode(ledPin, OUTPUT);

Di dalam fungsi loop(), Anda dapat mengubah siklus tugas (duty cycle) antara 0 dan 255 untuk meningkatkan dan mengurangi kecerahan LED. Dengan cara ini, Anda mengatur berapa banyak waktu LED dalam keadaan menyala pada setiap siklus PWM, yang pada gilirannya mengontrol kecerahan LED.

// increase the LED brightness
for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){ 
// changing the LED brightness with PWM
analogWrite(ledPin, dutyCycle);
delay(15);
}

Perhatikan penggunaan fungsi analogWrite() untuk mengatur siklus tugas (duty cycle). Anda hanya perlu memberikan dua argumen: pin LED dan nilai siklus tugas yang diinginkan.

analogWrite(ledPin, dutyCycle);

Akhirnya, kita mengubah siklus tugas antara 255 dan 0 untuk mengurangi kecerahan LED.

// decrease the LED brightness
for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
// changing the LED brightness with PWM
analogWrite(ledPin, dutyCycle);
delay(15);
}

Uji Coba Contoh analogWrite

Unggah kode ke ESP32 Anda. Pastikan Anda telah memilih board dan port COM yang benar. Periksa rangkaian Anda. LED seharusnya dapat meredup dan menyala dengan kecerahan yang meningkat dan menurun seiring waktu.

Contoh PWM ESP32 menggunakan LEDC API – Kode

Buka Arduino IDE Anda dan salin kode berikut. Contoh ini meningkatkan dan menurunkan kecerahan LED seiring waktu menggunakan fungsi LEDC ESP32.

// ESP32 PWM dengan LEDC API (Arduino-ESP32 core 3.x)
const int ledPin = 16;      // LED terhubung ke GPIO 16
const int freq = 5000;      // Frekuensi PWM 5 kHz
const int resolution = 8;   // Resolusi 8 bit (duty 0–255)

void setup() {
  // Konfigurasi pin LEDC; channel dipilih otomatis
  ledcAttach(ledPin, freq, resolution);
}

void loop() {
  // Meningkatkan kecerahan LED dari 0 ke 255
  for (int dutyCycle = 0; dutyCycle <= 255; dutyCycle++) {
    ledcWrite(ledPin, dutyCycle);   // di core 3.x argumen pertama adalah pin
    delay(10);
  }
  // Menurunkan kecerahan LED dari 255 ke 0
  for (int dutyCycle = 255; dutyCycle >= 0; dutyCycle--) {
    ledcWrite(ledPin, dutyCycle);
    delay(10);
  }
}

Penjelasan Kode:

1. Pin LED didefinisikan pada GPIO 16, dengan frekuensi 5 kHz dan resolusi 8 bit.
2. ledcAttach(ledPin, freq, resolution) mengonfigurasi pin sebagai output PWM sekaligus memilih channel LEDC secara otomatis, sehingga pinMode() tidak diperlukan.
3. ledcWrite(ledPin, dutyCycle) mengatur duty cycle. Mulai Arduino-ESP32 core 3.x, argumen pertama adalah nomor pin, bukan nomor channel.
4. Dua perulangan for menaikkan lalu menurunkan duty cycle dari 0 ke 255 dan sebaliknya.

Catatan versi: fungsi ledcSetup() dan ledcAttachPin() yang ada di banyak tutorial lama sudah dihapus sejak Arduino-ESP32 core 3.0, sehingga kode lama akan gagal dikompilasi. Cek versi core di Tools → Board → Boards Manager → esp32. Jika masih memakai core 2.x, gunakan ledcSetup(channel, freq, resolution), ledcAttachPin(pin, channel), dan ledcWrite(channel, duty).

Uji Coba Contoh: Unggah kode ini ke ESP32 Anda dan pastikan rangkaian telah disusun dengan benar. LED harus meredup dan menyala seiring waktu, dengan kecerahan yang meningkat dan menurun.

Baca juga: ESP32: Panduan Komprehensif untuk Pemula hingga Ahli (IoT, Pemrograman, & Proyek) untuk memahami roadmap lengkap belajar ESP32 dari dasar hingga proyek IoT.