PIC Esempi - LED - Dipartimento di Sistemi e Informatica

PIC Esempi - LED 

Per i primi esempi viene utilizzato soltanto un LED sulla porta B (PortB), successivamente 

si utilizzano più LED. 

1.1 

Questo semplice programma esegue uno switch ripetutamente su tutti i pin di uscita tra i 

due livelli alto e basso. 

; 1.1 

LIST p=16F628 ;tell assembler what chip we are using 

include "P16F628.inc" ;include the defaults for the chip 

__config 0x3D18 ;sets the configuration settings 

;(oscillator type etc.) 

org 0x0000 ;org sets the origin, 0x0000 for the 16F628, 

;this is where the program starts running 

;-------------------------------------------------------- 

movlw 0x07 ;assegna al registro W generico (accumulatore) il 

;valore 0x07il quale servirà a settare un determinato 

;comportamento del comparatore 

movwf CMCON ;turn comparators off (make it like a 16F84) 

;CMCON identifica un registro (Comparator Control 

;Register) 

; Writing a value of 7 (binary 00000111) to 

;CMCON turns OFF the comparators 

;--------------------------------------------------- 

bsf STATUS, RP0 ;select bank 1 

;pone a 1 il bit relativo al valore contenuto in RP0 

;nel registro STATUS 

;RP0 è un bit che se vero seleziona il banco 1 

;altrimenti il banco 0 

;Banking requires the use of control bits for bank 

;selection. 

;These control bits are located in the STATUS Register. 

movlw b'00000000' ;set PortB all outputs 

;pone il valore 0 nel registro W 

movwf TRISB ;sposta il valore in W (0) nel registro TRISB 

;in tal modo setta tutta la porta B come 

; uscita 

movwf TRISA ;set PortA all outputs 

;come per la porta B 

;NB. PORTA è formata solo da 5 bit 

bcf STATUS, RP0 ;select bank 0 

; l’istruzione riporta a 0 il bit nel registro STATUS 

;------------------------------------------------------------------------------- 

Loop 

movlw 0xff 

movwf PORTA ;set all bits on

movwf PORTB 

nop ;the nop's make up the time taken by the goto 

nop ;giving a square wave output 

movlw 0x00 

movwf PORTA 

movwf PORTB ;set all bits off 

goto Loop ;go back and do it again 

end 

Le prime tre righe sono istruzioni per l’assemblatore, non sono parte integrante del 

programma, lasciamole come sono in questi esempi senza farci troppe domande sul 

perchè ci sono. La __Config setta le varie configurazioni possibili del chip, in questo caso 

viene selezionato l’oscillatore interno a 4MHz. La riga successiva “org 0x0000” setta 

l’indirizzo iniziale, questo può variare a seconda del PIC usato ma i più moderni utilizzano 

l’indirizzo più basso (zero). 

Le righe 5 e 6: 

“movlw 0x07” significa “MOVe the Literal value 7 into the W register”, il registro W è il 

registro di lavoro principale, 

“movwf CMCON” significa “MOV the value in W to File CMCON”, CMCON è un registro 

utilizzato per selezionare l’uso del comparatore hardware. Pertanto le due righe settano 

CMCON al valore 7, questo disabilita il comparatore, e rende le relative linee di I/O 

disponibili per uso generale. 

Le cinque righe successive settano la direzione delle linee di I/O, inizialmente dobbiamo 

selezionare il “bank 1”, alcuni registri sono in “bank 0” ed altri in “bank 1”, per selezionare 

“bank 1” abbiamo bisogno di settare il bit RP0 nello STATUS register a “1” – il comando 

“bsf” (Bit Set File) setta un bit a uno. Il “bcf” (Bit Clear File) alla fine delle cinque righe, 

setta RP0 di nuovo a “0” e ritorna al “bank 0”. 

Il “movlw”, come prima, muove un valore nel registro W, questa volta però il valore 

passato è un valore binario (anzichè esadecimale 0x00), questo è indicato dalla “b” prima 

del valore stesso, in questo caso è semplicemente zero, e questo valore è poi trasferito ai 

due registri TRIS (TRIState) A e B. Questo setta la direzione dei pin, un valore “0” setta 

