MG996R Servo Motor: Tork, Akım, Besleme ve Arduino Kodu

MG996R servo, metal dişlileri ve 6 V'ta 11 kg·cm'ye varan torkuyla Arduino projelerinde ağır işlerin standart servo motorudur. 55 gramlık gövdesiyle robot kolun omzunu kaldırır, ağır bir kapağı açar, pan-tilt kamera yuvasını döndürür. Ancak bu gücün bir bedeli vardır: MG996R zorlandığında 2,5 A'e kadar akım çeker. Bu yüzden SG90 gibi Arduino'nun 5V pinine takılıp çalıştırılamaz; harici 5–6 V besleme, ortak GND ve servoya yakın bir kondansatör ister. Bu kurallara uyulmadığında servo titrer, Arduino kendini resetler, hatta bilgisayar USB portunu kapatır.

Bu rehberde MG996R'ın tork ve akım değerlerini gerçek sayılarla yorumlamayı, doğru güç kaynağını seçmeyi, Servo kütüphanesiyle 500–2500 µs aralığını kullanıp kendi servonun sınırlarını bulmayı, titremeyi ve resetlenmeyi önlemeyi öğreneceksin. Ardından ESP32 ve Raspberry Pi Pico kodlarına, 16 servoyu iki kabloyla süren PCA9685 modülüne, robot kol için servo seçimine ve SG90 ile MG90S karşılaştırmasına geçeceğiz.

MG996R servo nedir, nasıl çalışır?

MG996R, TowerPro'nun eski MG995 modelinin geliştirilmiş sürümüdür: yenilenen kontrol kartı ve dişliler sayesinde daha kararlı merkezlenir ve daha az boşluk bırakır. Gövdenin içinde küçük bir DC motor, motoru yavaşlatıp torku artıran metal dişli kutusu, çıkış milinin açısını ölçen bir potansiyometre ve bunları yöneten kontrol kartı bulunur. Kart, sinyal kablosundan her 20 ms'de (50 Hz) bir gelen darbenin genişliğini okur, istenen açıyla potansiyometrenin gösterdiği açıyı karşılaştırır ve fark kapanana kadar motoru döndürür. Yaklaşık 1500 µs'lik darbe orta konum demektir; darbe kısaldıkça mil bir yöne, uzadıkça diğer yöne döner. Veri sayfasındaki 5 µs ölü bant, servonun bundan küçük değişikliklere tepki vermediğini gösterir. Servo motorların genel çalışma mantığını Servo Motor Nedir? yazısında temelden anlattık.

Tork ne demek? kg·cm değerini doğru okumak

Tork, servonun milinden belli bir uzaklıktaki yükü döndürme gücüdür ve kuvvet × uzaklık olarak ölçülür. 11 kg·cm, milden 1 cm uzaktaki 11 kg'lık yükü ya da 10 cm uzaktaki 1,1 kg'ı tutabilmek demektir; uzaklık iki katına çıkınca taşınabilecek yük yarıya iner. Newton metreye çevirmek için 0,098 ile çarp: 11 kg·cm ≈ 1,08 N·m. Burada kritik ayrıntı şudur: veri sayfasındaki değer kilitlenme torkudur, yani servonun milinin durduğu, en yüksek akımı çektiği ve ısındığı sınırdır. Sürekli çalışmada bu değerin en fazla yarısını kullanmak servoyu serin tutar, titremeyi azaltır ve dişlilerin ömrünü uzatır.

Tablo yalnızca uçtaki yükü hesaba katar. Gerçek bir mekanizmada kolun kendi ağırlığı, üzerine takılan diğer servolar ve kıskaç da torka eklenir; her parçanın kütlesini milden uzaklığıyla çarpıp toplaman gerekir. Örneğin 15 cm'lik bir kolun ucunda 150 g'lık bir kıskaç ve 100 g'lık bir nesne varsa yalnızca bu ikisi 0,25 × 15 = 3,75 kg·cm eder; kolun kendi ağırlığıyla birlikte toplam 5 kg·cm'yi bulabilir. Bu, MG996R'ın 6 V'taki kilitlenme torkunun yarısının biraz altındadır, yani doğru seçimdir. Parça parça tork hesabını Arduino robot kol rehberinde örnekle bulabilirsin.

Akım: MG996R neden Arduino'nun 5V pininden beslenmez?

