KUNJUNGI KAMI

KUNJUNGI KITA DI BUKALAPAK, TOKOPEDIA DAN SHOPEE
Tampilkan postingan dengan label PROJECT. Tampilkan semua postingan
Tampilkan postingan dengan label PROJECT. Tampilkan semua postingan

Bagaimana RCWL-0516 Microwave Radar Motion Sensor Bekerja & Menghubungkannya dengan Arduino

Untuk sebagian besar proyek Arduino kita yang memerlukan informasi apakah seseorang telah meninggalkan atau memasuki area, sensor PIR adalah pilihan yang sangat baik. Namun, karena mereka hanya mendeteksi gerakan dari makhluk hidup, mereka akan menghasilkan lebih sedikit alarm palsu.

Nah, di sinilah sensor microweave seperti RCWL-0516 berguna, Sensor microwave RCWL-0516 mendeteksi setiap gerakan dari objek apa pun dan tidak bergantung pada tanda panas, sehingga lebih dapat diandalkan di lingkungan panas di mana sensor PIR mungkin tidak begitu efektif

Sebelum masuk ke detail-detail teknis, mari kita pertama-tama memahami bagaimana sebenarnya cara kerja sensor RCWL-0516.

Bagaimana cara kerja radar Doppler?


Modul RCWL-0516 menggunakan "Radar Doppler", yaitu radar khusus yang memanfaatkan Efek Doppler (juga dikenal sebagai pergeseran Doppler) untuk mendeteksi gerakan dan memicu peringatan kedekatan.

i Apa itu Efek Doppler? Efek Doppler, dinamai dari fisikawan Austria Christian Doppler yang mengusulkan istilah ini pada tahun 1842, menjelaskan perubahan frekuensi yang diamati oleh pengamat stasioner saat sumber frekuensi bergerak. Hal ini berlaku untuk semua jenis gelombang, seperti air, cahaya, radio, dan suara.

Efek ini adalah sesuatu yang mungkin sering Anda dengar, bahkan mungkin tanpa menyadarinya, seperti sirene yang nadanya turun saat ambulans lewat.



Saat ambulans mendekati Anda, gelombang suara dari sirene dipadatkan menjadi jarak yang lebih pendek, meningkatkan frekuensi mereka, yang kita dengar sebagai nada yang lebih tinggi. Kebalikannya terjadi ketika ambulans bergerak menjauh dari Anda, menyebabkan gelombang suara menjadi lebih rendah frekuensinya dan lebih rendah nadanya. Akibatnya, Anda mendengar penurunan nada sirene yang nyata saat melewati.

Radar Doppler bekerja dengan memantulkan sinyal microwave dari target yang diinginkan dan membaca frekuensi sinyal yang kembali. Dengan menganalisis bagaimana gerakan target telah mengubah frekuensi sinyal yang dikirim, kecepatan target dapat diukur.

Anda mungkin pernah melihat petugas polisi menggunakan alat radar kecepatan untuk menangkap orang yang berkendara terlalu cepat. Alat radar kecepatan ini, seperti jenis radar lainnya, terdiri dari pemancar dan penerima gelombang mikro. Mereka mengirimkan sinyal mikro dan kemudian menerimanya setelah memantul dari target.

Karena efek Doppler, jika objek bergerak menuju atau menjauh dari alat tersebut, frekuensi sinyal mikro yang dipantulkan berbeda dari sinyal yang dikirimkan.                   


Ketika sebuah mobil mendekati radar, frekuensi sinyal yang dikembalikan lebih tinggi daripada frekuensi sinyal yang dikirimkan; ketika mobil menjauh, frekuensinya lebih rendah.


Berdasarkan perbedaan frekuensi tersebut, radar speed gun menghitung kecepatan mobil tempat sinyal dipantulkan.


Gambaran Umum Perangkat RCWL-0516

Modul RCWL-0516 adalah sensor aktif, tidak seperti HC-SR501 Pasif Inframerah (PIR) yang bersifat pasif. Sensor ini memancarkan gelombang mikro pada frekuensi sekitar 3,18 GHz dan mengukur radiasi yang dipantulkan kembali.

RCWL-0516 sendiri cukup sederhana dan berfungsi langsung begitu diaktifkan. Cukup berikan daya antara 4V–28V dan ground. Keluaran sensor menjadi HIGH selama dua detik saat mendeteksi gerakan dan menjadi LOW saat dalam keadaan diam (tanpa gerakan terdeteksi).

Dan yang terbaik, sensor ini dapat mendeteksi gerakan hingga jarak 7 meter dengan konsumsi arus yang sangat rendah, hanya di bawah 3 mA.

RCWL-9196 IC

Inti dari sensor RCWL-0516 adalah penkontrol radar Doppler IC dengan kode RCWL-9196. IC ini sangat mirip dengan IC BISS0001 yang digunakan pada sensor PIR.



Chip ini juga mendukung pemicu berulang (repeat triggers) dan memiliki area deteksi 360 derajat tanpa titik buta. Artinya, sensor dapat mendeteksi gerakan dari segala arah tanpa ada ruang yang tidak terdeteksi.

Antena Microwave dan Penguat Daya RF

