Komponen · 12 mnt baca

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.

Modul motor getar
Modul motor getar: motor ERM tipe koin, transistor driver, dan dioda pelindung dalam satu board.

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.

KarakteristikMotor ERM koin tipikal (misalnya 1027)
UkuranDiameter 10 mm, tebal 2,7 mm
Tegangan nominal3 V (sekitar 2,5–3,5 V)
Arus ketika berjalanSekitar 60–90 mA pada 3 V
Arus awal100–120 mA dalam waktu singkat
KecepatanSekitar 10.000–13.000 rpm
Frekuensi getaranSekitar 160–220 Hz
Tegangan awal minimumSekitar 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.

KoneksiArduino UnoESP32Raspberry Pi Pico
VCC modul5VVIN (5 V) atau 3V3VBUS (5 V) atau 3V3(OUT)
GND modulGNDGNDGND
IN modulD5 (PWM)GPIO 25GP15
Tombol (kaki lainnya ke GND)D2Pin sentuh GPIO 4 (T0)GP14
HC-SR04 TRIG (contoh tongkat)D9--
HC-SR04 ECHO (contoh tongkat)D10--
Jika kamu memakai motor tanpa modul, jangan pernah menghubungkannya langsung ke pin. Hubungkan satu kabel motor ke 5 V dan kabel lainnya ke kolektor transistor NPN (2N2222, BC337, atau S8050); hubungkan emitor ke GND dan basis ke pin Arduino melalui resistor 1 kΩ. Pasang dioda 1N4148 atau 1N5819 secara paralel dengan motor, dengan katoda (ujung bergaris) menghadap 5 V. Tanpa dioda, transistor bisa cepat rusak dan Arduino dapat reset secara acak. Kamu bisa memeriksa resistor basis dengan alat Hukum Ohm, serta nilai arus dan penguatan transistor dengan alat Transistor.

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.

C++ (Arduino IDE)
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-rataGetaran yang terasa
0–600–1,2 VTidak ada, motor tidak berputar
70–1101,4–2,2 VZona ambang; mungkin memerlukan kick-start
120–1702,4–3,3 VGetaran ringan hingga sedang, ideal untuk peringatan panjang
180–2553,5–4,5 VGetaran 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

MicroPython
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.

C++ (Arduino IDE)
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

GejalaKemungkinan penyebabSolusi
Motor sama sekali tidak berputarNilai PWM di bawah ambang awal atau GND belum disatukanCoba 255 terlebih dahulu, tambahkan kick-start, dan satukan ground
Arduino reset ketika motor berjalanArus awal membuat tegangan catu turun drastis atau tidak ada diodaGunakan modul siap pakai dan tambahkan kapasitor 47–100 µF antara VCC dan GND
Getaran sangat lemahModul bekerja pada 3,3 V atau motor berada di permukaan lunakHubungkan VCC ke 5 V dan tempelkan motor pada permukaan keras
Motor menjadi hangatMotor berjalan dengan daya penuh pada 5 V dalam waktu lamaBatasi daya menjadi 60–70% dengan PWM dan gunakan pulsa singkat sebagai pengganti getaran terus-menerus
Terdengar denging lemah dari motorFrekuensi PWM berada dalam rentang pendengaranAtur frekuensi LEDC ke 20 kHz pada ESP32; gunakan getaran singkat pada Uno
Error ledcSetup tidak ditemukan pada ESP32Core ESP32 versi 3.xGunakan percabangan #if ESP_ARDUINO_VERSION_MAJOR dari artikel ini
Pin berhenti bekerja setelah motor tanpa modul dihubungkanMotor dihubungkan langsung ke pin dan merusaknyaGunakan pin lain dan selalu gerakkan motor melalui transistor dan dioda
Pola terasa miripGetaran terlalu pendek atau jedanya terlalu singkatBuat getaran terpendek 40–60 ms dan jedanya setidaknya 100 ms
Uji getaran di tempat penggunaan sebenarnya, bukan di meja kerjamu. Motor yang tergeletak di meja membuat kayu bergetar dan terasa lebih kuat daripada yang sebenarnya; di dalam gelang atau pegangan tongkat, motor yang sama bisa terasa jauh lebih lemah. Pasang motor dengan kuat pada permukaan keras, amankan kabel agar tidak tertarik, dan ukur kembali nilai ambang PWM setelah perakitan akhir.

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.

Lihat semua proyek
Menggunakan Buzzer
AR-13Pemula

Menggunakan Buzzer

Pernah penasaran bagaimana bel pintu atau alarm mengeluarkan suaranya? Arduino membuat buzzer kecil berbunyi bip dengan jeda singkat: bip, jeda, bip, jeda.

4.7(92)
170
Pengukuran Jarak HC-SR04 (Tampilan Serial)
AR-27Pemula

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.

4.6(50)
82
Kendali LED dengan Tombol Tekan (Tekan)
AR-9Pemula

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.

4.8(114)
253
Sensor Parkir dengan HC-SR04
AR-28Menengah
Premium

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…

4.8(64)
86
LED Fade dengan PWM ESP32
ES-8Pemula

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.

4.8(36)
55
Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
ES-13Menengah
Premium

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.

4.5(19)
32
Sensor Parkir ESP32 (HC-SR04 + Bar 5 LED + Buzzer + OLED)
ES-38Mahir
Premium

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.

14
LED Fade PWM Raspberry Pi Pico (Efek Bernapas)
PI-14Pemula

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.

4