List p=16f84 ;Tipo di processore include "P16F84.INC" ;Definizioni di registri interni. goto Inizio

Transcript

1 ESEMPIO 1.1 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Sommare due valori immediati (p.e. 5+7) il risultato va depositato nella posizione 0x10 List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Risultato equ 0x10 Determina la posizione del risultato Vettore di Reset Salva il vettore di interrupt Inizio movlw 0x05 Carica il 1 addo in W addlw 0x07 Somma il 2º addo movwf Risultato Memorizza il risultato Stop nop Metti breakpoint di arresto nop Fine del programma principale

2 ESEMPIO 1.2 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Tre valori A,B e C supponiamo siano stati precedentemente memorizzati. Si desidera risolvere la seguente equazione: (A+B)-C List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Dato_A equ 0x10 Determina la posizione del dato A Dato_B equ 0x11 Determina la posizione del dato B Dato_C equ 0x12 Determina la posizione del dato C Risultato equ 0x13 Determina la posizione del risultato Vettore di Reset Salva il vettore di interrupt Inizio movf Dato_A,W Carica il 1 addo addwf Dato_B,W Somma il 2º addo movwf Risultato Memorizza risultato parziale movf Dato_C,W Carica il sottrao subwf Risultato,F Sottrai dal minuo e memorizza Stop nop Metti breakpoint di arresto nop Fine del programa principale

3 ESEMPIO 1.3 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Sommare due numeri, A e B, di 16 bits ciascuno. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Dato_A_L equ 0x10 Dato_A_H equ 0x11 Dato_B_L equ 0x12 Dato_B_H equ 0x13 Risultato_L equ 0x14 Risultato_H equ 0x15 Determina la posizione del dato A (basso) Determina la posizione del dato A (alto) Determina la posizione del dato B (basso) Determina la posizione del dato B (alto) Determina la posizione del risultato (basso) Determina la posizione del risultato (alto) Vettore di Reset Salva il vettore di interrupt Inizio movf Dato_A_L,W Carica meno peso del dato A addwf Dato_B_L,W Somma meno peso del dato B movwf Risultato_L Memorizza il risultato movf Dato_A_H,W Carica più peso del dato A btfsc STATUS,C C'è stato trasporto anteriore?? addlw 1 Si, aggiungi 1 all'accumulatore addwf Dato_B_H,W Somma più peso del dato B movwf Risultato_H Conserva il risultato Stop nop Metti breakpoint di arresto nop Fine del programma principale