MG996R yüksüz dururken yalnızca yaklaşık 10 mA çeker (yük tutarken bu değer yükle birlikte artar), ama hareket ederken akım 0,5–0,9 A'e çıkar; mil zorlandığında ve her kalkışın ilk milisaniyelerinde ise 2,5 A'e yaklaşır. Arduino Uno USB'den beslendiğinde 5V pininden alabileceğin toplam akım, kartın 500 mA'lik sigortasıyla sınırlıdır ve bunun bir kısmını kart kendisi harcar. Servo kalkışa geçtiği anda 5 V hattı birkaç milisaniyeliğine belirgin biçimde düşer, işlemci kararsızlaşır ve kart yeniden başlar. Bilgisayar da aşırı akım gördüğü USB portunu bir süreliğine kapatabilir.

Kablolar da sorunun parçasıdır. Breadboard'da kullanılan ince jumper kabloların ve breadboard kontaklarının toplam direnci kolayca 0,2 Ω'u bulur. Ohm kanunu ile hesaplarsan 2,5 A'lik tepe akımda yalnızca kablolarda 2,5 × 0,2 = 0,5 V kaybolur; 5 V'luk kaynak servoya 4,5 V olarak ulaşır, servo zayıflar ve titrer. Breadboard kontakları da yaklaşık 1 A için tasarlanmıştır. MG996R'ın besleme kablolarını breadboard yerine doğrudan bir klemense ya da lehimli bir dağıtım hattına bağla ve 20–22 AWG kalınlığında kablo kullan.

Doğru besleme: harici 5–6 V, ortak GND ve kondansatör

1. Kaynağı seç: Servo sayısına göre yukarıdaki tablodaki akımı verebilen 5 V ya da 6 V'luk anahtarlamalı bir adaptör kullan. Taşınabilir projelerde 4 adet AA Ni-MH pil (4,8 V) ya da 2S LiPo ile 6 V'a ayarlı bir düşürücü (UBEC) iyi çalışır.
2. Artıyı yalnızca servoya ver: Kaynağın artısını MG996R'ın kırmızı kablosuna bağla; Arduino'nun 5V pinine bağlama.
3. GND'leri birleştir: Kaynağın eksisini hem servonun kahverengi kablosuna hem de Arduino'nun GND pinine bağla. Sinyal, GND'ye göre ölçülen bir gerilim olduğu için ortak GND olmadan servo darbeleri anlayamaz.
4. Sinyali bağla: Turuncu kabloyu Arduino Uno'nun D9 pinine bağla (ESP32'de GPIO 18, Pico'da GP15).
5. Kondansatör ekle: Servonun besleme uçlarına, servoya olabildiğince yakın, 470–1000 µF / 16 V bir elektrolitik kondansatör koy; gövdesindeki şeritli bacak eksiye gelir. Birden fazla servo varsa servo başına yaklaşık 100 µF hesapla.
6. Arduino'yu ayrı besle: Kartı USB'den ya da DC jaktan çalıştır. Böylece servonun yarattığı gerilim düşmeleri işlemciye ulaşmaz.

Servo kütüphanesi ve 500–2500 µs aralığı

Arduino'nun Servo kütüphanesi IDE ile birlikte gelir. servo.attach(9) yazdığında kütüphane varsayılan olarak 544–2400 µs aralığını kullanır ve write(0) ile write(180) komutlarını bu iki uca eşler; birçok MG996R bu aralıkta 180 derecenin biraz altında kalır. Aralığı genişletmek için servo.attach(9, 500, 2500) yaz. Bu ayrıntı önemlidir, çünkü writeMicroseconds() de attach ile verilen sınırların dışına çıkamaz: sınırları vermeden writeMicroseconds(2500) yazarsan kütüphane değeri sessizce 2400'e indirir. Ayrıca write() fonksiyonu 544'ten küçük sayıları açı, daha büyüklerini mikro saniye olarak yorumlar.

Servo kütüphanesi Arduino Uno'da 12 servoya kadar destek verir ve Timer1'i kullandığı için servo bağlıyken 9 ile 10 numaralı pinlerde analogWrite çalışmaz. Her MG996R'ın mekanik sınırı da birbirinden biraz farklıdır: üreticinin veri sayfası standart 1000–2000 µs darbelerle yaklaşık 120 derecelik dönüş verir, geniş aralıkla ise çoğu servo 180 dereceye yaklaşır. Sınırın ötesine itilen servo iç durdurucuya dayanır, kilitlenme akımı çeker, vızıldar ve ısınır. Bu yüzden ilk iş, aşağıdaki kodla kendi servonun güvenli darbe aralığını bulmaktır.

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. Kodu yükle, Seri Monitör'ü 115200 baud'da aç ve satır sonunu Yeni Satır olarak ayarla.
2. 1500 yaz; servo orta konuma gelir. Kornayı mekanizmanın orta konumuna bakacak şekilde bu anda tak.
3. 1000, 800, 700 gibi değerlerle alt sınıra doğru 50'şer µs azalt. Servo artık dönmüyor ya da vızıldamaya başlıyorsa son değerden 30–50 µs geri gel ve bu sayıyı MIN_US olarak not et.
4. Aynı işlemi 2000, 2200, 2300 gibi değerlerle üst sınır için yap ve MAX_US değerini bul. Bu iki sayıyı sonraki kodlarda kullanacaksın.

