Panduan MPU6050 Arduino: Akselerometer, Giroskop, dan Sudut Kemiringan

MPU6050 menggabungkan akselerometer 3 sumbu dan giroskop 3 sumbu dalam satu chip mungil dan merupakan sensor gerak yang paling banyak dipakai di proyek Arduino. Sensor ini mengukur seberapa jauh board dimiringkan, ke arah mana dan seberapa cepat board berputar, serta apakah board sedang diguncang atau jatuh. Robot penyeimbang diri, drone, stabilizer kamera (gimbal), penghitung langkah, dan game yang dikendalikan gerakan dibuat dengan sensor ini. MPU6050 terhubung ke Arduino hanya dengan empat kabel lewat I2C.

Di artikel ini kamu akan mempelajari langkah demi langkah cara kerja MPU6050, sumbu dan nilai mentahnya, pengkabelan I2C, membaca sensor dengan dan tanpa library, kalibrasi, menghitung sudut kemiringan dengan atan2, dan filter komplementer yang menggabungkan kekuatan kedua sensor. Setelah itu kita membuat alarm pendeteksi jatuh dengan ESP32 dan menulis kode MicroPython untuk Raspberry Pi Pico.

Apa itu MPU6050 dan bagaimana cara kerjanya?

MPU6050 buatan InvenSense (sekarang TDK) adalah sebuah IMU, unit pengukuran inersia. Di dalamnya ada struktur mekanis mungil dari silikon (MEMS). Akselerometer mengukur seberapa jauh sebuah massa kecil yang dipasang pada pegas bergeser karena percepatan; karena sensor ini merasakan gravitasi bahkan ketika diam, sensor yang tergeletak rata di meja menunjukkan sekitar 1 g (9,81 m/s²) di sumbu Z, sehingga kemiringannya terhadap tanah bisa dihitung. Giroskop mengukur kecepatan sudut, yaitu berapa derajat per detik sensor berputar, dari gaya Coriolis yang bekerja pada struktur yang bergetar. Hasil pengukuran diubah menjadi angka oleh ADC 16-bit di dalam chip dan dibaca lewat I2C. Chip ini juga berisi sensor suhu dan prosesor gerak digital (DMP) yang bisa mengambil alih perhitungan gerak.

Sumbu, nilai mentah, dan sensitivitas

Panah di board menunjukkan sumbu X dan Y; sumbu Z tegak lurus terhadap board dan mengarah ke atas. Sensor memberikan angka 16-bit bertanda untuk setiap sumbu. Untuk mengubah angka mentah ini menjadi satuan fisik, bagi dengan sensitivitas untuk rentang yang kamu pilih. Misalnya, di rentang bawaan ±2 g, nilai mentah 16384 berarti 1 g; dari sensor yang tergeletak di meja kamu akan membaca az ≈ 16384 dan ax, ay ≈ 0. Untuk giroskop di rentang ±250 °/s, nilai mentah 131 sama dengan putaran 1 derajat per detik. Rentang yang lebih lebar bisa mengukur gerakan yang lebih keras, tetapi menampilkan perubahan kecil dengan lebih kasar, jadi pilih rentang tersempit yang cukup untuk proyekmu.

Chip ini juga mengukur suhu: °C = nilai mentah / 340 + 36,53. Nilai ini menunjukkan suhu chip itu sendiri, bukan suhu ruangan, tetapi karena titik nol giroskop bergeser mengikuti suhu, nilai ini berguna untuk koreksi tingkat lanjut.

Pengkabelan MPU6050: Arduino Uno, ESP32, dan Pico

Karena board GY-521 punya regulator 3,3 V, VCC bisa kamu hubungkan ke pin 5V di Uno. Pin AD0 ditarik ke GND di board lewat resistor 4,7 kΩ, jadi alamatnya 0x68 kalau dibiarkan lepas; kalau ingin dua MPU6050 di bus yang sama, hubungkan pin AD0 salah satunya ke 3,3 V untuk mengubah alamatnya menjadi 0x69. Pin INT memberi sinyal ketika data baru siap atau gerakan terdeteksi; untuk proyek sederhana, pin ini tidak perlu disambung. Setelah pengkabelan, biasakan memeriksa apakah sensornya muncul dengan sketch I2C scanner; caranya ada di Layar LCD I2C.

Mulai cepat dengan library: Adafruit MPU6050

