A4988 ile NEMA 17 Step Motor Sürme: Vref Ayarı, Mikro Adım ve Kod

A4988 ile NEMA 17 step motor sürmek, 3D yazıcıların, CNC tezgâhlarının ve lazer kazıyıcıların kullandığı hassas hareketi kendi projene taşımanın en ucuz yoludur. A4988, Allegro firmasının ürettiği ve parmak ucu büyüklüğünde bir modül üzerinde satılan bir bipolar step motor sürücüsüdür: Arduino'dan gelen her STEP darbesinde motoru bir adım ilerletir, DIR pinine göre yönü seçer ve motor bobinlerinden geçen akımı senin belirlediğin değerde tutar. Yani motoru döndürmek için yalnızca iki pin ve 8–35 V arası bir güç kaynağı yeter.

Bu rehberde A4988'in nasıl çalıştığını, NEMA 17 motorun bobinlerini multimetreyle bulmayı, bağlantı şemasını ve besleme hattına neden 100 µF kondansatör takman gerektiğini öğreneceksin. Ardından en kritik adıma, Vref ile akım ayarına geçip formülü ve multimetreyle ölçümü adım adım yapacağız. MS1–MS3 pinleriyle mikro adım seçimi, kütüphanesiz ilk kod, AccelStepper ile yumuşak hızlanma, CNC Shield, ESP32 ve Raspberry Pi Pico kodları, ısınma ve soğutucu, DRV8825 ve TMC2208 karşılaştırması ve "motor titriyor ama dönmüyor" sorununun çözümleri de bu yazıda.

A4988 nedir, nasıl çalışır?

A4988'in içinde iki tam H-köprüsü (her bobin için bir tane), bir çevirici (translator) ve bir akım kontrol devresi bulunur. Çevirici, STEP pinindeki her LOW→HIGH geçişini bobinlere uygulanacak doğru akım sırasına çevirir; böylece bobin sırasını kodda senin hesaplaman gerekmez. Akım kontrolü ise kıyıcı (chopper) mantığıyla çalışır: sürücü her bobinin akımını küçük bir ölçüm direnci (Rs) üzerinden sürekli izler ve akım ayarlanan sınıra ulaşınca çıkışı çok kısa bir süre keser. Bu sayede motoru etiketindeki gerilimin çok üstünde, örneğin 12 ya da 24 V ile beslesen bile bobin akımı güvenli değerde kalır. Yongada ayrıca aşırı ısınma, düşük gerilim, kısa devre ve toprağa kısa devre korumaları vardır.

NEMA 17 step motor: özellikleri ve bobinleri bulmak

NEMA 17 bir motor modeli değil, ön yüzü 42 × 42 mm olan motorların ortak boyut standardıdır; içi, gövde uzunluğuna ve üreticiye göre değişir. Hobi projelerinde en sık görülen 17HS4401 modeli turda 200 adım (1,8°) atar; faz başına 1,7 A anma akımı, yaklaşık 1,5 Ω bobin direnci ve yaklaşık 40 N·cm tutma torku vardır. Etiketindeki gerilim yalnızca 1,7 A × 1,5 Ω ≈ 2,6 V'tur, ama bu seni yanıltmasın: A4988 akımı kendisi sınırladığı için motor 12–24 V ile beslenir. Yüksek gerilim, bobin akımının her adımda daha hızlı yükselmesini sağlar ve motor yüksek devirde daha az tork kaybeder. 28BYJ-48 gibi küçük unipolar motorlarla farkı merak ediyorsan 28BYJ-48 ve ULN2003 yazısına bakabilirsin.

Motorun 4 kablosu iki bağımsız bobine aittir ve A4988'e bağlamadan önce hangi iki kablonun aynı bobin olduğunu bilmen gerekir. Pek çok modelde siyah-yeşil bir bobini, kırmızı-mavi diğerini oluşturur, ama renkler üreticiye göre değiştiği için en güvenilir yol ölçmektir:

1. Multimetreyi direnç (Ω) kademesine al; kullanımını bilmiyorsan multimetre rehberine göz at.
2. Kablolardan birini sabit tut ve diğer üçüyle tek tek ölç. 1–4 Ω gördüğün kablo aynı bobinin öbür ucudur; diğer ikisinde ekran açık devre (OL) gösterir.
3. Kalan iki kablo ikinci bobindir; aralarında aynı direnci görmelisin. Ölçtüğün direnç ve anma akımıyla motorun etiket gerilimini Ohm kanunu hesaplayıcısıyla doğrulayabilirsin.
4. Multimetren yoksa iki kablonun uçlarını birbirine değdirip mili elle çevir: mil belirgin şekilde zorlanıyorsa o iki kablo aynı bobindir.
5. Bir bobini A4988'in 1A–1B, diğerini 2A–2B pinlerine bağla. Motor istediğinin tersine dönerse bobinlerden yalnızca birinin iki kablosunu yer değiştirmen yeter.

A4988 pinleri ve bağlantı şeması

100 µF kondansatör neden şart?

A4988 kartlarının üzerinde yalnızca küçük seramik kondansatörler bulunur. Adaptör kablosunun endüktansı bu düşük dirençli kondansatörlerle birleşince, beslemeyi açtığın anda ya da motor ani akım çektiğinde gerilim sıçramaları oluşur. Bu sıçramalar besleme yalnızca 12 V olsa bile yonganın 35 V'luk sınırını aşabilir ve sürücüyü kalıcı olarak bozabilir. Çözüm basittir: VMOT ile GND arasına, karta olabildiğince yakın, en az 47 µF, tercihen 100 µF'lık elektrolitik kondansatör takarsın. Kondansatörün gerilim değeri besleme geriliminin rahatça üstünde olmalıdır: 12 V için 25 V, 24 V için 35 V ya da 50 V'luk bir kondansatör seç. Elektrolitik kondansatörün kutbu vardır; uzun bacak (+) VMOT'a, gövdesinde şerit olan kısa bacak (–) GND'ye gider. Kondansatör türleri için Kondansatör Nedir?, doğru adaptörü seçmek için Arduino güç besleme yazısına bakabilirsin.

Vref ile akım ayarı: formül

A4988'in üzerindeki küçük potansiyometre, motor akımının üst sınırını belirleyen Vref (referans gerilimi) değerini ayarlar. Sürücü bu gerilimi kartın üzerindeki iki ölçüm direncinin (Rs) gerilimiyle karşılaştırır ve en yüksek bobin akımı şu formülle bulunur: I = Vref / (8 × Rs). Ayarlaman gereken Vref'i bulmak için formülü ters çevirirsin: Vref = I × 8 × Rs. Rs değerini öğrenmek için yonganın yanındaki iki küçük SMD direncin üzerindeki yazıya bak: R100 0,1 Ω, R068 0,068 Ω, R050 ise 0,05 Ω demektir. Kodları çözmekte zorlanırsan SMD direnç kodu hesaplayıcısını ya da SMD direnç kodları yazısını kullanabilirsin.

Hangi akımı seçmelisin? Motorun etiketindeki akım (17HS4401 için 1,7 A) asla aşılmaması gereken üst sınırdır. A4988 soğutucusuz yaklaşık 1 A'i rahat taşır; bu yüzden başlangıç için 0,8–1 A iyi bir değerdir. R100 dirençli yaygın kartlarda bu, 0,64–0,80 V Vref demektir. Motor yük altında adım kaçırıyorsa akımı 0,1 A'lik adımlarla artır; 1,2 A'in üstüne çıkacaksan yongaya soğutucu ve fan ekle. İhtiyacından yüksek bir akım, motoru belirgin şekilde güçlendirmekten çok sürücüyü ve motoru ısıtır.

Vref'i multimetreyle ölçmek: adım adım

