Si usa il compilatore ‘C’ READS51 per processori della famiglia dell’8051 per la scrittura del programma del microcontrollore in modo che la scheda di controllo faccia quanto detto nel paragrafo precedente.
La libreria “sfr51.h” contiene la dichiarazione dei registri SFR e dei loro indirizzi. Si definiscono 5 funzioni : inizializzazione, richiesta, rilascio, rx, tx.
La prima serve ad attivare l’uart e ad inizializzarne il baud rate.
Per prima cosa si attiva la seriale del processore, ponendo REN a ‘1’; in contemporanea si impone il modo 1, ovvero si sceglie l’uart a 8 bit con baud rate dato dal timer 1, ponendo SM0 a ‘0’ e SM1 a ‘1’.
In definitiva si pone il registro SCON a 50h=010100002.
Poi si pone il timer 1 in modalità 2, ovvero con T1M1 a ‘0’ e T1M0 a ‘1’, per lavorare col timer a 8 bit con auto-reload e si setta il timer 1 mettendo TR1 a ‘1’.
A tale scopo si fa un or logico tra il valore del registro TMOD e 20h=001000002 in
modo da tenere fisso TIM1 A ‘1’.
Infine si inizializza il baud rate a 19200 b/s ponendo TH1=TL1=FCh= 252 . 10
La funzione “richiesta” chiede l’accesso alla RAM esterna; dal capitolo 3 si sa che a tale scopo si fa richiesta al blocco “arb” ponendo il segnale req_micro a ‘1’ e poi si aspetta fino a quando il segnale ack_micro proveniente da arb non sia andato a ‘1’, il che indica l’assenso
Capitolo 5 : Processore 8051 e UART
Il segnale req_micro è stato collegato a P1.0, ovvero al pin meno significativo del registro P1 del microcontrollore, mentre ack_micro è stato collegato al pin P1.4.
La funzione “rilascio”, invece, comunica all’arb che il processore smette di accedere alla RAM, ponendo req_micro a ‘0’.
La lettura dalla seriale di un dato generico viene fatta attraverso la funzione “rx” che aspetta che il bit meno significativo di SCON, RI, sia a ‘1’.
Una volta che RI è a ‘1’ si legge il byte di dato dopo aver posto RI a ‘0’.
La scrittura sulla seriale di un dato viene fatta attraverso la funzione “tx” che aspetta che il bit TI di SCON sia a ‘1’ e scrive il dato dopo aver posto TI a ‘0’.
Attraverso una struttura a switch si effettua la scrittura e la lettura dei DAC, la lettura dell’ADC, la lettura degli status ed infine la scrittura e la lettura dei command.
Di seguito si riporta il protocollo seriale usato per comunicare tra PC esterno e scheda di controllo.
Il protocollo per la scrittura dei DAC può essere sintetizzato nel seguente modo :
<CMD DAC WRITE> <DAC ADDR> <DAC DATA L> <DAC DATA H> <CRC> Il protocollo di lettura dei DAC ha la seguente struttura :
<CMD DAC READ> <DAC ADDR> <CRC>,
mentre la risposta del microcontrollore ha la seguente struttura : <DAC DATA L> <DAC DATA H> <CRC>
Nel caso di scrittura nei DAC la porta seriale del microcontrollore riceve, quindi, il comando di scrittura, che nel caso in questione è il numero 10, il numero del DAC, da 1 a 5, su cui si vuole scrivere ed infine, uno di seguito all’altro, i due byte in cui sono contenuti i 12 bit del dato da scrivere.
Il processore riceve il comando di calcolare il CRC e di confrontare tale CRC ricevuto dal microcontrollore con quello inviato dall’esterno.
Se i due CRC coincidono il microcontrollore deve puntare all’indirizzo del DAC su cui scrivere (da 8000h a 8009h di figura 1 del capitolo 2), altrimenti esce dalla fase di scrittura.
Nel caso di lettura dei DAC, l’UART del processore riceve il comando di lettura, che nel caso in questione è il numero 20.
Di seguito il microcontrollore deve calcolare il CRC dei byte ricevuti dall’esterno e confrontarlo con il CRC che riceve; se i due CRC coincidono allora il processore deve puntare al DAC da cui si vuole leggere.
Quindi l’UART deve trasmette il primo dei due byte del dato letto, incrementare il puntatore per puntare alla locazione di memoria che contiene il secondo byte del dato e
Capitolo 5 : Processore 8051 e UART
quindi trasmetterlo all’esterno.
La lettura dei DAC termina col calcolo, da parte del microcontrollore, del CRC dei dati trasmessi da quest’ultimo e con la trasmissione di tale CRC.
Il protocollo di lettura degli ADC ha la seguente struttura : <CMD ADC READ> <CRC>,
mentre la risposta del microcontrollore ha la seguente struttura :
<ADC DATA1 L> <ADC DATA1 H> <ADC DATA2 L> <ADC DATA2 H> <ADC DATA3 L> <ADC DATA3 H> <ADC DATA4 L> <ADC DATA4 H> <ADC DATA5L> <ADC DATA5 H> <CRC>
Il protocollo di lettura dell’ ADC prevede una richiesta (attraverso la funzione “richiesta”) di accesso alla RAM, dove sono contenuti i dati dell’ADC.
Il comando di lettura è dell’ADC previsto dal protocollo è il numero 30.
Il processore, quindi, fa il calcolo del CRC, consistente nella somma di ciò che l’UART ha ricevuto dall’esterno, ed esegue il confronto di tale CRC con quello che l’UART riceve.
Si passa ad un ciclo di for per la lettura dei due byte di ciascuno dei 5 ADC insieme al calcolo del CRC ed alla sua trasmissione verso l’esterno.
La lettura dei 5 ADC termina con il rilascio (attraverso la funzione “rilascio”) della RAM.
Il protocollo di lettura degli status ha la seguente struttura : <CMD STATUS READ> <CRC>,
mentre la risposta del microcontrollore ha la seguente struttura : <STATUS DATA > <CRC>
Il protocollo di lettura degli status prevede il comando 40.
Il microcontrollore calcola il CRC di ciò che ha ricevuto e lo confronta con il CRC che l’UART sta ricevendo.
Se i CRC detti sono uguali tra loro allora il processore deve puntare alla locazione (800Ah) dove sono contenuti gli status e deve trasmettere gli status verso l’esterno.
A ciò seguono il calcolo del CRC e la sua trasmissione.
Il protocollo per la scrittura dei command può essere sintetizzato nel seguente modo : <CMD COMMAND WRITE> <COMMAMD DATA> <CRC>
Il comando di scrittura dei command previsto dal protocollo è il numero 50.
L’UART riceve il dato dall’esterno, quindi il processore deve calcolare il CRC e confrontarlo con quello ricevuto.
Capitolo 5 : Processore 8051 e UART
nella memoria dati del processore.
Il protocollo di lettura dei command ha la seguente struttura : <CMD COMMAND READ> <CRC>,
mentre la risposta del microcontrollore ha la seguente struttura : <COMMAMD DATA > <CRC>
Il comando previsto dal protocollo per la lettura dei command è il numero 60. Il processore deve calcolare il CRC e confrontarlo col CRC che riceve.
Se i due sono uguali allora il processore deve puntare alla locazione di memoria dove sono contenuti i command e l’UART trasmette il dato letto.
Quindi il processore calcola il CRC di ciò che è stato trasmesso e l’UART trasmette tale CRC.
Di seguito viene riportato il programma in linguaggio C per il microcontrollore finora descritto.
// --- READS51 generated header ---
// module : C:\Program Files\Rigel\Reads51\Work\8051\micro.c // created : 11:47:58, Wednesday, May 02, 2007
// ---
#include <sfr51.h>
char richiesta(); /* il processore richiede di accedere alla RAM*/
char rilascio(); /* il processore comunica la fine del suo accesso alla RAM*/ char rx(); /* lettura dalla seriale di un dato generico*/
void tx(char uart_data); /* scrittura di un dato generico*/ void inizializzazione(); /* inizializzazione dell’UART*/
void main() { unsigned int*pdac; unsigned int*padc; unsigned int*pstatus; unsigned int*pcommand;
char num_dac_w; char ric_dac1; char ric_dac2; char crc_dac_w;
char num_dac_r; char tx_dac1; char tx_dac2; char crc_dac_r; char crc_dac; char tx_adc1; char tx_adc2; char crc_adc; char crc_adc_r; int i;
char num_status; char stato; char crc_st; char crc_status;
char num_command_w; char dato_command_w; char dato_command_r; char crc_c_w; char num_command_r; char dato_command_tx; char crc_c_r; char crc_command; inizializzazione();
while(1) {
switch(rx()) {
case 10: /*scrittura DAC*/
num_dac_w=rx(); /* ricezione del numero del DAC */ if(num_dac_w<5)
Capitolo 5 : Processore 8051 e UART
{
ric_dac1=rx(); /* ricezione dei due byte da scrivere*/ ric_dac2=rx();
/*calcolo del crc ottenuto con le informazioni ricevute*/ crc_dac_w=num_dac_w+ric_dac1+ric_dac2+10;
if(crc_dac_w==rx()) {
pdac=0x8000+(2*num_dac_w); /* puntatore alla locazione dei DAC*/ *pdac=ric_dac1; /* scrittura del byte negli 8 LSB del DAC*/ pdac++;
*pdac=ric_dac2; /*scrittura del byte negli 8 MSB del DAC*/ }
} break;
case 20: /*lettura DAC*/
num_dac_r=rx(); /* ricezione del numero del DAC */ if(num_dac_r<5)
{
crc_dac=num_dac_r+20; /*calcolo del crc ottenuto con le informazioni ricevute*/ if(crc_dac==rx())
{
pdac=0x8000+(2*num_dac_r); /*puntatore alla locazione del DAC*/ tx_dac1=*pdac;
tx(tx_dac1); /*trasmissione del byte contenuto negli 8 LSB del DAC*/ pdac++;
tx_dac2=*pdac;
tx(tx_dac2); /*trasmissione del byte contenuto negli 8 MSB del DAC*/ crc_dac_r=tx_dac1+tx_dac2; /*calcolo del crc ottenuto con le informazioni*/
tx(crc_dac_r); /*trasmesse e trasmissione del crc ditto*/ }
} break;
case 30: /*lettura ADC*/
richiesta(); /*richiesta di accesso alla RAM*/
crc_adc_r=30; /*calcolo del crc ottenuto con le informazioni ricevute*/ if(crc_adc_r==rx())
{
crc_adc=0; for(i=0; i++; i<5) {
padc=0x0000+(2*i); /*puntatore alla locazione dell’ADC*/ tx_adc1=*padc;
tx(tx_adc1); /*trasmissione del byte contenuto negli 8 LSB dell'ADC*/ padc++;
tx_adc2=*padc;
tx(tx_adc2); /*trasmissione del byte contenuto negli 8 MSB dell'ADC*/ crc_adc+=tx_adc1+tx_adc2; /*calcolo del crc ottenuto con le informazioni trasmesse*/ }
tx(crc_adc); /*trasmissione del crc che è dato dalla somma dei 10 byte*/ /*trasmessi (2 per ognuno dei 5 ADC) */
}
rilascio(); /*rilascio dell’accesso alla RAM*/ break;
Capitolo 5 : Processore 8051 e UART
case 40: /*lettura status*/
crc_status=40; /*calcolo del crc ottenuto con le informazioni ricevute*/ if(crc_status==rx())
{
pstatus=0x800A; /*puntatore alla locazione degli status*/ stato=*pstatus;
tx(stato); /*trasmissione del byte contenuto nella locazione 0x800A*/ crc_st=stato; /*calcolo del crc ottenuto con le informazioni trasmesse*/ tx(crc_st); /*trasmissione del crc*/
} break;
case 50: /*scrittura command*/ dato_command_w=rx(); /*ricezione byte da scrivere*/
crc_c_w=dato_command_w+50; /*calcolo del crc ottenuto con le informazioni ricevute*/ if(crc_c_w==rx())
{
pcommand=0x800B; /*puntatore alla locazione dei command*/
*pcommand=dato_command_w; /*scrittura del byte ricevuto nella locazione 0x800B*/ }
break;
case 60: /*lettura command*/
crc_command=60; /*calcolo del crc ottenuto con le informazioni ricevute*/ if(crc_command==rx())
{
pcommand=0x800B; /*puntatore alla locazione dei command*/ dato_command_r=*pcommand;
tx(dato_command_r); /*trasmissione del byte contenuto nella locazione 0x800B*/ crc_c_r=dato_command_r; tx(crc_c_r); } break; } } }
char richiesta () /*richiesta di accesso alla RAM*/ {
P1=P1|0x01; /*metto req_micro a 1*/
while(P1&0x10==0x00); /*aspetto finchè non ho ack_micro a 1*/ return 1;
}
char rilascio() /*smetto di accedere alla RAM*/ {
P1=P1|0x00; /*metto req_micro a 0*/ }
char rx() /*lettura dalla seriale di un dato generico*/ {
while(RI==0); /*aspetto finchè RI non è uguale a 1*/ RI=0;
return SBUF; }
Capitolo 5 : Processore 8051 e UART
void tx(uart_data) /*scrittura sulla seriale di un dato generico*/ { while(TI==0); TI=0; SBUF=uart_data; } void inizializzazione() {
SCON=0x50; /*attivo il modo 1 e pongo REN a 1*/
TMOD=TMOD|0x20; /*pongo il timer 1 in modalità 2 con T1M1 a '1' e TIM0 a '0'*/ TH1=0xFC; /*baud a 19200 b/s*/
TL1=0xFC;
TR1=1; /*setto il timer 1*/ }
CONCLUSIONI
L’obiettivo che ci si è proposto è stato quello di programmare la Cyclone FPGA ed il processore 80C52 presenti nella scheda di controllo, per propulsore ionico ad effetto Hall, di cinque grandezze elettriche tra correnti e tensioni che alimentano il motore del propulsore.
La scheda trasmette e riceve via seriale e fornisce un controllo delle correnti e tensioni che andranno ad alimentare il propulsore SPT.
Nella tesi è stata fatta una breve descrizione delle tecniche trasmissive, con particolare attenzione alla trasmissione seriale ed agli standard RS232, RS422, RS485 ed ai rispettivi connettori di interfaccia.
Poi si è passati a fare un breve riepilogo del progetto della scheda di controllo, che è stato oggetto della tesi di laurea triennale, visualizzandone la struttura attraverso gli schematici elettrici realizzati con lo schematic entry Innoveda.
Quindi si è presentato il progetto del PCB della scheda con una breve descrizione dei criteri con cui è stato realizzato.
Poi si è passati a descrivere la programmazione della Cyclone FPGA attraverso il linguaggio VHDL.
Sono state fatte le simulazioni del ciclo di lettura e di scrittura della FLASH e della ricezione e della trasmissione dell’interfaccia con l’RS422/485, allo scopo di presentare degli esempi della risposta dell’FPGA agli stimoli di ingresso.
E’ stata infine descritta la programmazione dell’80C52 attraverso il linguaggio C ed è stata eseguita una descrizione dell’UART integrato del processore.
BIBLIOGRAFIA
[1] HA-2420, Sample and Hold Amplifier, Intersil, November 19, 2004
[2] HS-2420RH, Sample and Hold Amplifier, Intersil, February 2003
[3] OP27, Low Noise, Precision Operational Amplifier, Analog Devices
[4] 5962-94680, OP27, Precision Operational Amplifier, Defense Supply Center Columbus, Ohio
[5] HI-574A, 12 bit A/D Converter, Intersil, June 2001
[6] 5962-94680,574AU , 12 bit A/D Converter, Defense Supply Center Columbus, Ohio
[7] Am29F032B, Flash Memory, AMD, July 2003
[8] UT28F256, Radiation Hardened PROM, Aeroflex, December 2002
[9] HI-509A, CMOS Analog MUX, Intersil, November 22, 2004
[10] 5962-96742, HS-508BRH, Radation Hardened Multiplexer, Defense Supply Center Columbus, Ohio
[11] AD524, Precision Instrumentation Amplifier, Analog Devices
[12] 5962-88539, AD524, Precision Instrumentation Amplifier, Defense Supply Center Columbus, Ohio
[15] DS1487, Transceiver, July 1998, National Semiconductor
[16] DS16F95, Transceiver, July 1998, National Semiconductor
[17] 80C52, CMOS single-chip 8 bit Microcontroller, Philips
[18] 80C32E, Radation Tolerant Microcontroller, Atmel
[19] Cyclone Devices Handbook, Altera
[20] UT6325, Rad Hard Eclipse FPGA, Aeroflex
[21] RS232, Transceiver, Maxim
[22] CB3/CB3LV, SMD Clock Oscillator, CTS
[23] 1118R30M00000AF, Crystal Oscillator, Vectron International
[24] EPC2TC32, Configuration device for SRAM-based LUT devices, Altera
[25] LM1086CS-ADJ, 1.5A Low dropout positive regulator, National Semiconductor
[26] 5962-99547, HS-117RH, Positive Regulator, Defense Supply Center Columbus, Ohio
[27] LT1014MJ, Quad Precision Operational Amplifier, Texas Instruments
[28] RH1014MJ, Quad Precision Operational Amplifier, Linear Technology
[29] SN74LVC16245A, 16-bit Bus Transceiver, Texas Instrument
[30] UT54ACS164245S, 16-bit Bidiretional Transceiver, April 2002, Aeroflex
[32] 5962-89932, DAC08, 8-bit Multiplying D/A Converter, Defense Supply Center Columbus, Ohio
[33] HI-565, 12-bit Monolithic D/A Converter, May 2002, Intersil
[34] HS-565BRH, 12-bit Radiation Hardened Monolithic D/A Converter, January 2003, Intersil
[35] SN74HC138, 3-line to 8-line Decoders/Demultiplexer, Texas Instrument
[36] 5962-96544, 54ACS138, Radiation Hardened 3-line to 8-line Decoders/Demultiplexer, Defense Supply Center Columbus, Ohio
[37] SN54/74LS373, Octal Transparent Latch,
SN54/74LS374, Octal D-Type Flip Flop, Motorola
[38] 5962-96589, 54ACTS373, Radiation Hardened Octal Transparent Latch, Defense Supply Center Columbus, Ohio
[39] 5962-96591, 54ACTS374, Radiation Hardened Octal D-Type Flip Flop, Defense Supply Center Columbus, Ohio
[40] Tesi triennale : “Progetto di una scheda di controllo per propulsore ionico ad effetto Hall per uso spaziale”, Pomarico Francesca