Coderbot - 856111

Relazione del laboratorio Coderbot, Sabino Paulicelli.

Indice

Introduzione

1. Prepariamo l'ambiente di lavoro
2. Come funziona il motore
3. Come funziona l'encoder
4. Facciamo avanzare il Coderbot
5. Registriamo il movimento
6. La differenza tra le ruote
7. Misuriamo l'avanzamento
8. Misuriamo la velocità
9. Il controllo PID
10. Il Coderbot oscilla, troviamo il Ku
11. Grafico dell'oscillazione
12. Usiamo la formula di Ziegler-Nichols
13. Suddividiamo in threads
14. Scegliamo un algoritmo di scheduling
15. Test finale

Introduzione

Ho strutturato la mia relazione progredendo linearmente con la stesura del codice, e suddiviso i paragrafi secondo le varie fasi dell'apprendimento in laboratorio. Idealmente, leggendo la relazione in modo sequenziale, chiunque dovrebbe essere in grado di riprodurre il lavoro svolto affrontando le stesse problematiche e aggirando allo stesso modo i limiti intrinseci dell'attività.

1 Prepariamo l'ambiente di lavoro

Il laboratorio ha come obiettivo finale il movimento controllato del Coderbot, il robot utilizzato. La libreria usata è pigpio e, per lavorare localmente sul proprio computer, è possibile importarne l'header nella cartella del progetto. La compilazione e il test del software è stato lanciato sempre nel Raspberry Pi che comanda il Coderbot, per non aumentare la complessità dell'ambiente di lavoro. Non ci sono altri requisiti a parte il compiler, l'ultima versione di gcc o clang. I grafici presenti in questo documento sono stati prodotti con gnuplot e con Labplot. Il Coderbot dovrebbe avanzare sempre sullo stesso terreno, altrimenti la differenza nelle misurazioni può essere importante. Inoltre le ruote non dovrebbero mai slittare per troppo tempo.

Considerazioni riguardo l'esperienza pratica

Durante i test svolti a casa, mi sono accorto che il tappeto usato per l'avanzamento del Coderbot generava un attrito importante e non trascurabile sul ruotino sferico di coda. Ho provato a oliare il ruotino senza successo e sono riuscito ad evitare lo slittamento delle ruote e le sterzate casuali solo cambiando l'assetto del Coderbot come in figura, in particolare ho spostato la batteria in corrispondenza dell'asse delle ruote. Questa modifica ha però causato un cambiamento molto evidente nella differenza di giri al secondo delle ruote, a parità di potenza erogata. Ho dovuto alla fine considerare una richiesta di potenza del 2% inferiore sulla ruota di destra. Dopo qualche minuto di utilizzo, la ruota destra richiede invece una potenza del 30% maggiore circa. Con alimentazione a corrente e senza il peso della batteria, questo scarto scende a circa il 10%.

A seguito delle precedenti misurazioni (TODO: RIFARE MISURAZIONI), ho chiesto una sostituzione del Coderbot cb05. Con il nuovo robot (cb02) ho inizialmente ripercorso la prima suite di test, al fine di valutare non solo la velocità delle ruote a PWM 128 (metà potenza) ma anche per valutare un eventuale decadimento asimmetrico nella potenza erogata, similmente a ciò che ho potuto misurare con il precedente robot. Ho deciso di continuare le misurazioni sul tappeto della mia cucina, vinilico e antiscivolo, che garantisce una superficie uniforme e un attrito sulle ruote sufficiente ad assicurare l'assenza di slittamento, a patto che il peso della batteria continui a gravare sull'asse delle ruote.

2 Come funziona motore

3 Come funziona l'encoder

4 Facciamo avanzare il Coderbot

5 Registriamo il movimento

6 La differenza tra le ruote

Iniziati i primi test, è stato subito evidente che tra le ruote c'era una differenza misurabili, in termini circa del 5%. Nelle prime fasi, una volta tenuto conto di questo scarto, non sono necessari altri adattamenti prima delle misurazioni di base. In futuro però potrebbe essere necessario calcolare valori diversi di Ku e Tu per ogni ruota. Ho scelto di effettuare la misurazione di questo scarto su una statistica di 15 corse; siamo molto lontani dai numeri del Teorema del Limite Centrale, ma per un robot che scalda sia i motori che le ruote la varianza introdotta dopo diverse corse aumenta in modo incontrollato.

