Robot di autobilanciamento fai-da-te utilizzando arduino

Dopo essere stato ispirato dai motori RYNO e da altri scooter autobilanciati di Segway, ho sempre voluto costruire qualcosa con il mio Arduino Segway Robot. Pensandoci un po ', ho deciso di costruire un robot autobilanciato usando Arduino. In questo modo sarei in grado di cogliere il concetto alla base di tutti questi scooter e anche di imparare come funziona l' algoritmo PID.

Una volta che ho iniziato a costruire, mi sono reso conto che questo bot è un po 'una sfida da costruire. Ci sono così tante opzioni tra cui scegliere e quindi le confusioni iniziano proprio dalla selezione dei motori e rimangono fino all'ottimizzazione dei valori PID. E ci sono così tante cose da considerare come il tipo di batteria, la posizione della batteria, la presa della ruota, il tipo di driver del motore, il mantenimento del CoG (centro di gravità) e molto altro.

Ma lascia che te lo spieghi, una volta costruito sarai d'accordo che non è così difficile come sembra. Quindi ammettiamolo, in questo tutorial documenterò la mia esperienza nella costruzione del robot autobilanciante. Potresti essere un principiante assoluto che ha appena iniziato o potresti essere arrivato qui dopo una lunga frustrazione per non aver fatto funzionare il tuo bot. Questo posto vuole essere la tua destinazione finale. Quindi iniziamo……

Selezione delle parti per il robot autobilanciante

Prima di dirti tutte le opzioni per la costruzione del bot, lasciami elencare gli elementi che ho usato in questo progetto di robot autobilanciante

Arduino UNO
Motoriduttori CC (colore giallo) - 2No
Modulo driver motore L298N
MPU6050
Un paio di ruote
Batteria agli ioni di litio da 7,4 V.
Cavi di collegamento
Corpo stampato in 3D

Puoi mescolare e scegliere uno qualsiasi dei componenti sopra in base alla disponibilità di creare il tuo kit robot autobilanciante, assicurati solo che i componenti soddisfino i seguenti criteri.

Controller: Il controller che ho usato qui è Arduino UNO, perché perché è semplicemente facile da usare. Puoi anche usare un Arduino Nano o un Arduino mini ma ti consiglio di restare con UNO dato che possiamo programmarlo direttamente senza alcun hardware esterno.

Motori: la migliore scelta di motore che puoi utilizzare per un robot autobilanciato, senza dubbio sarà il motore passo-passo. Ma per mantenere le cose semplici ho usato un motoriduttore DC. Sì, non è obbligatorio avere uno stepper; il bot funziona bene anche con questi motoriduttori DC di colore giallo comunemente disponibili a buon mercato.

Driver del motore: se hai selezionato i motoriduttori CC come il mio, puoi utilizzare il modulo driver L298N come me, o anche un L293D dovrebbe funzionare bene. Ulteriori informazioni sul controllo del motore CC utilizzando L293D e Arduino.

Ruote: non sottovalutare questi ragazzi; Ho avuto difficoltà a capire che il problema era con le mie ruote. Quindi assicurati che le tue ruote abbiano una buona presa sul pavimento che stai usando. Guarda attentamente, la tua presa non dovrebbe mai permettere alle tue ruote di pattinare sul pavimento.

Accelerometro e giroscopio: la scelta migliore di accelerometro e giroscopio per il tuo bot sarà l'MPU6050. Quindi non tentare di crearne uno con un normale accelerometro come ADXL345 o qualcosa del genere, semplicemente non funzionerà. Saprai perché alla fine di questo articolo. Puoi anche consultare il nostro articolo dedicato sull'utilizzo di MPU6050 con Arduino.

Batteria: abbiamo bisogno di una batteria il più leggera possibile e la tensione operativa dovrebbe essere superiore a 5 V in modo da poter alimentare direttamente il nostro Arduino senza un modulo boost. Quindi la scelta ideale sarà una batteria ai polimeri di litio da 7,4 V. Qui, poiché avevo una batteria agli ioni di litio da 7,4 V prontamente disponibile, l'ho usata. Ma ricorda che una Li-po è vantaggiosa rispetto alla Li-ion.

