Gyroskop MPU6050

Hallo zusammen,

kennt jemand ein gutes Tutorial (Video oder Text), mit dem man das auslesen der Neigung des MPU6050 verstehen kann? Ich würde diesen nämlich gerne für meinen geplanten Quadrokopter verwenden und dafür ist es ungeschickt, die vorgefertigten Codes aus dem Internet zu übernehmen. Diese hängen sich nämlich oft auf und sind von den Ergebnissen her, sehr verwirrend. Erst einmal, sind die Zahlen bei jedem Upload verschieden und in einer seltsamen Einheit angegeben, bei der senkrecht 70° sind.

Ich freue mich auf Antworten

antondriller:
Ich freue mich auf Antworten

Keine Antwort, eine Frage: Hast Du schon hier im Forum mal die Suchfunktion getestet? Wenn das Ding, das Du benutzen willst, nichs absolut Exotisches ist, würde mich wundern, wenn es hier noch nie etwas dazu gegeben hätte.

Gruß

Gregor

Das ist nix exotisches.
Das Ding wird ziemlich oft und gerne benutzt.
Schlussendlich ist auch nicht das Auslesen das Problem, sondern der Wurm steckt darin, die ausgelesenen Werte dann so zu verwursten, dass man damit was anfangen kann.
Das Ding ist ein dreiachsiges Gyroskop mit nem dreiachsigen Beschleunigungsmesser, und gibt nicht aus, wo oben, unten, links oder rechts ist. Das ist dem Sensor nämlich vollkommen egal (er funktioniert z.B. auch im Weltraum), er misst lediglich Beschleunigungen in allen drei Achsen und auch Rotationen um diese.

Das muss man schon selber berechnen- oder eben eines der Beispielprogramme benutzen (ich glaub, das von Adafruit läuft hervorragend).
Wenn du dazu wirklich ins Hintergrundwissen einsteigen willst (Hut ab, das ist höhere Mathematik), wirst du das Datenblatt befragen müssen.

Nen Eigenbau-Copter mit deinem Wissen kannst du allerdings erstmal getrost vergessen. Dazu gehört dann noch so einiges mehr.

Erst einmal vielen Dank für deine Antwort. Dass das Auslesen der Werte nicht das Problem ist, habe ich schon selbst gemerkt. War vielleicht etwas ungeschickt formuliert. Selbst ich habe das hinbekommen.
Bin jetzt gerade dabei, mich mal auf dieser Seite hier über das Shield einzulesen.

Aber wieso sollte ich das mit der Drohne vergessen? So viel gehört da ja auch nicht dazu. Sie soll ja auch keine Funktionen haben wie automatisch zurückkehren oder einem folgen. Sie soll lediglich hoch und runter, nach vorne und hinten und nach links und rechts fliegen können. Und wenn ich das hinbekommen habe, würde ich gegebenenfalls noch versuchen, das Gyroskop einzubauen.

Das ganze ist nämlich für ein Schulprojekt in Technik, bei dem man zu zweit vier Monate Zeit hat, um ein komplexeres Projekt auf die Beine zu stellen. Ich habe bereits die vier Motoren mit einem Fernlenksystem über den Arduino steuern können. Viel mehr braucht man doch für eine einfache Drohne nicht?

Eine Frage: Wieso setzt du immer wieder Unterstriche zwischen die Wörter?

Ein selbstgebauter x-Copter wo dein MPU6050 dazu dient, die x Motoren so zu regeln, dass das Ding ruhig in der Luft steht, statt sich an einer unvorhersehbaren Stelle in den Boden zu bohren, ist eine sehr anspruchsvolle Aufgabe. Aus dem MPU die richtigen Werte zu lesen ist da eine Grundvoraussetzung, aber längst nicht alles.


das_soll_unterstrichenen_Text_darstellen
(Wenn man nur ASCII - Zeichen zur Formatierung hat oder verwenden will)

Ich habe bereits die vier Motoren mit einem Fernlenksystem über den Arduino steuern können. Viel mehr braucht man doch für eine einfache Drohne nicht?

An- bzw. Ausschalten reicht da leider nicht.
Die Motoren müssen auch abhänig von der Lage der Drohne im Raum in ihrer Drehzahl geregelt werden.
Das ist genau einer der Teile, wo es anfängt kompliziert zu werden.
Außer natürlich man findet im Internet fertige Steuerungs Software.

