Servo MG996R dengan Arduino: Torsi, Arus, Catu Daya, dan Kode

Servo MG996R adalah servo andalan untuk pekerjaan berat di proyek Arduino, berkat gear logamnya dan torsi sampai 11 kg·cm pada 6 V. Dengan bodi 55 gram, servo ini bisa mengangkat bahu lengan robot, membuka tutup yang berat, atau memutar dudukan kamera pan-tilt. Tapi kekuatan itu ada harganya: ketika terbebani, MG996R menarik arus sampai 2,5 A. Jadi, berbeda dengan SG90, kamu tidak bisa langsung mencolokkannya ke pin 5V Arduino; servo ini butuh catu daya eksternal 5–6 V, GND bersama, dan kapasitor yang dekat dengan servo. Kalau aturan ini diabaikan, servo bergetar (jitter), Arduino terus reset, bahkan komputermu bisa mematikan port USB.

Di panduan ini kamu akan belajar membaca angka torsi dan arus MG996R dengan angka nyata, memilih catu daya yang tepat, memakai rentang 500–2500 µs dengan library Servo untuk menemukan batas servomu sendiri, serta mencegah jitter dan reset. Setelah itu kita lanjut ke kode ESP32 dan Raspberry Pi Pico, modul PCA9685 yang menggerakkan 16 servo lewat dua kabel, memilih servo untuk lengan robot, dan perbandingan dengan SG90 dan MG90S.

Apa itu servo MG996R dan bagaimana cara kerjanya?

MG996R adalah versi perbaikan dari MG995 lama buatan TowerPro: board kontrol dan gear-nya yang didesain ulang membuat posisi tengahnya lebih andal dan celahnya (play) lebih kecil. Di dalam casing ada motor DC kecil, gearbox logam yang memperlambat motor sekaligus melipatgandakan torsinya, potensiometer yang mengukur sudut poros output, dan board kontrol yang mengatur semuanya. Board ini membaca lebar pulsa yang datang di kabel sinyal setiap 20 ms (50 Hz), membandingkan sudut yang diminta dengan sudut yang dilaporkan potensiometer, lalu memutar motor sampai selisihnya hilang. Pulsa sekitar 1500 µs berarti posisi tengah; pulsa yang lebih pendek memutar poros ke satu arah, yang lebih panjang ke arah sebaliknya. Dead band 5 µs di datasheet berarti servo mengabaikan perubahan yang lebih kecil dari itu. Cara kerja motor servo secara umum sudah kami jelaskan di Apa Itu Motor Servo?.

Apa arti torsi? Membaca rating kg·cm dengan benar

Torsi adalah kemampuan servo memutar beban pada jarak tertentu dari porosnya, dan diukur sebagai gaya × jarak. 11 kg·cm berarti servo bisa menahan 11 kg pada jarak 1 cm dari poros, atau 1,1 kg pada jarak 10 cm; kalau jaraknya dua kali lipat, beban yang bisa dibawa jadi setengahnya. Untuk mengubahnya ke newton meter, kalikan dengan 0,098: 11 kg·cm ≈ 1,08 N·m. Ini detail pentingnya: nilai di datasheet adalah torsi stall, yaitu batas ketika poros berhenti, arus mencapai puncak, dan servo memanas. Untuk pemakaian terus-menerus, tetap di maksimal setengah nilai itu membuat servo tetap dingin, mengurangi jitter, dan membuat gear lebih awet.

Tabel ini hanya menghitung beban di ujung. Di mekanisme nyata, berat lengan itu sendiri, servo lain yang terpasang di atasnya, dan gripper semuanya menambah torsi; kamu harus mengalikan massa tiap bagian dengan jaraknya dari poros lalu menjumlahkannya. Misalnya, kalau lengan 15 cm membawa gripper 150 g dan benda 100 g di ujungnya, dua itu saja sudah 0,25 × 15 = 3,75 kg·cm; ditambah berat lengannya sendiri, totalnya bisa mencapai 5 kg·cm. Itu sedikit di bawah setengah torsi stall MG996R pada 6 V, jadi pilihannya tepat. Perhitungan torsi per bagian lengkap dengan contoh ada di panduan lengan robot Arduino.

Arus: kenapa MG996R tidak bisa jalan dari pin 5V Arduino?