Inti dari sirkuit RF sensor ini adalah penguat daya RF MMBR941M. Komponen ini berfungsi menangkap sinyal RF berdaya rendah dan meningkatkannya ke tingkat daya yang lebih tinggi. Biasanya, penguat daya RF ini mensuplai antena sensor.




Karena antena gelombang mikro terintegrasi langsung pada PCB itu sendiri, RCWL-0516 menjadi unit yang sepenuhnya mandiri. Artinya, tidak memerlukan komponen tambahan untuk berfungsi, sehingga memudahkan pemasangan dan penggunaan.

Power 

RCWL-0516 menggunakan kurang dari 3 mA arus listrik dan beroperasi antara 4 hingga 28 volt, menjadikannya komponen ideal untuk desain berdaya baterai.

Selain itu, sensor ini dilengkapi dengan regulator tegangan 3.3V yang dapat menyuplai hingga 100 mA arus listrik untuk memberdayakan rangkaian eksternal.


Tegangan Operasi 
4-28V (umumnya 5V)
Jarak deteksi  5-7 Meter
Konsumsi Arus Maks  ~2,7 mA
Frekuensi Operasi  ~3,18 GHz
Daya Transmisi  30 mW (maks)
Durasi Sinyal  ~2 detik
Output Teratur  3,3V, 100 mA

Komponen Opsional – LDR

Sensor RCWL-0516 memiliki fitur menarik lainnya, yaitu dukungan untuk resistor peka cahaya (LDR) opsional. LDR berfungsi sebagai sakelar otomatis yang memungkinkan sensor hanya beroperasi dalam kondisi gelap.Ini berguna untuk membangun sistem pencahayaan yang peka terhadap gerakan.


Sebenarnya, ada dua cara untuk menghubungkan sebuah LDR ke sensor.

  • Dengan menggunakan dua pad CDS di bagian atas sensor.
  • Dengan menggunakan pin CDS di bagian bawah dan menghubungkan LDR antara pin tersebut dan ground.
Apa yang dimaksud dengan CDS?

CDS merupakan singkatan dari cadmium sulfida, yang merupakan komponen fotoaktif pada sebagian besar LDR (resistor tergantung cahaya). Oleh karena itu, LDR kadang-kadang disebut juga sebagai fotoresistor CDS.


Pengaturan Jumper RCWL-0516

Jika Anda melihat dengan cermat pada modul, Anda akan melihat tiga solder jumper di bagian belakang




Dengan memasang resistor dan kapasitor yang sesuai pada jumper-jumper ini, Anda dapat mengubah pengaturan default sensor

C-TM (Penyesuaian Panjang Pulsa): Dengan memasang kapasitor SMD yang sesuai pada C-TM, Anda dapat memperpanjang panjang pulsa keluaran. Panjang pulsa default adalah 2 detik. Nilai kapasitor yang lebih tinggi menghasilkan pulsa yang lebih lama. Sebagai contoh, 0,2µF memperpanjang pulsa keluaran menjadi 50 detik, sementara 1µF memperpanjangnya menjadi 250 detik.

R-GN (Penyesuaian Jarak Deteksi): Dengan memasang resistor yang sesuai pada R-GN, Anda dapat mengurangi jarak deteksi sensor. Secara default, jarak deteksi diatur pada 7m. Sebuah resistor 1M mengurangi jarak deteksi menjadi 5m, sementara resistor 270K menguranginya menjadi 1,5m.

R-CDS (Penyesuaian Sensitivitas Cahaya): Ini adalah alternatif untuk menyolder LDR. Setiap resistor dalam rentang 47K – 100K akan cukup. Semakin rendah nilainya, semakin terang cahaya yang diperlukan untuk menonaktifkan pemicu.

Pinout Sensor RCWL-0516

Sensor RCWL-0516 membawa keluar koneksi-koneksi berikut :



3V3 adalah output dari regulator 3.3V yang ada di dalam modul, bukan input pasokan daya. Jika Anda memerlukan output 3.3V yang bersih untuk memberi daya pada rangkaian logika eksternal, Anda dapat menggunakannya. Ini dapat menyediakan hingga 100mA arus.

GND adalah pin ground. Pin OUT adalah output logika TTL 3.3V. Output ini menjadi HIGH selama dua detik ketika mendeteksi gerakan dan menjadi LOW ketika dalam keadaan diam (tanpa gerakan terdeteksi).

VIN adalah pasokan daya untuk sensor. Anda dapat menghubungkan tegangan input di antara 4 hingga 28V ke pin ini, meskipun umumnya digunakan tegangan 5V.

CDS pins adalah tempat Anda dapat memasang resistor tergantung cahaya (LDR). Menambahkan komponen ini memungkinkan RCWL-0516 beroperasi hanya dalam kondisi gelap.

Eksperimen 1: Menggunakan Sensor RCWL-0516 sebagai Unit Mandiri

Salah satu alasan mengapa sensor RCWL-0516 sangat populer adalah karena merupakan sensor yang sangat serbaguna dan cukup mampu berdiri sendiri. Anda dapat meningkatkan serbaguna sensor ini lebih jauh dengan menghubungkannya ke mikrokontroler seperti Arduino.

