MPU 6050 Gyro, Beschleunigungssensor-Kommunikation mit Arduino (Atmega328p) - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:16

Die MPU6050 IMU verfügt über einen 3-Achsen-Beschleunigungsmesser und ein 3-Achsen-Gyroskop, die auf einem einzigen Chip integriert sind.

Das Gyroskop misst die Rotationsgeschwindigkeit oder die Änderungsrate der Winkelposition über die Zeit entlang der X-, Y- und Z-Achse.

Die Ausgaben des Gyroskops sind in Grad pro Sekunde. Um die Winkelposition zu erhalten, müssen wir also nur die Winkelgeschwindigkeit integrieren.

Auf der anderen Seite misst der Beschleunigungsmesser MPU6050 die Beschleunigung, indem er die Gravitationsbeschleunigung entlang der 3 Achsen misst und mithilfe einiger trigonometrischer Mathematik den Winkel berechnen kann, in dem der Sensor positioniert ist. Wenn wir also die Daten des Beschleunigungsmessers und des Gyroskops fusionieren oder kombinieren, können wir sehr genaue Informationen über die Sensorausrichtung erhalten.

3-Achsen-Gyroskop Das MPU-6050 besteht aus einem 3-Achsen-Gyroskop, das die Rotationsgeschwindigkeit entlang der x-, y-, z-Achse mit mikroelektromechanischer Systemtechnologie (MEMS) erfassen kann. Wenn der Sensor entlang einer Achse gedreht wird, wird aufgrund des Coriolis-Effekts eine Vibration erzeugt, die vom MEMS erkannt wird. Der 16-Bit-ADC wird verwendet, um die Spannung zu digitalisieren, um jede Achse abzutasten. +/- 250, +/- 500, +/- 1000, +/- 2000 sind der volle Skalenbereich der Ausgabe. Die Winkelgeschwindigkeit wird entlang jeder Achse in Grad pro Sekunde gemessen.

Nützlicher Link:…………….

Arduino-Board:.……….

MPU6050 IMU ……………https://compoindia.com/product/mpu6050-3-axis-accelerometer-and-gyroscope-sensor/

Schritt 1: MPU-6050-Modul

Das Modul MPU-6050 hat 8 Pins,

INT: Digitalausgangs-Pin unterbrechen.

AD0: I2C-Slave-Adresse LSB-Pin. Dies ist das 0. Bit in der 7-Bit-Slave-Adresse des Geräts. Wenn es an VCC angeschlossen ist, wird es als logische Eins gelesen und die Slave-Adresse ändert sich.

XCL: Auxiliary Serial Clock Pin. Dieser Pin wird verwendet, um andere I2C-Schnittstellenfähige Sensoren SCL-Pin mit MPU-6050 zu verbinden.

XDA: Auxiliary Serial Data Pin. Dieser Pin wird verwendet, um den SDA-Pin eines anderen I2C-Schnittstellenfähigen Sensors mit dem MPU-6050 zu verbinden.

SCL: Serial Clock-Pin. Verbinden Sie diesen Pin mit dem SCL-Pin des Mikrocontrollers. SDA: Serieller Daten-Pin. Verbinden Sie diesen Pin mit dem SDA-Pin des Mikrocontrollers.

GND: Erdungsstift. Verbinden Sie diesen Pin mit dem Masseanschluss.

VCC: Stromversorgungs-Pin. Verbinden Sie diesen Pin mit der +5V DC-Versorgung. Das MPU-6050-Modul hat eine Slave-Adresse (Wenn AD0 = 0, d.h. es ist nicht mit Vcc verbunden) als, Slave-Schreibadresse (SLA+W): 0xD0

Slave-Leseadresse (SLA+R): 0xD1

Schritt 2: Berechnungen

Die Gyroskop- und Beschleunigungsmesser-Sensordaten des MPU6050-Moduls bestehen aus 16-Bit-Rohdaten in 2er-Komplement-Form.

Die Temperatursensordaten des MPU6050-Moduls bestehen aus 16-Bit-Daten (nicht im 2er-Komplement).

Nehmen wir nun an, wir haben ausgewählt,

• - Skalenendwert des Beschleunigungsmessers von +/- 2 g mit Empfindlichkeitsskalierungsfaktor von 16, 384 LSB (Count)/g.
• - Gyroskop-Vollbereich von +/- 250 °/s mit Empfindlichkeitsskalierungsfaktor von 131 LSB (Count)/°/s. dann,