corsa	ticks_l	ticks_r	mm_percorsi	mm_per_tick	scarto %
1	8123	7970	445	0,055	1,9
2	7499	7168	403	0,055	4,6
3	7721	7537	423	0,055	2,4
4	7711	7503	417	0,055	2,8
5	6937	6823	376	0,055	1,7
6	7559	7557	412	0,055	0,0
7	8056	7823	435	0,055	3,0
8	8320	8474	457	0,054	-1,8
9	8254	8454	454	0,054	-2,4
10	8067	8140	448	0,055	-0,9
11	8203	8060	446	0,055	1,8
12	7996	8110	449	0,056	-1,4
13	8298	8087	446	0,054	2,6
14	8418	8226	459	0,055	2,3
15	8269	8351	458	0,055	-1,0

L'analisi statistica dello scarto percentuale tra le ruote mostra uno sbilanciamento medio dell'1% a favore della ruota destra, con una deviazione standard del 2.1%. La variabilità osservata (circa il doppio) rende inutile compensare in modo fissato e richiede quindi l'adozione di 2 controlli PID indipendenti.

7 Misuriamo l'avanzamento

Emerge in modo chiaro e stabile invece il valore di 0,055 millimetri per tick degli encoders, oppure 91 ticks per 5 mm. Il ciclo while nella funzione runForDistance(mm) conferma ogni misurazione effettuata. Il robot in questa fase non procede su una linea retta, quindi la misurazione deve per forza di cosa essere approssimata e misurata sul centro della parte anteriore del robot. I ticks vengono calcolati in base alla media dei 2 encoders.

    while (((enc_l.ticks + enc_r.ticks) / 2) < distanceTicks) {
        motor_gpio_move(&mot_l, dutyCycle);
        motor_gpio_move(&mot_r, dutyCycle);
        nanosleep(&_10_MS, NULL);
    }

8 Misuriamo la velocità

La velocità, seppure abbastanza stabile, ha un trend in crescita verso le utlime corse, ma si nota anche che ciò è dovuto al fatto che la ruota sinistra tende ad accelerare mentre la destra rallenta. I ticks a sinistra passano da circa 9100 a 9350, mentre a destra si passa da 9050 a 8850; avevo già visto questo comportamento con il coderbot 05 ed era quindi atteso anche in questo caso, seppure in misura inferiore intorno al 2-3%.

corsa	ticks_l	ticks_r	media_ticks	mm_percorsi	mm_per_tick	tempo_us	mm_per_sec
1	9206	8999	9103	500	0,055	5107526	98
2	9175	9021	9098	500	0,055	5167143	97
3	9107	9075	9091	500	0,055	5275187	95
4	9209	9000	9105	500	0,055	5173829	97
5	9172	9016	9094	500	0,055	5085602	98
6	9264	8924	9094	500	0,055	4953123	101
7	9351	8844	9098	500	0,055	4901619	102
8	9413	8797	9105	500	0,055	4913071	102
9	9262	8950	9106	500	0,055	4961444	101
10	9313	8899	9106	500	0,055	4872636	103
11	9232	8985	9109	500	0,055	4881170	102
12	9213	9000	9107	500	0,055	4862412	103
13	9231	8949	9090	500	0,055	4871381	103
14	9208	9006	9107	500	0,055	4931543	101
15	9283	8925	9104	500	0,055	4951912	101

Dalle prove emerge quanto segue:

• Con PWM al 50%, la velocità media è 100 mm/s
• Lo scarto tra le due ruote passa da circa 200 tick iniziali a 500 circa verso la fine.
• Confermo la necessità di avere 2 PID indipendenti.

9 Il controllo PID

Con i dati raccolti, è ora possibile iniziare a studiare il PID.

10 Il Coderbot oscilla, troviamo il Ku

11 Grafico dell'oscillazione

12 Usiamo la formula di Ziegler-Nichols

13 Suddividiamo in threads

14 Scegliamo un algoritmo di scheduling

15 Test finale