' ********************************************************************** ' ** Programma: KND08.BAS - Versione : 1.1 - 19 Aprile 2000 ** ' ** Compilatore : BASCOM 8051, (IDE V.1.0.0.20, LIB V.1.20) ** ' ** Scheda : KND 08 ** ' ** Ditta: grifo(r) ITALIAN TECHNOLOGY ** ' ** Via Dell' Artigiano 8/6 40016 San Giorgio di Piano (BO) ** ' ** Tel.+39 051 892 052 Fax +39 051 893 661 ** ' ** http://www.grifo.com http://www.grifo.it ** ' ** sales@grifo.it tech@grifo.it grifo@grifo.it ** ' ** ** ' ** Realizzato da: Adriano Pedrielli ** ' ********************************************************************** ' ' Questo programma, attraverso un menu, permette di gestire le risorse a bordo ' della scheda KND 08, tramite 2 linee TTL pilotate da un micro controllore della ' famiglia 51, ' La gestione di questo programma avviene tramite la seriale RS232, quindi e' ' indispensabile collegare una COM libera del PC al connettore CN2 della K51-AVR. ' Configurare il terminale del BASCOM 8051 nel menu OPTION/ COMUNICATION/ ' selezionare la COM e settare il BAUD a 19200, none, 8, 1. ' La scheda utilizzata e' la K51-AVR che va colleganta alla KND 08 come segue: ' K51-AVR KND 08 ' L1 (pin4 CN6) ----> SC (pin2 CN1 KND08) ' L2 (pin5 CN6) ----> SD (pin1 CN1 KND08) ' Collegare le alimentazioni su entrambe le schede. ' ' Prima di compilare settare nel menu OPTION/ COMPILER/ MISC : ' Byte End(Hex) = 65 '*********************************************************************** ' '****************** Direttive del compilatore ************************** ' $regfile = "REG51.DAT" ' elenco registri della CPU $romstart = &H0 ' indirizzo di partenza del codice $crystal = 11059200 ' frequenza di clock della CPU $baud = 19200 ' velocità di comunicazione RS-232 $large ' indirizzamento a 16 bit Config Timer0 = Timer , Gate = Internal , Mode = 1 'Timer0 = timer : timer0 viene programmato come timer 'Gate = Internal : abilitazione intera 'Mode = 1 : 16-bit di risoluzione, quando arriva a 0 scatta l'interrupt ' e manualmente deve essere ricaricato il valore di partenza. ' '****************** Dichiarazione delle costanti *********************** ' Pclk Alias P3.3 ' linea L1 su CN6 della K51-AVR che ' pilota il seganle di Clock. Psda Alias P3.4 ' linea L2 su CN6 della K51-AVR che ' pilota il seganle dei Dati. Const Cler = 12 ' codice di clear screen Const Bel = 7 ' codice di Bell Const Ric = 19 ' genera un interrupt di 4.88 mS ad ' una frequenza di 11.0592MHz. ' Per aumentare il tempo, vale la ' proporzione 19 : 4.88 = n : mS . ' volendo generare 7ms : ' (7*19)/4.88= 27 ' N.B. : il valore Max e' 255 (65mS) Const N_rinf = 5 ' numero di rinfreschi prima di ' aggiornare il valore, ogni unita' ' vale tempo interrupt *4 . ' Es:Timer0= 5mS *4= 20mS(1 rinfresco) ' '****************** Dichiarazione delle variabili ********************** ' Dim Rinfvr As Bit ' indica quale gruppo di display ' viene aggiornato, 1234 o 5678 Dim Led1 As Bit ' indica lo stato del Led 1 Dim Led2 As Bit ' indica lo stato del Led 2 Dim Led3 As Bit ' indica lo stato del Led 3 Dim Led4 As Bit ' indica lo stato del Led 4 Dim Led5 As Bit ' indica lo stato del Led 5 Dim Led6 As Bit ' indica lo stato del Led 6 Dim Numero As Long ' indica il numero da rappresentare Dim Num_h As Word ' numero 4 cifre per display, ' DY5, DY6, DY7, DY8. Dim Num_l As Word ' numero 4 cifre per display, ' DY1, DY2, DY3, DY4. Dim D As Byte ' indica quale decimal point e' attivo Dim Dp_h As Byte ' posizione del decimal point nel ' gruppo display 5678 Dim Dp_l As Byte ' posizione del decimal point nel ' gruppo display 1234 Dim T As Byte ' contiene il carattere ricevuto, Dim X As Byte ' uso generico Dim N As Long ' uso generico Dim Tstr As String * 1 ' Variabile stringa uso generico ' ' ************************************************************************ ' * Le variabili seguenti sono indispensabili per l'interrupt, possono * ' * essere modificate in qualunque momento. * ' ************************************************************************ ' Dim X8 As Byte ' uso generico dentro interrupt Dim X16 As Word ' uso generico Dim Bit23 As Long ' variabile di 24 bit che contiene lo ' il frame di bit per l'M5480 Dim Rinf As Byte ' contiene il numero di rinfreschi dei ' display, prima di aggiornare il valore Dim Digit As Byte ' contiene la conversione in digit Dim Cif_uh As Byte ' cifra delle unita DY5 Dim Cif_dh As Byte ' cifra delle decine DY6 Dim Cif_ch As Byte ' cifra delle centinaia DY7 Dim Cif_mh As Byte ' cifra delle migliaia DY8 Dim Cif_ul As Byte ' cifra delle unita DY1 Dim Cif_dl As Byte ' cifra delle decine DY2 Dim Cif_cl As Byte ' cifra delle centinaia DY3 Dim Cif_ml As Byte ' cifra delle migliaia DY4 Dim Cif_u As Byte ' cifra delle unita Dim Cif_d As Byte ' cifra delle decine Dim Cif_c As Byte ' cifra delle centinaia Dim Cif_m As Byte ' cifra delle migliaia Dim Cif_h As Byte ' contiene 1 cifra per 5678 Dim Cif_l As Byte ' contiene 1 cifra per 1234 Dim Num As Word ' numero generico Dim Dp As Byte ' indica il decimal point Dim Disp As Byte ' indica quale display si sta ' visualizzando ' **************************************************************************** ' '****************** Dichiarazione delle procedure ********************** ' Declare Sub Iniz ' inizializzazione variabili ecc. Declare Sub Conv_key ' conversione tasto in stringa Declare Sub Att_key ' Attesa pressione tasto Declare Sub Press ' Mes. Premi un tasto per continuare Declare Sub Demo ' esempio gestione display Declare Sub Ins_num ' Inserisco numero max 8 cifre Declare Sub Ins_dp ' Ins. decimal point Declare Sub Chek_rinf ' Verifica il non rinfresco in corso Declare Sub Sendclk ' emette un impulso di CLK Declare Sub Sinc5480 ' resetta le uscite dell'M5480 Declare Sub Testbit0 ' setta Psda come lo stato del Bit0 Declare Sub T_send ' Trasmette un bit Declare Sub Leds ' gestione On / Off LEDs Declare Sub Dec_point(d As Byte) ' attiva il punto decimale indicato Declare Sub Send5480 (bit23 As Long) ' comunica all'M5480 lo stato delle ' uscite, tramite il contenuto della ' variabile a 24 bit. Declare Sub Conv7 (digit As Byte) ' converte un numero da 0 a 9 in 7 ' segmenti Declare Sub C_cifre (num As Word , Dp As Byte) ' Converte 1 numero di 4 cifre in 4 ' cifre separate; attiva il punto ' decimale Declare Sub Conv_bit (disp As Byte , Cif_h As Byte , Cif_l As Byte) ' converte le cifre in bit per il 5480 On Timer0 T0_int ' procedura di risposta all'interrupt ' del Timer0 ' '************************* Programma main ****************************** ' Main: Waitms 1 ' ritardo Call Iniz ' inizializzazioni delle variabili ecc. Do Do Print Chr(cler) ; ' cancello lo schermo Print "** DEMO per la KND 08 abbinata alla K51-AVR REL.1.1 19.04.2000 **" Print Print "1) Esempio di conteggio" Print "2) Inserire un numero con max 8 cifre" Print "3) Inserire il punto decimale" Print "4) Accensione e spegnimento LEDs" Print "5) Reset" Print Print "SELEZIONARE IL MENU DESIDERATO : " Print Call Att_key ' Attendo un tasto Print "Tasto=" ; If T = 0 Then Print Tstr; ' visualizzo l'ultimo tasto Else If T > 31 Then Print Chr(t); ' visualizzo il tasto premuto Else Print Tstr; ' visualizzo l'ultimo tasto End If End If Print Chr(13); ' torno a inizio riga Loop Until T <> 0 ' esco se ho ricevuto un carattere Call Conv_key ' converto il tasto in stringa Select Case Tstr Case "1" : Call Demo ' esempio gestione display Case "2" : Call Ins_num ' Inserisco numero a 8 cifre Case "3" : Call Ins_dp ' Ins. decimal point Case "4" : Call Leds ' gestione LEDs Case "5" : Num_h = 0 ' azzero le variabili Num_l = 0 : Numero = 0 Dp_h = 0 : Dp_l = 0 D = 0 Led1 = 0 : Led2 = 0 : Led3 = 0 Led4 = 0 : Led5 = 0 : Led6 = 0 Call Press ' messaggio Call Att_key ' Attendo un tasto Case Else : Print Chr(bel); ' tasto non valido End Select Loop End ' '************************ Fine del programma *************************** ' ' '**************************** Procedure ******************************** ' ' *************** Inizializzazioni delle variabili ecc. *********************** ' Questa procedura si occupa di inizializzare le variabili, attiva la gestione ' del TIMER 0 in interrupt. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Iniz ' inizializzazione variabili ecc. Pclk = 0 ' abbasso la linea di CLK Psda = 0 ' abbasso la linea di Dati Rinf = 0 ' azzero il conteggio dei rinfreschi Disp = 0 ' punto hai display 1 e 5 Led1 = 0 ' spengo il Led 1 Led2 = 0 ' spengo il Led 2 Led3 = 0 ' spengo il Led 3 Led4 = 0 ' spengo il Led 4 Led5 = 0 ' spengo il Led 5 Led6 = 0 ' spengo il Led 6 Numero = 0 ' azzera il numero da 8 cifre Num_h = 0 ' azzera le cifre su 5678 Num_l = 0 ' azzera le cifre su 1234 D = 0 ' spengo il decimal point Dp_h = 0 ' decimal point 5678 disattivo Dp_l = 0 ' decimal point 1234 disattivo Load Timer0 , Ric ' quando il timer0 arriva a 0, ' scatta l'interrupt Enable Interrupts ' abilito l'uso degli interrupt Enable Timer0 ' abilito l'interrupt del timer0 Priority Set Timer0 ' priorita' di interrupt timer0 alta Start Timer0 ' partenza del timer0 Waitms 1 ' Ritardo assestamento segnali End Sub ' ' ************************** Gestione On / Off LEDs *************************** ' Questa procedura permette di attivare o disattivere i 6 LEDs a bordo della ' scheda KND 08. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Leds ' gestione On / Off LEDs Print Chr(cler) ; ' cancello lo schermo Print Print "Gestine accensione o spegnimento LEDs" Print "1) On / Off LED 1" Print "2) On / Off LED 2" Print "3) On / Off LED 3" Print "4) On / Off LED 4" Print "5) On / Off LED 5" Print "6) On / Off LED 6" Print "7) Esci" Print Print "SELEZIONA IL LEDs DESIDERATO : " Print Do Call Att_key ' Attendo un tasto Call Conv_key ' converto il tasto in stringa Select Case Tstr Case "1" : Led1 = Not Led1 ' Accensione o spegnimento LED 1 Case "2" : Led2 = Not Led2 ' Accensione o spegnimento LED 2 Case "3" : Led3 = Not Led3 ' Accensione o spegnimento LED 3 Case "4" : Led4 = Not Led4 ' Accensione o spegnimento LED 4 Case "5" : Led5 = Not Led5 ' Accensione o spegnimento LED 5 Case "6" : Led6 = Not Led6 ' Accensione o spegnimento LED 6 End Select Loop Until Tstr = "7" ' esco se viene premuto 7 End Sub ' ' ***************** Inserisco max 8 cifre ********************************* ' Questa procedura permette di assegnare un numero a 8 cifre per i display. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Ins_num ' Inserisco max 8 cifre Print Print Input " Inserire un numero compreso tra 0 e 99999999 ? " , N If N > 99999999 Then ' e' superiore a 99999999 N = 99999999 ' lo pongo a 99999999 End If Numero = N ' assegno il numero scelto Call Chek_rinf ' Verifica il non rinfresco in corso ' separo il numero a 8 cifre in due numeri da 4 cifre If Numero < 10000 Then ' il numero ha solo 4 cifre Num_l = Numero ' cifre basse Num_h = 0 ' cifre alte Else Num_h = Numero / 10000 ' ricavo le cifre alte Num_l = Numero Mod 10000 ' dal resto le cifre basse End If Call Press ' messaggio Call Att_key ' Attendo un tasto End Sub ' ' ******************** Inserisco il decimal point ************************** ' Questa procedura permette di attivare uno dei 8 decimal point nei display ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Ins_dp ' Ins. decimal point Print Print " Gestione del punto decimale" Print " 0 -> Disattiva il punto" Print " 1 -> Punto sulle unita' DY1" Print " 2 -> Punto sulle decine DY2" Print " 3 -> Punto sulle centinaia DY3" Print " 4 -> Punto sulle migliaia DY4" Print " 5 -> Punto sulle unita' DY5" Print " 6 -> Punto sulle decine DY6" Print " 7 -> Punto sulle centinaia DY7" Print " 8 -> Punto sulle migliaia DY8" Print Input " Inserire un numero compreso tra 0 e 8 ? " , D Call Dec_point(d) ' attiva il punto decimale indicato Call Press ' messaggio Call Att_key ' Attendo un tasto End Sub ' ' ****************** Attiva il punto decimale indicato ********************* ' Questa procedura selezione il decimal point secelto da 0 a 8. ' Parametri: 1 ingresso ' Ingresso: D as byte, valore da 0 a 8. ' Uscita: Dp_l as byte, 0 spento ' 1 acceso su DY1 ' 2 acceso su DY2 ' 3 acceso su DY3 ' 4 acceso su DY4 ' Dp_h as byte, 0 spento ' 5 acceso su DY5 ' 6 acceso su DY6 ' 7 acceso su DY7 ' 8 acceso su DY8 ' ***************************************************************************** ' Sub Dec_point (d As Byte) Select Case D Case 0 : Dp_h = 0 ' decimal point spento su DY5, 6, 7, 8 Dp_l = 0 ' decimal point spento su DY1, 2, 3, 4 Case 1 : Dp_l = 1 ' decimal point attivo su DY1 Dp_h = 0 ' decimal point spento su DY5, 6, 7, 8 Case 2 : Dp_l = 2 ' decimal point attivo su DY2 Dp_h = 0 ' decimal point spento su DY5, 6, 7, 8 Case 3 : Dp_l = 3 ' decimal point attivo su DY3 Dp_h = 0 ' decimal point spento su DY5, 6, 7, 8 Case 4 : Dp_l = 4 ' decimal point attivo su DY4 Dp_h = 0 ' decimal point spento su DY5, 6, 7, 8 Case 5 : Dp_h = 1 ' decimal point attivo su DY5 Dp_l = 0 ' decimal point spento su DY1, 2, 3, 4 Case 6 : Dp_h = 2 ' decimal point attivo su DY16 Dp_l = 0 ' decimal point spento su DY1, 2, 3, 4 Case 7 : Dp_h = 3 ' decimal point attivo su DY7 Dp_l = 0 ' decimal point spento su DY1, 2, 3, 4 Case Is => 8 : Dp_h = 4 ' decimal point attivo su DY8 Dp_l = 0 ' decimal point spento su DY1, 2, 3, 4 End Select End Sub ' ' ********************** Verifica il non rinfresco in corso ******************* ' Questa procedura verifica che l'interrupt non stia eseguendo un calcolo di ' aggiornamento dei valori da visualizzare sul display. ' Infatti le 2 variabili Num_r e Num_v, vengono usate per ricavare le singole ' cifre, quindi prima di modificare queste variabili e' necessario verificare ' non sia in corso il calcolo delle cifre. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Chek_rinf ' Verifica il non rinfresco in corso Do If Rinf < N_rinf Then ' non e' in corso il'calcolo cifre Exit Do Else If Disp <= 2 Then ' non e' in corso la visualizzazione Exit Do ' del quarto display End If End If Loop ' verifico che non sia in corso ' l'aggiornamento del display, ' altrimenti aspetto, max 5ms. End Sub ' ' ***************** Demo gestione display ********************************** ' Questa procedura esegue un conteggio di un numero da max 8 cifre . ' Durante il conteggio avviene uno scorrimento di tutti i decimal point e dei ' 6 LEDs rossi. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Demo ' Attiva display in demo Do For D = 0 To 8 ' visualizzo 8 decimal point ' in sequenza. Call Dec_point(d) Call Chek_rinf ' Verifica il non rinfresco in corso Incr Numero ' incremento il conteggio If Numero > 99999999 Then ' e' superiore alle 4 cifre Numero = 0 ' lo azzero End If ' separo il numero a 8 cifre in due numeri da 4 cifre If Numero < 10000 Then ' il numero ha solo 4 cifre Num_l = Numero ' cifre basse Num_h = 0 ' cifre alte Else Num_h = Numero / 10000 ' ricavo le cifre alte Num_l = Numero Mod 10000 ' dal resto le cifre basse End If Led1 = 0 ' spengo il Led 1 Led2 = 1 ' accendo il Led 2 Led3 = 0 ' spengo il Led 3 Led4 = 1 ' accendo il Led 4 Led5 = 0 ' spengo il Led 5 Led6 = 1 ' accendo il Led 6 Waitms 100 ' ritardo Led1 = 1 ' accendo il Led 1 Led2 = 0 ' spengo il Led 2 Led3 = 1 ' accendo il Led 3 Led4 = 0 ' spengo il Led 4 Led5 = 1 ' accendo il Led 5 Led6 = 0 ' spengo il Led 6 Waitms 100 ' ritardo T = Inkey ' leggo un carattere da seriale If T <> 0 Then ' e' stato premuto un tasto Exit For ' esco dal demo End If Next D Loop Until T <> 0 ' esco se e' stato premuto un tasto End Sub ' ' ************************************************************************** ' * Questa procedura prepara i bit da trasmettere all'M5480 (IC1 su KND 08)* ' * * ' * Parametri: 3 ingresso, 1 uscita * ' * Igresso : var. Disp byte (da 0 a 3), indica quale display verra gestito* ' * * ' * 0 -> DY4 e DY8 * ' * 1 -> DY3 e DY7 * ' * 2 -> DY2 e DY6 * ' * 3 -> DY1 e DY5 * ' * var. cif_h byte ( da 0 a 255), cifra 7 seg. DY5, 6 ,7 ,8 * ' * var. cif_l byte ( da 0 a 255), cifra 7 seg. DY1, 2, 3 ,4 * ' * * ' * uscita : var. Bit23 Long * ' * La variabile Bit23 ( 4 byte) e' cosi' suddivisa : * ' * Bit23+0 -> byte 0 indica la cifra per DY5, DY6, DY7, DY8 * ' * * ' * Bit23+1 -> byte 1 indica la cifra per DY1, DY2, DY3, DY4 * ' * * ' * Bit23+2 -> byte 2 * ' * bit0 abilita display 4 e 8 abilita' Led1, 2, 3 * ' * bit1 abilita display 3 e 7 abilita' Led4, 5, 6 * ' * bit2 abilita display 2 e 6 * ' * bit3 display 1 e 5 * ' * bit4 Led3 e Led6 * ' * bit5 Led2 e Led5 * ' * bit6 Led1 e Led4 * ' * bit7 Non usato * ' * Bit23+3 -> byte 3, tutti gli 8 bit non sono usati. * ' * * ' * Viene utilizzata una variabile generica X8. * ' * La variabile X8 deve essere dichiarata in RAM interna, in caso * ' * contrario non possono essere eseguite le istruzioni in assembler. * ' * var. Led1 bit (=1 led acceso) * ' * var. Led2 bit (=1 led acceso) * ' * var. Led3 bit (=1 led acceso) * ' * var. Led4 bit (=1 led acceso) * ' * var. Led5 bit (=1 led acceso) * ' * var. Led6 bit (=1 led acceso) * ' ************************************************************************** ' Sub Conv_bit (disp As Byte , Cif_h As Byte , Cif_l As Byte) ' converte le 2 cifre per il 5480 IC1 X8 = Cif_h mov {bit23+0},{x8} ' salvo il byte 0, con la 1 cifra X8 = Cif_l mov {bit23+1},{x8} ' salvo il byte 1, con la 2 cifra Select Case Disp ' seleziono la coppia display scelta Case 0 : X8 = &B00001110 ' attivo display 4 e 8 e Led If Led3 = 1 Then ' e' attivo il LED 3 X8 = X8 Or &B00010000 ' configuro il bit associato End If If Led2 = 1 Then ' e' attivo il LED 2 X8 = X8 Or &B00100000 ' configuro il bit associato End If If Led1 = 1 Then ' e' attivo il LED 1 X8 = X8 Or &B01000000 ' configuro il bit associato End If Case 1 : X8 = &B00001101 ' attivo display 3 e 7 If Led6 = 1 Then ' e' attivo il LED 6 X8 = X8 Or &B00010000 ' configuro il bit associato End If If Led5 = 1 Then ' e' attivo il LED 5 X8 = X8 Or &B00100000 ' configuro il bit associato End If If Led4 = 1 Then ' e' attivo il LED 4 X8 = X8 Or &B01000000 ' configuro il bit associato End If Case 2 : X8 = &B00001011 ' attivo display 2 e 6 Case Is => 3 : X8 = &B00000111 ' attivo display 1 e 5 End Select mov {bit23+2},{x8} ' salvo il byte 2 End Sub ' ' *************** Risposta all'interrupt del Timer0 ************************ ' * Risposta all'interrupt del Timer0 ( il Timer1 e' usato per la seriale) * ' * a intervalli di 5mS (vedi Const Ric) avviene la visualizzazione di 2 * ' * display a 7 segmenti, al prossimo interrupt altri 2 fino ad accenderli * ' * tutti e 8 in 4 passate da 5mS. Dopo 5 rinfreschi (vedi Const N_rinf) * ' * vengono ricavati le nuove cifre dai numeri Num_v e Num_r. * ' ************************************************************************** ' T0_int: Stop Timer0 ' fermo il timer0 Load Timer0 , Ric ' ricarico il valore di partenza Start Timer0 ' partenza del timer0 Select Case Disp ' agisco in base al display scelto Case 0 : Call Conv_bit(disp , Cif_mh , Cif_ml) ' preparo i bit per DY4 e DY8 Incr Disp ' commuto prossima coppia di display Case 1 : Call Conv_bit(disp , Cif_ch , Cif_cl) ' preparo i bit per DY3 e DY7 Incr Disp ' commuto prossima coppia di display Case 2 : Call Conv_bit(disp , Cif_dh , Cif_dl) ' preparo i bit per DY2 e DY6 Incr Disp ' commuto prossima coppia di display Case Is => 3 : Call Conv_bit(disp , Cif_uh , Cif_ul) ' preparo i bit per DY1 e DY5 Disp = 0 ' riparto del diplay 4 e 8 Incr Rinf ' 1 rinfresco completato, incremento End Select Call Send5480(bit23) ' mando le informazioni al M5480 IC1 If Rinf => N_rinf Then ' e' stato fatto il rinfresco N volte If Rinfvr = 0 Then ' rinfresco DY5, 6, 7, 8 Call C_cifre(num_h , Dp_h) ' ricalcolo le 4 cifre di Num_h Cif_mh = Cif_m ' salvo le migliaia Cif_ch = Cif_c ' salvo le centinaia Cif_dh = Cif_d ' salvo le decine Cif_uh = Cif_u ' salvo le unita' Else ' rinfresco i DY1, 2, 3, 4 Call C_cifre(num_l , Dp_l) ' ricalcolo le 4 cifre di Num_l Cif_ml = Cif_m ' salvo le migliaia Cif_cl = Cif_c ' salvo le centinaia Cif_dl = Cif_d ' salvo le decine Cif_ul = Cif_u ' salvo le unita' Rinf = 0 ' azzero il conteggio del rinfresco End If Rinfvr = Not Rinfvr ' inverto lo stato del bit End If Return ' ********************************************************************** ' ' ********************************************************************** ' * Converte 1 numero composto da 4 cifre, in 4 cifre separate fra * ' * loro per display a 7 segmenti, inoltre gestisce il decimal point * ' * per uno dei 4 display. * ' * * ' * Parametri : 2 ingresso, 4 uscita ' * ingresso : var. num (da 0 a 9999) * ' * var. dp byte (da 0 a 4) * ' * dp =0 -> decimal point spento * ' * dp =1 -> decimal point unita' acceso * ' * dp =2 -> decimal point decine acceso * ' * dp =3 -> decimal point centinaia acceso * ' * dp =4 -> decimal point migliaia acceso * ' * * ' * uscite : Cif_m tipo byte, cifra delle migliaia * ' * Cif_c Tipo Byte , cifra delle centinaia * ' * Cif_d Tipo Byte , cifra delle decine * ' * Cif_u Tipo Byte , cifra delle unita' * ' * N.B. var. X16 word uso generico * ' ********************************************************************** ' Sub C_cifre (num As Word , Dp As Byte) ' Converte 1 numero di 4 cifre in 4 ' cifre separate; attiva il punto ' decimale If Num > 9999 Then ' e' maggiore di 9999 Num = 9999 ' lo pongo a 9999 End If Cif_m = Num / 1000 ' ricavo la cifra delle migliaia X16 = Num Mod 1000 ' ricavo il resto Cif_c = X16 / 100 ' ricavo la cifra delle centinaia X16 = X16 Mod 100 ' ricavo il resto Cif_d = X16 / 10 ' ricavo la cifra delle decine X16 = X16 Mod 10 ' ricavo il resto Cif_u = X16 ' ricavo la cifra delle unita' Call Conv7(cif_m) ' converto la cifra in 7 segmenti Cif_m = Digit ' merizzo il valore If Dp = 4 Then ' "dp" delle migliaia e' attivo Cif_m = Cif_m Or &B10000000 ' attivo il decimal pint End If Call Conv7(cif_c) ' converto la cifra in 7 segmenti Cif_c = Digit If Dp = 3 Then ' "dp" delle centinaia e' attivo Cif_c = Cif_c Or &B10000000 ' attivo il decimal pint End If Call Conv7(cif_d) ' converto la cifra in 7 segmenti Cif_d = Digit If Dp = 2 Then ' "dp" delle decine e' attivo Cif_d = Cif_d Or &B10000000 ' attivo il decimal pint End If Call Conv7(cif_u) ' converto la cifra in 7 segmenti Cif_u = Digit If Dp = 1 Then ' "dp" delle unita' e' attivo Cif_u = Cif_u Or &B10000000 ' attivo il decimal pint End If End Sub ' ' *********** Converte un numero da 0 a 9 in codice 7 segmenti ********* ' * * ' * Parametri: 1 ingresso, 1 uscita * ' * ingresso : variabile Digit tipo byte (da 0 a 9) se = 10 lo spegne * ' * uscita: variabile Digit byte (conversione per 7 segmenti) * ' * * ' * In questa procedura il decimal point e' sempre disattivo. * ' ********************************************************************** ' Sub Conv7 (digit As Byte) ' converte un numero da 0 a 9 in 7 ' segmenti If Digit < 10 Then ' il numero risulta minore di 10 Digit = Lookup(digit , Tab_7seg) ' leggo in tabella il valore Else Digit = 0 ' se = o > 10 spengo il display End If End Sub ' ' ************* Comunica all'M5480 IC1 lo stato delle uscite *********** ' * Trasmette il contenuto della variabile Bit23 di tipo Long. * ' * La variabile Bit23 deve essere dichiarata in RAM interna, in caso * ' * contrario non possono essere eseguite le istruzioni in assembler. * ' * * ' * Parametri: 1 ingresso * ' * ingresso : variabile bit32 Long (usati 3 byte su 4). * ' * uscita : nulla. * ' ********************************************************************** ' Sub Send5480 (bit23 As Long) ' comunica all'M5480 lo stato delle ' uscite, tramite il contenuto della ' variabile a 24 bit. push acc ' salvo l'accumulatore push psw ' salvo il reg. del carry Call Sinc5480 ' Scincronizzo la sequenza Psda = 1 ' start Call Sendclk ' sequenza di start Call Sendclk ' sequenza 1 mov acc,{bit23+0} ' prelevo il byte 0 di 3 Call Testbit0 ' emetto il bit 0 (bit1 pin12 5480) Call Sendclk ' sequenza 2 Call T_send ' emetto il bit 1 (bit2 pin11 5480) ' sequenza 3 Call T_send ' emetto il bit 2 (bit3 pin10 5480) ' sequenza 4 Call T_send ' emetto il bit 3 (bit4 pin9 5480) ' sequenza 5 Call T_send ' emetto il bit 4 (bit5 pin8 5480) ' sequenza 6 Call T_send ' emetto il bit 5 (bit6 pin7 5480) ' sequenza 7 Call T_send ' emetto il bit 6 (bit7 pin6 5480) ' sequenza 8 Call Sendclk ' sequenza 9 Call Sendclk ' sequenza 10 Call Sendclk ' sequenza 11 Call T_send ' emetto il bit 7 (bit8 pin5 5480) ' sequenza 12 mov acc,{bit23+1} ' prelevo il byte 1 di 3 Call Testbit0 ' emetto il bit 0 (bit9 pin4 5480) Call Sendclk ' sequenza 13 Call T_send ' emetto il bit 1 (bit10 pin3 5480) ' sequenza 14 Call T_send ' emetto il bit 2 (bit11 pin2 5480) ' sequenza 15 Call Sendclk ' sequenza 16 Call Sendclk ' sequenza 17 Call Sendclk ' sequenza 18 Call Sendclk ' sequenza 19 Call T_send ' emetto il bit 3 (bit12 pin28 5480) ' sequenza 20 Call T_send ' emetto il bit 4 (bit13 pin27 5480) ' sequenza 21 Call T_send ' emetto il bit 5 (bit14 pin26 5480) ' sequenza 22 Call T_send ' emetto il bit 6 (bit15 pin25 5480) ' sequenza 23 Call T_send ' emetto il bit 7 (bit16 pin24 5480) ' sequenza 24 mov acc,{bit23+2} ' prelevo il byte 2 di 3 Call Testbit0 ' emetto il bit 0 (bit17 pin23 5480) Call Sendclk ' sequenza 25 Call Sendclk ' sequenza 26 Call T_send ' emetto il bit 1 (bit18 pin22 5480) ' sequenza 27 Call Sendclk ' sequenza 28 Call Sendclk ' sequenza 29 Call T_send ' emetto il bit 2 (bit19 pin21 5480) ' sequenza 30 Call T_send ' emetto il bit 3 (bit20 pin20 5480) ' sequenza 31 Call T_send ' emetto il bit 4 (bit21 pin19 5480) ' sequenza 32 Call T_send ' emetto il bit 5 (bit22 pin18 5480) ' sequenza 33 Call T_send ' emetto il bit 6 (bit23 pin17 5480) ' sequenza 34 Psda = 0 Call Sendclk ' sequenza 35 Call Sendclk ' sequenza 36 Call Sendclk ' sequenza 37 pop psw ' ripristino il reg. del carry pop acc ' ripristino l'accumulatore End Sub ' ' ****** Sposta lo stato del bit0 dell'accumulatore nel bit Psda ************* ' Parametri: nessuno ' Ingresso: ' Uscita: ' **************************************************************************** ' Sub Testbit0 mov c,acc.0 ' parcheggio il bit 0 nel carry mov {psda},c ' attivo il pin con il valore del carry End Sub ' ' ***************** Emette un impulso di CLK ************************ ' Parametri: nessuno ' Ingresso: ' Uscita: ' ******************************************************************* ' Sub Sendclk Pclk = 0 ' pongo la linea CLK a zero Pclk = 1 ' pongo la linea CLK a uno End Sub ' ' Sub T_send rr acc ' ruota l'accumulatore Call Testbit0 Call Sendclk End Sub ' ' ***************** Sincronizza la sequenza dell'M5480 ************** ' Questa procedura emette 37 impulsi di CLK, questo evita che si sfalsi ' la sequenza di dati. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ******************************************************************* ' Sub Sinc5480 Psda = 0 ' pongo la linea dati a zero For X = 1 To 37 ' cilco ripetuto 37 volte Call Sendclk ' emetto un impulso di CLK Next X End Sub ' ' ****************** Attesa sospensiva di un tasto ********************* ' Parametri: 1 uscita ' Ingresso: ' Uscita: T tipo byte, contiene il codice ricevuto dalla seriale ' ******************************************************************* ' Sub Att_key Do T = Inkey ' leggo un carattere dalla seriale Loop Until T <> 0 ' attendo che ci sia un carattere End Sub ' ' ******************************************************************* ' Sub Press ' Mes. Premi un tasto per continuare Print Print Print Print "Premi un tasto per continuare..." Print End Sub ' ' ****************** Conversione del tasto in stringa ************************* ' Questa procedura converte un carattere compreso fra 31 e 127 in stringa. ' Se il carattere non e' compreso nel campo indicato, la striga contiene uno ' spazio. ' Prametri: ' Ingresso: T as byte, carattere ricevuto ' Uscita: Tstr as String *1, stringa del carattere ricevuto ' ***************************************************************************** ' Sub Conv_key ' Conversione del tasto in stringa If T > 31 Then ' e' un carattere visibile T = T And &H7F ' elimino il bit7 Tstr = Chr(t) ' converto in striga il carattere Else ' altrimenti Tstr = " " ' pongo la stringa = a uno spazio End If End Sub ' ' ******************************************************************* ' ' ' ************* Tabella conversione per cifra a 7 segmenti ***************** Tab_7seg: ' num. 0 1 2 3 4 5 6 7 8 9 Data &H3F , &H06 , &H5B , &H4F , &H66 , &H6D , &H7D , &H07 , &H7F , &H6F ' ************************************************************************** '