Ketika diam tanpa beban, MG996R hanya menarik sekitar 10 mA (menahan beban menaikkan angka ini sesuai bebannya), tapi selama bergerak arusnya naik ke 0,5–0,9 A, dan ketika poros terbebani serta pada milidetik pertama setiap kali mulai bergerak, arusnya mendekati 2,5 A. Ketika Arduino Uno berjalan dari USB, total arus yang bisa kamu ambil dari pin 5V-nya dibatasi oleh sekring 500 mA di board, dan board itu sendiri sudah memakai sebagian. Begitu servo mulai bergerak, jalur 5 V turun cukup jauh selama beberapa milidetik, prosesor jadi tidak stabil, dan board restart. Komputer juga bisa mematikan port USB yang terlalu lama menerima arus berlebih.

Kabel juga bagian dari masalah. Kabel jumper tipis dan kontak breadboard dengan mudah menambah hambatan sampai 0,2 Ω. Hitung dengan kalkulator hukum Ohm: pada puncak 2,5 A, 2,5 × 0,2 = 0,5 V hilang di pengkabelan saja, jadi catu daya 5 V sampai di servo sebagai 4,5 V, dan servo jadi lebih lemah dan bergetar. Kontak breadboard juga hanya dirancang untuk sekitar 1 A. Hubungkan kabel daya MG996R langsung ke terminal sekrup atau jalur distribusi yang disolder, bukan ke breadboard, dan pakai kabel 20–22 AWG.

Memberi daya dengan benar: eksternal 5–6 V, GND bersama, dan kapasitor

1. Pilih catu daya: Pakai adaptor switching 5 V atau 6 V yang sanggup memberi arus sesuai tabel di atas untuk jumlah servomu. Untuk proyek portabel, 4 baterai AA NiMH (4,8 V) atau LiPo 2S dengan regulator step-down (UBEC) yang diatur ke 6 V bekerja dengan baik.
2. Beri positif hanya ke servo: Hubungkan positif catu daya ke kabel merah MG996R; jangan hubungkan ke pin 5V Arduino.
3. Satukan ground: Hubungkan negatif catu daya ke kabel cokelat servo sekaligus ke pin GND Arduino. Sinyal adalah tegangan yang diukur terhadap GND, jadi tanpa GND bersama servo tidak bisa memahami pulsanya.
4. Hubungkan sinyal: Hubungkan kabel oranye ke pin D9 di Arduino Uno (GPIO 18 di ESP32, GP15 di Pico).
5. Tambahkan kapasitor: Pasang kapasitor elektrolit 470–1000 µF / 16 V di antara kabel daya servo, sedekat mungkin dengan servo; kaki yang ditandai garis masuk ke negatif. Untuk beberapa servo, siapkan sekitar 100 µF per servo.
6. Beri daya Arduino secara terpisah: Jalankan board dari USB atau jack DC. Dengan begitu, penurunan tegangan yang disebabkan servo tidak sampai ke prosesor.

Library Servo dan rentang 500–2500 µs

Library Servo Arduino sudah ikut terpasang bersama IDE. Ketika kamu menulis servo.attach(9), library memakai rentang bawaan 544–2400 µs dan memetakan write(0) dan write(180) ke kedua ujungnya; banyak MG996R tidak sampai penuh 180 derajat di rentang ini. Untuk melebarkannya, tulis servo.attach(9, 500, 2500). Detail ini penting karena writeMicroseconds() juga tidak bisa melewati batas yang diberikan ke attach: kalau kamu menulis writeMicroseconds(2500) tanpa mengatur batasnya, library diam-diam memotongnya jadi 2400. Selain itu, write() menganggap angka di bawah 544 sebagai sudut dan angka yang lebih besar sebagai mikrodetik.