1. Buka Library Manager di Arduino IDE dan cari Adafruit MPU6050.
2. Ketika ditanya soal dependensi selama instalasi, pilih Install all supaya Adafruit Unified Sensor dan Adafruit BusIO ikut terinstal.
3. Hubungkan sensor sesuai tabel, upload sketch di bawah, lalu buka Serial Monitor di 115200 baud.
4. Buka Serial Plotter dari menu Tools untuk melihat keenam sumbu sebagai grafik langsung; kurva percepatan berubah ketika board dimiringkan, dan kurva giroskop berubah ketika board diputar.

1#include <Wire.h>
2#include <Adafruit_MPU6050.h>
3#include <Adafruit_Sensor.h>
4
5Adafruit_MPU6050 mpu;
6
7void setup() {
8  Serial.begin(115200);
9  if (!mpu.begin()) {                             // varsayılan adres 0x68 / default address 0x68
10    Serial.println("MPU6050 bulunamadi / not found");
11    while (true) delay(10);
12  }
13  mpu.setAccelerometerRange(MPU6050_RANGE_4_G);   // ±4 g
14  mpu.setGyroRange(MPU6050_RANGE_500_DEG);        // ±500 °/s
15  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);     // titreşimi süz / filter out vibration
16}
17
18void loop() {
19  sensors_event_t a, g, t;
20  mpu.getEvent(&a, &g, &t);
21  Serial.print("ax:");  Serial.print(a.acceleration.x);   // m/s²
22  Serial.print(" ay:"); Serial.print(a.acceleration.y);
23  Serial.print(" az:"); Serial.print(a.acceleration.z);
24  Serial.print(" gx:"); Serial.print(g.gyro.x);           // rad/s
25  Serial.print(" gy:"); Serial.print(g.gyro.y);
26  Serial.print(" gz:"); Serial.print(g.gyro.z);
27  Serial.print(" T:");  Serial.println(t.temperature);    // °C
28  delay(100);
29}

Library Adafruit memberikan hasil langsung dalam satuan fisik: percepatan dalam m/s², kecepatan sudut dalam rad/s, dan suhu dalam °C. Untuk mengubah nilai giroskop ke derajat per detik, cukup kalikan dengan 57,3. Filter low-pass internal yang dipilih dengan setFilterBandwidth mengurangi gangguan getaran: 21 Hz adalah titik awal yang bagus untuk gerakan tangan, dan kalau ingin menangkap benturan singkat, pilih 94 atau 260 Hz. Ketika mulai, library membaca register identitas chip (WHO_AM_I), dan begin() mengembalikan false kalau nilainya bukan 0x68.

Membaca tanpa library, kalibrasi, dan sudut kemiringan

Library memang memudahkan, tetapi membaca register secara langsung adalah cara yang bagus untuk memahami apa yang terjadi di dalam sensor. MPU6050 menyala dalam mode sleep; pertama kamu harus membangunkannya dengan menulis 0 ke register 0x6B (PWR_MGMT_1). Lalu baca 14 byte mulai dari alamat 0x3B: 6 byte percepatan, 2 byte suhu, dan 6 byte data giroskop. Setiap nilai terdiri dari dua byte, byte tinggi lebih dulu. Inilah register utama yang dipakai di kode dan layak kamu kenal:

Pada sensor yang diam, satu-satunya gaya yang dilihat akselerometer adalah gravitasi. Dengan melihat bagaimana gravitasi terbagi di antara sumbu-sumbunya, kamu mendapat dua sudut: sudut roll di sekitar sumbu X adalah roll = atan2(ay, az), dan sudut pitch di sekitar sumbu Y adalah pitch = atan2(−ax, √(ay² + az²)). Berbeda dengan arctangen biasa, atan2 memberikan tanda yang benar di keempat kuadran dan tidak membagi dengan nol ketika az mendekati nol. Misalnya, kalau kamu membaca ay = 8192 dan az = 14189, roll = atan2(8192, 14189) ≈ 30°. Namun putaran di sekitar sumbu Z (yaw) tidak terlihat oleh akselerometer, karena tidak mengubah cara gravitasi terbagi di antara sumbu-sumbunya.

Kedua sensor punya titik lemah. Akselerometer akurat dalam jangka panjang tetapi sangat berisik selama bergerak dan bergetar, karena selain gravitasi ia juga mengukur percepatan gerakan itu sendiri. Giroskop mulus dalam jangka pendek, tetapi untuk mendapat sudut kamu menjumlahkan kecepatan sudut dari waktu ke waktu (angle += rate × dt), dan offset kecil pun menumpuk lalu pelan-pelan menyeret sudutnya menjauh. Filter komplementer menggabungkan keduanya: angle = 0.98 × (angle + gyro × dt) + 0.02 × sudut akselerometer. Filter ini memercayai giroskop dalam jangka pendek dan akselerometer dalam jangka panjang. Di 100 Hz (dt = 0,01 s), koefisien ini memberikan konstanta waktu sekitar setengah detik: τ = 0.98 × 0.01 / 0.02 = 0,49 s.

