DC Motor, Servo Motor ve Step Motor Farkı: Hangisini Seçmeli?

DC motor, servo motor ve step motor farkı tek cümleyle şöyle özetlenir: DC motor elektrik verdiğin sürece sürekli ve hızlı döner, servo motor kendisine söylediğin açıya gidip orada kalır, step motor ise adım adım ve sayılabilir şekilde döner. Yani tekerlek döndüreceksen DC motor, bir kapağı 90 derece açacaksan servo, bir parçayı milimetrenin onda biri hassasiyetle taşıyacaksan step motor seçersin. Arduino, ESP32 ve Raspberry Pi Pico projelerinde hareket gereken her yerde bu üç motordan biriyle karşılaşırsın.

Bu rehberde üç motorun içinde ne olduğunu, hız, tork ve konum hassasiyetinde gerçek modellerin (TT motor, SG90, MG996R, 28BYJ-48, NEMA 17) rakamlarını, her birinin hangi sürücüye ihtiyaç duyduğunu (L298N, PWM sinyali, ULN2003, A4988), ne kadar akım çektiğini ve hangi projede hangisinin kullanıldığını karşılaştırıyoruz. Sonunda üç motoru aynı anda süren Arduino, ESP32 ve Pico kodlarını, fırçasız motor (BLDC) ve ESC'ye kısa bir girişi ve en sık yapılan hataları bulacaksın.

Kısa cevap: üç motorun farkı tek tabloda

Tablodaki en önemli satır geri besleme satırıdır. Servo, içindeki potansiyometre sayesinde nerede olduğunu bilir ve bir şey onu ittiğinde eski konumuna geri döner. Step motor nerede olduğunu bilmez; yalnızca kaç adım attığını sen sayarsın ve bu sayı, motor zorlanıp adım kaçırmadığı sürece doğrudur. DC motor ise ne kadar döndüğünü hiç bilmez; konum gerekiyorsa miline bir enkoder eklemen gerekir. Hangi motoru seçeceğin, büyük ölçüde projenin bu bilgiye ihtiyaç duyup duymadığına bağlıdır.

DC motor nasıl çalışır?

Hobi projelerindeki DC motorların neredeyse hepsi fırçalı DC motordur. İçinde sabit mıknatıslar ve dönen bir bobin (rotor) bulunur; karbon fırçalar ve bakır dilimli kolektör, rotor döndükçe akımın yönünü değiştirerek dönüşün hiç durmamasını sağlar. İki kablosu vardır: uçlara gerilim verince döner, uçları ters çevirince ters yöne döner. Uyguladığın gerilim hızı, motorun çektiği akım ise torku belirler. Motor dönerken bobinlerde ters EMK denen bir karşı gerilim oluşur ve akımı sınırlar; mil bir engelle kilitlenince bu karşı gerilim kaybolur ve akım kilitlenme (stall) akımına fırlar.

Redüktörsüz küçük bir DC motor binlerce devirle döner ama torku çok düşüktür; bu yüzden robotlarda hep redüktörlü (dişli kutulu) motorlar kullanılır. TT motordaki 1:48 dişli kutusu, motor milindeki yaklaşık 12.000 dev/dk'yı tekerlekte 250 dev/dk'ya düşürürken torku da (dişli kayıpları hariç) yaklaşık 48 kat artırır. Hızı PWM ile, yönü bir H-köprüsüyle değiştirirsin; ayrıntılar L298N ile DC Motor Kontrolü yazısında. DC motorun zayıf yanı konumdur: aynı PWM değeri bile pil gerilimine ve yüke göre farklı hız verir, bu yüzden "2 saniye ileri git" komutu her seferinde farklı bir mesafeye karşılık gelir. Tam mesafe gerekiyorsa tekerleğe bir enkoder eklenir.

Servo motor nasıl çalışır?

Servo motor aslında küçük bir kutuya yerleştirilmiş eksiksiz bir sistemdir: bir DC motor, motorun hızını düşürüp torkunu artıran bir dişli takımı, çıkış miline bağlı bir potansiyometre ve bir kontrol kartı. Arduino servoya doğrudan bir açı değil, 50 Hz'lik (20 ms'de bir) bir darbe gönderir; darbenin genişliği istenen konumu anlatır. Kontrol kartı istenen konumu potansiyometreden okuduğu gerçek konumla karşılaştırır ve fark sıfırlanana kadar motoru o yöne sürer. Buna kapalı çevrim kontrol denir; servoyu elinle çevirmeye çalıştığında direnmesinin sebebi budur.