Untuk eksperimen pertama kami, kami akan menggunakan RCWL-0516 untuk menunjukkan seberapa berguna sensor ini ketika berdiri sendiri.

Pengkabelan untuk eksperimen ini sangat sederhana. Hubungkan baterai ke VIN dan GND sensor, dan hubungkan LED merah kecil ke pin output melalui resistor pembatas arus 220Ω. Itu saja!

Sekarang, ketika RCWL-0516 mendeteksi gerakan, pin output akan menjadi "HIGH" dan menyalakan LED!'


Anda dapat menghubungkan output ini langsung ke modul relay jika Anda ingin mengaktifkan/mematikan sesuatu berdasarkan gerakan.

i  Sinyal radar dapat menembus bahan non-konduktif seperti plastik. Ini berarti Anda dapat menempatkan salah satu sensor ini di dalam suatu penutup plastik jika ingin menyembunyikannya atau melindunginya dari kerusakan yang tidak disengaja.

Eksperimen 2: Menambahkan LDR

Pada eksperimen berikutnya, kita akan menggunakan LDR (atau Resistor Tergantung Cahaya).

Menghubungkan LDR sangat mudah. Anda dapat menggunakan dua pad CDS di bagian atas sensor yang dirancang khusus untuk melekatkan LDR, atau menggunakan pin CDS di bagian bawah dan menghubungkan LDR antara pin tersebut dan ground.

Anda dapat menggunakan LDR apa pun yang dapat Anda dapatkan. Selain itu, LDR tidak memiliki polaritas, sehingga Anda dapat menghubungkannya dalam arah apa pun yang Anda inginkan.


Ketika LDR terpapar cahaya, Anda akan melihat bahwa sensor tidak menghasilkan output. Namun, begitu ruangan menjadi gelap, sensor ini kembali beroperasi normal.

Ini memiliki beberapa penggunaan di dunia nyata, seperti mengendalikan pencahayaan ruangan atau mendeteksi intruder pada malam hari.


Eksperimen 3: Membaca RCWL-0516 dengan Arduino

Pada eksperimen berikutnya, kita akan menggunakan Arduino untuk terus-menerus memeriksa pin sensor untuk melihat apakah ada deteksi gerakan.

Proyek ini tentu saja dapat diperluas untuk merespons gerakan dengan berbagai cara, seperti menghidupkan dan mematikan lampu, mengaktifkan kipas atau properti Halloween, atau bahkan mengambil gambar seorang intruder.

Penyambungan/Pengkabelan 

Menghubungkan sensor RCWL-0516 ke Arduino sangatlah mudah. Beri daya pada RCWL-0516 dengan 5V dan hubungkan ground ke ground. Karena RCWL-0516 berfungsi sebagai output digital, yang perlu Anda lakukan hanyalah mendengarkan pin output. Jadi hubungkan output ke pin digital #8 pada Arduino


Sekarang Anda siap untuk mengunggah beberapa kode dan membuat RCWL-0516 berfungsi.

Kode Arduino

Kodenya sangat sederhana. Pada dasarnya, itu hanya melacak apakah input ke pin #8 berada pada keadaan HIGH atau LOW.
 int ledPin = 13;                // choose the pin for the LED
int inputPin = 8;               // choose the input pin (for Radar sensor)
int motionState = LOW;          // we start, assuming no motion detected
int val = 0;                    // variable for reading the pin status
 
void setup() {
  pinMode(ledPin, OUTPUT);      // declare LED as output
  pinMode(inputPin, INPUT);     // declare sensor as input
 
  Serial.begin(9600);
}
 
void loop() {
  val = digitalRead(inputPin);  // read input value
  
  if (val == HIGH) {  // check if the input is HIGH
    digitalWrite(ledPin, HIGH);  // turn LED ON
    
    if (motionState == LOW) {
      Serial.println("Motion detected!"); // print on output change
      motionState = HIGH;
    }
  }
  else {
    digitalWrite(ledPin, LOW); // turn LED OFF
    
    if (motionState == HIGH) {
      Serial.println("Motion ended!");  // print on output change
      motionState = LOW;
    }
  }
}
Dengan sensor menghadap ke atas, gesekkan tangan Anda di atas sensor. Anda seharusnya melihat pesan "Deteksi Gerakan" tercetak di terminal serial


Referensi : 
"How RCWL-0516 Microwave Radar Motion Sensor Works & Interface It With Arduino", Last Minute Engineer, https://lastminuteengineers.com/rcwl0516-microwave-radar-motion-sensor-arduino-tutorial/

Menghasilkan Sinyal PWM dengan ESP32 Menggunakan Arduino IDE

Dalam tutorial ini, kami akan menunjukkan kepada Anda cara menghasilkan sinyal PWM dengan ESP32 menggunakan Arduino IDE. Sebagai contoh, kami akan membangun rangkaian sederhana yang memudarkan LED menggunakan pengendali PWM LED di ESP32. Kami juga akan menunjukkan kepada Anda bagaimana Anda dapat mendapatkan sinyal PWM yang sama pada pin GPIO yang berbeda pada saat yang bersamaan.


