MPU6050 Arduino: accelerometro, giroscopio e inclinazione

L'MPU6050 unisce in un unico, minuscolo chip un accelerometro a 3 assi e un giroscopio a 3 assi ed è il sensore di movimento più usato nei progetti Arduino. Misura quanto è inclinata la scheda, in che direzione e a che velocità ruota, e se viene scossa o sta cadendo. Con questo sensore si costruiscono robot autobilanciati, droni, stabilizzatori per fotocamere (gimbal), contapassi e giochi controllati con il movimento. L'MPU6050 si collega ad Arduino con soli quattro fili, tramite I2C.

In questo articolo imparerai passo dopo passo come funziona l'MPU6050, i suoi assi e i valori grezzi, il collegamento I2C, la lettura con e senza libreria, la calibrazione, il calcolo dell'angolo di inclinazione con atan2 e il filtro complementare, che unisce i punti di forza dei due sensori. Poi costruiremo con un ESP32 un allarme che rileva le cadute e scriveremo il codice MicroPython per il Raspberry Pi Pico.

Cos'è l'MPU6050 e come funziona?

L'MPU6050, prodotto da InvenSense (oggi TDK), è una IMU, cioè un'unità di misura inerziale. Al suo interno ci sono minuscole strutture meccaniche in silicio (MEMS). L'accelerometro misura quanto si sposta una piccola massa sospesa su molle quando c'è un'accelerazione; poiché percepisce la gravità anche da fermo, un sensore appoggiato in piano sul tavolo indica circa 1 g (9,81 m/s²) sull'asse Z, e così puoi ricavare la sua inclinazione rispetto al suolo. Il giroscopio misura la velocità angolare, cioè di quanti gradi al secondo sta ruotando il sensore, sfruttando la forza di Coriolis che agisce su strutture vibranti. Le misure vengono convertite in numeri da ADC a 16 bit dentro il chip e lette tramite I2C. Il chip contiene anche un sensore di temperatura e un processore digitale di movimento (DMP) che può occuparsi dei calcoli di orientamento.

Assi, valori grezzi e sensibilità

Le frecce sulla scheda indicano gli assi X e Y; l'asse Z è perpendicolare alla scheda e punta verso l'alto. Il sensore fornisce per ogni asse un numero a 16 bit con segno. Per convertire questo valore grezzo in un'unità fisica lo dividi per la sensibilità del fondo scala scelto. Per esempio, nel fondo scala predefinito di ±2 g un valore grezzo di 16384 equivale a 1 g; con il sensore fermo sul tavolo leggerai az ≈ 16384 e ax, ay ≈ 0. Nel giroscopio, con fondo scala ±250 °/s, un valore di 131 corrisponde a una rotazione di 1 grado al secondo. Un fondo scala più ampio misura movimenti più bruschi ma mostra i piccoli cambiamenti in modo più grossolano, quindi scegli il più stretto che basta al tuo progetto.

Il chip misura anche la temperatura: °C = valore grezzo / 340 + 36,53. Questo valore indica più la temperatura del chip stesso che quella ambiente, ma poiché lo zero del giroscopio varia con la temperatura, è utile per le correzioni avanzate.

Collegamento dell'MPU6050: Arduino Uno, ESP32 e Pico

Poiché la scheda GY-521 ha un regolatore a 3,3 V, puoi collegare VCC al pin 5V dell'Uno. Il pin AD0 è portato a GND sulla scheda da una resistenza da 4,7 kΩ, quindi lasciandolo libero l'indirizzo è 0x68; se vuoi usare due MPU6050 sullo stesso bus, collega a 3,3 V l'AD0 di uno dei due per portarne l'indirizzo a 0x69. Il pin INT segnala quando ci sono nuovi dati o quando viene rilevato un movimento; nei progetti semplici non serve collegarlo. Dopo il cablaggio è una buona abitudine verificare con uno scanner I2C che il sensore venga trovato; vedi come fare in Display LCD I2C.

Avvio rapido con una libreria: Adafruit MPU6050

1. Apri il Gestore librerie nell'Arduino IDE e cerca Adafruit MPU6050.
2. Quando durante l'installazione ti chiede delle dipendenze, scegli Install all: così vengono installate anche Adafruit Unified Sensor e Adafruit BusIO.
3. Collega il sensore come nella tabella, carica lo sketch qui sotto e apri il Monitor seriale a 115200 baud.
4. Apri il Plotter seriale dal menu Strumenti per seguire i sei assi in grafici dal vivo; inclinando la scheda cambiano le curve dell'accelerazione, ruotandola quelle del giroscopio.

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}

La libreria Adafruit fornisce i risultati direttamente in unità fisiche: accelerazione in m/s², velocità angolare in rad/s e temperatura in °C. Per convertire un valore del giroscopio in gradi al secondo basta moltiplicarlo per 57,3. Il filtro passa-basso interno scelto con setFilterBandwidth riduce il rumore delle vibrazioni: 21 Hz è un buon punto di partenza per i movimenti della mano, mentre per cogliere urti brevi scegli 94 o 260 Hz. All'avvio la libreria legge il registro di identità del chip (WHO_AM_I) e begin() restituisce false se non vale 0x68.

Lettura senza libreria, calibrazione e angolo di inclinazione

Le librerie semplificano il lavoro, ma leggere direttamente i registri è molto istruttivo per capire cosa succede dentro il sensore. All'accensione l'MPU6050 è in modalità sleep: prima devi svegliarlo scrivendo 0 nel registro 0x6B (PWR_MGMT_1). Poi leggi 14 byte a partire dall'indirizzo 0x3B: 6 byte di accelerazione, 2 di temperatura e 6 di giroscopio. Ogni valore occupa due byte, prima quello più significativo. Ecco i registri principali usati nel codice e utili da conoscere:

Con il sensore fermo, l'unica forza che l'accelerometro vede è la gravità. Osservando come si distribuisce sugli assi ricavi due angoli: il rollio attorno all'asse X, roll = atan2(ay, az), e il beccheggio attorno all'asse Y, pitch = atan2(−ax, √(ay² + az²)). A differenza dell'arcotangente normale, atan2 dà il segno giusto in tutti e quattro i quadranti e non divide per zero quando az si avvicina a zero. Per esempio, se leggi ay = 8192 e az = 14189, roll = atan2(8192, 14189) ≈ 30°. La rotazione attorno all'asse Z (imbardata, o yaw) invece l'accelerometro non la vede, perché non cambia il modo in cui la gravità si distribuisce sugli assi.

Entrambi i sensori hanno un punto debole. L'accelerometro è preciso nel lungo periodo ma molto rumoroso durante movimenti e vibrazioni, perché oltre alla gravità misura anche l'accelerazione del movimento stesso. Il giroscopio è fluido nel breve periodo, ma per ottenere un angolo sommi la velocità angolare nel tempo (angolo += velocità × dt), e anche un piccolo scostamento si accumula e fa derivare lentamente l'angolo. Il filtro complementare unisce i due: angolo = 0,98 × (angolo + giroscopio × dt) + 0,02 × angolo dell'accelerometro. Nel breve periodo si fida del giroscopio, nel lungo dell'accelerometro. A 100 Hz (dt = 0,01 s) questi coefficienti danno una costante di tempo di circa mezzo secondo: τ = 0,98 × 0,01 / 0,02 = 0,49 s.

La calibrazione è importante almeno quanto il filtro. Anche un giroscopio perfettamente fermo può mostrare uno scostamento costante (offset) di qualche °/s; se non lo correggi, l'angolo calcolato deriva di decine di gradi in pochi secondi. Lo sketch qui sotto, all'avvio e con il sensore fermo, fa la media di 500 letture e la sottrae da ogni lettura successiva. Durante la calibrazione appoggia la scheda su una superficie piana e non toccarla; poi osserva le curve di roll, pitch e yaw nel Plotter seriale.

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 con ESP32: un allarme anticaduta

Sull'ESP32 il collegamento è lo stesso dell'Uno; cambiano solo i pin I2C, GPIO 21 (SDA) e GPIO 22 (SCL), e il modulo si alimenta da 3V3. Tutti gli sketch precedenti funzionano senza modifiche sull'ESP32; se vuoi, puoi indicare i pin esplicitamente con Wire.begin(21, 22). L'esempio qui sotto è un rilevatore di cadute. In un oggetto in caduta libera l'accelerometro legge quasi 0 g, perché il corpo del sensore e la massa al suo interno cadono insieme; l'urto che segue produce un picco di diversi g. Se lo sketch rileva una caduta libera di almeno 100 ms seguita, entro mezzo secondo, da un urto superiore a 2,5 g, fa suonare per un secondo un buzzer attivo collegato a GPIO 25. Una caduta libera di 100 ms corrisponde a una caduta da circa 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}

Partendo da qui puoi sfruttare il Wi-Fi dell'ESP32 per, ad esempio, inviare una notifica Telegram al telefono se un familiare anziano cade, oppure mostrare gli angoli in tempo reale su una pagina web. Regola le soglie con prove tue: una scatola che cade dal tavolo e un sensore al polso danno picchi diversi. Per scegliere e collegare il buzzer, leggi Cos'è un buzzer?.

MPU6050 con Raspberry Pi Pico (MicroPython)

Sul Pico non serve alcuna libreria aggiuntiva: la classe I2C integrata in MicroPython legge i registri direttamente. Collega il sensore al bus I2C0, con SDA su GP4 e SCL su GP5. Con struct.unpack trasformiamo i 14 byte in sette numeri a 16 bit con segno; ">" significa big-endian (prima il byte più significativo) e "h" intero a 16 bit con segno. Il codice stampa prima gli indirizzi I2C trovati; se nella lista non vedi 0x68, controlla i collegamenti. Per semplicità non abbiamo aggiunto la calibrazione; se serve, applica allo stesso modo il metodo della media usato nello sketch Arduino.

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)

Idee di progetto con l'MPU6050

• Livella digitale: mostra gli angoli roll e pitch su un display OLED con una bolla che si muove.
• Servo comandato dal movimento: quando inclini il sensore in mano, un servomotore ruota allo stesso angolo; ideale per un braccio robotico o una testa per fotocamera.
• Gioco a inclinazione: gioca a Pong o a un labirinto inclinando la scheda invece di usare un joystick.
• Robot autobilanciato: elabora l'angolo pitch con un PID e tieni in piedi il robot con motori DC pilotati da un L298N.
• Contapassi: misura la camminata contando i picchi regolari dell'accelerazione totale.
• Registratore di vibrazioni: misura le scosse di una macchina o della lavatrice e dai un avviso quando si supera una soglia.

Errori comuni e soluzioni

Nonostante il prezzo basso, l'MPU6050 apre le porte alla misura del movimento: prima conosci i valori grezzi, poi calcola gli angoli e infine rendili fluidi con un filtro. Per scoprire altri sensori I2C e i loro usi, dai un'occhiata alla Guida ai sensori Arduino. Nell'app BlueGrays trovi progetti di controllo servo, display I2C, joystick e robot con schema elettrico e codice passo dopo passo, da combinare con l'MPU6050.