Um Sensor-Rohdaten zu erhalten, müssen wir zuerst die 2er-Komplementierung der Sensordaten von Beschleunigungsmesser und Gyroskop durchführen. Nachdem wir die Sensorrohdaten erhalten haben, können wir die Beschleunigung und die Winkelgeschwindigkeit berechnen, indem wir die Sensorrohdaten mit ihrem Empfindlichkeitsskalierungsfaktor wie folgt teilen:

Beschleunigungsmesserwerte in g (g-Kraft)

• Beschleunigung entlang der X-Achse = (Rohdaten der Beschleunigungsmesser-X-Achse/16384) g.
• Beschleunigung entlang der Y-Achse = (Rohdaten der Beschleunigungsmesser-Y-Achse/16384) g.
• Beschleunigung entlang der Z-Achse = (Rohdaten der Beschleunigungsmesser-Z-Achse/16384) g.

Gyroskopwerte in °/s (Grad pro Sekunde)

• Winkelgeschwindigkeit entlang der X-Achse = (Rohdaten der Gyroskop-X-Achse/131) °/s.
• Winkelgeschwindigkeit entlang der Y-Achse = (Rohdaten der Gyroskop-Y-Achse/131) °/s.
• Winkelgeschwindigkeit entlang der Z-Achse = (Rohdaten der Gyroskop-Z-Achse/131) °/s.

Temperaturwert in °/c (Grad pro Celsius)

Temperatur in Grad C = ((Temperatursensordaten)/340 + 36,53) °/c.

Zum Beispiel, Angenommen, nach dem 2'-Komplement erhalten wir den Rohwert der X-Achsen des Beschleunigungsmessers = +15454

Dann Ax = +15454/16384 = 0,94 g.

Mehr,

Wir wissen also, dass wir mit einer Empfindlichkeit von +/-2G und +/-250deg/s arbeiten, aber wie entsprechen unsere Werte diesen Beschleunigungen/Winkeln?

Dies sind beides gerade Liniendiagramme und wir können daraus errechnen, dass wir für 1G 16384 und für 1 Grad / s 131,07 lesen werden (obwohl die.07 aufgrund der Binärdatei ignoriert werden) Geradendiagramm mit 2G bei 32767 und -2G bei -32768 und 250/-250 bei den gleichen Werten.

Jetzt kennen wir also unsere Sensitivitätswerte (16384 und 131,07). Wir müssen nur die Offsets von unseren Werten abziehen und dann durch die Sensitivität dividieren.

Diese funktionieren gut für die X- und Y-Werte, aber da Z bei 1G und nicht bei 0 aufgezeichnet wurde, müssen wir 1G (16384) abziehen, bevor wir durch unsere Empfindlichkeit dividieren.

Schritt 3: MPU6050-Atmega328p-Verbindungen

Verbinden Sie einfach alles wie im Diagramm angegeben…

Die Anschlüsse sind wie folgt angegeben:-

MPU6050 Arduino Nano

VCC 5V-Ausgangspin

GND Massepin

SDA A4-Pin // serielle Daten

SCL A5 Pin // serieller Takt

Pitch- und Roll-Berechnung: Roll ist die Drehung um die x-Achse und Pitch ist die Drehung entlang der y-Achse.

Das Ergebnis ist im Bogenmaß. (Umwandeln in Grad durch Multiplizieren mit 180 und Dividieren durch pi)

Schritt 4: Codes und Erklärungen