Sebelum melanjutkan dengan tutorial ini, Anda harus sudah menginstal add-on ESP32 di Arduino IDE Anda. Ikuti salah satu tutorial berikut untuk menginstal ESP32 di Arduino IDE, jika Anda belum melakukannya.


Bagian yang Diperlukan

Untuk mengikuti tutorial ini, Anda memerlukan komponen-komponen berikut:

Anda dapat menggunakan tautan-tautan sebelumnya atau pergi langsung ke tokopedia.com/cncstorebandung untuk menemukan semua komponen yang Anda butuhkan untuk proyek Anda dengan harga terbaik!


Kontroler PWM LED ESP32

ESP32 memiliki kontroler PWM LED dengan 16 saluran independen yang dapat dikonfigurasi untuk menghasilkan sinyal PWM dengan properti yang berbeda.

Berikut adalah langkah-langkah yang harus Anda ikuti untuk memudarkan LED dengan PWM menggunakan Arduino IDE:

1. Pertama, Anda perlu memilih saluran PWM. Terdapat 16 saluran dari 0 hingga 15.

2. Kemudian, Anda perlu mengatur frekuensi sinyal PWM. Untuk LED, frekuensi 5000 Hz sudah cukup baik digunakan.

3. Anda juga perlu mengatur resolusi siklus tugas sinyal: Anda memiliki resolusi dari 1 hingga 16 bit. Kami akan menggunakan resolusi 8 bit, yang berarti Anda dapat mengendalikan kecerahan LED menggunakan nilai dari 0 hingga 255.

4. Selanjutnya, Anda perlu menentukan pada pin GPIO atau beberapa GPIO mana sinyal akan muncul. Untuk itu, Anda akan menggunakan fungsi berikut:

ledcAttachPin(GPIO, channel)
5.Terakhir, untuk mengontrol kecerahan LED menggunakan PWM, Anda menggunakan fungsi berikut:
ledcWrite(channel, dutycycle)
Fungsi ini menerima sebagai argumen saluran yang menghasilkan sinyal PWM dan siklus tugas.

Pengendalian Kecerahan LED
Mari kita lihat contoh sederhana untuk melihat bagaimana menggunakan pengontrol PWM LED ESP32 menggunakan Arduino IDE.

Skema
Sambungkan sebuah LED ke ESP32 Anda seperti pada diagram skema berikut. LED harus terhubung ke GPIO 16.



Catatan: Anda dapat menggunakan pin apa pun yang Anda inginkan, selama itu dapat berfungsi sebagai output. Semua pin yang dapat berfungsi sebagai output dapat digunakan sebagai pin PWM. Untuk informasi lebih lanjut tentang GPIO ESP32, baca: Referensi Pinout ESP32: Pin GPIO mana yang sebaiknya Anda gunakan?

Kode

Buka Arduino IDE Anda dan salin kode berikut.
 // the number of the LED pin
const int ledPin = 16;  // 16 corresponds to GPIO16

// setting PWM properties
const int freq = 5000;
const int ledChannel = 0;
const int resolution = 8;
 
void setup(){
  // configure LED PWM functionalitites
  ledcSetup(ledChannel, freq, resolution);
  
  // attach the channel to the GPIO to be controlled
  ledcAttachPin(ledPin, ledChannel);
}
 
void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);   
    delay(15);
  }
}
Anda memulai dengan mendefinisikan pin tempat LED terpasang. Dalam hal ini, LED terpasang pada GPIO 16.
const int ledPin = 16;  // 16 corresponds to GPIO16
Di dalam fungsi setup(), Anda perlu mengonfigurasi PWM LED dengan properti yang telah Anda tentukan sebelumnya menggunakan fungsi ledcSetup() yang menerima sebagai argumen ledChannel, frekuensi, dan resolusi, seperti berikut:
ledcSetup(ledChannel, freq, resolution);
Selanjutnya, Anda perlu memilih GPIO tempat Anda akan mendapatkan sinyal tersebut. Gunakan fungsi ledcAttachPin() yang menerima sebagai argumen GPIO tempat Anda ingin mendapatkan sinyal, dan saluran yang menghasilkan sinyal. Dalam contoh ini, kami akan mendapatkan sinyal pada GPIO ledPin, yang sesuai dengan GPIO 16. Saluran yang menghasilkan sinyal adalah ledChannel, yang sesuai dengan saluran 0.
 ledcAttachPin(ledPin, ledChannel);
Di dalam loop, Anda akan mengubah siklus tugas antara 0 dan 255 untuk meningkatkan kecerahan LED.
 for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);
    delay(15); 
}
Untuk mengatur kecerahan LED, Anda hanya perlu menggunakan fungsi ledcWrite() yang menerima sebagai argumen saluran yang menghasilkan sinyal, dan siklus tugas.
 ledcWrite(ledChannel, dutyCycle);
}
Karena kita menggunakan resolusi 8 bit, siklus tugas akan dikendalikan menggunakan nilai dari 0 hingga 255. Perhatikan bahwa dalam fungsi ledcWrite(), kita menggunakan saluran yang menghasilkan sinyal, dan bukan GPIO.

Pengujian Contoh

