APPENDICE
A
LA SOSPENSIONE
Le sospensioni hanno lo scopo fondamentale di assorbire le asperità e di tenere, quanto più possibile, le ruote a contatto con il terreno, massimizzando così la tenuta di strada.
Le componenti fondamentali delle sospensioni sono la geometria, realizzata attraverso i bracci e i mozzi, gli ammortizzatori e le molle.
Gli ammortizzatori e le molle sono gli elementi che definiscono il comportamento dinamico della sospensione in seguito ad un’asperità del terreno o in corrispondenza di un trasferimento di carico tra le ruote dovuto ad un’accelerazione/frenata o ad una curva.
Il tipo più diffuso di molla è quello elicoidale, al cui interno è normalmente alloggiato il cilindro dell'ammortizzatore. Una molla è un elemento elastico che resiste ad una compressione nella sua direzione di lavoro.
L’ammortizzatore è un elemento necessario per dissipare l'energia associata all'escursione della sospensione. Esso assorbe l'energia in eccesso e consente allo pneumatico di rimanere in contatto col terreno quanto più possibile.
Per capirne il funzionamento analizziamo il sistema in figura.
Consideriamo il veicolo come un semplicissimo sistema massa-molla con smorzamento, dove la massa è la frazione della massa del corpo del veicolo che grava su una ruota, mentre lo smorzamento è dato dall’ammortizzatore.
Scrivendo l’equazione di bilancio delle forze che agiscono sulla massa si ottiene un’equazione differenziale lineare nella variabile x:
0 2 2 = + + + kx Mg dt dx r dt x d M Dove:
− M è la massa che grava sulla ruota; − k è la costante elastica della molla;
− r è il coefficiente di smorzamento dell’ammortizzatore;
− x è l’estensione (o compressione) della molla rispetto al punto di equilibrio.
Consideriamo innanzitutto il caso in cui l’ammortizzatore sia assente. Allora l’equazione diventa: Mg kx dt x d M 2 + = 2
Quando la ruota supera un’irregolarità del terreno, la massa si sposta in una posizione diversa da quella d’equilibrio e la molla si comprime immagazzinando energia potenziale. Lasciando il sistema libero, esso tenderà a tornare nella posizione d’equilibrio trasformando l’energia potenziale in cinetica.
Una volta tornati nella posizione iniziale tutta l’energia si è trasformata in energia cinetica e quindi il sistema non è ancora in equilibrio. Per questo la molla, se era stata compressa, comincia ad estendersi perdendo energia cinetica e riacquistando
3 energia potenziale. Questo processo, in condizioni ideali, andrebbe avanti all’infinito seguendo la legge:
. cos 2 2 2 2 t v M x k EP = ⋅ + ⋅ =
Tale fenomeno fisico prende il nome di Moto armonico semplice, in cui un punto x si muove secondo la legge:
) ( 0 sen t x
x = ⋅
ω
⋅dove x0 è l’ampiezza d’oscillazione e ω
è la pulsazione propria del sistema che è legata alla costante elastica della molla e alla massa dalla seguente equazione:
M k =
ω
Figura A.2 Moto armonico semplice.
Queste considerazioni fanno già capire come una sospensione dotata solo di molla renderebbe impossibile la guida della motocicletta.
Il problema può essere risolto ricorrendo a qualche accorgimento che faccia tornare il sistema nella posizione di partenza con il minor numero d’oscillazioni. Tale accorgimento è proprio l’ammortizzatore, che deve controllare e smorzare queste oscillazioni che si ripetono con una precisa frequenza ed ampiezza stabilita dai parametri fisici della sospensione.
L’ammortizzatore assorbe e dissipa l’energia immagazzinata dalla molla, sfruttando l’azione di un dispositivo idraulico posto nel suo involucro circolare
(tubo) che contiene olio. Sull’estremità dell’ammortizzatore (stelo) che scorre nell’interno dell’involucro tubolare, è fissato un pistone che separa due camere. Quando lo stelo si muove l’olio deve spostarsi da un volume all’altro, passando attraverso delle valvole specifiche .
Figura A.3 Ammortizzatore in azione.
Torniamo allora ad analizzare il sistema di figura 1.1 considerando la presenza dell’ammortizzatore.
L’azione smorzante dell’ammortizzatore è proporzionale alla velocità di spostamento della massa.
La soluzione di tale equazione differenziale, quando la forza di smorzamento è piccola rispetto alla forza elastica, è un moto armonico smorzato:
) cos( 2 t d e A x M t r + ⋅ ⋅ = − ⋅ ω dove A e d sono legate alle condizioni iniziali e ω
, pulsazione delle oscillazioni, è data dalla seguente equazione:
2 2 − = M r M k ω
Si nota che aumentando r, l’ampiezza d’oscillazione diminuisce più rapidamente così come la pulsazione ω
.
5 scorre lo stelo nel fodero:
(
)
+ ⋅ ⋅ + + ⋅ ⋅ ⋅ = ⋅ − d t sen d t M r e A x t M r ω ω ω ) cos( 2 2 .A parità di condizioni, aumentando r si ha una riduzione della velocità: si può notare inoltre che esiste un valore di r, chiamato smorzamento critico, per il quale il sistema si arresta dopo una sola oscillazione.
Figura A.4 Moto armonico smorzato in condizione di smorzamento critico.
Questa è la condizione da raggiungere quando s’interviene sul setup della motocicletta.
Andando ad agire su alcuni parametri della sospensione se ne può modificare il funzionamento.
La molla si può regolare agendo su appositi registri in modo tale da aumentare o diminuire la compressione statica; mentre l’ammortizzatore, può essere regolato sia nella velocità di compressione che in quella d’estensione con registri a vite che servono a parzializzare i fori attraverso i quali fluisce l’olio idraulico responsabile dell’effetto smorzante.
Quando si agisce sulla regolazione delle sospensioni di una motocicletta, è fondamentale tener conto dell’importanza di accordare il funzionamento tra la sospensione anteriore e quella posteriore per limitare al massimo gli scompensi che le asperità del fondo stradale portano all’equilibrio della motocicletta. Se non si tiene conto di ciò, si può incorrere in reazioni anomale della moto alla presenza di sollecitazioni esterne con conseguente perdita di controllo del mezzo. Oltre ad accordare la sospensione anteriore con quella posteriore è importante accordare
l’ammortizzatore con la relativa molla evitando, ad esempio, di precaricare troppo poco la molla e invece frenare troppo l’idraulica ottenendo una sospensione che affonda eccessivamente per ogni piccola asperità e poi fatica a ristendersi.
APPENDICE
B
Il Ponte ad H
Un ponte ad H è costituito da quattro interruttori e permette il funzionamento bidirezionale del motore in presenza di un’alimentazione singola.
Figura B.1
La figura 1 mostra la connessione dei quattro transistor. In genere i due transistor inferiori (2 e 4 nello schema), detti di sink, assorbono la corrente proveniente dal motore; i due MOS connessi direttamente all’alimentazione sono detti di source. Secondo quali transistor sono attivi, abbiamo diversi possibili percorsi per la corrente.
Con riferimento alla Figura B.2:
Linea verde: se sono attivi un transistor di sink ed uno di source appartenenti a lati opposti del ponte, abbiano passaggio di corrente nel motore. In questo caso il motore è in rotazione in un verso; per ottenere la rotazione opposta bisogna attivare la coppia simmetrica.
Figura B.2
Linea rossa: se è attivo un transistor di sink ed uno di source appartenenti allo stesso lato del ponte abbiamo un corto circuito. Questa situazione deve essere evitata nel modo più assoluto perché porterebbe alla distruzione del ponte in tempi brevissimi.
Linea blu: se tutti i transistor sono spenti non ci sono maglie in cui può passare la corrente fornita dall'alimentatore. Quella indicata è la via che l'eventuale corrente accumulata dall'induttore percorre: si tratta ovviamente di un fenomeno temporaneo ma che deve necessariamente essere previsto per evitare malfunzionamenti. Terminata la scarica dell'induttore non si ha più passaggio di corrente e se il motore era precedentemente in moto si arresta lentamente a causa degli attriti meccanici.
Linea gialla: Se è attivo almeno uno dei transistor di source e nessuno di quelli di sink non vi sono percorsi in cui passa la corrente fornita dall'alimentatore ma si crea un cortocircuito ai capi del motore: l'effetto è una vigorosa azione frenante causata dalla presenza del generatore equivalente Eg già citato a proposito delle equazioni di funzionamento e dalla conseguente corrente generata dal motore. Il ponte ad H è utilizzabile in funzionamento on/off semplicemente applicando gli opportuni segnali per ottenere rotazione in un verso o nel verso opposto, frenata rapida o frenata lenta. In alternativa è possibile utilizzare un segnale pwm per pilotare il ponte, secondo due modalità:
Sign/magnitude pwm: si utilizzano due segnali, uno pwm per l'ampiezza ed uno costante per il verso di rotazione. Il duty cycle del segnale pwm varia tra lo 0%
9 (motore fermo) ed il 100% (motore a piena velocità); esso deve essere applicato direttamente ad una coppia diagonale di transistor mentre l'altra deve essere spenta.. L’ingresso di segno serve per scegliere la coppia di transistor che deve essere accesa.
Locked anti-phase pwm: occorre un solo segnale pwm tale che quando è alto è in conduzione una coppia di transistor, quando è basso l'altra. L'effetto è quello di forzare la corrente nel motore prima in un verso, poi nell'altra: a causa dell'induttanza si ha una stabilizzazione intorno al valor medio. In particolare quando un duty cycle è del 50% la corrente è nulla, la tensione media nulla e quindi il motore è fermo. Quando il duty cycle tende al 100% il motore ruota a piena velocità in un verso, quando è dello 0%, ruota a piena velocità nell'altro verso.
Un problema di questo circuito è legato alla difficoltà pratica che si ha nel pilotare i due transistor superiori, soprattutto se la tensione di alimentazione è elevata: infatti i loro drain non sono connessi a massa ma ad una tensione variabile. Come effetto si ha che:
l'ampiezza degli impulsi di pilotaggio non deve essere riferita a massa ma all'emettitore, con notevoli complicazioni circuitali.
l'ampiezza degli impulsi deve essere superiore alla tensione di alimentazione del motore.
La soluzione a tale inconveniente prevede in genere l’utilizzo di circuiti a pompa di carica che permettono di ottenere tensioni superiori a quella di alimentazione, per il pilotaggio dei gate del ponte.
Altro problema: un motore si comporta come un carico induttivo che, quando è comandato in modalità PWM, viene acceso e spento a frequenza dell’ordine dei Khz; quando il motore viene spento la corrente non va a zero istantaneamente, ma una certa quantità continuerà a passare nella stessa direzione della corrente di potenza provocando una sovratensione (il canale del MOS si comporta come una resistenza molto elevata) che potrebbe danneggiare il transistor. Una soluzione classica a tale inconveniente è quella di montare in anti-parallelo al MOS un diodo
in modo che la corrente continui a fluire attraverso esso fino a diventare zero. Si usa inoltre il MOS della parte superiore del ponte come synchronous rectifier. In questo modo quando si spegne il MOS di sotto si accende quello di sopra creando un cammino a bassa dissipazione per la corrente.
APPENDICE
C
IL BUS CAN
Il protocollo CAN (controller area network) è un protocollo di comunicazione seriale di tipo “broadcast” che permette il controllo real-time distribuito con un livello di sicurezza molto elevato. Introdotto dalla Bosch nei primi anni ‘80 per applicazioni automotive, si è diffuso ormai in molti settori dell’industria, compresa quella elettromedicale.
Sono in molti a vedere nel Bus CAN lo standard dominante nelle reti industriali del prossimo futuro, grazie ai notevoli vantaggi tecnologici che offre:
tempi di risposta rigidi, specifica fondamentale nel controllo di processo.
semplicità e flessibilità del cablaggio: CAN è un bus seriale tipicamente implementato su un doppino intrecciato. I nodi non hanno un indirizzo che li identifichi e possono quindi essere aggiunti o rimossi senza dover riorganizzare il sistema o una sua parte.
alta immunità ai disturbi.
Una rete CAN è composta, in genere, da più nodi ed ogni nodo ha il compito di controllare i dispositivi presenti nella rispettiva area e di gestire la comunicazione inter-area.
Facendo riferimento alla schematizzazione in livelli definita dall’ISO (International Standard Organization) col progetto OSI (Open System Interconnection) si può ritenere che il Bus CAN implementi il Physical Layer ed il Data Link Layer.
Figura C.2 Struttura di un nodo CAN.
• Il Physical Layer
Il layer fisico specificato è un doppino intrecciato, dalla cui lunghezza dipende la velocità di trasmissione (nel caso specifico 1Mbit/s): il flusso di bit è codificato con il metodo NRZ ( Non Return to Zero).I due livelli utilizzati sul bus sono detti “dominante” (‘d’) e “recessivo” (‘r’). La corrispondenza fra ‘d’ ed ‘r’ ed i livelli logici ‘0’ ed ‘1’ dipende dal tipo di cablaggio che puó essere AND o wired-OR
• Il Data Link Layer
Il Data Link Layer è a sua volta implementato attraverso altri due livelli: l’Object Layer ed il Transfer Layer.
Il primo si occupa del filtraggio dei messaggi arrivati ( in una comunicazione broadcast tutti i nodi ricevono gli stessi pacchetti: nell’Object Layer si scartano quelli non rilevanti per il nodo considerato) e della gestione dei messaggi da trasmettere e dell’interfaccia con l’Application Layer. La definizione
13 dell’Application Layer è lasciata interamente al progettista, al quale spettano i dettagli dell’interfacciamento degli utenti verso il bus.
Il secondo definisce le modalità di trasferimento: formato dei messaggi, segnalazione e correzione degli errori, esclusione dei nodi mal funzionanti, sincronizzazione e bit-timing. Le caratteristiche del Transfer Layer costituiscono il nucleo del protocollo CAN e sono quindi rigidamente specificate .
Per quanto riguarda la definizione dei messaggi, in figura 2 è riportata la struttura di un DATA frame.
Figura C.3 Struttura del frame per il protocollo CAN.
Tra i sottoblocchi, oltre all’identificatore, si possono riconoscere, il campo relativo ai dati, in genere inferiore a 8 byte, quello di CRC (Cyclic Redundancy Check) per il controllo degli eventuali errori di trasmissione, costituito da 15 bit. L’InterframeFace Space (IFS) separa due messaggi consecutivi.
La gestione delle collisioni è del tipo CSMA (Carrier Sense Multiple Access): quando un nodo trasmette un bit, controlla che sul bus sia presente la stessa informazione: se sì, continua, altrimenti, nel caso un altro nodo stia trasmettendo un bit dominante, interrompe la comunicazione, per poi riprenderla in seguito. A determinare la priorità del frame è l’identificatore.
APPENDICE
D
FIRMWARE
1. Funzioni per la conversione dati tramite ADC del microcontrollore
void init_ADC() INIZIALIZZAZIONE ADC
{
ADCF = 0x87; configuro P1.0 (batteria), P1.1(corsa), P1.2(corrente),
---P1.7(temp) come ingresso ADC
ADCLK = 12; Clock ADC = Fosc/(2*ADCLK) kHz (max 700 kHz)
ADCON = 0x20; EADC = 1;
}
void adc_driver() CONVERSIONE A/D DEI DATI
{
Int16 appoggio;
ADCON &= ~MSK_ADCON_ADEOC; pulisce i flag della conversione
switch(_adc_channel) {
case BATTERIA_ADC_CH:
appoggio = ADDH - BYTE1(batteria); batteria += appoggio;
_adc_channel = SOSPENSIONE_ADC_CH; break;
case SOSPENSIONE_ADC_CH:
appoggio = ADDH - BYTE1(sospensione); sospensione += appoggio;
_adc_channel = CORRENTE_ADC_CH; break;
case CORRENTE_ADC_CH:
appoggio = ADDH - BYTE1(corrente); corrente += appoggio;
if (ADDH >= MAX_CORRENTE) { fine_corsa = 1; stato_m = OFF;
MOTORE(stato_m); spengo motore
} else fine_corsa = 0; } else cicli_attesa = 0; _adc_channel = TEMP_ADC_CH; break; case TEMP_ADC_CH: temperatura = ADDH; _adc_channel = BATTERIA_ADC_CH; break; default: _num_adc_conv = 1;
15
}
_num_adc_conv--;
adc_start_conv_interrupt(_adc_channel, _num_adc_conv); }
2. Funzioni per la lettura di velocità e precarico tramite PCA in modalità capture
void init_pca() INIZIALIZZAZIONE PCA {
CMOD = 0x05; scelgo come clock l’overflow del timer0 e abilito interrupt quando c'è overflow
TMOD = TMOD & 0xF0; configurazione del timer0
TMOD = TMOD | 0x02; seleziono il modo 2 (a 8 bit con autoreload)
TCON = TCON & 0xCF; disabilito timer0 e resetto flag relativo
}
void mis_freq_driver() {
Uchar aux, ramo_ov; Uchar ccapl, ccaph;
EC = 0; disabilito le interruzioni provenienti dal PCA guardo chi ha generato l'interrupt: precarico o velocità precarico
if (CCON & MSK_CAPTURE_MISURA_PRECARICO) {
CCON = CCON & MSK_CAPTURE_MISURA_PRECARICO; if(dir_m==MOTORE_UP) { if (precarico < 0xFFFF) precarico++;} else {if (precarico >0) precarico--;}
}
else {
velocità
aux = CCON; leggo registro di controllo
leggo i registri di cattura del modulo coinvolto nella misura corrente
ccapl = CCAPL_MISURA_VELOCITA; ccaph = CCAPH_MISURA_VELOCITA; ramo_ov = 0;
controllo se CF = 1 e CCF0 = 1 e in quel caso decido quale delle due è arrivata prima
if ((aux & msk_capture) && (aux & MSK_OVERFLOW) && (ccaph==0)) ramo_ov = 1;
if((aux & msk_capture) && !ramo_ov) {
CCON = CCON & ~msk_capture; resetto flag CCF0
if(!evento_catturato) primo evento
{ evento_catturato = 1; start_time_H = ccaph; start_time_L = ccapl; } else {
stop_time_H = ccaph; stop_time_L = ccapl; num_eventi++;
} }
else ramo overflow: la misura corrente è terminata
{
reset_mis_freq(); scrivo il risultato della misura e configuro la misura succesiva
} }
EC = 1; riabilito interruzioni provenienti dal PCA
}
3. Funzione per il settaggio della porta seriale UART per la comunicazione
con l’esterno ( baud rate 38400)
void init_uart () INIZIALIZZAZIONE UART
{
PCON = PCON & 0X3F; selezione SM0 in SCON
SCON = 0x50; seleziono mode 1(8 bit, baud rate variabile) non mulitiprocessor communication e abilito la ricezione. Utilizzo overflow del timer2(modalità clock-output) per generare clock Uart
T2CON = 0; TH2 = (65536-9); TL2 =(65536-9); baud_rate = FT2clock/(4*(65536-RCAPH\RCPAL)) RCAP2L = LOW(65536-26); RCAP2H = HIGH(65536-26); TCLK = 1; RCLK = 1; TR2 = 1; attiva il timer
TI = 0; azzero flag interrupt relativo a tx ok
RI = 0; azzero flag interrupt relativo a rx ok
ES = 1; abilito uart a generare interrupt
4. Funzione per l’invio dati: PERIODO_LOG indica il tempo di aggiornamento del pacchetto (nella nostra applicazione è impostato 20 ms).
void logging() {
static periodo = 0;
if (enable_log && (stato_nodo == STATO_ON)) {
periodo++;
if (periodo == PERIODO_LOG) {
17 preparo il pacchetto
EA = 0; cav = cav_lat; stato_H &= 0xF0;
stato_H |= (stato_algoritmo & 0x0F); pacchetto_log[0] = stato_L; pacchetto_log[1] = BYTE1(sospensione); pacchetto_log[2] = BYTE1(precarico); pacchetto_log[3] = BYTE0(precarico); pacchetto_log[4] = BYTE1(corrente); pacchetto_log[5] = BYTE1(batteria); pacchetto_log[6] = BYTE1(delta_tempo); pacchetto_log[7] = BYTE0(delta_tempo); pacchetto_log[8] = num_cicli_contati; pacchetto_log[9] = temperatura; pacchetto_log[10] = stato_H; pacchetto_log[11] = BYTE0(corrente); pacchetto_log[12] = livello_precarico; pacchetto_log[13] = nuovo_livello_precarico; EA = 1; TI = 1; abilito trasmissione } } else periodo = 0; }
5. Funzione per la ricezione comandi
void rx_carattere() {
static type_stato_rx stato_rx; Uchar carattere_rx; carattere_rx = SBUF; switch(stato_rx) { case WAIT_RX: switch (carattere_rx) {
case 'O': abilita logging
enable_log_rx = TRUE;
stato_rx = WAIT_TRAILER_RX; break;
case 'C': disabilita logging
enable_log_rx = FALSE;
stato_rx = WAIT_TRAILER_RX; break;
case 'R': abilita controllo remoto
controllo_remoto_rx = TRUE; stato_rx = WAIT_TRAILER_RX; break;
case 'I': disabilita controllo remoto
controllo_remoto_rx = FALSE; stato_rx = WAIT_TRAILER_RX; break;
azzera_precarico_rx = TRUE; stato_rx = WAIT_TRAILER_RX; break;
case 'M': attiva motore(seguito dalla direzione)
stato_rx = MOTORE_RX; break;
case 'S': setta precarico(seguito dal numero di livello)
stato_rx = SETTA_RX; break; default: stato_rx = WAIT_TRAILER_RX; break; } case SETTA_RX: livello_precarico_rx = ascii_to_bin(carattere_rx); setta_precarico_rx = 1; stato_rx = WAIT_TRAILER_RX; break; case MOTORE_RX: switch (carattere_rx) { case '+': attiva_m_rx = 1; m_up_down_rx = 1; stato_rx = WAIT_TRAILER_RX; break; case '-': attiva_m_rx = 1; m_up_down_rx = 0; stato_rx = WAIT_TRAILER_RX; break; default: stato_rx = WAIT_TRAILER_RX; } break; case WAIT_TRAILER_RX:
if (carattere_rx == TRAILER_RX) stato_rx = WAIT_RX; break;
default:
stato_rx = WAIT_TRAILER_RX; }
6. Implementazione della macchina a stati per il controllo del motore
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)
19 { attiva_m = 0; cmd_m = 1; dir_m = m_up_down; stato_controllo = IDLE_CTRL; done = 1; } else if(setta_precarico) { setta = 1; setta_precarico = FALSE; nuovo_precarico = OFFSET_PRECARICO+nuovo_livello_precarico*DELTA_PREC ARICO; 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: if(fine_corsa) { 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; }
7. Corpo principale del ciclo
main()
{ tutte le variabili sono a 0 (il compilatore inserisce la porzione di codice che azzera la memoria) mentre le porte di I/O (dopo reset hardware) sono a 1
EA = 0; disabilitazione generale delle interruzioni
stato_nodo = STATO_RESET; RESET
CKCON = CKCON | 0x01; 6 cicli x istruzione inizializzazione periferiche uC
init_uart(); init_timer1(); init_pca(); init_ADC();
inizializzazione misura frequenza
reset_mis_freq();
inizializzazione ciclo lento
task_in_progress = 1;
inizializzazione variabili globali enable_log = FALSE; sospensione = 0; precarico = 0; batteria = 0; dir_m = 1; controllo = 0; controllo_rx = 0;
abilito generale delle interruzioni
EA = 1; CICLO LENTO while(1) { if (task_in_progress) { task_in_progress = 0; esecuzione task lettura_ingressi_locali(); calcola_nuovo_stato_nodo(); esegui_controllo(); scrivi_uscite_locali(); logging(); }
attesa di un nuovo tick
idle();
}
DEFINIZIONE VETTORI DI INTERRUPT
Interrupt(driver__tick_sistema(void), 3) driver che gestisce l'interrupt generata dal TIMER 1
{
static conta_tempo = 0;
static conta_tempo_ADC = 0;
TF1 = 0; riazzera flag interrupt sampling ADC if (conta_tempo_ADC == CONTA_CICLI_ADC) { adc_start_conv_interrupt(BATTERIA_ADC_CH, 4); conta_tempo_ADC = 0; }
21 else conta_tempo_ADC ++; tick di sistema if (conta_tempo == CONTA_CICLI_TIMER1) { task_in_progress = 1; conta_tempo = 0; } else conta_tempo ++; }
Interrupt(driver_uart(void), 4) driver che gestisce l'interrupt generata dalla UART
{
if (TI) tx_carattere(); else rx_carattere(); }
Interrupt(it_6(void), 6) driver che gestisce l'interrupt generata dal PCA
{
mis_freq_driver(); }
Interrupt(it_8(void), 8) driver che gestisce l'interrupt generata dall'ADC
{ adc_driver(); 8. Algoritmo di controllo case START: controllo = 0; enable_log = 1; done = 0;
azzera_precarico = 1; azzero precarico
livello_precarico = 0; stato_algoritmo_saved = READY; stato_algoritmo = WAIT; break; case READY: set = FALSE;
if(!cav_lat) stato_algoritmo = MEASURE; else if(controllo_remoto_rx) { enable_log_rx = 1; attiva_m_rx = 0; setta_precarico_rx = 0; stato_algoritmo = REMOTE; } break; case MEASURE: leggi = TRUE;
1. calcolo velocità e accelerazione e controllo se è finita una nuova misura di velocità if(nuova_misura_vel) { nuova_misura_vel = 0; if(delta_tempo==0) vel = 0; else { vel = num_cicli_contati; vel = vel << 24; vel = vel/delta_tempo; }
if(vel>vel_prec) acc = vel - vel_prec; else acc = vel_prec - vel;
vel_prec = vel; }
if((vel < VEL_MAX) && (vel > VEL_MIN) && (acc < ACC_MAX)) { vel_inrange = TRUE; if(cicli_inrange_prima_misura >= CICLI_INRANGE_PRIMA_MISURA) { cicli_misura++; corsa_media += BYTE1(sospensione); if(cicli_misura >= DURATA_MISURA) {
2. valuto nuovo livello precarico tramite confronto con soglie if((corsa_media - CORSA_ DESIDERATA)>=0)
{
segno_correzione= 1;
errore_corsa_media = corsa_media - CORSA_ DESIDERATA; }
else {
segno_correzione= -1;
errore_corsa_media = CORSA_ DESIDERATA - corsa_media; }
if(errore_corsa_media < ERRORE_CORSA_MEDIA_0) nuovo_livello_precarico = livello_precarico; else if(errore_corsa_media < ERRORE_CORSA_MEDIA_1)
nuovo_livello_precarico = livello_precarico + segno_correzione; else if(errore_corsa_media < ERRORE_CORSA_MEDIA_2)
nuovo_livello_precarico = livello_precarico + 2*segno_correzione; else if(errore_corsa_media < ERRORE_CORSA_MEDIA_3)
nuovo_livello_precarico = livello_precarico + 3*segno_correzione; else if(errore_corsa_media < ERRORE_CORSA_MEDIA_4)
nuovo_livello_precarico = livello_precarico + 4*segno_correzione; else if(errore_corsa_media < ERRORE_CORSA_MEDIA_5)
nuovo_livello_precarico = livello_precarico + 5*segno_correzione; else if(errore_corsa_media < ERRORE_CORSA_MEDIA_6)
nuovo_livello_precarico = livello_precarico + 6*segno_correzione; else nuovo_livello_precarico = livello_precarico + 7*segno_correzione; if(nuovo_livello_precarico<0) nuovo_livello_precarico = 0;
else if(nuovo_livello_precarico>7) nuovo_livello_precarico = 7; cicli_misura = 0; corsa_media = 0; cicli_inrange_prima_misura = 0; stato_algoritmo = PRELOAD_SETTING; cicli_nuova_misura = CICLI_NUOVA_MISURA; cicli_vel_zero = CICLI_VEL_ZERO; leggi = FALSE; } } else cicli_inrange_prima_misura++; } else { vel_inrange = FALSE; cicli_misura = 0; corsa_media = 0; cicli_inrange_prima_misura = 0; } if(cav_lat) {
23 stato_algoritmo = START; leggi = FALSE; } break; case PRELOAD_SETTING:
diff_livelli_precarico = nuovo_livello_precarico - livello_precarico;
if((diff_livelli_precarico < -1) || (diff_livelli_precarico > 1) || ((diff_livelli_precarico!=0) && !set)) { stato_algoritmo_saved = PRELOAD_SET; done = FALSE; setta_precarico = TRUE; stato_algoritmo = WAIT; setting = TRUE; }
else stato_algoritmo = PRELOAD_SET; break; case PRELOAD_SET: cicli_nuova_misura--; setting = FALSE; set = TRUE; 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 = MEASURE; case WAIT:
if(done) stato_algoritmo = stato_algoritmo_saved; else if(errore) stato_algoritmo = ERROR;
break; case ERROR: break; default: stato_algoritmo = START; break;
APPENDICE
E
Misure indirette: La Pressione
Vediamo come tramite la conoscenza della pressione del circuito idraulico sia possibile risalire in maniera indiretta alla corsa della sospensione.
Riscriviamo l’equazione del sistema all’equilibrio, considerando la pressione dell’olio: ' ) ( ' P M A A molla P S F k A A F F = ⋅ + = ⋅ + +
dove la superficie S è la superficie della corona circolare del pistone di regolazione del precarico e FA’ è la forza d’attrito che ostacola il movimento delle guide del
precarico.
Figura D.1: Schema di funzionamento del precarico.
A questo punto trascurando l’attrito si ottiene: ) (AP AM k S P⋅ = ⋅ + da cui: P M A k S P A = ⋅ − S Pressione=P PRECARICO S FA’ FA’
25 Per poter leggere tale grandezza indagare su una possibile soluzione, il sistema, in un primo momento, è stato dotato di un trasduttore per la misura della pressione. Per stabilire il sensore da utilizzare bisogna capire prima a quali pressioni è sottoposto il circuito idraulico. E’ necessario valutare, quindi, il carico massimo che può gravare sulla sospensione, e la superficie del pistone che regola il precarico, sulla quale agirà la forza della molla.
Per la realizzazione delle prove sperimentali è stato scelto il sensore CTE8050 della Sensor Technics poiché permette un montaggio facilitato grazie al suo connettore filettato da 1/8 di pollice, ovvero con le stesse caratteristiche di tutto il circuito idraulico della sospensione.
Il montaggio di tale sensore richiede comunque una certa attenzione poiché bisogna scaricare il circuito idraulico del sistema e quindi, una volta inserito il trasduttore, riempirlo d’olio facendo attenzione ad eliminare tutta l’aria.
Figura D.2 Sensore di pressione SensorTechnics, serie CTE8000 e schema di montaggio.
La tensione di uscita è proporzionale alla pressione differenziale misurata ( range 0-50 bar) ed è compresa, per il modello scelto, tra 0 e 5 V.
I risultati ottenuti fanno riferimento a test effettuati caricando e scaricando pesi dal banco prova su cui era montata una sospensione del tipo utilizzato su scooter Piaggio Exagon che permette una correzione del precarico di 37 kg per una corsa del pistone di regolazione di 34mm.
tempo che il motore è acceso, sia poco indicativa poiché la quantità d’olio rilasciata dal motore non passa istantaneamente nella camera posta in testa alla sospensione ma per alcuni secondi rimane all’interno del tubo che collega l’attuatore alla sospensione, dando così una lettura di pressione superiore rispetto all’equilibrio (quando, cioè, tutto l’olio pompato dal motore è travasato nella camera della sospensione, andando a spostare il pistone per la regolazione del precarico ).
Quindi per una lettura significativa del sensore di pressione bisogna attendere qualche secondo dallo spegnimento del motore dell’attuatore
PRECARICO Min 50% Max
Pressione (bar) Pressione (bar) Pressione (bar) PESO (kg)
max min max min max min 66 7,42 7,1 10,7 10,7 13,7 13,7 76 8,27 7,99 11,3 10,7 13,7 13,7 86 9,41 8,6 12,4 11,3 13,7 13,7 96 11,1 9,41 13,5 12,1 15,1 13,7 106 12,3 10,4 14,18 13,1 16,1 14,3 116 13,5 11,6 16,1 14,3 17,1 15,3 126 14,5 12,7 17,4 15,4 18,5 16,3 136 15,5 13,8 18,5 16,5 20 17,3 146 16,4 15 19,7 17,7 21 18,4 156 16,8 15,7 21,1 18,7 21,8 19,7 166 17,7 16,7 22,4 20,2 22,8 21 176 18,5 17,5 23,2 21,5 23,7 21,8 186 19 18,1 23,5 22,7 24,5 23,5 196 19,5 18,8 24,8 24 26 24,2
Tabella :Valori di pressione rilevati nelle misure
Come ci si aspettava, il sistema con una molla più precaricata, a parità di peso, è sottoposto ad una pressione maggiore (la forza della molla è maggiore perché AP
è maggiore); mentre per mantenere la pressione costante all’aumentare del peso devo diminuire il precarico.
27 La lettura dei dati evidenzia come anche questa grandezza risenta dell’isteresi della sospensione. 0 5 10 15 20 25 30 p re s s io n e
Figura D.3 Isteresi della pressione a precarico medio.
Una volta conosciuti AP e k è possibile eseguire una misura indiretta della corsa: Sapendo che la corsa del pistone (0-34 mm) varia linearmente con la resistenza letta sul sensore di precarico, ricaviamo facilmente AP:
PREC c
AP = ⋅
Dove PREC indica il valore letto sul sensore di precarico e c è la costante di conversione.
Per quanto riguarda il k della molla, bisogna precisare che le molli per sospensioni sono costruite in modo da avere una costante elastica che cresce all’aumentare del carico (molle progressive).
Questo complica la misura indiretta della corsa poiché il k diventa una funzione dello schiacciamento della molla stessa (AM + AP ).
Si è cercata allora una funzione che ottimizzasse l’andamento di k: il valore di corsa indiretta è però ancora poco significativo, essendo affetto da un errore troppo rilevante dovuto all’incertezza legata agli attriti in gioco. Tra gli obiettivi dell’evoluzione del software c’è il tentativo di migliorare questa misura.