1. Beslemeler kapalıyken motoru sürücüden ayır. Vref ölçümü için motora gerek yoktur.
2. A4988'in VDD ve GND pinlerine lojik beslemeyi ver (Arduino'nun 5V'u yeter). Vref bu gerilimden üretildiği için VDD olmadan ölçüm yapılamaz; VMOT'u da bağlı tutmak sorun yaratmaz.
3. Multimetreyi DC gerilim kademesine (2 V ya da 20 V) al. Siyah probu GND'ye, kırmızı probu potansiyometrenin metal başına değdir; bazı kartlarda bunun yerine VREF yazan küçük bir ölçüm noktası vardır.
4. Potansiyometreyi plastik ya da seramik uçlu küçük bir tornavidayla çok az çevir ve değeri izle. Çoğu kartta saat yönü Vref'i artırır, ama bu karta göre değişebilir; bazı potansiyometreler tam turda başa döner, bu yüzden küçük adımlarla ilerle.
5. Hesapladığın değere ulaşınca beslemeyi kes, motoru bağla ve ancak ondan sonra beslemeyi yeniden ver.
6. Motoru birkaç dakika çalıştırıp yonganın sıcaklığını kontrol et. Parmağını birkaç saniye bile tutamıyorsan Vref'i biraz düşür ya da soğutucu ekle.

MS1, MS2, MS3 ile mikro adım ayarı

Mikro adım (microstepping), sürücünün iki bobindeki akımı kademeli olarak değiştirip her tam adımı daha küçük parçalara bölmesidir. A4988, MS1–MS3 pinlerine verdiğin lojik seviyelere göre beş moddan birini seçer. Bu pinlerin içinde aşağı çekme (pull-down) dirençleri olduğu için üçünü boş bırakırsan motor tam adımda çalışır.

Mikro adımın asıl faydası yumuşak ve sessiz dönüştür: tam adımda motor her adımda sertçe sıçrar ve belirli hızlarda rezonansa girip titrer; 1/16 modunda ise hareket neredeyse kesintisiz olur. Ancak hassasiyetin gerçekten 16 kat artacağını düşünme. Tek bir mikro adımı ilerleten tork, tutma torkunun yalnızca sin(90° / 16) ≈ %10'u kadardır; sürtünme ya da yük bu küçük kuvveti yenerse motor birkaç mikro adım geride kalır. Hızı hesaplamak için şu formülü kullan: adım/sn = devir/dakika × 200 × mikro adım / 60. Örneğin 1/16 modunda dakikada 60 devir için saniyede 3200 STEP darbesi gerekir. Modu yazılımla değiştirmek istersen MS pinlerini de Arduino'ya bağlayabilirsin; çoğu projede ise sabit bir modu kabloyla seçmek yeterlidir.

İlk kod: kütüphanesiz STEP ve DIR ile dönüş

Aşağıdaki kod hiçbir kütüphane kullanmadan, yalnızca STEP pinine darbe göndererek motoru bir tur ileri, bir tur geri döndürür. MS1–MS3 pinlerini 5V'a bağladığını, yani motorun 1/16 modunda çalıştığını varsayıyoruz; bu yüzden bir tur 3200 adımdır.

