MPU 6050 Gyro, comunicare accelerometru cu Arduino (Atmega328p): 5 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

MPU6050 IMU are atât accelerometru cu 3 axe, cât și giroscop cu 3 axe integrate pe un singur cip.

Giroscopul măsoară viteza de rotație sau rata de schimbare a poziției unghiulare în timp, de-a lungul axelor X, Y și Z.

Ieșirile giroscopului sunt în grade pe secundă, deci pentru a obține poziția unghiulară trebuie doar să integrăm viteza unghiulară.

Pe de altă parte, accelerometrul MPU6050 măsoară accelerația măsurând accelerația gravitațională de-a lungul celor 3 axe și folosind unele matematici de trigonometrie putem calcula unghiul la care este poziționat senzorul. Deci, dacă fuzionăm sau combinăm accelerometrul și datele giroscopului, putem obține informații foarte precise despre orientarea senzorului.

Giroscop cu 3 axe MPU-6050 constă dintr-un giroscop cu 3 axe care poate detecta viteza de rotație de-a lungul axei x, y, z cu tehnologia sistemului microelectromecanic (MEMS). Când senzorul este rotit de-a lungul oricărei axe, se produce o vibrație datorită efectului Coriolis, care este detectat de MEMS. ADC pe 16 biți este utilizat pentru a digitiza tensiunea pentru a testa fiecare axă. +/- 250, +/- 500, +/- 1000, +/- 2000 sunt gama completă de ieșire. Viteza unghiulară este măsurată de-a lungul fiecărei axe în grade pe secundă unitate.

Link util: …………….

Placa Arduino:. ……….

MPU6050 IMU ……………

Pasul 1: modulul MPU-6050

Modulul MPU-6050 are 8 pini,

INT: Intrerupe pinul de iesire digital.

AD0: I2C Slave Address LSB pin. Acesta este al 0-lea bit în adresa slave a dispozitivului pe 7 biți. Dacă este conectat la VCC, acesta este citit ca logică una și se schimbă adresa slave.

XCL: Pin auxiliar pentru ceas serial. Acest pin este utilizat pentru a conecta alți senzori SCL pin cu interfață I2C activă la MPU-6050.

XDA: Pin de date seriale auxiliare. Acest pin este utilizat pentru a conecta alți senzori ai interfeței I2C cu pin SDA la MPU-6050.

SCL: Serial Clock pin. Conectați acest pin la pinul SCL al microcontrolerelor. SDA: Serial Data pin. Conectați acest pin la pinul SDA al microcontrolerelor.

GND: știft de împământare. Conectați acest pin la conexiunea la masă.

VCC: Pin de alimentare. Conectați acest pin la alimentarea + 5V DC. Modulul MPU-6050 are adresă Slave (Când AD0 = 0, adică nu este conectat la Vcc) ca, Slave Write address (SLA + W): 0xD0

Slave Read address (SLA + R): 0xD1

Pasul 2: Calcule

Datele senzorului giroscopului și accelerometrului modulului MPU6050 sunt formate din date brute de 16 biți sub forma complementului 2.

Datele senzorului de temperatură ale modulului MPU6050 sunt formate din date pe 16 biți (nu în forma complementului 2).

Acum, să presupunem că am selectat,

• - Accelerometru cu o gamă completă de +/- 2g cu factor de scară de sensibilitate de 16, 384 LSB (număr) / g.
• - Giroscoapul la scară completă de +/- 250 ° / s cu factor de scară de sensibilitate de 131 LSB (număr) / ° / s. atunci,

Pentru a obține date brute ale senzorilor, trebuie mai întâi să realizăm complementul 2 pentru datele senzorilor de accelerometru și giroscop. După obținerea datelor brute ale senzorului, putem calcula accelerația și viteza unghiulară împărțind datele brute ale senzorului cu factorul lor de scală de sensibilitate, după cum urmează …

Valorile accelerometrului în g (g forță)