Chassis: un altro posto dove non dovresti scendere a compromessi è con il telaio del tuo robot. Puoi usare cartone, legno, plastica qualsiasi cosa con cui sei bravo. Ma assicurati solo che il telaio sia robusto e non debba oscillare quando il bot sta cercando di bilanciarsi. Ho progettato dal proprio chassis su Solidworks deducendo dagli altri robot e stampato in 3D. Se hai una stampante, puoi anche stampare il disegno, i file del disegno verranno allegati nell'intestazione successiva.

Stampa 3D e assemblaggio del nostro robot autobilanciato

Se hai deciso di stampare in 3D lo stesso chassis che sto usando per costruire il mio bot, i file STL possono essere scaricati da thingiverse. Ho anche aggiunto i file di progettazione insieme ad esso in modo che tu possa anche modificarlo secondo le tue preferenze personali.

Le parti non hanno strutture sporgenti, quindi puoi stamparle facilmente senza supporti e un riempimento del 25% funzionerà bene. I design sono piuttosto semplici e qualsiasi stampante di base dovrebbe essere in grado di gestirlo con facilità. Ho usato il software Cura per tagliare il modello e stampato usando la mia tarantola Tevo, le impostazioni sono mostrate di seguito.

Dovresti stampare la parte del corpo e quattro parti di montaggio del motore. L'assemblaggio è piuttosto semplice; utilizzare dadi e bulloni da 3 mm per fissare il motore e le schede in posizione. Dopo l'assemblaggio dovrebbe assomigliare a questo mostrato nell'immagine qui sotto.

Il design effettivo è stato pianificato con il modulo di azionamento L298N nel rack inferiore, l'Arduino e la batteria sopra come mostrato sopra. Se stai seguendo lo stesso ordine puoi avvitare direttamente la scheda attraverso i fori forniti e utilizzare una targhetta per la batteria Li-po. Anche questa disposizione dovrebbe funzionare, ad eccezione delle ruote super piane che ho dovuto cambiare in seguito.

Nel mio bot ho scambiato la posizione della batteria e della scheda Arduino UNO per facilitare la programmazione e ho anche dovuto introdurre una scheda perf per completare le connessioni. Quindi il mio bot non sembrava come avevo pianificato nella fase iniziale. Dopo aver completato il test di programmazione del cablaggio e tutto il resto, il mio robot a due ruote finalmente appare così

Schema elettrico

Effettuare i collegamenti per questo robot di bilanciamento automatico basato su Arduino è piuttosto semplice. Questo è un robot autobilanciante che utilizza Arduino e MPU6050, quindi dobbiamo interfacciare l'MPU6050 con Arduino e collegare i motori tramite il modulo driver del motore. L'intero set-up è alimentato dalla batteria agli ioni di litio da 7,4 V. Lo schema del circuito per lo stesso è mostrato di seguito.

Il modulo driver del motore Arduino e L298N è alimentato direttamente rispettivamente tramite il pin Vin e il terminale 12V. Il regolatore di bordo sulla scheda Arduino convertirà l'ingresso da 7,4 V a 5 V e l'IC ATmega e l'MPU6050 saranno alimentati da esso. I motori DC possono funzionare da una tensione di 5V a 12V. Ma collegheremo il cavo positivo da 7,4 V dalla batteria al terminale di ingresso da 12 V del modulo driver del motore. Questo farà funzionare i motori con 7.4V. La tabella seguente elencherà come il modulo driver del motore MPU6050 e L298N è collegato ad Arduino.

Pin componente	Pin di Arduino
MPU6050
Vcc	+ 5V
Terra	Gnd
SCL	A5
SDA	A4
INT	D2
L298N
IN 1	D6
IN 2	D9
IN3	D10
IN4	D11

L'MPU6050 comunica con Arduino tramite l'interfaccia I2C, quindi utilizziamo i pin SPI A4 e A5 di Arduino. I motori DC sono collegati rispettivamente ai pin PWM D6, D9 D10 e D11. Dobbiamo collegarli ai pin PWM perché controlleremo la velocità del motore CC variando il ciclo di lavoro dei segnali PWM. Se non si ha familiarità con questi due componenti, si consiglia di leggere il tutorial sull'interfaccia MPU6050 e sul driver del motore L298N.

Codice robot autobilanciante

Ora dobbiamo programmare la nostra scheda Arduino UNO per bilanciare il robot. È qui che avviene tutta la magia; il concetto alla base è semplice. Dobbiamo controllare se il bot è inclinato in avanti o indietro utilizzando l'MPU6050 e poi se è inclinato in avanti dobbiamo ruotare le ruote in avanti e se è inclinato indietro dobbiamo ruotare le ruote nella direzione opposta.

Allo stesso tempo dobbiamo anche controllare la velocità di rotazione delle ruote, se il bot è leggermente disorientato dalla posizione centrale le ruote ruotano lentamente e la velocità aumenta man mano che si allontana dalla posizione centrale. Per ottenere questa logica utilizziamo l'algoritmo PID, che ha come set-point la posizione centrale e come uscita il livello di disorientamento.

Per conoscere la posizione attuale del bot utilizziamo l' MPU6050, che è un accelerometro a 6 assi e un sensore giroscopico combinato. Per ottenere un valore di posizione affidabile dal sensore è necessario utilizzare il valore sia dell'accelerometro che del giroscopio, perché i valori dell'accelerometro hanno problemi di rumore ei valori del giroscopio tendono a variare nel tempo. Quindi dobbiamo combinare entrambi e ottenere il valore di imbardata e rollio del nostro robot, di cui useremo solo il valore di imbardata.

Suona un po 'di testa che gira, giusto? Ma non preoccuparti, grazie alla community di Arduino abbiamo librerie prontamente disponibili che possono eseguire il calcolo del PID e ottenere anche il valore di imbardata dall'MPU6050. La libreria è sviluppata rispettivamente da br3ttb e jrowberg. Prima di procedere, scarica le loro librerie dal seguente link e aggiungile alla tua directory lib di Arduino.

github.com/br3ttb/Arduino-PID-Library/blob/master/PID_v1.h

github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Ora che abbiamo le librerie aggiunte al nostro IDE Arduino. Iniziamo a programmare per il nostro robot autobilanciante. Come sempre il codice completo per il robot di bilanciamento MPU6050 è fornito alla fine di questa pagina, qui sto solo spiegando i frammenti più importanti del codice. Come detto in precedenza, il codice è basato sul codice di esempio MPU6050, ottimizzeremo il codice per il nostro scopo e aggiungeremo il PID e la tecnica di controllo per il nostro robot autobilanciante.

Per prima cosa includiamo le librerie necessarie per il funzionamento di questo programma. Includono la libreria I2C incorporata, la libreria PID e la libreria MPU6050 che abbiamo appena scaricato.

#include "I2Cdev.h" #include // Da #include "MPU6050_6Axis_MotionApps20.h" //https://github.com/jrowberg/i2cdevlib/tree/master/Arduino/MPU6050

Quindi dichiariamo le variabili necessarie per ottenere i dati dal sensore MPU6050. Leggiamo sia il vettore di gravità che i valori di quaternione e quindi calcoliamo il valore di beccheggio e rollio dell'imbardata del bot. L' array float ypr conterrà il risultato finale.

// Controllo / stato della MPU vars bool dmpReady = false; // imposta vero se DMP init ha avuto successo uint8_t mpuIntStatus; // contiene il byte di stato dell'interrupt effettivo da MPU uint8_t devStatus; // restituisce lo stato dopo ogni operazione del dispositivo (0 = riuscita ,! 0 = errore) uint16_t packetSize; // dimensione prevista del pacchetto DMP (il valore predefinito è 42 byte) uint16_t fifoCount; // conteggio di tutti i byte attualmente in FIFO uint8_t fifoBuffer; // Buffer di memorizzazione FIFO // orientamento / movimento vars Quaternion q; // contenitore di quaternioni VectorFloat gravity; // gravity vector float ypr; // contenitore di imbardata / beccheggio / rollio e vettore di gravità

Poi viene il segmento molto importante del codice, ed è qui che trascorrerai molto tempo a sintonizzarti per il giusto insieme di valori. Se il tuo robot è costruito con un baricentro molto buono ei componenti sono disposti simmetricamente (cosa che nella maggior parte dei casi non lo è), il valore del tuo setpoint sarà 180. Altrimenti collega il tuo bot al monitor seriale di Arduino e inclinalo fino a trovi una buona posizione di bilanciamento, leggi il valore visualizzato sul monitor seriale e questo è il tuo valore di set point. Il valore di Kp, Kd e Ki deve essere regolato in base al tuo bot. Non esistono due bot identici che avranno gli stessi valori di Kp, Kd e Ki, quindi non c'è modo di sfuggirli. Guarda il video alla fine di questa pagina per avere un'idea di come regolare questi valori.

/ ********* Regola questi 4 valori per il tuo BOT ********* / double setpoint = 176; // imposta il valore quando il bot è perpendicolare al suolo utilizzando il monitor seriale. // Leggi la documentazione del progetto su circuitdigest.com per sapere come impostare questi valori double Kp = 21; // Imposta questo primo doppio Kd = 0,8; // Imposta questo secondo doppio Ki = 140; // Infine imposta questo / ****** Impostazione di fine valori ********* /

Nella riga successiva inizializziamo l'algoritmo PID passando le variabili di ingresso input, output, set point, Kp, Ki e Kd. Di questi abbiamo già impostato i valori di set-point Kp, Ki e Kd nello snippet di codice sopra. Il valore dell'ingresso sarà il valore corrente dell'imbardata che viene letto dal sensore MPU6050 e il valore dell'uscita sarà il valore calcolato dall'algoritmo PID. Quindi fondamentalmente l'algoritmo PID ci fornirà un valore di uscita che dovrebbe essere utilizzato per correggere il valore di ingresso in modo che sia vicino al set point.

PID pid (& input, & output, & setpoint, Kp, Ki, Kd, DIRECT);

All'interno della funzione di configurazione del vuoto inizializziamo l'MPU6050 configurando il DMP (Digital Motion Processor). Questo ci aiuterà a combinare i dati dell'accelerometro con i dati del giroscopio e fornirà un valore affidabile di imbardata, beccheggio e rollio. Non approfondiremo questo argomento poiché andrà ben oltre l'argomento. Comunque un segmento di codice che devi cercare nella funzione di setup sono i valori di offset del giroscopio. Ogni sensore MPU6050 ha i suoi valori di offset, puoi usare questo schizzo di Arduino per calcolare il valore di offset del tuo sensore e aggiornare le seguenti linee di conseguenza nel tuo programma.

// fornisci qui i tuoi offset giroscopici, scalati per la sensibilità minima mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1688);

Dobbiamo anche inizializzare i pin PWM digitale che stiamo utilizzando per collegare i nostri motori. Nel nostro caso è D6, D9, D10 e D11. Quindi inizializziamo questi pin poiché i pin di output li rendono BASSI per impostazione predefinita.

// Inizializzazione Motor outpu perni pinMode (6, OUTPUT); pinMode (9, OUTPUT); pinMode (10, OUTPUT); pinMode (11, OUTPUT); // Di default spegne entrambi i motori analogWrite (6, LOW); analogWrite (9, LOW); analogWrite (10, LOW); analogWrite (11, LOW);

All'interno della funzione main loop controlliamo se i dati dell'MPU6050 sono pronti per essere letti. Se sì, lo usiamo per calcolare il valore PID e quindi visualizzare il valore di ingresso e uscita del PID sul monitor seriale solo per verificare come risponde il PID. Quindi in base al valore dell'output decidiamo se il bot deve spostarsi avanti o indietro o stare fermo.

Dal momento che si presume che l'MPU6050 restituirà 180 quando il bot è in posizione verticale. Otterremo valori di correzione positivi quando il bot sta cadendo in avanti e otterremo valori negativi se il bot sta cadendo indietro. Quindi controlliamo questa condizione e chiamiamo le funzioni appropriate per spostare il bot in avanti o indietro.

while (! mpuInterrupt && fifoCount <packetSize) { // nessun dato mpu - esecuzione di calcoli PID e output ai motori pid.Compute (); // Stampa il valore di Input e Output sul monitor seriale per verificare come funziona. Serial.print (input); Serial.print ("=>"); Serial.println (output); if (input> 150 && input <200) {// Se il Bot sta cadendo if (output> 0) // Cadendo in avanti Forward (); // Ruota le ruote in avanti else if (output <0) // Cadendo indietro Reverse (); // Ruota le ruote all'indietro } else // Se il Bot non cade Stop (); // Tieni ferme le ruote }

La variabile di uscita PID decide anche la velocità di rotazione del motore. Se il bot sta per cadere, apportiamo una piccola correzione ruotando lentamente la ruota. Se queste piccole correzioni funzionano e ancora se il bot sta cadendo, aumentiamo la velocità del motore. Il valore della velocità di rotazione delle ruote sarà deciso dall'algoritmo PI. Nota che per la funzione Reverse abbiamo moltiplicato il valore dell'output per -1 in modo da poter convertire il valore negativo in positivo.

void Forward () // Codice per ruotare la ruota in avanti { analogWrite (6, output); analogWrite (9,0); analogWrite (10, output); analogWrite (11,0); Serial.print ("F"); // Informazioni di debug } void Reverse () // Codice per ruotare la rotella Indietro { analogWrite (6,0); analogWrite (9, output * -1); analogWrite (10,0); analogWrite (11, output * -1); Serial.print ("R"); } void Stop () // Codice per fermare entrambe le ruote { analogWrite (6,0); analogWrite (9,0); analogWrite (10,0); analogWrite (11,0); Serial.print ("S"); }

Funzionamento di Arduino Self Balancing Robot

Una volta che sei pronto con l'hardware, puoi caricare il codice sulla tua scheda Arduino. Assicurati che i collegamenti siano corretti poiché stiamo usando una batteria agli ioni di litio è necessaria estrema cautela. Quindi ricontrolla i cortocircuiti e assicurati che i terminali non entrino in contatto anche se il tuo bot subisce alcuni piccoli impatti. Accendi il tuo modulo e apri il tuo monitor seriale, se il tuo Arduino può comunicare con MPU6050 correttamente e se tutto funziona come previsto dovresti vedere la seguente schermata.

Qui vediamo i valori di input e output dell'algoritmo PID nel formato input => output . Se il bot è perfettamente bilanciato il valore dell'output sarà 0. Il valore di ingresso è il valore corrente dal sensore MPU6050. L'alfabeto "F" rappresenta che il bot si sta muovendo in avanti e "R" rappresenta che il bot al contrario.

Durante le fasi iniziali del PID ti consiglio di lasciare il tuo cavo Arduino collegato al bot in modo da poter monitorare facilmente i valori di input e output e inoltre sarà facile correggere e caricare il tuo programma per i valori Kp, Ki e Kd. Il video qui sotto mostra il funzionamento completo del bot e mostra anche come correggere i valori PID.

Spero che questo aiuti a costruire il tuo robot autobilanciante se hai qualche problema a farlo funzionare, quindi lascia le tue domande nella sezione commenti qui sotto o usa i forum per domande più tecniche. Se vuoi divertirti di più, puoi anche usare la stessa logica per costruire un robot di bilanciamento della palla.