Di Arduino Uno, library Servo mendukung sampai 12 servo, dan karena memakai Timer1, analogWrite tidak bekerja di pin 9 dan 10 selama ada servo yang terpasang. Batas mekanis tiap MG996R juga sedikit berbeda: datasheet pabrikan menyebut putaran sekitar 120 derajat dengan pulsa standar 1000–2000 µs, sedangkan dengan rentang yang lebih lebar kebanyakan servo mendekati 180 derajat. Servo yang dipaksa melewati batasnya akan menabrak stopper di dalamnya, menarik arus stall, berdengung, dan memanas. Jadi pekerjaan pertama adalah menemukan rentang pulsa aman servomu sendiri dengan sketch di bawah ini.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4Servo servo;
5int pulseUs = 1500;                // orta konum / center position
6
7void setup() {
8  Serial.begin(115200);
9  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
10  servo.attach(SERVO_PIN, 500, 2500);    // aralığı genişlet / widen the range
11  Serial.println(F("500-2500 arasi bir deger yaz / type a value between 500 and 2500"));
12}
13
14void loop() {
15  if (Serial.available()) {
16    long value = Serial.parseInt();             // yazılan sayıyı oku / read the typed number
17    while (Serial.available()) Serial.read();   // satır sonunu temizle / clear the line ending
18    if (value >= 500 && value <= 2500) {
19      int step = (value > pulseUs) ? 10 : -10;  // 10 µs adımlarla yavaşça git / move slowly in 10 µs steps
20      while (abs(value - pulseUs) >= 10) {
21        pulseUs += step;
22        servo.writeMicroseconds(pulseUs);
23        delay(5);
24      }
25      pulseUs = value;
26      servo.writeMicroseconds(pulseUs);
27      Serial.print(F("Darbe / pulse: "));
28      Serial.print(pulseUs);
29      Serial.println(F(" us"));
30    }
31  }
32}

1. Upload sketch-nya, buka Serial Monitor di 115200 baud, dan atur akhir baris ke New Line.
2. Ketik 1500; servo bergerak ke tengah. Pasang lengan servo pada momen ini sehingga menunjuk ke posisi tengah mekanismemu.
3. Turunkan ke arah batas bawah dengan langkah 50 µs memakai nilai seperti 1000, 800, dan 700. Kalau servo tidak bergerak lagi atau mulai berdengung, mundur 30–50 µs dari nilai terakhir dan catat angka itu sebagai MIN_US.
4. Lakukan hal yang sama untuk batas atas dengan nilai seperti 2000, 2200, dan 2300 untuk menemukan MAX_US. Dua angka ini akan kamu pakai di sketch berikutnya.

Gerakan halus: kode yang mengurangi lonjakan arus dan sentakan

Satu perintah seperti servo.write(160) melempar servo ke targetnya dengan kecepatan penuh, menempuh 60 derajat dalam 0,14 detik pada 6 V. Selama itu motor menarik arus yang mendekati arus stall, mekanismenya tersentak, dan benda yang dipegang bisa jatuh. Memecah gerakan menjadi langkah-langkah kecil mengurangi puncak arus sekaligus guncangan mekanis. Sketch di bawah ini memajukan servo 1 derajat setiap 15 ms (sekitar 67°/dtk), dan karena memakai millis(), kamu bisa mengerjakan hal lain pada waktu yang sama.

1#include <Servo.h>
2
3const byte SERVO_PIN = 9;
4const int MIN_US = 550;            // kalibrasyonda bulduğun alt sınır / lower limit from calibration
5const int MAX_US = 2450;           // kalibrasyonda bulduğun üst sınır / upper limit from calibration
6const byte STEP_MS = 15;           // derece başına süre: 15 ms ≈ 67°/sn / time per degree: 15 ms ≈ 67°/s
7
8const int POSES[] = {20, 160, 90, 45, 135};    // sırayla gidilecek açılar / angles to visit in order
9const byte POSE_COUNT = sizeof(POSES) / sizeof(POSES[0]);
10
11Servo servo;
12int current = 90;                  // şu anki açı / current angle
13int target = 90;                   // hedef açı / target angle
14byte poseIndex = 0;
15unsigned long lastStep = 0;
16unsigned long arrivedAt = 0;
17
18int angleToUs(int angle) {
19  return map(angle, 0, 180, MIN_US, MAX_US);   // açıyı darbeye çevir / angle to pulse width
20}
21
22void setup() {
23  servo.writeMicroseconds(angleToUs(current)); // önce konum, sonra attach / position first, then attach
24  servo.attach(SERVO_PIN, MIN_US, MAX_US);
25  arrivedAt = millis();
26}
27
28void loop() {
29  unsigned long now = millis();
30
31  // Hedefe 1 derecelik adımlarla yaklaş / approach the target in 1-degree steps
32  if (current != target && now - lastStep >= STEP_MS) {
33    lastStep = now;
34    current += (target > current) ? 1 : -1;
35    servo.writeMicroseconds(angleToUs(current));
36    if (current == target) arrivedAt = now;
37  }
38
39  // Hedefte 1 sn bekle, sonra sıradaki poza geç / wait 1 s at the target, then take the next pose
40  if (current == target && now - arrivedAt >= 1000) {
41    target = POSES[poseIndex];
42    poseIndex = (poseIndex + 1) % POSE_COUNT;
43  }
44
45  // Burada başka işler de yapılabilir / other tasks can run here too
46}

