Usando MPU-6050 con il Raspberry Pi

L'MPU-6050 è un dispositivo di tracciamento del movimento a 6 assi con giroscopio e accelerometro, che lo rende ideale per applicazioni di rilevamento del movimento come robotica, droni e progetti IoT. In questa guida, imparerai come connettere e utilizzare MPU-6050 con un Raspberry Pi per acquisire dati di movimento e orientamento.

Cosa avrai bisogno

Raspberry Pi (Qualsiasi modello con supporto GPIO, ad esempio PI 3, PI 4)
Modulo MPU-6050
Breadboard e fili jumper
Un computer con accesso SSH a Raspberry Pi o una tastiera e un monitoraggio collegati
Python installato su Raspberry Pi

Passaggio 1: Cablaggio dell'MPU-6050 a Raspberry Pi

L'MPU-6050 comunica con il Raspberry Pi usando il protocollo I2C.

Connessioni

Pin MPU-6050	Pin di lampone
VCC	3.3V (pin 1)
GND	Terra (pin 6)
SDA	SDA (PIN 3, GPIO2)
SCL	SCL (PIN 5, GPIO3)

Nota: Garantire che il modulo MPU-6050 funzioni a 3,3 V. La maggior parte dei moduli include un regolatore di tensione, consentendo loro di essere alimentati con 5 V.

Passaggio 2: abilita l'interfaccia I2C su Raspberry Pi

Apri lo strumento di configurazione Raspberry Pi:
```
sudo raspi-config
```
Navigare a Opzioni di interfaccia> i2c e abilitarlo.
Riavvia il Raspberry Pi:
```
sudo reboot
```

Passaggio 3: installare strumenti e librerie richieste

Aggiorna il tuo Raspberry Pi:
```
sudo apt update && sudo apt upgrade -y
```
Installa gli strumenti I2C:
```
sudo apt install -y i2c-tools
```
Installa le librerie Python per la comunicazione I2C ed elaborazione dei dati:
```
pip install smbus2
```

Passaggio 4: verificare la connessione

Utilizzo i2cdetect Per verificare che l'MPU-6050 sia rilevato sul bus I2C:
```
sudo i2cdetect -y 1
```
Dovresti vedere MPU-6050 all'indirizzo 0x68 (O 0x69 Se il perno AD0 viene tirato in alto). Se non:
- Controlla il tuo cablaggio.
- Assicurarsi che l'MPU-6050 sia alimentato.

Passaggio 5: lettura dei dati dall'MPU-6050

Il seguente script di Python recita i dati di accelerometro e giroscopio dall'MPU-6050.

Esempio di codice Python

import smbus2
import time

# MPU-6050 Registers and Address
MPU6050_ADDR = 0x68
PWR_MGMT_1 = 0x6B
ACCEL_XOUT_H = 0x3B
GYRO_XOUT_H = 0x43

# Initialize I2C bus
bus = smbus2.SMBus(1)

# Wake up the MPU-6050
bus.write_byte_data(MPU6050_ADDR, PWR_MGMT_1, 0)

def read_raw_data(addr):
    # Read two bytes of data from the given address
    high = bus.read_byte_data(MPU6050_ADDR, addr)
    low = bus.read_byte_data(MPU6050_ADDR, addr+1)
    value = (high << 8) | low
    # Convert to signed value
    if value > 32767:
        value -= 65536
    return value

try:
    while True:
        # Read accelerometer data
        accel_x = read_raw_data(ACCEL_XOUT_H)
        accel_y = read_raw_data(ACCEL_XOUT_H + 2)
        accel_z = read_raw_data(ACCEL_XOUT_H + 4)

        # Read gyroscope data
        gyro_x = read_raw_data(GYRO_XOUT_H)
        gyro_y = read_raw_data(GYRO_XOUT_H + 2)
        gyro_z = read_raw_data(GYRO_XOUT_H + 4)

        # Convert raw data to meaningful values (optional scaling may be needed)
        accel_x_scaled = accel_x / 16384.0
        accel_y_scaled = accel_y / 16384.0
        accel_z_scaled = accel_z / 16384.0

        gyro_x_scaled = gyro_x / 131.0
        gyro_y_scaled = gyro_y / 131.0
        gyro_z_scaled = gyro_z / 131.0

        print(f"Accelerometer: X={accel_x_scaled:.2f}, Y={accel_y_scaled:.2f}, Z={accel_z_scaled:.2f}")
        print(f"Gyroscope: X={gyro_x_scaled:.2f}, Y={gyro_y_scaled:.2f}, Z={gyro_z_scaled:.2f}")

        time.sleep(1)

except KeyboardInterrupt:
    print("Exiting...")

Passaggio 6: applicazioni dell'MPU-6050

Tracciamento del movimento: Tracciare il movimento e l'orientamento in robotica o indossabili.
Sistemi di stabilizzazione: Implementare la stabilizzazione giroscopica per droni o gimbal.
Gaming: Crea controller di gioco basati sul movimento.
Progetti IoT: Utilizzare i dati di movimento per attivare eventi di automazione.

Risoluzione dei problemi

Dispositivo non rilevato:
- Verificare le connessioni SDA e SCL.
- Assicurarsi che l'interfaccia I2C sia abilitata su Raspberry Pi.
- Controllare l'alimentazione su MPU-6050.
Letture imprecise:
- Calibrare il sensore implementando un offset per ciascun asse.
- Assicurarsi che il sensore sia posizionato su una superficie stabile.
Errori i2c:
- Assicurati che non ci siano dispositivi contrastanti sul bus I2C.

Conclusione

L'MPU-6050 è un sensore di movimento versatile in grado di aggiungere precise capacità di tracciamento del movimento ai progetti Raspberry Pi. Seguendo questa guida, è possibile impostare e utilizzare MPU-6050 per applicazioni come robotica, sistemi di stabilizzazione e automazione IoT. Sperimenta i dati di ridimensionamento e filtraggio per perfezionare il sensore per le tue esigenze!