Driver Stepper A4988 dengan NEMA 17: Vref, Microstepping, dan Kode

Menggerakkan NEMA 17 dengan A4988 adalah cara termurah untuk membawa gerakan presisi seperti di printer 3D, mesin CNC, dan laser engraver ke proyekmu sendiri. A4988 adalah driver motor stepper bipolar buatan Allegro yang dijual dalam bentuk modul seukuran ujung jari: setiap pulsa STEP dari Arduino menggerakkan motor satu langkah, pin DIR menentukan arah, dan driver menjaga arus di kumparan motor tetap pada nilai yang kamu atur. Dengan kata lain, untuk memutar motor kamu cukup butuh dua pin dan catu daya antara 8 dan 35 V.

Di panduan ini kamu akan belajar cara kerja A4988, cara menemukan kumparan NEMA 17 dengan multimeter, cara pengkabelannya, dan kenapa catu dayanya butuh kapasitor 100 µF. Setelah itu kita masuk ke langkah paling penting, yaitu mengatur arus dengan Vref, lengkap dengan rumus dan pengukuran multimeter langkah demi langkah. Microstepping dengan pin MS1–MS3, sketch pertama tanpa library, akselerasi halus dengan AccelStepper, CNC Shield, kode ESP32 dan Raspberry Pi Pico, panas dan heatsink, perbandingan dengan DRV8825 dan TMC2208, serta solusi untuk masalah klasik “motor bergetar tapi tidak berputar” juga ada di sini.

Apa itu A4988 dan bagaimana cara kerjanya?

Di dalam A4988 ada dua H-bridge penuh (satu untuk tiap kumparan), sebuah translator, dan rangkaian pengendali arus. Translator mengubah setiap transisi LOW→HIGH di pin STEP menjadi urutan arus yang tepat untuk kumparan, jadi kamu tidak perlu mengatur urutan kumparan di kodemu. Pengendalian arusnya memakai chopper: driver terus memantau arus tiap kumparan lewat resistor sensor kecil (Rs) dan mematikan output sebentar setiap kali arus mencapai batas yang diatur. Karena itu arus kumparan tetap di nilai yang aman walaupun motor diberi tegangan jauh di atas tegangan nominalnya, misalnya 12 atau 24 V. Chip ini juga punya proteksi terhadap panas berlebih, tegangan kurang, beban yang terhubung singkat, dan korsleting ke ground.

Motor stepper NEMA 17: spesifikasi dan cara menemukan kumparan

NEMA 17 bukan nama model motor, melainkan standar ukuran untuk motor dengan pelat depan 42 × 42 mm; isi di dalamnya tergantung panjang bodi dan pabriknya. 17HS4401, model yang paling umum di proyek hobi, punya 200 langkah per putaran (1,8°), arus nominal 1,7 A per fase, hambatan kumparan sekitar 1,5 Ω, dan torsi penahan kira-kira 40 N·cm. Tegangan di labelnya hanya 1,7 A × 1,5 Ω ≈ 2,6 V, tapi jangan terkecoh: karena A4988 membatasi arusnya sendiri, motor diberi daya 12–24 V. Tegangan yang lebih tinggi membuat arus kumparan naik lebih cepat di setiap langkah, sehingga motor tidak banyak kehilangan torsi di kecepatan tinggi. Kalau kamu penasaran apa bedanya dengan motor unipolar kecil seperti 28BYJ-48, lihat 28BYJ-48 dan ULN2003.

4 kabel motor ini milik dua kumparan yang terpisah, dan sebelum menghubungkannya ke A4988 kamu harus tahu dua kabel mana yang membentuk satu kumparan. Di banyak model, hitam-hijau adalah satu kumparan dan merah-biru kumparan lainnya, tapi warnanya berbeda-beda antarpabrik, jadi cara paling andal adalah mengukurnya:

1. Setel multimeter-mu ke mode hambatan (Ω); kalau belum yakin caranya, lihat panduan multimeter.
2. Pegang satu kabel dan ukur terhadap masing-masing dari tiga kabel lainnya. Kabel yang terbaca 1–4 Ω adalah ujung lain dari kumparan yang sama; dua kabel lainnya menunjukkan rangkaian terbuka (OL).
3. Dua kabel sisanya adalah kumparan kedua dan harus menunjukkan hambatan yang sama. Dengan hambatan terukur dan arus nominal, kamu bisa mengecek tegangan label motor memakai kalkulator hukum Ohm.
4. Tidak punya multimeter? Tempelkan ujung dua kabel lalu putar porosnya dengan tangan: kalau terasa jauh lebih berat, dua kabel itu adalah kumparan yang sama.
5. Hubungkan satu kumparan ke pin 1A–1B A4988 dan kumparan lainnya ke 2A–2B. Kalau motor berputar ke arah sebaliknya dari yang kamu mau, cukup tukar dua kabel dari salah satu kumparan.

Pinout A4988 dan skema pengkabelan

Kenapa kapasitor 100 µF wajib dipasang?

Board A4988 hanya membawa kapasitor keramik kecil. Ditambah induktansi kabel daya, kapasitor ber-ESR rendah ini menimbulkan lonjakan tegangan ketika catu daya dinyalakan atau ketika motor tiba-tiba menarik arus. Lonjakan ini bisa melewati batas 35 V chip bahkan dengan catu daya 12 V dan merusak driver secara permanen. Solusinya sederhana: pasang kapasitor elektrolit minimal 47 µF, idealnya 100 µF, di antara VMOT dan GND, sedekat mungkin dengan board. Rating tegangannya harus cukup jauh di atas tegangan catu daya: pilih 25 V untuk catu 12 V, dan 35 V atau 50 V untuk 24 V. Kapasitor elektrolit punya polaritas; kaki panjang (+) ke VMOT dan kaki pendek (–), yang ditandai garis di bodinya, ke GND. Untuk jenis-jenis kapasitor, lihat Apa Itu Kapasitor?, dan untuk memilih adaptor yang tepat, lihat Cara Memberi Daya ke Arduino.

Mengatur arus dengan Vref: rumusnya

Potensiometer kecil di A4988 mengatur Vref (tegangan referensi), yang menentukan arus motor maksimum. Driver membandingkan tegangan ini dengan tegangan di dua resistor sensor (Rs) di board, dan arus puncak kumparan dihitung dengan: I = Vref / (8 × Rs). Untuk mencari Vref yang kamu butuhkan, balik rumusnya: Vref = I × 8 × Rs. Untuk mengetahui Rs, baca tanda di dua resistor SMD kecil di dekat chip: R100 berarti 0,1 Ω, R068 berarti 0,068 Ω, dan R050 berarti 0,05 Ω. Kalau kesulitan membaca kodenya, pakai dekoder kode SMD atau artikel tentang kode resistor SMD.

Arus berapa yang sebaiknya dipilih? Arus di label motor (1,7 A untuk 17HS4401) adalah batas atas yang tidak boleh dilewati. Tanpa heatsink, A4988 nyaman menangani sekitar 1 A, jadi 0,8–1 A adalah titik awal yang bagus. Di board umum dengan resistor R100, itu berarti Vref 0,64–0,80 V. Kalau motor melewatkan langkah ketika diberi beban, naikkan arusnya bertahap 0,1 A; kalau kamu naik di atas 1,2 A, tambahkan heatsink dan kipas di chip. Arus yang lebih besar dari kebutuhan jauh lebih banyak memanaskan driver dan motor daripada membuat motor terasa lebih kuat.

Mengukur Vref dengan multimeter: langkah demi langkah

1. Dengan semua daya dimatikan, lepaskan motor dari driver. Kamu tidak butuh motor untuk mengukur Vref.
2. Beri daya pin VDD dan GND A4988 dengan catu daya logika (pin 5V Arduino sudah cukup). Vref diturunkan dari tegangan ini, jadi kamu tidak bisa mengukurnya tanpa VDD; VMOT tetap terhubung pun tidak masalah.
3. Setel multimeter ke tegangan DC (range 2 V atau 20 V). Tempelkan probe hitam ke GND dan probe merah ke bagian atas potensiometer yang berbahan logam; beberapa board punya titik uji kecil berlabel VREF sebagai gantinya.
4. Putar potensiometer sedikit demi sedikit dengan obeng kecil dari plastik atau keramik sambil memperhatikan angkanya. Di kebanyakan board, putaran searah jarum jam menaikkan Vref, tapi ini bisa berbeda; beberapa potensiometer kembali ke awal setelah satu putaran penuh, jadi lakukan dengan langkah kecil.
5. Begitu mencapai nilai hasil perhitungan, matikan daya, hubungkan motor, dan baru setelah itu nyalakan lagi.
6. Jalankan motor beberapa menit dan cek suhu chip. Kalau jarimu tidak tahan menempel di sana bahkan beberapa detik, turunkan Vref sedikit atau tambahkan heatsink.

