IMU MPU-9250/6500

Abbildung 1: IMU MPU-9250/6500

Autor: Prof. Schneider

Einleitung

Die Inertiale Messeinheit (Engl. intertial measurement unit, IMU) ist ein 9-Achsen-Positionserkennungsmodul, das die folgenden Sensoren kombiniert:

• 3-Achsen-Gyroskop
• 3-Achsen-Beschleunigungssensor
• 3-Achsen-Magnetfeldsensor (Erdmagnetfeld/Kompass)

Ein Digital Motion Processor (DMP) ist zudem in einer winzigen Gehäusegröße von nur 3x3x1 mm verbaut. Das Modul kann über einen I²C-Bus angesprochen werden. Der MPU-9250 ist ein Multi-Chip-Modul welches die MPU-6500 (Geschleunigung und Gyro) via I²C mit dem AKM-8963 (Magnetometer) verbindet.

Technische Übersicht

Eigenschaft	Daten
Artikel	MPU-9250/6500
ADU	3x 16-Bit Analog-Digital Konverter für Gyro, Beschleunigung und Magnetfeld
Schnittstelle	I2C und SPI Schnittstelle
Spannungsversorgung am VCC Pin	3,3 V bis 5 V Über den intern verbauten LDO ME6211C33M5G-N ((S2RC),out 3.3V 500mA 300mW), bekommt der Sensor intern seine benötigten 2,4 V bis 3,6 V
Stromaufnahme	4 mA
Messbereich Gyroskop	einstellbar: ±250, ±500, ±1000 and ±2000 °/s
Messbereich Beschleunigung	einstellbar: ±2g, ±4g, ±8g and ±16g
Messbereich Magnetometer	±4800 µT
Hersteller	InvenSense, TDK

Pinbelegung

Pin	MPU-9250	Signal	Arduino Uno R3	Leitungsfarbe der im Alpha Bot verbauten Sensoren	Pin am Alpha Bot mit Arduino Uno R4 WIFI qwii-Bus
1	Betriebsspannung Vcc	VCC	VCC, 3,3 V	rot	Pin2 +3,3V rotes qwii Kabel
2	Masse GND	GND	GND	schwarz	Pin1 GND schwarzes qwii Kabel
3	SCL	I2C Taktleitung interner 10 kOhm Widerstand auf 3,3 V	SCL	weiß	Pin4 SCL gelbes qwii Kabel
4	SDA	I2C Datenleitung interner 10 kOhm Widerstand auf 3,3 V	SDA	blau	Pin3 SDA blaues qwii Kabel
5	EDA	externe I²C Pins	NC		NC
6	ECL	externe I²C Pins	NC		NC
7	ADO/SDO	Änderung der I²C Buss Adresse LOW (NC/GND) = 0x68, HIGH (+3,3V) = 0x69	NC		NC
8	INT	Interrupt Pin um anzuzeigen, dass aktuelle Daten vorliegen, welche ausgewertet werden können.	NC	gelb	eventuell auf einen neuen nicht benötigten Interrupt Pin Uno R4
9	NCS	Chip Select bei SPI Nutzung	NC		NC
10	FSYNC	Frame Synchronisation für Interrupts von externen Sensoren	NC		NC

Messverfahren

Technischer Aufbau

Das MPU-9250 ist ein Multi-Chip-Modul (MCM), das aus zwei Chips besteht, die in einem einzigen QFN-Gehäuse integriert sind, siehe Abbildung 5.