Yumuşak hareket: akım darbelerini ve sarsıntıyı azaltan kod

servo.write(160) gibi tek bir komut servoyu tam hızla, 6 V'ta 60 dereceyi 0,14 saniyede geçerek hedefe fırlatır. Bu sırada motor neredeyse kilitlenme akımı çeker, mekanizma sarsılır ve tutulan nesne düşebilir. Hareketi küçük adımlara bölmek hem akım tepelerini hem de mekanik darbeyi azaltır. Aşağıdaki kod servoyu her 15 ms'de 1 derece (yaklaşık 67°/sn) ilerletir ve millis() kullandığı için bu sırada başka işler de yapabilirsin.

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}

angleToUs() fonksiyonu açıyı kalibrasyonda bulduğun MIN_US ile MAX_US arasına eşler; böylece 0 ve 180 derece servonun gerçek ve güvenli uçları olur. Servo kapalıyken konumunu hatırlamaz ve ilk darbeyi aldığı an tam hızla o açıya gider. writeMicroseconds() komutunun attach()'tan önce verilmesi, kütüphanenin varsayılan 1500 µs darbesini atlayıp doğrudan senin başlangıç açını göndermesini sağlar; mekanizmayı kapatmadan önce aynı başlangıç pozuna getirirsen açılış sıçraması neredeyse yok olur. Hızı STEP_MS ile ayarla: 30 ms yavaş ve yumuşak, 5 ms hızlı ama sarsıntılı bir hareket verir. Servoyu bir potansiyometreyle sürmek istersen okuduğun değeri açıya çevirip target değişkenine yazman yeterlidir.

Titreme ve Arduino'nun resetlenmesi: sebepler ve çözümler

ESP32 ile MG996R kontrolü

ESP32'de Arduino'nun standart Servo kütüphanesi çalışmaz; Kütüphane Yöneticisi'nden ESP32Servo kütüphanesini kur. Kullanımı neredeyse aynıdır: periyodu setPeriodHertz(50) ile belirtirsin ve kütüphane 500–2500 µs dışındaki sınırları kabul etmez. ESP32'nin sinyal çıkışı 3,3 V'tur ve MG996R'ların büyük çoğunluğu bunu sorunsuz algılar; servon tepki vermiyor ya da kararsızsa sinyal hattına bir lojik seviye dönüştürücü ekle. Aşağıdaki örnekte GPIO 34'e bağlı bir potansiyometre servoyu döndürür. ESP32'nin ADC'si 12 bit olduğu için okuma 0–4095 arasındadır ve biraz gürültülüdür; kod bu yüzden süzme ve ölü bant kullanır.

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}

Raspberry Pi Pico (MicroPython) ile MG996R

Raspberry Pi Pico'da ek kütüphane gerekmez: PWM'i 50 Hz'e ayarlayıp darbe genişliğini duty_ns() ile nanosaniye cinsinden verirsin; 500 µs, 500000 ns demektir. Pico'nun sinyali de 3,3 V'tur. Servoyu Pico'nun VBUS ya da VSYS pininden besleme; bu pinlerdeki akım bilgisayarın USB portundan gelir ve MG996R'ın tepe akımı Pico'yu yeniden başlatır. Servoyu harici kaynaktan besle ve GND'leri birleştir. Aşağıdaki kod servoyu derece derece, yumuşak biçimde üç konum arasında gezdirir.

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)

PCA9685 ile 16 servo: iki kabloyla çok sayıda MG996R

Servo sayısı artınca ya da kesmeleri kapatan kütüphanelerle çalışırken PCA9685 modülü işini kolaylaştırır. Bu kart 16 kanallı, 12 bit çözünürlüklü bir PWM üretecidir ve Arduino ile yalnızca SDA ve SCL kablolarıyla, I2C üzerinden konuşur. Darbeleri kendi saatiyle ürettiği için işlemci başka işlerle meşgulken bile sinyal titremez. Varsayılan adresi 0x40'tır; kart üzerindeki A0–A5 lehim köprüleriyle adres değiştirilerek aynı hatta 62 kart, yani teorik olarak 992 servo bağlanabilir. 50 Hz'de 20 ms'lik periyot 4096 adıma bölünür ve bir adım yaklaşık 4,9 µs eder: 500 µs yaklaşık 102, 2500 µs yaklaşık 512 adımdır.

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}