/*

Arduino und MPU6050 Beschleunigungsmesser und Gyroskopsensor Tutorial von Dejan, https://howtomechatronics.com */ #include const int MPU = 0x68; // MPU6050 I2C-Adresse float AccX, AccY, AccZ; schweben GyroX, GyroY, GyroZ; float accAngleX, accAngleY, gyroAngleX, gyroAngleY, gyroAngleZ; Schwimmrollen, Nicken, Gieren; float AccErrorX, AccErrorY, GyroErrorX, GyroErrorY, GyroErrorZ; float elapsedTime, currentTime, previousTime; intc = 0; Void setup () { Serial.begin (19200); Wire.begin(); // Kommunikation initialisieren Wire.beginTransmission(MPU); // Kommunikation mit MPU6050 starten // MPU=0x68 Wire.write(0x6B); // Sprechen Sie mit dem Register 6B Wire.write (0x00); // Reset durchführen - eine 0 in das 6B-Register setzen Wire.endTransmission(true); // die Übertragung beenden /* // Beschleunigungssensor-Empfindlichkeit konfigurieren - Full Scale Range (Standard +/- 2g) Wire.beginTransmission (MPU); Wire.write (0x1C); // Mit dem ACCEL_CONFIG-Register (1C hex) sprechen Wire.write (0x10); // Setzen Sie die Registerbits als 00010000 (+/- 8g Skalenendwert) Wire.endTransmission (true); // Gyro Sensitivity konfigurieren - Full Scale Range (Standard +/- 250deg/s) Wire.beginTransmission(MPU); Wire.write (0x1B); // Sprechen Sie mit dem GYRO_CONFIG-Register (1B hex) Wire.write (0x10); // Setzen Sie die Registerbits als 00010000 (1000deg/s full scale) Wire.endTransmission (true); Verzögerung (20); */ // Rufen Sie diese Funktion auf, wenn Sie die IMU-Fehlerwerte für Ihr Modul abrufen müssen compute_IMU_error(); Verzögerung (20); aufrechtzuerhalten. Void Schleife () {// === Beschleunigungsdaten lesen === // Wire.beginTransmission (MPU); Wire.write (0x3B); // Beginne mit Register 0x3B (ACCEL_XOUT_H) Wire.endTransmission(false); Wire.requestFrom(MPU, 6, wahr); // Insgesamt 6 Register lesen, jeder Achsenwert wird in 2 Registern gespeichert // Für einen Bereich von +-2g müssen wir die Rohwerte durch 16384 dividieren, gemäß dem Datenblatt AccX = (Wire.read() << 8 | Wire.read()) / 16384.0; // X-Achsen-Wert AccY = (Wire.read() << 8 | Wire.read()) / 16384.0; // Y-Achsenwert AccZ = (Wire.read() << 8 | Wire.read()) / 16384.0; // Z-Achsen-Wert // Berechnen von Roll und Pitch aus den Beschleunigungsmesserdaten accAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * 180 / PI) - 0.58; // AccErrorX ~(0.58) Siehe die benutzerdefinierte Funktioncalcul_IMU_error() für weitere Details accAngleY = (atan(-1 * AccX / sqrt(pow(AccY, 2) + pow(AccZ, 2))) * 180 / PI) + 1,58; // AccErrorY ~(-1.58) // === Gyroskopdaten lesen === // previousTime = currentTime; // Vorherige Zeit wird vor der aktuellen Zeit gespeichert read currentTime = millis(); // Aktuelle Uhrzeit aktuelle Uhrzeit gelesen elapsedTime = (currentTime - previousTime) / 1000; // Durch 1000 teilen, um Sekunden zu erhalten Wire.beginTransmission(MPU); Wire.write (0x43); // Gyro-Daten erste Registeradresse 0x43 Wire.endTransmission (false); Wire.requestFrom(MPU, 6, wahr); // Insgesamt 4 Register lesen, jeder Achsenwert wird in 2 Registern gespeichert GyroX = (Wire.read () << 8 | Wire.read ()) / 131.0; // Für einen 250deg/s Bereich müssen wir zuerst den Rohwert durch 131.0 dividieren, laut Datenblatt GyroY = (Wire.read() << 8 | Wire.read()) / 131.0; GyroZ = (Wire.read() << 8 | Wire.read()) / 131.0; // Korrigieren Sie die Ausgänge mit den berechneten Fehlerwerten GyroX = GyroX + 0.56; // GyroErrorX ~(-0.56) GyroY = GyroY - 2; // GyroErrorY ~(2) GyroZ = GyroZ + 0.79; // GyroErrorZ ~ (-0.8) // Derzeit sind die Rohwerte in Grad pro Sekunde, deg/s, also müssen wir mit Sendonds (s) multiplizieren, um den Winkel in Grad zu erhalten gyroAngleX = gyroAngleX + GyroX * elapsedTime; // deg/s * s = deg gyroAngleY = gyroAngleY + GyroY * elapsedTime; gieren = gieren + GyroZ * verstrichene Zeit; // Komplementärfilter - Kombiniere Beschleunigungs- und Kreiselwinkelwerte roll = 0.96 * gyroAngleX + 0.04 * accAngleX; Steigung = 0,96 * gyroAngleY + 0,04 * accAngleY; // Drucken Sie die Werte auf dem seriellen Monitor Serial.print (roll); Serial.print("/"); Serial.print (Pitch); Serial.print("/"); Serial.println (gieren); } voidcalcul_IMU_error() {// Wir können diese Funktion im Setup-Abschnitt aufrufen, um den Beschleunigungsmesser- und Kreiseldatenfehler zu berechnen. Von hier aus erhalten wir die in den obigen Gleichungen verwendeten Fehlerwerte auf dem Serial Monitor gedruckt. // Beachten Sie, dass wir die IMU flach platzieren sollten, um die richtigen Werte zu erhalten, damit wir dann die richtigen Werte erhalten können // Beschleunigungsmesserwerte 200 Mal lesen while (c < 200) { Wire.beginTransmission (MPU); Wire.write (0x3B); Wire.endTransmission(false); Wire.requestFrom(MPU, 6, wahr); AccX = (Wire.read() << 8 | Wire.read()) / 16384.0; AccY = (Wire.read() << 8 | Wire.read()) / 16384.0; AccZ = (Wire.read() << 8 | Wire.read()) / 16384.0; // Alle Messwerte summieren AccErrorX = AccErrorX + ((atan((AccY) / sqrt(pow((AccX), 2) + pow(((AccZ), 2))) * 180 / PI)); AccErrorY = AccErrorY + ((atan(-1 * (AccX) / sqrt(pow((AccY), 2) + pow(((AccZ), 2))) * 180 / PI)); c++; } //Dividiere die Summe durch 200, um den Fehlerwert zu erhalten AccErrorX = AccErrorX / 200; AccErrorY = AccErrorY / 200; c = 0; // Kreiselwerte 200 Mal lesen while (c < 200) { Wire.beginTransmission (MPU); Wire.write (0x43); Wire.endTransmission(false); Wire.requestFrom(MPU, 6, wahr); GyroX = Wire.read() << 8 | Wire.read(); GyroY = Wire.read() << 8 | Wire.read(); GyroZ = Wire.read() << 8 | Wire.read(); // Alle Messwerte summieren GyroErrorX = GyroErrorX + (GyroX / 131.0); GyroErrorY = GyroErrorY + (GyroY / 131.0); GyroErrorZ = GyroErrorZ + (GyroZ / 131.0); c++; } //Dividiere die Summe durch 200, um den Fehlerwert zu erhalten GyroErrorX = GyroErrorX / 200; GyroErrorY = GyroErrorY / 200; GyroErrorZ = GyroErrorZ / 200; // Drucken Sie die Fehlerwerte auf dem Serial Monitor Serial.print ("AccErrorX: "); Serial.println (AccErrorX); Serial.print ("AccErrorY:"); Serial.println (AccErrorY); Serial.print ("GyroErrorX:"); Serial.println (GyroErrorX); Serial.print ("GyroErrorY:"); Serial.println (GyroErrorY); Serial.print ("GyroErrorZ:"); Serial.println (GyroErrorZ); } ------------------------------------------------- ---------------------------------------------------------- Ergebnisse:- X = Y = Z = ------------------------------------------------------ ----------------------------------------------- Wichtiger Hinweis: - ----------------

