Notação:
f: um dos registradores do banco de registradores (memória ram interna) (0 =<  f  <= 4f )
    os 12 registradores 0 a b são especiais(SFR), os 68 registradores de 0c a 4f são de "propósito geral"(GPR), isto é são a memória ram do microcontrolador (o campo f de uma instrução tem na verdade 7 bits, o que permitiria endereçar até 128 bytes de ram)
w: o acumulador de propósito geral da ULA
d: mnemônico para o destino de uma operação, que pode ser  f (i.é 1) ou w (i.é  0)
k: mnemônico para um valor literal (i. é. constante) de 8 bits
<b>: mnemônico para um número de 3 bits identificando um bit de um byte (bit 7 é o mais significativo e bit 0 o menos significativo)
opr: mnemônico para uma das seguintes operações:
         add (adição), sub (subtração), and ( "e lógico"), ior ("ou lógico"), xor ("ou exclusivo lógico")
end: número de 11 bits representando o endereço de uma instrução ( usado em saltos e chamadas de rotinas)

1. Instruções movxx  para atribuição/cópia de valores nos registradores f e w:

Os mnemônicos dessas instruções não são intuitivos. Veja as  macros  correspondentes nos comentários
movf       f, d                                 ; f => d     macro: mov f, d
movwf    f                                     ; w => f     macro: mov w, f
movlw    k                                    ; k => w    macro: movl k, w

Exemplos:
movf    f,w                                   ; f => w
movf    f, f                                    ; f => f  afeta o bit Z, útil para testar se f é zero
movlw    h'1a'                             ; 0x1a => w
 

2. Instruções aritméticas/lógicas com os registradores f e w

oprwf    f,d                                 ; f opr w => d

Exemplos:
                 addwf    f,w            ;  f + w =>w  (soma conteúdo de f e w, resultado em w)
                 addwf    f, f             ;  f + w => f (soma conteúdo de f e w, resultado em f)
                 subwf    f, w           ; f - w => w
                 subwf    f, f             ; f - w  => f
                 andwf    f, w           ; f & w => w
                 iorwf       f, w           ; f | w => w
 

3. Instruções aritméticas/lógicas com um literal k e o registrador w:

oprlw    k                                    ; f opr  w => w

Exemplos:
                    addlw    k                ; k + w => w
                    sublw    k                ; k - w => w
 

4. Outras instruções aritméticas/lógicas

clrf    f                                            ; 0 => f
clrw                                                ; 0 => w
decf    f,d                                       ; f -1 =>d
incf    f, d                                       ; f + 1 => d
comf  f,d                                        ; complemento de f  => d
rlf        f,d                                        ; rotate f left thru carry:
rrf        f,d                                        ; rotate f right thru carry
bcf      f,b                                        ; 0 => f<b>  zera o bit <b> de f
bsf      f,b                                        ; 1 => f<b>   põe 1 no bit <b> de f

Exemplos:
                    incf    f, f                     ; f+1 => f
                    decf   f,w                    ; f-1 => w
                    bcf    f, 7                      ; 0 => f<7>
 

5.  Instruções de desvio e chamadas de rotinas

goto  end                                        ; desvia para instrução localizada em end: end => pc<10:0>
decfsz        f,d                                ; decrementa f , se fica 0 salta a próxima instrução
incfsz        f,d                                 ; incrementa f , se fica 0 salta a próxima instrução
btfsc          f, b                                ; testa bit f<b>, se zero salta próxima instrução
btfss          f, b                                ; testa bit f<b>, se 1 salta próxima instrução
call    end                                        ; chama rotina localizada em end
return                                              ; retorna de chamada de rotina:  tos => pc
retlw    k                                          ; retorna de chamada de rotina com valor k no registrador w (k => w)
retfie                                                ; retorna de rotina de interrupção, ativa interrupções: tos=>pc, 1=>gie
 
6. Macros  de uso comum, que realizam operações aritméticas, lógicas e de desvio

                                                           ~= xxx significa: equivalente a xxx
addcf    f, d                                      ; add carry to f                    ~=  btfsc    3,0     incf    f, d
subcf    f,d                                       ; subtract carry from f      ~= btfsc 3,0   decf    f,d
b    k                                                  ; branch                               ~= goto k
bz    k                                                ; branch on Zero                ~= btfsc    3,2    goto k
bnz    k                                             ; branch on No Zero         ~= btfss    3,2  goto k
skpz                                                 ; skip on Zero                     ~= btfss    3,2
skpnz                                               ; skip on No Zero               ~= btfsc    3,2
bc    k                                                ; branch on Carry              ~= btfsc    3,0  goto k
bnc    k                                              ; branch on No Carry        ~= btfss    3,0  goto k
skpc                                                  ; skip on Carry                    ~= btfss    3,0
skpnc                                                ; skip on No  Carry            ~= btfsc   3,0
clrz                                                     ; clear Zero flag                   ~= bcf    3,2
setz                                                    ; set Zero flag                      ~= bsf    3,2
clrc                                                     ; clear Carry flag                 ~= bcf    3,0
setc                                                    ; set Carry flag                     ~= bsf    3,0
tstf    f                                                 ; test f                                     ~= movf    f,1
xchg       f1, f2 ; exchange f1 with f2          ~= xorwf f1, 1     xorwf f1, 0     xorwf f1, 1 movwf f2
decbnz ct, rot                                  ; ct-1=>ct se # 0 vai p/ rot ~= decfsz ct    goto rot
 
7. Miscelânea

nop                                                   ; não faz nada
swapf    f,d                                       ; troca os 4 bits de mais alta ordem com os 4 de mais baixa ordem
crwdt                                                ; clear watch dog timer
sleep                                                ; vai para modo stand by
 
8. Endereçamento indireto via registrador FSR

O conteúdo do regitrador FSR (f=04) é usado como apontador para a memória ram (i. é, um registrador f) através do registrador fictício INDF (00), ou seja quando INDF é  operando de uma instrução, o conteúdo de FSR é utilizado no seu lugar. Isto é útil para operações com vetores. Exemplo: o trecho de programa a seguir  zera os registradores f de propósito geral (endereços 0xc a 0x4f):

movlw    0xc                      ; 0xc => w
movwf    FSR                    ; inicializa FSR com o endereço do 1º registrador de propósito geral (0xc)
movlw  0x50                      ;  50h => w   end do último registrador + 1
loop
            clrf     INDF              ; zera ((FSR))
            incf    FSR               ; faz FSR apontar para o próximo registrador de propósito geral
            subfw FSR, w        ; (FSR) - 50h => w
            bnz       loop           ; volta ao laço se # 0
 
 

9. Trecho de programa para calcular a seqüência de Fibonacci com precisão até 8 bits.

                                               ; utiliza as macros mov, add, xchg e decbnz
                                               ; count, f0 e  f1 são bytes na memória ram (regs de propósito geral)
                                               ; Célio G.    -     Nov 2001
movlw     d'12'
mov    w,  count                  ; calcule o 12º número de Fibonacci
clrf    f0                                  ; 0=>f0
clrf    f1
incf   f1                                  ; 1=> f1
loop
      mov    f0,w                      ; f0 =>w
      add    f1, w                      ; f0+f1 =>w
      xchg    f1, f0                    ; f1=> w, f0+f1 =>f1, w=>f0
      decbnz count, loop
 sleep