un pin come Uscita, mentre un “1” lo setta come Ingresso – pertanto il valore b'00000000' 

(otto zero) setta tutti i pin come Uscita, b'10000000' setterà il pin 7 come un ingresso, e 

tutti gli altri come uscite – utilizzando un balore binario risulta semplice vedere quale quali 

pin soni ingressi (1) e quali uscite (0). 

Questo completa il set up del chip, adesso discutiamo la vera parte del programma che 

produrrà delle azioni, si inizia con l’etichetta “Loop”, l’ultimo comando “goto Loop' fa si che 

il programma ritorni al punto relativo all’etichetta, e esegue un loop infinito. 

La prima istruzione di questa sezione è “movlw 0xff” questa muove il numero esadecimale 

0xff (255 decimale, 11111111 binario) nel registro W, la seconda e la terza in seguito 

trasferiscono questo valore alla PortA e alla PortB di I/O – questo “prova” a settare tutti i 

16 pin (approfondiremo in seguito!).

Le due istruzioni seguenti sono “nop” “NO Operation”, questa istruzione richiede 1uS per 

essere eseguita e non fa niente, vengono utilizzate solo per mantenere le uscite alte per 

un extra time di 2uS. 

Poi abbiamo “movlw 0x00” la quale muove 0x00 (0 decimale, 00000000 binario) nel 

registro W, poi verrà trasferito alle porte come visto prima, questo setta tutti e 16 le uscite 

al livello basso. L’ultimo “goto Loop” ritorna all’inizio e permette di rieseguire la sezione 

all’infinito, continuerà switchando le porte al valore alto e basso. 

1.2 

Come avete potuto notare nella prima parte (implementando il codice di cui sopra), i LED's 

non lampeggiano!. In realtà i LED lampeggiano ma lo fanno troppo velocemente 

affinchè sia visibile. Il PIC esegue ciascuna istruzione a 4MHz, pertanto impiega 1uS per 

completare (ad eccezione del “jump”, che impiega 2uS), questo fa si che i LED 

lampeggino migliaia di volte al secondo – troppo veloce per i nostri occhi!. Questo è un 

problema comune nella programmazione di microcontrollori che interagiscono con 

ambienti fisici esterni, girano troppo velocemente rispetto al mondo esterno, spesso 

abbiamo bisogno di rallentare l’esecuzione!. 

Anche questo secondo esempio cambia lo stato delle porte di uscita da alto a basso e 

viceversa, ma questa volta utilizziamo un delay fra i due cambi di stato. 

; 1.2 



__config 0x3D18 ;sets the configuration settings (oscillator type etc.) 

cblock 0x20 ;direttiva del compilatore 

;start of general purpose registers 

count1 ;used in delay routine 

counta ;used in delay routine 

countb ;used in delay routine 

endc ;fine direttiva 



movlw 0x07 



movlw b'00000000' 

movwf TRISB ;set PortB all outputs 



Loop 

movlw 0xff 

movwf PORTA ;set all bits on 

movwf PORTB 

nop ;the nop's make up the time taken by the goto 


;---------------------------------------------------------------------------------call 

Delay ;this waits for a while! 

;viene richiamata la routine di nome Delay 

movlw 0x00 

movwf PORTA 

movwf PORTB ;set all bits off 

call Delay ;ritardo


;acceso wait spento wait acceso wait spento wait ................... 

;--------------------------------------------------------------------------------- 

; di seguito abbiamo la routine in grado di contare 250ms 

Delay movlw d'250' ;delay 250 ms (4 MHz clock) 

;nel registro W si inserisce il valore 250 

movwf count1 ; tale valore (250) viene passato al registro 

;countl 

d1 movlw 0xC7 ;199 volte 

movwf counta ;assegna 199 al registro conta 

movlw 0x05 ;5 volte 

movwf countb assegna 5 al registo contb 

Delay_0 

decfsz counta, f ;decrementa il registro conta e se zero passa 

;alla riga successiva 

goto $+2 ;passa 2 istruzioni in avanti (ne salta una) 

decfsz countb, f 

goto Delay_0 

decfsz count1 ,f 

goto d1 

retlw 0x00 ;ritorno dalla chiamata di subroutine 

;inoltre in grado di restituire un valore 