Standart RC aralığı 1–2 ms'dir, ama SG90 gibi ucuz servoların çoğu tam 180° için yaklaşık 0,5–2,4 ms ister; Arduino Servo kütüphanesi de varsayılan olarak 544–2400 µs aralığını kullanır. SG90'ın ölü bandı, yani tepki vermediği en küçük değişim yaklaşık 10 µs'dir ve bu yaklaşık 1°'ye karşılık gelir; servonun pratik hassasiyeti bu yüzden bir derece civarındadır. Sürekli dönüş servosu (FS90R) ise geri beslemesi devre dışı bırakılmış bir servodur: açıyı değil hızı ve yönü kontrol edersin, konum bilgisi kaybolur. Daha fazla güç gerekiyorsa metal dişli MG996R standart seçimdir; temel kullanım için Servo Motor Nedir? yazısına bakabilirsin.

Step motor nasıl çalışır?

Step motorda (adım motoru) fırça yoktur. Gövdedeki bobinler belirli bir sırayla enerjilendirilir ve mıknatıslı rotor her seferinde bir sonraki bobine doğru tek bir adım atar. En yaygın hibrit step motorlar turda 200 adım, yani adım başına 1,8° döner. Kaç darbe gönderirsen o kadar adım atar, darbeleri ne kadar sık gönderirsen o kadar hızlı döner. Bobinlere akım verildiği sürece motor durduğu yerde kilitli kalır; buna tutma torku denir. Önemli fark şudur: step motor açık çevrimdir; yük torkunu aşarsa adım kaçırır ve Arduino bunu fark etmez. 3D yazıcıların açılışta eksenleri sınır anahtarlarına götürüp sıfırlaması (homing) bu yüzdendir.

İki tür step motor görürsün. Unipolar motorlarda (28BYJ-48, 5 kablo) bobinlerin ortak bir ucu vardır ve ULN2003 gibi basit bir transistör dizisiyle sürülür. Bipolar motorlarda (NEMA 17, 4 kablo) bobin akımının yönünü çevirmek gerekir; bunu A4988, DRV8825 ya da TMC2209 gibi akım sınırlamalı sürücüler yapar. Bu sürücüler mikroadım da yapar: A4988 her tam adımı 16 parçaya bölerek turdaki adım sayısını 3200'e çıkarır, hareketi de çok daha sessiz ve pürüzsüz hâle getirir. Ayrıntılar için 28BYJ-48 ve ULN2003 ile A4988 step motor sürücü yazılarına bakabilirsin.

Hız, tork ve konum hassasiyeti: rakamlarla karşılaştırma

Tork genellikle kg·cm ile verilir: 1 kg·cm'lik bir motor, milinden 1 cm uzaktaki 1 kg'lık yükü tutabilir, 2 cm uzakta ise yalnızca 0,5 kg'ı (1 kg·cm ≈ 0,098 N·m). Örneğin 6 V'taki MG996R 11 kg·cm verir; 15 cm'lik bir kolun ucunda teorik olarak 11 / 15 ≈ 0,73 kg tutar. Ancak bu değer motorun kilitlendiği andaki en yüksek torktur ve kolun kendi ağırlığı da yüke eklenir. Motoru uzun ömürlü çalıştırmak için bu değerin yarısının altında kalmak iyi bir kuraldır; yani bu kolun ucunda pratikte birkaç yüz gram taşıyabilirsin.

Hızda sıralama tersine döner. DC motor açık ara en hızlısıdır. Servo 180°'lik bir hareketi SG90'da yaklaşık 0,3 saniyede tamamlar ve bundan hızlı gidemez. Step motorun torku ise hız arttıkça düşer, çünkü her adımda bobin akımının tam yükselmeye zamanı kalmaz; 28BYJ-48 dakikada 15 turu geçince adım kaçırmaya başlar. NEMA 17'yi A4988 ile 12 V yerine 24 V'tan beslemek, sürücü akımı zaten sınırladığı için yüksek hızlarda daha fazla tork sağlar. Hassasiyette ise step motor öne geçer: NEMA 17 tam adımda 1,8°, 1/16 mikroadımda kâğıt üzerinde 0,1125° konum verir. Küçük bir not: 28BYJ-48'in iç dişli oranı tam 1:64 değil yaklaşık 1:63,68'dir, bu yüzden gerçek bir tur 2048 değil yaklaşık 2038 adımdır; saat gibi sürekli dönen projelerde bu fark birikir.