Auch die Aufgabe aus dem Sensorg wirklich verwärtbare Infos herauszuholen ist auch nicht wirklich trivial (Stichwort Kalmanfilter).

Eventuell könnte dir da diese Lib helfen:

Da ich leider selbst keinen von den MPUs habe konnte ich das allerdings leider nicht vorher testen.

Edit:
Hier ist der Forum Post zu der Bibliothek von oben.

Und hier ein Link zu einem Artikel mit Erklärungen wie es implementiert wurde (eigentlich das worum es dir ja geht).

antondriller:
Eine Frage: Wieso setzt du immer wieder Unterstriche zwischen die Wörter?

Das soll „unterstrichen“ heißen. Da in Newsgruppen im Usenet üblicherweise nur ASCII-Text („nur-Text“ in reinem ASCII) benutzt wird, sind solchen Krücken ein Ausweg:

unterstrichen
/kursiv/
fett

Gruß

Gregor

PS: Es gibt hier im Forum jemanden, der sich einen Multicopter gebaut hat. Wer das ist, weiß ich grad nicht, aber wenn Du suchst, wirst Du sie/ihn finden.

Addi2438:
An- bzw. Ausschalten reicht da leider nicht.
Die Motoren müssen auch abhänig von der Lage der Drohne im Raum in ihrer Drehzahl geregelt werden.

Das ist es auch nicht, was ich gemacht habe. Statt steuern hätte ich vielleicht lieber regeln schreiben sollen. Also bevor ich den Arduino hatte, habe ich meine RC-Projekte immer folgenderweise aufgebaut:

Fernsteuerung - - - - - - - > Empfänger -> ESC -> Motor

Mit dem Arduino:

Fernsteuerung - - - - - - - > Empfänger -> Arduino -> ESC(s) -> Motor(en)

So kann ich nun, statt nur die Geschwindigkeit zu regeln, auch noch beispielsweise Bewegungsabläufe für die Motoren programmieren oder eben auch den Output von Sensoren in die Drehgeschwindigkeit mit einfließen lassen. Das müsste doch reichen um eine einfache Drohne zu bauen.

Was ist eigentlich der Unterschied zwischen folgenden Code, den ich gerade geschrieben habe, und diesen ewig langen im Internet, die dieses DMP verwenden? Ich habe bei meinem Code eigentlich keine Defizite entdeckt (beinhaltet nur X- und Y-Achse, die anderen brauche ich vorerst nicht).

#include "Wire.h"
#include "I2Cdev.h"
#include "MPU6050.h"

MPU6050 mpu;

int16_t gx, gy, gz;
int16_t ax, ay, az;

int x;
int y;

void setup()
{
Wire.begin();
Serial.begin(115200);
mpu.initialize();
}

void loop()
{
mpu.getMotion6(&gy, &gx, &gz, &ax, &ay, &az);

x = map(gx, -17000, 17000, -90, 90);
y = map(gy, -17000, 17000, -90, 90);

Serial.println("");
Serial.print("GX: ");
Serial.print(x);
Serial.print(" ");
Serial.print("GY: ");
Serial.println(y);
Serial.println("");
Serial.println("--------------------");

delay(200);
}

Wenn du eine fertige Drohne, statt direkt mit der Fernbedienung indirekt mit einer modifizierten Fernbedienung verbindest, kann das natürlich was anderes sein.

“ESC” in deinem Schema wäre dann mehr als nur die Motor-Ansteuerung, sondern die komplette Lageregelung…

Man kann das auch auf dem Arduino realisieren, ist aber anspruchsvoll (selbst mit gefundenen fertigen
Regelungs-Sketchen), finde ich.


was ist “dieses DMP”? 3 Buchstaben sind etwas wenig zum googeln (oder ich zu faul)

Ups, da hab ich mich wohl vertan. DMP ist nur der Digital Motion Processor, also der Teil, der die Neigung misst.
Irgendwo hab ich nämlich gelesen, dass DMP irgendeine Methode ist, um präzise und keine solchen schwankenden Messergebnisse herauszubekommen.
Ist ja auch egal, wie es heißt. Zumindest ist der Code des folgenden Programms echt sehr lang (ca. 46% des Speichers vom UNO). Natürlich werden da auch noch die Z-Achse vom Gyroskop, und das Accelerometer angezeigt aber es werden auch furchtbare Befehle angewendet.

