Komponen · 12 mnt baca

Panduan servo MG90S dengan Arduino: perbandingan dengan SG90, pengkabelan, kalibrasi

Memakai servo MG90S dengan Arduino: gear logam vs SG90, torsi 2,2 kg·cm, warna kabel, kalibrasi 500–2400 µs, catu daya, serta kode untuk Uno, ESP32, dan Pico.

Servo MG90S adalah servo mikro seukuran SG90 tetapi dengan gear logam: bodinya yang 13,4 g menghasilkan torsi macet 1,8 kg·cm di 4,8 V dan 2,2 kg·cm di 6 V, serta jauh lebih tahan benturan, tabrakan lengan, dan putaran tak sengaja dengan tangan dibanding SG90 bergear plastik. Memakai servo MG90S dengan Arduino semudah SG90: tiga kabel yang sama, library Servo yang sama, dan sinyal 50 Hz yang sama. Perbedaannya ada di detail; arusnya sedikit lebih besar, rentang pulsanya berbeda dari unit ke unit, dan perlu dikalibrasi kalau kamu ingin sudut yang akurat.

Dalam panduan ini kamu akan membandingkan spesifikasi MG90S dengan SG90 dan MG996R, lalu melihat warna kabel dan pengkabelan untuk Arduino Uno, ESP32, dan Raspberry Pi Pico. Setelah itu kamu akan belajar bagaimana rentang pulsa 500–2400 µs berubah menjadi sudut, cara mencari batas servomu sendiri dari Serial Monitor, dan cara mengoreksi kesalahan sudut dengan kalibrasi tiga titik. Bagian terakhir membahas ukuran catu daya terpisah, kontrol dari ponsel dengan ESP32, kode MicroPython untuk Pico, dan sendi lengan robot mana yang cocok untuk MG90S.

Motor servo mikro MG90S bergear logam
MG90S: dimensi bodi sama dengan SG90, gear logam, dan tiga kabel berwarna cokelat, merah, dan oranye.

Apa itu servo MG90S dan bagaimana cara kerjanya?

Di dalam MG90S ada motor DC kecil, gearbox logam yang memperlambat motor dan melipatgandakan torsinya, potensiometer yang mengukur sudut poros output, dan papan kontrol yang mengatur semuanya. Setiap 20 ms (50 Hz), papan mengukur lebar pulsa yang masuk dari kabel sinyal, membandingkannya dengan sudut yang dilaporkan potensiometer, lalu menggerakkan 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 adalah setengah dari 10 µs milik SG90, jadi MG90S merespons perubahan pulsa yang lebih kecil dan menahan posisinya dengan lebih presisi. Dasar cara kerja servo sudah kami bahas di Apa itu motor servo?.

FiturNilai
Tegangan kerja4,8–6 V
Torsi macet1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V) ≈ 0,18–0,22 N·m
Kecepatan (per 60°)0,10 s (4,8 V), 0,08 s (6 V)
Arus diamSekitar 5–10 mA (poros diam, tanpa beban)
Arus ketika bergerakSekitar 120–250 mA (tanpa beban)
Arus macetSekitar 0,7–1 A
Dead band5 µs
PutaranSekitar 180° dengan 500–2400 µs (berbeda dari unit ke unit)
Sinyal50 Hz (periode 20 ms), posisi diatur oleh lebar pulsa
GearGear logam, bantalan di poros output
Berat dan ukuran13,4 g, 22,8 × 12,2 × 28,5 mm
KabelSekitar 25 cm; cokelat GND, merah positif, oranye sinyal
Suhu kerja0–55 °C

MG90S vs SG90: gear, torsi, dan arus

Dari luar, kedua servo ini hampir identik: lubang baut, lebar bodi, dan horn-nya kompatibel, jadi MG90S bisa langsung dipasang di dudukan yang dirancang untuk SG90. Perbedaan sebenarnya ada di dalam. Gear plastik SG90 meloncat giginya dan patah ketika lengan membentur sesuatu atau porosnya dipaksa dengan tangan; gear logam MG90S biasanya tetap aman menghadapi benturan yang sama. Di 6 V torsinya naik dari 1,8 menjadi 2,2 kg·cm dan kecepatannya turun menjadi 0,08 detik per 60 derajat. Sebagai gantinya, MG90S sekitar 4,4 gram lebih berat, menarik arus sedikit lebih besar ketika macet, dan biasanya dua sampai tiga kali lebih mahal daripada SG90. Gear logam juga bisa punya sedikit celah (backlash); di lengan yang presisi, ini terlihat sebagai kelonggaran satu atau dua derajat ketika arah beban berubah.