Hangi motor hangi sürücüyle çalışır?

Arduino'nun bir pini en fazla 40 mA verebilir, güvenli sınır ise 20 mA civarıdır; küçük bir TT motoru bile boşta bunun yaklaşık 7 katını, kilitlenince 70 katından fazlasını çeker. Ayrıca motor bobinleri akım kesildiği anda yüksek bir ters gerilim darbesi üretir ve korumasız bir pini bozabilir. Bu yüzden motor ile kart arasında her zaman akımı taşıyan bir sürücü bulunur: kart yalnızca küçük kontrol sinyalleri verir, motorun akımı ise doğrudan güç kaynağından sürücü üzerinden akar. Sürücülerin içinde transistörler ve ters gerilimi söndüren diyotlar vardır. Tek yönde dönen bir fan ya da pompa için tek bir MOSFET yeterlidir.

Güç tüketimi: hangi motor ne kadar akım çeker?

Üç motorun akım davranışı birbirinden çok farklıdır ve güç kaynağını buna göre seçmek gerekir. DC motor yük arttıkça daha çok akım çeker; kalkış anında ve tekerlek sıkıştığında kilitlenme akımına yaklaşır. Kaynağı boştaki akıma göre değil, bu tepe akıma göre seçmelisin. Servo beklerken çok az akım çeker, ama her harekette kısa ve sert akım darbeleri yapar: tek bir SG90 bile anlık olarak 0,5 A'i aşabilir, MG996R ise zorlandığında 2,5 A'e çıkar. Bu darbeler gerilimi düşürüp Arduino'yu resetler ya da ESP32'de brownout hatasına yol açar. Step motor ise hiç kıpırdamasa bile bobinlerinden sürekli akım geçer: 28BYJ-48 dururken de 150–200 mA çeker ve ısınır. Pille çalışan projelerde tutma torkuna ihtiyacın yoksa bobinleri kapatman (A4988'de EN pinini HIGH yapman) pil ömrünü ciddi şekilde uzatır.

• Ayrı besleme kullan: Motorları Arduino'nun 5V pininden besleme. USB portu yaklaşık 500 mA verir ve bunun bir kısmını kart zaten harcar; tek bir küçük servo dışında her motor için ayrı bir kaynak gerekir.
• GND'leri birleştir: Motor kaynağının eksi ucu ile kartın GND'si mutlaka bağlı olmalıdır; aksi hâlde kontrol sinyalinin bir referansı olmaz (bkz. ortak toprak).
• Kondansatör ekle: Servo besleme hattına 470–1000 µF elektrolitik, A4988'in VMOT girişine en az 47 µF, fırçalı DC motorun uçlarına 100 nF seramik kondansatör koy. İlki gerilim çökmesini, sonuncusu fırça gürültüsünü azaltır.
• Kaynağı tepe akıma göre seç: Örneğin 4 servolu bir robot kol için en az 3 A verebilen 5–6 V'luk bir kaynak, iki TT motorlu bir araba için 2 × 1,5 A'i kaldıran bir pil paketi gerekir. Pilin ne kadar dayanacağını pil ömrü hesaplayıcısıyla bulabilirsin.
• Gerilimi doğru düşür: 7,4 V'luk bir paketten servo için 5–6 V elde etmen gerekiyorsa LM2596 gibi anahtarlamalı bir düşürücü kullan; 7805 gibi doğrusal regülatörler amper seviyesindeki akımlarda çok ısınır.

Üç motoru aynı Arduino'da sürmek: adım adım

Farkı görmenin en iyi yolu üçünü yan yana çalıştırmaktır. Aşağıdaki devrede bir TT motor L298N ile, bir SG90 doğrudan bir pinle, bir 28BYJ-48 de ULN2003 kartıyla sürülüyor. Pin tablosu, Arduino Uno, ESP32 ve Raspberry Pi Pico kodlarının üçüyle de uyumludur.

1. L298N üzerindeki ENA jumper'ını çıkar; ENA, IN1 ve IN2'yi tablodaki pinlere, DC motoru OUT1 ve OUT2 klemenslerine bağla. Motor beslemesini (örneğin iki seri 18650 pil, 7,4 V) 12V klemensine ver.
2. Servonun kahverengi kablosunu GND'ye, kırmızısını ayrı bir 5–6 V kaynağa, turuncu sinyal kablosunu D9'a bağla.
3. 28BYJ-48'in beyaz soketini ULN2003 kartına tak, IN1–IN4'ü D10–D13'e bağla ve kartın + ucunu 5 V kaynağa ver.
4. Bütün kaynakların eksi uçlarını ve Arduino'nun GND'sini birbirine bağla.
5. Kodu Arduino IDE ile yükle; Servo ve Stepper kütüphaneleri IDE ile birlikte gelir, ayrıca kurman gerekmez.
6. Motor kaynaklarını aç ve üç motorun sırayla nasıl davrandığını izle.

1#include <Servo.h>
2#include <Stepper.h>
3
4// DC motor (L298N): ENA=5, IN1=7, IN2=8
5const int ENA = 5;                 // PWM; Servo kütüphanesi 9 ve 10'un PWM'ini kapatır / Servo library disables PWM on 9 and 10
6const int IN1 = 7;
7const int IN2 = 8;
8
9const int SERVO_PIN = 9;           // servo sinyali / servo signal
10Servo servo;
11
12const int STEPS_PER_REV = 2048;    // 28BYJ-48 tam tur / full revolution
13Stepper stepper(STEPS_PER_REV, 10, 12, 11, 13);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
14
15void releaseStepper() {            // bobinleri bırak, boşta akım çekmesin / release coils, no idle current
16  for (int pin = 10; pin <= 13; pin++) {
17    digitalWrite(pin, LOW);
18  }
19}
20
21void setup() {
22  pinMode(ENA, OUTPUT);
23  pinMode(IN1, OUTPUT);
24  pinMode(IN2, OUTPUT);
25  servo.attach(SERVO_PIN);
26  stepper.setSpeed(10);            // devir/dakika, 28BYJ-48 için en fazla ~15 / RPM, max ~15 for 28BYJ-48
27}
28
29void loop() {
30  // 1) DC motor: hız ve yön, konum yok / speed and direction, no position
31  digitalWrite(IN1, HIGH);
32  digitalWrite(IN2, LOW);
33  analogWrite(ENA, 180);           // yaklaşık %70 güç / about 70% power
34  delay(2000);
35  analogWrite(ENA, 0);             // motoru serbest bırak / let the motor coast
36  delay(500);
37
38  // 2) Servo: açı ver, gidip orada kalsın / give an angle, it goes there and holds
39  servo.write(0);
40  delay(600);
41  servo.write(180);
42  delay(600);
43  servo.write(90);
44  delay(600);
45
46  // 3) Step motor: tam çeyrek tur ileri ve geri / exactly a quarter turn forward and back
47  stepper.step(STEPS_PER_REV / 4);   // 512 adım = 90° / 512 steps = 90°
48  delay(500);
49  stepper.step(-STEPS_PER_REV / 4);
50  releaseStepper();
51  delay(1000);
52}

Kodu çalıştırınca farkı açıkça görürsün: DC motor iki saniye döner ama her seferinde mili farklı bir noktada durur. Servo 0°, 180° ve 90°'ye hızla gider; onu elinle çevirmeye çalışırsan direnir. Step motor yavaşça tam çeyrek tur ilerler ve aynı noktaya geri döner; releaseStepper() çağrıldıktan sonra mili elle rahatça çevrilebilir. Stepper kütüphanesinin step() fonksiyonu hareket bitene kadar kodu bekletir; birden fazla motoru aynı anda ve yumuşak hızlanmayla sürmek istersen AccelStepper kütüphanesine geçmelisin.

ESP32 ile DC, servo ve step motor

ESP32'nin pinleri 3,3 V verir; L298N ve ULN2003 girişleri bu seviyeyi HIGH olarak tanır, servolar da 3,3 V'luk sinyalle çalışır. Motorların beslemesi yine ayrı olmalıdır. Fark servoda: Arduino'nun standart Servo kütüphanesi ESP32'yi desteklemez. Ya ESP32Servo kütüphanesini kurarsın ya da aşağıdaki gibi ESP32'nin donanım PWM birimi LEDC ile 50 Hz'lik sinyali kendin üretirsin. DC motor için 1 kHz, servo için 50 Hz gibi iki farklı frekans kullandığımızdan kanalları ledcAttachChannel ile ayrı zamanlayıcılara (kanal 0 ve 2) veriyoruz; bazı çekirdek sürümlerinde komşu kanallar aynı zamanlayıcıyı paylaşır. Kod ESP32 Arduino çekirdeği 3.x içindir, 2.x sürümlerinde bunun yerine ledcSetup ve ledcAttachPin kullanılır. Stepper kütüphanesi ESP32'de değişmeden çalışır; ESP32'yi yeni tanıyorsan ESP32 Nedir? yazısına göz at.

1#include <Stepper.h>
2
3// ESP32 Arduino çekirdeği 3.x / ESP32 Arduino core 3.x
4const int ENA = 25;                // L298N hız (PWM) / L298N speed (PWM)
5const int IN1 = 26;
6const int IN2 = 27;
7const int SERVO_PIN = 18;          // servo sinyali / servo signal
8
9const int STEPS_PER_REV = 2048;
10Stepper stepper(STEPS_PER_REV, 19, 22, 21, 23);   // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
11
12void motor(int speed) {            // -255 … 255
13  digitalWrite(IN1, speed > 0);
14  digitalWrite(IN2, speed < 0);
15  ledcWrite(ENA, abs(speed));
16}
17
18void servoWrite(int angle) {       // 0 … 180
19  int us = map(angle, 0, 180, 500, 2400);              // açı → darbe (µs) / angle → pulse (µs)
20  ledcWrite(SERVO_PIN, (uint32_t)us * 65535 / 20000);  // 20 ms içindeki pay / share of the 20 ms period
21}
22
23void setup() {
24  pinMode(IN1, OUTPUT);
25  pinMode(IN2, OUTPUT);
26  ledcAttachChannel(ENA, 1000, 8, 0);        // kanal 0: 1 kHz, 8 bit (0–255) / channel 0: 1 kHz, 8-bit
27  ledcAttachChannel(SERVO_PIN, 50, 16, 2);   // kanal 2, ayrı zamanlayıcı: 50 Hz, 16 bit / channel 2, separate timer: 50 Hz, 16-bit
28  stepper.setSpeed(10);                      // devir/dakika / RPM
29}
30
31void loop() {
32  motor(200);         delay(2000);   // DC: ileri / forward
33  motor(0);           delay(500);    // DC: dur / stop
34  servoWrite(0);      delay(600);    // servo: 0°
35  servoWrite(180);    delay(600);    // servo: 180°
36  servoWrite(90);     delay(600);    // servo: 90°
37  stepper.step(512);  delay(500);    // step: çeyrek tur / quarter turn
38  stepper.step(-512); delay(1000);
39}

Raspberry Pi Pico ile MicroPython kodu

Pico'da her GP pini PWM verebilir. MicroPython'da duty_u16() ile DC motorun hızını 0–65535 arasında, duty_ns() ile de servonun darbe genişliğini nanosaniye cinsinden ayarlarsın. Step motoru ise yarım adım dizisini dört pine sırayla yazarak döndürürsün; yarım adımda 28BYJ-48'in bir turu 4096 adımdır. Pico'yu yeni tanıyorsan Raspberry Pi Pico Nedir? yazısından başlayabilirsin.

1from machine import Pin, PWM
2import time
3
4# DC motor (L298N): ENA=GP15, IN1=GP14, IN2=GP13
5ena = PWM(Pin(15))
6ena.freq(1000)
7in1 = Pin(14, Pin.OUT)
8in2 = Pin(13, Pin.OUT)
9
10# Servo: GP16, 50 Hz
11servo = PWM(Pin(16))
12servo.freq(50)
13
14# Step motor (ULN2003): IN1–IN4 = GP2–GP5
15coils = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]
16SEQ = [(1,0,0,0), (1,1,0,0), (0,1,0,0), (0,1,1,0),
17       (0,0,1,0), (0,0,1,1), (0,0,0,1), (1,0,0,1)]   # yarım adım dizisi / half-step sequence
18
19def motor(speed):                    # -100 … 100
20    in1.value(speed > 0)
21    in2.value(speed < 0)
22    ena.duty_u16(int(abs(speed) * 655.35))
23
24def servo_angle(angle):              # 0 … 180
25    us = 500 + angle * 1900 // 180   # 500–2400 µs
26    servo.duty_ns(us * 1000)
27
28phase = 0                            # dizideki konum, çağrılar arasında korunur / position in the sequence, kept between calls
29
30def step(steps, delay_ms=2):         # yarım adımda 4096 adım = 1 tur / 4096 half-steps = 1 turn
31    global phase
32    d = 1 if steps > 0 else -1
33    for _ in range(abs(steps)):
34        phase = (phase + d) % 8
35        for pin, v in zip(coils, SEQ[phase]):
36            pin.value(v)
37        time.sleep_ms(delay_ms)
38    for pin in coils:
39        pin.value(0)                 # bobinleri bırak / release coils
40
41while True:
42    motor(70)                        # DC: %70 ileri / 70% forward
43    time.sleep(2)
44    motor(0)                         # DC: dur / stop
45    time.sleep(0.5)
46    for a in (0, 180, 90):           # servo: üç açı / three angles
47        servo_angle(a)
48        time.sleep(0.6)
49    step(1024)                       # step: çeyrek tur / quarter turn
50    time.sleep(0.5)
51    step(-1024)
52    time.sleep(1)