1// A4988 + NEMA 17, kütüphanesiz / without a library
2const int STEP_PIN = 2;            // CNC Shield X ekseniyle aynı / same as CNC Shield X axis
3const int DIR_PIN  = 5;
4const int EN_PIN   = 8;            // aktif LOW / active LOW
5
6const long STEPS_PER_REV = 200L * 16;   // 1,8° motor, 1/16 mikro adım = 3200 / 1.8° motor, 1/16 microstep
7
8void setup() {
9  pinMode(STEP_PIN, OUTPUT);
10  pinMode(DIR_PIN, OUTPUT);
11  pinMode(EN_PIN, OUTPUT);
12  digitalWrite(EN_PIN, LOW);       // sürücüyü aç / enable the driver
13}
14
15void rotate(long steps, unsigned int pauseUs) {
16  digitalWrite(DIR_PIN, steps > 0 ? HIGH : LOW);   // yön / direction
17  delayMicroseconds(5);                           // DIR, STEP'ten önce otursun / let DIR settle before STEP
18  for (long i = 0; i < labs(steps); i++) {
19    digitalWrite(STEP_PIN, HIGH);
20    delayMicroseconds(5);                         // darbe en az 1 µs / pulse at least 1 µs
21    digitalWrite(STEP_PIN, LOW);
22    delayMicroseconds(pauseUs);                   // küçüldükçe hız artar / smaller = faster
23  }
24}
25
26void loop() {
27  rotate(STEPS_PER_REV, 500);      // 1 tur ileri, ~1,6 sn / one turn forward, ~1.6 s
28  delay(1000);
29  rotate(-STEPS_PER_REV, 500);     // 1 tur geri / one turn back
30  delay(1000);
31}

Kodda dikkat etmen gereken üç zamanlama var. A4988, STEP darbesinin HIGH ve LOW kısımlarının en az 1 µs sürmesini ister; 5 µs güvenli bir değerdir. DIR değiştikten sonra ilk STEP darbesinden önce en az 200 ns beklemek gerekir; kodda bunun için 5 µs bekliyoruz. Hızı ise darbeler arasındaki bekleme belirler: 500 µs beklemeyle bir adım yaklaşık 0,51 ms sürer ve bir tur (3200 adım) yaklaşık 1,6 saniyede, yani dakikada 36 devir civarında tamamlanır. Bu kodun iki zayıf yanı vardır: motor tam hızla aniden kalkar ve döngü sürerken Arduino başka hiçbir iş yapamaz. Bekleme süresini doğrudan 100 µs'ye indirirsen motor büyük ihtimalle kalkamaz, yalnızca vızıldar.

AccelStepper ile hızlanma ve yavaşlama

Step motoru durduğu yerden bir anda yüksek hıza çıkaramazsın; rotor ve yük bu ani değişime yetişemez, motor senkronu kaybeder ve adım kaçırır. Çözüm, hızı rampa şeklinde artırıp hedefe yaklaşırken azaltmaktır. Kütüphane Yöneticisi'nden kurabileceğin AccelStepper bunu bekletmeden yapar: run() fonksiyonunu loop() içinde sürekli çağırırsın, kütüphane de zamanı gelen adımı atar. Böylece motor dönerken buton okuyabilir, ekran güncelleyebilir ya da sensör ölçebilirsin; bu mantığı millis() ve delay() yazısında ayrıntılı bulabilirsin. Uno üzerinde AccelStepper'ın güvenle ulaşabildiği hız saniyede birkaç bin adımdır (belgelerinde 16 MHz için yaklaşık 4000 adım/sn verilir); bu yüzden örnekte 2000 adım/sn kullandık, bu da 1/16 modunda dakikada yaklaşık 37 devir eder.

1#include <AccelStepper.h>
2
3const int STEP_PIN = 2;
4const int DIR_PIN  = 5;
5const int EN_PIN   = 8;
6const long STEPS_PER_REV = 200L * 16;            // 1/16 mikro adımda 1 tur / one turn at 1/16 microstep
7
8AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
9
10void setup() {
11  stepper.setEnablePin(EN_PIN);
12  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
13  stepper.enableOutputs();
14  stepper.setMaxSpeed(2000);                     // adım/sn, Uno için güvenli / steps per second, safe on Uno
15  stepper.setAcceleration(1500);                 // adım/sn² / steps per second²
16  stepper.moveTo(STEPS_PER_REV * 3);             // 3 tur ileri / three turns forward
17}
18
19void loop() {
20  if (stepper.distanceToGo() == 0) {             // hedefe varıldı / target reached
21    delay(500);
22    stepper.moveTo(stepper.currentPosition() == 0 ? STEPS_PER_REV * 3 : 0);   // git-gel / back and forth
23  }
24  stepper.run();                                 // her döngüde çağır, bekletmez / call every loop, non-blocking
25}

