Parçalar · 11 dk okuma

Titreşim Motoru Arduino: Modül Bağlantısı, PWM ve Haptik Desenler

Titreşim motoru Arduino: ERM coin motor modülü, transistör ve diyot, PWM ile şiddet, haptik desenler, akıllı baston, ESP32 ve Pico kodları, DRV2605 notu.

Titreşim motoru Arduino projelerinde sese ya da ışığa gerek kalmadan kullanıcıya bilgi vermenin en kolay yoludur. Telefonların sessizdeyken titremesini, akıllı saatlerin bileğe dokunur gibi uyarı vermesini ve oyun kollarındaki sarsıntıyı hep bu küçük motorlar sağlar. Hobi elektroniğinde en çok kullanılan tür, 10 mm çapında ve yalnızca 2–3 mm kalınlığında olan coin (madeni para) tipi ERM titreşim motorudur. Tek başına bir motor Arduino pinine doğrudan bağlanamaz, ama üzerinde transistör ve diyot bulunan hazır titreşim motoru modülü sayesinde üç kabloyla çalıştırılabilir.

Bu rehberde ERM motorun nasıl titreştiğini, modülün içindeki transistörün ve diyodun neden gerekli olduğunu ve motorun ne kadar akım çektiğini öğreneceksin. Ardından titreşimi PWM ile kademeli olarak ayarlayacak, motorun zayıf güçte neden hiç dönmediğini ve bunun "kalkış darbesi" ile nasıl çözüldüğünü göreceğiz. Kısa tık, çift tık, kalp atışı ve SOS gibi haptik desenleri delay() kullanmadan çalan bir kod yazacak, mesafeye göre titreşen bir akıllı baston mantığı kuracağız. Son bölümlerde ESP32'nin dokunmatik pinine dokununca titreşimle geri bildirim veren bir örnek, Raspberry Pi Pico için MicroPython kodu ve gelişmiş haptik efektler için DRV2605 sürücüsü var.

Titreşim motoru modülü
Titreşim motoru modülü: coin tipi ERM motor, sürücü transistörü ve koruma diyodu tek kartta.

Titreşim motoru nedir, nasıl çalışır?

ERM, İngilizce "Eccentric Rotating Mass", yani eksantrik dönen kütle demektir. Motorun milinde ağırlık merkezi tam ortada olmayan küçük bir kütle vardır. Motor döndükçe bu dengesiz kütle motoru her turda bir yöne çeker ve bu çekiş titreşim olarak hissedilir. Coin tipi motorlarda kütle yassı gövdenin içinde döner, dışarıda hareket eden hiçbir parça yoktur; bu yüzden yapıştırıp kullanmak çok kolaydır. Silindir tipi ERM motorlarda ise yarım ay biçimli metal ağırlık dışarıdadır ve daha güçlü titreşir. Titreşimin hem şiddeti hem de frekansı motorun hızına bağlıdır: gerilim arttıkça motor hızlanır, titreşim hem güçlenir hem de tizleşir. Telefonlarda ve oyun kollarında giderek daha çok kullanılan LRA (doğrusal rezonans aktüatörü) ise farklı çalışır: bir yay üzerindeki mıknatısı ileri geri titreştirir ve yalnızca kendi rezonans frekansındaki alternatif bir sinyalle düzgün çalışır, düz DC gerilimle değil. Arduino setlerinde bulunan modüller neredeyse her zaman ERM'dir.

ÖzellikTipik coin ERM motor (ör. 1027)
Boyut10 mm çap, 2,7 mm kalınlık
Anma gerilimi3 V (yaklaşık 2,5–3,5 V arası)
Çalışma akımı3 V'ta yaklaşık 60–90 mA
Kalkış akımıKısa süreliğine 100–120 mA
HızYaklaşık 10 000–13 000 dev/dk
Titreşim frekansıYaklaşık 160–220 Hz
En düşük kalkış gerilimiYaklaşık 2–2,3 V; altında motor dönmeye başlamaz

Titreşim motoru modülünün içinde neler var?