Hangi projede hangi motor?

Bazı projelerde iki motor da iş görür ve seçim ayrıntılara bağlıdır. Robot arabada tekerlekler için DC motor yeterlidir, ama aracın tam 50 cm gitmesini istiyorsan ya enkoder eklersin ya da tekerlekleri step motorla döndürürsün. Robot kolda servolar en kolay yoldur; ağır ve hassas kollarda eklemlerde step motor ve dişli kullanılır. 3D yazıcıda bir eksenin 1 mm için kaç adım atacağını hesaplamak kolaydır: 200 adımlı motor, 1/16 mikroadım ve 20 dişli GT2 kasnak (diş aralığı 2 mm) ile 200 × 16 / (20 × 2) = 80 adım/mm elde edilir; 8 mm hatveli T8 trapez vidada bu değer 200 × 16 / 8 = 400 adım/mm olur. Radar ve güneş takip sistemi gibi 0–180° tarama yapan projelerde ise servo hem en ucuz hem en basit çözümdür.

Fırçasız motor (BLDC) ve ESC'ye kısa giriş

Fırçasız DC motorda (BLDC) yapı tersine çevrilmiştir: mıknatıslar dönen kısımda, bobinler sabit gövdededir. Fırça ve kolektör olmadığı için sürtünme, kıvılcım ve aşınma yoktur; motor daha verimli, daha sessiz ve çok daha uzun ömürlüdür. Bedeli şudur: akımın yönünü artık fırçalar değil bir elektronik devre değiştirmelidir. Bu yüzden BLDC motorların 3 kablosu vardır ve doğrudan pile bağlanınca dönmez. Model motorlarda hız KV değeriyle verilir, yani volt başına yüksüz devir sayısıyla. 1000 KV'luk bir motor (ör. A2212) 3 hücreli LiPo pil (11,1 V) ile yüksüzken yaklaşık 11.100 dev/dk döner. Drone'lar, RC uçaklar, elektrikli kaykay ve scooter'lar, bilgisayar fanları ve sabit diskler fırçasız motor kullanır.