FiturSG90MG90SMG996R
GearPlastikLogamLogam, bantalan ganda
Torsi macet1,8 kg·cm (4,8 V)1,8 kg·cm (4,8 V), 2,2 kg·cm (6 V)9,4 kg·cm (4,8 V), 11 kg·cm (6 V)
Kecepatan (per 60°)0,10 s (4,8 V)0,10 s (4,8 V), 0,08 s (6 V)0,17 s (4,8 V), 0,14 s (6 V)
Dead band10 µs5 µs5 µs
Berat9 g13,4 g55 g
Ukuran22,2 × 11,8 × 31 mm22,8 × 12,2 × 28,5 mm40,7 × 19,7 × 42,9 mm
Tegangan kerja4,8–6 V4,8–6 V4,8–7,2 V
Arus macetSekitar 0,6–0,75 ASekitar 0,7–1 A2,5 A (6 V)
Ketahanan benturanRendah, gear mudah dolBaikSangat baik
Dari pin 5V ArduinoSatu servo, beban ringanSatu servo, beban ringanTidak, selalu pakai catu daya eksternal
Pemakaian umumEksperimen pertama, tutup yang ringanPergelangan, gripper, pan-tilt, robot kecilBahu lengan robot, tutup berat, kemudi
SG90
SG90
MG90S
MG90S
MG996R
MG996R

Untuk memilih, hitung dulu torsi yang kamu butuhkan: torsi adalah berat beban dikalikan jaraknya dari poros. Beban 100 g yang berjarak 5 cm dari poros butuh 0,1 × 5 = 0,5 kg·cm. Di 5 V, MG90S memberi sekitar 2 kg·cm, tetapi itu batas macet, ketika poros berhenti; untuk pemakaian terus-menerus, tetap di bawah setengahnya, sekitar 1 kg·cm, menjaga servo tetap dingin dan gear lebih awet. Dengan aturan itu, MG90S nyaman membawa hingga 200 g di ujung lengan 5 cm dan hingga 100 g di ujung lengan 10 cm. Kalau kamu butuh lebih dari 1 kg·cm, naik ke servo MG996R; kalau hanya bereksperimen atau memutar komponen seberat beberapa gram, SG90 sudah cukup.

Warna kabel dan pengkabelan MG90S

Tiga kabel MG90S mengikuti skema warna TowerPro. Beberapa produsen memakai warna lain, tetapi urutannya hampir selalu sama, dengan positif di tengah. Kalau konektornya terpasang terbalik, servo biasanya tidak rusak, hanya tidak berfungsi; tetap saja perbaiki segera, karena arus ground servo akan mencoba mengalir lewat pin sinyal Arduino.

Kabel (TowerPro)FungsiMerek lainSambungkan ke
CokelatGND (negatif)HitamNegatif catu daya dan GND Arduino
MerahPositif (4,8–6 V)Merah5 V atau positif eksternal 5–6 V
OranyeSinyal (PWM)Kuning atau putihPin digital di board
SambunganArduino UnoESP32Raspberry Pi Pico
Oranye (sinyal)D9GPIO 18GP15
Merah (positif): satu servo, beban ringanPin 5VPin 5V (VIN), dari USBPin VBUS (5 V dari USB)
Merah (positif): ada beban atau beberapa servoEksternal 5–6 VEksternal 5–6 VEksternal 5–6 V
Cokelat (GND)GND dan negatif catu dayaGND dan negatif catu dayaGND dan negatif catu daya
Potensiometer (contoh Uno)Kaki tengah ke A0, kaki luar ke 5V dan GND——
Servo kedua (contoh Pico)——GP14
Jangan pernah menyambungkan kabel merah ke pin 3,3 V: servo bekerja lemah dan membebani regulator kecil di board. Beri daya satu MG90S dari pin 5V Arduino hanya untuk uji tanpa beban; ketika servo macet, arus yang mendekati 1 A melewati batas 500 mA USB dan board reset. Baterai LiPo 2S 7,4 V melewati batas 6 V milik MG90S; kalau disambungkan langsung, papan kontrolnya bisa terbakar. Ketika memakai catu daya eksternal, jangan lupa menyatukan ground; alasannya kami jelaskan di Apa itu GND?.

Catu daya terpisah: berapa servo, berapa arus?

MG90S menarik 120–250 mA ketika bergerak tanpa beban, tetapi di milidetik pertama setiap kali mulai bergerak dan ketika porosnya dipaksa, arusnya melonjak ke 0,7–1 A. Dengan lebih banyak servo, lonjakan ini menumpuk. Perhitungkan juga pengkabelannya: kontak breadboard dan kabel jumper tipis dengan mudah mencapai 0,2 Ω. Hitung dengan hukum Ohm: pada lonjakan 3,2 A dari empat servo yang mulai bersamaan, 3,2 × 0,2 = 0,64 V hilang di kabel saja; catu daya 5 V sampai ke servo sebagai 4,4 V, dan servo melemah serta bergetar. Membagi daya servo lewat terminal sekrup atau rel yang disolder, bukan lewat breadboard, mengurangi kerugian ini secara drastis.