Bir Arduino Uno pini en fazla 40 mA verebilir, güvenli sınır ise 20 mA civarıdır. ESP32 ve Pico pinleri daha da zayıftır. Titreşim motoru ise 60–120 mA çeker ve bir bobin gibi davranır: akımı kesildiği anda uçlarında ters yönde yüksek bir gerilim darbesi oluşur. Bu yüzden motoru doğrudan pine bağlamak hem pini zorlar hem de mikrodenetleyiciyi resetleyebilir ya da bozabilir. Hazır modül bu sorunu üç parçayla çözer:

  • Sürücü transistör: Genellikle S8050 ya da benzeri küçük bir NPN transistör, bazı modüllerde N kanallı bir MOSFET. Arduino pini yalnızca birkaç miliamperlik kontrol akımı verir, motor akımı transistörden geçer. Transistörün bir anahtar gibi nasıl çalıştığını Transistör Nedir? yazısında anlattık.
  • Taban direnci: Pinden transistöre giden akımı sınırlar; 1 kΩ civarında bir değer hem 5 V hem 3,3 V kartlarla çalışır.
  • Serbest geçiş (flyback) diyodu: Motora ters paralel bağlanan bu diyot, motor kapandığında oluşan gerilim darbesini kısa devre ederek transistörü korur. Diyodun görevini Diyot Nedir? yazısında bulabilirsin.

Modüllerin çoğunda üç pin bulunur: VCC, GND ve sinyal pini IN (bazı kartlarda S ya da SIG). IN pinine HIGH verdiğinde transistör iletime geçer ve motor döner. Modülün kendisi 3,3–5 V ile çalışır. 5 V ile beslediğinde transistördeki küçük düşümden sonra motor yaklaşık 4,5 V görür; bu, 3 V'luk motorun anma değerinin üstündedir. Kısa uyarılar için sorun olmaz, ama motor uzun süre sürekli çalışacaksa PWM ile gücü yaklaşık yüzde 60–70'te sınırlamak motorun ömrünü uzatır.

Bağlantı: Arduino Uno, ESP32 ve Raspberry Pi Pico

Aşağıdaki tabloda bu yazıdaki bütün kodların kullandığı pinler var. Motor pini her kartta PWM verebilen bir pin olmalıdır. ESP32 ve Pico'da IN pinine giden 3,3 V'luk sinyal transistörü sürmek için yeterlidir; modülün VCC pinini ise daha güçlü titreşim için 5 V'a, daha yumuşak titreşim için 3,3 V'a bağlayabilirsin. Hangi beslemeyi seçersen seç, GND'ler mutlaka ortak olmalıdır.

BağlantıArduino UnoESP32Raspberry Pi Pico
Modül VCC5VVIN (5 V) ya da 3V3VBUS (5 V) ya da 3V3(OUT)
Modül GNDGNDGNDGND
Modül IND5 (PWM)GPIO 25GP15
Buton (diğer ucu GND)D2Dokunmatik pin GPIO 4 (T0)GP14
HC-SR04 TRIG (baston örneği)D9--
HC-SR04 ECHO (baston örneği)D10--
Modülsüz, çıplak bir motor kullanıyorsan onu asla doğrudan pine bağlama. Motorun bir ucunu 5 V'a, diğer ucunu bir NPN transistörün (2N2222, BC337 ya da S8050) kollektörüne bağla; emiteri GND'ye, tabanı 1 kΩ dirençle Arduino pinine bağla. Motorun iki ucu arasına katodu (çizgili tarafı) 5 V'a bakacak şekilde bir 1N4148 ya da 1N5819 diyot koy. Diyot unutulursa transistör kısa sürede bozulabilir ve Arduino rastgele resetlenebilir. Taban direncini Ohm Kanunu aracıyla, transistörün akım ve kazanç değerlerini Transistör aracıyla kontrol edebilirsin.

İlk kod: aç-kapat ve PWM ile titreşim şiddeti

Titreşim motoru modülünü bir LED gibi düşünebilirsin: digitalWrite(HIGH) motoru tam güçte çalıştırır, analogWrite() ise PWM ile ortalama gerilimi ve dolayısıyla titreşim şiddetini ayarlar. Arduino Uno'nun D5 ve D6 pinleri yaklaşık 980 Hz, diğer PWM pinleri yaklaşık 490 Hz frekansta çalışır. PWM'in temelini PWM Nedir? yazısında ayrıntılı anlattık. ERM motorların önemli bir özelliği vardır: duran bir motoru döndürmeye başlatmak, dönen bir motoru döndürmeye devam ettirmekten daha fazla güç ister. Bu yüzden düşük bir PWM değeriyle başlattığın motor hiç kıpırdamayabilir. Çözüm, motoru birkaç on milisaniye tam güçle başlatıp sonra istediğin değere indirmektir; buna kalkış darbesi (kick-start) denir. Aşağıdaki kod önce tam güçte kısa bir titreşim yapar, sonra şiddeti adım adım artırır ve her adımı Seri Monitör'e yazar.

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}

