Motor getar Arduino: pengkabelan modul, PWM, dan pola haptik
Panduan motor getar Arduino: modul motor koin ERM, transistor dan dioda, kekuatan PWM, pola haptik, tongkat pintar, kode ESP32 dan Pico, serta catatan tentang DRV2605.
Dalam proyek motor getar Arduino, motor kecil adalah cara termudah untuk memberi informasi kepada pengguna tanpa suara atau cahaya. Ponsel yang bergetar dalam mode senyap, smartwatch yang mengetuk pergelangan tangan, dan kontroler game yang bergemuruh semuanya mengandalkan motor mungil ini. Jenis yang paling banyak dipakai dalam hobi elektronika adalah motor getar ERM tipe koin, dengan diameter 10 mm dan ketebalan hanya 2–3 mm. Motor tanpa modul tidak boleh dihubungkan langsung ke pin Arduino, tetapi modul motor getar siap pakai yang dilengkapi transistor dan dioda pada board dapat menjalankannya hanya dengan tiga kabel.
Dalam panduan ini kamu akan mempelajari cara motor ERM bergetar, mengapa transistor dan dioda di dalam modul diperlukan, serta berapa besar arus yang ditarik motor. Lalu kita akan mengatur getaran secara bertahap dengan PWM dan melihat mengapa motor sama sekali tidak berputar pada daya rendah serta bagaimana “kick-start” mengatasinya. Kita akan menulis kode yang memainkan pola haptik seperti ketukan singkat, ketukan ganda, detak jantung, dan SOS tanpa memakai delay(), serta membuat logika tongkat pintar yang bergetar sesuai jarak. Di bagian akhir kamu akan menemukan contoh umpan balik getaran ketika menyentuh pin sentuh ESP32, kode MicroPython untuk Raspberry Pi Pico, dan driver DRV2605 untuk efek haptik tingkat lanjut.