Jumlah servoKetika bergerakKondisi terburuk (semua macet)Catu daya yang disarankan
10,12–0,25 ASekitar 1 A5V Arduino untuk uji tanpa beban, 5 V 1 A dengan beban
2 (pan-tilt)0,25–0,5 A2 A5 V, 2 A
4 (lengan robot kecil)0,5–1 A4 A5 V, 3–4 A
60,75–1,5 A6 A5–6 V, 5 A, dan kode yang menggerakkan servo satu per satu
16 (PCA9685)2–4 A16 ACatu daya switching 5–6 V, 10 A atau lebih
  1. Pilih catu daya: pakai adaptor switching 5 V atau 4 baterai AA NiMH (4,8 V). Baterai alkaline baru bisa mencapai 1,6 V per sel, jadi tempat baterai 4 sel bisa memberi 6,4 V, sedikit di atas batas MG90S.
  2. Alirkan positif ke servo: sambungkan positif catu daya ke kabel merah servo; jangan sambungkan ke pin 5V Arduino.
  3. Satukan ground: sambungkan negatif catu daya ke kabel cokelat servo sekaligus ke pin GND Arduino; tanpa ground bersama, servo tidak bisa membaca pulsa dengan benar.
  4. Tambahkan kapasitor: pasang kapasitor elektrolit 470 µF / 16 V di jalur catu daya servo, dekat dengan servo; untuk beberapa servo tambahkan sekitar 100 µF per servo. Kaki bergaris disambungkan ke negatif.
  5. Sambungkan sinyal: sambungkan kabel oranye ke pin D9 Uno dan beri daya Arduino secara terpisah dari USB atau colokan DC-nya.
Kalau kamu punya adaptor 12 V, kamu bisa mengatur output modul LM2596 ke 5–6 V dan dengan nyaman memberi daya hingga tiga servo MG90S. Untuk proyek bertenaga baterai, perkirakan lama pemakaiannya dengan kalkulator umur baterai; arus rata-rata servo bisa berbeda sepuluh kali lipat tergantung apakah servo terus bergerak atau hanya sesekali.

Rentang pulsa 500–2400 µs dan library Servo

Dengan library Servo bawaan Arduino IDE, menulis servo.attach(9) memberi rentang default 544–2400 µs, dan write(0) serta write(180) dipetakan ke kedua ujung itu. Sebagian besar MG90S butuh pulsa lebih pendek dari 544 µs untuk 0 derajat, jadi dengan pengaturan default servo kurang beberapa derajat di salah satu ujung. Menentukan rentang dengan servo.attach(9, 500, 2400) mengatasinya. Detail ini penting karena writeMicroseconds() juga tidak bisa keluar dari batas yang diberikan ke attach; tanpa batas itu, 500 µs yang kamu tulis diam-diam dinaikkan menjadi 544. Di rentang 500–2400 µs, satu derajat sekitar 1900 / 180 ≈ 10,6 µs. Karena dead band MG90S 5 µs, kamu bahkan bisa membuat langkah setengah derajat dengan writeMicroseconds().

SudutDefault attach(9) (544–2400)attach(9, 500, 2400)Catatan
0°544 µs500 µsSelisih beberapa derajat di ujung
45°1008 µs975 µs—
90°1472 µs1450 µsTitik tengah sebenarnya biasanya antara 1450 dan 1550 µs
135°1936 µs1925 µs—
180°2400 µs2400 µsPersempit kalau membentur batas mekanis

Nilai di tabel adalah hasil hitungan; pada servo sungguhan, pulsa yang dibutuhkan untuk 90 derajat bisa 1500 atau 1520 µs, bukan 1450. Beberapa datasheet menyebut 1000–2000 µs memberi gerak penuh, tetapi pada praktiknya MG90S hanya berputar 90–100 derajat di rentang itu. Kalau pulsanya didorong melewati batas mekanis, servo menekan batas internalnya, berdengung, menarik arus macet, dan memanas; karena gear logam menahan tekanan ini tanpa suara, kamu tidak akan secepat itu menyadari masalahnya seperti pada SG90. Karena itu tugas pertama adalah mengukur batas servomu sendiri.

Kalibrasi sudut: cari batas MG90S-mu sendiri