;nel registro accumulatore (non interessa) 

end 

Questo non fa altro che introdurre due righe di codice in più nel main, “call Delay”, questa 

è una chiamata ad una subroutine, una parte del programma che esegue e poi ritorna 

dove è stata chiamata. La routine è richiamata due volte, una dopo che i LED sono 

diventati accesi, e nuovamente dopo il loro spegnimento. Tutta la routine “Delay” è tempo 

perso, cicla continuamente fino a quando non termina. 

La parte aggiunta all’inizio del programma (cblock to endc) alloca una coppia di variabili 

(count1 and count2) a due dei registri “general purpose file registers”, questi iniziano alla 

locazione 0x20 – la direttiva cblock alloca la prima variabile a 0x20, e seguenti. 

The cblock directive allows you to define several bytes together. For example: 

cblock 0x70 

temp 

x, y 

endc 

This bit of assembler defines 3 bytes that will be at locations 0x70 (temp), 0x71 (x), and 

0x72 (y). Note that if you put multiple items on the same line, you need a comma between 

them. 

La routine “Delay” realizza un ritardo di 250mS, settato nella sua prima riga (movlw d'250') 

– la “d” indica che si tratta di un numero decimale, per facilitarne la comprensione – 

pertanto si accenono i LED, si aspettano 250mS, si spengono i LED, si attendono altri 

250mS, e poi si ripete. Questo fa si che i LED lampeggino 2 volte al secondo, adesso sarà

certamente visibile il lampeggiamento. Alterando il valore d'250' si può modificare il flash 

rate, comunque poichè al massimo disponiamo di 8 bit il valore non potrà essere più di 

d'255' (0xff esadecimale). 

Figura 1 – Registri speciali 

Figura 2 – Registri Generici 

Questa routine introduce un nuovo comando “decfsz” “Decrement File and Skip on Zero”, 

questo decrementa il file register specificato (in questo caso count2, o count1) e se il 

risultato è uguale a zero passa oltre la riga successiva. Pertanto questa prima sezione 

utilizzando il seguente, 

d2 decfsz count2 ,f 

goto d2 

decrementa count2, controlla se è uguale a zero, e altrimenti continua verso il “goto d2”, il 

quale risalta indietro e decrementa count2 nuovamente, continua fino a quando count2 è 

uguale a zero, poi “goto d2” viene ignorato e count1 viene decrementato nello stesso 

modo, questa volta tornando all’inizio del loop count2, e così via. Questo è detto “nested 

loop”, il ciclo interno impiega 1mS per eseguire, e quello esterno chiama quello interno un 

numero di volte specificato in count1 – 

così se carichiamo 0x01 in count1 la routine Delay impiegherà 1mS, nell’esempio utilizzato 

noi carichiamo d'250' (hex 0xfa) in count1, così impiegherà 250mS (1/4 di secondo). 

L’altro comando nuovo è “retlw” “RETurn from subroutine with Literal in W”, ritorna dove è 

stata chiamata la subroutine, e restituisce un valore opzionale nel registro W (non è però 

utilizzato per restituire tale valore in questo esempio, pertanto gli assegnamo 0x00).

Dicevamo che le routine al max possono dare un ritardo massimo di 255mS, se volessimo 

un tempo maggiore dovremmo introdurre un altro ciclo esterno che richiama la routine 

“Delay” in numero di volte che ci serve, se vogliamo far lampeggiare i LED una volta al 

secondo (anziché due) possiamo semplicemente duplicare la riga “call Delay”, 


call Delay ;this waits for a while! 

call Delay ;second delay call added 

movlw 0x00 

questo dà un ritardo di 500mS, mantenendo il LED acceso per 1/2 secondo, aggiungendo 

una seconda chiamata “call Delay” al “off time” il LED starà spento per 1/2 secondi. Non 

c’è inoltre bisogno di questa simmetria, usando una chiamata “call Delay” per il “on time”, 

e tre per il “off time” il LED continuerà a lampeggiare una volta al secondo ma sarà acceso 

per 1/4 del tempo (25/75) – utilizzerà solo il 50% dell’energia rispetto a un 50/50. 

Ci sono interessanti vantaggi nell’usare subroutine, una routine come quella del ritardi 