Apa itu motor getar dan bagaimana cara kerjanya?
ERM merupakan singkatan dari “Eccentric Rotating Mass”. Poros motor membawa massa kecil dengan pusat gravitasi yang tidak tepat di tengah. Ketika motor berputar, massa yang tidak seimbang ini menarik motor ke satu arah pada setiap putaran, dan tarikan itu terasa sebagai getaran. Pada motor koin, massa berputar di dalam rumah motor yang pipih dan tidak ada bagian luar yang bergerak, sehingga motor sangat mudah ditempel dan digunakan. Motor ERM silinder memiliki pemberat logam berbentuk setengah bulan di bagian luar dan menghasilkan getaran lebih kuat. Kekuatan dan frekuensi getaran sama-sama bergantung pada kecepatan motor: ketika tegangan naik, motor berputar lebih cepat, dan getarannya menjadi lebih kuat sekaligus lebih tinggi frekuensinya. LRA (aktuator resonansi linear), yang semakin banyak dipakai pada ponsel dan kontroler game, bekerja dengan cara berbeda: magnet pada pegas bergerak bolak-balik dan hanya bekerja dengan baik menggunakan sinyal bolak-balik pada frekuensi resonansinya sendiri, bukan DC biasa. Modul dalam kit Arduino hampir selalu berupa ERM.
| Karakteristik | Motor ERM koin tipikal (misalnya 1027) |
|---|---|
| Ukuran | Diameter 10 mm, tebal 2,7 mm |
| Tegangan nominal | 3 V (sekitar 2,5–3,5 V) |
| Arus ketika berjalan | Sekitar 60–90 mA pada 3 V |
| Arus awal | 100–120 mA dalam waktu singkat |
| Kecepatan | Sekitar 10.000–13.000 rpm |
| Frekuensi getaran | Sekitar 160–220 Hz |
| Tegangan awal minimum | Sekitar 2–2,3 V; di bawahnya motor tidak akan mulai berputar |
Apa isi modul motor getar?
Pin Arduino Uno dapat memasok paling banyak 40 mA, dengan batas aman sekitar 20 mA. Pin ESP32 dan Pico memiliki kemampuan yang lebih kecil lagi. Motor getar menarik 60–120 mA dan berperilaku seperti kumparan: begitu arusnya diputus, lonjakan tegangan balik yang tinggi muncul di kedua terminalnya. Karena itu, menghubungkan motor langsung ke pin membebani pin dan dapat membuat mikrokontroler reset atau bahkan rusak. Modul siap pakai mengatasi masalah ini dengan tiga komponen:
- Transistor driver: Biasanya S8050 atau transistor NPN kecil sejenis; beberapa modul memakai MOSFET kanal-N. Pin Arduino hanya memasok arus kendali beberapa miliampere, sedangkan arus motor mengalir melalui transistor. Cara kerja transistor sebagai sakelar dijelaskan dalam Apa Itu Transistor?.
- Resistor basis: Membatasi arus dari pin ke transistor; nilai sekitar 1 kΩ cocok untuk board 5 V maupun 3,3 V.
- Dioda flyback: Dipasang terbalik secara paralel dengan motor, dioda ini menghubungsingkatkan lonjakan tegangan yang muncul ketika motor dimatikan dan melindungi transistor. Kamu bisa membaca fungsinya dalam Apa Itu Dioda?.
Sebagian besar modul memiliki tiga pin: VCC, GND, dan pin sinyal IN (S atau SIG pada beberapa board). Ketika kamu mengatur IN menjadi HIGH, transistor aktif dan motor berputar. Modulnya bekerja pada 3,3–5 V. Dengan catu 5 V, motor menerima sekitar 4,5 V setelah sedikit jatuh tegangan pada transistor, yang melebihi tegangan nominal motor 3 V. Ini tidak masalah untuk peringatan singkat, tetapi jika motor akan berjalan terus-menerus dalam waktu lama, membatasi daya sekitar 60–70% dengan PWM akan memperpanjang umurnya.
Pengkabelan: Arduino Uno, ESP32, dan Raspberry Pi Pico
Tabel berikut mencantumkan pin yang digunakan oleh semua sketch dalam artikel ini. Pada setiap board, pin motor harus mampu menghasilkan PWM. Pada ESP32 dan Pico, sinyal 3,3 V ke pin IN sudah cukup untuk menggerakkan transistor; kamu dapat menghubungkan pin VCC modul ke 5 V untuk getaran lebih kuat atau ke 3,3 V untuk getaran lebih lembut. Apa pun catu daya yang dipilih, ground harus disatukan.
| Koneksi | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC modul | 5V | VIN (5 V) atau 3V3 | VBUS (5 V) atau 3V3(OUT) |
| GND modul | GND | GND | GND |
| IN modul | D5 (PWM) | GPIO 25 | GP15 |
| Tombol (kaki lainnya ke GND) | D2 | Pin sentuh GPIO 4 (T0) | GP14 |
| HC-SR04 TRIG (contoh tongkat) | D9 | - | - |
| HC-SR04 ECHO (contoh tongkat) | D10 | - | - |
Sketch pertama: nyala/mati dan kekuatan getaran dengan PWM
Kamu bisa menganggap modul motor getar seperti LED: digitalWrite(HIGH) menjalankan motor dengan daya penuh, sedangkan analogWrite() memakai PWM untuk mengatur tegangan rata-rata dan dengan demikian kekuatan getaran. Pada Arduino Uno, pin D5 dan D6 bekerja sekitar 980 Hz, sedangkan pin PWM lainnya sekitar 490 Hz. Dasar PWM dibahas secara terperinci dalam Apa Itu PWM?. Motor ERM memiliki sifat penting: membuat motor yang berhenti mulai berputar membutuhkan daya lebih besar daripada mempertahankan putaran motor yang sudah berputar. Karena itu, motor yang mulai dijalankan dengan nilai PWM rendah mungkin sama sekali tidak bergerak. Solusinya adalah menjalankan motor dengan daya penuh selama beberapa puluh milidetik, lalu menurunkannya ke nilai yang diinginkan; ini disebut kick-start. Sketch berikut mula-mula memberikan getaran singkat dengan daya penuh, lalu menaikkan kekuatannya secara bertahap dan mencetak setiap tahap ke Serial Monitor.
1const int MOTOR_PIN = 5; // PWM pini (Uno'da ~980 Hz) / PWM pin (~980 Hz on Uno)
2
3// Kalkış darbesiyle istenen güce geç / start with a kick, then go to the requested power
4void motorGuc(int guc) {
5 static int oncekiGuc = 0;
6 if (guc > 0 && oncekiGuc == 0 && guc < 200) {
7 analogWrite(MOTOR_PIN, 255); // durgun motoru tam güçle kaldır / kick a stopped motor at full power
8 delay(30);
9 }
10 analogWrite(MOTOR_PIN, guc); // 0-255 arası güç / power between 0 and 255
11 oncekiGuc = guc;
12}
13
14void setup() {
15 Serial.begin(9600);
16 pinMode(MOTOR_PIN, OUTPUT);
17
18 motorGuc(255); // 300 ms tam güç / 300 ms at full power
19 delay(300);
20 motorGuc(0);
21 delay(1000);
22}
23
24void loop() {
25 for (int guc = 60; guc <= 255; guc += 15) {
26 Serial.print("PWM: ");
27 Serial.println(guc);
28 motorGuc(guc);
29 delay(700);
30 motorGuc(0); // her adım arasında dur / stop between steps
31 delay(500);
32 }
33 delay(2000);
34}Ketika menjalankan kode, kamu akan melihat bahwa motor sama sekali tidak bergetar, atau hanya bergetar sangat lemah, di bawah nilai PWM tertentu. Dengan catu 5 V, ambang ini biasanya berada antara 70 dan 110; nilai tepatnya bergantung pada motor dan modul. Catat nilai di Serial Monitor ketika getaran motor pertama kali terasa jelas dan gunakan sebagai daya minimum dalam proyekmu. Berkat kick-start, nilai sedikit di bawah ambang ini juga bisa bekerja, karena setelah motor berputar, daya yang lebih kecil sudah cukup untuk mempertahankan putarannya.
| Nilai PWM (catu 5 V) | Tegangan rata-rata | Getaran yang terasa |
|---|---|---|
| 0–60 | 0–1,2 V | Tidak ada, motor tidak berputar |
| 70–110 | 1,4–2,2 V | Zona ambang; mungkin memerlukan kick-start |
| 120–170 | 2,4–3,3 V | Getaran ringan hingga sedang, ideal untuk peringatan panjang |
| 180–255 | 3,5–4,5 V | Getaran kuat, untuk peringatan singkat yang menarik perhatian |
Pola haptik: ketukan singkat, ketukan ganda, detak jantung, dan SOS
Satu jenis getaran hanya memberi tahu bahwa “sesuatu terjadi”. Pola yang berbeda juga memberi tahu pengguna apa yang terjadi: ketukan singkat dapat berarti konfirmasi, dua ketukan singkat berarti peringatan, getaran panjang berarti alarm, dan irama seperti detak jantung berarti pengingat. Tangan manusia hampir tidak merasakan getaran yang lebih pendek dari 20–30 ms, dan motor ERM memerlukan sekitar 30–50 ms untuk mulai berputar. Jadi, buat getaran terpendek dalam pola sepanjang 40–60 ms dan jeda antara dua getaran setidaknya 80–100 ms. Dalam sketch berikut, setiap pola berupa array pasangan {power, duration}. Pemutar pola bekerja dengan millis(), sehingga loop() dapat mengerjakan tugas lain selama pola dimainkan. Setiap penekanan tombol pada D2 memainkan pola berikutnya.
1const int MOTOR_PIN = 5;
2const int BUTON_PIN = 2; // diğer ucu GND / other leg to GND
3
4struct Adim { uint8_t guc; uint16_t sure; }; // güç 0-255, süre ms / power 0-255, duration ms
5
6const Adim TIK[] = {{255, 50}};
7const Adim CIFT_TIK[] = {{255, 50}, {0, 100}, {255, 50}};
8const Adim UZUN[] = {{200, 600}};
9const Adim KALP[] = {{255, 60}, {0, 120}, {180, 80}, {0, 600}, {255, 60}, {0, 120}, {180, 80}};
10const Adim SOS[] = {{255, 100}, {0, 100}, {255, 100}, {0, 100}, {255, 100}, {0, 300},
11 {255, 350}, {0, 100}, {255, 350}, {0, 100}, {255, 350}, {0, 300},
12 {255, 100}, {0, 100}, {255, 100}, {0, 100}, {255, 100}};
13const Adim ARTAN[] = {{120, 150}, {160, 150}, {200, 150}, {255, 300}};
14
15struct Desen { const Adim *adimlar; uint8_t adet; const char *ad; };
16const Desen DESENLER[] = {
17 {TIK, 1, "Tik"}, {CIFT_TIK, 3, "Cift tik / Double tap"}, {UZUN, 1, "Uzun / Long"},
18 {KALP, 7, "Kalp atisi / Heartbeat"}, {SOS, 17, "SOS"}, {ARTAN, 4, "Artan / Ramp"}
19};
20const uint8_t DESEN_SAYISI = sizeof(DESENLER) / sizeof(DESENLER[0]);
21
22const Adim *calanDesen = nullptr; // şu an çalan desen / pattern now playing
23uint8_t calanAdet = 0, adimNo = 0;
24unsigned long adimBaslangic = 0;
25
26void desenBaslat(const Desen &d) {
27 calanDesen = d.adimlar;
28 calanAdet = d.adet;
29 adimNo = 0;
30 adimBaslangic = millis();
31 analogWrite(MOTOR_PIN, calanDesen[0].guc);
32 Serial.println(d.ad);
33}
34
35void desenGuncelle() { // loop'ta sürekli çağır / call it continuously in loop
36 if (calanDesen == nullptr) return;
37 if (millis() - adimBaslangic < calanDesen[adimNo].sure) return;
38 adimNo++;
39 if (adimNo >= calanAdet) { // desen bitti / pattern finished
40 analogWrite(MOTOR_PIN, 0);
41 calanDesen = nullptr;
42 return;
43 }
44 adimBaslangic = millis();
45 analogWrite(MOTOR_PIN, calanDesen[adimNo].guc);
46}
47
48void setup() {
49 Serial.begin(9600);
50 pinMode(MOTOR_PIN, OUTPUT);
51 pinMode(BUTON_PIN, INPUT_PULLUP);
52}
53
54void loop() {
55 static uint8_t siradaki = 0;
56 static bool oncekiBasili = false;
57 bool basili = (digitalRead(BUTON_PIN) == LOW);
58 if (basili && !oncekiBasili && calanDesen == nullptr) { // yeni basış / new press
59 desenBaslat(DESENLER[siradaki]);
60 siradaki = (siradaki + 1) % DESEN_SAYISI;
61 }
62 oncekiBasili = basili;
63 desenGuncelle();
64 delay(5); // basit ark önleme / simple debounce
65}Untuk mengubah pola, kamu hanya perlu mengedit array; fungsi pemutarnya tetap sama. Dalam pola SOS, getaran pendek berdurasi 100 ms, getaran panjang 350 ms, dan jeda antarhuruf 300 ms; perbandingan ini mengikuti susunan “titik, garis” kode Morse. Buat pola yang jelas berbeda agar pengguna tidak tertukar: gunakan jumlah berbeda (satu, dua, tiga getaran) atau durasi yang jelas berbeda. Sebelum menambahkan pola ke proyek, coba pada beberapa orang dan minta mereka menebak arti setiap pola; dalam desain haptik, itulah pengujian terbaik.
Peringatan wearable dan tongkat pintar
Motor getar sangat berguna ketika suara mengganggu atau tidak bisa didengar. Dalam proyek wearable, tempatkan motor di dalam gelang, sarung tangan, atau sabuk, dekat dengan kulit. Bagian dalam pergelangan tangan, telapak tangan, dan ujung jari merupakan area yang paling peka terhadap getaran. Menempelkan motor pada permukaan keras, misalnya dinding dalam casing hasil cetak 3D dengan selotip dua sisi, menyalurkan getaran lebih baik daripada menjahitnya secara longgar pada kain. Dalam proyek tongkat pintar untuk tunanetra, motor ditempatkan pada bagian pegangan tepat di bawah ibu jari, dan jarak ke rintangan diubah menjadi laju serta kekuatan getaran: semakin dekat rintangannya, semakin cepat dan kuat getarannya, hingga menjadi getaran terus-menerus ketika sangat dekat. Sketch berikut menunjukkan logika ini dengan sensor jarak HC-SR04.
1const int TRIG_PIN = 9;
2const int ECHO_PIN = 10;
3const int MOTOR_PIN = 5;
4const int UZAK_CM = 150; // bunun ötesinde titreşim yok / no vibration beyond this
5const int YAKIN_CM = 30; // bunun altında sürekli titreşim / continuous below this
6
7int mesafeOlc() {
8 digitalWrite(TRIG_PIN, LOW);
9 delayMicroseconds(2);
10 digitalWrite(TRIG_PIN, HIGH);
11 delayMicroseconds(10);
12 digitalWrite(TRIG_PIN, LOW);
13 unsigned long sure = pulseIn(ECHO_PIN, HIGH, 12000); // ~2 m zaman aşımı / ~2 m timeout
14 if (sure == 0) return 999; // yankı yok / no echo
15 return sure / 58; // cm
16}
17
18void setup() {
19 pinMode(TRIG_PIN, OUTPUT);
20 pinMode(ECHO_PIN, INPUT);
21 pinMode(MOTOR_PIN, OUTPUT);
22}
23
24void loop() {
25 int cm = mesafeOlc();
26 if (cm > UZAK_CM) {
27 analogWrite(MOTOR_PIN, 0); // yol açık / path is clear
28 delay(60);
29 } else if (cm <= YAKIN_CM) {
30 analogWrite(MOTOR_PIN, 255); // dur uyarısı / stop warning
31 delay(60);
32 } else {
33 int guc = map(cm, UZAK_CM, YAKIN_CM, 150, 255); // yaklaştıkça güçlenir / stronger when closer
34 int bosluk = map(cm, UZAK_CM, YAKIN_CM, 900, 150); // yaklaştıkça sıklaşır / more frequent when closer
35 analogWrite(MOTOR_PIN, guc);
36 delay(80); // 80 ms titreşim / 80 ms buzz
37 analogWrite(MOTOR_PIN, 0);
38 delay(bosluk);
39 }
40}Agar tetap sederhana, sketch ini memakai delay() dan tidak mengambil pembacaan baru selama menunggu; pada tongkat sungguhan, struktur berbasis millis() seperti pada bagian sebelumnya memberikan respons lebih baik. Daya minimum dipertahankan pada 150 agar motor tidak berada di bawah ambang dan gagal berputar untuk rintangan yang jauh. Untuk proyek lengkap dengan peringatan genangan air, deteksi jatuh, SOS, dan perhitungan baterai, lihat Tongkat Pintar Arduino, dan untuk perincian sensor, lihat panduan sensor jarak HC-SR04.
Arus, catu daya, dan umur baterai
Motor koin menarik 60–90 mA ketika berjalan dan lebih dari 100 mA dalam waktu singkat ketika mulai berputar. Pin 5V Arduino Uno dapat dengan mudah memasoknya dari USB. Masalah biasanya muncul pada rangkaian bertenaga baterai yang tegangannya sudah mendekati batas minimum, atau pada proyek dengan beberapa motor berjalan bersamaan: ketika motor mulai berputar, tegangan turun sekejap dan board reset. Untuk mencegahnya, tambahkan kapasitor elektrolit 47–100 µF di antara pin VCC dan GND modul, dan jika memakai lebih dari satu motor, jalankan dengan selisih beberapa milidetik, bukan bersamaan. Ketika menghitung umur baterai, ingat bahwa motor bekerja dalam getaran singkat, bukan terus-menerus: misalnya, motor 80 mA yang berjalan total 3 detik per menit hanya memiliki arus rata-rata 4 mA. Gunakan alat Umur baterai dengan nilai proyekmu sendiri untuk mengetahui berapa jam perangkat dapat bertahan.
Umpan balik sentuhan dengan ESP32
Dua keunggulan ESP32 sangat cocok dipadukan dengan motor getar: chip ini memiliki pin sentuh kapasitif, dan unit LEDC penghasil PWM memungkinkan pengaturan frekuensi secara bebas. Sketch berikut memberikan getaran “klik” singkat, seperti layar ponsel, ketika kabel atau potongan foil tembaga yang dihubungkan ke GPIO 4 (T0) disentuh; jika sentuhan berlangsung lebih dari 1 detik, konfirmasi diberikan lewat getaran panjang. Frekuensi PWM diatur ke 20 kHz, di batas pendengaran manusia, sehingga denging lemah dari driver motor pun hilang. Kode dapat dikompilasi dengan core Arduino ESP32 versi 2.x maupun 3.x, karena nama fungsi LEDC berbeda di antara keduanya.
1const int MOTOR_PIN = 25; // modül IN / module IN
2const int DOKUNMA_PIN = T0; // GPIO 4, kapasitif dokunma / capacitive touch
3const int PWM_FREKANS = 20000; // 20 kHz, duyulmaz / 20 kHz, inaudible
4const int PWM_BIT = 8; // 0-255 çözünürlük / 0-255 resolution
5const int PWM_KANAL = 0; // yalnız 2.x için / only for core 2.x
6
7void motorYaz(uint8_t guc) {
8#if ESP_ARDUINO_VERSION_MAJOR >= 3
9 ledcWrite(MOTOR_PIN, guc); // 3.x: pin numarasıyla / 3.x: by pin number
10#else
11 ledcWrite(PWM_KANAL, guc); // 2.x: kanal numarasıyla / 2.x: by channel number
12#endif
13}
14
15void titret(uint8_t guc, int ms) {
16 motorYaz(guc);
17 delay(ms);
18 motorYaz(0);
19}
20
21int esik = 0;
22
23void setup() {
24 Serial.begin(115200);
25#if ESP_ARDUINO_VERSION_MAJOR >= 3
26 ledcAttach(MOTOR_PIN, PWM_FREKANS, PWM_BIT);
27#else
28 ledcSetup(PWM_KANAL, PWM_FREKANS, PWM_BIT);
29 ledcAttachPin(MOTOR_PIN, PWM_KANAL);
30#endif
31 long toplam = 0; // dokunulmamış değeri ölç / measure the untouched value
32 for (int i = 0; i < 20; i++) {
33 toplam += touchRead(DOKUNMA_PIN);
34 delay(10);
35 }
36 esik = (toplam / 20) * 7 / 10; // %70'inin altı dokunuş / below 70% means touched
37 Serial.printf("Dokunma esigi / Touch threshold: %d\n", esik);
38 titret(255, 60); // hazır işareti / ready signal
39}
40
41void loop() {
42 static bool dokunuyor = false;
43 static unsigned long dokunmaBasi = 0;
44 static bool uzunVerildi = false;
45 int deger = touchRead(DOKUNMA_PIN); // dokununca değer düşer / value drops when touched
46
47 if (deger < esik && !dokunuyor) { // dokunuş başladı / touch started
48 dokunuyor = true;
49 uzunVerildi = false;
50 dokunmaBasi = millis();
51 titret(255, 40); // kısa tık / short click
52 } else if (deger < esik && !uzunVerildi && millis() - dokunmaBasi > 1000) {
53 titret(200, 400); // uzun basış onayı / long-press confirmation
54 uzunVerildi = true;
55 } else if (deger >= esik) {
56 dokunuyor = false;
57 }
58 delay(20);
59}Pada ESP32, nilai pin sentuh biasanya sekitar 50–80 ketika tidak disentuh dan turun jelas ketika disentuh jari; karena itu, kode mengukur nilai rata-rata ketika mulai berjalan dan menghitung ambang secara otomatis. Namun, pada ESP32-S2 dan S3, nilai sentuh justru berlawanan dan naik ketika disentuh; pada board tersebut kamu perlu membalik perbandingannya. Jika pin VCC modul dihubungkan ke pin VIN ESP32, motor bergetar lebih kuat pada 5 V; sinyal 3,3 V pada pin IN sudah cukup untuk menggerakkan transistor. Dengan memadukannya dengan Wi-Fi atau Bluetooth, kamu bisa membuat gelang yang bergetar ketika ponselmu menerima notifikasi, atau perangkat peringatan yang dikendalikan melalui BLE ESP32.
Motor getar dengan Raspberry Pi Pico dan MicroPython
Pada Raspberry Pi Pico, setiap pin GPIO dapat menghasilkan PWM. Dalam MicroPython, fungsi duty_u16() pada kelas PWM menerima nilai antara 0 dan 65535; 65535 berarti daya penuh. Kode berikut memainkan pola detak jantung setiap kali tombol pada GP14 ditekan. Seperti pada contoh Arduino, pola berupa daftar pasangan daya dan durasi. Kamu dapat menghubungkan pin VCC modul ke VBUS (5 V dari USB) untuk getaran lebih kuat atau ke 3V3(OUT) untuk getaran lebih lembut.
1from machine import Pin, PWM
2import time
3
4motor = PWM(Pin(15)) # modül IN pini / module IN pin
5motor.freq(1000) # 1 kHz PWM
6buton = Pin(14, Pin.IN, Pin.PULL_UP) # diğer ucu GND / other leg to GND
7
8# (güç %, süre ms) çiftleri / (power %, duration ms) pairs
9KALP = [(100, 60), (0, 120), (70, 80), (0, 600), (100, 60), (0, 120), (70, 80)]
10CIFT_TIK = [(100, 50), (0, 100), (100, 50)]
11
12def guc_ayarla(yuzde):
13 motor.duty_u16(int(65535 * yuzde / 100))
14
15def desen_cal(desen):
16 for yuzde, sure in desen:
17 guc_ayarla(yuzde)
18 time.sleep_ms(sure)
19 guc_ayarla(0) # her zaman kapalı bitir / always end switched off
20
21desen_cal(CIFT_TIK) # açılış işareti / start-up signal
22while True:
23 if buton.value() == 0: # basıldı / pressed
24 desen_cal(KALP)
25 while buton.value() == 0: # bırakılmasını bekle / wait for release
26 time.sleep_ms(10)
27 time.sleep_ms(20)Pin Pico bekerja pada 3,3 V dan tidak disarankan menarik lebih dari sekitar 12 mA dari satu pin, jadi pada Pico pun kamu perlu memakai modul transistor, bukan motor tanpa modul. Tombol tidak dibaca selama pola dimainkan; jika perlu mengerjakan beberapa hal sekaligus, kamu bisa menerapkan pola millis() Arduino dengan time.ticks_ms() atau melanjutkan langkah pola menggunakan interrupt Timer. Jika baru mulai memakai MicroPython, artikel dasar-dasar MicroPython merupakan titik awal yang baik.
Driver haptik DRV2605: efek getaran profesional
Modul transistor hanya menyalakan dan mematikan motor atau memperkuat dan memperlemah getarannya dengan PWM. “Klik” tegas yang kamu rasakan pada ponsel dihasilkan dengan menjalankan dan menghentikan motor sangat cepat: motor mula-mula dipercepat dengan pulsa di atas tegangan nominalnya (overdrive), lalu ketika getaran berakhir, motor direm dengan tegangan balik singkat. Chip DRV2605L dari Texas Instruments melakukannya sendiri. Chip ini terhubung melalui I2C (alamat 0x5A), dapat menggerakkan motor ERM maupun LRA, dan memiliki 123 efek bawaan seperti klik, klik ganda, getaran, serta ketukan lembut. Chip mempelajari karakteristik motor melalui kalibrasi otomatis dan dapat mengubah input audio menjadi getaran. Dengan library Adafruit DRV2605, hanya diperlukan beberapa baris kode; pada Uno, hubungkan SDA ke A4 dan SCL ke A5, sedangkan motor langsung dihubungkan ke output motor pada board DRV2605.
1#include <Wire.h>
2#include <Adafruit_DRV2605.h>
3
4Adafruit_DRV2605 haptik;
5
6void setup() {
7 Serial.begin(9600);
8 if (!haptik.begin()) { // I2C adresi 0x5A / I2C address 0x5A
9 Serial.println("DRV2605 bulunamadi / not found");
10 while (1) {}
11 }
12 haptik.selectLibrary(1); // ERM efekt kütüphanesi / ERM effect library
13 haptik.setMode(DRV2605_MODE_INTTRIG); // go() ile tetikle / trigger with go()
14}
15
16void efektCal(uint8_t efekt) {
17 haptik.setWaveform(0, efekt); // 1. slot: efekt / slot 1: effect
18 haptik.setWaveform(1, 0); // 0 = dizinin sonu / 0 = end of sequence
19 haptik.go();
20}
21
22void loop() {
23 efektCal(1); // 1: güçlü tık / strong click
24 delay(1000);
25 efektCal(10); // 10: çift tık / double click
26 delay(1000);
27 efektCal(14); // 14: güçlü vızıltı / strong buzz
28 delay(2000);
29}DRV2605 dapat memainkan hingga 8 efek berturut-turut dalam satu urutan; isi slot 0 hingga 7 dengan setWaveform() dan tandai akhir urutan dengan 0. Jika memakai motor LRA, panggil useLRA() dan pilih library LRA nomor 6. Untuk peringatan sederhana, modul transistor sudah lebih dari cukup; jika kamu merancang produk wearable, kontroler game, atau antarmuka sentuh, DRV2605 memberikan peningkatan sensasi yang jelas terasa.
Ide proyek dengan motor getar
- Gelang timer senyap: Buat timer pomodoro yang bergetar di pergelangan tangan ketika pelajaran atau sesi belajar berakhir, tanpa mengganggu kelas.
- Tongkat pintar untuk tunanetra: Ikuti panduan tongkat pintar untuk proyek lengkap yang mengubah jarak rintangan menjadi irama getaran.
- Bel pintu senyap: Buat perangkat di sakumu bergetar ketika sensor gerak PIR di pintu mendeteksi seseorang.
- Kontroler game: Tambahkan getaran ketika terjadi tabrakan pada kontroler game yang dibuat dengan modul joystick.
- Pengingat postur: Ukur sudut punggung dengan MPU6050 dan berikan getaran singkat ketika kamu duduk membungkuk terlalu lama.
- Getaran sebagai pengganti suara: Pada alarm yang dipakai malam hari, tempatkan motor getar di bawah bantal sebagai pengganti buzzer.
Kesalahan umum dan solusinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| Motor sama sekali tidak berputar | Nilai PWM di bawah ambang awal atau GND belum disatukan | Coba 255 terlebih dahulu, tambahkan kick-start, dan satukan ground |
| Arduino reset ketika motor berjalan | Arus awal membuat tegangan catu turun drastis atau tidak ada dioda | Gunakan modul siap pakai dan tambahkan kapasitor 47–100 µF antara VCC dan GND |
| Getaran sangat lemah | Modul bekerja pada 3,3 V atau motor berada di permukaan lunak | Hubungkan VCC ke 5 V dan tempelkan motor pada permukaan keras |
| Motor menjadi hangat | Motor berjalan dengan daya penuh pada 5 V dalam waktu lama | Batasi daya menjadi 60–70% dengan PWM dan gunakan pulsa singkat sebagai pengganti getaran terus-menerus |
| Terdengar denging lemah dari motor | Frekuensi PWM berada dalam rentang pendengaran | Atur frekuensi LEDC ke 20 kHz pada ESP32; gunakan getaran singkat pada Uno |
| Error ledcSetup tidak ditemukan pada ESP32 | Core ESP32 versi 3.x | Gunakan percabangan #if ESP_ARDUINO_VERSION_MAJOR dari artikel ini |
| Pin berhenti bekerja setelah motor tanpa modul dihubungkan | Motor dihubungkan langsung ke pin dan merusaknya | Gunakan pin lain dan selalu gerakkan motor melalui transistor dan dioda |
| Pola terasa mirip | Getaran terlalu pendek atau jedanya terlalu singkat | Buat getaran terpendek 40–60 ms dan jedanya setidaknya 100 ms |
Motor getar adalah cara termurah untuk menambahkan sensasi sentuhan pada proyekmu selain layar dan suara. Setelah memahami transistor dan dioda di dalam modul, pengaturan kekuatan dengan PWM, kick-start, dan pola haptik, kamu bisa merancang peringatan senyap maupun perangkat bantu untuk tunanetra. Dalam aplikasi BlueGrays, kamu dapat menjelajahi proyek seperti buzzer, sensor parkir HC-SR04, dan kendali daya PWM dengan skema rangkaian langkah demi langkah serta kode siap pakai, lalu mengembangkan idemu sendiri dengan menambahkan motor getar.
Pertanyaan umum
Bagaimana cara menghubungkan motor getar ke Arduino?
Hubungkan pin VCC modul motor getar siap pakai ke 5V, GND ke GND, dan IN ke pin PWM seperti D5. Transistor pada modul mengalirkan arus motor dan dioda melindungi Arduino. Jika memakai motor tanpa modul, kamu harus menambahkan transistor NPN, resistor basis 1 kΩ, dan dioda.
Pada tegangan berapa motor getar bekerja?
Sebagian besar motor getar ERM tipe koin memiliki tegangan nominal 3 V dan bekerja antara sekitar 2,5 dan 3,5 V. Modul siap pakai dapat diberi catu 3,3–5 V; pada 5 V motor bergetar lebih kuat, tetapi pembatasan daya dengan PWM untuk penggunaan lama akan memperpanjang umurnya. Di bawah sekitar 2 V, motor tidak akan mulai berputar.
Berapa arus yang ditarik motor getar?
Motor getar koin tipikal menarik 60–90 mA ketika berjalan dan 100–120 mA dalam waktu singkat ketika mulai berputar. Nilai ini beberapa kali lebih besar daripada arus yang dapat dipasok pin Arduino dengan aman. Karena itu, motor harus digerakkan melalui transistor atau modul siap pakai.
Bagaimana cara mengatur kekuatan motor getar?
Kekuatan diatur dengan PWM, yaitu analogWrite(pin, 0–255) pada Arduino; semakin tinggi nilainya, semakin cepat motor berputar dan semakin kuat getarannya. Karena motor tidak berputar di bawah ambang tertentu, memberikan daya penuh selama 20–30 ms terlebih dahulu lalu menurunkannya ke nilai target bekerja baik pada daya rendah. Pada ESP32, ledcWrite(), dan pada Pico, duty_u16(), melakukan tugas yang sama.
Apa perbedaan motor getar ERM dan LRA?
Motor ERM bergetar dengan memutar massa yang tidak seimbang pada porosnya dan bekerja dengan DC biasa. LRA menggerakkan magnet pada pegas secara bolak-balik, hanya bekerja dengan sinyal bolak-balik pada frekuensi resonansinya, dan memberikan respons lebih tegas serta cepat. Untuk menggerakkan LRA diperlukan driver haptik seperti DRV2605.
Mengapa motor getar memerlukan dioda?
Karena motor memiliki kumparan, lonjakan tegangan balik yang tinggi muncul di kedua terminalnya begitu arus diputus. Dioda yang dipasang terbalik secara paralel dengan motor menghubungsingkatkan lonjakan ini dan mencegah kerusakan transistor serta mikrokontroler. Modul siap pakai sudah dilengkapi dioda ini pada board.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Menggunakan Buzzer
Pernah penasaran bagaimana bel pintu atau alarm mengeluarkan suaranya? Arduino membuat buzzer kecil berbunyi bip dengan jeda singkat: bip, jeda, bip, jeda.