Kodu çalıştırdığında motorun belli bir PWM değerinin altında hiç titremediğini ya da çok zayıf titrediğini fark edeceksin. 5 V beslemede bu eşik genellikle 70–110 arasındadır; tam değer motora ve modüle göre değişir. Seri Monitör'de motorun ilk kez net hissedildiği değeri not et ve projende bunu en düşük güç olarak kullan. Kalkış darbesi sayesinde bu eşiğin biraz altındaki değerler de çalışabilir, çünkü motor bir kez dönmeye başladıktan sonra daha az güçle dönmeye devam eder.

PWM değeri (5 V besleme)Ortalama gerilimHissedilen titreşim
0–600–1,2 VYok, motor dönmez
70–1101,4–2,2 VEşik bölgesi; kalkış darbesi gerekebilir
120–1702,4–3,3 VHafif ve orta titreşim, uzun süreli uyarılar için ideal
180–2553,5–4,5 VGüçlü titreşim, kısa ve dikkat çekici uyarılar için

Haptik desenler: kısa tık, çift tık, kalp atışı ve SOS

Tek tip bir titreşim yalnızca "bir şey oldu" der. Farklı desenler ise kullanıcıya ne olduğunu da anlatır: kısa bir tık bir onayı, iki kısa tık bir uyarıyı, uzun bir titreşim bir alarmı, kalp atışına benzeyen bir ritim bir hatırlatmayı gösterebilir. İnsan eli 20–30 ms'den kısa titreşimleri zor hisseder, ERM motor da hızlanmak için yaklaşık 30–50 ms'ye ihtiyaç duyar. Bu yüzden desenlerde en kısa titreşimi 40–60 ms, iki titreşim arasındaki boşluğu en az 80–100 ms tut. Aşağıdaki kodda her desen, {güç, süre} çiftlerinden oluşan bir dizidir. Desen çalar fonksiyonu millis() ile çalışır, yani desen sürerken loop() başka işleri de yapabilir. D2'ye bağlı butona her basışta bir sonraki desen çalar.

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}

Desenleri değiştirmek için yalnızca dizileri düzenlemen yeterlidir; çalar fonksiyon aynı kalır. SOS deseninde kısa titreşimler 100 ms, uzunlar 350 ms ve harfler arası boşluk 300 ms'dir; bu oranlar Mors kodunun "nokta, çizgi" düzenine uyar. Kullanıcıların desenleri karıştırmaması için birbirinden belirgin biçimde farklı tut: sayıları farklı olsun (bir, iki, üç titreşim) ya da süreleri belirgin biçimde ayrılsın. Desenleri bir projeye eklemeden önce birkaç kişiye denet ve hangi desenin ne anlama geldiğini tahmin etmelerini iste; haptik tasarımda en iyi ölçü budur.

Giyilebilir uyarı ve akıllı baston

Titreşim motoru, sesin rahatsız edici olduğu ya da duyulmadığı yerlerde öne çıkar. Giyilebilir projelerde motoru bir bilekliğin, eldivenin ya da kemerin içine, cilde yakın bir yere yerleştir. Bilek iç yüzü, avuç içi ve parmak uçları titreşime en duyarlı bölgelerdir. Motoru kumaşa gevşek dikmek yerine sert bir yüzeye, örneğin 3D baskı bir kutunun iç duvarına çift taraflı bantla yapıştırmak titreşimi daha iyi iletir. Görme engelliler için akıllı baston projelerinde ise motor, sapın tam başparmağın altına gelen kısmına yerleştirilir ve engelin uzaklığı titreşimin sıklığına ve şiddetine çevrilir: engel yaklaştıkça titreşimler sıklaşır ve güçlenir, çok yakında sürekli titreşime dönüşür. Aşağıdaki kod bu mantığı HC-SR04 mesafe sensörüyle gösterir.

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}