Kode di bawah menggerakkan servo dengan langkah 10 µs memakai karakter yang kamu ketik di Serial Monitor. + memperpanjang pulsa, - memperpendeknya, dan c kembali ke tengah (1500 µs); n menyimpan nilai sekarang sebagai batas bawah dan x sebagai batas atas. Setelah setiap penyimpanan, kode menampilkan baris attach siap pakai untuk sketch-sketch berikutnya. Untuk beberapa langkah sekaligus, ketik +++++ lalu tekan Enter; servo bergerak lima langkah, atau 50 µs.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu sinyal kablosu / orange signal wire
4const int STEP_US = 10;            // her + ya da - için 10 µs / 10 µs per + or -
5
6Servo servo;
7int pulseUs = 1500;                // ortadan başla / start at the center
8int minUs = 1000;                  // bulunacak alt sınır / lower limit to find
9int maxUs = 2000;                  // bulunacak üst sınır / upper limit to find
10
11void printPulse() {
12  Serial.print(F("Darbe / pulse: "));
13  Serial.print(pulseUs);
14  Serial.println(F(" us"));
15}
16
17void setup() {
18  Serial.begin(115200);
19  servo.writeMicroseconds(pulseUs);      // önce darbe, sonra attach / pulse first, then attach
20  servo.attach(SERVO_PIN, 500, 2500);    // geniş aralık: sınırı sen bulacaksın / wide range: you find the limits
21  Serial.println(F("+ / - : 10 us | c: 1500 us | n: min | x: max"));
22  printPulse();
23}
24
25void loop() {
26  if (!Serial.available()) return;
27  char key = Serial.read();
28  if (key == '+') pulseUs += STEP_US;
29  else if (key == '-') pulseUs -= STEP_US;
30  else if (key == 'c') pulseUs = 1500;
31  else if (key == 'n') minUs = pulseUs;    // alt sınırı kaydet / save the lower limit
32  else if (key == 'x') maxUs = pulseUs;    // üst sınırı kaydet / save the upper limit
33  else return;                             // Enter ve diğer tuşları yok say / ignore Enter and other keys
34
35  pulseUs = constrain(pulseUs, 500, 2500);
36  servo.writeMicroseconds(pulseUs);
37  printPulse();
38
39  if (key == 'n' || key == 'x') {          // hazır attach satırı / ready-made attach line
40    Serial.print(F("servo.attach(9, "));
41    Serial.print(minUs);
42    Serial.print(F(", "));
43    Serial.print(maxUs);
44    Serial.println(F(");"));
45  }
46}
  1. Sambungkan servo tanpa beban, upload kode, lalu buka Serial Monitor di 115200 baud.
  2. Ketik c lalu tekan Enter; servo menuju 1500 µs. Pasang horn di posisi gerigi yang paling dekat dengan titik tengah mekanismemu.
  3. Bergerak ke ujung bawah dengan -. Ketika servo berhenti berputar, berdengung, atau bergetar, mundur 3–4 langkah (30–40 µs) lalu ketik n.
  4. Lakukan hal yang sama untuk ujung atas dengan + lalu ketik x. Catat baris servo.attach(9, MIN, MAX) yang muncul di Serial Monitor.
  5. Cari 90 derajat dengan busur derajat yang digambar di kertas atau dicetak: simpan pulsa ketika horn berdiri tegak lurus sebagai US_90.

Karena gerigi di poros servo, horn hanya bisa dipasang dalam langkah tetap, jadi jarang tepat di tengah, dan beberapa derajat selisihnya kamu koreksi di software. Selain itu, hubungan pulsa dan sudut pada servo tidak benar-benar linear: pemetaan dua titik yang tepat di 0 dan 180 derajat bisa meleset 3–5 derajat di tengah. Kalibrasi tiga titik menghilangkan kesalahan ini: kamu memakai tiga pulsa hasil ukur untuk 0, 90, dan 180 derajat, lalu memanggil fungsi map() terpisah untuk setiap setengahnya. Kode di bawah memakai cara ini untuk meneruskan sudut yang dibaca dari potensiometer di A0 ke servo.

C++ (Arduino IDE)
1#include <Servo.h>
2
3const byte SERVO_PIN = 9;          // turuncu kablo / orange wire
4const byte POT_PIN = A0;           // potansiyometre orta bacağı / potentiometer wiper
5
6// Kalibrasyonda ölçtüğün üç nokta / the three points you measured
7const int US_0 = 520;              // 0 derece / 0 degrees
8const int US_90 = 1480;            // korna tam dik / horn exactly upright
9const int US_180 = 2380;           // 180 derece / 180 degrees
10
11Servo servo;
12float smoothAngle = 90;            // süzülmüş açı / filtered angle
13int lastAngle = -1;
14
15int angleToUs(int angle) {
16  angle = constrain(angle, 0, 180);
17  if (angle <= 90) return map(angle, 0, 90, US_0, US_90);   // alt yarı / lower half
18  return map(angle, 90, 180, US_90, US_180);                // üst yarı / upper half
19}
20
21void setup() {
22  servo.writeMicroseconds(angleToUs(90));   // açılışta ortada başla / start centered
23  servo.attach(SERVO_PIN, US_0, US_180);
24}
25
26void loop() {
27  int target = map(analogRead(POT_PIN), 0, 1023, 0, 180);
28  smoothAngle += (target - smoothAngle) * 0.15;   // gürültüyü süz / filter the noise
29  int angle = (int)(smoothAngle + 0.5);
30  if (abs(angle - lastAngle) >= 2) {             // 2 derecelik ölü bant / 2-degree deadband
31    servo.writeMicroseconds(angleToUs(angle));
32    lastAngle = angle;
33  }
34  delay(15);
35}