Microstepping dengan MS1, MS2, dan MS3

Microstepping artinya driver mengubah arus di kedua kumparan secara bertahap, sehingga setiap langkah penuh terbagi menjadi bagian-bagian yang lebih kecil. A4988 memilih salah satu dari lima mode berdasarkan level logika di pin MS1–MS3. Pin-pin ini punya resistor pull-down internal, jadi kalau ketiganya dibiarkan tidak terhubung, motor berjalan di mode full step.

Manfaat sebenarnya dari microstepping adalah putaran yang halus dan senyap: di mode full step motor tersentak di setiap langkah serta beresonansi dan bergetar di kecepatan tertentu, sedangkan di 1/16 gerakannya hampir mulus tanpa putus. Tapi jangan berharap presisinya benar-benar naik 16 kali lipat. Torsi yang mendorong satu microstep hanya sin(90° / 16) ≈ 10% dari torsi penahan; kalau gesekan atau beban mengalahkan gaya kecil itu, motor tertinggal beberapa microstep. Untuk menghitung kecepatan, pakai: langkah/dtk = RPM × 200 × microstep / 60. Misalnya, 60 RPM di 1/16 butuh 3200 pulsa STEP per detik. Kalau ingin mengganti mode lewat software, kamu juga bisa menghubungkan pin MS ke Arduino; tapi di kebanyakan proyek, memilih mode tetap dengan kabel sudah cukup.

Sketch pertama: memutar motor dengan STEP dan DIR, tanpa library

Sketch di bawah memutar motor satu putaran maju dan satu putaran mundur tanpa library apa pun, hanya dengan mengirim pulsa ke pin STEP. Kita anggap kamu sudah menghubungkan MS1–MS3 ke 5V, jadi motor berjalan di 1/16 dan satu putaran sama dengan 3200 langkah.

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}

Ada tiga pewaktuan yang perlu diperhatikan di kode ini. A4988 butuh bagian HIGH dan LOW pulsa STEP berlangsung minimal 1 µs; 5 µs adalah nilai yang aman. Setelah DIR berubah, kamu harus menunggu minimal 200 ns sebelum pulsa STEP pertama; kode ini menunggu 5 µs untuk itu. Kecepatan ditentukan oleh jeda antarpulsa: dengan jeda 500 µs, satu langkah butuh sekitar 0,51 ms, jadi satu putaran (3200 langkah) butuh sekitar 1,6 detik, kira-kira 36 RPM. Kode ini punya dua kelemahan: motor langsung mulai di kecepatan penuh secara mendadak, dan Arduino tidak bisa mengerjakan hal lain selama perulangan berjalan. Kalau jedanya langsung kamu turunkan ke 100 µs, kemungkinan besar motor gagal mulai dan hanya berdengung.

Akselerasi dan deselerasi dengan AccelStepper

Kamu tidak bisa membawa motor stepper dari diam ke kecepatan tinggi dalam sekejap; rotor dan bebannya tidak bisa mengikuti perubahan mendadak seperti itu, motor kehilangan sinkronisasi dan melewatkan langkah. Solusinya adalah menaikkan kecepatan secara bertahap dan menurunkannya lagi ketika mendekati target. AccelStepper, yang bisa kamu instal dari Library Manager, melakukan ini tanpa memblokir: kamu memanggil run() terus-menerus di dalam loop() dan library mengambil satu langkah setiap kali waktunya tiba. Dengan begitu kamu bisa membaca tombol, memperbarui layar, atau membaca sensor selama motor berputar; pendekatan ini dibahas lengkap di millis() vs delay(). Di Uno, AccelStepper bisa mencapai beberapa ribu langkah per detik dengan andal (dokumentasinya menyebut sekitar 4000 langkah/dtk di 16 MHz), jadi contohnya memakai 2000 langkah/dtk, sekitar 37 RPM di 1/16.

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}