Mein Programm oben ist viel kürzer und liefert ziemlich genaue Ergebnisse und ich weiß nicht, wieso das andere dann so lang ist.

Hm, ich hab gerade nix zum testen zur Hand, aber irgendwas sagt mir, dass es mit den paar Zeilen da längst nicht getan ist.
Ich hab mir ein paar Mal, aus Neugier, "fertige" Codes für Drohnen angesehen-die waren durchweg ein kleines bisschen länger.

Allerdings: du scheinst selbst nicht genau zu wissen, was dein Programm da wirklich macht.
Irgendwas tun die Bibliotheken nämlich auch, sonst bräuchte man die nicht (und das kann sehr viel sein).

Wie gesagt: um den MPU-Baustein auszulesen, ist noch nicht viel von Nöten, schon richtig, aber damit dann was anfangen-da schauts anders aus.
Was genau siehst du denn da im seriellen Monitor?
Die Winkel, in denen du das Ding hälst?

Wenn dem so ist, und die in allen drei Achsen immer korrekt sind (alles andere nutzt dir für eine dreiachsige Lageregelung rein gar nix), dann ist das ein guter Anfang. Glaub ich aber irgendwie nicht...

antondriller:
... furchtbare Befehle ...

Programmierer ist ein echter Scheißjob. Manchmal wünscht man sich, man dürfe akkordmäßig öffentliche und kostenlose Toiletten reinigen. Wundere Dich bloß nicht, wenn Du beim Programmieren auf furchtbare Algorithmen stößt. Schlimmer ist nur, wenn man keine Flüche kennt.

Gruß

Gregor

Nabend.
Ich habe schon ein paar Jahre dieses Teil hier rumliegen, bisher aber nicht 1x angeschlossen xD Heute hab ich damit mal angefangen, ich hab da was Ähnliches vor, wie Du (aber keinen Zeitdruck^^).
Was mich bisher stört: die Daten auf Anhieb in was Brauchbares zu wandeln ist leider nicht so einfach wie beim LSM9DS1, den hatte ich mal für ein Praktikum genutzt. Dessen Lib hatte es ziemlich einfach gemacht, an die Daten ranzukommen.

Mein Programm oben ist viel kürzer und liefert ziemlich genaue Ergebnisse und ich weiß nicht, wieso das andere dann so lang ist.

–>In diesem Beispielprogramm gibt es noch einige Parameter mehr, die berechnet werden. Zusätzlich wird noch eine Schnittstelle für Motionapps und Processing bereitgestellt, wenn ich das richtig verstehe.

x = map(gx, -17000, 17000, -90, 90);
y = map(gy, -17000, 17000, -90, 90);

–>Wie bist Du auf diesen Ansatz eigentlich gekommen?

Ich such jedenfalls mal weiter, wie man den Sensor genau kalibriert. Außerdem müssen für Regelungsprozesse die Werte noch mittels Kalman-Filter stabilisiert werden.

Rabenauge:
Was genau siehst du denn da im seriellen Monitor?
Die Winkel, in denen du das Ding hälst?

Genau. Ich hab einfach die Werte vom Gyroskop, die von -17.000 bis 17.000 reichen, gemappt also. -17.000 zu -90 geändert und 17.000 zu 90. Die Zwischenwerte bei diesem Befehl werden dann automatisch berechnet. Diesen Befehl habe ich schon öfters in den Programmen für das Gyroskop gelesen und musste dann mal herausfinden, was der eigentlich macht. Damit dürfte sich auch deine Frage beantwortet haben DerLehmi.

Also wenn ich den Sensor gerade halte, liegen die Werte ungefähr bei 0. Wenn ich den MPU auf der X- oder Y-Achse neige, gehen die Werte entweder Richtung 90 oder -90. Ich kann auch nicht ganz glauben, dass es damit schon getan ist aber es scheint zu funktionieren.

DerLehmi:
Außerdem müssen für Regelungsprozesse die Werte noch mittels Kalman-Filter stabilisiert werden.

Genau diese Stabilisierung meinte ich. Vielleicht wären die Werte meines Programms noch etwas genauer damit.

Übrigens: Das Schulprojekt beginnt erst nach den Weihnachtsferien. Also hab ich schon noch etwas länger Zeit als 4 Monate. Ich will mich nur jetzt schon einmal informieren, da es natürlich ein eher anspruchsvolles Projekt ist.

DerLehmi:
Ich such jedenfalls mal weiter, wie man den Sensor genau kalibriert.