Ganti US_0, US_90, dan US_180 dengan hasil ukurmu sendiri. angleToUs() memetakan 0–90 di antara dua titik pertama dan 90–180 di antara dua titik terakhir, jadi posisi ketika horn tegak lurus memang benar 90 derajat. Memakai writeMicroseconds() juga menghindari write() membulatkan ke derajat bulat. Derau beberapa angka pada bacaan potensiometer diredam dengan filter sederhana berfaktor 0,15 dan dead band 2 derajat; tanpa dead band, servo terus tersentak-sentak di tempat. Penyebab getaran lainnya kami bahas rinci di masalah servo bergetar. Di Uno, library Servo memakai Timer1, jadi analogWrite() tidak berfungsi di pin D9 dan D10 selama ada servo yang terpasang.

MG90S dengan ESP32: kendalikan dari ponsel dengan slider

Library Servo standar Arduino tidak berfungsi di ESP32; pasang library ESP32Servo dari Library Manager. Library ini berfungsi di core ESP32 versi 2.x maupun 3.x, menerima periode dengan setPeriodHertz(50), dan tidak menerima batas di luar 500–2500 µs. Output sinyal ESP32 adalah 3,3 V, dan hampir semua MG90S bisa membacanya tanpa masalah. Kode di bawah menyambungkan ESP32 ke jaringan Wi-Fi-mu; buka alamat IP yang muncul di Serial Monitor di ponsel yang ada di jaringan yang sama, dan kamu akan melihat slider; begitu dilepas, servo berputar ke sudut tersebut.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* ssid = "AgAdi";          // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123";   // Wi-Fi şifren / your Wi-Fi password
7const int SERVO_PIN = 18;            // turuncu kablo / orange wire
8const int MIN_US = 500;              // kalibrasyon değerlerin / your calibration values
9const int MAX_US = 2400;
10
11WebServer server(80);
12Servo servo;
13int currentAngle = 90;
14
15const char PAGE[] = R"rawliteral(<!DOCTYPE html><html><head>
16<meta name="viewport" content="width=device-width,initial-scale=1"><title>MG90S</title></head>
17<body style="font-family:sans-serif;text-align:center">
18<h2>MG90S: <span id="v">90</span>&deg;</h2>
19<input id="s" type="range" min="0" max="180" value="90" style="width:90%">
20<script>
21const s = document.getElementById('s'), v = document.getElementById('v');
22s.oninput = () => v.textContent = s.value;
23s.onchange = () => fetch('/set?a=' + s.value);
24</script></body></html>)rawliteral";
25
26void handleRoot() {
27  server.send(200, "text/html", PAGE);
28}
29
30void handleSet() {
31  if (server.hasArg("a")) {
32    currentAngle = constrain(server.arg("a").toInt(), 0, 180);   // 0–180 ile sınırla / clamp to 0–180
33    servo.write(currentAngle);
34  }
35  server.send(200, "text/plain", String(currentAngle));
36}
37
38void setup() {
39  Serial.begin(115200);
40  servo.setPeriodHertz(50);                  // 50 Hz servo sinyali / 50 Hz servo signal
41  servo.attach(SERVO_PIN, MIN_US, MAX_US);
42  servo.write(currentAngle);
43
44  WiFi.begin(ssid, password);
45  while (WiFi.status() != WL_CONNECTED) delay(300);
46  Serial.print(F("IP: "));
47  Serial.println(WiFi.localIP());            // bu adresi telefonda aç / open this address on your phone
48
49  server.on("/", handleRoot);
50  server.on("/set", handleSet);
51  server.begin();
52}
53
54void loop() {
55  server.handleClient();
56}

Ketika ESP32 menyalakan Wi-Fi, ia sesaat menarik arus hingga 250 mA; kalau arus awal servo jatuh di jalur USB yang sama, board menampilkan "Brownout detector was triggered" dan restart. Beri daya servo dari catu daya 5 V terpisah dan satukan ground-nya; detailnya ada di error brownout ESP32. GPIO 13, 18, 19, 23, 25, 26, dan 27 adalah pilihan yang bagus untuk sinyal; jangan pakai GPIO 6–11 yang terhubung ke flash, atau 34–39 yang hanya input.

