' ********************************************************************** ' ** Programma: KND44av.BAS - Versione : 1.2 - 14 March 2001 ** ' ** Compiler: BASCOM AVR (IDE V. 1.11.5.0, LIB V. 1.11.5.0) ** ' ** Scheda : KND 44 ** ' ** 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 44, 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 44 come segue: ' K51-AVR KND 44 ' L1 (pin4 CN6) ----> SC (pin2 CN1 KND44) ' L2 (pin5 CN6) ----> SD (pin1 CN1 KND44) ' 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, veri o rossi 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 Num_v As Long ' numero 4 cifre per display verdi, ' DY5, DY6, DY7, DY8. Dim Num_r As Long ' numero 4 cifre per display rossi, ' DY1, DY2, DY3, DY4. Dim Dp_v As Byte ' posizione del decimal point nel ' gruppo display verdi Dim Dp_r As Byte ' posizione del decimal point nel ' gruppo display rossi Dim Tasto As Byte ' uso generico ' ' ************************************************************************ ' * 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 verdi, prima di aggiornare ' il valore Dim Digit As Byte ' contiene la conversione in digit Dim Cif_uv As Long ' cifra delle unita DY5 verde Dim Cif_dv As Long ' cifra delle decine DY6 verde Dim Cif_cv As Long ' cifra delle centinaia DY7 verde Dim Cif_mv As Long ' cifra delle migliaia DY8 verde Dim Cif_ur As Long ' cifra delle unita DY1 rosso Dim Cif_dr As Long ' cifra delle decine DY2 rosso Dim Cif_cr As Long ' cifra delle centinaia DY3 rosso Dim Cif_mr As Long ' cifra delle migliaia DY4 rosso 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 verdi Dim Cif_l As Long ' contiene 1 cifra per rossi Dim Num As Word ' numero generico Dim Dp As Byte ' decimal point Dim Disp As Byte ' indica quale display si sta ' visualizzando Dim Cifa As Long ' passaggio parametri Dim Cifb As Long ' passaggio parametri 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_n_v ' Inserisco 4 cifre per i verdi Declare Sub Ins_n_r ' Inserisco 4 cifre per i rossi Declare Sub Ins_dp_v ' Ins. decimal point per i verdi Declare Sub Ins_dp_r ' Ins. decimal point per i rossi 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 Leds ' gestione On / Off LEDs 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 Cifa As Long , Byval Cifb 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 44 abbinata alla K51-AVR REL.1.1 17.04.2000 **" Print Print "1) Esempio di conteggio" Print "2) Inserire 4 cifre nei display verdi" Print "3) Inserire 4 cifre nei display rossi" Print "4) Punto decimale nei display verdi" Print "5) Punto decimale nei display rossi" Print "6) Accensione e spegnimento LEDs" Print "7) 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_n_v ' Inserisco 4 cifre i verdi Case "3" : Call Ins_n_r ' Inserisco 4 cifre i rossi Case "4" : Call Ins_dp_v ' Ins. decimal point per i verdi Case "5" : Call Ins_dp_r ' Ins. decimal point per i rossi Case "6" : Call Leds ' gestione LEDs Case "7" : Num_v = 0 ' azzero le variabili Num_r = 0 Dp_v = 0 : Dp_r = 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 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_v = 0 ' azzero i display verdi Num_r = 0 ' azzero i display rossi Dp_v = 0 ' decimal point verde disattivo Dp_r = 0 ' decimal point rosso 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 44. ' 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 Tasto = Att_key() ' Attendo un tasto Select Case Tasto 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 Tasto = "7" ' esco se viene premuto 7 End Sub ' ' ***************** Inserisco 4 cifre per i display verdi ********************* ' Questa procedura permette di assegnare un numero a 4 cifre per i display verdi ' DY5, DY6, DY7, DY8. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Ins_n_v ' Inserisco 4 cifre per i verdi Local V As Long , T As Byte Print Print Print " Inserire un numero compreso tra 0 e 9999 ? " ; V = Iv() Call Chek_rinf ' Verifica il non rinfresco in corso Num_v = V ' assegno il numero ai verdi Call Press ' messaggio T = Att_key() ' Attendo un tasto End Sub ' ' ***************** Inserisco 4 cifre per i display rossi ********************* ' Questa procedura permette di assegnare un numero a 4 cifre per i display rossi ' DY1, DY2, DY3, DY4. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Ins_n_r ' Inserisco 4 cifre per i rossi Local V As Long , T As Byte Print Print Print " Inserire un numero compreso tra 0 e 9999 ? "; V = Iv() Call Chek_rinf ' Verifica il non rinfresco in corso Num_r = V ' assegno il numero ai rossi Call Press ' messaggio T = Att_key() ' Attendo un tasto End Sub ' ' ******** Inserisco il decimal point per i display verdi ********************* ' Questa procedura permette di attivare uno dei 4 decimal point nei display ' verdi DY5, DY6, DY7, DY8. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Ins_dp_v ' Ins. decimal point per i verdi Local D As Long , T As Byte Print Print " Gestione del punto sui display verdi" Print " 0 -> Disattiva il punto" Print " 1 -> Punto sulle unita' DY5" Print " 2 -> Punto sulle decine DY6" Print " 3 -> Punto sulle centinaia DY7" Print " 4 -> Punto sulle migliaia DY8" Print Print " Inserire un numero compreso tra 0 e 4 ? "; D = Iv() Dp_v = D ' assegno il decimal point Call Press ' messaggio T = Att_key() ' Attendo un tasto End Sub ' ' ******** Inserisco il decimal point per i display rossi ********************* ' Questa procedura permette di attivare uno dei 4 decimal point nei display ' rossi DY1, DY2, DY3, DY4. ' Parametri: nessuno ' Ingresso: ' Uscita: ' ***************************************************************************** ' Sub Ins_dp_r ' Ins. decimal point per i rossi Local D As Long , T As Byte Print Print " Gestione del punto sui display rossi" 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 Print " Inserire un numero compreso tra 0 e 4 ? " ; D = Iv() Dp_r = D ' assegno il decimal point Call Press ' messaggio T = Att_key() ' Attendo un tasto 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 inizializza 2 numeri diversi per i display rossi e per i ' verdi, ne incrementa il valore su uno e decrementa su l'altro. ' 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 Num_v = 0 ' inizializzo il valore di conteggio Num_r = 9999 ' inizializzo il valore di conteggio Do For Dp_v = 0 To 4 ' visualizzo 4 decimal point dei verdi ' in sequenza. Call Chek_rinf ' Verifica il non rinfresco in corso Incr Num_v ' incremento il conteggio If Num_v > 9999 Then ' e' superiore alle 4 cifre Num_v = 0 ' lo azzero 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 200 ' ritardo Call Chek_rinf ' Verifica il non rinfresco in corso Dp_r = 4 - Dp_v ' attivo il decimal point sui rossi ' nella posizione opposta ai verdi Decr Num_r ' decremento il conteggio If Num_r = 0 Then ' e' arrivato a zero Num_r = 9999 ' lo pongo al valore massimo End If 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 200 ' 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 Dp_v 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 44)* ' * * ' * Parametri: 3 ingresso, 1 uscita * ' * Igresso : var. Disp byte (da 0 a 3), indica quale display verra gestito* ' * rossi verdi * ' * 0 -> DY4 e DY8 * ' * 1 -> DY3 e DY7 * ' * 2 -> DY2 e DY6 * ' * 3 -> DY1 e DY5 * ' * var. cif_v byte ( da 0 a 255), cifra 7 seg. verde * ' * var. cif_r byte ( da 0 a 255), cifra 7 seg. rossa * ' * * ' * uscita : var. Bit23 Long * ' * La variabile Bit23 ( 4 byte) e' cosi' suddivisa : * ' * Bit23+0 -> byte 0 indica la cifra per DY5, DY6, DY7, DY8 verdi * ' * * ' * Bit23+1 -> byte 1 indica la cifra per DY1, DY2, DY3, DY4 rossi * ' * * ' * 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 Cifa As Long , Byval Cifb As Long) ' converte le 2 cifre per il 5480 IC1 Local X8 As Byte Local Bit32 As Long ' converte le 2 cifre per il 5480 IC1 Bit23 = 0 X8 = Cifa ' salvo il byte 0, con la 1 cifra Bit23 = X8 X8 = Cifb ' 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 ' ' *************** 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_mv , Cif_mr) ' preparo i bit per DY4 e DY8 Incr Disp ' commuto prossima coppia di display Case 1 : Call Conv_bit(cif_cv , Cif_cr) ' preparo i bit per DY3 e DY7 Incr Disp ' commuto prossima coppia di display Case 2 : Call Conv_bit(cif_dv , Cif_dr) ' preparo i bit per DY2 e DY6 Incr Disp ' commuto prossima coppia di display Case Is => 3 : Call Conv_bit(cif_uv , Cif_ur) ' 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 i verdi Call C_cifre(num_v , Dp_v) ' ricalcolo le 4 cifre di Num_v Cif_mv = Cif_m ' salvo le migliaia Cif_cv = Cif_c ' salvo le centinaia Cif_dv = Cif_d ' salvo le decine Cif_uv = Cif_u ' salvo le unita' Else ' rinfresco i rossi Call C_cifre(num_r , Dp_r) ' ricalcolo le 4 cifre per i rossi Cif_mr = Cif_m ' salvo le migliaia Cif_cr = Cif_c ' salvo le centinaia Cif_dr = Cif_d ' salvo le decine Cif_ur = 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 Long , Dp As Byte) ' Converte 1 numero di 4 cifre in 4 ' cifre separate; attiva il punto ' decimale Local X16 As Word 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 Digit byte (conversione per 7 segmenti) * ' * * ' * In questa procedura il decimal point e' sempre disattivo. * ' ********************************************************************** ' Function Conv7 (byval Cifra As Long) As Byte ' converte un numero da 0 a 9 in 7 ' segmenti If Cifra < 10 Then ' il numero risulta minore di 10 Conv7 = Lookup(cifra , 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 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. 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 ' ************************************************************************** '