Bu kod sade tutmak için delay() kullanıyor ve bekleme süresince yeni ölçüm yapmıyor; gerçek bir bastonda önceki bölümdeki gibi millis() tabanlı bir yapı kullanmak daha iyi tepki verir. En düşük gücü 150'de tutmamızın sebebi, uzaktaki engellerde motorun eşik değerin altında kalıp hiç dönmemesini önlemektir. Su birikintisi uyarısı, düşme algılama, SOS ve pil hesabıyla birlikte tam bir proje için Akıllı Baston Arduino Projesi yazısına, sensörün ayrıntıları için HC-SR04 mesafe sensörü rehberine bakabilirsin.

Akım, güç kaynağı ve pil ömrü

Bir coin motor çalışırken 60–90 mA, kalkış anında kısa bir süre 100 mA'in üstünde akım çeker. Bu, Arduino Uno'nun 5V pininin USB'den rahatça verebileceği bir değerdir. Sorun genellikle pil ile beslenen ve gerilimi zaten sınırda olan devrelerde ya da aynı anda birkaç motorun çalıştığı projelerde çıkar: motor kalkarken gerilim bir anlığına düşer ve kart resetlenir. Bunu önlemek için modülün VCC ile GND pinleri arasına 47–100 µF'lık bir elektrolitik kondansatör ekle ve birden fazla motor kullanıyorsan onları aynı anda değil, birkaç milisaniye arayla başlat. Pil ömrünü hesaplarken motorun sürekli değil, kısa aralıklarla çalıştığını hesaba kat: örneğin dakikada toplam 3 saniye çalışan 80 mA'lik bir motorun ortalama akımı yalnızca 4 mA'dir. Kendi projenin değerleriyle Pil Ömrü aracını kullanarak kaç saat dayanacağını bulabilirsin.

ESP32 ile dokunmatik geri bildirim

ESP32'nin iki avantajı titreşim motoruyla çok iyi birleşir: kart üzerinde kapasitif dokunmatik pinler bulunur ve PWM üreten LEDC birimi frekansı serbestçe ayarlamana izin verir. Aşağıdaki kod GPIO 4'e (T0) bağlı bir kabloya ya da bakır folyoya dokunulduğunda, telefon ekranındaki gibi kısa bir "tık" titreşimi verir; dokunuş 1 saniyeden uzun sürerse uzun bir titreşimle onaylar. PWM frekansını 20 kHz yaptık; bu frekans insan kulağının duyma sınırındadır, böylece motor sürücüsünden gelebilecek ince vızıltı da kaybolur. Kod, ESP32 Arduino çekirdeğinin hem 2.x hem 3.x sürümüyle derlenir, çünkü LEDC fonksiyonlarının adı bu iki sürümde farklıdır.

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}

ESP32'de dokunmatik pin değeri dokunulmadığında genellikle 50–80 civarındadır ve parmakla dokunulunca belirgin biçimde düşer; kod bu yüzden açılışta ortalama değeri ölçüp eşiği otomatik hesaplar. ESP32-S2 ve S3'te ise dokunmatik değerler ters yönde, dokununca artar; bu kartlarda karşılaştırmayı tersine çevirmen gerekir. Modülün VCC pinini ESP32'nin VIN pinine bağlarsan motor 5 V ile daha güçlü titrer; IN pininin 3,3 V'luk sinyali transistörü sürmek için yeterlidir. Bu yapıyı Wi-Fi ya da Bluetooth ile birleştirerek telefona bildirim geldiğinde titreyen bir bileklik ya da ESP32 BLE ile kontrol edilen bir uyarı cihazı yapabilirsin.

Raspberry Pi Pico ve MicroPython ile titreşim motoru

Raspberry Pi Pico'da her GPIO pini PWM üretebilir. MicroPython'da PWM sınıfının duty_u16() fonksiyonu 0 ile 65535 arasında bir değer alır; 65535 tam güç demektir. Aşağıdaki kod GP14'e bağlı butona her basışta bir kalp atışı deseni çalar. Desen, Arduino örneğindeki gibi güç ve süre çiftlerinden oluşan bir listedir. Modülün VCC pinini daha güçlü titreşim için VBUS'a (USB'nin 5 V'u), daha yumuşak titreşim için 3V3(OUT) pinine bağlayabilirsin.

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)