Da hab ich sogar ein Programm für. Leider weiß ich nicht mehr, wo ich es heruntergeladen habe weshalb ich es jetzt einfach hier rein poste.

// Arduino sketch that returns calibration offsets for MPU6050 // Version 1.1 (31th January 2014)
// Done by Luis Ródenas luisrodenaslorda@gmail.com
// Based on the I2Cdev library and previous work by Jeff Rowberg jeff@rowberg.net
// Updates (of the library) should (hopefully) always be available at GitHub - jrowberg/i2cdevlib: I2C device library collection for AVR/Arduino or other C++-based MCUs

// These offsets were meant to calibrate MPU6050’s internal DMP, but can be also useful for reading sensors.
// The effect of temperature has not been taken into account so I can’t promise that it will work if you
// calibrate indoors and then use it outdoors. Best is to calibrate and use at the same room temperature.

/* ========== LICENSE ==================================
I2Cdev device library code is placed under the MIT license
Copyright (c) 2011 Jeff Rowberg

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

*/

// I2Cdev and MPU6050 must be installed as libraries
#include “I2Cdev.h”
#include “MPU6050.h”
#include “Wire.h”

/////////////////////////////////// CONFIGURATION /////////////////////////////
//Change this 3 variables if you want to fine tune the skecth to your needs.
int buffersize=1000; //Amount of readings used to average, make it higher to get more precision but sketch will be slower (default:1000)
int acel_deadzone=8; //Acelerometer error allowed, make it lower to get more precision, but sketch may not converge (default:8)
int giro_deadzone=1; //Giro error allowed, make it lower to get more precision, but sketch may not converge (default:1)

// default I2C address is 0x68
// specific I2C addresses may be passed as a parameter here
// AD0 low = 0x68 (default for InvenSense evaluation board)
// AD0 high = 0x69
//MPU6050 accelgyro;
MPU6050 accelgyro(0x68); // ← use for AD0 high

int16_t ax, ay, az,gx, gy, gz;

int mean_ax,mean_ay,mean_az,mean_gx,mean_gy,mean_gz,state=0;
int ax_offset,ay_offset,az_offset,gx_offset,gy_offset,gz_offset;

/////////////////////////////////// SETUP ////////////////////////////////////
void setup() {
// join I2C bus (I2Cdev library doesn’t do this automatically)
Wire.begin();
// COMMENT NEXT LINE IF YOU ARE USING ARDUINO DUE
TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz). Leonardo measured 250kHz.

// initialize serial communication
Serial.begin(115200);

// initialize device
accelgyro.initialize();

// wait for ready
while (Serial.available() && Serial.read()); // empty buffer
while (!Serial.available()){
Serial.println(F(“Send any character to start sketch.\n”));
delay(1500);
}
while (Serial.available() && Serial.read()); // empty buffer again

// start message
Serial.println("\nMPU6050 Calibration Sketch");
delay(2000);
Serial.println("\nYour MPU6050 should be placed in horizontal position, with package letters facing up. \nDon’t touch it until you see a finish message.\n");
delay(3000);
// verify connection
Serial.println(accelgyro.testConnection() ? “MPU6050 connection successful” : “MPU6050 connection failed”);
delay(1000);
// reset offsets
accelgyro.setXAccelOffset(0);
accelgyro.setYAccelOffset(0);
accelgyro.setZAccelOffset(0);
accelgyro.setXGyroOffset(0);
accelgyro.setYGyroOffset(0);
accelgyro.setZGyroOffset(0);
}

/////////////////////////////////// LOOP ////////////////////////////////////
void loop() {
if (state==0){
Serial.println("\nReading sensors for first time…");
meansensors();
state++;
delay(1000);
}

if (state==1) {
Serial.println("\nCalculating offsets…");
calibration();
state++;
delay(1000);
}

if (state==2) {
meansensors();
Serial.println("\nFINISHED!");
Serial.print("\nSensor readings with offsets:\t");
Serial.print(mean_ax);
Serial.print("\t");
Serial.print(mean_ay);
Serial.print("\t");
Serial.print(mean_az);
Serial.print("\t");
Serial.print(mean_gx);
Serial.print("\t");
Serial.print(mean_gy);
Serial.print("\t");
Serial.println(mean_gz);
Serial.print(“Your offsets:\t”);
Serial.print(ax_offset);
Serial.print("\t");
Serial.print(ay_offset);
Serial.print("\t");
Serial.print(az_offset);
Serial.print("\t");
Serial.print(gx_offset);
Serial.print("\t");
Serial.print(gy_offset);
Serial.print("\t");
Serial.println(gz_offset);
Serial.println("\nData is printed as: acelX acelY acelZ giroX giroY giroZ");
Serial.println(“Check that your sensor readings are close to 0 0 16384 0 0 0”);
Serial.println(“If calibration was succesful write down your offsets so you can set them in your projects using something similar to mpu.setXAccelOffset(youroffset)”);
while (1);
}
}