CNC Shield V3 ile birden fazla motor

Birden fazla NEMA 17 süreceksen kablo karmaşasından kurtulmanın en kolay yolu Arduino CNC Shield V3'tür. Uno'nun üzerine takılan bu kartta dört A4988 yuvası (X, Y, Z ve A), her sürücünün altında mikro adım jumper'ları, motor soketleri, sınır anahtarı girişleri ve güç klemensi bulunur; üç jumper'ın üçü de takılıysa A4988 1/16 modunda çalışır. Bağlantı tablosunda STEP, DIR ve EN için bilerek D2, D5 ve D8'i seçmiştik: bunlar shield'in X ekseni pinleridir, yani yukarıdaki kodlar shield'de de değiştirmeden çalışır. Uno'ya GRBL yazılımını yüklersen shield, bilgisayardan G-code alan bir CNC ya da lazer kontrol kartına dönüşür. GRBL'de her eksenin 1 mm için kaç adım atacağını $100, $101 ve $102 ayarlarına yazarsın: 20 dişli GT2 kasnak ve 1/16 mikro adımda bu değer 200 × 16 / (20 × 2) = 80 adım/mm, 8 mm hatveli T8 trapez vidada ise 200 × 16 / 8 = 400 adım/mm olur.

ESP32 ile A4988 kullanımı

ESP32'nin pinleri 3,3 V verir. A4988 bir girişi ancak VDD geriliminin %70'inin üstündeyse kesin olarak HIGH kabul eder; VDD 5 V olduğunda bu eşik 3,5 V'tur ve 3,3 V'luk sinyal sınırın altında kalır. Bu yüzden ESP32 ve Pico ile çalışırken A4988'in VDD pinini 3V3'e bağla: sürücü 3–5,5 V arasında sorunsuz çalışır ve seviye dönüştürücüye gerek kalmaz. VDD değiştiği için Vref'i yeniden ölçmeyi unutma. Aşağıdaki kod, Seri Monitör'e yazdığın açıya (örneğin 90 ya da -45) motoru hızlanarak götürür. ESP32 çok daha hızlı olduğu için AccelStepper burada saniyede 6000 adıma rahatça çıkar; daha yüksek hızlar için donanım zamanlayıcısı kullanan FastAccelStepper kütüphanesine bakabilirsin. ESP32'yi yeni tanıyorsan ESP32 Nedir? yazısından başla.

1#include <AccelStepper.h>
2
3// ESP32: STEP=25, DIR=26, EN=27, A4988 VDD → 3V3
4const int STEP_PIN = 25;
5const int DIR_PIN  = 26;
6const int EN_PIN   = 27;
7const float STEPS_PER_DEG = 200.0 * 16 / 360.0;  // 1/16'da derece başına 8,89 adım / 8.89 steps per degree at 1/16
8
9AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
10
11void setup() {
12  Serial.begin(115200);
13  stepper.setEnablePin(EN_PIN);
14  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
15  stepper.enableOutputs();
16  stepper.setMaxSpeed(6000);                     // adım/sn / steps per second
17  stepper.setAcceleration(4000);                 // adım/sn² / steps per second²
18  Serial.println("Aci yaz, ornek 90 / type an angle, e.g. 90");
19}
20
21void loop() {
22  if (Serial.available()) {
23    float angle = Serial.parseFloat();           // Seri Monitör'den açı / angle from the Serial Monitor
24    while (Serial.available()) Serial.read();    // satır sonunu at / drop the line ending
25    stepper.moveTo(lround(angle * STEPS_PER_DEG));
26    Serial.printf("Hedef / target: %.1f\n", angle);
27  }
28  stepper.run();                                 // bekletmeden adım at / step without blocking
29}