Unggah kode ke ESP32 Anda. Pastikan Anda telah memilih papan dan port COM yang benar. Lihat sirkuit Anda. Anda seharusnya memiliki LED pengatur cahaya yang meningkat dan mengurangi kecerahan.


Mendapatkan Sinyal yang Sama pada GPIO yang Berbeda

Anda dapat mendapatkan sinyal yang sama dari saluran yang sama pada berbagai GPIO yang berbeda. Untuk mencapainya, Anda hanya perlu menghubungkan GPIO tersebut ke saluran yang sama pada fungsi setup().

Mari modifikasi contoh sebelumnya untuk meredupkan 3 LED menggunakan sinyal PWM yang sama dari saluran yang sama.

Skema

Tambahkan dua LED tambahan ke sirkuit Anda dengan mengikuti diagram skematik berikut:




(Diagram skematik ini menggunakan versi modul ESP32 DEVKIT V1 dengan 30 GPIO - jika Anda menggunakan model lain, harap periksa pinout untuk papan yang Anda gunakan.)

Kode

Salin kode berikut ke Arduino IDE Anda.
 // the number of the LED pin
const int ledPin = 16;  // 16 corresponds to GPIO16
const int ledPin2 = 17; // 17 corresponds to GPIO17
const int ledPin3 = 5;  // 5 corresponds to GPIO5

// setting PWM properties
const int freq = 5000;
const int ledChannel = 0;
const int resolution = 8;
 
void setup(){
  // configure LED PWM functionalitites
  ledcSetup(ledChannel, freq, resolution);
  
  // attach the channel to the GPIO to be controlled
  ledcAttachPin(ledPin, ledChannel);
  ledcAttachPin(ledPin2, ledChannel);
  ledcAttachPin(ledPin3, ledChannel);
}
 
void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
    // changing the LED brightness with PWM
    ledcWrite(ledChannel, dutyCycle);   
    delay(15);
  }
}
}
Ini adalah kode yang sama dengan yang sebelumnya tetapi dengan beberapa modifikasi. Kami telah mendefinisikan dua variabel tambahan untuk dua LED baru, yang mengacu pada GPIO 17 dan GPIO 5.
const int ledPin2 = 17; // 17 corresponds to GPIO17 
const int ledPin3 = 5;  // 5 corresponds to GPIO5
Kemudian, dalam fungsi setup(), kami telah menambahkan baris-baris berikut untuk mengaitkan kedua GPIO dengan saluran 0. Ini berarti bahwa kita akan mendapatkan sinyal yang sama, yang dihasilkan pada saluran 0, pada kedua GPIO tersebut. 

Menguji Proyek

Unggah sketsa yang baru ke ESP32 Anda. Pastikan Anda telah memilih papan dan port COM yang benar. Sekarang, perhatikan sirkuit Anda:



Semua GPIO mengeluarkan sinyal PWM yang sama. Jadi, ketiga LED meningkat dan berkurang kecerahannya secara bersamaan, menghasilkan efek yang disinkronkan.



Penutup

Secara ringkas, dalam pos ini Anda telah mempelajari cara menggunakan pengontrol PWM LED ESP32 dengan Arduino IDE untuk mengatur kecerahan LED. Konsep yang dipelajari dapat digunakan untuk mengendalikan output lain dengan PWM dengan mengatur properti sinyal yang tepat.

SERVER WEB MOTOR SERVO ESP32 DENGAN ARDUINO IDE

Dalam tutorial ini, kami akan menunjukkan kepada Anda bagaimana membangun sebuah server web dengan ESP32 yang mengontrol posisi poros dari sebuah motor servo menggunakan slider. Pertama, kita akan melihat cara mengendalikan motor servo dengan ESP32, dan kemudian kita akan membangun server webnya.


Menghubungkan Motor Servo ke ESP32

Motor servo memiliki tiga kabel: daya, tanah (ground), dan sinyal. Biasanya, kabel daya berwarna merah, GND berwarna hitam atau coklat, dan kabel sinyal biasanya berwarna kuning, oranye, atau putih."

Kabel Warna
Daya Merah
GND Hitam, atau coklat
Sinyal Kuning, oranye, atau putih



Ketika menggunakan motor servo kecil seperti S0009 seperti yang ditunjukkan pada gambar di bawah ini, Anda dapat memberinya pasokan daya langsung dari ESP32."














Tetapi jika Anda menggunakan lebih dari satu motor servo atau jenis lainnya, Anda mungkin perlu memberi pasokan daya ke servo Anda menggunakan sumber daya eksternal.












Jika Anda menggunakan motor servo kecil seperti S0009, Anda perlu menghubungkan:


GND -> pin GND ESP32;

Daya -> pin VIN ESP32;

Sinyal -> GPIO 13 (atau salah satu pin PWM lainnya).

Catatan: dalam kasus ini, Anda dapat menggunakan salah satu GPIO ESP32, karena setiap GPIO dapat menghasilkan sinyal PWM. Namun, kami tidak merekomendasikan penggunaan GPIO 9, 10, dan 11 yang terhubung ke flash SPI terintegrasi dan tidak direkomendasikan untuk penggunaan lain.

Skema