/////////////////////////////////// FUNCTIONS ////////////////////////////////////
void meansensors(){
long i=0,buff_ax=0,buff_ay=0,buff_az=0,buff_gx=0,buff_gy=0,buff_gz=0;

while (i<(buffersize+101)){
// read raw accel/gyro measurements from device
accelgyro.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);

if (i>100 && i<=(buffersize+100)){ //First 100 measures are discarded
buff_ax=buff_ax+ax;
buff_ay=buff_ay+ay;
buff_az=buff_az+az;
buff_gx=buff_gx+gx;
buff_gy=buff_gy+gy;
buff_gz=buff_gz+gz;
}
if (i==(buffersize+100)){
mean_ax=buff_ax/buffersize;
mean_ay=buff_ay/buffersize;
mean_az=buff_az/buffersize;
mean_gx=buff_gx/buffersize;
mean_gy=buff_gy/buffersize;
mean_gz=buff_gz/buffersize;
}
i++;
delay(2); //Needed so we don’t get repeated measures
}
}

void calibration(){
ax_offset=-mean_ax/8;
ay_offset=-mean_ay/8;
az_offset=(16384-mean_az)/8;

gx_offset=-mean_gx/4;
gy_offset=-mean_gy/4;
gz_offset=-mean_gz/4;
while (1){
int ready=0;
accelgyro.setXAccelOffset(ax_offset);
accelgyro.setYAccelOffset(ay_offset);
accelgyro.setZAccelOffset(az_offset);

accelgyro.setXGyroOffset(gx_offset);
accelgyro.setYGyroOffset(gy_offset);
accelgyro.setZGyroOffset(gz_offset);

meansensors();
Serial.println("…");

if (abs(mean_ax)<=acel_deadzone) ready++;
else ax_offset=ax_offset-mean_ax/acel_deadzone;

if (abs(mean_ay)<=acel_deadzone) ready++;
else ay_offset=ay_offset-mean_ay/acel_deadzone;

if (abs(16384-mean_az)<=acel_deadzone) ready++;
else az_offset=az_offset+(16384-mean_az)/acel_deadzone;

if (abs(mean_gx)<=giro_deadzone) ready++;
else gx_offset=gx_offset-mean_gx/(giro_deadzone+1);

if (abs(mean_gy)<=giro_deadzone) ready++;
else gy_offset=gy_offset-mean_gy/(giro_deadzone+1);

if (abs(mean_gz)<=giro_deadzone) ready++;
else gz_offset=gz_offset-mean_gz/(giro_deadzone+1);

if (ready==6) break;
}
}

War schon schneller^^
Übrigens, Code lieber in Code-Tags verfrachten :wink: (Schaltfläche im Editor links, über dem :slight_smile: -Smiley)

Genau. Ich hab einfach die Werte vom Gyroskop, die von -17.000 bis 17.000 reichen, gemappt also. -17.000 zu -90 geändert und 17.000 zu 90.

-->Wundert mich etwas, da der Wertebereich -32768, +32767 ist. Der repräsentierte Wert hängt von der eingestellten Empfindlichkeit ab (+/- 2, 4, 8, o. 16g fürs Accelerometer und +/- 250, 500, 1000, o. 2000 deg/sec fürs Gyroscop.)

Was ist eigentlich der Unterschied zwischen folgenden Code, den ich gerade geschrieben habe, und diesen ewig langen im Internet, die dieses DMP verwenden?

-->Der DMP ist ein Prozessor auf dem Breakout. Er nimmt die Werte vom Sensor und berechnet damit die Werte in Quaternionen, wandelt diese in Euler-Winkel um und kann noch mehr Zeugs berechnen. Außerdem werden damit Fehler herausgerechnet, also ein Filter. Damit sollte es überflüssig sein, einen eigenen Kalman- oder Komplementärfilter zu basteln....

