Met behulp van de MPU-6050 met de Raspberry Pi

De MPU-6050 is een 6-assig bewegingsvolgsysteem met een gyroscoop en versnellingsmeter, waardoor het ideaal is voor bewegingsgevoelige toepassingen zoals robotica, drones en IoT-projecten. In deze handleiding leer je hoe je de MPU-6050 aansluit en gebruikt met een Raspberry Pi om bewegings- en oriëntatiegegevens vast te leggen.

Wat je nodig hebt

Raspberry Pi (elk model met GPIO-ondersteuning, bijv. Pi 3, Pi 4)
MPU-6050-module
Breadboard en jumperkabels
Een computer met SSH-toegang tot de Raspberry Pi of een aangesloten toetsenbord en monitor
Python geïnstalleerd op de Raspberry Pi

Stap 1: De MPU-6050 aansluiten op de Raspberry Pi

De MPU-6050 communiceert met de Raspberry Pi via het I2C-protocol.

Aansluitingen

MPU-6050 Pin	Raspberry Pi Pin
VCC	3.3V (Pin 1)
GND	Ground (Pin 6)
SDA	SDA (Pin 3, GPIO2)
SCL	SCL (Pin 5, GPIO3)

Let op: Zorg ervoor dat de MPU-6050-module op 3.3V werkt. De meeste modules bevatten een spanningsregelaar, waardoor ze met 5V kunnen worden gevoed.

Stap 2: De I2C-interface inschakelen op de Raspberry Pi

Open het configuratieprogramma van de Raspberry Pi:
```
sudo raspi-config
```
Navigeer naar Interface Options > I2C en schakel deze in.
Start de Raspberry Pi opnieuw op:
```
sudo reboot
```

Stap 3: Benodigde tools en bibliotheken installeren

Update je Raspberry Pi:
```
sudo apt update && sudo apt upgrade -y
```
Installeer de I2C-tools:
```
sudo apt install -y i2c-tools
```
Installeer Python-bibliotheken voor I2C-communicatie en gegevensverwerking:
```
pip install smbus2
```

Stap 4: De verbinding verifiëren

Gebruik i2cdetect om te controleren of de MPU-6050 wordt gedetecteerd op de I2C-bus:
```
sudo i2cdetect -y 1
```
Je zou de MPU-6050 moeten zien op adres 0x68 (of 0x69 als de AD0-pin hoog is getrokken). Zo niet:
- Controleer je bedrading.
- Zorg ervoor dat de MPU-6050 van stroom wordt voorzien.

Stap 5: Gegevens lezen van de MPU-6050

Het volgende Python-script leest versnellingsmeter- en gyroscoopgegevens van de MPU-6050.

Python-codevoorbeeld

import smbus2
import time

# MPU-6050 Registers en adres
MPU6050_ADDR = 0x68
PWR_MGMT_1 = 0x6B
ACCEL_XOUT_H = 0x3B
GYRO_XOUT_H = 0x43

# I2C-bus initialiseren
bus = smbus2.SMBus(1)

# De MPU-6050 wakker maken
bus.write_byte_data(MPU6050_ADDR, PWR_MGMT_1, 0)

def read_raw_data(addr):
    # Lees twee bytes aan gegevens van het opgegeven adres
    high = bus.read_byte_data(MPU6050_ADDR, addr)
    low = bus.read_byte_data(MPU6050_ADDR, addr+1)
    value = (high << 8) | low
    # Converteren naar een waarde met teken
    if value > 32767:
        value -= 65536
    return value

try:
    while True:
        # Versnellingsmetergegevens lezen
        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)

        # Gyroscoopgegevens lezen
        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)

        # Ruwe gegevens omzetten naar betekenisvolle waarden (optionele schaling kan nodig zijn)
        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"Versnellingsmeter: X={accel_x_scaled:.2f}, Y={accel_y_scaled:.2f}, Z={accel_z_scaled:.2f}")
        print(f"Gyroscoop: X={gyro_x_scaled:.2f}, Y={gyro_y_scaled:.2f}, Z={gyro_z_scaled:.2f}")

        time.sleep(1)

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

Stap 6: Toepassingen van de MPU-6050

Bewegingsvolgen: Volg beweging en oriëntatie in robotica of wearables.
Stabilisatiesystemen: Implementeer gyroscopische stabilisatie voor drones of gimbals.
Gaming: Creëer bewegingsgebaseerde gamecontrollers.
IoT-projecten: Gebruik bewegingsgegevens om automatiseringsgebeurtenissen te activeren.

Probleemoplossing

Apparaat niet gedetecteerd:
- Controleer de SDA- en SCL-verbindingen.
- Zorg ervoor dat de I2C-interface is ingeschakeld op de Raspberry Pi.
- Controleer de stroomtoevoer naar de MPU-6050.
Onnauwkeurige metingen:
- Kalibreer de sensor door een offset voor elke as te implementeren.
- Zorg ervoor dat de sensor op een stabiel oppervlak is geplaatst.
I2C-fouten:
- Zorg ervoor dat er geen conflicterende apparaten op de I2C-bus zijn.

Conclusie

De MPU-6050 is een veelzijdige bewegingssensor die nauwkeurige bewegingsvolgmogelijkheden kan toevoegen aan je Raspberry Pi-projecten. Door deze handleiding te volgen, kun je de MPU-6050 instellen en gebruiken voor toepassingen zoals robotica, stabilisatiesystemen en IoT-automatisering. Experimenteer met het schalen en filteren van gegevens om de sensor naar wens af te stellen!