Kalibrasi sama pentingnya dengan filter, bahkan lebih. Giroskop yang sama sekali tidak bergerak pun bisa menunjukkan offset tetap beberapa °/s; kalau tidak dikoreksi, sudut hasil hitunganmu bergeser puluhan derajat dalam hitungan detik. Sketch di bawah merata-rata 500 bacaan ketika mulai, selama sensor diam, lalu mengurangkannya dari setiap bacaan berikutnya. Taruh board di permukaan datar dan jangan disentuh selama kalibrasi; setelah itu amati kurva roll, pitch, dan yaw di Serial Plotter.

1#include <Wire.h>
2
3const int MPU_ADDR = 0x68;           // AD0 GND'de ya da boşta / AD0 to GND or floating
4const float GYRO_LSB = 131.0;        // ±250 °/s aralığında 1 °/s / 1 °/s at the ±250 °/s range
5const float ALPHA = 0.98;            // tamamlayıcı filtre katsayısı / complementary filter weight
6
7int16_t ax, ay, az, tempRaw, gx, gy, gz;
8float gxOff = 0, gyOff = 0, gzOff = 0;   // jiroskop sapmaları / gyro offsets
9float roll = 0, pitch = 0, yaw = 0;
10unsigned long lastMicros;
11
12void writeReg(uint8_t reg, uint8_t val) {
13  Wire.beginTransmission(MPU_ADDR);
14  Wire.write(reg);
15  Wire.write(val);
16  Wire.endTransmission();
17}
18
19int16_t read16() {
20  uint8_t hi = Wire.read();          // önce yüksek bayt / high byte first
21  uint8_t lo = Wire.read();
22  return (int16_t)(((uint16_t)hi << 8) | lo);
23}
24
25void readMPU() {
26  Wire.beginTransmission(MPU_ADDR);
27  Wire.write(0x3B);                  // ACCEL_XOUT_H
28  Wire.endTransmission(false);       // hattı bırakma, tekrar başlat / repeated start
29  Wire.requestFrom(MPU_ADDR, 14);    // ivme 6 + sıcaklık 2 + jiroskop 6 bayt / accel 6 + temp 2 + gyro 6 bytes
30  ax = read16(); ay = read16(); az = read16();
31  tempRaw = read16();
32  gx = read16(); gy = read16(); gz = read16();
33}
34
35void calibrateGyro() {
36  const int N = 500;
37  long sx = 0, sy = 0, sz = 0;
38  for (int i = 0; i < N; i++) {
39    readMPU();
40    sx += gx; sy += gy; sz += gz;
41    delay(3);
42  }
43  gxOff = sx / (float)N;
44  gyOff = sy / (float)N;
45  gzOff = sz / (float)N;
46}
47
48void setup() {
49  Serial.begin(115200);
50  Wire.begin();
51  Wire.setClock(400000);             // 400 kHz hızlı mod / 400 kHz fast mode
52  writeReg(0x6B, 0x00);              // PWR_MGMT_1: uykudan uyandır / wake up
53  writeReg(0x1A, 0x03);              // CONFIG: alçak geçiren filtre ~44 Hz / low-pass ~44 Hz
54  writeReg(0x1B, 0x00);              // GYRO_CONFIG: ±250 °/s
55  writeReg(0x1C, 0x00);              // ACCEL_CONFIG: ±2 g
56  delay(100);
57  Serial.println("Kalibrasyon: sensoru oynatma / calibrating: keep still");
58  calibrateGyro();
59  readMPU();
60  roll  = atan2(ay, az) * RAD_TO_DEG;                                    // başlangıç açıları / initial angles
61  pitch = atan2(-ax, sqrt((float)ay * ay + (float)az * az)) * RAD_TO_DEG;
62  lastMicros = micros();
63}
64
65void loop() {
66  readMPU();
67  unsigned long now = micros();
68  float dt = (now - lastMicros) / 1000000.0;   // saniye / seconds
69  lastMicros = now;
70
71  float accRoll  = atan2(ay, az) * RAD_TO_DEG;                           // ivmeölçerden açı / angle from accelerometer
72  float accPitch = atan2(-ax, sqrt((float)ay * ay + (float)az * az)) * RAD_TO_DEG;
73  float gxRate = (gx - gxOff) / GYRO_LSB;      // °/s
74  float gyRate = (gy - gyOff) / GYRO_LSB;
75  float gzRate = (gz - gzOff) / GYRO_LSB;
76
77  roll  = ALPHA * (roll  + gxRate * dt) + (1 - ALPHA) * accRoll;        // tamamlayıcı filtre / complementary filter
78  pitch = ALPHA * (pitch + gyRate * dt) + (1 - ALPHA) * accPitch;
79  yaw  += gzRate * dt;                         // yalnız jiroskop: zamanla kayar / gyro only: drifts over time
80
81  Serial.print("roll:");   Serial.print(roll, 1);
82  Serial.print(" pitch:"); Serial.print(pitch, 1);
83  Serial.print(" yaw:");   Serial.println(yaw, 1);
84  delay(10);                                   // yaklaşık 100 Hz / about 100 Hz
85}