4 ESEMPIO 1.4 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Sottrarre due numeri, A - B, di 16 bits ciascuno. Anche se questo esercizio è simile al precedente, è da notare che, il contenuto dell' accumulatore agisce come sottrao e, l'operando, come minuo. Ugualmente è da notare che il flag CARRY va interpretato in modo opposto a come va fatto con la somma (a "0" c'è trasporto). List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Dato_A_L equ 0x10 Dato_A_H equ 0x11 Dato_B_L equ 0x12 Dato_B_H equ 0x13 Risultato_L equ 0x14 Risultato_H equ 0x15 Determina la posizione del dato A (basso) Determina la posizione del dato A (alto) Determina la posizione del dato B (basso) Determina la posizione del dato B (alto) Determina la posizione del risultato (basso) Determina la posizione del risultato (alto) Vettore di Reset Salva il vettore di interrupt Inizio movf Dato_B_L,W Carica meno peso del dato B (sottrao) subwf Dato_A_L,W Sottrai meno peso del dato A (minuo) movwf Risultato_L Memorizza il risultato movf Dato_B_H,W Carica più peso del dato B (sottrao) btfss STATUS,C C'è stato trasporto(carry = 0) anteriore?? addlw 1 Sì, aggiungi 1 all'accumulatore (sottrao) subwf Dato_A_H,W Sottrai più peso del dato A (minuo) movwf Risultato_H Conserva il risultato Stop nop Metti breakpoint d'arresto nop Fine del programma principale

5 ESEMPIO 1.5 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Memorizzare il modello 33 in 15 posizioni contigue della memoria di dati, iniziando dall'indirizzo 0x10 List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Contatore equ 0x0c Contatore interno Prima equ 0x10 Posizione iniziale Vettore di Reset Salva il vettore di interrupt Inizio movlw.15 movwf Contatore Carica il contatore con 15 (in decimale) movlw Prima movwf FSR Orienta il puntatore con indirizzo iniziale movlw 0x33 Carica modello da memorizzare Loop movwf INDF Memorizza modello in pos. indicata da FSR incf FSR,F Aumenta il puntatore FSR decfsz Contatore,F Diminuisci contatore fino ad arrivare a 0 goto Loop Contatore non è 0 Stop nop Metti breakpoint d'arresto nop Fine del programma principale

6 ESEMPIO 1.6 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Il programma paragona due numeri A e B. Se A=B, il risultato è 0. Se A > B, il risultato è A-B. Se A < B il resultato è A+B Si noti che, non avo istruzioni di paragone, questo è realizzato mediante sottrazioni. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Dato_A equ 0x10 Variabile del dato A Dato_B equ 0x11 Variabile del dato B Risultato equ 0x12 Variabile per il risultato Vettore di Reset Salva il vettore di interrupt Inizio movf Dato_B,W Carica il dato B subwf Dato_A,W Sottrai/paragona a dato A btfsc STATUS,Z Sono uguali (Z=1)?? goto A_uguale_B Sì btfsc STATUS,C No. A maggiore di B (C=0)?? goto A_mayor_B Sì A_minor_B movf Dato_A,W No, A è minore di B addwf Dato_B,W Somma A più B movwf Risultato Conserva il risultato goto Stop A_mayor_B movwf Risultato goto Stop A_uguale_B clrf Risultato Azzera il risultato Stop nop Metti breakpoint d'arresto nop Fine del programma principale

7 ESEMPIO 1.7 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Il programma realizza una temporizzazione di 0.5 secondi. Si presume una frequenza di lavoro del PIC di 4 MHz, per cui il TMR0 cambia ogni 1 us (4Tosc=1uS ). Il TMR0 viene caricato con (il suo complemento, 7) e si seleziona un prescaler di 8. La temporizzazione così ottenuta è di 1990 us. Se questa si ripete 250 volte, si ottiene una temporizzazione totale intorno ai uS List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Contatore equ 0x10 Variabile per il contatore Vettore di Reset Salva il vettore di interrupt Inizio bsf STATUS,RP0 Seleziona banco dati 1 movlw b' ' movwf OPTION_REG Configura prescaler di 8 assegnato al TMR0 bcf STATUS,RP0 Seleziona banco dati 0 movlw.250 movwf Contatore Attiva la variabile contatore Loop1 clrf INTCON Disconnetti flag del TMR0 e interrupt movlw.7 movwf TMR0 Carica il TMR0 con complemento di 250 Loop2 btfss INTCON,T0IF Fine del TMR0 (flag T0IF=1)?? goto Loop2 No, aspettare decfsz Contatore,F Sì. Ripetere tante volte quante ne indica il contatore goto Loop1 Stop nop Metti breakpoint di arresto nop Fine del programma principale

8 ESEMPIO 1.8 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Questo esempio realizza il prodotto di due numeri di 8 bits generando un risultato di 16 bits. Il programma impiega lo stesso meccanismo di realizzazione di un prodotto su carta. Si noti che il programma viene eseguito sempre nello stesso intervallo di tempo, qualunque siano gli operandi. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni cblock 0x10 Inizio di definizione di variabili Moltiplicando Moltiplicatore Risultato_H Risultato_L Estatus_Temp Contatore c Variabile per il moltiplicando Variabile per il moltiplicatore Parte alta del risultato Parte bassa del risultato Reg. di stato temporale Variabile con numero di volte per eseguire operazioni Fine delle definizioni Vettore di Reset Salva il vettore di interrupt Inizio Loop clrf Risultato_H clrf Risultato_L Metti a 0000 il risultato iniziale movlw 0x08 movwf Contatore Avvia il contatore con 8 bcf STATUS,C Cancella il carry movf Moltiplicando,W Carica il moltiplicando btfsc Moltiplicatore,0 E' 1 il bit di minor peso del moltiplicatore?? addwf Risultato_H,F Sì, si somma il moltiplicando rrf Risultato_H,F rrf Risultato_L,F Spostamento a destra del risultato Ruota a destra il moltiplicatore senza che si modifichi il flag Carry Ruota_sen_Carry movf STATUS,W movwf Estatus_Temp Salva provvisoriamente il carry rrf Moltiplicatore,F Sposta a destra il moltiplicatore movf Estatus_Temp,W movwf STATUS Recupera il carry originale decfsz goto Loop Contatore,F Ripeti il loop 8 volte Stop nop Metti breakpoint d'arresto nop Fine del programma principale

9 ESEMPIO 1.9 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Converti il valore binario presente in posizione 0x10 in BCD. Il risultato va depositato nelle variabili Buffer_H e Buffer_L. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Binario equ 0x10 Valore binario iniziale Buffer_H equ 0x11 Parte alta del risultato Buffer_L equ 0x12 Parte bassa del risultato Temp_1 equ 0x13 Registro temporale Vettore di Reset Salva il vettore di interrupt Inizio movf Binario,W Carica il valore binario iniziale clrf Buffer_L clrf Buffer_H Attiva registri di lavoro BIN_BCD_1 addlw 0xf6 Sottrai 10 mediante somma di complemento a 2. btfss STATUS,C C'è Carry? goto BIN_BCD_3 NO. movwf Temp_1 SI.Conservare nel registro temporale. incf Buffer_L,F Aumentare byte basso, conservarlo e inviare... movf Buffer_L,W..copia al ==> W... xorlw b' '..0ah xor W. btfss STATUS,Z Buffer_L è uguale a 10?? goto BIN_BCD_2 NO. clrf Buffer_L SI. Metti Buffer_L a 0 incf Buffer_H,F Incrementare Buffer_H BIN_BCD_2 movf Temp_1,W Recuperare il dato. goto BIN_BCD_1 Continuare l'operazione. BIN_BCD_3 addlw H'0A' TEMPO + 0Ah swapf Buffer_L,F <3:0> <==> <7:4> y ==> Buffer_L iorwf Buffer_L,F W OR Buffer_L ==> Buffer_L Stop nop Metti breakpoint d'arresto nop Fine del programma principale

10 ESEMPIO 1.10 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione Converti il valore binario presente in posizione 0x10, compreso tra 0 e 9, nel suo equivalente in codice GRAY Questo esempio cerca di abituare l'utente all'utilizzo di tabelle List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Bcd equ 0x10 Valore BCD iniziale Gray equ 0x11 Valore ottenuto in codice GRAY Vettore di Reset Salva il vettore di interrupt Tabel addwf PCL,F Calcola spostamento sulla tabella retlw b' ' Codice GRAY della cifra 0 retlw b' ' Codice GRAY della cifra 1 retlw b' ' Codice GRAY della cifra 2 retlw b' ' Codice GRAY della cifra 3 retlw b' ' Codice GRAY della cifra 4 retlw b' ' Codice GRAY della cifra 5 retlw b' ' Codice GRAY della cifra 6 retlw b' ' Codice GRAY della cifra 7 retlw b' ' Codice GRAY della cifra 8 retlw b' ' Codice GRAY della cifra 9 Inizio movf Bcd,W Carica il valore BCD originale call Tabel Converti in GRAY movwf Gray Conserva il risultato Stop nop Metti breakpoint di arresto nop Fine del programma principale

11 ESEMPIO 2.11 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Il Display a 7 segmenti del MicroPIC Trainer Sul display a catodo comune connesso alla porta B, si vuole visualizzare lo stato logico "0" o "1" dell'interruttore RA0. Mediante l'interruttore RA1 si attiva o no il punto decimale. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Vettore di Reset Salva il vettore di interrupt Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata bcf STATUS,RP0 Seleziona banco 0 Loop clrwdt Aggiorna il WDT btfsc PORTA,0 Controlla RA0 goto RA0_es_1 E'livello "1" movlw b' ' movwf PORTB Visualizza la cifra 0 goto Test_RA1 RA0_es_1 movlw b' ' movwf PORTB Visualizza la cifra 1 Test_RA1 btfsc PORTA,1 Controlla RA1 goto RA1_es_1 E' a "1" bcf PORTB,7 Disconnetti punto decimale goto Loop RA1_es_1: bsf PORTB,7 Attiva punto decimale goto Loop Fine del programma principale

12 ESEMPIO 2.12 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Il Display a 7 segmenti del MicroPIC Trainer. Decodificatore hex. a 7 segmenti. Mediante i quattro interruttori RA0-RA3 si introduce un valore esadecimale di 4 bits che deve essere visualizzato sul display del MicroPIC Trainer List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Vettore di Reset Salva il vettore di interrupt ********************************************************************************** Tabella: Questa procedura converte il codice binario presente nei 4 bits di minor peso del reg. W nel suo equivalente a 7 segmenti. Il codice a 7 segmenti ritorna anche nel reg. W Tabella: addwf PCL,F Spostamento sulla tabella retlw b' ' Cifra 0 retlw b' ' Cifra 1 retlw b' ' Cifra 2 retlw b' ' Cifra 3 retlw b' ' Cifra 4 retlw b' ' Cifra 5 retlw b' ' Cifra 6 retlw b' ' Cifra 7 retlw b' ' Cifra 8 retlw b' ' Cifra 9 retlw b' ' Cifra A retlw b' ' Cifra b retlw b' ' Cifra C retlw b' ' Cifra d retlw b' ' Cifra E retlw b' ' Cifra F Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata bcf STATUS,RP0 Seleziona banco 0 Loop clrwdt Aggiornare il WDT movf PORTA,W andlw b' ' Leggi il codice di RA0-RA3 call Tabella Converti in 7 segmenti movwf PORTB Visualizza sul display goto Loop Fine del programma principale

13 ESEMPIO 2.13 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Contatore UP/DOWN binario Sugli 8 leds di uscita connessi alla porta B verrà visualizzato, in binario, il numero di impulsi applicati dall'entrata RA0. RA1 determina se il conto è ascente (a "1") o discente List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Vettore di Reset Salva il vettore di interrupt ******************************************************************************** Delay_20_ms: Questa procedura di temporizzazione ha per oggetto di eliminare l'"effetto rimbalzo" delle periferiche elettromeccaniche. Realizza un delay di 20 ms. Se il PIC lavora a una frequenza di 4MHz, il TMR0 cambia ogni us. Se vogliamo tempori- zzare us (20 ms) con un prescaler di 128, il TMR0 dovrà contare 156 eventi (156 * 128). Il valore 156 equivale a 9c hex. e poiché il TMR0 è ascedente bisognerà caricare il suo complemento a 1 (63 hex.). Delay_20_ms: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x63 Complemento hex. di 156 movwf TMR0 carica il TMR0 Delay_20_ms_1 clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Delay_20_ms_1 Ancora no bcf INTCON,T0IF Adesso sì, rimettere il flag return Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata movlw b' ' movwf OPTION_REG Prescaler di 128 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 Loop clrwdt Aggiornare il WDT btfss PORTA,0 Aumento del segnale RA0? goto Loop No call Delay_20_ms Elimina rimbalzi Loop_2 clrwdt Aggiornare il WDT btfsc PORTA,0 Diminuzione di RA0 (impulsi)?? goto Loop_2 No call Delay_20_ms C'è stato impulso, eliminare rimbalzi btfss PORTA,1 RA1 = 1 goto Down No, conto discente Up incf PORTB,F Conto ascente

14 goto Loop Down decf PORTB,F Conto discente goto Loop Fine del programma principale

15 ESEMPIO 2.14 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Contatore UP/DOWN decimale di una cifra Sul display a 7 segmenti connessi alla porta B verrà visualizzato il numero di impulsi applicati dall'entrata RA0. RA1 determina se il conto è ascente (a "1") o discente List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Contatore equ 0x0c Variabile del contatore Vettore di Reset Salva il vettore di interrupt ********************************************************************************** Tabella: Questa procedura converte il codice BCD presente nei 4 bits di minore peso del reg. W nel suo equivalente a 7 segmenti. Il codice a 7 segmenti ritorna anche nel reg. W Tabella: addwf PCL,F Spostamento sulla tabella retlw b' ' Cifra 0 retlw b' ' Cifra 1 retlw b' ' Cifra 2 retlw b' ' Cifra 3 retlw b' ' Cifra 4 retlw b' ' Cifra 5 retlw b' ' Cifra 6 retlw b' ' Cifra 7 retlw b' ' Cifra 8 retlw b' ' Cifra 9 ********************************************************************************* Delay_20_ms: Questa procedura di temporizzazione ha per scopo di eliminare l'"effetto rimbalzo" delle periferiche elettromeccaniche. Realizza un delay di 20 ms. Se il PIC lavora a una frequenza di 4MHz, il TMR0 cambia ogni us. Se desideriamo tempori- zzare us (20 ms) con un prescaler di 128, il TMR0 dovrà contare 156 eventi (156 * 128). >Il valore 156 equivale a 9c hex. e poiché il TMR0 è ascente bisognerà caricare il suo complemento a 1 (63 hex.). Delay_20_ms: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x63 Complemento hex. di 156 movwf TMR0 carica il TMR0 Delay_20_ms_1 clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Delay_20_ms_1 Ancora no bcf INTCON,T0IF Adesso sì, rimettere il flag return Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata

16 movlw b' ' movwf OPTION_REG Prescaler di 128 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 clrf Contatore Mettere a 0 del contatore Loop movf Contatore,W call Tabella Converti BCD in 7 segmenti movwf PORTB Visualizza il valore del contatore Wait_0 clrwdt Aggiornare il WDT btfss PORTA,0 Aumento del segnale RA0? goto Wait_0 No call Delay_20_ms Elimina rimbalzi Wait_1 clrwdt Aggiornare il WDT btfsc PORTA,0 Diminuzione di RA0 (impulso)?? goto Wait_1 No call Delay_20_ms C'è stato impulso, eliminare rimbalzi btfss PORTA,1 RA1 = 1 goto Down No, conto discente Up Down incf Contatore,F Aumenta contatore movlw.10 subwf Contatore,W btfss STATUS,Z E' maggiore di 9?? goto Loop No clrf Contatore Sì, mettere a 0 il contatore goto Loop decf Contatore,F Diminuisci il contatore movlw 0xff subwf Contatore,W btfss STATUS,Z E' minore di 0?? goto Loop No movlw 0x09 movwf Contatore Sì, mettere a 9 il contatore goto Loop Fine del programma principale

17 ESEMPIO 2.15 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Generazione di onde quadrate di differenti frequenze variando il valore del TMR0 La linea di uscita RB0 cambierà stato a una frequenza determinata dal valore introdotto mediante i 3 interruttori RA0-RA2: RA2 RA1 RA0 Frequenza Periodo Semiperiodo KHz KHz 1000 us 500 us KHz 500 us 250 us KHz 333 us 166 us KHz 250 us 125 us KHz 200 us 100 us KHz 166 us 83 us KHz 143 us 71 us Nel trattamento di interrupt che provocherà l'overflow del TMR0, si può notare come vengono salvati il W e il registro di stato, per recuperarli posteriormente. E' ciò che si chiama "salvare il contesto" List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Valore equ 0x0c Variabile di frequenza W_Temp equ 0x0d W temporale Status_Temp equ 0x0e Registro di stato temporale org 0x04 goto Interrupt Vettore di Reset Vettore di interrupt ********************************************************************************* Tabella: questa procedura restituisce il valore da caricare nel TMR0 secondo la frequenza selez- ionata. Parto da una frequenza generale di 4 MHz, il TMR0 cambia ogni 1 us. Si seleziona un preescaler di 4. Il valore da caricare in TMR0 si ottiene divido il semiperiodo della frequenza desiderata con il prescaler. Al valore ottenuto si sottrae 2 per motivi di sincronismo interno del PIC, si converte in hex. e si comple- menta. Tabel.: addwf PCL,F Calcola spostamento della tabella retlw 0x00 0 KHz retlw 0x86 1 KHz retlw 0xc5 2 KHz retlw 0xda 3 KHz retlw 0xe4 4 KHz retlw 0xea 5 KHz retlw 0xee 6 KHz retlw 0xf1 7 KHz Interrupt movwf W_Temp swapf STATUS,W Salva il W

18 movwf Status_Temp Salva il registro di stato movf Valore,W movwf TMR0 Ricarica il TMR0 bcf INTCON,T0IF Disattiva il flag TMR0 movlw b' ' xorwf PORTB,F Fai oscillare RB0 swapf Status_Temp,W movwf STATUS Recupera il registro di stato swapf W_Temp,F swapf W_Temp,W Recupera il registro W retfie Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata movlw b' ' movwf OPTION_REG Prescaler di 4 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 movlw b' ' movwf INTCON Interrupt TMR0 abilitato Loop clrwdt Aggiornare il WDT movf PORTA,W andlw b' ' btfss STATUS,Z RA0-RA2 = 0?? goto Uscita_On No, uscita di frequenza bcf INTCON,GIE Sì, interrupt OFF, frequenza OFF goto Loop Uscita_On call Tabella Determina valore da caricare in TMR0 movwf Valor Carica la variabile bsf INTCON,GIE Interrupt ON goto Loop Fine del programma principale

19 ESEMPIO 2.16 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Generazione di numeri aleatori Ogni volta che si applica un impulso attraverso RA0, si genera un numero binario aleatorio di 8 bits che verrà visualizzato sugli 8 leds connessi nella porta B, per 3 secondi. Tra le differenti tecniche, quella utilizzata per ottenere il numero, consiste nel catturare il valore del TMR0 in un determinato momento. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Numero equ 0x0c Numero aleatorio Delay_Cont equ 0x0d Contatore di intervalli Vettore di Reset Salva vettore di interrupt ********************************************************************************* Delay_20_ms: Questa procedura di temporizzazione ha per scopo di eliminare l'"effetto rimbalzo" delle periferiche elettromeccaniche. Realizza un delay di 20 ms. Se il PIC lavora a una frequenza di 4MHz, il TMR0 cambia ogni us. Se vogliamo tempori- zzare us (20 ms) con un prescaler di 256, il TMR0 dovrà contare 78 eventi (78 * 256). Il valore 78 equivale a 0x4e hex. e poiché il TMR0 è ascente bisognerà caricare il suo complemento a 1 (0xb1 hex.). Delay_20_ms: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0xb1 Complemento hex. de 78 movwf TMR0 carica il TMR0 Delay_20_ms_1 clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Delay_20_ms_1 Ancora no return ********************************************************************************* Delay_var: Questa procedura a scopo generico realizza una temporizzazione variabile tra 50 ms e 12.8". Si impiega un prescaler di 256 e il TMR0 viene caricato con 195. La velocità di lavoro è di 4Mhz e quindi il TMR0 incrementa ogni us. In questo modo, il TMR0 deve contare 195 eventi che, con un preescaler di 128 fa un intervallo totale di us/50 ms (195 * 256). Il valore 195 va espresso in Hex. (c3) e poiché il TMR0 è ascente bisognerà caricare il suo complemento (3C hex.) Tale intervallo di 50 ms si ripete tante volte quante ne indica la variabile "Delay_cont", è per questo che il delay minimo è di 50 ms ("Delay_cont=1) e il massimo di 12.8" (Delay_cont=255). Delay_var: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x3c Complemento hex. de 195 movwf TMR0 carica il TMR0 Intervallo clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0??

20 goto Intervallo Ancora no decfsz Delay_Cont,F Diminusci contatore di intervalli goto Delay_var Ripeti l'intervallo di 50 ms return Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata movlw b' ' movwf OPTION_REG Prescaler di 256 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 Loop clrwdt Aggiornare il WDT btfss PORTA,0 Attivato RA0?? goto Loop Ancora No movf TMR0,W Adesso sì. movwf Numero Cattura il valore del TMR0 (Nº aleatorio) call Delay_20_ms Elimina rimbalzi RA0_1 clrwdt Aggiorna il WDT btfsc PORTA,0 Disattivato RA0?? goto RA0_1 Ancora no movf Numero,W E' stato prodotto un impulso in RA0, si legge movwf PORTB il valore catturato del TMR0 (Nº aleatorio) e si toglie con i leds della PORTA B movlw d'60' movwf Delay_Cont Introduci variabile di temporizzazione call Delay_var Temporizza 3 secondi clrf PORTB Disconetti le uscite goto Loop Fine del programma principale

21 ESEMPIO 2.17 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Generazione di numeri aleatori. Il dado elettronico Si tratta di generare un numero aleatorio tra 1 e 6. Quando RA0 è a "1", sul display a 7 segmenti connesso alla porta B, si visualizzano in forma sequeziale i numeri dall'1 al 6, con intervalli di 0.05". Quando RA0 passa a livello "0", si visualizza il numero aleatorio ottenuto in un tempo di 3". Poi il display si spegne e la sequenza si ripete. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Numero equ 0x0c Numero aleatorio Delay_Cont equ 0x0d Contatore di intervalli Temporale equ 0x0e Variabile temporale Vettore di Reset Salva vettore di interrupt ********************************************************************************** Tabella: Questa procedura converte il codice binario presente nei 4 bits di minor peso del reg. W nel suo equivalente a 7 segmenti. Il codice a 7 segmenti ritorna anche nel reg. W Tabella: addwf PCL,F Spostamento sulla tabella retlw b' ' Cifra 0 retlw b' ' Cifra 1 retlw b' ' Cifra 2 retlw b' ' Cifra 3 retlw b' ' Cifra 4 retlw b' ' Cifra 5 retlw b' ' Cifra 6 ********************************************************************************* Delay_20_ms: Questa procedura di temporizzazione ha per scopo di eliminare l'"effetto rimbalzo" delle periferiche elettromeccaniche. Realizza un delay di 20 ms. Se il PIC lavora a una frequenza di 4MHz, il TMR0 cambia ogni us. Se vogliamo tempori- zzare us (20 ms) con un prescaler di 256, i TMR0 dovrà contare 78 eventi (78 * 256). Il valore 78 equivale a 0x4e hex. e poiché il TMR0 è ascente bisognerà caricare il suo complemento a 1 (0xb1 hex.). Delay_20_ms: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0xb1 Complemento hex. de 78 movwf TMR0 carica il TMR0 Delay_20_ms_1 clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Delay_20_ms_1 Ancora no return ********************************************************************************* Delay_var: Questa pocedura a scopo generale realizza una temporizzazione variabile tra 50 ms e 12.8". Si impiega un prescaler di 256 e il TMR0 viene caricato con 195. La velocità di lavoro è di 4Mhz e quindi il TMR0 aumenta ogni us. In

22 questo modo, il TMR0 deve contare 195 eventi che, con un preescaler di 128 fa un intervallo totale di us/50 ms (195 * 256). Il valore 195 deve essere espresso in Hex. (c3) e poichè il TMR0 è ascente bisognerà caricare il suo complemento (3C hex.) Tale intervallo di 50 ms si ripete tante volte quante ne indica la variabile "Delay_cont", è per questo che il delay minimo è di 50 ms ("Delay_cont=1) e il massimo di 12.8" (Delay_cont=255). Delay_var: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x3c Complemento hex. de 195 movwf TMR0 carica il TMR0 Intervallo clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Intervallo Ancora no decfsz Delay_Cont,F Diminuisci contatore di intervalli goto Delay_var Ripeti l'intervallo di 50 ms return Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata movlw b' ' movwf OPTION_REG Prescaler di 256 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 Loop clrwdt Aggiornare il WDT btfss PORTA,0 Attivato RA0?? goto Loop Ancora No movf TMR0,W Adesso sì. movwf Numero Cattura il valore del TMR0 (Nº aleatorio) call Delay_20_ms Elimina rimbalzi Il numero aleatorio viene, mediante sottrazioni consecutive, diviso in 6. In questo modo l'ultimo resto sarà tra 0 e 5 che verrà incrementato di una unità affinché si abbia defini- tivamente un numero tra 1 e 6 Dividi: movlw d'6' subwf Numero,W Sottrai 6 al numero aleatorio movwf Numero conservalo sublw d'5' btfss STATUS,C Guarda se è minore de 5 goto Dividi No incf Numero,F Il numero è tra 1 e 6 Questa procedura di istruzioni ha per scopo di mostrare sul display i numeri dall'1 al 6 a intervalli di 0.05" per dare una sensazione di movimento del dado. Tale movimento viene mantenuto mentre RA0 é a "1". Andando a "0" si presenta il numero aleatorio precedentemente catturato dal TMR0 Dado: movlw d'6' movwf Temporale Avvia il contatore del dado RA0_1 clrwdt Aggiornamento del WDT btfss PORTA,0 Guarda se RA0 è a 1 goto Uscita No, visualizza l'aleatorio movf Temporale,W Numero da visualizzare call Tabella Conversione in BCD movwf PORTB Visualizza sul display movlw d'1'

23 movwf Delay_Cont Variabile di temporizzazione call Delay_var temporizza 0.05" decfsz Temporale,F Numero seguente goto RA0_1 goto Dado call Delay_20_ms Elimina rimbalzi Uscita: movf Numero,W Ripri l'aleatorio call Tabella Lo converte in 7 segmenti movwf PORTB Uscita sul Display movlw d'60' movwf Delay_Cont avvia variabile di temporizzazione call Delay_var Temporizza 3" clrf PORTB Disconnetti l'uscita goto Loop Fine del programma principale

24 ESEMPIO 2.18 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer Il TMR0 come contatore di eventi esterni Un sensore optoelettronico connesso a RA4 genera un impulso ogni volta che un oggetto si iterpone tra l'emissore e il recettore di luce. Il TMR0 si incarica di contarli a seconda del valore del prescaler. Tale valore si aggiusta mediante 3 interruttori (RA0-RA2) connessi alla Porta A, essoci così 8 pre-divisioni: I2 I1 I0 Divisione : : : : : : : :256 Il conteggio è visualizzato in binario sui leds collegato alla Porta B e deve essere moltiplicato per il valore del prescaler selezionato, per determinare il numero totale di impulsi. Il contatore si riassetta metto RA3 a "1". Va tenuto conto del "effetto rimbalzo" che si produce nell'interruttore RA4 del MicroPIC Trainer. List p=16f84 Tipo di processore include "P16F84.INC" Definizioni de registri interni Vettore di Reset Salva vettore di interrupt Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata movlw b' ' movwf OPTION_REG TMR0 contatore sensibile al discente di RA4 bcf STATUS,RP0 Seleziona banco 0 Loop clrf TMR0 Mettere a 0 il contatore Loop1: clrwdt Aggiorna il WDT btfsc PORTA,3 Controlla se I3 è attivo (RESET) goto Loop Sì Conto arrestato e settaggio a 0 movf PORTA,W No, leggere I2-I0 per formare il nuovo valore andlw b' ' del prescaler bsf STATUS,RP0 Seleziona pagina 1 iorwf OPTION_REG,F Aggiorna il nuovo valore del prescaler bcf STATUS,RP0 Seleziona pagina 0 movf TMR0,W Leggi il valore del contatore movwf PORTB Uscita ai leds goto Loop1 Fine del programma principale

25

26 ESEMPIO 2.19 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer La memoria EEPROM di dati.la macchina "SUO TURNO" Si tratta di simulare il funzionamento delle macchine tipo "SUO TURNO" comuni in molteplici attività. Sul display verrà visualizzato il numero del turno attuale. Questo aumenta a ogni impulso applicato da RA0. Nella memoria EEPROM del PIC16F84 si immagazzina l'ultimo numero visualizzato, in modo che, davanti a una mancanza di alimentazione (p.e.), si ripra il conto dall' ultimo numero. Se si inizia utilizzando il sistema per la prima volta, si visualizza lo 0 List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Contatore equ 0x0c Variabile per il contatore Vettore di Reset Salva vettore di interrupt **************************************************************************************** EE_Write: Registra un byte nella EEPROM di dati. L'indirizzo sarà quello contenuto in EEADR e il dato si suppone sia stato precedentemente messo in EEDATA EE_Write bsf STATUS,RP0 Seleziona banco 1 bsf EECON1,WREN Permesso di scrittura movlw b' ' movwf EECON2 movlw b' ' movwf EECON2 Sequenza stabilita da Microchip bsf EECON1,WR Ordine di scrittura bcf EECON1,WREN Disconnetti permesso di scrittura Wait btfss EECON1,EEIF Controllare flag di fine di scrittura goto Wait bcf EECON1,EEIF Rimettere flag di fine di scrittura bcf STATUS,RP0 Selezione banco 0 return ************************************************************************************** EE_Read: Leggere un byte dalla EEPROM. Il registro EEADR deve essere caricato con l'indiriz- zo da leggere. In EEDATA apparirà il dato letto. EE_Read bsf STATUS,RP0 Selezione di banco 1 bsf EECON1,RD Ordine di lettura bcf STATUS,RP0 Selezione di banco 0 return ********************************************************************************** Tabella: Questa procedura converte il codice BCD presente nei 4 bits di minor peso del reg. W nel suo equivalente a 7 segmenti. Il codice a 7 segmenti ritorna anche nel reg. W

27 Tabella: addwf PCL,F Spostamento sulla tabella retlw b' ' Cifra 0 retlw b' ' Cifra 1 retlw b' ' Cifra 2 retlw b' ' Cifra 3 retlw b' ' Cifra 4 retlw b' ' Cifra 5 retlw b' ' Cifra 6 retlw b' ' Cifra 7 retlw b' ' Cifra 8 retlw b' ' Cifra 9 ********************************************************************************* Delay_20_ms: Questa procedura di temporizzazione ha per scopo di eliminare l'"effetto rimbalzo" delle periferiche elettromeccaniche. Realizza un delay di 20 ms. Se il PIC lavora a una frequenza di 4MHz, il TMR0 cambia ogni us. Se vogliamo tempori- zzare us (20 ms) con un prescaler di 128, il TMR0 dovrà contare 156 eventi (156 * 128). Il valore 156 equivale a 9c hex. e poiché il TMR0 è ascente bisognerà caricare il suo complemento a 1 (63 hex.). Delay_20_ms: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x63 Complemento hex. de 156 movwf TMR0 carica il TMR0 Delay_20_ms_1 clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Delay_20_ms_1 Ancora no bcf INTCON,T0IF Adesso sì, rimettere il flag return Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA Porta A si configura come entrata movlw b' ' movwf OPTION_REG Prescaler di 128 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 Ini_0 Ini_1 clrf EEADR Seleziona indirizzo 00 di EEPROM call EE_Read Leggi byte dalla EEPROM movlw 0x09 subwf EEDATA,W btfsc STATUS,C Maggiore di 9?? goto Ini_0 Sì, mettere a 0 il contatore goto Ini_1 No clrf Contatore Mettere a 0 il contatore goto Loop movf EEDATA,W movwf Contatore Avviare contatore Loop movf Contatore,W call Tabella movwf PORTB Converti contatore a 7 segmenti Visualizza sul display Wait_0 clrwdt Aggiorna il WDT btfss PORTA,0 RA0 è a "1"?? goto Wait_0 No, aspettare call Delay_20_ms Eliminare rimbalzi Wait_1 clrwdt Aggiornare il WDT

28 btfsc PORTA,0 RA0 è a "0"?? goto Wait_1 No, aspettare call Delay_20_ms Eliminare rimbalzi. C'è stata un impulso incf Contatore,F Aumenta contatore movlw.10 subwf Contatore,W btfsc STATUS,Z Contatore maggiore di 9?? clrf Contatore Sì, ritorno a 00 movf Contatore,W movwf EEDATA call EE_Write Registra il nuovo valore del contatore nella EEPROM goto Loop Fine del programma principale

29 ESEMPIO 2.20 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer L'uso dello schermo LCD Questo esempio vuole introdurci all'utilizzo dello schermo LCD, per visualizzare differenti messaggi (p.e. Ciao). Va ricordato che le linee RA0-RA2 agiscono ora come uscita di segnali di controllo verso l'lcd. Esso connesse ai propri interruttori nel MicroPIC Trainer, questi devono essere permanentemente a livello logico "1". List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Lcd_var equ 0x0c Variabili (2) delle procedure di utilizzo dell'lcd Vettore di Reset Salva vettore di interrupt include "LCD_Cxx.inc" Include le procedure di utilizzo dell'lcd Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA RA0-RA2 uscite, RA3-RA4 entrate bcf STATUS,RP0 Seleziona banco 0 call LCD_INI movlw b' ' call LCD_REG Sequenza di inizio dell'lcd Invia istruzione: LCD ON, Cursore ON e blink ON movlw 'C' call LCD_DATO Visualizza C movlw 'i' call LCD_DATO Visualizza i movlw 'a' call LCD_DATO Visualizza a movlw 'o' call LCD_DATO Visualizza o movlw ' ' call LCD_DATO Visualizza bianco Loop sleep Messa in Standby goto Loop Ritorno in standby Fine del programma principale

30 ESEMPIO 2.21 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer L'uso dello schermo LCD Questo esempio vuole introdurci all'utilizzo dello schermo LCD, per visualizzare differenti messaggi. Va ricordato che le linee RA0-RA2 agiscono ora come uscita di segnali di controllo verso l'lcd. Esso connesse ai propri interruttori nel MicroPIC Trainer, questi devono essere permanentemente a livello logico "1". List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Lcd_var equ 0x0c Variabili (2) delle procedure d'uso dell'lcd Delay_Cont equ 0x0e Variabile per la temporizzazione Temporal_1 equ 0x0f Variabile temporale Temporal_2 equ 0x10 Variabile temporale Vettore di Reset Salva vettore di interrupt include "LCD_Cxx.inc" Include le procedure d'uso dell'lcd **************************************************************************************** ** A seconda del valore contenuto nel registro W, si restituisce il carattere da visualizzare Tabella_Messaggi movwf PCL Calcola lo spostamento sulla tabella Mess_0 equ $ Mess_0 punta al primo carattere del messaggio 0 retlw 'C' retlw 'i' retlw 'a' retlw 'o' retlw 0x00 Ultimo carattere del messaggio 0 Mess_1 equ $ Mess_1 punta al primo carattere del messaggio 1 retlw 'H' retlw 'e' retlw 'l' retlw 'l' retlw 'o' retlw 0x00 Ultimo carattere del messaggio 1 ********************************************************************************* Delay_var: Questa procedura a scopo generale realizza una temporizzazione variabile tra 50 ms e 12.8". Si impiega un prescaler di 256 e il TMR0 viene caricato con 195. La velocità di lavoro è di 4Mhz e quindi il TMR0 aumenta ogni us. In questo modo, il TMR0 deve contare 195 eventi che, con un prescaler di 256 fa un intervallo totale di us/50 ms (195 * 256). Il valore 195 deve essere espresso in Hex. (c3) e poiché il TMR0 è ascente bisognerà caricare il suo complemento (3C hex.)

31 Tale intervallo di 50 ms si ripete tante volte quante ne indica la variabile "Delay_cont", è per questo che il delay minimo è di 50 ms ("Delay_cont=1) e il massimo di 12.8" (Delay_cont=255). Delay_var: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x3c Complemento hex. di 195 movwf TMR0 Carica il TMR0 Intervallo clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Intervallo Ancora no decfsz Delay_Cont,F Diminuisci contatore di intervalli goto Delay_var Ripeti l'intervallo di 50 ms return ************************************************************************************* Messaggio: Questa procedura visualizza sull'lcd il messaggio il cui inizio è indicato nell'accumulatore. La fine di un messaggio si determina mediante il codice 0x00 Messagg movwf Temporal_1 Salva posizione della tabella Messagg_1 movf Temporal_1,W Recupera posizione della tabella call Tabella_Messaggi Cerca carattere di uscita movwf Temporal_2 Mantieni il carattere movf Temporal_2,F btfss STATUS,Z Guarda se è l'ultimo goto No_è_ultimo return No_è_ultimo call LCD_DATO Visualizza sull'lcd incf Temporal_1,F Carattere succesivo goto Messagg_1 ********************************************************************************** Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come usicta movlw b' ' movwf TRISA RA0-RA2 uscite, RA3-RA4 entrate movlw b' ' movwf OPTION_REG Prescaler di 256 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 call LCD_INI movlw b' ' call LCD_REG Sequenza di inizio dell'lcd Invia istruzione: LCD ON, Cursore OFF e blink OFF Loop posizione) posizione) movlw b' ' call LCD_REG Cancella LCD e Home (collocare cursore in 1ª movlw Mess_0 call Messagg Visualizza il messaggio 0 movlw.20 movwf Delay_Cont call Delay_var Temporizza 2 secondi movlw b' ' call LCD_REG Cancella LCD e Home (collocare cursore in 1ª movlw Mess_1 call Messagg Visualizza il messaggio 1 movlw.20 movwf Delay_Cont call Delay_var Temporizza 2 secondi goto Loop

32 Fine del programma principale

33 ESEMPIO 2.22 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer L'uso dello schermo LCD, ancora più messaggi. Questo esempio vuole introdurci all'utilizzo dello schermo LCD, per visualizzare differenti messaggi. Va ricordato che le linee RA0-RA2 agiscono ora come uscita di segnali di controllo verso l'lcd. Esso connesse con i propri interruttori nel MicroPIC Trainer, questi devono essere permanentemente a livello logico "1". List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Lcd_var equ 0x0c Variabili (2) delle procedure di utilizzo dell'lcd Delay_Cont equ 0x0e Variabile per la temporizzazione Temporal_1 equ 0x0f Variabile temporale Temporal_2 equ 0x10 Variabile temporale Vettore di Reset Salva vettore di interrupt include "LCD_Cxx.inc" Include le procedure di utilizzo dell'lcd **************************************************************************************** ** Secondo il valore contenuto nel registro W, si restituisce il carattere da visualizzare Tabel_Messaggi movwf PCL Calcola lo spostamento sulla tabella *********************************************************************************** La direttiva dt genera tante istruzioni retlw quanti bytes o caratteri contiene Mess_0 equ $ Mess_0 punta al primo carattere del messaggio 0 dt "Microsystems",0x00 Mess_1 equ $ Mess_1 punta al primo carattere del messaggio 1 dt "Engineering",0x00 Mess_2 equ $ Mess_2 punta al primo carattere del messaggio 2 dt "Gral. Concha 39",0x00 Mess_3 equ $ Mess_3 punta al primo carattere del messaggio 3 dt "48012 Bilbao",0x00 ********************************************************************************* Delay_var: Questa procedura di scopo generale realizza una temporizzazione variabile tra 50 ms e 12.8". Si impiega un prescaler di 256 e il TMR0 viene caricato con 195. La velocità di lavoro è di 4Mhz e quindi il TMR0 aummenta ogni us. In questo modo, il TMR0 deve contare 195 eventi che, con un prescaler di 256 fa un intervallo totale di us/50 ms (195 * 256). Il valore 195 deve essere espresso in Hex. (c3) e poiché il TMR0 è ascente bisognerà caricare il suo complemento (3C hex.) Tale intervallo di 50 ms si ripete tante volte quante ne indica la variabile "Delay_cont", è per questo che il delay minimo è di 0 ms ("Delay_cont=1) e il massimo di 12.8"

34 (Delay_cont=255). Delay_var: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x3c Complemento hex. di 195 movwf TMR0 carica il TMR0 Intervallo clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Intervallo Ancora no decfsz Delay_Cont,F Diminuisci contatore di intervalli goto Delay_var Ripeti l'intervallo di 50 ms return ************************************************************************************* Messaggio: Questa procedura visualizza sull'lcd il messaggio il cui inizio è indicato nell'accumulatore. La fine di un messaggio si determina mediante il codice 0x00 Messagg movwf Temporal_1 Salva posizione della tabella Messagg_1 movf Temporal_1,W Recupera posizione della tabella call Tabel_Messaggi Cerca carattere di uscita movwf Temporal_2 Mantieni il carattere movf Temporal_2,F btfss STATUS,Z Guarda se è l'ultimo goto No_è_ultimo return No_è_ultimo call LCD_DATO Visualizza sull'lcd incf Temporal_1,F Carattere successivo goto Messagg_1 ********************************************************************************** Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA RA0-RA2 uscite, RA3-RA4 entrate movlw b' ' movwf OPTION_REG Prescaler di 256 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 call LCD_INI movlw b' ' call LCD_REG Sequenza di inizio dell'lcd Invia istruzione: LCD ON, Cursore OFF e blink OFF Loop posizione) posizione) movlw b' ' call LCD_REG Cancella LCD e Home (collocare cursore in 1ª movlw Mess_0 call Messagg Visualizza il messaggio 0 movlw b' ' call LCD_REG Colloca cursore in 2ª fila dell'lcd movlw Mess_1 call Messagg Visualizza messaggio 1 movlw.40 movwf Delay_Cont call Delay_var Temporizza 4 secondi movlw b' ' call LCD_REG Cancella LCD e Home (collocare cursore in 1ª movlw Mess_2 call Messagg Visualizza il messaggio 2 movlw b' ' call LCD_REG Colloca cursore in 2ª fila dell'lcd movlw Mess_3

35 call Messagg Visualizza il messaggio 3 movlw.40 movwf Delay_Cont call Delay_var Temporizza 4 secondi goto Loop Fine del programma principale

36 ESEMPIO 2.23 Autore: Mikel Etxebarria (c) Microsystems Engineering (Bilbao) Esempio per simulazione e/o MicroPIC Trainer L'uso dello schermo LCD. Un semplice generatore di messaggi. Questo esempio vuole realizzare un generatore di messaggi per l'lcd. Con RA4 a "1", il sistema è nel modo di programmazione. In questo modo il messaggio è registrato nella EEPROM di dati. Con RA4 a "0" entriamo nel modo di riproduzione. Il messaggio registrato nella EEPROM viene visualizzato sull'lcd. Quando l'interruttore RA3 è a livello "1", nella posizione attuale del cursore appaio- no sequenzialmente i distinti caratteri disponibili. Mettolo a "0" si sele- ziona l'attuale e si registra nella EEPROM. Ritornando di nuovo a "1" si seleziona il se- guente carattere. Va ricordato che le linee RA0-RA2 ora agiscono come uscita di segnali di controllo verso l'lcd. Esso connesse ai propri interruttori nel MicroPIC Trainer, questi devono essere permanentemente a livello logico "1". List p=16f84 Tipo di processore include "P16F84.INC" Definizioni di registri interni Lcd_var equ 0x0c Variabili (2) delle procedure d'uso dell'lcd Delay_Cont equ 0x0e Variabile per la temporizzazione Temporale_1 equ 0x0f Variabile temporale Temporale_2 equ 0x10 Variabile temporale Cur_Pos equ 0x11 Posizione del cursore Vettore di Reset Salva vettore di interrupt include "LCD_Cxx.inc" Include le procedure d'uso dell'lcd ********************************************************************************* Delay_20_ms: Questa procedura di temporizzazione ha per scopo di eliminare l'"effetto rimbalzo" delle periferiche elettromeccaniche. Realizza un delay di 20 ms. Se il PIC lavora a una frequenza di 4MHz, il TMR0 cambia ogni us. Se vogliamo temporiz- zare us (20 ms) con un prescaler di 128, il TMR0 dovrà contare 156 eventi (156 * 128). Il valore 156 equivale a 9c hex. e poiché il TMR0 è ascedente bisognerà caricare il suo complemento a 1 (63 hex.). Delay_20_ms: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x63 Complemento hex. di 156 movwf TMR0 carica il TMR0 Delay_20_ms_1 clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Delay_20_ms_1 Ancora no bcf INTCON,T0IF Adesso sì, rimettere il flag return ********************************************************************************* Delay_var: Questa procedura a scopo generico realizza una temporizzazione variabile tra 50 ms e 12.8". Si impiega un prescaler di 256 e il TMR0 viene caricato con 195. La velocità di lavoro è di 4Mhz e quindi il TMR0 aumenta ogni us. In questo modo, il TMR0 deve contare 195 eventi che, con un prescaler di 256 fa un

37 intervallo totale di us/50 ms (195 * 256). Il valore 195 deve essere espresso in Hex. (c3) e poiché il TMR0 è ascente bisognerà caricare il suo complemento (3C hex.) Tale intervallo di 50 ms si ripete tante volte quante ne indica la variabile "Delay_cont", è per questo che il delay minimo è di 50 ms ("Delay_cont=1) e il massimo di 12.8" (Delay_cont=255). Delay_var: bcf INTCON,T0IF Disconnetti il flag di overflow movlw 0x3c Complemento hex. di 195 movwf TMR0 carica il TMR0 Intervallo clrwdt Aggiornare il WDT btfss INTCON,T0IF Overflow del TMR0?? goto Intervallo Ancora no decfsz Delay_Cont,F Diminuisci contatore di intervalli goto Delay_var Ripeti l'intervallo di 50 ms return **************************************************************************************** EE_Write: Registra un byte nella EEPROM di dati. L'indirizzo sarà quello contenuto in EEADR e il dato si suppone sia stato precedentemente messo in EEDATA EE_Write bsf STATUS,RP0 Seleziona banco 1 bsf EECON1,WREN Permesso di scrittura movlw b' ' movwf EECON2 movlw b' ' movwf EECON2 Sequenza stabilita da Microchip bsf EECON1,WR Ordine di scrittura bcf EECON1,WREN Disconnetti permesso di scrittura Wait btfss EECON1,EEIF Testare flag di fine scrittura goto Wait bcf EECON1,EEIF Rimettere flag di fine scrittura bcf STATUS,RP0 Seleziona banco 0 return ************************************************************************************** EE_Read: Leggere un byte della EEPROM. Si suppone che il registro EEADR sia caricato con l'indiriz- zo da leggere. In EEDATA apparirà il dato letto. EE_Read bsf STATUS,RP0 Selezione di banco 1 bsf EECON1,RD Ordine di lettura bcf STATUS,RP0 Selezione di banco 0 return ********************************************************************************** Inizio clrf PORTB Cancella i latch di uscita bsf STATUS,RP0 Seleziona banco 1 clrf TRISB Porta B si configura come uscita movlw b' ' movwf TRISA RA0-RA2 uscite, RA3-RA4 entrate movlw b' ' movwf OPTION_REG Prescaler di 256 per il TMR0 bcf STATUS,RP0 Seleziona banco 0 movlw 0x80 movwf Cur_Pos Posizione iniziale del cursore call LCD_INI Sequenza di inizio dell'lcd movlw b' ' call LCD_REG Cancella LCD e Home movlw b' '