Livella digitale basata su Arduino e MPU6050: 3 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 09:59

Benvenuto nel mio primo istruttore in assoluto! Spero che lo trovi informativo. Non esitate a lasciare un feedback positivo o negativo.

Questo progetto è quello di realizzare una livella digitale basata su arduino e MPU6050. Mentre il design e il codice finiti sono miei, il concetto originale e gran parte del codice su cui ho lavorato non lo sono. Non mi piacciono i plagi, quindi sono più che felice di dare credito a coloro che hanno idee su cui ho costruito. Le 2 persone principali a cui voglio dare un grido sono Paul McWhorter di YouTuber e DroneBot Workshop. Includo i link ad essi nel mio PDF di link utili di YouTube. Grazie anche a EEEnthusiast per il suo video informativo sull'utilizzo dell'MPU6050, inclusa l'impostazione e la lettura dal modulo senza una libreria esterna (il suo collegamento è nello stesso PDF).

Il progetto che ho prodotto, funziona "così com'è" ed è abbastanza accurato, sicuramente fino al 45% in entrambe le direzioni. Puoi usarlo esattamente come l'ho progettato io, oppure puoi personalizzarlo secondo i tuoi gusti. I più astuti noteranno che il mio progetto sembra quasi identico a quello prodotto dall'officina DroneBot, ma state tranquilli, ci sono differenze significative, soprattutto quando si tratta del codice per il calcolo degli angoli, oltre alla possibilità di memorizzare i valori di calibrazione in Eeprom!

Alcune funzioni per stuzzicare l'appetito:

Angoli di beccheggio e rollio disponibili entro 0,1 di grado.

Rilevamento automatico dell'orientamento dell'unità giroscopica (orizzontale o verticale)

Calibrazione completa con risultati memorizzati automaticamente su eeprom

Indicazione LED da -2 a +2 gradi (modificabile nel codice)

Indicazione acustica aggiuntiva del livello (può essere attivata/disattivata al volo)

Curcuit compatto che richiede componenti minimi

Iniziamo.

Forniture

Questo progetto (così com'è) utilizza i seguenti elementi:

1 x Arduino nano (il mio è un clone)

1 x modulo giroscopio/accelerometro MPU6050

1 x LCD - 16 x 2 + connessione I2C

1 x premere per fare l'interruttore

1 x cicalino piezo

1 x LED verde

2 x LED gialli

2 x LED rossi

5 resistenze da 220 ohm

Vari cavi jumper

tagliere

Alimentazione (il mio usava un power bank USB 5v, quando non era collegato al mio PC, ma si poteva usare una batteria opportunamente collegata)

Passaggio 1: il circuito

Supponendo che tu abbia tutti i componenti, dovrai costruire la tua breadboard.

Mostro la mia configurazione come guida, ma le connessioni sono le seguenti:

Il pin D2 di Arduino si collega a 1 lato dell'interruttore a pressione. L'altro lato dell'interruttore a pressione si collega a terra

Il pin D3 di Arduino si collega a 1 lato del resistore da 220 ohm. L'altro lato del resistore si collega all'annode del LED rosso. Il catodo del LED rosso va a massa.

Il pin D4 di Arduino si collega a 1 lato del resistore da 220 ohm. L'altro lato del resistore si collega all'annode del LED giallo. Il catodo del LED giallo va a massa.

Il pin D5 di Arduino si collega a 1 lato del resistore da 220 ohm. L'altro lato del resistore si collega all'annode del LED verde. Il LED del catodo verde va a massa.

Il pin D6 di Arduino si collega a 1 lato del resistore da 220 ohm. L'altro lato del resistore si collega all'annode del LED giallo. Il catodo del LED giallo va a massa.

Il pin D7 di Arduino si collega a 1 lato del resistore da 220 ohm. L'altro lato del resistore si collega all'annode del LED rosso. Il catodo del LED rosso va a massa.

Il pin D8 di Arduino si collega a un lato del cicalino piezoelettrico. L'altro lato del cicalino si collega a terra.

Il pin A4 di Arduino si collega ai pin SDA dell'MPU6050 E dell'LCD.

Il pin A5 di Arduino si collega ai pin SCL sull'MPU6050 E sull'LCD

L'alimentazione 5v e Gnd per MPU6050 e LCD provengono rispettivamente dai pin Arduino Nano 5v e GND.

Una volta completato, dovrebbe essere simile alla mia configurazione mostrata. Ho messo blu tak sotto l'MPU6050 per impedirne il movimento e anche sul display LCD per tenerlo sul bordo della breadboard.

Passaggio 2: il codice

Il codice allegato è il codice che ho usato per questo progetto. L'unica libreria con cui potresti avere problemi è la

Libreria LiquidCrystal_I2C.h poiché l'ho importata quando ho iniziato a lavorare con gli LCD. Sfortunatamente, ci sono alcune librerie che usano la stessa istruzione #include, ma sono leggermente diverse. Se hai problemi con il tuo, trova un altro codice LCD che funzioni per te e modifica il codice di conseguenza. È solo probabile che sia la configurazione che differisce. Tutti i comandi di "stampa" dovrebbero funzionare allo stesso modo.

Tutto il codice è stato commentato e supponendo che l'abbia fatto bene, ci sarà anche un video che spiega tutto, ma qui ci sono alcuni punti da notare:

LiquidCrystal_I2C lcd(0x27, 16, 2);

Il codice sopra è la configurazione per il mio LCD. Se la tua libreria è diversa, potresti dover cambiare non solo la tua libreria, ma anche questa riga.

{ lcd.setCursor(0, 1); lcd.print("Orizzontale!"); orientamento = ORIZZONTALE; //Leggi i dati grezzi acc e gyro dall'MPU-6050 1000 volte per (int cal_int = 0; cal_int < 1000; cal_int ++) { read_mpu_6050_data(); //Aggiungi l'offset gyro x alla variabile gyro_x_cal gyro_x_cal += gyro_x; //Aggiungi l'offset del giroscopio alla variabile gyro_y_cal gyro_y_cal += gyro_y; //Aggiungi l'offset z del giroscopio alla variabile gyro_z_cal gyro_z_cal += gyro_z; //Aggiungi l'offset acc x alla variabile acc_x_cal acc_x_cal += acc_x; //Aggiungi l'offset acc y alla variabile acc_y_cal acc_y_cal += acc_y; } // Divide tutti i risultati per 1000 per ottenere l'offset medio gyro_x_cal /= 1000.0; giroscopio_y_cal /= 1000.0; giroscopio_z_cal /= 1000.0; acc_x_cal /= 1000.0; acc_y_cal /= 1000.0; HorizonalCalibration = 255; eeprom_address = 0; EEPROM.put(eeprom_address, HorizonalCalibration); eeprom_address += sizeof(int); EEPROM.put(eeprom_address, gyro_x_cal); eeprom_address += sizeof(float); EEPROM.put(eeprom_address, gyro_y_cal); eeprom_address += sizeof(float); EEPROM.put(eeprom_address, gyro_z_cal); eeprom_address += sizeof(float); EEPROM.put(eeprom_address, acc_x_cal); eeprom_address += sizeof(float); EEPROM.put(eeprom_address, acc_y_cal); eeprom_address += sizeof(float); //Nota che non stiamo memorizzando un offset per acc_z, a causa della gravità! ritardo (500); }

Il blocco di codice sopra viene eseguito alla routine di calibrazione. Questo codice è per la calibrazione orizzontale. C'è un codice quasi identico per la calibrazione verticale (nota, il codice sa se il tuo MPU6050 è montato orizzontalmente o verticalmente!). MPU6050, viene letto 1000 volte. i valori appropriati vengono sommati cumulativamente, quindi divisi per 1000 per fornire un valore medio di "compensazione". Questi valori vengono poi memorizzati nella Nano eeprom. Tutti i valori di calibrazione orizzontale vengono memorizzati a partire dall'indirizzo eeprom 0. Tutti i valori verticali vengono memorizzati a partire dall'indirizzo eeprom 24. La calibrazione DEVE essere eseguita su una superficie completamente piana, altrimenti non significano nulla.

/* * Le prossime righe elaborano i dati grezzi per cambiarli in angoli che possono essere visualizzati sul display LCD e sui LED. * Il valore di 4096, per il quale sono divisi i dati di accelerazione, è preso dalla scheda tecnica dell'MPU6050 e si basa sulla frequenza di campionamento. * Il valore di 9,8 è gravità * La funzione atan2 proviene dal modulo matematico e viene utilizzata per calcolare gli angoli dai dati forniti */ thetaM =-atan2((acc_x/4096.0)/9.8, (acc_z/4096.0)/9.8) /2/3.141592656 * 360; //Dati grezzi phiM =-atan2((acc_y/4096.0)/9.8, (acc_z/4096.0)/9.8)/2/3.141592656 * 360; //Dati grezzi dt=(millis()-millisOld)/1000.; millisOld=millis(); /* * Questa sezione utilizza i dati del giroscopio per rendere il sistema più reattivo * il valore di 65.5, per il quale sono divisi i dati del giroscopio è preso dal foglio dati dell'MPU6050 e si basa sulla frequenza di campionamento */ theta=(theta+(gyro_y/ 65.5)*dt)*.96 + thetaM*.04; //Filtro passa basso phi=(phi+(gyro_x/65.5)*dt)*.96 + phiM*.04; //Filtro passa basso

Il codice sopra è la roba che calcola gli angoli. Si spera che i commenti forniscano una piccola panoramica di come funziona, ma per una spiegazione approfondita, controlla il video di Paul McWhorters collegato al PDF allegato. Quello che dirò però è che puoi cambiare la frequenza di campionamento per il giroscopio e l'accelerometro (che viene fatto nella subroutine di configurazione MPU6050 nella parte inferiore del mio codice). Se modifichi la frequenza di campionamento, devi anche modificare per quanto i dati grezzi sono divisi. Per i dati dell'accelerometro, il valore corrente è 4096. Per il giroscopio, il valore corrente è 65,5.

Fare riferimento alle schede tecniche allegate e al video di EEEntusiast (link nel PDF allegato) per informazioni più approfondite su come vengono rilevati i valori di campionamento e offset.

Passaggio 3: passaggi successivi

A questo punto si spera di aver realizzato questo progetto, ma adesso?

In primo luogo, perché non trasformarlo in una livella a bolla che puoi usare. Puoi acquistare una livella a bolla economica (assicurati che sia del tipo di scatola) che puoi adattare o, se hai il kit, stampare la tua livella/scatola.

Magari prova con le frequenze di campionamento del giroscopio e dell'accelerometro per vedere se funzionano meglio con una frequenza piuttosto che con un'altra.

Prova a perfezionare ulteriormente il codice. Ad esempio, attualmente, oltre i 45 gradi, l'angolo dichiarato è a dir poco approssimativo. C'è un modo per aggirarlo?

Se hai domande, non importa quanto semplici possano sembrare, chiedi pure. Se posso aiutare, lo farò.

Se ti piace questo tutorial, per favore metti un mi piace, così lo so.

Se lo fai, per favore mostramelo (soprattutto se si tratta di un caso funzionante).

GRAZIE