BLDC motoru Arduino'ya bağlamak için bir ESC (Electronic Speed Controller, elektronik hız kontrolcüsü) gerekir. ESC pilden aldığı DC gerilimi motor için üç fazlı darbelere çevirir; sensörsüz ESC'ler rotorun konumunu boştaki bobinde oluşan ters gerilimden tahmin eder. İşin güzel yanı, ESC'nin kumanda girişinin bir servoyla aynı olmasıdır: 50 Hz'lik darbelerde 1000 µs dur, 2000 µs tam gaz anlamına gelir. ESC'nin akım değeri (ör. 30 A) motorun çekebileceği en yüksek akımdan büyük olmalıdır ve çoğu ESC'de 5 V veren bir BEC çıkışı bulunur. Güvenlik için ESC açıldığında önce en düşük gazı görmek ister; buna arming (kurma) denir ve bu sinyali almadan motoru döndürmez. Aşağıdaki kodda ESC'nin sinyal kablosu D9'a, gaz için kullanılan potansiyometrenin orta ucu A0'a bağlıdır.

1#include <Servo.h>
2
3Servo esc;                         // ESC bir servo gibi sürülür / an ESC is driven like a servo
4const int POT_PIN = A0;            // gaz potansiyometresi / throttle potentiometer
5
6void setup() {
7  esc.attach(9, 1000, 2000);       // 1000–2000 µs aralığı / 1000–2000 µs range
8  esc.writeMicroseconds(1000);     // en düşük gaz: ESC'yi kur (arming) / minimum throttle: arm the ESC
9  delay(3000);                     // bip seslerini bekle / wait for the beeps
10}
11
12void loop() {
13  int throttle = map(analogRead(POT_PIN), 0, 1023, 1000, 2000);   // pot → gaz / pot → throttle
14  esc.writeMicroseconds(throttle);
15  delay(20);                       // bir servo periyodu / one servo period
16}