Pico'nun pinleri 3,3 V ile çalışır ve tek pinden en fazla 12 mA civarında akım çekilmesi önerilir; bu yüzden Pico ile de çıplak motor değil, transistörlü modül kullanmalısın. Desen çalarken buton okunmaz; birden fazla iş yapman gerekiyorsa time.ticks_ms() ile Arduino'daki millis() düzenini kurabilir ya da bir Timer kesmesiyle desen adımlarını ilerletebilirsin. MicroPython'a yeni başlıyorsan MicroPython temelleri yazısı iyi bir başlangıçtır.

DRV2605 haptik sürücü: profesyonel titreşim efektleri

Transistörlü modül motoru yalnızca açıp kapatır ya da PWM ile güçlendirip zayıflatır. Telefonlardaki keskin "tık" hissi ise motoru çok hızlı başlatmak ve çok hızlı durdurmakla elde edilir: motor önce anma geriliminin üstünde bir darbeyle hızlandırılır (overdrive), titreşim bitince de ters yönde kısa bir gerilimle frenlenir. Texas Instruments'ın DRV2605L entegresi bu işi kendisi yapar. I2C ile bağlanır (adresi 0x5A), hem ERM hem LRA motorları sürebilir ve içinde tık, çift tık, vızıltı, yumuşak çarpma gibi 123 hazır efekt bulunur. Motorun özelliklerini otomatik kalibrasyonla öğrenir ve ses girişini titreşime çevirebilir. Adafruit DRV2605 kütüphanesiyle kullanımı birkaç satırdır; modülü Uno'da SDA'yı A4'e, SCL'yi A5'e bağlarsın, motor da doğrudan DRV2605 kartının motor çıkışına takılır.

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 bir dizide en fazla 8 efekti art arda çalabilir; setWaveform() ile 0'dan 7'ye kadar slotları doldurup dizinin sonunu 0 ile işaretlersin. LRA motor kullanıyorsan useLRA() çağırıp 6 numaralı LRA kütüphanesini seçmelisin. Basit uyarılar için transistörlü modül fazlasıyla yeterlidir; giyilebilir bir ürün, oyun kumandası ya da dokunmatik bir arayüz tasarlıyorsan DRV2605 hissedilen kaliteyi belirgin biçimde artırır.

Titreşim motoruyla proje fikirleri

  • Sessiz zamanlayıcı bilekliği: Ders ya da çalışma süresi dolunca sınıfı rahatsız etmeden bileğinde titreşen bir pomodoro sayacı yap.
  • Görme engelliler için akıllı baston: Engelin uzaklığını titreşim ritmine çeviren tam proje için akıllı baston rehberini izle.
  • Sessiz kapı zili: Kapıya yerleştirilen bir PIR hareket sensörü birini algılayınca cebindeki cihaz titresin.
  • Oyun kumandası: Joystick modülü ile yaptığın oyun kumandasına çarpışma anında sarsıntı ekle.
  • Duruş uyarıcısı: MPU6050 ile sırtının eğimini ölç, uzun süre kambur oturunca kısa titreşimle uyar.
  • Ses yerine titreşim: Gece kullanılan bir alarmda buzzer yerine yastığın altına yerleştirilmiş bir titreşim motoru kullan.

Sık hatalar ve çözümleri