• Accelerarea de-a lungul axei X = (Accelerometru axa X date brute / 16384) g.
• Accelerarea de-a lungul axei Y = (Accelerometru axa Y date brute / 16384) g.
• Accelerarea de-a lungul axei Z = (Accelerometru axa Z date brute / 16384) g.

Valorile giroscopului în ° / s (grade pe secundă)

• Viteza unghiulară de-a lungul axei X = (date brute giroscop X axa / 131) ° / s.
• Viteza unghiulară de-a lungul axei Y = (date brute a giroscopului Y axa / 131) ° / s.
• Viteza unghiulară de-a lungul axei Z = (date brute a giroscopului axa Z / 131) ° / s.

Valoarea temperaturii în ° / c (grad pe Celsius)

Temperatura în grade C = ((date senzor de temperatură) / 340 + 36,53) ° / c.

De exemplu, Să presupunem că după complementul de 2’obținem accelerometrul axelor X valoare brută = +15454

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

Mai mult,

Deci știm că rulăm la o sensibilitate de +/- 2G și +/- 250deg / s, dar cum corespund valorile noastre acelor accelerații / unghiuri.

Acestea sunt ambele grafice în linie dreaptă și putem calcula din ele că pentru 1G vom citi 16384 și pentru 1dec / sec vom citi 131.07 (Deși.07 va fi ignorat din cauza binarului) aceste valori au fost elaborate doar desenând grafic în linie dreaptă cu 2G la 32767 și -2G la -32768 și 250 / -250 la aceleași valori.

Deci, acum cunoaștem valorile sensibilității noastre (16384 și 131.07), trebuie doar să scădem de la valorile noastre și apoi să ne dedicăm sensibilității.

Acestea vor funcționa bine pentru valorile X și Y, dar, deoarece Z a fost înregistrat la 1G și nu la 0, va trebui să reducem 1G (16384) înainte de a împărți la sensibilitatea noastră.

Pasul 3: Conexiuni MPU6050-Atmega328p

Conectați-vă tot ceea ce este prezentat în diagramă …

Conexiunile sunt date după cum urmează: -

MPU6050 Arduino Nano

Pin de ieșire VCC 5v

GND Știft de masă

Pin SDA A4 // date seriale

Pin SCL A5 // ceas serial

Calculul pitch-and-roll: Roll-ul este rotația în jurul axei x, iar pitch-ul este rotația de-a lungul axei y.

Rezultatul este în radiani. (convertiți în grade înmulțind cu 180 și împărțind la pi)

Pasul 4: Coduri și explicații

/*

Tutorial Accelerometru și senzor giroscop Arduino și MPU6050 de Dejan, https://howtomechatronics.com * / #include const int MPU = 0x68; // Adresă plutitoare MPU6050 I2C AccX, AccY, AccZ; plutitor GyroX, GyroY, GyroZ; float accAngleX, accAngleY, gyroAngleX, gyroAngleY, gyroAngleZ; rulou plutitor, pitch, yaw; float AccErrorX, AccErrorY, GyroErrorX, GyroErrorY, GyroErrorZ; float elapsedTime, currentTime, previousTime; int c = 0; void setup () {Serial.begin (19200); Wire.begin (); // Inițializați comunicarea Wire.beginTransmission (MPU); // Începeți comunicarea cu MPU6050 // MPU = 0x68 Wire.write (0x6B); // Discutați cu registrul 6B Wire.write (0x00); // Fă resetare - plasează un 0 în registrul 6B Wire.endTransmission (adevărat); // opriți transmisia / * // Configurați sensibilitatea accelerometrului - gama completă a scalei (implicit +/- 2g) Wire.beginTransmission (MPU); Wire.write (0x1C); // Discutați cu registrul ACCEL_CONFIG (1C hex) Wire.write (0x10); // Setați biții de registru ca 00010000 (+/- 8g gama completă a scalei) Wire.endTransmission (adevărat); // Configurați sensibilitatea giroscopului - gamă completă a scării (implicit +/- 250deg / s) Wire.beginTransmission (MPU); Wire.write (0x1B); // Discutați cu registrul GYRO_CONFIG (1B hex) Wire.write (0x10); // Setați biții de registru ca 00010000 (1000deg / s la scară completă) Wire.endTransmission (adevărat); întârziere (20); * / // Apelați această funcție dacă trebuie să obțineți valorile de eroare IMU pentru modulul calculate_IMU_error (); întârziere (20); } void loop () {// === Citește datele accelerometrului === // Wire.beginTransmission (MPU); Wire.write (0x3B); // Începeți cu registrul 0x3B (ACCEL_XOUT_H) Wire.endTransmission (fals); Wire.requestFrom (MPU, 6, adevărat); // Citiți 6 registre în total, fiecare valoare a axei este stocată în 2 registre // Pentru un interval de + -2g, trebuie să împărțim valorile brute la 16384, conform fișei tehnice AccX = (Wire.read () << 8 | Wire.read ()) / 16384.0; // valoarea axei X AccY = (Wire.read () << 8 | Wire.read ()) / 16384.0; // valoarea axei Y AccZ = (Wire.read () << 8 | Wire.read ()) / 16384.0; // Valoarea axei Z // Calculul Roll and Pitch din datele accelerometrului accAngleX = (atan (AccY / sqrt (pow (AccX, 2) + pow (AccZ, 2))) * 180 / PI) - 0,58; // AccErrorX ~ (0.58) Consultați funcția personalizată calculate_IMU_error () pentru mai multe detalii accAngleY = (atan (-1 * AccX / sqrt (pow (AccY, 2) + pow (AccZ, 2))) * 180 / PI) + 1,58; // AccErrorY ~ (-1.58) // === Citirea datelor giroscopului === // previousTime = currentTime; // Ora anterioară este stocată înainte de ora reală citită currentTime = millis (); // Ora curentă, timpul efectiv citit elapsedTime = (CurrentTime - previousTime) / 1000; // Împărțiți la 1000 pentru a obține secunde Wire.beginTransmission (MPU); Wire.write (0x43); // Adresa primului registru de date giroscopice 0x43 Wire.endTransmission (fals); Wire.requestFrom (MPU, 6, adevărat); // Citiți 4 registre în total, fiecare valoare a axei este stocată în 2 registre GyroX = (Wire.read () << 8 | Wire.read ()) / 131.0; // Pentru un interval de 250deg / s, trebuie să împărțim mai întâi valoarea brută la 131,0, conform fișei tehnice GyroY = (Wire.read () << 8 | Wire.read ()) / 131.0; GyroZ = (Wire.read () << 8 | Wire.read ()) / 131.0; // Corectați ieșirile cu valorile de eroare calculate GyroX = GyroX + 0,56; // GyroErrorX ~ (-0.56) GyroY = GyroY - 2; // GyroErrorY ~ (2) GyroZ = GyroZ + 0,79; // GyroErrorZ ~ (-0.8) // În prezent, valorile brute sunt în grade pe secundă, deg / s, deci trebuie să ne înmulțim cu sendonde (s) pentru a obține unghiul în grade gyroAngleX = gyroAngleX + GyroX * elapsedTime; // deg / s * s = deg gyroAngleY = gyroAngleY + GyroY * elapsedTime; yaw = yaw + GyroZ * elapsedTime; // Filtru complementar - combinați valorile accelerometrului și unghiului giroscopic = 0,96 * gyroAngleX + 0,04 * accAngleX; pitch = 0,96 * gyroAngleY + 0,04 * accAngleY; // Imprimați valorile pe monitorul serial Serial.print (roll); Serial.print ("/"); Serial.print (pitch); Serial.print ("/"); Serial.println (yaw); } void calculate_IMU_error () {// Putem numi această funcție în secțiunea de configurare pentru a calcula eroarea de accelerometru și date giroscopice. De aici vom obține valorile de eroare utilizate în ecuațiile de mai sus tipărite pe monitorul serial. // Rețineți că ar trebui să plasăm IMU plat pentru a obține valorile corecte, astfel încât să putem apoi valorile corecte // Citiți valorile accelerometrului de 200 de ori în timp ce (c <200) {Wire.beginTransmission (MPU); Wire.write (0x3B); Wire.endTransmission (fals); Wire.requestFrom (MPU, 6, adevărat); AccX = (Wire.read () << 8 | Wire.read ()) / 16384.0; AccY = (Wire.read () << 8 | Wire.read ()) / 16384.0; AccZ = (Wire.read () << 8 | Wire.read ()) / 16384.0; // Sumați toate citirile 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 ++; } // Împarte suma la 200 pentru a obține valoarea de eroare AccErrorX = AccErrorX / 200; AccErrorY = AccErrorY / 200; c = 0; // Citiți valorile giroscopice de 200 de ori în timp ce (c <200) {Wire.beginTransmission (MPU); Wire.write (0x43); Wire.endTransmission (fals); Wire.requestFrom (MPU, 6, adevărat); GyroX = Wire.read () << 8 | Wire.read (); GyroY = Wire.read () << 8 | Wire.read (); GyroZ = Wire.read () << 8 | Wire.read (); // Suma tuturor citirilor GyroErrorX = GyroErrorX + (GyroX / 131.0); GyroErrorY = GyroErrorY + (GyroY / 131.0); GyroErrorZ = GyroErrorZ + (GyroZ / 131.0); c ++; } // Împarte suma la 200 pentru a obține valoarea erorii GyroErrorX = GyroErrorX / 200; GyroErrorY = GyroErrorY / 200; GyroErrorZ = GyroErrorZ / 200; // Imprimați valorile de eroare pe 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); } ------------------------------------------------- ---------------------------------------------- Rezultate: - X = Y = Z = --------------------------------------------- ----------------------------------------------- Notă importantă: - ----------------

În secțiunea buclă începem prin citirea datelor accelerometrului. Datele pentru fiecare axă sunt stocate în 2 octeți sau registre și putem vedea adresele acestor registre din foaia de date a senzorului.

Pentru a le citi pe toate, începem cu primul registru și folosind funcția requiestFrom () solicităm să citim toate cele 6 registre pentru axele X, Y și Z. Apoi citim datele din fiecare registru și, deoarece ieșirile sunt două completări, le combinăm în mod corespunzător pentru a obține valorile corecte.

Pasul 5: Înțelegerea unghiului de înclinare

Accelerometru

Gravitația Pământului este o accelerație constantă în care forța este întotdeauna îndreptată în jos spre centrul Pământului.

Când accelerometrul este paralel cu gravitația, accelerația măsurată va fi 1G, când accelerometrul este perpendicular pe gravitație, va măsura 0G.

Unghiul de înclinare poate fi calculat din accelerația măsurată utilizând această ecuație:

θ = sin-1 (Accelerare măsurată / Accelerație gravitațională)

Giroscopul (alias senzorul de viteză) este utilizat pentru a măsura viteza unghiulară (ω).

Pentru a obține unghiul de înclinare al unui robot, trebuie să integrăm datele din giroscop, așa cum se arată în ecuația de mai jos:

ω = dθ / dt, θ = ∫ ω dt

Fuziunea senzorului giroscopic și accelerometrului După ce am studiat caracteristicile atât giroscopului, cât și accelerometrului, știm că acestea au punctele lor forte și punctele slabe. Unghiul de înclinare calculat din datele accelerometrului are un timp de răspuns lent, în timp ce unghiul de înclinare integrat din datele giroscopice este supus la deriva pe o perioadă de timp. Cu alte cuvinte, putem spune că datele accelerometrului sunt utile pe termen lung, în timp ce datele giroscopice sunt utile pe termen scurt.

Link pentru o mai bună înțelegere: Faceți clic aici