Kodu çalıştırmak için Kütüphane Yöneticisi'nden Adafruit PWM Servo Driver kütüphanesini kur. setOscillatorFrequency(27000000) satırı önemlidir: PCA9685'in iç saati kâğıt üzerinde 25 MHz'tir ama gerçekte yaklaşık 23–27 MHz arasında değişir ve Adafruit'in örnekleri 27 MHz kullanır. Bu ayar olmadan writeMicroseconds() ile verdiğin darbeler birkaç yüzde kayabilir. Kurulumda servoların 200 ms arayla tek tek başlatılması, 16 servonun aynı anda kalkış akımı çekmesini önler. Her servonun sınırı farklıysa MIN_US ve MAX_US değerlerini 16 elemanlı dizilere çevirip kanal başına kalibrasyon yapabilirsin. Kod ESP32'de de değişmeden çalışır, çünkü Wire kütüphanesi orada varsayılan olarak GPIO 21 ve 22'yi kullanır.

MG996R, SG90 ve MG90S karşılaştırması

Seçimi yük ve kol uzunluğu belirler. Birkaç gramlık bir parçayı döndürecek ya da yalnızca deneme yapacaksan SG90 yeterlidir. Aynı boyutta ama darbelere dayanıklı metal dişli istiyorsan MG90S'i seç. Gereken tork 1 kg·cm'yi geçiyorsa, örneğin 10 cm'lik bir kolun ucunda 100 g taşıyacaksan, MG996R'a geç. MG996R'ın torku SG90'ınkinin yaklaşık beş katıdır, ama daha yavaştır, altı kat ağırdır ve üç dört kat fazla akım çeker; kaynağı ve mekanik bağlantıyı buna göre planlamalısın. 11 kg·cm de yetmiyorsa 20 kg·cm sınıfındaki DS3218 gibi daha büyük servolara bakabilirsin.

Robot kol için servo seçimi

• Taban: MG996R. Kolun bütün ağırlığını servo miline bindirme; tabana bir rulman koy, servo yalnızca döndürsün.
• Omuz: En çok zorlanan eklemdir. MG996R kullan; kol 20 cm'yi geçiyorsa 20 kg·cm sınıfı bir servo ya da karşı ağırlık ekle.
• Dirsek: MG996R. Ağır servoyu omuz hizasına alıp dirseği bir itme çubuğuyla sürmek omzun yükünü azaltır.
• Bilek ve bilek dönüşü: MG90S yeterlidir; burada MG996R kullanmak omzun taşıdığı ağırlığı boşuna artırır.
• Kıskaç: SG90 ya da MG90S. Kapanma açısını nesneye yeni değdiği noktaya ayarla; sürekli sıkmaya çalışan servo kilitlenme akımı çeker.
• Bağlantı: MG996R'ın 25 dişli miline metal korna tak ve kornayı ortadaki vidayla sabitle; plastik kornalar bu torkta kısa sürede sıyırır.

MG996R ile proje fikirleri

• Robot kol: Taban, omuz ve dirsekte MG996R, bilek ve kıskaçta MG90S ile 6 servolu bir kol; yapımı robot kol rehberinde.
• Pan-tilt kamera: İki MG996R ile bir ESP32-CAM modülünü yatay ve dikey eksende döndür.
• Güneş takip sistemi: Dört LDR ile ışığın geldiği yönü bul ve küçük bir paneli MG996R ile güneşe çevir; ayrıntılar güneş takip sistemi yazısında.
• Akıllı çöp kutusu: El yaklaşınca ağır bir kapağı açan akıllı çöp kutusu.
• Kartlı kapı kilidi: RFID RC522 ile doğru kart okutulunca bir sürgüyü MG996R ile çek.
• Joystick kumandalı vinç: Bir joystick ile iki eksende hareket eden küçük bir vinç ya da kepçe.
• Sürekli dönen tahrik: MG996R'ın 360 derece dönen sürümüyle yavaş ama güçlü bir tekerlek; farkı 360 derece servo yazısında.

MG996R, doğru beslendiğinde küçük servoların yapamadığı işleri kolayca üstlenen, dayanıklı ve ucuz bir motordur. Kuralları hatırla: harici 5–6 V kaynak, ortak GND, servoya yakın bir kondansatör, kalibre edilmiş darbe aralığı ve yumuşak hareket; servo sayısı artınca da PCA9685. BlueGrays uygulamasında potansiyometre ve joystick ile servo kontrolü, ESP32 ile servolu RFID kapı kilidi ve 32 servolu koreografi gibi projeleri adım adım devre şeması ve hazır kodlarıyla bulabilirsin.