Dalam contoh kami, kami akan menghubungkan kabel sinyal ke GPIO 13. Jadi, Anda dapat mengikuti diagram skema berikut untuk menghubungkan motor servo Anda.

















Skema ini menggunakan versi modul ESP32 DEVKIT V1 dengan 36 GPIO - jika Anda menggunakan model lain, harap periksa pinout untuk papan yang Anda gunakan.)


Bagaimana Mengendalikan Motor Servo?

Anda dapat mengatur posisi poros servo dalam berbagai sudut dari 0 hingga 180º. Servo dikendalikan menggunakan sinyal modulasi lebar pulsa (PWM). Ini berarti bahwa sinyal PWM yang dikirimkan ke motor akan menentukan posisi porosnya.



Untuk mengendalikan motor, Anda dapat menggunakan kemampuan PWM dari ESP32 dengan mengirimkan sinyal 50Hz dengan lebar pulsa yang sesuai. Atau Anda dapat menggunakan pLibrary untuk membuat tugas ini menjadi lebih sederhana.


Menyiapkan Arduino IDE

Ada add-on untuk Arduino IDE yang memungkinkan Anda untuk memprogram ESP32 menggunakan Arduino IDE dan bahasa pemrogramannya. Ikuti salah satu tutorial berikut untuk menyiapkan Arduino IDE Anda agar dapat bekerja dengan ESP32, jika Anda belum melakukannya.

Setelah memastikan Anda telah menginstal add-on ESP32, Anda dapat melanjutkan tutorial ini.


Menginstal ESP32_Arduino_Servo_Library

Library ESP32 Arduino Servo memudahkan pengendalian motor servo dengan ESP32 Anda, menggunakan Arduino IDE. Ikuti langkah-langkah berikut untuk menginstal library di Arduino IDE Anda:


  1. Klik di sini untuk mengunduh ESP32_Arduino_Servo_Library. Anda harus memiliki folder .zip di folder Unduhan Anda.
  2. Ekstrak folder .zip dan Anda akan mendapatkan folder ESP32-Arduino-Servo-Library-Master
  3. Ganti nama folder Anda dari ESP32-Arduino-Servo-Library-Master menjadi ESP32_Arduino_Servo_Library
  4. Pindahkan folder ESP32_Arduino_Servo_Library ke folder library instalasi Arduino IDE Anda
  5. Terakhir, buka kembali Arduino IDE Anda

Menguji Contoh

Setelah menginstal library, buka Arduino IDE Anda. Pastikan Anda telah memilih papan ESP32, lalu buka File > Contoh > ServoESP32 > Simple Servo.

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
  Written by BARRAGAN and modified by Scott Fitzgerald
*********/

#include 

Servo myservo;  // create servo object to control a servo
// twelve servo objects can be created on most boards

int pos = 0;    // variable to store the servo position

void setup() {
  myservo.attach(13);  // attaches the servo on pin 13 to the servo object
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    myservo.write(pos);              // tell servo to go to position in variable 'pos'
    delay(15);                       // waits 15ms for the servo to reach the position
  }
}


Memahami Kode

Sketsa ini memutar motor servo 180 derajat ke satu sisi, dan 180 derajat ke sisi lainnya. Mari kita lihat bagaimana cara kerjanya.


Pertama, Anda perlu menyertakan library Servo:


#include <Servo.h>
Kemudian, Anda perlu membuat sebuah objek servo. Dalam hal ini, objek tersebut dinamakan myservo.
Servo myservo;

Setup()

Dalam fungsi setup(), Anda menginisialisasi komunikasi serial untuk tujuan debugging, dan menghubungkan GPIO 13 ke objek servo."