può essere usata in molte parti del codice ripetutamente, quindi salvandola una volta 

si risparmia spazio. Inoltre modifiche non richiederanno di modificare in più parti il codice 

ma solo la subroutine, il cambiamento si ripercuoterà a tutte le chiamate alla subroutine. 

1.3 

I due esempi precedenti accendevano semplicemente i LED ponendo i pin alti o bassi, 

spesso vogliamo agire su un solo pin, questo è facilmente realizzabile con il comando 

“bcf” e “bsf”, “bcf” “Bit Clear File” pone un bit a zero, e “bsf” “Bit Set File” pone un bit a 1, il 

range dei bit va da 0 (LSB) a 7 (MSB). Il seguente esempio fa lampeggiare il bit 7 (RB7) 

della PortB, mentre gli altri bit resteranno a zero. 

; 1.3 

LIST p=16F628 

;tell assembler what chip we are using 


__config 0x3D18 ;sets the configuration settings (oscillator 

type etc.) 

Loop 

cblock 0x20 ;start of general purpose registers 




endc 



movlw 0x07 




movwf TRISB 



clrf PORTA 

clrf PORTB ;set all outputs low 

bsf PORTB, 7 ;turn on RB7 only! 

call Delay ;this waits for a while!

cf PORTB, 7 ;turn off RB7 only!. 

call Delay 


Delay movlw d'3' ;delay 250 ms (4 MHz clock) 250=FA 

movwf count1 

d1 movlw 0x17 ;delay 1mS C7=199 

movwf counta 

movlw 0x01 

movwf countb 

Delay_0 

decfsz counta, f 

goto $+2 


goto Delay_0 


goto d1 

retlw 0x00 

end 

Il “movwf PORTA” e il “movwf PORTB” sono state rimpiazzate da una singola riga 

“bsf PORTB, 7” (per accendere il LED), e “bcf PORTB, 7” (per spegnere il LED). Le 

righe associate “movlw 0xff” e “movlw 0x00” sono state eliminate, poichè non servono più, 

i due “nop” sono stati rimossi, sono superflui – non ci interessa aggiungere 2uS ad una 

routine che dura 250mS. 

1.4 

Se vogliamo utilizzare un pin diverso rispetto all’RB7, basterà cambiare il “7” nelle due 

righe prima viste. Questo esempio (funzionalmente identico al precedente) assegna due 

costanti all’inizio del programma, LED, e LEDPORT – a questi vengono assegnati i valori 

“7” e “PORTB”, e questi nomi di costanti sono utilizzati in “bsf” e “bcf”. L’uso delle costanti 

facilita così eventuali cambiamenti alle assegnazioni dei pin. 

; 1.4 



__config 0x3D18 

type etc.) 

;sets the configuration settings (oscillator 





endc 

LED Equ 7 ;set constant LED = 7 dichiara una costante 

LEDPORT Equ PORTB ;set constant LEDPORT = 'PORTB' 



movlw 0x07 




movwf TRISB 



clrf PORTA

Loop 

clrf PORTB ;set all outputs low 

bsf LEDPORT, LED ;turn on RB7 only! 


bcf LEDPORT, LED ;turn off RB7 only!. 

call Delay 



movwf count1 

d1 movlw 0xC7 ;delay 1mS 

movwf counta 

movlw 0x01 

movwf countb 

Delay_0 


goto $+2 


goto Delay_0 


goto d1 

retlw 0x00 

end 

Questo lavora esattamente come la versione precedente infatti comparando i relativi file 

HEX questi risulteranno identici. 

Esercizi 

• Alterare il numero delle chiamate della Delay in modo tale da produrre 

lampeggiamenti asimmetrici. 

• Cambiare l’assegnamento dei pin. 

• Far lampeggiare più di un LED ma meno di 8 contemporaneamente - TIP: 

aggiungere extra comandi del tipo “bsf” e “bcf”. Aggiungere altri LED lampeggianti 

utilizzando diversi rate -TIP: far lampeggiare uno on/off, poi un altro on/off, 

aggiungendo diverse chiamate a Delay. 

Gli esempi successivi usano più LED (LED board)

1.5 

Usando la LED board si fa girare un LED all’interno della riga. 

; 1.5 




; type etc.) 