Im Loop-Bereich beginnen wir mit dem Lesen der Beschleunigungsmesserdaten. Die Daten für jede Achse werden in 2 Bytes oder Registern gespeichert und die Adressen dieser Register können wir dem Datenblatt des Sensors entnehmen.

Um sie alle zu lesen, beginnen wir mit dem ersten Register und fordern mit der Funktion requiestFrom() auf, alle 6 Register für die X-, Y- und Z-Achse zu lesen. Dann lesen wir die Daten aus jedem Register, und da die Ausgänge Zweierkomplement sind, kombinieren wir sie entsprechend, um die richtigen Werte zu erhalten.

Schritt 5: Verstehen des Neigungswinkels

Beschleunigungsmesser

Die Schwerkraft der Erde ist eine konstante Beschleunigung, bei der die Kraft immer nach unten zum Erdmittelpunkt zeigt.

Wenn der Beschleunigungsmesser parallel zur Schwerkraft ist, beträgt die gemessene Beschleunigung 1G, wenn der Beschleunigungsmesser senkrecht zur Schwerkraft steht, misst er 0G.

Der Neigungswinkel kann aus der gemessenen Beschleunigung mit dieser Gleichung berechnet werden:

θ = sin-1 (gemessene Beschleunigung / Schwerkraftbeschleunigung)

GyroGyro (auch bekannt als Geschwindigkeitssensor) wird verwendet, um die Winkelgeschwindigkeit (ω) zu messen.

Um den Neigungswinkel eines Roboters zu erhalten, müssen wir die Daten vom Kreisel wie in der folgenden Gleichung gezeigt integrieren:

= dθ / dt, θ = ∫ ω dt

Gyro- und Beschleunigungssensor-FusionNachdem wir die Eigenschaften von Gyro und Beschleunigungsmesser untersucht haben, wissen wir, dass sie ihre eigenen Stärken und Schwächen haben. Der berechnete Neigungswinkel aus den Beschleunigungsmesserdaten hat eine langsame Reaktionszeit, während der integrierte Neigungswinkel aus den Kreiseldaten einer Drift über einen bestimmten Zeitraum ausgesetzt ist. Mit anderen Worten, wir können sagen, dass die Beschleunigungsmesserdaten langfristig nützlich sind, während die Kreiseldaten kurzfristig nützlich sind.

Link zum besseren Verständnis: Hier klicken