Abbildung 5: InvenSense Inc. [ https://product.tdk.com/system/files/dam/doc/product/sensor/mortion-inertial/imu/data_sheet/ps-mpu-9250a-01-v1.1.pdf Datenblatt 1.1 MPU 9250 Seite 21/42]

Ein Chip beherbergt das 3-Achsen-Gyroskop und den 3-Achsen-Beschleunigungssensor. Der andere Chip beherbergt das 3-Achsen- Magnetometer AK8963 der Asahi Kasei Microdevices Corporation. Somit ist das MPU-9250 ein 9-Achsen-MotionTracking-Gerät, das ein 3-Achsen-Gyroskop, einen 3-Achsen-Beschleunigungssensor, ein 3-Achsen-Magnetometer und einen Digital MotionProcessor™ (DMP) beinhaltet. Mit seinem dedizierten I²C-Sensor-Bus liefert der MPU-9250 direkt vollständige 9-Achsen-MotionFusion™-Ausgabedaten.

Der MPU-9250 ist zudem so konzipiert, dass er über seinen zusätzlichen I²C-Anschluss mit mehreren nicht-inertialen digitalen Sensoren, wie beispielsweise Drucksensoren, kommunizieren kann. Der MPU-9250 verfügt über drei 16-Bit-Analog-Digital-Wandler (ADCs) zur Digitalisierung der Gyroskop-Ausgänge, drei 16-Bit-ADCs zur Digitalisierung der Beschleunigungsmesser-Ausgänge und drei 16-Bit-ADCs zur Digitalisierung der Magnetometer- Ausgänge, siehe Abbildung 5. Zur präzisen Erfassung sowohl schneller als auch langsamer Bewegungen verfügen die Bauteile über einen vom Anwender programmierbaren Gyroskop-Vollbereich von ±250, ±500, ±1000 und ±2000°/s (dps) sowie einen vom Anwender programmierbaren Beschleunigungssensor- Vollbereich von ±2 g, ±4 g, ±8 g und ±16 g sowie einen Magnetometer-Vollbereich von ±4800 μT. Zu den weiteren branchenführenden Merkmalen zählen programmierbare digitale Filter, ein Präzisions-Taktgeber mit einer Abweichung von 1 % im Temperaturbereich von -40 °C bis 85 °C, ein integrierter Temperatursensor sowie programmierbare Interrupts. Das Gerät verfügt über serielle I²C- und SPI-Schnittstellen, einen VDD-Betriebsbereich von 2,4 V bis 3,6 V sowie eine separate digitale E/A-Versorgung (VDDIO) von 1,71 V bis VDD. Die Kommunikation mit allen Registern des Bausteins erfolgt entweder über I²C mit 400 kHz oder über SPI mit 1 MHz. Für Anwendungen, die eine schnellere Kommunikation erfordern, können die Sensor- und Interrupt-Register über SPI mit 20 MHz ausgelesen werden.

Funktionsweise der 4 Sensoren

Beschleunigungssensor (3-Achsen-Accelerometer):

Dieser arbeitet mit MEMS Technik einer Technology, bei der im Chip kleine federnde aufgehängte Silizium-Massen durch die Beschleunigung und die Erdbeschleunigung verschoben werden und deren Verschiebung gemessen werden kann z.B. durch die Messung sich verändernder Kapazitäten an Kammstruckturen, welche zwischen der Masse und dem starren äußeren Körper befinden, und deren Kapazität sich durch die Verschiebung wie bei einem klassischen Plattenkondensator ändert.

Gyroskop (3-Achsen-Gyro):

Hierbei wird die Corioliskraft genutzt. Auch hier kommen wieder MEMS zum Einsatz. Es wird die Rotation gemessen in dem man die Vibrationen quer zu ihrer Antriebsrichtung erfasst. Die Abbildung 4 zeigt wie mithilfe eines MEMS verschiedene Richtungen erfasst werden können, weiter Informationen dazu in Medium:Rapid Prototyping of Inertial MEMS Devices through.pdf.

Magnetometer (3-Achsen-Kompass):

Beim Magnetometer werden Hall-Effekt-Sensoren genutzt, mit denen man die Magnetfeldstärke und die Richtung erfassen kann. Zu beachten ist, das die Achsen des Magnetometers in unterschiedliche Richtungen ausgerichtet sind im Vergleich zum Beschleunigungssensor und des Gyros siehe Abbildung 7. Durch die Integration dreier Sensoren können die negativen Eigenschaften der einzelnen Sensoren kompensiert werden. So kann der Magnetfeldsensor die Drift des Gyroskops kompensieren werden und die Ausrichtung des Sensors im Raum bestimmt werden, solange keine magnetischen Gegenstände wie Metallteile, Magnete oder Elektromagneten wie z.B. Motoren in der Nähe sind. Daher sollten bei Verwendung des Sensors alle Sensoren beim Starten kalibriert werden, z.B. wie beim Handy der Magnetfeldsensor kalibriert wird über das Bewegen des Sensors in einer achtförmigen Schleife oder der Bestimmung des Start-Offset des Gyros.

Abbildung 7: Ausrichtung der 3 Unterschiedlichen Sensoren im MPU 9250 laut InvenSense Inc. [ https://product.tdk.com/system/files/dam/doc/product/sensor/mortion-inertial/imu/data_sheet/ps-mpu-9250a-01-v1.1.pdf Datenblatt 1.1 MPU 9250 Seite 38/42

Temperatur:

Praktisches Beispiel zum Ausdrucken am 3D Drucker eines MEMS Gyros bei Printables von dona97m siehe Abbildung 3.

Abbildung 3: MEMS Gyro 3D Druck von https://www.printables.com/model/357673-mems-gyroscope/remixes MEMS Gyroscope

Abbildung 4: MEMS Gyro Beispiel von https://www.researchgate.net/publication/353487249/figure/fig2/AS:11431281390681098@1745289189539/Reference-layout-of-a-triaxial-beating-heart-MEMS-gyroscope-a-and-associated-modal.tif Rapid Prototyping of Inertial MEMS Devices through Structural Optimization aus sensors 26.06.2021 von Giannini, D.;Bonaccorsi, G.; Braghin, F. Rapid

Literatur

Beispiel des Aufbaus und der Auslegung eines MEMS Gyros. https://www.researchgate.net/publication/353487249_Rapid_Prototyping_of_Inertial_MEMS_Devices_through_Structural_Optimization

Software

MPU9250_qwii_UNO_R4_wifi.ino  

#include <Wire.h>

// I2C-Adressen
const int MPU_ADDR = 0x68;   // Hauptadresse für Beschleunigung & Gyro
const int MAG_ADDR = 0x0C;   // Adresse des integrierten Magnetometers (AK8963)

void setup() {
  Serial.begin(115200);
  while (!Serial) { ; } // Warten auf serielle Verbindung (wichtig beim Uno R4)

  // Wire1 initialisiert den physischen Qwiic-Anschluss des Uno R4 nicht wire das ist nur für Pin A4, A5, Pin18, Pin19 SCL/SDA
  Wire1.begin(); 

  // 1. MPU-9250 aufwecken
  Wire1.beginTransmission(MPU_ADDR);
  Wire1.write(0x6B); // PWR_MGMT_1 Register
  Wire1.write(0x00); // Aufwecken (0 setzen)
  Wire1.endTransmission(true);
  delay(10);

  // 2. I2C-Bypass aktivieren, um direkt auf das Magnetometer zugreifen zu können
  Wire1.beginTransmission(MPU_ADDR);
  Wire1.write(0x37); // INT_PIN_CFG Register
  Wire1.write(0x02); // BYPASS_EN auf 1 setzen
  Wire1.endTransmission(true);
  delay(10);

  // 3. Magnetometer (AK8963) konfigurieren
  // In den Power-Down Modus versetzen, bevor der Modus gewechselt wird
  Wire1.beginTransmission(MAG_ADDR);
  Wire1.write(0x0A); // CNTL1 Register
  Wire1.write(0x00); // Power-Down Mode
  Wire1.endTransmission(true);
  delay(10);
  
  // Kontinuierlicher Messmodus 2 (100Hz) mit 16-Bit Auflösung aktivieren
  Wire1.beginTransmission(MAG_ADDR);
  Wire1.write(0x0A); // CNTL1 Register
  Wire1.write(0x16); // 16-bit Auflösung (b4 = 1) & Kontinuierlicher Modus 2 (b3-b0 = 0110)
  Wire1.endTransmission(true);
  delay(10);

  Serial.println("MPU-9250 + AK8963 via Qwiic (Wire1) initialisiert.");
}

void loop() {
  // --- 1. BESCHLEUNIGUNG, TEMPERATUR & GYRO AUSLESEN ---
  // Wir fordern 14 Bytes ab Register 0x3B an
  Wire1.beginTransmission(MPU_ADDR);
  Wire1.write(0x3B); 
  Wire1.endTransmission(false);
  Wire1.requestFrom(MPU_ADDR, 14, true);

  int16_t ax = (Wire1.read() << 8) | Wire1.read();
  int16_t ay = (Wire1.read() << 8) | Wire1.read();
  int16_t az = (Wire1.read() << 8) | Wire1.read();
  
  int16_t rawTemp = (Wire1.read() << 8) | Wire1.read();
  
  int16_t gx = (Wire1.read() << 8) | Wire1.read();
  int16_t gy = (Wire1.read() << 8) | Wire1.read();
  int16_t gz = (Wire1.read() << 8) | Wire1.read();

  // Umrechnung der Chip-Temperatur in Grad Celsius
  float temperature = (rawTemp / 333.87) + 21.0;


  // --- 2. MAGNETOMETER AUSLESEN ---
  int16_t mx = 0, my = 0, mz = 0;
  
  // Prüfen, ob Magnetometer-Daten bereitstehen (ST1 Register, Bit 0)
  Wire1.beginTransmission(MAG_ADDR);
  Wire1.write(0x02); 
  Wire1.endTransmission(false);
  Wire1.requestFrom(MAG_ADDR, 1, true);
  
  if (Wire1.available() && (Wire1.read() & 0x01)) {
    // 7 Bytes anfordern (6 Bytes Daten X,Y,Z + 1 Status-Byte ST2 am Ende zwingend erforderlich!)
    Wire1.beginTransmission(MAG_ADDR);
    Wire1.write(0x03); 
    Wire1.endTransmission(false);
    Wire1.requestFrom(MAG_ADDR, 7, true);

    if (Wire1.available() >= 7) {
      // AK8963 speichert Daten als Low-Byte zuerst (Little Endian)!
      mx = Wire1.read() | (Wire1.read() << 8);
      my = Wire1.read() | (Wire1.read() << 8);
      mz = Wire1.read() | (Wire1.read() << 8);
      
      // Das ST2 Register (7. Byte) MUSS ausgelesen werden, um die nächste Messung freizugeben
      uint8_t st2 = Wire1.read(); 
    }
  }


  // --- 3. SERIELLE AUSGABE HINTEREINANDER ---
  // Formatierung mit Tabs (\t) für perfekte Lesbarkeit im Seriellen Monitor / Plotter
  Serial.print("GyroX:"); Serial.print(gx);
  Serial.print("\tGyroY:"); Serial.print(gy);
  Serial.print("\tGyroZ:"); Serial.print(gz);
  
  Serial.print("\tAccX:");  Serial.print(ax);
  Serial.print("\tAccY:");  Serial.print(ay);
  Serial.print("\tAccZ:");  Serial.print(az);
  
  Serial.print("\tMagX:");  Serial.print(mx);
  Serial.print("\tMagY:");  Serial.print(my);
  Serial.print("\tMagZ:");  Serial.print(mz);
  
  Serial.print("\tTemp:");  Serial.print(temperature, 2);
  Serial.println(); // Zeilenumbruch am Ende des Datensatzes

  delay(100); // Messung alle 100ms
}

URL: https://svn.hshl.de/svn/Informatikpraktikum_1/trunk/Arduino/ArduinoLibOrdner/ArduinoUnoR3/examples/DemoMPU9250_qwii_UNO_R4_wifi/DemoMPU9250_qwii_UNO_R4_wifi.ino

Erwartetes Ergebnis GyroX:-246 GyroY:19 GyroZ:-114 AccX:-2916 AccY:380 AccZ:15336 MagX:-1610 MagY:194 MagZ:18 Temp:28.38

AlphaBot

In der Abbildung 2 des AlphaBots sieht man den MontagePunkt des MPU-9250, sowie dessen Ausrichtung der Messachsen. X zeigt in Fahrtrichtung des Linienverfolgers.

Abbildung 2: Ausrichtung der Messachsen des MPU-9250/6500 im AlphaBot

Zweiter I²C-Bus Arduino UNO R4 Wifi

https://docs.arduino.cc/tutorials/uno-r4-wifi/qwiic/

I²C-Scanner

Prüfen Sie welche Sensoren am I2C-Bus angeschlossen sind.

DemoI2C_Scanner.ino  

#include <Wire.h>

void setup()
{
  Serial.begin(115200);
  Wire.begin();
  Serial.println("I2C Scan");
  for(byte address=1; address<127; address++)
  {
    Wire.beginTransmission(address);
    if(Wire.endTransmission()==0)
    {
      Serial.print("Gefunden: 0x"); // 0x71 MPU9250 auf einem GY-6500/GY-9250-Board
      Serial.println(address, HEX);
    }
  }
}
void loop(){}

URL: https://svn.hshl.de/svn/Informatikpraktikum_1/trunk/Arduino/ArduinoLibOrdner/ArduinoUnoR3/examples/DemoI2C_Scanner/DemoI2C_Scanner.ino

Erwartetes Ergebnis

I2C Scan
Gefunden: 0x68

0x68 ist die I²C-Adresse des Sensors.

Prüfen welcher Chip verbaut wurde

Bei diesen Modulen kommt es vor, dass ein Board als MPU-9250 verkauft wird, aber tatsächlich ein MPU6500 bestückt ist.

Lesen Sie das Register 0x75 per I²C aus.

Tabelle 1: Erwartete Antwort

Chip	WHO_AM_I
MPU-6500	0x70
MPU-9250	0x71

DemoWhoAmI.ino  

#include <Wire.h>
void setup() {
  Serial.begin(115200);
  while (!Serial);
  Wire.begin();   // I²C initialisieren
  Wire.beginTransmission(0x68);
  Wire.write(0x75);               // WHO_AM_I-Register
  Wire.endTransmission(false);
  Wire.requestFrom(0x68, 1);

  if (Wire.available()) {
    byte id = Wire.read();
    Serial.print("WHO_AM_I = 0x");
    Serial.println(id, HEX);
    if (id == 0x71)
      Serial.println("MPU-9250 erkannt");
    else if (id == 0x70)
      Serial.println("MPU-6500 erkannt");
    else
      Serial.println("Unbekannter Sensor");
  } else {
    Serial.println("Keine Antwort vom Sensor.");
  }
}
void loop() {
}

URL: https://svn.hshl.de/svn/Informatikpraktikum_1/trunk/Arduino/ArduinoLibOrdner/ArduinoUnoR3/examples/DemoWhoAmI/DemoWhoAmI.ino

Arduino-Bibliothek installieren

MPU9250_asukiaaa

Tabelle 1: Übersicht der Demos

Demo	Funktion
DemoUnoR4Wifi.ino	Demo zum Senden von Sensordaten via Wifi für die Arduino IDE
DemoUnoR4Wifi.m	Demo zum Empfangen von Sensordaten via Wifi mit MATLAB®
GetDate.ino	Demo zum Auslesen der IMU-Daten des Sensors MPU 9250
E15_RadInkrementalgeberFahrt.ino	Demo zum Ansteuern der Motoren und auslesen der Odometrie des AlphaBot

DemoUnoR4Wifi.ino  

clear all; clc;

port = 7000; % UDP Port, auf dem MATLAB lauscht

u = udpport("IPV4", "LocalPort", port);

disp("Warte auf UDP-Daten vom Arduino ...")

while true
    nBytes = u.NumBytesAvailable;
    if nBytes  > 0 % Prüfen, ob Daten vorhanden sind
        data = read(u, nBytes, "string");
        disp(data)
    end
end

GetDate.ino aus der Bibliothek MPU9250_asukiaaa 

#include <MPU9250_asukiaaa.h>

#ifdef _ESP32_HAL_I2C_H_
#define SDA_PIN 21
#define SCL_PIN 22
#endif

MPU9250_asukiaaa mySensor;
float aX, aY, aZ, aSqrt, gX, gY, gZ, mDirection, mX, mY, mZ;

void setup() {
  Serial.begin(115200);
  while(!Serial);
  Serial.println("started");

#ifdef _ESP32_HAL_I2C_H_ // For ESP32
  Wire.begin(SDA_PIN, SCL_PIN);
  mySensor.setWire(&Wire);
#endif

  mySensor.beginAccel();
  mySensor.beginGyro();
  mySensor.beginMag();

  // You can set your own offset for mag values
  // mySensor.magXOffset = -50;
  // mySensor.magYOffset = -55;
  // mySensor.magZOffset = -10;
}

void loop() {
  uint8_t sensorId;
  int result;

  result = mySensor.readId(&sensorId);
  if (result == 0) {
    Serial.println("sensorId: " + String(sensorId));
  } else {
    Serial.println("Cannot read sensorId " + String(result));
  }

  result = mySensor.accelUpdate();
  if (result == 0) {
    aX = mySensor.accelX();
    aY = mySensor.accelY();
    aZ = mySensor.accelZ();
    aSqrt = mySensor.accelSqrt();
    Serial.println("accelX: " + String(aX));
    Serial.println("accelY: " + String(aY));
    Serial.println("accelZ: " + String(aZ));
    Serial.println("accelSqrt: " + String(aSqrt));
  } else {
    Serial.println("Cannod read accel values " + String(result));
  }

  result = mySensor.gyroUpdate();
  if (result == 0) {
    gX = mySensor.gyroX();
    gY = mySensor.gyroY();
    gZ = mySensor.gyroZ();
    Serial.println("gyroX: " + String(gX));
    Serial.println("gyroY: " + String(gY));
    Serial.println("gyroZ: " + String(gZ));
  } else {
    Serial.println("Cannot read gyro values " + String(result));
  }

  result = mySensor.magUpdate();
  if (result != 0) {
    Serial.println("cannot read mag so call begin again");
    mySensor.beginMag();
    result = mySensor.magUpdate();
  }
  if (result == 0) {
    mX = mySensor.magX();
    mY = mySensor.magY();
    mZ = mySensor.magZ();
    mDirection = mySensor.magHorizDirection();
    Serial.println("magX: " + String(mX));
    Serial.println("maxY: " + String(mY));
    Serial.println("magZ: " + String(mZ));
    Serial.println("horizontal direction: " + String(mDirection));
  } else {
    Serial.println("Cannot read mag values " + String(result));
  }

  Serial.println("at " + String(millis()) + "ms");
  Serial.println(""); // Add an empty line
  delay(500);
}

DemoUnoR4Wifi.m  

// Notw. Hardware HC-05 Bluetooth Modul
// Vorbereitung:
//                 1) Binden Sie den Uno R4 in Ihr Netzwerk ein (Z. 25, 26).
//                 2) Tragen Sie die IP Ihres MATLAB Rechners ein (Z. 32).
//                 3) Übertragen Sie das Skript an den Uno R4. 
//                 4) Wählen Sie einen frein UDP-Port (Z. 38).
//*****************************************************************************

#include <WiFiS3.h>
#include <WiFiUdp.h>

// WLAN Zugangsdaten
char ssid[] = "Ihr_WLAN_Name";     // Anpassen
char pass[] = "Ihr_WLAN_Passwort"; // Anpassen

WiFiUDP udp;

// IP-Adresse des MATLAB-Rechners
IPAddress matlabIP(192, 168, 1, 1);  // Anpassen

// MATLAB UDP-Port
unsigned int matlabPort = 7000;

void setup()
{
  Serial.begin(115200);
  while (!Serial);
  Serial.println("Verbinde WLAN...");

  while (WiFi.begin(ssid, pass) != WL_CONNECTED)
  {
    delay(5000);
    Serial.print(".");
  }

  Serial.println();
  Serial.println("WLAN verbunden");
  Serial.print("Arduino IP: ");
  Serial.println(WiFi.localIP());
  udp.begin(7001);
}


void loop()
{
  static int Zaehler_s16 = 0;             // Beispiel für Messwert
  float Zeit_f32 = float(millis())/1000;  // Zeit in s

  char Daten_s8[50];

  // Format: Float;Integer
  sprintf(Daten_s8, "%.3f;%d", Zeit_f32, Zaehler_s16);

  Serial.println(Daten_s8);

  // UDP senden
  udp.beginPacket(matlabIP, matlabPort);
  udp.write(Daten_s8);
  udp.endPacket();

  Zaehler_s16++; // Zähler inkrementieren

  delay(100);
}

E15_RadInkrementalgeberFahrt.ino 

/* Bibliotheken einbinden */
#include "AlphaBot.h"

/* Globale KONSTANTEN deklarieren */
AlphaBot R2D2 = AlphaBot();               // Instanz des Alphabot wird erzeugt. */
const byte PORT_ENC_L_u8 = 2;             // Die linke Lichtschranke (CNTL) liegt an Arduino D2
const byte PORT_ENC_R_u8 = 3;             // Die rechte Lichtschranke (CNTR) liegt an Arduino D3
const byte ANZAHL_INCREMENTE_u8 = 40;     // Die Encoderscheibe hat 20 Löcher und somit 40 Zustände
const int MOTOR_POWER_s16 = 80;           // Motorleistung
const unsigned long BAUDRATE_u32 = 9600;  // Serielle Übertragungsgeschwindigkeit in Baud
const unsigned long DELAY_MS_u32 = 1000;  // Delay in ms

/* Globale Variablen */
volatile byte valEncL_u8 = 0;               // https://www.arduino.cc/reference/de/language/variables/data-types/byte/
volatile byte valEncR_u8 = 0;               // Inkrementzähler
volatile long int RadumdrehungenL_s32 = 0;  // https://www.arduino.cc/reference/de/language/variables/data-types/long/
volatile long int RadumdrehungenR_s32 = 0;  // Zähler für die kompletten Radumdrehungen

/* Einmalige Systeminitialisierung */
void setup() {
  Serial.begin(BAUDRATE_u32);                 // Seriellen Monitor starten
  pinMode(PORT_ENC_L_u8, INPUT);              // Eingangsport D2 definieren
  pinMode(PORT_ENC_R_u8, INPUT);              // Eingangsport D3 definieren
  attachInterrupt(0, updateEncoderL, CHANGE); // 0: D2 Auslösen des Interrupts bei Signalwechsel
  attachInterrupt(1, updateEncoderR, CHANGE); // 1: D3 https://www.arduino.cc/reference/de/language/functions/external-interrupts/attachinterrupt/
}
/* Zyklusschleife */
void loop() {  
  /* Ausgaben im Seriellen Monitor */
  Serial.print(valEncL_u8);
  Serial.print(" :-: ");
  Serial.print(valEncR_u8);
  Serial.print(" :-: ");
  Serial.print(RadumdrehungenL_s32);
  Serial.print(" :-: ");
  Serial.print(RadumdrehungenR_s32);
  Serial.print("\n");
  delay(DELAY_MS_u32);

  R2D2.MotorRun(MOTOR_POWER_s16, MOTOR_POWER_s16);  // Fahrt starten
  delay(DELAY_MS_u32);                              // Fahrzeit
  R2D2.Brake();                                     // Alle Motoren stoppen
}

/* Unterfunktionen */
void updateEncoderL(){                  // Inkrementalgeber Links
  valEncL_u8++;
  if (valEncL_u8 > ANZAHL_INCREMENTE_u8)// 40 Zustandswechsel = 1 Radumdrehung 
  { 
    valEncL_u8 = 0;                     // Reset Inkrementzähler
    RadumdrehungenL_s32++;              // Umdrehungen inkrementieren
  } 
}

void updateEncoderR(){                  // Inkrementalgeber Rechts
  valEncR_u8++;
  if (valEncR_u8 > ANZAHL_INCREMENTE_u8)// 40 Zustandswechsel = 1 Radumdrehung
  { 
    valEncR_u8 = 0;                     // Reset Inkrementzähler
    RadumdrehungenR_s32++;              // Umdrehungen inkrementieren
  } 
}

Weitere AlphaBot und Arduino Demos finden Sie im SVN-Repositorium

https://svn.hshl.de/svn/Informatikpraktikum_1/trunk/Arduino/ArduinoLibOrdner/

Video

How to use MPU-9250 Gyroscope, Accelerometer, Magnetometer for Arduino

Datenblätter

• InvenSense: Datenblatt MPU-9250 Rev. 1.4
• InvenSense: Datenblatt MPU-9250 Rev. 1.1
• Erklärung des Sensors Teil 1 wolles-elektronikkiste.de
• Erklärung des Sensors Teil 2 wolles-elektronikkiste.de

---

→ zurück zum Hauptartikel: Sensor-Baukasten | HSHL-Mechatronik-Baukasten