Fungsi angleToUs() memetakan sudut di antara nilai MIN_US dan MAX_US yang kamu temukan ketika kalibrasi, sehingga 0 dan 180 derajat menjadi titik ujung servo yang nyata dan aman. Servo tidak mengingat posisinya ketika daya mati, dan langsung bergerak ke sudut yang diperintahkan dengan kecepatan penuh begitu menerima pulsa pertama. Memanggil writeMicroseconds() sebelum attach() membuat library melewatkan pulsa bawaan 1500 µs dan langsung mengirim sudut awalmu; kalau kamu mengembalikan mekanisme ke pose awal yang sama sebelum mematikan daya, lompatan ketika dinyalakan hampir hilang. Atur kecepatannya dengan STEP_MS: 30 ms memberi gerakan lambat dan halus, 5 ms cepat tapi tersentak-sentak. Kalau ingin menggerakkan servo dengan potensiometer, cukup ubah hasil bacaannya menjadi sudut lalu tulis ke variabel target.

Jitter dan Arduino yang reset: penyebab dan solusinya

Mengendalikan MG996R dengan ESP32

Library Servo Arduino standar tidak bekerja di ESP32; instal library ESP32Servo dari Library Manager. Cara pakainya hampir sama: kamu mengatur periodenya dengan setPeriodHertz(50), dan library ini tidak menerima batas di luar 500–2500 µs. Output sinyal ESP32 adalah 3,3 V, dan sebagian besar MG996R bisa membacanya tanpa masalah; kalau servomu tidak merespons atau bergerak tidak menentu, tambahkan konverter level logika di jalur sinyal. Pada contoh di bawah ini, potensiometer yang terhubung ke GPIO 34 memutar servo. Karena ADC ESP32 12-bit, hasil bacaannya berkisar dari 0 sampai 4095 dan sedikit berderau, karena itulah kodenya memakai filter dan dead band.

1#include <ESP32Servo.h>
2
3const int SERVO_PIN = 18;          // servo sinyali / servo signal
4const int POT_PIN = 34;            // pot orta bacağı (ADC1) / pot wiper (ADC1)
5const int MIN_US = 500;            // ESP32Servo bu aralığın dışına çıkmaz / ESP32Servo stays within 500–2500
6const int MAX_US = 2500;
7
8Servo servo;
9float smooth = 0;                  // süzülmüş pot değeri / filtered pot value
10int lastAngle = -1;
11
12void setup() {
13  Serial.begin(115200);
14  ESP32PWM::allocateTimer(0);              // servo için zamanlayıcı ayır / reserve a timer for the servo
15  servo.setPeriodHertz(50);                // 50 Hz = 20 ms periyot / 20 ms period
16  servo.attach(SERVO_PIN, MIN_US, MAX_US);
17  smooth = analogRead(POT_PIN);
18}
19
20void loop() {
21  smooth += (analogRead(POT_PIN) - smooth) * 0.1;   // ADC gürültüsünü süz / filter ADC noise
22  int angle = map((int)smooth, 0, 4095, 0, 180);    // 12 bit ADC: 0–4095
23  if (abs(angle - lastAngle) >= 2) {                // ölü bant: titremeyi keser / deadband stops jitter
24    servo.write(angle);
25    lastAngle = angle;
26    Serial.println(angle);
27  }
28  delay(20);
29}

MG996R dengan Raspberry Pi Pico (MicroPython)

Di Raspberry Pi Pico kamu tidak butuh library tambahan: atur PWM ke 50 Hz dan berikan lebar pulsa dalam nanodetik dengan duty_ns(); 500 µs berarti 500000 ns. Sinyal Pico juga 3,3 V. Jangan beri daya servo dari pin VBUS atau VSYS Pico; arus di pin ini berasal dari port USB komputer, dan arus puncak MG996R akan membuat Pico restart. Beri daya servo dari catu daya eksternal dan satukan ground-nya. Kode di bawah ini menggerakkan servo dengan halus, derajat demi derajat, di antara tiga posisi.

1from machine import Pin, PWM
2import time
3
4MIN_NS = 500000                   # 500 µs = 0 derece / 0 degrees
5MAX_NS = 2500000                  # 2500 µs = 180 derece / 180 degrees
6
7servo = PWM(Pin(15))              # turuncu kablo GP15'e / orange wire to GP15
8servo.freq(50)                    # 50 Hz servo sinyali / 50 Hz servo signal
9
10def write_angle(angle):
11    angle = max(0, min(180, angle))                           # 0–180 ile sınırla / clamp to 0–180
12    servo.duty_ns(MIN_NS + (MAX_NS - MIN_NS) * angle // 180)  # açıyı darbeye çevir / angle to pulse
13
14def move_slow(start, end, ms_per_degree=15):
15    step = 1 if end > start else -1
16    for a in range(start, end + step, step):  # 1 derecelik adımlar / 1-degree steps
17        write_angle(a)
18        time.sleep_ms(ms_per_degree)
19
20write_angle(90)                   # ortadan başla / start at the center
21time.sleep(1)
22
23while True:
24    move_slow(90, 170)
25    time.sleep(1)
26    move_slow(170, 10)
27    time.sleep(1)
28    move_slow(10, 90)
29    time.sleep(1)

16 servo dengan PCA9685: banyak MG996R lewat dua kabel

Ketika jumlah servo bertambah, atau ketika kamu memakai library yang mematikan interrupt, modul PCA9685 membuat semuanya lebih mudah. Board ini adalah generator PWM 16 kanal 12-bit yang berkomunikasi dengan Arduino lewat I2C hanya dengan kabel SDA dan SCL. Karena pulsanya dibuat dengan clock-nya sendiri, sinyalnya tetap stabil meski prosesor sedang sibuk dengan pekerjaan lain. Alamat bawaannya 0x40; dengan mengubah alamat lewat jumper solder A0–A5 di board, kamu bisa menghubungkan 62 board ke bus yang sama, artinya secara teori 992 servo. Pada 50 Hz, periode 20 ms dibagi menjadi 4096 langkah, dan satu langkah sekitar 4,9 µs: 500 µs kira-kira 102 langkah dan 2500 µs sekitar 512.

1#include <Wire.h>
2#include <Adafruit_PWMServoDriver.h>
3
4Adafruit_PWMServoDriver pca = Adafruit_PWMServoDriver(0x40);   // varsayılan adres / default address
5
6const byte SERVO_COUNT = 16;
7const uint16_t MIN_US = 500;       // kalibrasyonla daralt / narrow it after calibration
8const uint16_t MAX_US = 2500;
9
10uint16_t angleToUs(float angle) {
11  return MIN_US + (uint16_t)(angle * (MAX_US - MIN_US) / 180.0);
12}
13
14void setup() {
15  pca.begin();
16  pca.setOscillatorFrequency(27000000);   // kartın gerçek saatine yakın / close to the real board clock
17  pca.setPWMFreq(50);                     // servolar için 50 Hz / 50 Hz for servos
18  delay(10);
19  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
20    pca.writeMicroseconds(ch, angleToUs(90));   // hepsini ortala / center them all
21    delay(200);                                 // sırayla başlat: akım darbesini dağıt / one by one: spread the current surge
22  }
23}
24
25void loop() {
26  // Dalga: her servo komşusundan biraz geride / wave: each servo slightly behind its neighbour
27  float t = millis() / 1000.0;
28  for (byte ch = 0; ch < SERVO_COUNT; ch++) {
29    float angle = 90 + 40 * sin(t * 2.0 - ch * 0.4);   // 50–130° arası / between 50° and 130°
30    pca.writeMicroseconds(ch, angleToUs(angle));
31  }
32  delay(20);
33}

Untuk menjalankan sketch ini, instal library Adafruit PWM Servo Driver dari Library Manager. Baris setOscillatorFrequency(27000000) itu penting: di atas kertas clock internal PCA9685 adalah 25 MHz, tapi kenyataannya berkisar sekitar 23 sampai 27 MHz, dan contoh dari Adafruit memakai 27 MHz. Tanpa pengaturan ini, pulsa yang kamu atur dengan writeMicroseconds() bisa meleset beberapa persen. Menyalakan servo satu per satu dengan jeda 200 ms di setup mencegah ke-16 servo menarik arus awal secara bersamaan. Kalau tiap servo punya batas yang berbeda, ubah MIN_US dan MAX_US menjadi array 16 elemen dan kalibrasi tiap kanal. Sketch ini juga jalan tanpa perubahan di ESP32, karena di sana library Wire memakai GPIO 21 dan 22 secara bawaan.

MG996R vs SG90 vs MG90S

Beban dan panjang lengan yang menentukan. Kalau kamu memutar bagian yang beratnya beberapa gram atau sekadar bereksperimen, SG90 sudah cukup. Kalau kamu ingin ukuran yang sama dengan gear logam yang tahan guncangan, pilih MG90S. Kalau torsi yang kamu butuhkan melebihi 1 kg·cm, misalnya membawa 100 g di ujung lengan 10 cm, naik ke MG996R. MG996R punya torsi sekitar lima kali SG90, tapi lebih lambat, enam kali lebih berat, dan menarik arus tiga sampai empat kali lebih besar, jadi rencanakan catu daya dan pemasangan mekanisnya sesuai itu. Kalau 11 kg·cm masih belum cukup, lihat servo yang lebih besar di kelas 20 kg·cm seperti DS3218.

Memilih servo untuk lengan robot

• Pangkal: MG996R. Jangan bebankan seluruh berat lengan ke poros servo; tambahkan bearing di pangkal supaya servo hanya perlu memutarnya.
• Bahu: Ini sendi yang paling berat bebannya. Pakai MG996R; kalau lengannya lebih panjang dari 20 cm, tambahkan servo kelas 20 kg·cm atau pemberat penyeimbang.
• Siku: MG996R. Memindahkan servo yang berat ke ketinggian bahu dan menggerakkan siku dengan batang dorong (push rod) mengurangi beban di bahu.
• Pergelangan dan putaran pergelangan: MG90S sudah cukup; memakai MG996R di sini hanya menambah berat yang harus dibawa bahu.
• Gripper: SG90 atau MG90S. Atur sudut menutupnya ke titik ketika jari-jari gripper baru menyentuh benda; servo yang terus berusaha menjepit akan menarik arus stall.
• Pemasangan: Pasang lengan servo logam di poros 25 gigi MG996R dan kunci dengan sekrup tengah; lengan servo plastik cepat aus pada torsi sebesar ini.

Ide proyek MG996R

• Lengan robot: Lengan 6 servo dengan MG996R di pangkal, bahu, dan siku serta servo MG90S di pergelangan dan gripper; lihat panduan lengan robot untuk cara membuatnya.
• Kamera pan-tilt: Putar modul ESP32-CAM secara horizontal dan vertikal dengan dua MG996R.
• Pelacak matahari: Temukan arah cahaya dengan empat LDR dan putar panel kecil ke arah matahari dengan MG996R; detailnya ada di artikel pelacak matahari.
• Tempat sampah pintar: Tempat sampah pintar yang membuka tutup berat ketika ada tangan mendekat.
• Kunci pintu berkartu: Tarik grendel dengan MG996R ketika kartu yang benar dipindai di RFID RC522.
• Crane yang dikendalikan joystick: Crane atau ekskavator kecil yang bergerak di dua sumbu dengan joystick.
• Penggerak kontinu: Roda yang lambat tapi kuat dengan versi 360 derajat dari MG996R; perbedaannya dijelaskan di artikel servo 360 derajat.

Kalau diberi daya dengan benar, MG996R adalah motor yang tangguh dan murah yang dengan mudah mengambil alih pekerjaan yang tidak sanggup ditangani servo kecil. Ingat aturannya: catu daya eksternal 5–6 V, GND bersama, kapasitor dekat servo, rentang pulsa yang sudah dikalibrasi dan gerakan yang halus, serta PCA9685 begitu jumlah servo bertambah. Di aplikasi BlueGrays kamu akan menemukan proyek seperti kendali servo dengan potensiometer dan joystick, kunci pintu RFID ESP32 dengan servo, dan koreografi 32 servo, masing-masing dengan skema rangkaian langkah demi langkah dan kode siap pakai.