MG90S 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(). Kelas kecil MicroServo di bawah menyimpan nilai kalibrasi masing-masing servo dan bergerak satu derajat setiap kali agar gerakannya halus. Di contoh ini, pergelangan lengan robot ada di GP15 dan gripper di GP14. Di Pico, kedua pin ini berbagi slice PWM yang sama (slice 7), jadi frekuensinya juga sama; itu tidak masalah karena keduanya memakai 50 Hz, tetapi kalau kamu mengatur pin lain di slice yang sama ke 1 kHz untuk kecerahan LED, servo juga ikut kacau. Untuk dua servo, pakai catu daya 5 V eksternal alih-alih VBUS dan satukan ground-nya.

MicroPython
1from machine import Pin, PWM
2import time
3
4class MicroServo:
5    def __init__(self, pin, min_us=500, max_us=2400):
6        self.pwm = PWM(Pin(pin))
7        self.pwm.freq(50)                  # 50 Hz = 20 ms periyot / 20 ms period
8        self.min_us = min_us               # bu servonun kalibrasyonu / this servo's calibration
9        self.max_us = max_us
10        self.angle = None
11
12    def write(self, angle):
13        angle = max(0, min(180, angle))   # 0–180 ile sınırla / clamp to 0–180
14        us = self.min_us + (self.max_us - self.min_us) * angle / 180
15        self.pwm.duty_ns(int(us * 1000))  # µs -> ns
16        self.angle = angle
17
18    def move_to(self, target, ms_per_degree=10):
19        if self.angle is None:            # ilk komut: doğrudan git / first command: go directly
20            self.write(target)
21            return
22        step = 1 if target > self.angle else -1
23        for a in range(int(self.angle), int(target) + step, step):
24            self.write(a)                 # derece derece ilerle / move degree by degree
25            time.sleep_ms(ms_per_degree)
26
27    def off(self):
28        self.pwm.duty_ns(0)               # sinyali kes, servo serbest / stop the signal, servo goes limp
29
30wrist = MicroServo(15, 520, 2380)        # bilek GP15 / wrist on GP15
31gripper = MicroServo(14, 600, 2300)      # kıskaç GP14, aynı PWM dilimi / gripper on GP14, same PWM slice
32
33wrist.write(90)
34gripper.write(20)
35time.sleep(1)
36
37while True:
38    gripper.move_to(70)                  # kıskacı kapat / close the gripper
39    wrist.move_to(150)
40    time.sleep(0.5)
41    wrist.move_to(30)
42    gripper.move_to(20)                  # kıskacı aç / open the gripper
43    time.sleep(1)

MG90S di lengan robot: cocok untuk sendi yang mana?

Lengan robot kecil 4 sumbu dari akrilik atau hasil cetak 3D biasanya dibuat dengan empat servo mikro, dan di lengan seperti ini MG90S jauh lebih awet daripada SG90: ketika lengan membentur sesuatu atau gripper dipaksa dengan tangan, gear plastiklah yang pertama patah. Di lengan yang lebih besar, MG90S hanya dipakai di sendi ujung. Hitungannya sederhana: kalikan berat setiap bagian setelah sendi dengan jaraknya dari poros sendi, lalu jumlahkan. Gripper 40 g di 6 cm dan benda 50 g di 8 cm memberi 0,04 × 6 + 0,05 × 8 = 0,64 kg·cm pada servo pergelangan, di bawah batas aman MG90S sekitar 1 kg·cm di 5 V.

SendiBeban umumApakah MG90S cocok?
Dasar (putaran)Rendah kalau berat lengan bertumpu pada bantalanYa di lengan kecil, MG996R di lengan besar
BahuPaling tinggi, 2–5 kg·cmHanya di lengan yang sangat ringan; biasanya MG996R
SikuSedang, 1–3 kg·cmYa di lengan pendek
PergelanganRendah, 0,3–1 kg·cmYa, ideal
GripperRendah, tetapi berisiko terus menjepitYa; batasi sudut menutupnya sesuai benda

Kesalahan gripper yang paling umum adalah mengirim servo melewati sudut ketika ia sudah menjepit benda. Karena tidak bisa mencapai target, servo terus menarik arus macet, memanas, dan dalam beberapa menit motor atau papan kontrolnya bisa rusak. Atur sudut menutup sampai titik ketika capitnya baru menyentuh benda, atau mundurkan sudutnya beberapa derajat setelah benda tergenggam. Perhitungan torsi lengkap dan cara membuat lengan 6 sumbu ada di panduan lengan robot Arduino; kalau kamu ingin menggerakkan lebih dari enam servo dari satu board, driver servo PCA9685 mempermudah pekerjaannya.