BelirtiOlası sebepÇözüm
Motor hiç dönmüyorPWM değeri kalkış eşiğinin altında ya da GND ortak değilÖnce 255 ile dene, kalkış darbesi ekle, GND'leri birleştir
Motor çalışınca Arduino resetleniyorKalkış akımı beslemeyi çökertiyor ya da diyot yokHazır modül kullan, VCC ile GND arasına 47–100 µF kondansatör ekle
Titreşim çok zayıfModül 3,3 V ile besleniyor ya da motor yumuşak bir yüzeydeVCC'yi 5 V'a bağla, motoru sert bir yüzeye yapıştır
Motor ısınıyor5 V'ta uzun süre tam güçte çalışıyorPWM ile gücü %60–70'te sınırla, sürekli titreşim yerine kısa darbeler kullan
Motordan ince bir vızıltı sesi geliyorPWM frekansı duyulabilir aralıktaESP32'de LEDC frekansını 20 kHz yap, Uno'da kısa titreşimler kullan
ESP32'de ledcSetup bulunamadı hatasıESP32 çekirdeği 3.x sürümüYazıdaki #if ESP_ARDUINO_VERSION_MAJOR ayrımını kullan
Çıplak motor bağladıktan sonra pin çalışmıyorMotor doğrudan pine bağlanmış ve pin zarar görmüşBaşka bir pin kullan, motoru mutlaka transistör ve diyotla sür
Desenler birbirine benziyorTitreşimler çok kısa ya da aralar çok darEn kısa titreşimi 40–60 ms, aralığı en az 100 ms yap
Titreşimi masada değil, gerçek kullanım yerinde test et. Masaya konan bir motor tahtayı titreterek olduğundan güçlü hissettirir; bileklik ya da baston sapının içinde aynı motor çok daha zayıf gelebilir. Motoru sert bir yüzeye sıkıca sabitle, kabloları gerilmeyecek şekilde yapıştır ve eşik PWM değerini son montajdan sonra yeniden ölç.

Titreşim motoru, projelerine ekranlara ve seslere ek olarak dokunma duyusunu katmanın en ucuz yoludur. Modülün içindeki transistörü ve diyodu, PWM ile şiddet ayarını, kalkış darbesini ve haptik desenleri öğrendiğine göre artık hem sessiz uyarılar hem de görme engelliler için yardımcı cihazlar tasarlayabilirsin. BlueGrays uygulamasında buzzer, HC-SR04 park sensörü ve PWM ile güç kontrolü gibi projeleri adım adım devre şemaları ve hazır kodlarıyla inceleyebilir, bu projelere titreşim motorunu ekleyerek kendi fikirlerini geliştirebilirsin.

Sıkça sorulan sorular

Titreşim motoru Arduino'ya nasıl bağlanır?

Hazır titreşim motoru modülünün VCC pinini 5V'a, GND pinini GND'ye, IN pinini D5 gibi bir PWM pinine bağlaman yeterlidir. Modülün üzerindeki transistör motor akımını taşır, diyot da Arduino'yu korur. Çıplak bir motor kullanıyorsan araya mutlaka bir NPN transistör, 1 kΩ taban direnci ve bir diyot koymalısın.

Titreşim motoru kaç volt ile çalışır?

Coin tipi ERM titreşim motorlarının çoğu 3 V anma gerilimine sahiptir ve yaklaşık 2,5–3,5 V arasında çalışır. Hazır modüller 3,3–5 V ile beslenebilir; 5 V'ta motor daha güçlü titrer ama uzun süreli kullanımda PWM ile gücü sınırlamak ömrünü uzatır. Motor yaklaşık 2 V'un altında dönmeye başlamaz.

Titreşim motoru ne kadar akım çeker?

Tipik bir coin titreşim motoru çalışırken 60–90 mA, kalkış anında kısa süreliğine 100–120 mA akım çeker. Bu değer bir Arduino pininin güvenle verebileceği akımın birkaç katıdır. Bu yüzden motor bir transistör ya da hazır modül üzerinden sürülmelidir.

Titreşim motorunun şiddeti nasıl ayarlanır?

Şiddet PWM ile, yani Arduino'da analogWrite(pin, 0–255) komutuyla ayarlanır; değer büyüdükçe motor hızlanır ve daha güçlü titrer. Motor belli bir eşiğin altında hiç dönmediği için düşük güçlerde önce 20–30 ms tam güç verip sonra istenen değere inmek iyi sonuç verir. ESP32'de ledcWrite(), Pico'da duty_u16() aynı işi yapar.

ERM ve LRA titreşim motoru arasındaki fark nedir?

ERM motor, milindeki dengesiz bir kütleyi döndürerek titreşir ve düz DC gerilimle çalışır. LRA ise bir yay üzerindeki mıknatısı ileri geri titreştirir, yalnızca kendi rezonans frekansındaki alternatif sinyalle çalışır ve daha keskin, daha hızlı tepki verir. LRA sürmek için DRV2605 gibi bir haptik sürücü gerekir.

Titreşim motoru için diyot neden gerekli?

