;------------------------------------------------------------------------------------------ ; pwrasm.inc 2.11 - Ridefinizioni e macro per estensione assembler PIC ; ; Ultimo aggiornamento 26/9/2002 ; ; (C) 2001-2002, Claudio Fin ;------------------------------------------------------------------------------------------ ; A T T E N Z I O N E: IL CONTENUTO DI QUESTO FILE NON E' STATO COMPLETAMENTE TESTATO. ; SONO SICURAMENTE ANCORA PRESENTI ALCUNI "O"RRORI SIA NEL CODICE CHE NEI COMMENTI. ; RINGRAZIO ANTICIPATAMENTE CHI VORRA' SEGNALARMELI. LE ISTRUZIONI MARCATE CON UN PUNTINO ; DOVREBBERO ESSERE CORRETTE SIA NEL FUNZIONAMENTO CHE NELLA DESCRIZIONE. ;------------------------------------------------------------------------------------------ ; ; Elenco delle istruzioni standard e delle nuove macroistruzioni (spostate a destra e ; scritte in maiuscolo per distinguerle dalle istruzioni standard). ; Mem indica le locazioni occupate nella memoria programma, cicli indica i cicli macchina ; richiesti (con 4 Mhz un ciclo = 1 µS), dove possono esserci diversi tempi di esecuzione ; e' riportato un altro valore tra parentesi (per indicare l'alternativa) o dopo due punti ; (per indicare diverse possibilita' comprese tra un minimo e un massimo). ; ; Le istruzioni per il caricamento e la manipolazione di dati a 16 e 24 bit vogliono ; la parte piu' bassa dei valori caricata all' indirizzo piu' basso. Nelle Ldf16 e Ldf24 ; si scrivono i valori partendo dalla parte piu' alta, per esempio: ; ; Ldf24 var,102,4,80 ; ; carica a partire dall'indirizzo di var il valore 6685776, con 80 caricato all'indirizzo ; var, 4 all'indirizzo var+1 e 102 caricato all'indirizzo var+2. ; ; Nelle istruzioni per lo spostamento e test di singoli bit la dicitura b indica bit a 1, ; nb indica bit a 0. Per esempio Jb effettua un jump se il bit testato e' a 1 mentre ; Waitnb attende finche' il bit testato rimane a 0. ; ; Legenda: n = valore immediato 8 bit f = registro dell'area dati ; d = destinazione (f o w) b = bit addr = indirizzo di programma ;------------------------------------------------------------------------------------------ ; CARICAMENTO/SPOSTAMENTO/SWAP ; Opcode Operandi Mem Cicli Descrizione ;------------------------------------------------------------------------------------------ ;. movlw n 1 1 carica n nell'accumulatore w ;. Ldf f,n 2 2 carica n in f ;. Ldf16 f,n2,n1 4 4 carica n2/n1 in f+1,f ;. Ldf24 f,n3,n2,n1 6 6 carica n3/n2/n1 in f+2,f+1,f ;. Ldf32 f,n4,n3,n2,n1 8 8 carica n4/n3/n2/n1 in f+3,f+2,f+1,f ;. movf f,d 1 1 muove f in d (f o w) ;. movwf f 1 1 muove l'accumulatore in f ;. Movff f1,f2 2 2 muove f1 in f2 ;. Movff16 f1,f2 4 4 muove f1 in f2 (a 16 bit) ;. Movff24 f1,f2 6 6 muove f1 in f2 (a 24 bit) ;. Movff32 f1,f2 8 8 muove f1 in f2 (a 32 bit) ;. clrw 1 1 azzera l'accumulatore ;. clrf f 1 1 azzera f ;. Clrf16 f 2 2 azzera f (a 16 bit) ;. Clrf24 f 3 3 azzera f (a 24 bit) ;. Clrf32 f 4 4 azzera f (a 32 bit) ;. swapf f,d 1 1 scambia i nibbles di f e li muove in d (f o w) ; Swapwf f 3 3 scambia w con f ; Swapff f1,f2 5 5 scambia i registri f1 e f2 ; Swapff16 f1,f2 10 10 scambia le word f1 e f2 (a 16 bit) ; Swapff24 f1,f2 15 15 scambia le word f1 e f2 (a 24 bit) ; Swapff32 f1,f2 20 20 scambia le word f1 e f2 (a 32 bit) ;------------------------------------------------------------------------------------------ ; ARITMETICHE ; (i flags non vengono settati come per le istruzioni standard) ; Opcode Operandi Mem Cicli Descrizione ;------------------------------------------------------------------------------------------ ;. addlw n 1 1 somma n all'accumulatore ;. addwf f,d 1 1 somma f all'accumulatore e muove in d (f o w) ;. Addlf f,n 2 2 f = f + n ;. Addlf16 f,n2,n1 6 6 f = f + n (a 16 bit) ;. Addff f1,f2 2 2 f1 = f1 + f2 ;. Addff16 f1,f2 6 6 f1 = f1 + f2 (a 16 bit) ; Addff24 f1,f2 13 5..13 f1 = f1 + f2 (a 24 bit) ; Addff32 f1,f2 22 5..22 f1 = f1 + f2 (a 24 bit) ;. sublw n 1 1 sottrae l'accumulatore da n (W = n - W) ;. subwf f,d 1 1 sottrae l'accumulatore da f e muove in d (f o w) ; Sublf f,n 2 2 f = f - n ; Subff f1,f2 2 2 f1 = f1 - f2 ;. incf f,d 1 1 incrementa f e muove in d (f o w) ;. Incf16 f 3 3 incrementa f(16)bit ;. Incf24 f 5 3..5 incrementa f(24)bit ;. Incf32 f 7 3..7 incrementa f(32)bit ;. decf f,d 1 1 decrementa f e muove in d (f o w) ;. Decf16 f 4 4 decrementa f(16)bit ;. Decf24 f 7 4..7 decrementa f(24)bit ;. Decf32 f 10 4..10 decrementa f(32)bit ;------------------------------------------------------------------------------------------ ; LOGICHE E MANIPOLAZIONE DI BIT ; (i flags non vengono settati come per le istruzioni standard) ; Opcode Operandi Mem Cicli Descrizione ;------------------------------------------------------------------------------------------ ;. rlf f,d 1 1 ruota f a sinistra attraverso carry e muove in d ; Rlf16 f 3 3 ruota f a sinistra attraverso carry a 16 bit ;. rrf f,d 1 1 ruota f a destra attraverso carry e muove in d ; Rrf16 f 3 3 ruota f a destra attraverso carry a 16 bit ; Shlf f 2 2 shift a sinistra di f ;. Shlf16 f 3 3 shift a sinistra di f (a 16 bit) ; Shrf f 2 2 shift a destra di f ; Shrf16 f 3 3 shift a destra di f (a 16 bit) ;. bcf f,b 1 1 resetta bit b di f ;. bsf f,b 1 1 setta bit b di f ;. Movb f1,b1,f2,b2 4 4 muove bit b1 di f1 in bit b2 di f2 ;. Movnb f1,b1,f2,b2 4 4 muove not bit b1 di f1 in bit b2 di f2 ;. Togg f,b 2 2 inverte bit b di f ;. andlw n 1 1 and logico tra n e accumulatore ;. andwf f,d 1 1 and logico tra f e accum. e muove in d (f o w) ; Andlf f,n 2 2 ; Andlf16 f1,n1,n2 6 6 ; Andff f1,f2 2 2 ; Andff16 f1,f2 4 4 ;. iorlw n 1 1 or logico tra n e accumulatore ;. iorwf f,d 1 1 or logico tra f e accum. e muove in d (f o w) ; Iorlf f,n 2 2 ; Iorlf16 f1,n1,n2 6 6 ; Iorff f1,f2 2 2 ; Iorff16 f1,f2 6 6 ;. xorlw n 1 1 xor logico tra n e accumulatore ;. xorwf f,d 1 1 xor logico tra f e accum. e muove in d (f o w) ; Xorlf f,n 2 2 ; Xorlf16 f,n1,n2 6 6 ; Xorff f1,f2 2 2 ; Xorff16 f1,f2 6 6 ;. comf f,d 1 1 not logico di f, muove in d (f o w) ;------------------------------------------------------------------------------------------ ; TEST, SALTI, SUBROUTINE, TEST CONDIZIONALI, LOOP ; Opcode Operandi Mem Cicli Descrizione ;------------------------------------------------------------------------------------------ ;. call addr 1 2 chiama subroutine ;. goto addr 1 2 salta all'indirizzo addr ;. Jp addr 1 2 ---come goto--- ;. return 1 2 ritorno da subroutine ;. Ret 1 2 ---come return--- ;. retfie 1 2 ritorno da interrupt ;. retlw n 1 2 ritorno da subroutine con n caricato in w ;. Skip n 1 2 salta n istruzioni elementari ;. decfsz f,d 1 1(2) decrementa f, muove in d (f o w), skip se zero ;. Decfsz16 f,d 7 decrementa f a 16 bit, skip se zero ;. Decfsz24 f,d 11 decrementa f a 24 bit, skip se zero ;. incfsz f,d 1 1(2) incrementa f, muove in d (f o w), skip se zero ; Incfsz16 f,d 6 6(7) incrementa f a 16 bit, skip se zero ; Incfsz24 f,d 9 9(10) incrementa f a 24 bit, skip se zero ; Jpfz f,addr 3 3(4) jump se f=0 ; Jpfz16 f,addr 4 4(5) jump se f=0 ; Jpfz24 f,addr 5 5(6) jump se f=0 ;. Skfz f 2 2(3) skip se f=0 ; Skfz16 f 3 3(4) skip se f=0 ; Skfz24 f 4 4(5) skip se f=0 ;. btfsc f,b 1 1(2) test bit b di f, skip se 0 (clear) ;. Sknb f,b 1 1(2) ---come btfsc--- skip se bit non a uno (nb) ;. btfss f,b 1 1(2) test bit b di f, skip se 1 (set) ;. Skb f,b 1 1(2) ---come btfss--- skip se bit a uno (b) ;. Jnb f,b,addr 2 2(3) test bit jump se bit b di f non a uno (nb) ;. Jb f,b,addr 2 2(3) test bit jump se bit b di f a uno (b) ;. Skz 1 1(2) test flag, skip se flag Z settato ;. Sknz 1 1(2) test flag, skip se flag Z resettato ;. Skc 1 1(2) test flag, skip se flag C settato ;. Sknc 1 1(2) test flag, skip se flag C resettato ;. Jz addr 2 2(3) test flag, jump ad addr se flag Z settato ;. Jnz addr 2 2(3) test flag, jump ad addr se flag Z resettato ;. Jc addr 2 2(3) test flag, jump ad addr se flag C settato ;. Jnc addr 2 2(3) test flag, jump ad addr se flag C resettato ;. Ske 2 1(2) testcond, skip se = ;. Skne 2 1(2) testcond, skip se <> ; Skg 2 testcond, skip se > ; Skl 4 4(5) testcond, skip se < ; Skge 3 testcond, skip se >= ; Skle 2 testcond, skip se <= ;. Je addr 2 2(3) testcond, jump ad addr se = ;. Jne addr 2 2(3) testcond, jump ad addr se <> ; Jg addr 2 testcond, jump ad addr se > ; Jl addr 5 testcond, jump ad addr se < ; Jge addr 4 testcond, jump ad addr se >= ; Jle addr 2 testcond, jump ad addr se <= ;. Djnz f,addr 2 3(2) decrementa f e jump ad addr se non zero ;. Djnz16 f,addr 8 9(8) decrementa f(16bit) e jump ad addr se non zero ;. Djnz24 f,addr 12 9..14 decrementa f(24bit) e jump ad addr se non zero ;. Cpje f,n,addr 4 4(5) confronta f con n e jump se uguali ;. Cpjne f,n,addr 4 4(5) confronta f con n e jump se non uguali ;. Waitb f,b 2 3(2) attende finche' il bit b di f vale 1 ;. Waitnb f,b 2 3(2) attende finche' il bit b di f vale 0 ;. Delay f,n 4 X ritardo di 4 + 3*(n-1) cicli ;. Delay16 f,n1,n2 12 X ritardo di 12 + 9*(n-1) cicli ;------------------------------------------------------------------------------------------ ; CONTROLLO SISTEMA ; Opcode Operandi Mem Cicli Descrizione ;------------------------------------------------------------------------------------------ ;. nop 1 1 attende 1 ciclo ;. Nop2 1 2 attende 2 cicli ;. clrwdt 1 1 azzera wdt ;. sleep 1 ;. Bank0 2 2 attiva banco0 ;. Bank1 2 2 attiva banco1 ;. Bank2 2 2 attiva banco2 ;. Bank3 2 2 attiva banco3 ;------------------------------------------------------------------------------------------ ;------------------------------------------------------------------------------------------ ; Carica il valore n nella variabile var. ;------------------------------------------------------------------------------------------ Ldf macro var,n movlw n movwf var endm ;------------------------------------------------------------------------------------------ ; Carica il valore n2,n1 nella variabile var a 16 bit. ;------------------------------------------------------------------------------------------ Ldf16 macro var,n2,n1 movlw n1 movwf var movlw n2 movwf var+1 endm ;------------------------------------------------------------------------------------------ ; Carica il valore n3,n2,n1 nella variabile var a 24 bit. ;------------------------------------------------------------------------------------------ Ldf24 macro var,n3,n2,n1 movlw n1 movwf var movlw n2 movwf var+1 movlw n3 movwf var+2 endm ;------------------------------------------------------------------------------------------ ; Carica il valore n4,n3,n2,n1 nella variabile var a 32 bit. ;------------------------------------------------------------------------------------------ Ldf32 macro var,n4,n3,n2,n1 movlw n1 movwf var movlw n2 movwf var+1 movlw n3 movwf var+2 movlw n4 movwf var+3 endm ;------------------------------------------------------------------------------------------ ; Muove la variabile var1 in var2 a 8 bit ;------------------------------------------------------------------------------------------ Movff macro var1,var2 movf var1,w movwf var2 endm ;------------------------------------------------------------------------------------------ ; Muove la variabile var1 in var2 a 16 bit ;------------------------------------------------------------------------------------------ Movff16 macro var1,var2 movf var1,w movwf var2 movf var1+1,w movwf var2+1 endm ;------------------------------------------------------------------------------------------ ; Muove la variabile var1 in var2 a 24 bit ;------------------------------------------------------------------------------------------ Movff24 macro var1,var2 movf var1,w movwf var2 movf var1+1,w movwf var2+1 movf var1+2,w movwf var2+2 endm ;------------------------------------------------------------------------------------------ ; Muove la variabile var1 in var2 a 32 bit ;------------------------------------------------------------------------------------------ Movff32 macro var1,var2 movf var1,w movwf var2 movf var1+1,w movwf var2+1 movf var1+2,w movwf var2+2 movf var1+3,w movwf var2+3 endm ;------------------------------------------------------------------------------------------ ; Azzera la variabile var a 16 bit ;------------------------------------------------------------------------------------------ Clrf16 macro var clrf var clrf var+1 endm ;------------------------------------------------------------------------------------------ ; Azzera la variabile var a 24 bit ;------------------------------------------------------------------------------------------ Clrf24 macro var clrf var clrf var+1 clrf var+2 endm ;------------------------------------------------------------------------------------------ ; Azzera la variabile var a 32 bit ;------------------------------------------------------------------------------------------ Clrf32 macro var clrf var clrf var+1 clrf var+2 clrf var+3 endm ;------------------------------------------------------------------------------------------ Swapwf macro var ;scambia accumulatore con var xorwf var,f xorwf var,w xorwf var,f endm ;------------------------------------------------------------------------------------------ Swapff macro var1,var2 ;scambia var1 con var2 movf var1,w xorwf var2,f xorwf var2,w xorwf var2,f movwf var1 endm ;------------------------------------------------------------------------------------------ Swapff16 macro var1,var2 ;scambia var1 con var2 (a 16 bit) movf var1,w xorwf var2,f xorwf var2,w xorwf var2,f movwf var1 movf var1+1,w xorwf var2+1,f xorwf var2+1,w xorwf var2+1,f movwf var1+1 endm ;------------------------------------------------------------------------------------------ Swapff24 macro var1,var2 ;scambia var1 con var2 (a 24 bit) movf var1,w xorwf var2,f xorwf var2,w xorwf var2,f movwf var1 movf var1+1,w xorwf var2+1,f xorwf var2+1,w xorwf var2+1,f movwf var1+1 movf var1+2,w xorwf var2+2,f xorwf var2+2,w xorwf var2+2,f movwf var1+2 endm ;------------------------------------------------------------------------------------------ Swapff32 macro var1,var2 ;scambia var1 con var2 (a 32 bit) movf var1,w xorwf var2,f xorwf var2,w xorwf var2,f movwf var1 movf var1+1,w xorwf var2+1,f xorwf var2+1,w xorwf var2+1,f movwf var1+1 movf var1+2,w xorwf var2+2,f xorwf var2+2,w xorwf var2+2,f movwf var1+2 movf var132,w xorwf var2+3,f xorwf var2+3,w xorwf var2+3,f movwf var1+3 endm ;------------------------------------------------------------------------------------------ ; Somma a 8 (var = var + n) ;------------------------------------------------------------------------------------------ Addlf macro var,n movlw n addwf var,f endm ;------------------------------------------------------------------------------------------ ; Somma a 16 bit (var = var + n) ;------------------------------------------------------------------------------------------ Addlf16 macro var,n2,n1 movlw n1 addwf var,f btfsc STATUS,C incf var+1,f movlw n2 addwf var+1,f endm ;------------------------------------------------------------------------------------------ ; Somma a 8 bit (var1 = var1 + var2) ;------------------------------------------------------------------------------------------ Addff macro var1,var2 movf var2,w addwf var1,f endm ;------------------------------------------------------------------------------------------ ; Somma a 16 bit (var1 = var1 + var2) ;------------------------------------------------------------------------------------------ Addff16 macro var1,var2 movf var2,w ;somma parte bassa addwf var1,f btfsc STATUS,C ;se non c'e' riporto skip incf var1+1,f ;propaga riporto su parte alta movf var2+1,w ;somma parte alta addwf var1+1,f endm ;------------------------------------------------------------------------------------------ ; Somma a 24 bit (var1 = var1 + var2) ;------------------------------------------------------------------------------------------ Addff24 macro var1,var2 movf var2,w ;somma parte bassa addwf var1,f btfss STATUS,C ;se c'e' riporto skip goto $+4 ;altrimenti vai a somma parte media incfsz var1+1,f ;propaga riporto su parte media e alta goto $+2 incf var1+2,f movf var2+1,w ;somma parte media addwf var1+1,f btfsc STATUS,C ;se non c'e' riporto skip incf var1+2,f ;propaga riporto su parte alta movf var2+2,w ;somma parte alta addwf var1+2,f endm ;------------------------------------------------------------------------------------------ ; Somma a 32 bit (var1 = var1 + var2) ;------------------------------------------------------------------------------------------ Addff32 macro var1,var2 movf var2,w ;somma byte 1 addwf var1,f btfss STATUS,C ;se c'e' riporto skip goto $+6 ;altrimenti vai a somma byte 2 incfsz var1+1,f ;propaga riporto su bytes 2 3 4 goto $+4 incfsz var1+2,f goto $+2 incf var1+3,f movf var2+1,w ;somma byte 2 addwf var1+1,f btfss STATUS,C ;se c'e' riporto skip goto $+4 ;altrimenti vai a somma byte 3 incfsz var1+2,f ;propaga riporto su byte 3 4 goto $+2 incf var1+3,f movf var2+2,w ;somma byte 3 addwf var1+2,f btfsc STATUS,C ;se non c'e' riporto skip incf var1+3,f ;propaga riporto su byte 4 movf var2+3,w ;somma byte 4 addwf var1+3,f endm ;------------------------------------------------------------------------------------------ Sublf macro var,n movlw n subwf var,f endm ;------------------------------------------------------------------------------------------ Subff macro var1,var2 movlw var2 subwf var1,f endm ;------------------------------------------------------------------------------------------ ; Incrementa la variabile var a 16 bit ;------------------------------------------------------------------------------------------ Incf16 macro var incfsz var,f goto $+2 incf var+1,f endm ;------------------------------------------------------------------------------------------ ; Incrementa la variabile var a 24 bit ;------------------------------------------------------------------------------------------ Incf24 macro var incfsz var,f ;incrementa parte bassa goto $+4 ;se non overflow goto fine incfsz var+1,f ;altrimenti incrementa parte media goto $+2 ;se non overflow goto fine incf var+2,f ;altrimenti incrementa parte alta endm ;------------------------------------------------------------------------------------------ ; Incrementa la variabile var a 32 bit ;------------------------------------------------------------------------------------------ Incf32 macro var incfsz var,f ;incrementa byte0 goto $+6 ;se non overflow goto fine incfsz var+1,f ;altrimenti incrementa byte1 goto $+4 ;se non overflow goto fine incfsz var+2,f ;altrimenti incrementa byte2 goto $+2 ;se non overflow goto fine incf var+3,f ;altrimenti incrementa byte3 endm ;------------------------------------------------------------------------------------------ ; Decrementa la variabile var a 16 bit ;------------------------------------------------------------------------------------------ Decf16 macro var decf var,f ;decrementa parte bassa incfsz var,w ;incrementa per vedere se torna a 0 goto $+2 ;se no salta a fine decf var+1,f ;altrimenti decrementa parte alta endm ;------------------------------------------------------------------------------------------ ; Decrementa la variabile var a 24 bit ;------------------------------------------------------------------------------------------ Decf24 macro var decf var,f ;decrementa la parte bassa incfsz var,w ;incrementa per vedere se torna a 0 goto $+5 ;se no salta a fine decf var+1,f ;altrimenti decrem. parte media incfsz var+1,w ;incrementa per vedere se torna a 0 goto $+2 ;se no salta a fine decf var+2,f ;altrimenti decrem. parte alta endm ;------------------------------------------------------------------------------------------ ; Decrementa la variabile var a 32 bit ;------------------------------------------------------------------------------------------ Decf32 macro var decf var,f ;decrementa byte0 incfsz var,w ;incrementa per vedere se torna a 0 goto $+8 ;se no salta a fine decf var+1,f ;altrimenti decrementa byte1 incfsz var+1,w ;incrementa per vedere se torna a 0 goto $+5 ;se no salta a fine decf var+2,f ;altrimenti decrementa byte2 incfsz var+2,w ;incrementa per vedere se torna a 0 goto $+2 ;se no salta a fine decf var+3,f ;altrimenti decrementa byte3 endm ;------------------------------------------------------------------------------------------ ; LOGICHE E MANIPOLAZIONE DI BIT ;------------------------------------------------------------------------------------------ Rlf16 macro var rlf var+1,w rlf var,f rlf var+1,f endm ;------------------------------------------------------------------------------------------ Rrf16 macro var rrf var,w rrf var+1,f rrf var,f endm ;------------------------------------------------------------------------------------------ Shlf macro var bcf STATUS,C rlf var,f endm ;------------------------------------------------------------------------------------------ ; Shift a sinistra di una variabile a 16 bit, il bit meno significativo diventa 0, il piu' ; significativo finisce nel flag C. ;------------------------------------------------------------------------------------------ Shlf16 macro var bcf STATUS,C rlf var,f rlf var+1,f endm ;------------------------------------------------------------------------------------------ Shrf macro var bcf STATUS,C rrf var,f endm ;------------------------------------------------------------------------------------------ Shrf16 macro var bcf STATUS,C rrf var+1,f rrf var,f endm ;------------------------------------------------------------------------------------------ Movb macro var1,b1,var2,b2 ;muove b1 di var1 in b2 di var2 btfss var1,b1 bcf var2,b2 btfsc var1,b1 bsf var2,b2 endm ;------------------------------------------------------------------------------------------ Movnb macro var1,b1,var2,b2 ;muove not b1 di var1 in b2 di var2 btfsc var1,b1 bcf var2,b2 btfss var1,b1 bsf var2,b2 endm ;------------------------------------------------------------------------------------------ ; Inverte il bit b di var ;------------------------------------------------------------------------------------------ Togg macro var,b movlw 1<