' ********************************************************************** ' ** Programma: KND08av.BAS - Versione : 1.2 - 07 March 2001 ** ' ** Compiler: BASCOM AVR (IDE V. 1.11.5.0, LIB V. 1.11.5.0) ** ' ** 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: Graziano GAIBA ** ' ********************************************************************** ' ' 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. ' ' ++++++********** ATTENZIONE **********+++++++ ' + + ' + Per compilare correttamente il programma: + ' + 1) aprire il menu Options/Compiler/Chip + ' + 2) impostare a 130 il valore di Stacksize + ' + 3) impostare a 80 il valore di Framesize + ' + + ' ++++++********** ATTENZIONE **********+++++++ ' '*********************************************************************** ' '****************** Direttive del compilatore ************************** ' $regfile = "8515def.DAT" ' AT90s8515 registers list $romstart = &H0 ' code start address $crystal = 5529600 ' micro clock frequence $baud = 19200 ' baud rate ' Configura il timer 0 come timer ed il prescaler che divide il clock per 64 Config Timer0 = Timer , Prescale = 64 ' '****************** Dichiarazione delle costanti *********************** ' Pclk Alias Portd.3 ' linea L1 su CN6 della K51-AVR che Config Pind.3 = Output ' pilota il segnale di Clock. Psda Alias Portd.4 ' linea L2 su CN6 della K51-AVR che Config Pind.4 = Output ' pilota il segnale dei Dati. Const Cler = 12 ' codice di clear screen Const Bel = 7 ' codice di Bell Const Ric = 255 ' genera un interrupt di 1.157 mS ad ' una frequenza di 5.5296MHz. 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 Long ' numero 4 cifre per display, ' DY5, DY6, DY7, DY8. Dim Num_l As Long ' numero 4 cifre per display, ' DY1, DY2, DY3, DY4. ' DY1, DY2, DY3, DY4. Dim Decpt As Long ' 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 Tasto As Byte ' contiene il carattere ricevuto, Dim Tstr As String * 1 ' Variabile stringa uso generico Dim Numh As Long ' Passaggio parametri Dim Numl As Long ' Passaggio parametri ' ' ************************************************************************ ' * Le variabili seguenti sono indispensabili per l'interrupt, possono * ' * essere modificate in qualunque momento. * ' ************************************************************************ ' 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 Long ' cifra delle unita DY5 Dim Cif_dh As Long ' cifra delle decine DY6 Dim Cif_ch As Long ' cifra delle centinaia DY7 Dim Cif_mh As Long ' cifra delle migliaia DY8 Dim Cif_ul As Long ' cifra delle unita DY1 Dim Cif_dl As Long ' cifra delle decine DY2 Dim Cif_cl As Long ' cifra delle centinaia DY3 Dim Cif_ml As Long ' cifra delle migliaia DY4 Dim Cif_u As Long ' cifra delle unita Dim Cif_d As Long ' cifra delle decine Dim Cif_c As Long ' cifra delle centinaia Dim Cif_m As Long ' cifra delle migliaia Dim Cif_h As Long ' contiene 1 cifra per 5678 Dim Cif_l As Long ' 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 Dim Cifra As Long ' Passaggio parametri ' **************************************************************************** ' '****************** Dichiarazione delle procedure ********************** ' Declare Function Iv() As Long ' Input di Valore decimale Declare Sub Iniz ' inizializzazione variabili ecc. Declare Function Att_key() As Byte ' 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 Check_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 Leds ' gestione On / Off LEDs Declare Sub Dec_point(byval Decpt As Long) ' 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 Function Conv7 (byval Cifra As Long) As Byte ' converte un numero da 0 a 9 in 7 ' segmenti Declare Sub C_cifre (num As Long , Dp As Byte) ' Converte 1 numero di 4 cifre in 4 ' cifre separate; attiva il punto ' decimale Declare Sub Conv_bit(byval Cifh As Long , Byval Cifl As Long) ' 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.2 07.03.2001 **" 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 Tasto = Att_key() ' Attendo un tasto Print "Tasto=" ; If Tasto <> 0 Then Print Chr(tasto); ' visualizzo l'ultimo tasto End If Print Chr(13); ' torno a inizio riga Loop Until Tasto <> 0 ' esco se ho ricevuto un carattere Select Case Tasto 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 Dp_h = 0 : Dp_l = 0 Led1 = 0 : Led2 = 0 : Led3 = 0 Led4 = 0 : Led5 = 0 : Led6 = 0 Call Press ' messaggio Tasto = Att_key() ' Attendo un tasto Case Else : Print Chr(bel); ' tasto non valido End Select Loop ' ' *************** 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(cif_mh , Cif_ml) ' preparo i bit per DY4 e DY8 Incr Disp ' commuto prossima coppia di display Case 1 : Call Conv_bit(cif_ch , Cif_cl) ' preparo i bit per DY3 e DY7 Incr Disp ' commuto prossima coppia di display Case 2 : Call Conv_bit(cif_dh , Cif_dl) ' preparo i bit per DY2 e DY6 Incr Disp ' commuto prossima coppia di display Case Is => 3 : Call Conv_bit(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 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 Num_h = 0 ' azzera le cifre su 5678 Num_l = 0 ' azzera le cifre su 1234 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 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 Local T As Byte Print Chr(cler) ; ' cancello lo schermo Print Print "Gestione 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 T = Att_key() ' Attendo un tasto Select Case T 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 T = "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 Local T As Byte Print Print Print " Inserire un numero compreso tra 0 e 99999999 ? " ; Numero = Iv() If Numero > 99999999 Then ' e' superiore a 99999999 Numero = 99999999 ' lo pongo a 99999999 End If Call Check_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 T = Att_key() ' Attendo un tasto End Sub ' ' ******************** Inserisco il decimal point ************************** ' Questa procedura permette di attivare uno degli 8 decimal point nei display ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Ins_dp ' Ins. decimal point Local T As Byte , L As Long 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 Print " Inserire un numero compreso tra 0 e 8 ? " ; L = Iv() Call Dec_point(l) ' attiva il punto decimale indicato Call Press ' messaggio T = 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 (byval Decpt As Long) Select Case Decpt 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 Check_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 Local T As Byte , D As Long Numero = 0 Do For D = 0 To 8 ' visualizzo 8 decimal point ' in sequenza. Call Dec_point(d) Call Check_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(byval Cifh As Long , Byval Cifl As Long) Local X8 As Byte Local Bit32 As Long ' converte le 2 cifre per il 5480 IC1 Bit23 = 0 X8 = Cifh ' salvo il byte 0, con la 1 cifra Bit23 = X8 X8 = Cifl ' salvo il byte 1, con la 2 cifra Bit32 = X8 Shift Bit32 , Left , 8 Bit23 = Bit23 Or Bit32 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 Bit32 = X8 ' salvo il byte 2 Shift Bit32 , Left , 16 Bit23 = Bit23 Or Bit32 End Sub ' ' ********************************************************************** ' * 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) Local X16 As Word ' 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' Digit = 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 Digit = 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 Digit = 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 Digit = 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 byte (conversione per 7 segmenti) * ' * * ' * In questa procedura il decimal point e' sempre disattivo. * ' ********************************************************************** ' Function Conv7 (digit As Long) As Byte ' converte un numero da 0 a 9 in 7 ' segmenti If Digit < 10 Then ' il numero risulta minore di 10 Conv7 = Lookup(digit , Tab_7seg) ' leggo in tabella il valore Else Conv7 = 0 ' se = o > 10 spengo il display End If End Function ' ' ************* 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 bit23 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. Local I As Byte Call Sinc5480 ' Sincronizzo la sequenza Psda = 1 ' start Call Sendclk ' sequenza di start For I = 1 To 34 ' emetto i bits ' sequenze da 1 a 34 Select Case I Case 1 : ' Sequenza 1 Call Sendclk Case 9 To 11: ' Sequenze da 9 a 11 Call Sendclk Case 16 To 19: ' Sequenze da 16 a 19 Call Sendclk Case 26 : ' Sequenza 1 Call Sendclk Case 28 To 29 : ' Sequenza 1 Call Sendclk Case Else: Call Testbit0 ' Invia il bit Call Sendclk ' Muove il clock Shift Bit23 , Right ' Prepare bit successivo End Select Next I Psda = 0 Call Sendclk ' sequenza 35 Call Sendclk ' sequenza 36 Call Sendclk ' sequenza 37 End Sub ' ' ****** Sposta lo stato del bit0 dell'accumulatore nel bit Psda ************* ' Parametri: nessuno ' Ingresso: ' Uscita: ' **************************************************************************** ' Sub Testbit0 Psda = Bit23.0 ' Bit 0 di bit23 su linea dati End Sub ' ' ***************** Emette un impulso di CLK ************************ ' Parametri: nessuno ' Ingresso: ' Uscita: ' ******************************************************************* ' Sub Sendclk Pclk = 0 ' pongo la linea CLK a zero Waitus 2 ' Attende 2 usec Pclk = 1 ' pongo la linea CLK a uno Waitus 2 ' Attende 2 usec 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 Local X As Byte 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: tipo byte, contiene il codice ricevuto dalla seriale ' ******************************************************************* ' Function Att_key() As Byte Local T As Byte Do T = Inkey() ' leggo un carattere dalla seriale Loop Until T <> 0 ' attendo che ci sia un carattere Att_key = T End Function ' ' ******************************************************************* ' Sub Press ' Mes. Premi un tasto per continuare Print Print Print Print "Premi un tasto per continuare..." Print End Sub ' ' ****************** Inserimento di un valore decimale *********************** ' * Parametri: 1 uscita * ' * Ingresso: * ' * Uscita: tipo byte, contiene il valore digitato tramite la porta seriale * ' **************************************************************************** ' Function Iv() As Long Local Count As Byte ' Numero di caratteri ricevuti Local Key As Byte ' Carattere letto Local Valore As String * 10 ' Stringa complessiva Local Strkey As String * 1 ' Carattere letto -> stringa Count = 0 ' Inizializza contatore Valore = "" ' Inizializza stringa Do Do Key = Inkey() ' Legge un carattere Loop Until Key <> 0 ' Esce se c'e' un carattere If Count < 10 Then ' Letti meno di 10 caratteri? Select Case Key ' Se il tasto letto... Case "0" To "9": ' ...e' una cifra decimale Strkey = Chr(key) ' Convrte in stringa Print Strkey; ' Echo Valore = Valore + Strkey ' Accoda alla stringa totale Incr Count ' Incrementa il contatore End Select End If Loop Until Key = 13 ' Esce con Enter Print ' Va a capo Iv = Val(valore) ' Restituisce il valore End Function ' della stringa ' ' ******************************************************************* ' ' ' ************* 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 ' ************************************************************************** '