4BE Esempi/esercizi di progetto sistemi HW/SW

Transcript

Edited by Foxit PDF Editor
1 di 18
Copyright (c) by Foxit Software Company, 2004
For Evaluation Only.
INTERFACCE DI INPUT/OUPUT
Sono circuiti che permettono ai sistemi digitali (come il PC o un sistema HC11) di collegarsi a periferiche esterne come tasti o led.
Nel caso più semplice si presentano all'esterno come connettori con tanti pin (poli) sui quali il sistema emette dei segnali (se sono di
OUTPUT) oppure riceve dei segnali (se sono di input).
Dal punto di vista del programmatore queste interfacce possono essere viste come celle di memoria (tipicamente) di 1 BYTE =8bit.
Ogni bit corrisponde ad un pin del connettore. In una interfaccia di ingresso una tensione ALTA/BASSA applicata dall'esterno su un pin
si riflette in un valore 1/0 di un determinato bit all'interno della cella.
In una interfaccia di OUTPUT ponendo ad 1 (tramitea pposite istruzioni all'interno di un programma) un certo bit della cella, si ottiene
l'effetto di produrre una tensione ALTA/BASSA su un determinato pin dell'interfaccia.
Ogni interfaccia è identificata da un indirizzo (numero intero). Ad esempio sulla porta parallela del PC sono presenti delle interfacce di
OUPUT e di INPUT poste rispettivamente agli indirizzi 0x378 e 0x379.
Sistemi di controllo analogici Aldini 30/01/08
Figura 2. Sui PC sono disponibili molte interfacce di
INPUT/OUTPUT, ognuna identificata da un indirizzo.
LA PORTA PARALLELA DEI PC
La porta parallela dei PC si presenta come un connettore a 25
poli (v. fig.1). Viene chiamata spesso interfaccia anche se i
diversi pin in realtà corrispondono a diverse interfacce, di INPUT
e di OUPUT. E' nata per collegare ai PC una stampante ma puo'
essere benissimo usata anche per altri scopi: ad esempio ai pin
2..9 possono essere collegati 8 led ed ai pin 10,11,12,13,15,
cinque tasti o switch. In figura 3 vengono mostrati con maggiore
dettaglio il significato e la direzione dei segnali per tutti i pin
della parallela. Sono anche mostrati i collegamenti con la scheda
di test usata in laboratorio.
COME SI ACCEDE ALLE PORTE DI I/O.
(Cioè come si scrive nelle interfacce di OUTPUT e si legge dalle
interfacce di INPUT)
Dal punto di vista del programmatore, le interfacce (o porti), possono
essere assimilate, (RIPETO IL CONCETTO) a delle celle di un BYTE
= 8 BIT con la particolarità che cio' che leggiamo (se sono di INPUT) o
scriviamo (se sono di OUPUT) in esse corrisponde bit a bit allo stato
alto/basso di determinati pin dell'interfaccia.
Ogni porto è identificato dal suo indirizzo (è un numero che contraddistingue ogni porto). Per porre a 1 (“accendere”), ad esempio, tutti i pin del porto
che sta all'indirizzo 0x378, basta mettere dentro questo porto il valore 1111111, ovvero in esadecimale 0XFF o in decimale 255.
SCRITTURA su un porto di OUT
Sui PC, usando il linguaggio C, è disponibile una funzione apposita per scrivere su un porto di OUTPUT. Si chiama outportb, ha due argomenti:
l'indirizzo del porto in cui scrivere ed il valore da scriverci dentro.
Sintassi: ouportb( indirizzo, dato); Ad esempio per porre a Vcc tutti i pin del porto 0X378:
ouportb(0x378,0xFF);
NB: in winXP occorre mettere nel programma #include "portio.h", ed avere precedentemente caricato i driver (port95nt.exe scaricabile da internet)
Nei sistemi HC11 che vedremo in seguito, l'istruzione che scrive su un porto di out é
MB(indirizzo) =dato;
LETTURA di un porto di INPUT
Sui PC, usando il linguaggio C, è disponibile una funzione apposita per leggere un porto di INPUT. Si chiama inportb, ha un argomento: l'indirizzo
del porto da cui leggere, e restituisce un valore di ritorno, che è il dato letto. variabile= inportb( indirizzo);
Ad esempio per leggere lo stato dei pin del porto 0x379, e memorizzarlo nella variabile PIPPO:
PIPPO=inportb(0x379);
Nei sistemi HC11 si puo' usare l'istruzione MB(indirizzo) come mostrato nell'esempio seguente
PIPPO=MB(0x379);
Segue un esempio di programma che accende un led collegato al pin 2 della parallela (bit N. 1 della cella 0x378) se un tasto collegato al pin 15 (bit N. 3 della
cella 0x379) è premuto (quindi il pin è a massa, come mostrato in fig.1)
#include “portio.h” //necessario nei sistemi XP
unsigned char PIN,POUT; //variabili di appoggio per memorizzare lo stato (livelli dei pin) dei porti di ingresso ed uscita
main()
{ while(1) //ciclo infinito
{PIN=inportb(0X379);
//leggo e metto in PIN lo stato degli 8 pin del porto 0x379
if ( (PIN&8) = =0) {POUT = POUT | (1); } //se il pin numero 15 della parallela (corrisponde al bit N. 3 della cella 0x379) è a massa..
if ( (PIN&8) ! = 0) {POUT = POUT & (~1); } //metto a 0 il bit numero 0 di POUT, così spegnero' il led corrispondente a questo bit
outportb(0X378)=POUT; //lo stato desiderato dei pin del porto 0x378 , che prima ho preparato nella variabile POUT, adesso lo
//trasferisco sul porto(cioè sul circuito che pilota i pin del connettore)
}
}
SRUTTURA BASE DEI PROGRAMMI DI CONTROLLO
2 di 18
Chiamiamo programmi di controllo quelli che debbono gestire (generare/testare) dei segnali binari ricevuti o emessi tramite opportune interfacce di
INPUT (tipo 74HC244) o di OUTPUT (tipo 74HC373)
I segnali di ingresso sono generati, nel caso più semplice da TASTI.
I segnali di uscita sono generati dal nostro sistema (dal nostro programma) e possono comandare, nel caso più semplice, l'accensione/spegnimento di
LED.
Interfacce (o porti di I/O)
Le interfacce o porti di OUTPUT sono assimilabili a celle, identificate da un indirizzo che si possono (tipicamente) solo scrivere. I singoli bit di queste
celle accendono/spengono dei segnali binari, uscenti su determinati pin (connettori)
del sistema.
Le interfacce o porti di INPUT sono assimilabili a celle, identificate da un indirizzo,
che si possono solo leggere. I singoli bit di queste celle corrispondono allo stato alto/
basso di determinati segnali binari, entranti in determinati pin (presenti su certi
connettori) del sistema come quello della porta parallela nei PC.
ISTRUZIONI PER ACCEDERE ALLE INTERFACCE/PORTI DI I/O1
Nelle celle (variabili) ordinarie i dati si inseriscono con gli operatori di assegnamento: esempio PIPPO=0XFF; mette 0XFF nella cella di nome PIPPO
Nelle celle delle interfacce di I/O i dati si inseriscono o leggono come indicato di seguito.
In ambito PC (DOS/WIN98 oppure windows XP con driver appositi indicati a lezione2) si usano le funzioni
ouportb(indirizzo,dato) ed inportb(indirizzo)
In ambito HC11 (con l'ambiente ALVIN) per accedere alle interfacce di I/O si puo' usare la notazione
MB(indirizzo) (ad esempio MB(0x800) rappresenta la cella identificata dall'indirizzo 0x800)
Esempi:
Per porre a 1 (“accendere”), ad esempio, tutti i pin del porto che sta all'indirizzo 0x378, basta mettere dentro questo porto il valore 111111, ovvero in
esadecimale 0XFF o in decimale 255.
In un programma per PC l'istruzione che ottiene questo effetto è
ouportb(0x378,0xFF);
In un programma per HC11 potrebbe essere
MB(0x3F8) = 0XFF;
Sui PC è ad esempio disponibile un connettore a 25 poli indicato come 'porta parallela' che contiene (tra gli altri) un porto di uscita (8pin) posto
all'indirizzo 0x378. A questi pin posiamo collegare ad esempio 8 led. L'istruzione ouportb(0x378,0xFF); li accende tutti
Per leggere il dato presente in una cella (interfaccia) di INPUT memorizzandolo in una certa variabile PIPPO
PIPPO= inportb(indirizzo); oppure in ambito HC11
PIPPO=MB(indirizzo);
Ad esempio per leggere e mettere in PIPPO il dato presente nella cella 0x379 della parallela di un PC: PIPPO=inportb(0X379);
GESTIONE DEI DISPOSITIVI DI I/O CON TECNICA 'POLLING'
La gestione di dispositivi di I/O collegati al micro può essere realizzata utilizzando
diverse tecniche. Di seguito viene descritta quella più semplice chiamata “polling”.
Come si nota osservando la figura, l' algoritmo di controllo e’ costituito
fondamentalmente da un ciclo
che termina solo con lo spegnimento della macchina che lo esegue ed e’ per questo detto
infinito. All’ interno del ciclo viene rilevato lo stato di tutti i segnali (o più in generale
dei dispositivi) connessi al sistema e vengono svolte le azioni richieste dalla loro
eventuale attivazione.
Questa tecnica di gestione dei dispositivi si chiama “polling”.
Il ciclo infinito ha una durata massima che dipende dal numero di istruzioni che contiene e dal
tempo che il micro impiega a per eseguirle.
Per avere un riferimento numerico, si immagini che l' HC11 (ad 8Mhz) impiega circa 2 us per
eseguire le istruzioni (in linguaggio macchina!) più comuni.
Tanto per avere un dato di riferimento che ci permetta di svolgere in seguito delle considerazioni
intuitive, assumeremo d'ora in avanti che la durata del ciclo infinito sia 1ms.( È un valore fissato
in modo del tutto arbitrario, quello preciso dipende dalla particolare applicazione ed andrebbe
calcolato caso per caso)
NB: Perché questa tecnica funzioni correttamente occorre ovviamente che il tempo di attivazione
di ciascun dispositivo duri almeno tanto quanto l' esecuzione di una singola ripetizione del ciclo infinito.
1
Per accedere direttamente alle celle di memoria o I/O nei sistemi HC11 è possibile:
1)
2)
definire dei puntatori inserendovi l'indirizzo delle celle cui si vuole accedere
Ad esempio per accedere alla cella 0x800 posso definire il puntatore PIPPO così
unsigned char *PIPPO = (unsigned char *)(0X800);
Per azzerare la cella 0x800 potrò fare
*PIPPO=0;
Usare la notazione MB(indirizzo_della_cella) disponibile nell'ambiente ALVIN
Per azzerare la cella 0x800 basterà fare
MB(0x800)=0;
2
in windows XP occorre mettere nel programma #include "portio.h", ed avere precedentemente caricato il driver port95nt.exe scaricabile da internet...
Lettura dei livelli e dei fronti
3 di 18
Una delle scelte fondamentali che il programmatore deve compiere riguarda il tipo di attivazione dei dispositivi da controllare, in
particolare deve decidere se leggere i fronti oppure i livelli dei segnali che questi dispositivi emettono.
Bisogna ricordare che il ciclo infinito viene ripetuto moltissime volte al secondo dal micro. Se nel ciclo è presente un test sul livello di un
segnale, questo test sarà verificato per tutto il tempo di attivazione del segnale. Se tale durata è ad esempio un secondo, ed il micro
compie in un secondo mille ripetizioni (giri) del ciclo infinito, il test sarà verificato 1000 volte per ogni attivazione del segnale.
I test sui fronti sono invece verificati una volta soltanto per ogni attivazione del segnale.
I due esempi seguenti illustrano questo problema e le considerazioni da fare per risolverlo.
fig 1: In questo caso è corretto leggere i livelli e non i fronti dei segnali A e B
fig 2: In questo caso è necessario leggere i fronti del segnale B
Codifica degli algoritmi di controllo
● Generalmente all'inizio del ciclo senza fine vengono letti tutti i segnali di ingresso (si legge la cella/BYTE/PORTO ai cui “pin” sono collegati i
segnali) memorizzandoli nella forma di un BYTE in opportune variabili, ad esempio P244, o PIN (di tipo unsigned char) .
Su PC (per esempio) P244= inportb(0X378);
Su HC11
P244 = MB(0X378)
;
● All'interno del ciclo infinito
■ si testano i livelli /fronti dei segnali testando i valori dei bit della variabile (ad esempio P244) in cui è
stato memorizzato il loro stato, ad esempio P244. usando le formule per il test. (vedi punti Z1, Z4,Z7 della figura 3)
■ si modificano in una variabile di appoggio, ad esempio P373, o POUT, i bit corrispondenti ai pin dell'interfaccia di USCITA che si vogliono
accendere/spegnere /commutare usando le formule per il set/reset/inversione) (vedi punti Z3,Z5,Z8)
FORMULE PER IL SET/RESET/TEST/ INVERSIONE DI UN BIT
set
PIPPO=PIPPO | 2 n
reset
PIPPO=PIPPO & (~2 );
inversione
;
(esempio PIPPO=PIPPO|4; mette mette a 1 il bit numero 2 di PIPPO)
n
PIPPO=PIPPO ^ 2
n
n
;
test su 1
if (PIPPO & 2 )
test su 0
if ( !(PIPPO & 2n) ) {.....}
test sul
fronte +
{.....}
(mette a 0 il bit numero n di PIPPO
(commuta il bit numero n di PIPPO)
(esegue ..... se il bit numero n di PIPPO vale 1)
(esegue ...... se il bit numero n di PIPPO vale 0)
n
if ( (PIPPO & 2 ) && ! ( PIPPOprec & 2n) ) {.....} (esegue ...... se il bit n di pippo è
passato da 0 ma 1)
● Alla fine del ciclo infinito si scrivono (inviano) sui porti di output (ad esempio circuiti integrati del 74HC373), i dati preparati nella ( o nelle)
variabile di appoggio P373 (vedi punto Z10)
Su PC
(esempio) outportb(0x378, P373);
Su HC11 (esempio3) MB(0x378)=P373;
● Quando nell'algoritmo ci sono blocchi che testano il fronte di un certo segnale, occorre considerare che questo fronte puo' essere rilevato soltanto
confrontando il valore attuale del segnale (cioè quello letto all'inizio del ciclo corrente e memorizzato ad esempio nella variabile P244), con quello
precedente (cioè quello che abbiamo letto durante il giro precedente) per capire se c'è stata una variazione (0->1 = fronte di salita, 1->0 = fronte di
discesa)
Occorre dunque alla fine di ogni giro, prima di ripetere la lettura che darà i nuovi valori dei segnali, memorizzare in una variabile di appoggio
ad,esempio P244prec, i valori della lettura corrente (vedi punto 9 della figura) che al prossimo giro saranno i 'valori precedenti'
3
oppure si definiscono, all'inizio del programma dei 'puntatori' alle celle (porti di I/O) es:
#define PORTO_USCITA *(volatile unsigned char *) (0x378)
In seguito per scrivere nel porto basta fare, per esempio: PORTO_USCITA = 0XFF; //mette 11111111 nel porto di uscita 0x378
Evaluation Only.
ESEMPIO CAMPIONE DI CODIFICA di un ALGORITMO DIFor
CONTROLLO
(ciclo base di controllo)
4 di 18
Il seguente esempio mostra come si codificano gli algoritmi di controllo in C, a partire da un diagramma contenente i blocchi tipici di test
(sui livelli o sui fronti) e set/reset/inversione. A sinistra è mostrato un algoritmo che commuta L1 ad ogni pressione di P3 e accende o
spegne L4 a seconda che P5 sia premuto oppure no. Si assume che il sistema HC11 disponga di un porto di uscita (integrato 74HC373)
posto all'indirizzo 0x800, e di un porto di ingresso (integrato 74HC244) posto all'indirizzo 0x802. A questi porti sono collegati i due led
ed i due pulsanti come in figura.
Queste variabili in altri testi sono ciamate IN, INprec, O
figura 3: esempio di codifica di un algoritmo di coontrollo
ESERCIZIO 1
Il livello del liquido presente nel serbatoio di figura deve essere mantenuto tra le due sonde metalliche A,B che
danno 1 quando sono bagnate.
Mostra lo schema dei collegamenti, il diagramma a blocchi e la codifica C del sistema che realizza quanto
richiesto accendendo il meno possibile la pompa P. Supponi che i porti di INPUT ed OUTPUT siano collocati agli
indirizzi 0x800 e 0x801.
CODIFICA C
#include ''io68hc11.h''
unsigned char PIN,POUT; / /variabili di appoggio per memorizzare lo stato (livelli
dei pin) dei porti di INPUT ed OUTPUT
main()
{ while(1) //ciclo infinito
{PIN=MB(0X800); //leggo e metto in PIN lo stato degli 8 pin del 244
if ( PIN&1 ) { POUT = POUT & (~2); } //se il pin numero 0 del 244 era
diverso da 0A attiva, spengo la pompa
//se il pin numero 1 del 244 era
uguale a 0B spenta ,accendo la pompa
if ( (PIN&2) ==0) { POUT = POUT | ( 2); }
MB(0X801)=POUT;
//lo stato desiderato dei pin del porto 373 , che prima ho preparato nella variabile
POUT, adesso lo trasferisco sul chip. Solo ora i pin del 373 vengono modificati.
}
}
ESERCIZIO 2
5 di 18
Un sistema HC11 dispone di un porto di ingresso posto all'indirizzo 0x1003 e di un porto di uscita posto
all'indirizzo 0x1004. Al porto di input sono collegti i segnali A,B di due fotocellule poste all'ingresso e all'uscita di
nun corridoio.
Progetta il SW che controlla gli accessi del corridoio di figura in modo che si accenda un led quando il
corridoio è occupato.
Soluzione: utilizzo una variabile cont che incremento ogni volta che uno entra (fronte su A) e decremento
quando uno esce (fronte su B)
Questa variabile dunque tiene il contro dei presenti. Per decidere se accendere il led basta verificare se è >0.
CODIFICA NEL LINGUAGGIO C per HC11:
#include “io68hc11.h”
unsigned char IN, INprec, OUT;
int cont;
main()
{ Inprec=0; cont=0;
while(1) // ciclo infinito
{ IN=MB(0x1003); //lettura del byte all' indirzzo 0x1003
if ( (IN&1) == 1 && (INprec&1) == 0) //se il bit 1 ora vale 1 e prima valeva 0....
{cont ++;
}
if ( (IN&2) ==2 && (INprec & 2) == 0 )
{cont --;
}
if (cont>100) //se ci sono più di 100 persone acc. led (metto a 1 il bit 1)
{ OUT=OUT | 1;
// OUT = OUT | 2°
accendo L
}
else { OUT=OUT & (~1) ;
// OUT = OUT & ( ~2°) spengo L
}
MB (0x1004)=OUT;
INprec=IN ; // il valore attuale delporto di ingresso, presente nella variabile IN
// lo memorizzo in INprec, perché mi servirà' nel confronto
// col nuovo valore che leggero' al prossimo giro
}
}
ESERCIZIO 3
L'ascensore di fig. deve portarsi al piano 0 oppure al piano 1 a seconda che sia premuto P0 oppure P1.
Quando è premuto PA, l'ascensore deve cambiare piano.
Durante il movimento i pulsanti P1, P0 e PA sono ignorati.
S0 ed S1 sono sensori che si portano a 1 quando l'ascensore è presente al piano in cui sono collocati.
MS comanda il motore per la salita, MG per la discesa.
Progetta l'algoritmo (e scrivi la sua codifica C) che
Codifica C
controlla il movimento dell'ascensore in accordo
Debbo ricordarmi a quali pin ho collegatoi segnali di ingresso
con queste specifiche.
e di uscita e quali sono gli indirizzi del porto di ingresso (0x2000)
e di uscita (0x2001)
#include<io68hc11.h>
char unsigned IN,OUT; // oppure P244,P373
main()
{ OUT=0;
//MG ed MS=0, parto col motore spento.
MB(0x2001)=OUT;
while(1) //ciclo infinito
{
IN=MB(0x2000); //lettura degli ingressi. Gli 8 segnali (tra cui Pa..) del 244, vengono memorizzati nella variabile IN.
if (IN & 8)
//S0, pin numero 3 → 23=8, è attivo?
{
OUT= OUT& (~2); MB(0x2001)=OUT; //MG =0
if ( (IN & 4) || (IN & 2 ) ) //PA o P1 sono uguali a uno?
{
OUT=OUT |1;
//MS viene messo a uno
}
}
if (IN & 16)
//S1 è uguale a uno?
{
OUT=OUT &(~1);
1.
if ( (IN&4) || (IN&1) )
{
OUT=OUT |2;
}
}
MB(0x2001)=OUT;
}
}
ESERCIZIO 4 (PROGETTO ASCENSORE COMPRENSIVO DELLA PARTE For
HW) Evaluation Only.
6 di 18
L'ascensore di fig.1 deve portarsi al piano 0 oppure al piano 1 a seconda che sia premuto P0 oppure P1.
Quando è premuto PA, l'ascensore deve cambiare piano.
Durante il movimento i pulsanti P1, P0 e PA sono ignorati.
S0 ed S1 sono sensori che si portano a 1 quando l'ascensore è presente al piano in cui sono collocati.
MS comanda il motore per la salita, MG per la discesa.
Progetta l'HW/SW di un sistema che controlli l'ascensore, utilizzando un HC11,
un chip di SRAM da 8K, un chip di EPROM da 16K, un 244 ed un 373
PROGETTO HW
Di seguito è riportato lo schema elettrico di massima del sistema a uC, comprendente le memorie (SRAM e
EPROM), il PAL, i dispositivi di I/O (244 e 373). L’EPROM essendo una memoria non volatile è destinata a
contenere il programma (le istruzioni), mentre la SRAM è usata per le variabili. Il dispositivo PAL (acronimo di
PROGRAMMABLE ARRAY LOGIC) serve ad abilitare, in base all’indirizzo che il µC pone sull’address bus, il chip
che, in un determinato istante, deve rispondergli.
MAPPA DEGLI INDIRIZZI:
La mappa degli indirizzi stabilisce in quale posizione sono collocati tutti i chip del sistema. Nella compilazione della mappa bisogna seguire alcune regole (per i sistemi HC11):
1 – Alla fine della mappa deve essere presente un chip di memoria non volatile. All'avvio, infatti, il µC legge nelle celle FFFE,FFFF a
quale indirizzo comincia il programma da eseguire Questa memoria serve a contenere il programma da eseguire all’ avvio.
2 – Le memorie collocate all’inizio della mappa devono essere inserite in ordine di capacità decrescente . (per semplificare le
equazioni..)
3 - Le memorie collocate alla fine della mappa devono essere inserite in ordine di capacità decrescente verso l’alto.
EQUAZIONI DEI CHIP-SELECT:
CESRAM = A15∗ A14∗ A13
CEEPROM = A15∗A14
OE244=A15∗A14∗A13∗A12∗A11∗A10∗A9∗ A8∗A7∗A6∗ A5∗A4∗A3∗A2∗A1∗A0∗RD
G373= A15∗ A14∗ A13∗A12∗ A11∗A10∗A9∗ A8∗A7∗ A6∗ A5∗A4∗A3∗ A2∗A1∗A0∗WR
RD= E∗ R/W
WR= E∗ R/W
PROGETTO SW
I pulsanti vanno controllati solo ad ascensore fermo, cioè quando S1 oppure S0 valgono 1.
Quando S0 vale 1, cioè l'ascensore è al piano 0, intanto spengo MG (Motore Giù) perchè potrebbe essere appena arrivato qui (scendendo mosso da
MG=1), e dunque debbo fermarlo; poi guardo se debbo salire al piano 1 → controllo P1 e PA. Se uno dei due risulta attivo accendo il motore per la
salita. Ragionamenti analoghi debbo svolgere quando il motore si trova al piano 1, cioè S1==1.
Codifica C
Debbo ricordarmi a quali pin ho collegato
i segnali di ingresso e di uscita e quali sono
gli indirizzi del porto di ingresso (0x2000)
e di uscita (0x2001)
char unsigned IN,OUT; // oppure P244,P373
main()
{ OUT=0;
//MG ed MS=0, parto col motore spento.
MB(0x2001)=OUT;
while(1) //ciclo infinito
{
IN=MB(0x2000); //lettura degli ingressi. Gli 8 segnali (tra cui Pa..) del 244, vengono memorizzati nella variabile IN.
if (IN & 8)
//S0, pin numero 3 → 23=8, è attivo?
{
OUT= OUT& (~2); MB(0x2001)=OUT; //MG =0
if ( (IN & 32) || (IN & 128 ) ) //PA o P1 sono uguali a uno?
{
OUT=OUT |1;
//MS viene messo a uno
}
}
if (IN & 16)
//S1 è uguale a uno?
{
OUT=OUT &(~1);
if((IN&32)|(IN&64))
{
OUT=OUT |2;
}
}
MB(0x2001)=OUT;
}
}
NEL CASO NON SIA STATO ANCORA SVOLTO IL PROGETTO HW,
Edited
DEVI STUDIARE SOLO LA PARTE SW !! Sistemi di controllo analogici Aldini 30/01/08
7 di 18
by Foxit PDF Editor
ESERCIZIO 5
Un sistema con HC11 dispone di: 1 chip di SRAM da 16K, 2 chip di EPROM (EPR1 ed EPR2) da 16K e 8K, un HPDL2416, un 244 ed un 373
1) Completa lo schema HW di figura indicando dove collegare i segnali P (pulsante), M (comando di accensione/spegnimento di un motore), G
(onda quadra generata da un NE555 con f=1kHz), L (Led), A,B (sensori che si attivano quando sfiorati da un oggetto)
2) Calcola le equazioni dei chip select delle EPROM e dell'HPDL2416
NB: per gli algoritmi seguenti non è consentito inserire cicli di attesa interni al ciclo infinito.
3) Da uno scivolo giungono sul nastro delle lastre. Progetta l' algoritmo che accende il motore M per il solo tempo necessario al trasferimento di ogni
lastra nel raccoglitore. Assumi che durante il trasferimento, nessuna nuova lastra sia fatta scivolare sul nastro
4) Codifica in C l'algoritmo precedente (oppure il 4 bis)
5) Progetta nuovamente l'algoritmo 3, facendo pero' in modo che il motore si arresti solo dopo 2 secondi dal momento in cui la lastra ha abbandonato A.
6) Progetta nuovamente l'algoritmo 3 assumendo però che una nuova lastra possa essere immessa nello scivolo appena risulta sgombro, anche senza
aspettare che le lastre precedenti sia state trasferite nel raccoglitore.
HW-------------------------------------------------------------------------------------------------------------------------
SW --------------------------------------------------------------------------------------------------#include<io68hc11.h>
unsigned char p244,p373,p244p;
main()
{p373=0;
MB(0x800)=p373;
while(1)
{ p244=MB(0x802);
if((p244&2)&&!(p244p&2))
{p373=p373|1;
}
if(!(p244&1)&&(p244p&1))
{p373=p373&(~1);
}
MB(0X800)=p373;
p244p=p244;
}
}
diagramma a blocchi
codifica C
ESERCIZIO 6
TESTO: Un sistema basato sul µC 68HC11, deve essere dotato dei seguenti chip:
● un chip di SRAM (2K), ● un chip di EPROM1 (2K) ● un 373 ● un 244. Le interfacce di I/O debbono essere
collegate ai segnali A,B,L di figura in cui A e B sono barriere ottiche ed L è un led
1) Progetta l'HW del sistema (schema, mappa degli indirizzi, equazioni dei chip-select)
2) Progetta il SW di controllo (ALGORITMO + CODIFICA C) che accende il led L quando l'elica gira in senso
antiorario e lo tiene spento quando gira in senso opposto.
PROGETTO HW:
MAPPA DEGLI INDIRIZZI: vedi figura 2
EQUAZIONI DEI CHIP-SELECT
CESRAM = A15 ⋅ A14 ⋅ A13 ⋅ A12 ⋅ A11
CEEPROM = A15 ⋅ A14 ⋅ A13 ⋅ A12 ⋅ A11
OE 244 = A15 ⋅ A14 ⋅ A13 ⋅ A12 ⋅ A11 ⋅ A10 ⋅ A9 ⋅ A8 ⋅ A 7 ⋅ A 6 ⋅ A5 ⋅ A 4 ⋅ A3 ⋅ A 2 ⋅ A1 ⋅ A0 ⋅ RD
G 373 = A15 ⋅ A14 ⋅ A13 ⋅ A12 ⋅ A11 ⋅ A10 ⋅ A9 ⋅ A8 ⋅ A 7 ⋅ A 6 ⋅ A5 ⋅ A 4 ⋅ A3 ⋅ A 2 ⋅ A1 ⋅ A 0 ⋅ WR
WR = R / W ⋅ E
;
RD = R / W ⋅ E
PROGETTO SW:
CODIFICA NEL LINGUAGGIO C per HC11:
unsigned char P244, P244p, P373;
main()
{ P373=0;MB(0x0801)=P373; //spengo tutti i pin del 373
while(1)
{
P244 = MB(0x0800);
if ((P244 & 1) && ! (P244p & 1))
{ if ((P244 & 2) ==0)
P373&=~1;
else
P373 |= 1;
}
MB (0x0801)=P373;
P244p=P244;
// il valore attuale del 244,
// presente nella variabile in
// lo memorizzo in P244p, perché
// mi servirà' nel confronto col nuovo valore
// che leggero' al prossimo giro
Ad ogni fronte di A, controllo il valore di B;
se B vale 0 (quindi la fotocellula non è oscurata) vuol
dire che l’elica sta girando da A verso B, quindi in senso
orario (spengo il led L).
Se invece al momento in cui si rileva il fronte di A, B
vale 1; vuol dire che l’elica sta girando in senso
antiorario e perciò devo accendere il led L.
}
}
8 di 18
ESERCIZIO 7
La tavola porta pezzi di figura deve muoversi alternativamente tra i due fine corsa Fs ed Fd.
Il movimento verso destra è ottenuto attivando il segnale Ms, quello verso sinistra Md.
Alla pressione del tasto Pstart deve iniziare il movimento della tavola che deve arrestarsi soltanto alla
pressione di Pstop. L'unica posizione di riposo consentita per la tavola deve essere quella
corrispondente all'attivazione di Fd .
1) progetta l'HW usando un chip di SRAM da 2K, uno di EPROM da 4K, un 373,un 244.
(indicando anche i collegamenti del sistema con i segnali Fs,Fd,Pstart,Pstop, MS,MD)
2) progetta il SW e codificalo in C.
PROGETTO HW:
EQUAZIONI DEI CHIP-SELECT:
oe244=A15∗A14∗A13∗A12∗A11∗A10∗A9∗A8∗A7∗A6∗A5∗A4∗A3∗A2∗A1∗A0∗RD
G373= A15∗A14∗A13∗A12∗A11∗A10∗A9∗A8∗A7∗A6∗A5∗A4∗A3∗A2∗A1∗A0∗WR
CsEPROM1=A15∗A14∗A13∗A12
RD= R /W ∗E
WR= R /W ∗E
PROGETTO SW: Nel diagramma di flusso abbiamo usato
una flag Fstop perchè ci dobbiamo ricordare quali dei
due pulsanti Pstop e Pstart è stato premuto per ultimo.
Quando Fstop=1 vuol dire che l'ultimo pulsante premuto
è stato Pstop.
Nell'algoritmo, quidni, ogni volta che vengono premuti
Pstart e Pstop semplicemente ci ricordiamo questi
eventi settando/resettando la flag Fstop.
Quando si attiva Fs non si deve fare altro che invertire il
verso del movimento.
Se invece la tavola è in prossimità di FD, disattiviamo Ms
e poi controlliamo se dobbiamo arrestarci oppure far
ripartire il movimento verso sinistra.
Basterà verificare se la flag Fstop vale 1. In questo caso
infatti vuol dire che l'ultimo pulante premuto è stato
Pstop.
9 di 18
ESEMPIO RIASSUNTIVO COMPLETO DI PROGETTO HW/SW
10 di 18
Un sistema con HC11 dispone di: 1 chip di SRAM da 2K, 2 chip di EPROM (EPR1 ed EPR2) da 32 e 16K, un 244 ed un 373.
1) Completa lo schema HW di figura indicando dove collegare i segnali A,B (barriere ottiche) ed R,G (Led Rosso,Giallo)
2) Calcola le equazioni dei chip select delle EPROM, della SRAM e del 373.
3) Progetta l' algoritmo che accende il led Giallo quando il numero di pezzi trasportati dal nastro raggiunge il valore 100, ed il led Rosso qualora un
pezzo risulti più corto di 2 m. (il Led R deve spegnersi appena viene rilevato un pezzo più lungo di 2m)
4) Codifica in C l' algoritmo del punto precedente.
Soluzione PUNTO 1)
I segnali A,B sono ingressi (sono segnali che il micro deve
leggere), quindi li collego al 244.
I segnali G ed R sono uscite (il micro deve scriverli, cioè
impostarne il valore 1/0) perciò li collego al 373.
Soluzione PUNTO 2)
Per calcolare le equazioni dei chip-select debbo compilare
la mappa degli indirizzi che occupa lo spazio da 0000 a FFFF
(il micro ha 16 fili di indirizzo, Quando tutti sono posti a 1,
per esprimere l'ultimo indirizzo, il numero rappresentato in
esadecimale è FFFF).
Gli ultimi indirizzi della mappa debbono essere coperti da una
memoria non volatile. Nel nostro caso metteremo dunque un
chip di EPROM (la memoria non volatile in fondo è
necessaria perché quando il micro viene acceso/resettato
preleva dalle celle FFFE ed FFFF l'indirizzo del programma
da eseguire).
I chip, sia quelli collocati a partire dal fondo (EPROM) sia
quelli collocati a partire dall'inizio 0000 (SRAM), vanno
disposti in ordine di capacità decrescente (per semplificare la
scrittura delle equazioni)
Metteremo dunque EPR1 (il chip più grande) in fondo, ed
EPR2 sopra. Allo stesso modo disporremo SRAM all'inizio e
solo dopo i chip più piccoli 244 e 373.
0000+
07FF (vedi tabella, riga con 2K)
oppure scrivi undici uno e convertili in
esadecimale (undici perchè 2K=2 11)
7FFF 3FFF = (vedi tabella 16K)
4000
8000 1=
7FFF
debbo determinare l'indirizzo
che precede 8000
FFFF 7FFF = (vedi tabella 32K)
8000
2K=211 ---> scrivo il prodotto da A15 ad A11
11 di 18
Indirizzo di partenza = $0000 , in binario
0000 0000 0000 0000 (nego i segnali sottoposti ad uno 0)
CS _ SRAM =A15 A14 A13 A12 A11
NB: il nome del segnale, CS__SRAM è lo stesso usato nello schema !
32K=215 -->scrivo A15
1000 0000 0000 0000
CS _ EPR1=A15
16K=214--> scrivo il prodotto da A15 ad A14
0100 0000 0000 0000
CS _ EPR2= A15 A14
1 Byte = 20--> scrivo il prodotto da A15 ad A0
0000 1000 0000 0001
G373=A15 A14 A13 A12 A11 A10 A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 WR
Condiziono il chip select dei 373 (si procede in modo analogo
per i 244) con il segnale di abilitazione alla scrittura WR
Soluzione PUNTO 3)
Per contare i pezzi basta usare un contatore, cioè una variabile incrementata di 1 ogni volta che una
delle due barriere, ad esempio A, si attiva.
Le attivazioni da intercettare sono i fronti e NON i livelli. Ogni pezzo infatti, quando entra nel campo
della barriera genera un solo fronte, perciò il blocco CONT++ verrà correttamente eseguito una sola
volta per ogni pezzo. Il livello di A invece resta attivo per ogni pezzo molto tempo, durante il quale il
micro può' compiere molte letture, trovando tutte le volte A=1. Se il blocco CONT++ venisse
eseguito ogni volta che A==1, CONT verrebbe incrementato moltissime volte anche se sta passando
un solo pezzo.
Per rilevare se un pezzo è minore di due metri, basta guardare, non appena il pezzo raggiunge B
(cioè quando B passa da 0 a 1, cioè presenta un fronte di salita) quanto vale A, che dista da B 2
metri. Se A vale 0 il pezzo è più corto, altrimenti è più lungo
Soluzione PUNTO 4)
#include <io68hc11.h>
unsigned char P244,P244p,P373, CONT;
main()
{ P373=0X00; //tutti i bit a 0
MB(0x801)=P373;
//scrivo sull'integrato HC373 quanto preprato nella
//variabile P373 --> 'spengo' tutti i pin
while(1)
{ P244=MB ( 0X0800); //mem. nella var P244 lo stato degli 8 ingressi del 244
if( (P244 & 2) && !(P244p & 2) ) // faccio &2 perchè A è sul pin 1 e 21 = 2 !!!
{ CONT++;
if ( CONT == 100)
{ P373 =P373 | 2; //G=1
}
}
if( (P244 & 1) && !(P244p & 1) ) // faccio &2 perchè A è sul pin 1 e 21 = 2 !!!
{ CONT++;
if (! (P244 & 2)) //se il segnale A (bit numero 1 --> 21=2 ) vale 0
{ P373 =P373 | 1;
} //R=1
else { P373 =P373 & (~ 1); } // R=0
}
MB(0x801)=P373; //scrivo sul HC373 quanto preparato nella variabile P373
P244p=P244; //memorizzo lo stato del 244 appena letto nella var P244p in
//modo che alla prossima lettura (vei P244=MB(0X800) in essa
//possa trovare lo stato precedente del 244 ed avere così, nelle
//variabili P244 e P244p rispettivamente lo stato attuale e
//quello precedete di tutti i segnali del 244
}//fine while
} //fine main

4BE Esempi/esercizi di progetto sistemi HW/SW

Transcript

Documenti analoghi

copa la vecia! - Treviso Eventi

GIUSEPPE MAGNIFICO ENTUSIASMA CON LE SUE “PIN UP”-foto

Voltmetro a led per Yaesu FT 857 / FT 897

Scheda Audio Sweex PCI

Yamaha Fazer FZ6 2004-2005

Forum sul FaiDaTe di Aggiustatutto.it

colonna pevero hotel - CharmingSardinia.com

MOD. 04 PGS36_DS erede senza consenso di legit

Accessori: Disegno quotato Collegamento

pin to pin - Archivio Penale