Pengukuran Jarak HC-SR04 (Tampilan Serial)
Sensor HC-SR04 bekerja persis seperti kelelawar yang mencari jalan dalam gelap: ia mengirim suara yang tidak bisa kamu dengar, mendengarkan pantulannya, dan mengukur seberapa jauh benda di depannya.

Kendali LED dengan Tombol Tekan (Tekan)
Persis seperti bel pintu: lampu tetap menyala selama kamu menekan, dan mati ketika kamu melepasnya. Arduino terus mendengarkan tombol; selama ditekan LED menyala, dan begitu jarimu terangkat LED mati.

Sensor Parkir dengan HC-SR04
Versi mini sensor parkir mobil: makin dekat sesuatu, makin cepat bunyi bipnya. Sensor jarak mengukur benda di depannya; jika jaraknya lebih dari 20 sentimeter LED hijau tetap menyala, dan begitu…

LED Fade dengan PWM ESP32
Mengubah kecerahan LED secara halus dari 0 ke maksimum, dan dari maksimum ke 0. Kita mengendalikan PWM dengan analogWrite() seperti di Arduino; sintaks yang sama bekerja tanpa masalah di ESP32 Arduino Core 3.0+. Definisi pin + pinMode + analogWrite sudah cukup.

Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
Di proyek ini, kita mengendalikan kecerahan LED secara analog memakai potensiometer. Pin ADC ESP32 membaca tegangan 0-3,3V dari potensiometer, lalu nilai ini diubah menjadi sinyal PWM (Pulse Width Modulation) dan dikirim ke LED. Hasilnya, ketika kamu memutar potensiometer, LED perlahan menerang dan meredup. Dengan Arduino Core 3.0+, analogWrite() bisa langsung dipakai; di ESP32-S2/S3, resolusi ADC tetap 12-bit.