Ide proyek MG90S

  • Dudukan kamera pan-tilt: putar modul ESP32-CAM secara horizontal dan vertikal dengan dua servo MG90S; gear logam tahan terhadap guncangan.
  • Radar Arduino: sapukan sensor HC-SR04 dari 0 sampai 180 derajat dengan MG90S dan gambar layar radar; cara membuatnya ada di proyek radar Arduino.
  • Tempat sampah pintar: tempat sampah pintar yang membuka tutup ringan ketika tangan mendekat.
  • Pemberi makan hewan otomatis: pemberi makan hewan yang membuka dan menutup penutup kecil pada waktu yang ditentukan.
  • Robot penghindar rintangan: servo leher yang memutar sensor jarak ke kiri dan kanan; lihat panduan robot penghindar rintangan.
  • Pelacak matahari mini: cari arah cahaya dengan dua LDR dan putar panel kecil dengan MG90S; detailnya ada di pelacak matahari.
  • Tugas yang butuh putaran terus-menerus: untuk roda atau konveyor, pakai servo 360 derajat alih-alih MG90S.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Servo kurang beberapa derajat di salah satu ujungRentang default 544–2400 µsTulis attach(9, 500, 2400) lalu kalibrasi
Berdengung dan memanas di ujungPulsa melewati batas mekanisPersempit ke nilai MIN dan MAX yang kamu temukan
Arduino reset ketika servo bergerakServo diberi daya dari USB lewat pin 5VCatu daya 5 V eksternal, GND bersama, dan kapasitor 470 µF
Bergetar ketika diamCatu daya lemah, kabel panjang dan tipis, atau derau potensiometerKabel tebal, kapasitor, filter, dan dead band
Tidak ada respons sama sekali, atau gerakan acakGND catu daya eksternal tidak tersambung ke ArduinoSambungkan negatif catu daya ke GND Arduino
Berbunyi klik ketika dibebani, poros selipGigi gear patah atau sekrup horn kendurGanti set gear, kencangkan sekrup tengah
Torsi jauh lebih kecil dari perkiraan, servo seberat 9 gTiruan dengan gear plastikTimbang servonya: MG90S asli sekitar 13–14 g
Servo melompat tiba-tiba ketika dinyalakanattach() mengirim 1500 µs sebagai pulsa pertamaBerikan pulsa awal dengan writeMicroseconds() sebelum attach()
Kalau servo tidak perlu menahan beban, putuskan sinyalnya dengan servo.detach() setelah mencapai target; servo menjadi senyap dan hampir tidak menarik arus. Namun, torsi penahan ikut hilang bersama sinyal, jadi jangan pakai detach di sendi lengan yang menahan beban. Memaksa poros dengan tangan mungkin tidak mematahkan gear logam, tetapi membebani motor dan potensiometer di dalamnya; selalu putar horn dengan pelan dan dalam keadaan servo mati.

MG90S adalah pilihan tepat untuk proyek apa pun yang butuh servo lebih tangguh dan sedikit lebih kuat tanpa keluar dari ukuran SG90. Ingat aturannya: catu daya 5 V eksternal untuk apa pun selain beban ringan, GND bersama, kapasitor di dekat servo, rentang pulsa yang dimulai dari 500–2400 µs lalu dipersempit lewat kalibrasi, dan sudut menutup yang dibatasi pada gripper. Di aplikasi BlueGrays kamu bisa menemukan kontrol servo dengan potensiometer dan joystick, kunci pintu RFID dengan servo di ESP32, dan proyek koreografi 32 servo, masing-masing dengan diagram rangkaian langkah demi langkah dan kode siap pakai.

Pertanyaan umum

Apa bedanya MG90S dan SG90?

Ukuran dan pengkabelannya sama, tetapi MG90S punya gear logam dan memberi torsi 2,2 kg·cm di 6 V, sedangkan gear plastik SG90 memberi sekitar 1,8 kg·cm dan mudah dol ketika benturan. MG90S sekitar 13,4 g dibanding SG90 yang 9 g, dan menarik arus sedikit lebih besar ketika macet. Di kode tidak ada perbedaan; keduanya berfungsi dengan library Servo yang sama.

Berapa berat yang bisa diangkat servo MG90S?

Torsi macet MG90S adalah 1,8 kg·cm di 4,8 V dan 2,2 kg·cm di 6 V, jadi di jarak 1 cm dari poros ia hanya bisa menahan sekitar 2 kg. Untuk pemakaian terus-menerus, hitung setengah torsinya: sekitar 200 g di ujung lengan 5 cm dan sekitar 100 g di ujung lengan 10 cm.

Bisakah MG90S diberi daya dari pin 5V Arduino?