antondriller:
... Das ganze ist nämlich für ein Schulprojekt in Technik, ...

Gehört die Dokumentation des Ergebnisses/des Entstehens zum Projekt dazu? Ich habe oft den Eindruck, dass das übel vernachlässigt wird.

Gruß

Gregor

gregorss:
Gehört die Dokumentation des Ergebnisses/des Entstehens zum Projekt dazu? Ich habe oft den Eindruck, dass das übel vernachlässigt wird.

Dass die Dokumentation vernachlässigt wird? Bei uns ganz sicher nicht :smiley: . Manchmal ist das echt nervig mit den ganzen Protokollen.

DerLehmi:
-->Wundert mich etwas, da der Wertebereich -32768, +32767 ist. Der repräsentierte Wert hängt von der eingestellten Empfindlichkeit ab (+/- 2, 4, 8, o. 16g fürs Accelerometer und +/- 250, 500, 1000, o. 2000 deg/sec fürs Gyroscop.)

Komisch. Ich hab jetzt woanders das mit den 17.000 gelesen. Ich hab jetzt einfach mal das Mapping weggelassen und mir die "rohen" Werte anzeigen lassen. Dort ging es von -17.000 bis 17.000. Ich weiß jetzt zwar nicht, was stimmt, aber mit 17.000 funktioniert es zumindest bei mir und bei den anderen Werten kommen seltsame Werte raus. :-\

Hast du denn schon einmal meinen Code auf deinen Arduino + MPU6050 geladen? Wenn nicht, musst du mal ausprobieren. Es wundert mich nämlich wirklich, dass dort so präzise Werte rauskommen trotz des einfachen Programms. Das einzige, was ich nicht hinbekommen habe, ist, dass auch die Nachkommastellen angezeigt werden. Da will der Befehl
mpu.getMotion6(&gy, &gx, &gz, &ax, &ay, &az);
irgendwie nicht mitmachen. Aber vielleicht habt ihr da ne Idee. Ich hab's mit den ganzen unterschiedlichen Variablenarten noch nicht so drauf. Ist aber auch nicht so wichtig. Gradzahlen von -90 bis 90 sind mir genau genug. :slight_smile:

Hier mein Code:

#include "Wire.h"
#include "I2Cdev.h"
#include "MPU6050.h"

MPU6050 mpu;

int16_t gx, gy, gz;
int16_t ax, ay, az;

int x;
int y;

void setup() 
{
    Wire.begin();
    Serial.begin(115200);
    mpu.initialize();
}

void loop() 
{
    mpu.getMotion6(&gy, &gx, &gz, &ax, &ay, &az);

    x = map(gx, -17000, 17000, -90, 90);
    y = map(gy, -17000, 17000, -90, 90);


    Serial.print("GX: ");
    Serial.print(x);
    Serial.print("   ");
    Serial.print("GY: ");
    Serial.println(y);



    delay(2);
}

Die komplizierten Codes zu verstehen, kann ich wahrscheinlich erst einmal vergessen. Ihr müsst wissen, ich bin in der 10. Klasse und kann mit Euler und Vectoren noch nicht wirklich viel anfangen. :wink:

Komisch. Ich hab jetzt woanders das mit den 17.000 gelesen. Ich hab jetzt einfach mal das Mapping weggelassen und mir die "rohen" Werte anzeigen lassen. Dort ging es von -17.000 bis 17.000. Ich weiß jetzt zwar nicht, was stimmt, aber mit 17.000 funktioniert es zumindest bei mir und bei den anderen Werten kommen seltsame Werte raus. :-\

-->Ahso...dann sind das wohl doch nicht die Rohdaten die aus dem FiFo ausgelesen werden. Wäre nun interessant, ob die Lib die Daten bearbeitet oder ob auch der DMP zu Rate gezogen wird.... Und ja, hab ich probiert. Nur halt die Z-Achse macht nix Brauchbares...

Aber vielleicht habt ihr da ne Idee.

Int hat keine Nachkommastellen. Nutze als Datentyp dafür double oder float.

Die komplizierten Codes zu verstehen, kann ich wahrscheinlich erst einmal vergessen. Ihr müsst wissen, ich bin in der 10. Klasse und kann mit Euler und Vectoren noch nicht wirklich viel anfangen.

-->Interessant ist für uns an dieser Stelle eigentlich nur die Berechnung der Yaw, Pitch und Roll-Werte :wink: