Rpibot - Informazioni sull'apprendimento della robotica: 9 passaggi

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

Sono un ingegnere di software embedded in un'azienda automobilistica tedesca. Ho iniziato questo progetto come piattaforma di apprendimento per sistemi embedded. Il progetto è stato cancellato in anticipo ma mi è piaciuto così tanto che ho continuato nel tempo libero. Questo è il risultato…

Avevo i seguenti requisiti:

• Hardware semplice (l'obiettivo è il software)
• Hardware economico (circa 100€)
• Espandibile (alcune opzioni fanno già parte della descrizione)
• Tensione di alimentazione per tutti i componenti da un'unica sorgente 5V (powerbank)

Non c'era davvero un obiettivo a parte l'apprendimento. La piattaforma può essere utilizzata per l'apprendimento, la sorveglianza, i concorsi robotici, …

Non è un tutorial per principianti. Hai bisogno di alcune conoscenze di base su:

• Programmazione (Python)
• Elettronica di base (per collegare tra loro i moduli con la giusta tensione)
• Teoria del controllo di base (PID)

Alla fine probabilmente affronterai problemi come ho fatto io. Con un po' di curiosità e resistenza, affronterai il progetto e risolverai le sfide. Il mio codice è il più semplice possibile e le righe di codice critiche sono commentate per dare suggerimenti.

Il codice sorgente completo e i file sono disponibili qui:

Forniture:

Meccanica

• 1x pannello in compensato (formato A4, spessore 4 mm)
• 3x M4 x 80 Vite e dado
• 2x Motoriduttori con albero di uscita secondario per encoder. Ruote.
• 1x ruota libera

1x montaggio telecamera pan e tilt (opzionale)

Elettronica

• 1x Raspberry Pi Zero con intestazione e fotocamera
• 1x servocomando PCA 9685
• 2x ruota e circuito encoder ottico
• 1x cavi per ponticelli femmina
• 1x power bank USB
• 1x driver a doppio motore DRV8833
• 2x Micro servi SG90 per panoramica e inclinazione della fotocamera (opzionale)
• 1x MPU9250 IMU (opzionale)
• 1x sensore di distanza ad ultrasuoni HC-SR04 (opzionale)
• 1x scheda perforata e filo di saldatura, intestazioni, …

Passaggio 1: costruisci il telaio

Non sono un buon progettista meccanico. Anche l'obiettivo del progetto non è passare troppo tempo nel telaio. Comunque ho definito i seguenti requisiti:

• Materiali economici
• Montaggio e smontaggio rapido
• Espandibile (es. spazio per sensori aggiunti)
• Materiali leggeri per risparmiare energia per l'elettronica

Un telaio semplice ed economico può essere realizzato in compensato. È facile da lavorare con un seghetto e un trapano a mano. Puoi incollare piccole parti in legno per creare gli alloggiamenti per sensori e motori.

Pensa alla sostituzione dei componenti difettosi o al debug elettrico. Le parti principali devono essere fissate con viti per essere sostituibili. Una pistola per colla a caldo può essere semplice, ma probabilmente non è il modo migliore per costruire un telaio… Ho avuto bisogno di molto tempo per pensare a un concetto semplice per smontare facilmente le parti. La stampa 3D è una buona alternativa, ma può essere piuttosto costosa o richiedere molto tempo.

La ruota libera è finalmente molto leggera e facile da montare. Le alternative erano tutte pesanti o piene di attrito (ne ho provate un paio prima di trovare quella definitiva). Ho dovuto solo tagliare un distanziale di legno per livellare la ruota libera di coda dopo aver montato le ruote principali.

Proprietà della ruota (per calcoli software)

Circonferenza: 21, 5 cm Impulsi: 20 impulsi/giro. Risoluzione: 1, 075 cm (finalmente 1 impulso è di circa 1 cm, il che è facile per i calcoli del software)

Passaggio 2: elettronica e cablaggio

Il progetto utilizza diversi moduli come mostrato nel diagramma.

Il Raspberry Pi Zero è il controller principale. Sta leggendo i sensori e controllando i motori tramite un segnale PWM. È collegato a un PC remoto tramite wifi.

Il DRV8833 è un ponte H a doppio motore. Fornisce la corrente sufficiente ai motori (cosa che il Raspberry Pi non può fare poiché le uscite possono fornire solo alcuni mA).

L'encoder ottico fornisce un segnale di forma quadrata ogni volta che la luce passa attraverso le ruote dell'encoder. Useremo gli interrupt HW del Raspberry Pi per ottenere le informazioni ogni volta che il segnale cambia.

Il pca9695 è una scheda di controllo servo. Sta comunicando tramite un bus seriale I2C. Questa scheda fornisce i segnali PWM e la tensione di alimentazione che controllano i servi per la panoramica e l'inclinazione della camma.

L'MPU9265 è un sensore di accelerazione a 3 assi, velocità di rotazione angolare a 3 assi e sensore di flusso magnetico a 3 assi. Lo useremo principalmente per ottenere la direzione della bussola.

I diversi moduli sono tutti collegati tra loro tramite ponticello. Una breadboard funge da dispatcher e fornisce tensioni di alimentazione (5 V e 3,3 V) e massa. I collegamenti sono tutti descritti nella tabella dei collegamenti (vedi allegato). Il collegamento di 5 V a un ingresso da 3,3 V probabilmente distruggerà il tuo chip. Fare attenzione e controllare due volte tutti i cablaggi prima di fornire (in particolare in questo caso è necessario considerare l'encoder). È necessario misurare le tensioni di alimentazione principali sulla scheda di spedizione con un multimetro prima di collegare tutte le schede. I moduli sono stati fissati con viti in nylon nel telaio. Anche qui sono stato felice di averli riparati ma anche smontabili in caso di malfunzionamento.

L'unica saldatura è stata infine i motori, la breadboard e le intestazioni. Ad essere onesti, mi piacciono i cavi dei ponticelli, ma possono portare a una connessione allentata. In alcune situazioni, alcuni monitoraggi software possono aiutarti nell'analisi delle connessioni.

Passaggio 3: infrastruttura software

Dopo aver raggiunto la meccanica, imposteremo alcune infrastrutture software per avere condizioni di sviluppo confortevoli.

Idiota

Questo è un sistema di controllo della versione gratuito e open source. Viene utilizzato per gestire progetti di grandi dimensioni come Linux, ma può essere facilmente utilizzato anche per piccoli progetti (vedi Github e Bitbucket).

Le modifiche al progetto possono essere tracciate localmente e anche inviate a un server remoto per condividere il software con la comunità.

I principali comandi utilizzati sono:

git clone https://github.com/makerobotics/RPIbot.git [Ottieni il codice sorgente e la configurazione git]

git pull origin master [ottieni le ultime dal repository remoto]

git status [ottieni lo stato del repository locale. Ci sono file modificati?] git log [ottieni l'elenco dei commit] git add. [aggiungi tutti i file modificati allo stage da considerare per il prossimo commit] git commit -m "comment for commit" [commit le modifiche al repository locale]git push origin master [spingi tutti i commit al repository remoto]

Registrazione

Python fornisce alcune funzioni di registrazione integrate. La struttura del software dovrebbe definire già tutto il framework di logging prima di iniziare un ulteriore sviluppo.

Il logger può essere configurato per accedere con un formato definito nel terminale o in un file di registro. Nel nostro esempio, il logger è configurato dalla classe webserver ma potremmo anche farlo da soli. Qui impostiamo solo il livello di registrazione su DEBUG:

logger = logging.getLogger(_name_)

logger.setLevel(logging. DEBUG)

Misurazione e tracciatura

Per analizzare i segnali nel tempo, la cosa migliore è tracciarli in un grafico. Poiché il Raspberry Pi ha solo un terminale di console, tracceremo i dati in un file CSV separato da punto e virgola e li tracceremo dal PC remoto.

Il file di traccia separato da punto e virgola è generato dal nostro codice Python principale e deve avere intestazioni come questa:

timestamp;yawCorr;encoderR;I_L;odoDistance;ax;encoderL;I_R;yaw;eSpeedR;eSpeedL;pwmL;speedL;CycleTimeControl;wz;pwmR;speedR;Iyaw;hdg;m_y;m_x;eYaw;cycleTimeSense;

1603466959.65;0;0;25;0.0;-0.02685546875;0;25;0;25;25;52;0.0;23;0.221252441406;16;0.0;0;252.069366413;-5.19555664062;-16.0563964844;0;6; 1603466959.71;0;0;50;0.0;0.29150390625;0;50;0;25;25;55;0.0;57;-8.53729248047;53;0.0;0;253.562118111;-5.04602050781;-17.1031494141;0;6; 1603466959.76;0;-1;75;0.0;-0.188232421875;1;75;2;25;25;57;0;52;-24.1851806641;55;0;0;251.433794171;-5.64416503906;-16.8040771484;2;7;

La prima colonna contiene il timestamp. Le seguenti colonne sono libere. Lo script di stampa viene chiamato con un elenco di colonne da tracciare:

remote@pc:~/python rpibot_plotter -f trace.csv -p speedL, speedR, pwmL, pwmR

Lo script della trama è disponibile nella cartella degli strumenti:

Il plotter sta usando matplotlib in Python. Devi copiarlo nel tuo PC.

Per maggiore comodità, lo script python viene chiamato da uno script bash (plot.sh) che viene utilizzato per copiare il file di traccia Raspberry Pi sul PC remoto e chiamare il plotter con una selezione del segnale. Lo script bash "plot.sh" chiede se il file deve essere copiato. Questo era più conveniente per me invece di copiare manualmente ogni volta. "sshpass" viene utilizzato per copiare il file dal Raspberry Pi al PC remoto tramite scp. È in grado di copiare un file senza chiedere la password (viene passato come parametro).

Infine si apre una finestra con il grafico come mostrato in figura.

Comunicazione remota

L'interfaccia di sviluppo per Raspberry Pi è SSH. I file possono essere modificati direttamente sul target o copiati da scp.

Per controllare il robot, sul Pi è in esecuzione un server Web che fornisce il controllo tramite Websocket. Questa interfaccia è descritta nel passaggio successivo.

Configura il Raspberry Pi

C'è un file che descrive l'installazione del Raspberry Pi nella cartella "doc" del codice sorgente (setup_rpi.txt). Non ci sono molte spiegazioni ma molti comandi e collegamenti utili.

Passaggio 4: l'interfaccia utente

Usiamo il leggero server web Tornado per ospitare l'interfaccia utente. È un modulo Python che chiamiamo quando avviamo il software di controllo del robot.

Architettura software

L'interfaccia utente è composta dai seguenti file:gui.html [Descrizione dei controlli e del layout della pagina web] gui.js [Contiene il codice javascript per gestire i controlli e aprire una connessione websocket al nostro robot] gui.css [Contiene gli stili di i controlli html. Le posizioni dei comandi sono definite qui]

La comunicazione websocket

L'interfaccia utente non è delle più belle, ma sta facendo il suo lavoro. Mi sono concentrato qui su tecnologie che erano nuove per me come Websockets.

Il sito web sta comunicando con il server web del robot da Websockets. Questo è un canale di comunicazione bidirezionale che rimarrà aperto quando la connessione è stata avviata. Inviamo i comandi del robot tramite Websocket al Raspberry Pi e riceviamo informazioni (velocità, posizione, flusso della telecamera) per la visualizzazione.

Il layout dell'interfaccia

L'interfaccia utente ha un input manuale per i comandi. Questo è stato utilizzato all'inizio per inviare comandi al robot. Una casella di controllo attiva e disattiva il flusso della telecamera. I due cursori controllano la panoramica e l'inclinazione della telecamera. La parte in alto a destra dell'interfaccia utente controlla il movimento del robot. È possibile controllare la velocità e la distanza target. Le informazioni di telemetria di base vengono visualizzate nel disegno del robot.

Passaggio 5: programmazione della piattaforma del robot

Questa parte era l'obiettivo principale del progetto. Ho rifattorizzato gran parte del software quando ho introdotto il nuovo chassis con i motori DC. Ho usato Python come linguaggio di programmazione per diversi motivi:

• È la lingua principale di Raspberry Pi
• È un linguaggio di alto livello con molte funzionalità ed estensioni integrate
• È orientato agli oggetti ma può essere utilizzato anche per la programmazione sequenziale
• Nessuna compilazione o catena di strumenti necessaria. Modifica il codice ed eseguilo.

Architettura software principale

Il software è orientato agli oggetti, suddiviso in pochi oggetti. La mia idea era di dividere il codice in 3 blocchi funzionali:

Senso Pensa Attuare

Sense.py

Acquisizione ed elaborazione del sensore principale. I dati vengono memorizzati in un dizionario da utilizzare nella fase successiva.

Controllo.py

Una sottoclasse di attuazione controlla i motori ei servi dopo un po' di astrazione. L'oggetto Control principale gestisce i comandi di alto livello e anche gli algoritmi di controllo (PID) per il motore.

rpibot.py

Questo oggetto principale è la gestione del server web Tornado e l'istanziazione delle classi sense e control in thread separati.

Ogni modulo può essere eseguito da solo o come parte dell'intero progetto. È possibile solo rilevare e stampare le informazioni del sensore per verificare che i sensori siano collegati correttamente e forniscano le informazioni corrette.

Il controllo PID

Il primo compito è scoprire cosa vogliamo controllare. Ho iniziato cercando di controllare la posizione, che era molto complessa e non aiutava molto.

Infine, vogliamo controllare la velocità di ciascuna ruota e anche la direzione del robot. Per farlo dobbiamo mettere in cascata due logiche di controllo.

Per aumentare la complessità passo dopo passo, il robot dovrebbe essere controllato:

anello aperto (a potenza costante)

pwm = K

quindi aggiungi l'algoritmo del ciclo chiuso

pwm = Kp.speedError+Ki. Integration(speedError)

e infine aggiungi il controllo della direzione come ultimo passaggio.

Per il controllo della velocità ho usato un controllo "PI" e "P" solo per l'imbardata. Ho impostato manualmente i parametri sperimentando. Probabilmente qui potrebbero essere usati parametri molto migliori. Il mio obiettivo era solo una linea retta e l'ho quasi ottenuto. Ho creato un'interfaccia nel software per scrivere alcune variabili dall'interfaccia utente. L'impostazione del parametro Kp su 1.0 richiede il seguente comando nell'interfaccia utente:

IMPOSTA;Kp;1.0

Potrei impostare il parametro P appena abbastanza basso da evitare qualsiasi overshot. L'errore residuo viene corretto dal parametro I (errore integrato)

È stato difficile per me scoprire come collegare a cascata entrambi i controlli. La soluzione è semplice, ma ho provato molti altri modi prima… Quindi, alla fine, ho cambiato l'obiettivo di velocità delle ruote per girare in una o nell'altra direzione. Modificare direttamente l'uscita del controllo della velocità è stato un errore poiché il controllo della velocità stava cercando di rimuovere questa perturbazione.

In allegato lo schema di controllo utilizzato. Mostra solo il lato sinistro del controllo del robot.

Passaggio 6: le calibrazioni del sensore

La prima cosa da considerare è che l'intera IMU deve funzionare correttamente. Ho ordinato 3 parti e le ho rispedite fino a quando non ho avuto un sensore completamente funzionante. Ogni sensore precedente aveva alcune parti del sensore che non funzionavano correttamente o non funzionavano affatto. Ho usato alcuni script di esempio per testare le basi prima di montarlo nel robot.

I segnali del sensore IMU devono essere calibrati prima di utilizzarlo. Alcuni segnali del sensore dipendono dall'angolo e dalla posizione di montaggio.

Le tarature di accelerazione e velocità di rotazione

La calibrazione più semplice è per l'accelerazione longitudinale (A_x). Da fermo dovrebbe esserci circa 0 m/s². Se si ruota correttamente il sensore, è possibile misurare la gravità (circa 9, 8 m/s²). Per calibrare a_x, devi solo montarlo correttamente e poi definire l'offset per ottenere 0 m/s² da fermo. Ora A_x è calibrato. Si possono ottenere gli offset per le velocità di rotazione in modo simile da fermo.

La calibrazione del magnetometro per la bussola

Per i sensori di campo magnetico è necessaria una calibrazione più complessa. Useremo m_x e m_y per ottenere il campo magnetico nel livello orizzontale. Avere m_x e m_y ci darà l'opportunità di calcolare una direzione della bussola.

Per il nostro semplice scopo calibreremo solo la deviazione del ferro duro. Questa operazione deve essere eseguita in quanto il sensore si trova nella posizione finale in quanto dipendente dalle perturbazioni del campo magnetico.

Registriamo m_x e m_y mentre giriamo il robot attorno all'asse z. Tracciamo m_x vs m_y in un grafico XY. Il risultato in un'ellissi come mostrato nell'immagine. I puntini di sospensione devono essere centrata sull'origine. Qui consideriamo i valori massimo e minimo di m_x e m_y per ottenere gli offset in entrambe le direzioni. Infine controlliamo la calibrazione e vediamo che l'ellissi è ora centrata.

La calibrazione del ferro dolce significherebbe che cambiamo l'immagine da un'ellissi a un cerchio. Questo può essere fatto aggiungendo un fattore su ciascun valore del sensore.

Ora è possibile codificare una routine di test per ricalibrare o almeno per verificare che i sensori siano ancora calibrati.

La direzione della bussola

I dati del magnetometro verranno ora utilizzati per calcolare la direzione della bussola. Per questo, dobbiamo convertire i segnali m_x e m_y in un angolo. Python fornisce direttamente la funzione math.atan2 che ha questo obiettivo. Il calcolo completo è definito nel file mpu9250_i2c.py ("calcHeading(mx, my, mz)").

Passaggio 7: design alternativi

Il progetto ha richiesto molto tempo poiché il design era completamente aperto. Per ogni componente ho realizzato alcune implementazioni prototipali e sperimentato i limiti del sistema.

L'argomento più complesso è stato l'encoder della ruota. Ho testato 3 diverse opzioni prima di trovare l'encoder ottico attualmente in uso. Penso che anche le soluzioni abortite siano molto interessanti in un progetto del genere. Riguarda le parti dove ho imparato di più.

Servo a rotazione continua collegato a pca 9695

Per evitare un ponte H aggiuntivo per un motore DC, ho iniziato con i servi a rotazione continua. Questi sono stati guidati dal già presente servo driver pca 9695. Tutta la meccanica di propulsione e la relativa elettronica erano molto più semplici. Questo design presentava due inconvenienti:

• La scarsa gamma di controllo dei servi.
• La posizione di mantenimento dell'encoder mancante

I servi iniziano a muoversi con il 50% di pwm e hanno la massima velocità a circa il 55%. Questo è un intervallo di controllo molto scarso.

Senza un codificatore, era molto difficile trovare un codificatore pronto all'uso. Ho testato 3 diversi encoder di riflettanza che erano montati sul telaio. Ho registrato una ruota encoder fatta da me all'esterno della ruota con sezioni in bianco e nero. Ho usato i sensori QTR-1RC che richiedono molta elaborazione del segnale per ottenere il segnale giusto. Il Raspberry Pi non è stato in grado di eseguire quel tipo di elaborazione in tempo reale. Così ho deciso di aggiungere un NodeMCU D1 mini come controller in tempo reale al robot. È stato collegato al Raspberry Pi dall'UART seriale per fornire i dati del sensore elaborati. Il NodeMCU gestiva anche il sensore HC-SR04. La meccanica era difficile e poco robusta, la linea seriale riceveva rumore dalla linea I2C e dai motori, quindi alla fine ho costruito la seconda versione del telaio con semplici motoriduttori DC azionati da un ponte ad H. Questi motori hanno un albero di uscita secondario per posizionare un encoder ottico.

Passaggio 8: elaborazione delle immagini

Per migliorare la guida autonoma, possiamo fare qualche elaborazione delle immagini.

La libreria opencv è un riferimento per questo. Può essere utilizzato da Python per implementare rapidamente il rilevamento degli ostacoli.

Catturiamo un'immagine e applichiamo alcune attività di elaborazione delle immagini:

I primi test sono stati fatti con le trasformazioni di Canny e Sobel. Canny può essere un buon candidato, ma non è abbastanza ragionevole. Sobel è troppo sensibile (troppi oggetti rilevati).

Alla fine ho creato il mio filtro per mescolare tutti i gradienti orizzontali e verticali (rileva i mobili):

• Trasforma l'immagine a colori in un'immagine a livello di grigio
• Sfoca l'immagine per rimuovere piccoli disturbi
• Limita l'immagine a un'immagine in bianco e nero
• Ora rileviamo gradienti orizzontali e verticali per rilevare oggetti come pareti e mobili
• Filtriamo solo i contorni grandi rimanenti (vedi contorni colorati nell'immagine)

Ora possiamo usare queste nuove informazioni per rilevare gli ostacoli…

Passaggio 9: passaggi successivi…

Ora abbiamo una semplice piattaforma robotica con sensori, attuatori e una telecamera. Il mio obiettivo è muovermi in autonomia e tornare in stazione senza aggiungere altri sensori. Per questo avrò bisogno dei seguenti passaggi:

• Fusione dei sensori di imbardata e segnali di rotta magnetici
• Elaborazione delle immagini della fotocamera (solo CPU bassa disponibile per questo)
• Rilevamento delle collisioni (distanza ultrasonica e telecamera)
• Costruzione della mappa o orientamento

Ora vai e crea le tue sfide o obiettivi…