Untuk uji tanpa beban, satu MG90S bisa diberi daya dari pin 5V Arduino. Namun, ketika servo dipaksa, arus yang mendekati 1 A melewati batas 500 mA USB dan Arduino reset. Untuk proyek dengan beban atau beberapa servo, pakai catu daya 5 V eksternal dan satukan ground-nya.

Apakah MG90S 180 atau 360 derajat?

MG90S standar berputar sekitar 180 derajat; gerak penuhnya biasanya butuh pulsa 500–2400 µs, dan batasnya berbeda dari unit ke unit. Versi putaran terus-menerus 360 derajat juga dijual, tetapi dengan versi itu kamu mengendalikan kecepatan dan arah, bukan sudut.

Kenapa servo MG90S-ku bergetar atau berdengung?

Penyebab paling umum adalah catu daya yang lemah: servo yang diberi daya dari USB menurunkan tegangan ketika mulai bergerak. Kalau berdengung di ujung, rentang pulsanya melewati batas mekanis, jadi persempit dengan kalibrasi. Kalau bergetar ketika dikendalikan potensiometer, saring bacaannya dan tambahkan dead band 1–2 derajat.

Apakah MG90S berfungsi dengan ESP32 dan sinyal 3,3 V?

Ya. Papan kontrol MG90S bisa membaca sinyal 3,3 V tanpa masalah; cukup pakai library ESP32Servo di ESP32 atau kelas PWM MicroPython di Pico. Daya servo tetap harus 5 V; jangan beri daya dari pin 3,3 V.

Lihat semua proyek
Menggunakan Motor Servo
AR-35Pemula
Premium

Menggunakan Motor Servo

Lengan motor servo kecil berputar ke tiga posisi bergantian: penuh ke awal, tepat ke tengah, dan penuh ke akhir, menunggu dua detik di setiap perhentian.

4.7(48)
67
Menggerakkan Motor Servo dengan Potensiometer
AR-36Pemula
Premium

Menggerakkan Motor Servo dengan Potensiometer

Ketika kamu memutar kenop potensiometer, lengan motor servo ikut berputar: satu ujung kenop berarti nol derajat, ujung lainnya berarti setengah putaran.

4.6(37)
53
Kendali Servo dengan Joystick
AR-60Menengah
Premium

Kendali Servo dengan Joystick

Arahkan dua motor dengan joystick, persis seperti memutar kamera keamanan. Dorong tuas ke kiri atau kanan dan servo bawah berputar perlahan, dorong ke atas atau bawah dan servo atas mendongak dan…

4.7(42)
58
Motor Servo ESP32 (Kendali Potensiometer)
ES-16Menengah
Premium

Motor Servo ESP32 (Kendali Potensiometer)

Di proyek ini, kita mengendalikan motor servo SG90 memakai potensiometer. Kita mengatur sudut servo dengan memetakan nilai analog yang dibaca dari potensiometer ke rentang 0–180 derajat. Library ESP32Servo menghasilkan sinyal servo di pin GPIO ESP32 yang sesuai dan bisa menjadi output; proyek ini memakai GPIO 18. Ini metode kendali dasar untuk lengan robot, gimbal kamera, dan mekanisme pintu otomatis.

4.3(29)
42
Kunci Pintu RFID ESP32 (RC522 + Servo + OLED + Buzzer + LED)
ES-35Mahir
Premium

Kunci Pintu RFID ESP32 (RC522 + Servo + OLED + Buzzer + LED)

Kita membuat kunci pintu pintar dengan ESP32, modul RFID RC522, motor servo SG90, layar OLED SSD1306, buzzer aktif, dan 2 LED. Ketika sebuah kartu dipindai, UID-nya dibandingkan dengan daftar kartu resmi yang disimpan di kode; jika resmi, motor servo berputar untuk membuka kunci (LED hijau + 2 bunyi bip pendek), dan pintu otomatis terkunci lagi setelah 5 detik. Untuk kartu tidak resmi, LED merah menyala, peringatan diberikan dengan 3 bunyi bip cepat, dan UID yang terbaca ditampilkan di layar.

4.8(9)
16
Koreografi Lingkaran Servo - Pola Animasi dengan 32 Servo
AR-97Mahir
Premium

Koreografi Lingkaran Servo - Pola Animasi dengan 32 Servo

Proyek animasi visual dengan 32 motor servo yang disusun melingkar di Arduino Mega. Servo-servo dikelola dalam satu array, tersambung ke pin 22-53 Mega, dan menampilkan empat urutan gerak: getaran kacau ketika semua servo bergerak ke sudut acak, sapuan serempak ketika semuanya bergerak bersamaan, gelombang yang berputar halus mengelilingi lingkaran, dan terakhir jarum kompas yang berayun ke kiri dan kanan.

4.5(40)
62
Robot Penghindar Rintangan
AR-81Mahir
Premium

Robot Penghindar Rintangan

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

5.0(38)
49