Banyak motor dengan CNC Shield V3

Kalau kamu menggerakkan lebih dari satu NEMA 17, cara termudah menghindari kabel yang kusut adalah Arduino CNC Shield V3. Board ini dipasang di atas Uno dan punya empat soket A4988 (X, Y, Z, dan A), jumper microstepping di bawah tiap driver, header motor, input limit switch, dan terminal daya; dengan ketiga jumper terpasang, A4988 berjalan di 1/16. Di tabel pengkabelan, kita sengaja memilih D2, D5, dan D8 untuk STEP, DIR, dan EN: ini adalah pin sumbu X di shield, jadi sketch di atas langsung jalan di shield tanpa perubahan. Kalau kamu mem-flash GRBL ke Uno, shield ini berubah menjadi pengendali CNC atau laser yang menerima G-code dari komputermu. Di GRBL, jumlah langkah per milimeter untuk tiap sumbu dimasukkan di pengaturan $100, $101, dan $102: dengan pulley GT2 20 gigi dan microstepping 1/16 hasilnya 200 × 16 / (20 × 2) = 80 langkah/mm, dan di lead screw T8 dengan lead 8 mm hasilnya 200 × 16 / 8 = 400 langkah/mm.

Memakai A4988 dengan ESP32

Pin ESP32 mengeluarkan 3,3 V. A4988 hanya membaca input sebagai HIGH dengan andal kalau nilainya di atas 70% dari VDD; dengan VDD 5 V ambangnya 3,5 V, jadi sinyal 3,3 V tidak cukup. Karena itu, hubungkan pin VDD A4988 ke 3V3 ketika bekerja dengan ESP32 atau Pico: driver tetap jalan dengan baik di 3–5,5 V dan kamu tidak butuh konverter level logika. Karena VDD berubah, jangan lupa mengukur Vref lagi. Sketch di bawah menggerakkan motor, dengan akselerasi, ke sudut yang kamu ketik di Serial Monitor (misalnya 90 atau -45). Karena ESP32 jauh lebih cepat, AccelStepper dengan mudah mencapai 6000 langkah per detik di sini; untuk kecepatan yang lebih tinggi, lihat library FastAccelStepper yang memakai timer hardware. Kalau kamu baru mengenal ESP32, mulailah dari Apa Itu ESP32?.

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}

A4988 dengan Raspberry Pi Pico dan MicroPython

Di Pico, pin VDD A4988 juga dihubungkan ke pin 3V3 (OUT). Sebagai ganti library akselerasi, di MicroPython kamu bisa menulis ramp linear sederhana seperti di bawah: fungsi move() mengubah jeda antarpulsa secara bertahap dari 2000 µs ke 400 µs selama 600 langkah pertama dan terakhir, dan berjalan di kecepatan penuh di antaranya. Perulangan MicroPython menambah beberapa puluh mikrodetik di setiap langkah, jadi kecepatan sebenarnya sedikit lebih rendah dari hasil perhitungan. Kalau kamu butuh puluhan ribu langkah per detik atau beberapa motor sekaligus, blok PIO di Pico bisa menghasilkan pulsa tanpa membuat CPU sibuk sama sekali. Untuk menginstal MicroPython di Pico, lihat Apa Itu Raspberry Pi Pico?.

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)

Panas, heatsink, dan proteksi termal

Wajar kalau A4988 jadi panas, karena arus kumparan mengalir lewat MOSFET di dalam chip. Jalur arus tiap kumparan biasanya punya hambatan total 0,64 Ω, dan daya yang terbuang naik sebanding dengan kuadrat arus: kira-kira P ≈ I² × 0,64 Ω. Di pengaturan 1 A itu sekitar 0,65 W, dan di 1,5 A sekitar 1,45 W; ketika chip memanas, hambatannya juga naik, jadi angka sebenarnya lebih tinggi lagi. Itu panas yang banyak untuk board seukuran ujung jari. Ketika chip mencapai 165 °C, proteksi termal mematikan output dan menyalakannya lagi setelah suhunya turun sekitar 15 °C. Motor yang jalan beberapa detik, berhenti, lalu lanjut sendiri adalah tanda klasik proteksi ini bekerja.