Raspberry Pi Pico ve MicroPython ile A4988

Pico'da da A4988'in VDD pinini 3V3 (OUT) pinine bağlarsın. MicroPython'da hazır bir hızlanma kütüphanesi kullanmak yerine aşağıdaki gibi basit bir doğrusal rampa yazabilirsin: move() fonksiyonu ilk ve son 600 adımda darbeler arasındaki beklemeyi 2000 µs ile 400 µs arasında kademeli olarak değiştirir, ortada ise tam hızda gider. MicroPython döngüsü her adıma birkaç on mikrosaniye ekler, bu yüzden gerçek hız hesaplanandan biraz düşüktür. Saniyede on binlerce adım ya da aynı anda birkaç motor gerekiyorsa Pico'nun PIO birimleri darbeleri işlemciyi hiç meşgul etmeden üretebilir. Pico'ya MicroPython kurmak için Raspberry Pi Pico Nedir? yazısına bakabilirsin.

1from machine import Pin
2import time
3
4step = Pin(2, Pin.OUT)              # STEP → GP2
5direction = Pin(3, Pin.OUT)         # DIR → GP3
6enable = Pin(4, Pin.OUT, value=0)   # EN → GP4, 0 = sürücü açık / 0 = driver enabled
7
8STEPS_PER_REV = 200 * 16            # 1/16 mikro adım / 1/16 microstep
9
10def move(steps, max_sps=2500, ramp_steps=600):
11    direction.value(1 if steps > 0 else 0)    # yön / direction
12    time.sleep_us(5)
13    n = abs(steps)
14    ramp = min(ramp_steps, n // 2)            # hızlanma ve yavaşlama adımı / accel and decel steps
15    fast = 1000000 // max_sps                 # en kısa bekleme, µs / shortest pause, µs
16    slow = 2000                               # 500 adım/sn ile başla / start at 500 steps/s
17    for i in range(n):
18        k = min(i, n - 1 - i)                 # başa ya da sona uzaklık / distance to start or end
19        pause = slow - (slow - fast) * k // ramp if k < ramp else fast
20        step.value(1)
21        time.sleep_us(3)                      # STEP darbesi / STEP pulse
22        step.value(0)
23        time.sleep_us(pause)
24
25while True:
26    move(STEPS_PER_REV)             # 1 tur ileri / one turn forward
27    time.sleep(1)
28    move(-STEPS_PER_REV // 2)       # yarım tur geri / half a turn back
29    time.sleep(1)

Isınma, soğutucu ve termal koruma

A4988'in ısınması normaldir, çünkü bobin akımı yonganın içindeki MOSFET'lerden geçer. Her bobinin akım yolunda tipik olarak toplam 0,64 Ω direnç bulunur ve harcanan güç akımın karesiyle artar: kabaca P ≈ I² × 0,64 Ω. 1 A ayarında bu yaklaşık 0,65 W, 1,5 A'de ise yaklaşık 1,45 W eder; yonga ısındıkça direnç de artar ve gerçek değer daha da yükselir. Parmak ucu büyüklüğündeki bir kart için bu çok fazla ısıdır. Yonga 165 °C'ye ulaşınca termal koruma çıkışları kapatır ve yaklaşık 15 °C soğuyunca yeniden açar. Motorun birkaç saniye çalışıp durması, sonra kendi kendine devam etmesi tam olarak bu korumanın belirtisidir.

• Soğutucu tak: Yonganın üzerine termal bantlı küçük bir alüminyum soğutucu yapıştır; soğutucunun pinlere ya da potansiyometreye değmediğinden emin ol.
• Hava akışı sağla: 1,2 A'in üstünde ya da kapalı bir kutuda küçük bir fan, soğutucunun etkisini katlar.
• Akımı ihtiyaca göre ayarla: Motor yük altında adım kaçırmıyorsa Vref'i biraz düşür; akımı %20 azaltmak ısıyı yaklaşık %36 azaltır.
• Beklerken bobinleri kapat: Tutma torkuna ihtiyacın yoksa hareket bitince EN pinini HIGH yap ya da disableOutputs() çağır; hem sürücü hem motor soğur.
• Motorun sıcaklığına da bak: Step motorlar dururken de akım çektiği için ılık, hatta sıcak olur. Gövde 60 °C'yi geçiyorsa akımı düşür; bu sıcaklıkta 3D yazıcıdaki PLA parçalar yumuşamaya başlar.
• Daha güçlü sürücüye geç: Motorun 1,5 A'in üstünde akıma ihtiyacı varsa DRV8825 ya da TMC2209 gibi bir sürücü daha uygundur.

A4988, DRV8825 ve TMC2208 farkı

Üç sürücü de aynı 16 pinli "StepStick" yerleşimini kullanır ve çoğu zaman CNC Shield'de birbirinin yerine takılabilir, ama dikkat etmen gereken farklar var. DRV8825'in potansiyometresi kartın farklı bir yerindedir ve formülü farklıdır; A4988'de VDD olan pin DRV8825'te FAULT çıkışıdır. TMC2208 aynı kodla motoru A4988'e göre ters yöne döndürür; kodda DIR'i ters çevirmen ya da motor soketini 180° çevirmen gerekir. Gelişmiş ayarları UART üzerinden yapılır ve sensörsüz sıfırlama (StallGuard) istiyorsan TMC2209'a bakmalısın. Kısacası öğrenmek ve düşük maliyetli projeler için A4988 hâlâ en mantıklı başlangıçtır; gürültü önemliyse TMC2208, daha yüksek akım gerekiyorsa DRV8825 seç. Motor türlerinin genel karşılaştırması için DC, servo ve step motor farkı yazısını okuyabilirsin.

Motor titriyor ama dönmüyor: sık hatalar ve çözümleri

A4988 ve NEMA 17 ile proje fikirleri

• Kamera kaydırıcı: GT2 kayış ve kasnakla kamerayı ray üzerinde milimetre milimetre ilerleterek zaman atlamalı (timelapse) video çek.
• Kalem çizici (pen plotter): CNC Shield ve GRBL ile kalemi iki eksende hareket ettirip bilgisayardaki çizimi kâğıda aktar; kalemi kaldırıp indirmek için bir servo motor yeter.
• Döner tabla: Ürün fotoğrafı ya da 3D tarama için nesneyi eşit açılarla döndür; 1/16 modunda bir tur 3200 adım olduğu için 36 fotoğrafın her biri arasında yaklaşık 89 adım atarsın.
• Güneş takip paneli: Paneli gün boyunca güneşe çeviren bir düzenek kur; fikrin tamamı güneş takip sistemi yazısında.
• Robot kol tabanı: Ağır bir kolun gövdesini servo yerine NEMA 17 ve dişliyle döndür; diğer eklemler için robot kol yazısına göz at.
• Elle konumlama: Motoru bir joystick ile hızlı, bir rotary encoder ile adım adım hassas şekilde hareket ettir.
• Otomatik perde ya da sürgülü kapak: Açılışta bir sınır anahtarıyla sıfır noktasını bul, setCurrentPosition(0) ile kaydet ve perdeyi istediğin konuma götür.

A4988 ile NEMA 17 sürmenin özeti şudur: bobinleri doğru eşleştir, besleme hattına 100 µF koy, Vref'i formülle hesaplayıp multimetreyle ayarla, mikro adımı seç ve motoru hızlanmayla çalıştır. Bu temeli öğrendiğinde 3D yazıcı ve CNC gibi makinelerin nasıl çalıştığı da netleşir. BlueGrays uygulamasında step motor kullanımı ve step motordan 360 derece dönen servo yapımı gibi hareket projelerini devre şemaları ve kodlarıyla adım adım bulabilirsin.