MPU6050 dengan ESP32: alarm pendeteksi jatuh

Di ESP32, pengkabelannya sama dengan di Uno, hanya saja pin I2C-nya adalah GPIO 21 (SDA) dan GPIO 22 (SCL), dan modulnya diberi daya dari 3V3. Semua sketch di atas berjalan tanpa perubahan di ESP32; kalau mau, kamu bisa menentukan pinnya secara eksplisit dengan Wire.begin(21, 22). Contoh di bawah adalah pendeteksi jatuh. Pada benda yang jatuh bebas, akselerometer membaca hampir 0 g, karena badan sensor dan massa di dalamnya jatuh bersamaan; benturan sesudahnya menghasilkan puncak beberapa g. Kalau sketch melihat jatuh bebas selama minimal 100 ms yang diikuti benturan di atas 2,5 g dalam setengah detik, buzzer aktif di GPIO 25 berbunyi selama satu detik. Jatuh bebas 100 ms setara dengan jatuh dari ketinggian sekitar 5 cm (h = ½ × g × t²).

1#include <Wire.h>
2#include <Adafruit_MPU6050.h>
3#include <Adafruit_Sensor.h>
4
5Adafruit_MPU6050 mpu;
6const int BUZZER_PIN = 25;           // aktif buzzer / active buzzer
7const float FREE_FALL_G = 0.4;       // serbest düşüş eşiği / free-fall threshold
8const float IMPACT_G = 2.5;          // darbe eşiği / impact threshold
9unsigned long fallStart = 0, fallEnd = 0;
10
11void setup() {
12  Serial.begin(115200);
13  pinMode(BUZZER_PIN, OUTPUT);
14  Wire.begin(21, 22);                // SDA, SCL
15  if (!mpu.begin(0x68, &Wire)) {
16    Serial.println("MPU6050 bulunamadi / not found");
17    while (true) delay(10);
18  }
19  mpu.setAccelerometerRange(MPU6050_RANGE_8_G);   // darbeler için geniş aralık / wide range for impacts
20  mpu.setFilterBandwidth(MPU6050_BAND_94_HZ);     // kısa darbeleri kaçırma / keep short peaks
21}
22
23void loop() {
24  sensors_event_t a, g, t;
25  mpu.getEvent(&a, &g, &t);
26  float x = a.acceleration.x, y = a.acceleration.y, z = a.acceleration.z;
27  float total = sqrt(x * x + y * y + z * z) / SENSORS_GRAVITY_STANDARD;   // toplam ivme, g / total acceleration in g
28  unsigned long now = millis();
29
30  if (total < FREE_FALL_G) {
31    if (fallStart == 0) fallStart = now;             // düşüş başladı / fall started
32  } else if (fallStart != 0) {
33    if (now - fallStart > 100) fallEnd = now;        // en az 100 ms süren düşüş / fall of at least 100 ms
34    fallStart = 0;
35  }
36
37  if (fallEnd != 0 && now - fallEnd < 500 && total > IMPACT_G) {   // düşüşten sonra 0,5 s içinde darbe / impact within 0.5 s
38    Serial.println("DUSME ALGILANDI / FALL DETECTED");
39    digitalWrite(BUZZER_PIN, HIGH);
40    delay(1000);
41    digitalWrite(BUZZER_PIN, LOW);
42    fallEnd = 0;
43  }
44  if (fallEnd != 0 && now - fallEnd >= 500) fallEnd = 0;   // darbe gelmedi, sıfırla / no impact, reset
45  delay(5);
46}

Dari sini, kamu bisa menambahkan Wi-Fi ESP32, misalnya untuk mengirim notifikasi Telegram ke ponselmu kalau kerabat lansia terjatuh, atau menampilkan sudutnya secara langsung di halaman web. Sesuaikan ambangnya lewat uji cobamu sendiri: kotak yang jatuh dari meja dan sensor yang dipakai di pergelangan tangan menghasilkan puncak yang berbeda. Untuk memilih dan menghubungkan buzzer, baca Apa Itu Buzzer?.

MPU6050 dengan Raspberry Pi Pico (MicroPython)

Di Pico tidak perlu library tambahan; kelas I2C bawaan MicroPython bisa membaca register secara langsung. Hubungkan sensor ke bus I2C0, dengan SDA di GP4 dan SCL di GP5. Kita memakai struct.unpack untuk mengubah 14 byte menjadi tujuh angka 16-bit bertanda; “>” berarti big-endian (byte tinggi lebih dulu) dan “h” berarti 16-bit bertanda. Kode ini pertama-tama mencetak alamat I2C yang ditemukannya; kalau 0x68 tidak ada di daftar, periksa pengkabelannya. Agar sederhana, kami tidak menambahkan kalibrasi; kalau perlu, metode merata-rata dari sketch Arduino bisa kamu terapkan dengan cara yang persis sama.

1from machine import Pin, I2C
2import math, struct, time
3
4MPU = 0x68
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6print("Bulunan adresler / found addresses:", [hex(a) for a in i2c.scan()])
7
8i2c.writeto_mem(MPU, 0x6B, b"\x00")     # uykudan uyandır / wake up
9i2c.writeto_mem(MPU, 0x1A, b"\x03")     # alçak geçiren filtre ~44 Hz / low-pass ~44 Hz
10i2c.writeto_mem(MPU, 0x1B, b"\x00")     # jiroskop ±250 °/s / gyro ±250 °/s
11i2c.writeto_mem(MPU, 0x1C, b"\x00")     # ivmeölçer ±2 g / accelerometer ±2 g
12roll = pitch = 0.0
13last = time.ticks_us()
14
15while True:
16    data = i2c.readfrom_mem(MPU, 0x3B, 14)
17    ax, ay, az, t, gx, gy, gz = struct.unpack(">hhhhhhh", data)   # büyük endian, işaretli / big-endian, signed
18    now = time.ticks_us()
19    dt = time.ticks_diff(now, last) / 1000000
20    last = now
21    acc_roll = math.degrees(math.atan2(ay, az))
22    acc_pitch = math.degrees(math.atan2(-ax, math.sqrt(ay * ay + az * az)))
23    roll = 0.98 * (roll + gx / 131 * dt) + 0.02 * acc_roll        # tamamlayıcı filtre / complementary filter
24    pitch = 0.98 * (pitch + gy / 131 * dt) + 0.02 * acc_pitch
25    temp = t / 340 + 36.53                                        # °C
26    print("roll {:.1f}  pitch {:.1f}  T {:.1f}".format(roll, pitch, temp))
27    time.sleep_ms(10)

Ide proyek MPU6050

• Waterpass digital: tampilkan sudut roll dan pitch di layar OLED dengan gelembung yang bergerak.
• Servo yang dikendalikan gerakan: ketika kamu memiringkan sensor di tangan, motor servo berputar ke sudut yang sama; ideal untuk lengan robot atau kepala kamera.
• Game yang dikendalikan kemiringan: mainkan Pong atau game labirin dengan memiringkan board, bukan dengan joystick.
• Robot penyeimbang diri: olah sudut pitch dengan loop PID dan jaga robot tetap tegak dengan motor DC yang dikendalikan L298N.
• Penghitung langkah: ukur aktivitas berjalan dengan menghitung puncak teratur pada percepatan total.
• Pencatat getaran: ukur guncangan mesin atau mesin cuci dan beri peringatan ketika melewati ambang.

Kesalahan umum dan cara mengatasinya

Walaupun harganya murah, MPU6050 membuka pintu untuk mengukur gerakan: kenali dulu nilai mentahnya, lalu hitung sudutnya, dan terakhir haluskan dengan filter. Untuk melihat sensor I2C lain dan kegunaannya, lihat Panduan Sensor Arduino. Di aplikasi BlueGrays ada proyek kontrol servo, layar I2C, joystick, dan robot dengan skema rangkaian dan kode langkah demi langkah yang bisa kamu gabungkan dengan MPU6050.