endc 


LEDTRIS Equ TRISB ;set constant for TRIS register 


:------------------- this is where the program starts running 

Loop 

movlw 0x07 ;il valore 7 al registro del comparatore 

;esclude il comparatore hw 




movwf LEDTRIS 


clrf LEDPORT ;set all outputs low 

movlw b'10000000' 

movwf LEDPORT 


movlw b'01000000' 



movlw b'00100000' 



movlw b'00010000' 



movlw b'00001000' 



movlw b'00000100' 



movlw b'00000010' 



movlw b'00000001' 



goto Loop ;go back and do it again


movwf count1 

d1 movlw 0xC7 

movwf counta 

movlw 0x01 

movwf countb 

Delay_0 


goto $+2 


goto Delay_0 

1.6 


goto d1 

retlw 0x00 

end 

Possiamo facilmente modificare la routine sopra in modo tale che il LED rimbalzi da una 

parte all’altre, semplicemente aggiungendo altre “movlw” e “movwf” più la riga “call 

Delay”. 

; 1.6 




;type etc.) 





endc 




;--------------------------- ;this is where the program starts running 

Loop 

movlw 0x07 







movlw b'10000000' 



movlw b'01000000' 



movlw b'00100000' 


call Delay ;this waits for a while!

movlw b'00010000' 



movlw b'00001000' 



movlw b'00000100' 



movlw b'00000010' 



movlw b'00000001' 



movlw b'00000010' 



movlw b'00000100' 



movlw b'00001000' 



movlw b'00010000' 



movlw b'00100000' 



movlw b'01000000' 





movwf count1 

d1 movlw 0xC7 

movwf counta 

movlw 0x01 

movwf countb 

Delay_0 


goto $+2 


goto Delay_0 

1.7 


goto d1 

retlw 0x00 

end

Nonostante le due precedenti routine siano funzionanti, sono però rudimentali. .5 usa 24 

righe all’interno del loop, utilizzando un altro comando del PIC si può ridurre il numero di 

righe di codice. 

; 1.7 




type etc.) 






endc 




;------------------- this is where the program starts running 

movlw 0x07 







Start movlw b'10000000' ;set first LED lit 


Loop bcf STATUS, C ;clear carry bit 


rrf LEDPORT, f ;ruota il contenuto del registro LEDPORT 

;un bit a destra attraverso il riporto 

;il valore di f è 1 pertanto il 

;risultato viene rimesso nel registro 

;se fosse 0 il risultato andrebbe in W 

btfss STATUS, C ;check if last bit (1 rotated into Carry) 

;se il bit del riporto nel registro STATUS 

;è 0 allora esegue l’istruzione successiva, 

;altrimenti la salta e sostituisce con NOP 


goto Start 


movwf count1 

d1 movlw 0xC7 

movwf counta 

movlw 0x01 

movwf countb 

Delay_0 


goto $+2 


goto Delay_0 


goto d1 

retlw 0x00 

end

Questo esempio introduce il comando 'rrf” “Rotate Right File”, ruota il contenuto del file 

register verso destra (divide il valore per 2). Poichè il comando “rrf” ruota passando dal 

“carry” bit occorre essere sicuri questo sia svuotato con il comando “bcf STATUS, C”. Per 

verificare il raggiungimento della fine utilizziamo la riga “btfss STATUS, C” per verificare 

quando il CARRY bit è settato, questo restart la sequenza di bit dal 7. 

1.8 

Possiamo applicare questo metodo anche al 1.6, in questo caso aggiungendo il comando 

“rlf” “Rotate Left File”, questo shifta il contenuto del registro a sinistra (moltiplicando per 2). 

; 1.8 




type etc.) 






endc 




;------------------ this is where the program starts running 

movlw 0x07 







Start movlw b'10000000' ;set first LED lit 


;------------- sposta a destra 

Loop bcf STATUS, C ;clear carry bit 


rrf LEDPORT, f 



movlw b'00000001' ;set last LED lit 


;------------- sposta a sinistra 

Loop2 bcf STATUS, C ;clear carry bit 


rlf LEDPORT, f ;ruota verso sinistra 


goto Loop2 ;go back and do it again 

