Algoritmo di controllo e firmware
4.1 Impostazioni preliminari
Come mostrato nel capitolo precedente, è possibile osservare una variazione del carico statico del veicolo, semplicemente osservando la durata dell'attivazione su un prefissato numero di giri del motore in corrente continua. Prima di poter decidere nel dettaglio quale sia la strategia migliore per il controllo, è stato necessario predisporre il microcontrollore per la misura.
La misura richiede che sia controllabile la posizione del precarico e quindi il numero di giri del motore, tale informazione è necessaria, e si utilizza, anche per impostare il precarico opportuno. Per la misura inoltre è necessario osservare la durata dell'attivazione tramite uno specifico timer/contatore.
Di seguito si riporta un estratto del firmware per il controllo del precarico attuale:
if (CCON & MSK_CAPTURE_MISURA_PRECARICO) {
CCON = CCON & ~MSK_CAPTURE_MISURA_PRECARICO; if(dir_m==MOTORE_UP) {
if(precarico < 0xFFFF) precarico++; }
// motore down
else if (precarico >0) precarico--; }
Per monitorare il livello attuale di precarico, quindi, si utilizza il segnale generato dal sensore a effetto Hall, di cui è dotato il motore in corrente continua, e uno dei cinque moduli del PCA in modalità capture. Ogni volta che viene rilevato un evento in ingresso al modulo prescelto del PCA,in funzione della direzione di rotazione del motore, viene incrementato o decrementato il valore del precarico.
La misura del tempo di attivazione è stata realizzata per mezzo di un contatore a 16 bit con sensibilità tmin=0,96 ms , e con fondoscala
F.S.≃62,915 s , abilitato in conseguenza dell'attivazione del motore stesso. Di
seguito si riporta un estratto del firmware con l'implementazione del contatore: void misura_tempo_attivazione()
{
static Uint16 timer_attivazione = 0; if(stato_m)
{
//se motore attivo conta durata attivazione timer_attivazione ++;
//e la scrivo in uscita
tempo_attivazione = timer_attivazione; }
else timer_attivazione = 0; //motore disattivato }
Il segnale di sincronismo del contatore è ottenuto come multiplo dell'interrupt generato dal Timer1.
Il Timer1, settato in modalità 2, ossia come timer a 8 bit con autoreload, funge da timer generale di sistema e genera un interrupt con periodo
Tinterrupt=0,192 ms , come si può ottenere semplicemente:
Tinterrupt=
fclk
dove per fclk si intende la frequenza di clock del sistema che, nel caso
specifico, vale 16 MHz, mentre 12 è il numero di cicli di clock per ciclo macchina, in quanto il Timer1 lavora in modalità standard.
Un estratto del firmware con la gestione dell'interrupt del Timer1, è riportata di seguito:
// driver che gestisce l'interrupt generata dal TIMER 1 Interrupt(driver__tick_sistema(void), 3)
{
static conta_tempo = 0; static conta_tempo_ADC = 0; static conta_tempo_attivazione = 0; // riazzera flag interrupt
TF1 = 0; // sampling ADC if (conta_tempo_ADC == CONTA_CICLI_ADC) { adc_start_conv_interrupt(SOSPENSIONE_ADC_CH, 2); conta_tempo_ADC = 0; } else conta_tempo_ADC ++;
// tick di sistema, un ciclo ogni 10ms circa if (conta_tempo == CONTA_CICLI_TIMER1) { task_in_progress = 1;
conta_tempo = 0; }
else conta_tempo ++;
// timer attivazione, risoluzione minima 1ms circa if (conta_tempo_attivazione == CONTA_TIMER_ATT) { misura_tempo_attivazione(); conta_tempo_attivazione = 0; } else conta_tempo_attivazione ++; }
4.2 Misure sperimentali
dati, si è fatto uso di un Virtual Instrument (VI) appositamente sviluppato con LabView, di cui in Fig. 4.1 è riportato il front panel.
Fig. 4.1 – Front panel del VI per le misure.
I dati sperimentali acquisiti, sono stati analizzati e confrontati con l'ausilio di un foglio di calcolo elettronico.
In Fig. 4.2 è riportato l'andamento del tempo di attivazione, nelle varie prove sperimentali, per diversi valori del carico statico, nel caso di sollevamento dello stesso (il carico corrispondente a ogni traccia è indicato nel grafico). Come si può riscontrare, è possibile distinguere diversi livelli di carico.
Fig. 4.2 – Tempo attivazione(asse y) incrementando il precarico, per carichi diversi.
0 10 20 30 40 50 60 7,000 7,400 7,800 8,200 8,600 9,000 9,400 9,800 10,200 kg100 kg120 kg140 num. esperimenti se c.
Il tempo di attivazione è stato monitorato al variare del carico statico nell'intervallo [100, 140] kg, con risoluzione di carico pari a 10 kg.
Nel caso di misurazioni con carico inferiore ai 100 kg, la sospensione raggiunge la massima estensione, tale fenomeno deriva dal fatto che il carico risulta inferiore al precarico minimo della molla, per cui la corsa della sospensione rilevata dal sensore di elongazione rimane sempre nulla, introducendo un errore sistematico nella misura.
Fig. 4.3 – Tempi di attivazione (asse y) decrementando il precarico, per carichi diversi.
Le attivazioni sono state fatte portando il precarico dal livello minimo, riconosciuto come livello 0, al livello massimo, livello 7, per ridurre al minimo l'influenza, sulla velocità media, del transitorio iniziale.
In Fig. 4.3 è riportato l'andamento del tempo di attivazione sulle varie prove effettuate, con diversi livelli di carico, in fase di abbassamento del carico stesso. Come si evince dal grafico, la durata di ogni attivazione è indipendente dall'entità carico, mediamente essa vale tatt=5.2 s , con fluttuazione con varianza
2=0,017 , quindi calcolandone la velocità media M corrispondente come:
M=numero giri
tatt⋅210 (4.2)
dove il numero di giri dal livello 0 al livello 7 è numero giri = 370 , mentre
0 10 20 30 40 50 60 4,700 4,800 4,900 5,000 5,100 5,200 5,300 5,400 5,500 5,600 kg100 kg120 kg140 num.esperimenti se c
210 è il rapporto di demoltiplicazione del motore in corrente continua fornito dal costruttore, con tali dati si ottiene in definitiva M≃20,3 min
−1
. Da un confronto di tale valore con quello fornito nel datasheet del motore nel caso di assenza di carico, si osserva la prossimità dei due valori (Fig. 2.5). La differenza è attribuibile alla presenza di attrito nella pressa idrostatica e sui vincoli della vite. Tale risultato va a suffragare quanto espresso analiticamente in (3.36).
Fluttuazioni sulla durata di attivazione nel sollevamento, oltre che nell'abbassamento, del carico sono state osservate durante le varie prove, come può essere osservato nei grafico di Fig. 4.2. Tali fluttuazioni sono attribuibili a fenomeni di non linearità legati a temperatura, viscosità e attrito esposti nel precedente capitolo.
Fig. 4.4 – Andamento di M (asse y), per diversi valori di carico.
Per compensare, almeno parzialmente, i fenomeni legati alle variazioni di temperatura e possibili variazioni della tensione di batteria del mezzo, si è pensato di utilizzare la differenza fra la velocità media di abbassamento del carico D e
quella di sollevamento S , ossia di monitorare la riduzione di velocità M
per effetto del carico, rispetto alla velocità costante di discesa del motore:
M=D−S (4.3) 0 10 20 30 40 50 60 0,050 0,055 0,060 0,065 0,070 0,075 0,080 0,085 0,090 0,095 0,100 kg100 kg120 kg140 num. esperimenti ra d/ se c
Se si esplicitano i termini in (4.3) con le espressioni trovate per nel precedente capitolo 3, si ha:
M= K⋅V K 2 R⋅b '− K⋅V −⋅R⋅M⋅g K 2 R⋅b' (4.4)
è quindi subito evidente come sia compensata la dipendenza dalla tensione di batteria V .
In Fig. 4.4 e nella successiva Fig. 4.5 sono riportati rispettivamente gli andamenti di M e di tatt , definita come la differenza fra la durata
dell'attivazione di sollevamento tS e di abbassamento tD del carico:
tatt=tS−tD (4.5)
Fig. 4.5 – Andamento di tatt (asse y), per diversi valori di carico.
Dal confronto dei due grafici con quello di Fig. 4.2, si può notare come le fluttuazioni siano più contenute nel caso di differenza fra attivazione in salita e in discesa (Figure 4.4 e 4.5), piuttosto che nel caso di solo sollevamento (Fig. 4.2), inoltre i due andamenti differenza hanno andamenti molto simili, per cui ha senso pensare di utilizzare esclusivamente tatt che consente una notevole
0 10 20 30 40 50 60 2,000 2,400 2,800 3,200 3,600 4,000 4,400 4,800 kg100 kg120 kg140 num. esperimenti se c.
semplificazione a livello computazionale per il microcontrollore, in quanto richiede, rispetto alle grandezze rilevate, la sola operazione di differenza.
Per continuità e per confronto con i lavori precedenti al presente, contestualmente alla misura del tempo di attivazione, si è effettuata la misura della corrente media di attivazione.
Fig. 4.6 – Corrente media IS (asse y), per diversi valori di carico.
La corrente viene convertita in digitale su 8 bit, tramite uno dei canali del convertitore ADC di cui è dotato il microcontrollore. Con risoluzione a 8 bit, la sensibilità è di Imin=0,061 A .
Analogamente a quanto accade per la misura del tempo di attivazione, la corrente viene convertita con un periodo Tconv=0,96 ms . per un confronto equo
delle due misure, si è pensato di mediare la corrente misurata nell'intervallo di durata dell'attivazione del motore, ciò richiede ovviamente che venga conteggiato il numero di conversioni dell'ADC durante tale intervallo.
Dai dati sperimentali rilevati per la corrente, si sono ottenuti gli andamenti riportati nel grafico di Fig. 4.6 in cui è rappresentato l'andamento della corrente media sulle varie attivazioni per diversi valori del carico statico (i valori corrispondenti sono indicati nel grafico). Analogamente a quanto accade per la misura del tempo di attivazione, si possono distinguere diversi livelli di carico.
Nella misura di corrente può essere ancora utilizzata la differenza fra la
0 10 20 30 40 50 60 2,500 2,700 2,900 3,100 3,300 3,500 3,700 3,900 4,100 kg100 kg120 kg140 num. esperimenti A m pe re
corrente media nella fase di incremento IS e quella nella fase di diminuzione del
precarico ID , per compensare alcune delle fluttuazioni su di essa:
IM=IS−ID (4.6)
In Fig. 4.7 è riportato l'andamento della corrente (4.6).
Fig. 4.7 – Andamento di IM (asse y), per diversi valori di carico.
Nella tabella 4.1 sono riportati i valori medi di tatt e IM e la deviazione standard , ottenuti nelle varie misurazioni. Dai dati in tabella si osserva come per le misure di corrente la deviazione standard sia minore, circa la metà, rispetto a quella nel caso di misure temporali, ma come contrappeso si hanno degli intervalli fra un valore medio e l'altro circa dimezzati.
Tabella 4.1
KG 100 120 140
Media tatt 2,803 3,197 4,196
Deviazione standard tatt 0,210 0,226 0,341
Media IM 2,076 2,311 2,758 Deviazione standard IM 0,142 0,101 0,153 0 10 20 30 40 50 60 1,500 1,700 1,900 2,100 2,300 2,500 2,700 2,900 kg100 kg120 kg140 num. esperimenti A m pe re
Si consideri l'errore introdotto da queste due misurazioni. Per la misura di corrente l'errore di quantizzazione val I =0,061 A e, mentre per la misura del tempo di attivazione t=0,96 ms . La corrente media IM è ottenuta come:
IM=
∑
j=1 NC Ij NC (4.7)Introducendo l'errore di quantizzazione sulla corrente sul numero di conversioni NC , è semplice ottenere per l'errore relativo sulla corrente media
r IM : r I M= 1 NC NC1 I IM⋅ 1 NC NC 1 (4.8)
dove NC/NC rappresenta l'errore relativo sul numero di conversioni. Per la valutazione della velocità media si ottiene come:
M=NP
tatt
(4.9)
Con NP si è indicato il numero di giri di precarico. Introducendo l'errore di
quantizzazione sul numero di giri di precarico e sul tempo di attivazione, si ha per l'errore relativo sulla velocità media r M :
r M= 1 tatt t1 NP NP ⋅ 1 t tatt1 (4.10)
In (4.10) il rapporto NP/NP rappresenta l'errore relativo sul numero di
giri di precarico, mentre t /tatt è l'errore relativo su tempo di attivazione. Può essere osservato che:
NC
NC
=t
tatt
(4.11)
L'uguaglianza (4.11) deriva dal fatto che ogni conversione dell'ADC è comandata da un segnale alla stessa frequenza del segnale di sincronismo del contatore per la misura del tempo di attivazione. Se ne deduce che gli errori relativi sulla corrente media r IM e sulla velocità media r M , differiscono per
l'entità dell'errore sulla corrente I / IM e sul numero di giri di precarico
NP/NP .
L'errore sul numero di giri di precarico, rimane fissato una volta scelto il range di precarico su cui effettuare le misurazioni, nel caso specifico NP=1 e
NP=370 , da cui si ottiene NP/NP≃0,003 . L'errore relativo sulla corrente
invece dipende dal valore medio della corrente in assenza di errore, sarà quindi tanto maggiore quanto più piccola sarà IM . Nel caso specifico la situazione
peggiore si ha in fase di riduzione del precarico, in cui IM=0,879 A da cui si
ottiene I / IM=0,061/0.879≃0,070 .
Il risultato trovato è concorde con quanto atteso intuitivamente, avendo utilizzato come risoluzione per la misura temporale e in corrente rispettivamente 16 bit e 8 bit.
4.3 Algoritmo di controllo
Fig.4.8 – Grafo di flusso dell'algoritmo di controllo.
In base a quanto osservato sperimentalmente, per poter controllare il precarico in funzione della durata dell'attivazione del motore, sarà necesario:
• attivare il motore incrementando il precarico sino al livello prefissato; • leggere il tempo di attivazione in salita;
• attivare il motore decrementando il precarico fino al livello di
partenza;
• leggerne il tempo di attivazione;
• decidere in base alla differenza fra le due letture il livello di precarico
da impostare;
• impostare il nuovo precarico e attendere per la prossima attivazione.
In Fig. 4.8 è riportato il grafo di flusso dell'algoritmo di controllo.
L'implementazione firmware dell'algoritmo di controllo è costituita da due macchine a stati. La prima di queste, gestisce il flusso dell'algoritmo di controllo del sistema, può essere sintetizzata a partire dal diagramma di flusso di Fig. 4.8. Di seguito si riporta un estratto del firmware di tale macchina a stati:
// macchina a stati che implementa algoritmo di controllo switch(stato_nodo) { case STATO_ON: switch(stato_algoritmo) { case START: controllo = 0; controllo_alg = 0; enable_log = 1; // azzero precarico done = 0; azzera_precarico = 1; livello_precarico = 0; first_run = 1; stato_algoritmo_saved = READY; stato_algoritmo = WAIT; break; case READY: //cav_lat = 0;
if(!cav_lat) stato_algoritmo = START_ALG; else if(controllo_remoto_rx) { enable_log_rx = 1; attiva_m_rx = 0; setta_precarico_rx = 0; stato_algoritmo = REMOTE; } break; case START_ALG:
if(cav_lat) stato_algoritmo = START; precarico_prev = livello_precarico;
nuovo_livello_precarico = 0; stato_algoritmo = PRELOAD_SETTING; start_S0 = 1; break; case REMOTE: if (!controllo_remoto_rx) stato_algoritmo = READY; else { azzera_precarico = azzera_precarico_rx; azzera_precarico_rx = 0; attiva_m = attiva_m_rx; attiva_m_rx = 0; m_up_down = m_up_down_rx; setta_precarico = setta_precarico_rx; setta_precarico_rx = 0; nuovo_livello_precarico = livello_precarico_rx; } break; case WAIT: if(done) { if(dummy_S7) stato_algoritmo = stato_algoritmo_saved; else if(BYTE1(corrente) <= CORRENTE_NULLA) stato_algoritmo = stato_algoritmo_saved;
}
else if(errore) stato_algoritmo = ERROR; break; case ERROR: if(controllo_remoto_rx) { enable_log_rx = 1; attiva_m_rx = 0; setta_precarico_rx = 0; stato_algoritmo = REMOTE; } break; case PRELOAD_SETTING: setta_precarico = 1; done = 0; stato_algoritmo = WAIT; if(start_S0) { if(first_run) stato_algoritmo_saved = DUMMY_RUN; else stato_algoritmo_saved = SET_S7; }
else if(dummy_S7 || set_S7)
stato_algoritmo_saved = SET_S0;
else if(set_S0_DS7) stato_algoritmo_saved = SET_S7;
COMPARE;
else if(threshold_ok) stato_algoritmo_saved = PRELOAD_SET; break; case PRELOAD_SET: threshold_ok = 0; cicli_nuova_misura--; if (num_cicli_contati==0) cicli_vel_zero--; else cicli_vel_zero = CICLI_VEL_ZERO; if(cav_lat) stato_algoritmo = START;
else if((cicli_nuova_misura==0) ||
(cicli_vel_zero==0)) stato_algoritmo = START_ALG; break; case SET_S7: nuovo_livello_precarico = 7; set_S7 = 1; set_S0_DS7 = 0; start_S0 = 0; stato_algoritmo = PRELOAD_SETTING; break; case SET_S0: nuovo_livello_precarico = 0; if(dummy_S7){ set_S0_DS7 = 1; dummy_S7 = 0; } if(set_S7){ set_S0_S7 = 1; set_S7 = 0; time_up = tempo_attivazione; } stato_algoritmo = PRELOAD_SETTING; break; case DUMMY_RUN: nuovo_livello_precarico = 7; first_run = 0; dummy_S7 = 1; start_S0 = 0; stato_algoritmo = PRELOAD_SETTING; break; case COMPARE: time_down = tempo_attivazione; delta_time = time_up - time_down; if(precarico_prev == 0){ if(delta_time > SOGLIA_ALTA) nuovo_livello_precarico = 7; else nuovo_livello_precarico = precarico_prev; } else if(precarico_prev == 7){ if(delta_time < SOGLIA_BASSA) nuovo_livello_precarico = 0; else nuovo_livello_precarico =
precarico_prev; } else nuovo_livello_precarico = 0; stato_algoritmo = PRELOAD_SETTING; threshold_ok = 1; set_S0_S7 = 0; cicli_nuova_misura = CICLI_NUOVA_MISURA; cicli_vel_zero = CICLI_VEL_ZERO; break; default:; } break; default: stato_algoritmo = START; }
La seconda macchina a stati si occupa della gestione del funzionamento del motore, in funzione di quanto impostato nella prima macchina a stati. L'implementazione firmware, di questa seconda macchina stati, è:
// macchina a stati che controlla il motore conta_cicli ++; switch (stato_controllo) { case IDLE_CTRL: conta_cicli = 0; if(azzera_precarico) { fine_corsa = 0; stato_controllo = RESET_CTRL; } else if (attiva_m) { attiva_m = 0; cmd_m = 1; dir_m = m_up_down; stato_controllo = IDLE_CTRL; done = 1; } else if(setta_precarico) { #define OFFSET_PRECARICO 50 #define DELTA_PRECARICO 53 setta = 1; setta_precarico = FALSE; nuovo_precarico = OFFSET_PRECARICO+nuovo_livello_precarico*DELTA_PRECARICO; stato_controllo = SETTA_CTRL;
if(nuovo_precarico > precarico) segno_precarico=1; else segno_precarico = 0;
if(segno_precarico) dir_m = MOTORE_UP; else dir_m = MOTORE_DOWN;
} break; case RESET_CTRL:
precarico = 0; stato_controllo = IDLE_CTRL; azzera_precarico = 0; errore = 0; done = 1; } else if(conta_cicli<RESET_CTRL_TIMEOUT) { cmd_m = 1; dir_m = MOTORE_DOWN; } else { errore = 1; azzera_precarico = 0; stato_controllo = IDLE_CTRL; } break; case SETTA_CTRL: if ((nuovo_precarico>precarico)^segno_precarico) { stato_controllo = IDLE_CTRL; setta = 0; done = 1; livello_precarico = nuovo_livello_precarico; } else { cmd_m = 1; } break; default: stato_controllo = IDLE_CTRL; }
Si può osservare che il sistema potrebbe essere implementato con una singola macchina a stati che gestisca, contemporaneamente, le due funzionalità esposte, ma la scelta di una struttura in apparenza più complessa, consente maggiore flessibilità a possibili modifiche e leggibilità del firmware, modifiche che possono essere frequenti e necessarie per il sistema attualmente in fase di sviluppo.
La macchina a stati per la gestione del flusso dell'algoritmo di controllo si compone essenzialmente dei seguenti stati:
• START: è lo stato, analogamente a quanto accadeva nel sistema
dotato di sensore, in cui entra il sistema in seguito a reset hardware, accensione o apertura del cavalletto laterale, vengono inizializzate le variabili per la gestione del flusso di algoritmo e viene comandato l'azzeramento del precarico.
• READY: il sistema ha completato le operazioni preliminari, si attende
che il cavalletto venga chiuso per avviare le operazioni per il settaggio del precarico, o che venga riconosciuta una richiesta di controllo remoto.
• START ALG: in questo stato viene impostato il livello di precarico di
partenza per l'attivazione, inoltre viene memorizzato il precarico precedente all'esecuzione della misura.
• PRELOAD SETTING: in tale stato si abilita il funzionamento del
motore e si seleziona lo stato da cui procedere al termine dell'attivazione, in funzione di quale sia lo stato precedente che ha richiesto l'attivazione stessa.
• WAIT: è lo stato, successivo a PRELOAD SETTING, di attesa del
completamento di una attivazione. Al termine di ogni attivazione del motore il sistema passa nello stato selezionato in PRELOAD SETTING.
• SET S7: dopo aver impostato il precarico di partenza, in questo stato
viene impostato il livello di precarico con cui terminare l'attivazione in salita.
• SET S0: al termine dell'attivazione in salita,in questo stato si
memorizza la durata dell'attivazione terminata e si imposta il livello di precarico in modo da tornare nella configurazione di partenza, cioè quella impostata in START ALG.
• COMPARE: in seguito al completamento dell'attivazione in riduzione
dl precarico, in questo stato si legge la durata dell'ultima attivazione e quindi si calcola tatt , definito in (4.3). A seconda del livello di
precarico memorizzato in START ALG, si seleziona il valore con cui confrontare tatt .
• PRELOAD SET: prima dell'esecuzione del ciclo di misura
durata maggiore di un prefissato TSTOP o se è trascorso un certo
TMAX , il ciclo viene riavviato da START ALG.
Come è possibile dedurre dal nome utilizzato per alcuni degli stati della macchina di controllo dell'algoritmo, nella fase attuale di sviluppo e con l'obiettivo di presentare una versione dimostrativa del sistema funzionante su banco prova, si è scelto di regolare il precarico su due livelli cioè il precarico massimo quantizzato come livello 7, e quello minimo, come livello 0. Per gli stessi motivi esposti in precedenza, inoltre si è scelto di monitorare il tempo di attivazione nel passaggio dal livello 0 al livello 7 per l'incremento, e il viceversa per il decremento del precarico.
Il controllo con termine di confronto selezionabile, che consente di limitare i problemi legati alle inevitabili fluttuazioni sul carico della sospensione per effetto del moto del veicolo, introducendo una sorta di inerzialità al cambiamento del livello di precarico precedentemente impostato, è stato scelto in quanto non si ha una caratterizzazione completa della sospensione, che consentirebbe un controllo di tipo differente, ma non necessariamente più affidabile, caratterizzazione che richiede sperimentazioni trasversali e indipendenti rispetto a quelle effettuate nel presente lavoro [17]. Per tali motivi si è adottato un approccio sperimentale per la determinazione dei dati necessari al controllo del sistema stesso.