• Pasang heatsink: Tempelkan heatsink aluminium kecil ke chip dengan thermal tape; pastikan heatsink tidak menyentuh pin atau potensiometer.
• Beri aliran udara: Di atas 1,2 A, atau di dalam kotak tertutup, kipas kecil melipatgandakan efek heatsink.
• Atur arus sesuai kebutuhan: Kalau motor tidak melewatkan langkah ketika diberi beban, turunkan Vref sedikit; mengurangi arus 20% memangkas panas sekitar 36%.
• Matikan kumparan ketika diam: Kalau kamu tidak butuh torsi penahan, buat pin EN menjadi HIGH atau panggil disableOutputs() setelah gerakan selesai; driver dan motor sama-sama jadi lebih dingin.
• Cek juga suhu motor: Motor stepper tetap menarik arus walaupun diam, jadi bisa hangat bahkan panas. Kalau bodinya di atas 60 °C, turunkan arusnya; di suhu itu komponen PLA di printer 3D mulai melunak.
• Pindah ke driver yang lebih kuat: Kalau motormu butuh lebih dari 1,5 A, driver seperti DRV8825 atau TMC2209 lebih cocok.

A4988 vs DRV8825 vs TMC2208

Ketiga driver ini memakai footprint 16 pin “StepStick” yang sama dan sering bisa saling ditukar di CNC Shield, tapi ada perbedaan yang perlu diperhatikan. Potensiometer DRV8825 ada di posisi lain dan rumusnya berbeda; pin yang di A4988 adalah VDD, di DRV8825 menjadi output FAULT. Dengan kode yang sama, TMC2208 memutar motor ke arah sebaliknya dibanding A4988, jadi kamu perlu membalik DIR lewat software atau memutar konektor motor 180°. Pengaturan lanjutannya dilakukan lewat UART, dan kalau kamu ingin homing tanpa sensor (StallGuard), lihat TMC2209. Singkatnya, A4988 tetap titik awal paling masuk akal untuk belajar dan proyek berbiaya rendah; pilih TMC2208 kalau kebisingan penting dan DRV8825 kalau kamu butuh arus lebih besar. Untuk perbandingan umum jenis-jenis motor, baca Motor DC vs Servo vs Stepper.

Motor bergetar tapi tidak berputar: kesalahan umum dan solusinya

Ide proyek dengan A4988 dan NEMA 17

• Slider kamera: Gerakkan kamera di sepanjang rel milimeter demi milimeter dengan belt dan pulley GT2 untuk merekam video time-lapse.
• Pen plotter: Gerakkan pena di dua sumbu dengan CNC Shield dan GRBL untuk memindahkan gambar dari komputer ke kertas; untuk mengangkat dan menurunkan pena cukup pakai motor servo.
• Meja putar: Putar objek dengan sudut yang sama untuk foto produk atau pemindaian 3D; karena satu putaran di 1/16 sama dengan 3200 langkah, kamu mengambil sekitar 89 langkah di antara masing-masing dari 36 foto.
• Pelacak matahari: Buat rangka yang memutar panel menghadap matahari sepanjang hari; ide lengkapnya ada di artikel pelacak matahari.
• Pangkal lengan robot: Putar pangkal lengan yang berat dengan NEMA 17 dan roda gigi sebagai ganti servo; untuk sendi lainnya, lihat artikel lengan robot Arduino.
• Pemosisian manual: Gerakkan motor dengan cepat memakai joystick dan dengan presisi, langkah demi langkah, memakai rotary encoder.
• Gorden otomatis atau penutup geser: Ketika mulai menyala, cari titik nol dengan limit switch, simpan dengan setCurrentPosition(0), lalu gerakkan gorden ke posisi mana pun yang kamu mau.

Ringkasnya, begini cara menggerakkan NEMA 17 dengan A4988: pasangkan kumparan dengan benar, pasang 100 µF di jalur catu daya, hitung Vref dengan rumus lalu atur dengan multimeter, pilih microstepping, dan jalankan motor dengan akselerasi. Begitu kamu menguasai dasar ini, cara kerja mesin seperti printer 3D dan CNC juga jadi jelas. Di aplikasi BlueGrays kamu bisa menemukan proyek gerak seperti “Menggunakan Motor Stepper” dan “Servo 360 Derajat dari Motor Stepper”, langkah demi langkah lengkap dengan skema rangkaian dan kodenya.