goto Start ;finished, back to first loop 


movwf count1 

d1 movlw 0xC7 

movwf counta 

movlw 0x01

Delay_0 

1.9 

movwf countb 


goto $+2 


goto Delay_0 


goto d1 

retlw 0x00 

end 

Fino ad ora abbiamo utilizzato due metodi per creare il LED rimbalzante, adesso creiamo 

un’altra versione ancora, utilizzando un lookup table. 

; 1.9 




type etc.) 



count ;used in table read routine 




endc 




;----------------------- this is where the program starts running 

movlw 0x07 







Start clrf count ;set counter register “count” to zero 

Read movf count, w ;put counter value in W 

call Table ;chiama la sub “Table” 

movwf LEDPORT ;sposta il contenuto di W alla porta B 

call Delay ;chiama la sub delay 

incf count, w ;incrementa di 1 il valore del registro count 

;e copia il valore in W 

xorlw d'14' ;check for last (14th) entry 

;verifica se W contiene il valore 14 

;se uguali setta il flag Z 

btfsc STATUS, Z ;se Z è settato andiamo alla riga successiva 

;altrimenti saltiamo una riga 

goto Start ;if start from beginning 

incf count, f ;else do next incrementa il valore count 

goto Read

Table ADDWF PCL, f ;data table for bit pattern 

;aggiunge al program counter il valore 

;contenuto in W 

;in base al contenuto di W si salta infatti sommando al PC il valore di W 

;il PC si sposta a PC+W 

retlw b'10000000' ;inserisce il valore in W 

retlw b'01000000' 

retlw b'00100000' 

retlw b'00010000' 

retlw b'00001000' 

retlw b'00000100' 

retlw b'00000010' 

retlw b'00000001' 

retlw b'00000010' 

retlw b'00000100' 

retlw b'00001000' 

retlw b'00010000' 

retlw b'00100000' 

retlw b'01000000' 


movwf count1 

d1 movlw 0xC7 

movwf counta 

movlw 0x01 

movwf countb 

Delay_0 


goto $+2 


goto Delay_0 


goto d1 

retlw 0x00 

end 

Introduce un altro nuovo comando, il 'addwf” “ADD W to File”, è un comando di somma, 

infatti essendo il PIC con architettura RISC ha solo 35 comandi, pertanto alcuni 

comandi apparentemente semplici come la lettura dei dati di una tabella non sono 

presenti. 

Nel 1.2 abbiamo usato il comando “retlw”, senza usarne il valore restituito, adesso per 

creare la data table facciamo uso del valore restituito. 

Alla etichetta “Start” prima poniamo a zero un contatore che sarà poi utilizzato, il “clrf 

Count”, questo verrà poi spostato nel registro W mediante “movf Count, w”, e la subroutine 

Table verrà chiamata. 

La prima riga della subroutine è “addwf PCL, f”, la quale somma il contenuto di W (che è 

stato appena settato a zero) con il registro PCL, il PCL è il Program Counter, conta 

esattamente dove si trova l’esecuzione del programma, perciò aggiungendovi zero ci si 

sposta alla riga successiva “retlw b’10000000' che restituisce b'10000000' nel registro W, 

Questo è poi spostato ai LED. 

l conteggio viene poi incrementato e il programma cicla richiamando nuovamente la Table, 

questa volta W contiene il valore 1, poi sommato a PCL il quale fa un salto di una riga e

estituisce la seguente riga della Table – si continua per il resto della table. Non è però 

una buona cosa superare la lunghezza della tabella, causando un salto del PCL ad una 

riga dopo alla tabella, la quale in questo caso è la Delay. Per evitarlo si controlla il valore 

di count, usando “xorlw d14” “eXclusive Or Literal with W”, il quale implementa un 

“exclusive or” con il registro W (dove si trova il valore di count) e il valore 14, e setta il flag 

“Z” “Zero” se sono uguali, poi controlliamo il flag Z, e se è settato facciamo un salto 

indietro all’inizio e resettiamo count a zero e così via. 

Il vantaggio di questo sistema è la possibilità di avere qualsiasi pattern nella tabella e la 

facilità di modifica della stessa.

PIC Esempi - LED - Dipartimento di Sistemi e Informatica

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?