void setup() {
  myservo.attach(13);
Loop()
Dalam loop(), kita mengubah posisi poros motor dari 0 hingga 180 derajat, dan kemudian dari 180 hingga 0 derajat. Untuk mengatur poros ke posisi tertentu, Anda hanya perlu menggunakan metode write() dalam objek servo. Anda mengirimkan sebagai argumen, sebuah angka integer dengan posisi dalam derajat."
Servo myservo;

Setup()

Dalam fungsi setup(), Anda menginisialisasi komunikasi serial untuk tujuan debugging, dan menghubungkan GPIO 13 ke objek servo."

myservo.write(pos);

Menguji Sketsa

Unggah kode ke ESP32 Anda. Setelah mengunggah kode, Anda seharusnya melihat poros motor berputar ke satu sisi dan kemudian ke sisi lainnya.

Membuat Server Web ESP32

Sekarang bahwa Anda tahu bagaimana mengendalikan servo dengan ESP32, mari buat server web untuk mengendalikannya (pelajari lebih lanjut tentang cara membangun Server Web ESP32). Server web yang akan kita bangun:

  • Mengandung slider dari 0 hingga 180, yang dapat Anda sesuaikan untuk mengontrol posisi poros servo;
  • Nilai slider saat ini secara otomatis diperbarui di halaman web, serta posisi poros, tanpa perlu merefresh halaman web. Untuk ini, kami menggunakan AJAX untuk mengirim permintaan HTTP ke ESP32 di latar belakang;
  • Mererefresh halaman web tidak mengubah nilai slider maupun posisi poros.



Membuat Halaman HTML


Mari mulai dengan melihat teks HTML yang perlu dikirimkan oleh ESP32 ke peramban Anda.

<!DOCTYPE html>
<html>
<head>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" href="data:,">
  <style>
    body {
      text-align: center;
      font-family: "Trebuchet MS", Arial;
      margin-left:auto;
      margin-right:auto;
    }
    .slider {
      width: 300px;
    }
  </style>
  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
</head>
<body>
  <h1>ESP32 with Servo</h1>
  <p>Position: <span id="servoPos"></span></p>
  <input type="range" min="0" max="180" class="slider" id="servoSlider" onchange="servo(this.value)"/>
  <script>
    var slider = document.getElementById("servoSlider");
    var servoP = document.getElementById("servoPos");
    servoP.innerHTML = slider.value;
    slider.oninput = function() {
      slider.value = this.value;
      servoP.innerHTML = this.value;
    }
    $.ajaxSetup({timeout:1000});
    function servo(pos) {
      $.get("/?value=" + pos + "&");
      {Connection: close};
    }
  </script>
</body>
</html>

Membuat Slider
Halaman HTML untuk proyek ini melibatkan pembuatan slider. Untuk membuat slider dalam HTML, Anda menggunakan tag <input>. Tag <input> menentukan bidang di mana pengguna dapat memasukkan data.

Terdapat berbagai jenis input yang tersedia. Untuk mendefinisikan sebuah slider, gunakan atribut "type" dengan nilai "range". Dalam slider, Anda juga perlu mendefinisikan rentang minimum dan maksimum menggunakan atribut "min" dan "max".


<input type="range" min="0" max="180" class="slider" id="servoSlider" onchange="servo(this.value)"/&gt
Anda juga perlu mendefinisikan atribut lain seperti:

  • class untuk menggaya slider
  • id untuk memperbarui posisi saat ini yang ditampilkan pada halaman web
  • Dan akhirnya, atribut onchange untuk memanggil fungsi servo untuk mengirim permintaan HTTP ke ESP32 ketika slider bergerak.
   

Menambahkan JavaScript ke Berkas HTML

Selanjutnya, Anda perlu menambahkan beberapa kode JavaScript ke berkas HTML Anda dengan menggunakan tag <script> dan </script>. Potongan kode ini akan memperbarui halaman web dengan posisi slider saat ini:"
var slider = document.getElementById("servoSlider");
var servoP = document.getElementById("servoPos");
servoP.innerHTML = slider.value;
slider.oninput = function() {
slider.value = this.value;
servoP.innerHTML = this.value;
}value=" + pos + "&");
}
Dan baris-baris selanjutnya melakukan permintaan HTTP GET ke alamat IP ESP pada jalur URL tertentu /?value=[POSISI_SLIDER]&.

$.ajaxSetup({timeout:1000});
function servo(pos) {
$.get("/?value=" + pos + "&");
}
Sebagai contoh, ketika slider berada pada posisi 0, Anda melakukan permintaan HTTP GET pada URL berikut:
Dan ketika slider berada pada posisi 180 derajat, Anda akan memiliki sesuatu seperti ini:
Dengan cara ini, ketika ESP32 menerima permintaan GET, ia dapat mengambil parameter nilai dalam URL dan memindahkan motor servo ke posisi yang tepat.

Kode

Sekarang, kita perlu menyertakan teks HTML sebelumnya dalam sketsa dan memutar motor servo sesuai dengan posisinya. Sketsa berikut ini melakukan hal tersebut.

Catatan: seperti yang telah kita sebutkan sebelumnya, Anda perlu menginstal add-on ESP32 di Arduino IDE Anda. Ikuti salah satu panduan berikut untuk menginstal papan ESP32 di Arduino IDE, jika Anda belum melakukannya:


Instruksi Windows – Papan ESP32 di Arduino IDE
Instruksi Mac dan Linux – Papan ESP32 di Arduino IDE

Salin kode berikut ke Arduino IDE Anda, tetapi jangan mengunggahnya sekarang. Pertama, kita akan melihat bagaimana cara kerjanya."
Berikut adalah kode HTML yang telah ditandai dengan kotak warna abu untuk kode Arduino yang Anda berikan
  