Motor bir bobin içerdiği için akımı kesildiği anda uçlarında ters yönde yüksek bir gerilim darbesi oluşur. Motora ters paralel bağlanan diyot bu darbeyi kısa devre ederek transistörün ve mikrodenetleyicinin zarar görmesini önler. Hazır modüllerde bu diyot kartın üzerinde zaten bulunur.

Tüm projeleri gör
Buzzer Kullanımı
AR-13Başlangıç

Buzzer Kullanımı

Kapı zili ya da alarm sesi nasıl çıkar, hiç merak ettin mi? Arduino küçük bir buzzer'ı kısa aralıklarla öttürür: bip, sus, bip, sus.

4.7(92)
170
HC-SR04 Mesafe Ölçme (Serial Ekran)
AR-27Başlangıç

HC-SR04 Mesafe Ölçme (Serial Ekran)

Yarasalar karanlıkta yollarını nasıl buluyorsa HC-SR04 sensörü de öyle çalışır: duyamadığın bir ses gönderir, yankısını dinler ve önündeki cismin ne kadar uzakta olduğunu ölçer.

4.6(50)
82
Buton İle Led Yakma (Push)
AR-9Başlangıç

Buton İle Led Yakma (Push)

Kapı zili gibi: bastığın sürece ışık yanar, bırakınca söner. Arduino butonu sürekli dinler; butona basılıyken LED'i yakar, elini çektiğin an söndürür.

4.8(114)
253
HC-SR04 ile Park Sensörü
AR-28Orta
Premium

HC-SR04 ile Park Sensörü

Arabalardaki park sensörünün küçük bir benzeri: bir şey yaklaştıkça bip sesleri hızlanır.

4.8(64)
86
ESP32 PWM ile LED Soldurma (Fade)
ES-8Başlangıç

ESP32 PWM ile LED Soldurma (Fade)

LED'in parlaklığını yumuşak şekilde 0'dan max'a, max'tan 0'a değiştirme. Arduino'daki gibi analogWrite() ile PWM kontrolü yapıyoruz — ESP32 Arduino Core 3.0+ ile aynı syntax sorunsuz çalışır. Pin tanımı + pinMode + analogWrite yeterli.

4.8(36)
55
ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
ES-13Orta
Premium

ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)

Bu projede bir potansiyometre ile LED parlaklığını analog olarak kontrol ediyoruz. ESP32'nin ADC pini potansiyometreden gelen 0-3.3V gerilimi okur, ardından bu değer PWM (Pulse Width Modulation) sinyaline çevrilerek LED'e gönderilir. Böylece potansiyometreyi çevirdikçe LED kademeli olarak parlar ve söner. Arduino Core 3.0+ ile analogWrite() doğrudan kullanılabilir; ESP32-S2/S3'te ADC çözünürlüğü 12-bit'e sabitlenir.

4.5(19)
32
ESP32 Park Sensörü (HC-SR04 + 5 LED Bar + Buzzer + OLED)
ES-38İleri
Premium

ESP32 Park Sensörü (HC-SR04 + 5 LED Bar + Buzzer + OLED)

Otomobil park sensörünün ESP32 versiyonu! HC-SR04 ultrasonik sensörle öndeki nesneye olan mesafeyi ölçüyoruz. Mesafe azaldıkça 5 LED'lik bar dolar (yeşil → sarı → kırmızı) ve buzzer'ın bip aralığı kısalır. Çok yaklaşınca (10 cm'nin altında) sürekli alarm çalar ve tüm LED'ler yanar. SSD1306 OLED ekranda büyük yazıyla anlık cm değeri ve durum metni gösterilir.

14
Raspberry Pi Pico PWM ile LED Fade (Nefes Efekti)
PI-14Başlangıç

Raspberry Pi Pico PWM ile LED Fade (Nefes Efekti)

LED artık sadece yanıp sönmüyor, nefes alıyor! Raspberry Pi Pico'nun PWM (Pulse Width Modulation, darbe genişlik modülasyonu) özelliğiyle LED'in parlaklığı yavaş yavaş artar, sonra yavaş yavaş azalır; uyku modundaki bir dizüstü bilgisayarın ışığı gibi sakin bir "nefes" efekti. Bu projede machine.PWM sınıfını, duty_u16() ile 0–65535 arası 16 bit parlaklık değerini ve PWM frekansını öğrenirsin.

4