Sensor Parkir ESP32 (HC-SR04 + Bar 5 LED + Buzzer + OLED)
Versi ESP32 dari sensor parkir mobil! Kita memakai sensor ultrasonik HC-SR04 untuk mengukur jarak ke benda di depannya. Semakin dekat jaraknya, bar 5 LED semakin penuh (hijau → kuning → merah) dan jeda bunyi bip buzzer semakin pendek. Ketika benda sudah sangat dekat (di bawah 10 cm), alarm berbunyi terus dan semua LED menyala. Layar OLED SSD1306 menampilkan jarak terkini dalam cm dengan font besar, pesan status (STOP / CAUTION / CLOSE / STOP! / DANGER), dan simulasi bar jarak.

LED Fade PWM Raspberry Pi Pico (Efek Bernapas)
LED tidak lagi sekadar berkedip, ia bernapas! Dengan PWM (Pulse Width Modulation) Pico, kecerahan LED naik lalu turun perlahan, seperti lampu MacBook yang tidur. Pelajari kelas machine.PWM, duty_u16() (kecerahan 16-bit 0–65535), frekuensi PWM (freq(1000): 1000 siklus per detik, tanpa kedipan terlihat), loop range() bertahap, dan output mirip analog dari pin digital. PWM juga dipakai untuk warna RGB, motor, servo, dan buzzer.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