/*********
Rui Santos
Complete project details at https://randomnerdtutorials.com
*********/
#include <WiFi.h>
#include <Servo.h>
Servo myservo; // create servo object to control a servo
// twelve servo objects can be created on most boards
// GPIO the servo is attached to
static const int servoPin = 13;
// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
// Set web server port number to 80
WiFiServer server(80);
// Variable to store the HTTP request
String header;
// Decode HTTP GET value
String valueString = String(5);
int pos1 = 0;
int pos2 = 0;
// Current time
unsigned long currentTime = millis();
// Previous time
unsigned long previousTime = 0;
// Define timeout time in milliseconds (example: 2000ms = 2s)
const long timeoutTime = 2000;
void setup() {
Serial.begin(115200);
myservo.attach(servoPin); // attaches the servo on the servoPin to the servo object
// Connect to Wi-Fi network with SSID and password
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void loop(){
WiFiClient client = server.available(); // Listen for incoming clients
if (client) { // If a new client connects,
currentTime = millis();
previousTime = currentTime;
Serial.println("New Client."); // print a message out in the serial port
String currentLine = ""; // make a String to hold incoming data from the client
while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop while the client's connected
currentTime = millis();
if (client.available()) { // if there's bytes to read from the client,
char c = client.read(); // read a byte, then
Serial.write(c); // print it out the serial monitor
header += c;
if (c == '\n') { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a row.
// that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
// and a content-type so the client knows what's coming, then a blank line:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();
// Display the HTML web page
client.println(""); client.println(""); client.println(""); // CSS to style the on/off buttons // Feel free to change the background-color and font-size attributes to fit your preferences client.println(""); client.println(""); // Web Page client.println("

ESP32 with Servo

"); client.println("

Position:

"); client.println(""); client.println(""); client.println("");
//GET /?value=180& HTTP/1.1
if(header.indexOf("GET /?value=")>=0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1+1, pos2);
//Rotate the servo
myservo.write(valueString.toInt());
Serial.println(valueString);
}
// The HTTP response ends with another blank line
client.println();
// Break out of the while loop
break;
} else { // if you got a newline, then clear currentLine
currentLine = "";
}
} else if (c != '\r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
}
}
// Clear the header variable
header = "";
// Close the connection
client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
}
Cara Kerja Kode
Pertama, kita menyertakan libarary Servo, dan membuat objek servo yang disebut myservo.

#include
Servo myservo; // create servo object to control a servo
Kita juga membuat variabel untuk menyimpan nomor GPIO yang terhubung ke servo. Dalam kasus ini, GPIO 13.

const int servoPin = 13;
Jangan lupa bahwa Anda perlu memodifikasi dua baris berikut untuk menyertakan kredensial jaringan Anda.
// Replace with your network credentials const char* ssid = "";
const char* password = "";
Kemudian, buat beberapa variabel yang akan digunakan untuk mengekstrak posisi slider dari permintaan HTTP.
// Decode HTTP GET value
String valueString = String(5);
int pos1 = 0;
int pos2 = 0;
setup()
Dalam setup(), Anda perlu menghubungkan servo ke GPIO yang terhubung dengannya, dengan menggunakan myservo.attach().
myservo.attach(servoPin); // attaches the servo on the servoPin to the servo object

Bagian pertama dari loop() membuat server web dan mengirimkan teks HTML untuk menampilkan halaman web. Kami menggunakan metode yang sama yang telah kami gunakan dalam proyek server web ini.

Bagian berikut dari kode mengambil nilai slider dari permintaan HTTP."
//GET /?value=180& HTTP/1.1
if(header.indexOf("GET /?value=") >= 0) {
pos1 = header.indexOf('=');
pos2 = header.indexOf('&');
valueString = header.substring(pos1 + 1, pos2);
}
Ketika Anda menggerakkan slider, Anda membuat permintaan HTTP pada URL berikut yang berisi posisi slider antara tanda = dan & 

Anda dapat menandai URL HTTP tersebut dalam HTML seperti berikut:
http://your-esp-ip-address/?value=[SLIDER_POSITION]&
Nilai posisi slider disimpan dalam variabel valueString.

Kemudian, kita mengatur servo ke posisi tertentu tersebut menggunakan myservo.write() dengan variabel valueString sebagai argumen. Variabel valueString adalah string, jadi kita perlu menggunakan metode toInt() untuk mengonversinya menjadi angka bulat - tipe data yang diterima oleh metode write()."
myservo.write(valueString.toInt());
Menguji Server Web
Sekarang Anda dapat mengunggah kode ke ESP32 Anda - pastikan Anda telah memilih papan yang benar dan port COM yang benar. Juga jangan lupa untuk memodifikasi kode untuk menyertakan kredensial jaringan Anda.

Setelah mengunggah kode, buka Serial Monitor pada kecepatan baud 115200.
Tekan tombol "Enable" pada ESP32 untuk me-restart papan, dan salin alamat IP ESP32 yang muncul di Serial Monitor.

Buka peramban Anda, tempelkan alamat IP ESP, dan Anda akan melihat halaman web yang telah Anda buat sebelumnya. Geser slider untuk mengontrol motor servo.



Di Serial Monitor, Anda juga dapat melihat permintaan HTTP yang Anda kirimkan ke ESP32 ketika Anda menggerakkan slider.



Eksperimenlah dengan server web Anda untuk melihat apakah semuanya berfungsi dengan baik.


Penutup

Secara ringkas, dalam tutorial ini Anda telah belajar cara mengendalikan motor servo dengan ESP32 dan cara membuat server web dengan slider untuk mengontrol posisinya.

Ini hanyalah contoh bagaimana mengendalikan motor servo. Alih-alih slider, Anda dapat menggunakan bidang input teks, beberapa tombol dengan sudut-sudut yang telah ditentukan, atau bidang input lain yang sesuai.

Referensi : 
"ESP32 Servo Motor Web Server with Arduino IDE", Random Nerd Tutorial, https://randomnerdtutorials.com/esp32-servo-motor-web-server-arduino-ide/