Sık yapılan hatalar ve çözümleri

• Motor çalışınca Arduino resetleniyor: Motor ya da servo kartın 5V pininden besleniyor. Ayrı bir kaynak kullan, GND'leri birleştir ve beslemeye büyük bir kondansatör ekle.
• Servo titriyor ya da yerinde sıçrıyor: Kaynak zayıf, kablolar ince ve uzun ya da GND ortak değil. Servoya en az 1 A verebilen 5–6 V'luk bir kaynak bağla.
• Servoyla birlikte DC motorun hızı değişmiyor: ENA pini Uno'da 9 ya da 10'a bağlı; Servo kütüphanesi bu pinlerin PWM'ini kapatır. ENA'yı 3, 5, 6 ya da 11'e taşı.
• DC motor düşük PWM değerlerinde dönmüyor, yalnızca vınlıyor: Durağan sürtünmeyi yenecek kadar güç yok. Motoru kısa bir an yüksek değerle başlatıp sonra hızı düşür ya da en düşük değeri 80–100 civarında tut. L298N'in yaklaşık 2 V'luk gerilim kaybını da hesaba kat.
• Step motor titreşiyor ama dönmüyor: Bobin sırası yanlış ya da hız çok yüksek. 28BYJ-48 için Stepper(2048, IN1, IN3, IN2, IN4) sırasını kullan ve hızı dakikada 15 turun altında tut.
• Step motor adım kaçırıyor: Yük çok ağır, hızlanma çok sert ya da A4988'in akım sınırı düşük. Vref'i I = Vref / (8 × Rcs) formülüyle ayarla (Rcs, kart üzerindeki akım algılama direncidir) ve AccelStepper ile yavaş hızlanma kullan.
• A4988 yandı: Motor kablosu sürücü enerjiliyken takılıp çıkarılmış, Vref fazla yüksek ya da VMOT girişine kondansatör konmamış. Motoru her zaman güç kapalıyken bağla.
• ESC motoru döndürmüyor, sürekli bip sesi çıkarıyor: Açılışta en düşük gaz sinyali gelmemiş. setup() içinde writeMicroseconds(1000) gönderip birkaç saniye beklediğinden emin ol; gerekirse ESC'yi kılavuzundaki gibi kalibre et.

Kısacası DC motor hız, servo açı, step motor ise konum demektir; doğru motoru doğru sürücüyle eşleştirdiğinde projenin yarısı çözülmüş olur. Önce bir SG90 ve bir TT motorla başlayıp sonra step motora geçmek, üçünü de öğrenmenin en kolay yoludur. BlueGrays uygulamasında servo motor kullanımı, potansiyometreyle servo kontrolü, step motor kullanımı, step motordan 360 derecelik servo yapımı, L298N ile Bluetooth kontrollü araba ve engelden kaçan robot projelerini devre şemaları ve kodlarıyla adım adım bulabilirsin.