Exemplos de operações PIC

09/05/2016
1
109/05/2016
Parte 6
EXEMPLOS
209/05/2016
1. MPLAB® SIM
2. DISPLAY DE 7 SEGMENTOS
3. TECLADO
4. PWM
5. ENTRADA ANALÓGICA
MPLAB® SIM1
309/05/2016
MPLAB® SIM
MPLAB® SIM1
409/05/2016
1 – Programa vazio
end
----------------------------------------------------------------------
Debug build of project `E:Documentosmarco2.mcp' started.
Language tool versions: MPASMWIN.exe v5.44, mplink.exe v4.42, mplib.exe v4.42
Preprocessor symbol `__DEBUG' is defined.
Fri May 11 15:17:13 2012
----------------------------------------------------------------------
Make: The target "E:Documentosmarco2.o" is out of date.
Executing: "C:Program FilesMicrochipMPASM SuiteMPASMWIN.exe" /q /p16F877 "marco2.asm"
/l"marco2.lst" /e"marco2.err" /d__DEBUG=1
Make: The target "E:Documentosmarco2.cof" is out of date.
Executing: "C:Program FilesMicrochipMPASM Suitemplink.exe" /p16F877 "marco2.o" /u_DEBUG
/z__MPLAB_BUILD=1 /z__MPLAB_DEBUG=1 /o"marco2.cof" /M"marco2.map" /W /x
MPLINK 4.42, Linker
Device Database Version 1.7
Copyright (c) 1998-2011 Microchip Technology Inc.
Errors : 0
----------------------------------------------------------------------
Debug build of project `E:Documentosmarco2.mcp' succeeded.
Language tool versions: MPASMWIN.exe v5.44, mplink.exe v4.42, mplib.exe v4.42
Preprocessor symbol `__DEBUG' is defined.
Fri May 11 15:17:19 2012
----------------------------------------------------------------------
BUILD SUCCEEDED
MPLAB® SIM1
509/05/2016
2 – Programa vazio com comentário
; Programa 2 – Vazio
end ;fim
• Este programa emprega um comentário
e uma diretiva, respectivamente.
• Nenhuma instrução é usada.
• É gerado um código assembly vazio.
• É recomendado que a primeira linha do
código assembly seja um comentário
explicativo do programa.
MPLAB® SIM1
609/05/2016
3 – Definição da PIC®
; Programa 3 - Arquivo de inclusão
#include <p16f877.inc> ;definição da PIC
end ;fim
• Este programa emprega um
comentário e duas diretivas,
respectivamente.
• Se o arquivo de definição da PIC® não
for incluído, somente os mnemônicos
de instrução poderão ser usados.

09/05/2016
2
MPLAB® SIM1
709/05/2016
4 – Definição de constante
; Programa 4 - Definição de constante
constant marqualrélio = 0x20 ;definição da constante
end ;fim
• Este programa emprega um comentário e
quatro diretivas, respectivamente.
• Constantes podem ser definidas.
• Constantes não aparecem no código montado.
• O nome deve possuir, apenas, uma palavra.
• Acentos são permitidos.
• O primeiro algarismo não pode ser numérico.
MPLAB® SIM1
809/05/2016
Constantes
Significado Tamanho Máximo
Destiny 1 bit 0x1
Bit 3 bits 0x7
File 7 bits 0x7f
Literal 8 bits 0xff
Program Address 11 bits 0x7ff
MPLAB® SIM1
909/05/2016
Constantes do tipo File
• Como, no código assembly, file possui,apenas, sete
bits, seu nome aparece sempre no banco 0, mesmo
que se refira a um registrador de outro banco.
• Se o endereço escolhido corresponde a um SFR, o
nome da constante não aparece na lista.
MPLAB® SIM1
1009/05/2016
5 – Definição da posição inicial do programa
; Programa 5 - Definição da posição inicial do programa
org 0x5 ;posição inicial (13-bit)
constant marqualrélio = 0x0a ;definição da constante
end ;fim
• Este programa emprega um comentário e
cinco diretivas, respectivamente.
• A posição inicial padrão é 0x0.
• A diretiva ORG recebe um número de 13 bits.
• A rigor, a diretiva deveria ser 0x0005.
MPLAB® SIM1
1109/05/2016
6 – Realização de uma escrita direta na SRAM
; Programa 6 - Gravação de registrador
org 0xfff ;posição inicial
MOVLW 0xaa ;W = 0xaa
MOVWF 0x2a ;SRAM(0x2a) = W
end ;fim
MPLAB® SIM1
1209/05/2016
7 – Efeito do valor inicial do acumulador
; Programa 7 - Efeito do valor inicial do acumulador
org 0x5 ;posição inicial
CLRW ;limpa o acumulador
ADDLW 0xaa ;W = 0xaa + W
end ;fim
0005 0103 CLRW
0006 3EAA ADDLW 0xAA
0007 00AA MOVWF 0x2A
Program Memory
Address Opcode Disassembly
027 0x00
028 0x00
029 0x00
02A 0xAA
02B 0x00
02C 0x00
02D 0x00
File Registers
Address Hex

09/05/2016
3
MPLAB® SIM1
1309/05/2016
Limpeza do acumulador
• Ao ligar o chip, o valor do acumulador é zero e, a
princípio, a limpeza do acumulador não seria necessária.
• A não limpeza do acumulador, porém, provoca erros,
devido a dois motivos:
1. Na segunda vez em que o programa for executado, o
acumulador contém o resultado prévio obtido na
execução anterior.
2. Mesmo na primeira execução, as cinco primeiras
linhas do programa, em branco (0x3fff), realizam,
cada uma delas, uma subtração unitária no
acumulador, de modo que, quando a adição é
executada, o valor do acumulador não seria zero.
MPLAB® SIM1
1409/05/2016
8 – Realização de uma adição com label
; Programa 8 - Realização de uma adição com label
constant marqualrélio = 0xaa ;dado
constant ondecadê = 0x2a ;endereço
CLRW ;limpa o acumulador
ADDLW marqualrélio ;W = marqualrélio + W
MOVWF ondecadê ;SRAM(ondecadê) = W
end ;fim
0005 0103 CLRW
0006 3EAA ADDLW 0xAA
027 0x00
028 0x00
029 0x00
02A 0xAA
02B 0x00
02C 0x00
02D 0x00
MPLAB® SIM1
; Programa 9 – Realização de uma cópia direta
MOVLW 0xaa ;W = 0xaa
MOVLW 0xaa-1 ;W = 0xa9
MOVWF 0x2a+1 ;SRAM(0x2b) = W
end ;fim
1509/05/2016
9 – Realização de uma cópia direta
0005 30AA MOVLW 0xAA
0007 30AB MOVLW 0xA9
0008 00AB MOVWF 0x2B
027 0x00
028 0x00
029 0x00
02A 0xAA
02B 0xA9
02C 0x00
02D 0x00
• Aqui, a cópia direta significa que
foram usados os valores numéricos.
MPLAB® SIM1
; Programa 10 – Realização de uma cópia indireta
MOVLW marqualrélio ;W = marqualrélio
MOVLW marqualrélio-1 ;W = marqualrélio-1
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
end ;fim
1609/05/2016
10 – Realização de uma cópia indireta
0007 30AB MOVLW 0xA9
027 0x00
028 0x00
029 0x00
02A 0xAA
02B 0xA9
02C 0x00
02D 0x00
• Aqui, a cópia indireta significa
que foram usados rótulos.
MPLAB® SIM1
1709/05/2016
11 – Realização de um incremento
; Programa 11 – Realização de um incremento
INCF ondecadê,0 ;W = marqualrélio + 1
end ;fim
0007 0A2A INCF 0x2A, 0x0
027 0x00
028 0x00
029 0x00
02A 0xAA
02B 0xAB
02C 0x00
02D 0x00
MPLAB® SIM1
; Programa 12 – Operações aritméticas
constant marqualrélio = 0x45 ;dado 1
constant operador = 0xae ;dado 2
MOVLW marqualrélio ;W = marqualrélio*
ADDLW operador ;W = operador ADD marqualrélio
SUBLW operador ;W = operador SUB marqualrélio
INCF ondecadê+3,1 ;SRAM(ondecadê+3) = SRAM(ondecadê+3) + 1
DECF ondecadê+4,1 ;SRAM(ondecadê+4) = SRAM(ondecadê+4) – 1
end ;fim
1809/05/2016
12 – Operações aritméticas
Cópia
Adição
Subtração
Incremento
Decremento
*Esta linha pode serremovida.

09/05/2016
4
MPLAB® SIM1
029 0x00
02A 0x45
02B 0xF3
02C 0x69
02D 0x46
02E 0x44
02F 0x00
1909/05/2016
AE 1010 1110
45 0100 0101
F3 1111 0011
ADD
AE 1010 1110
45 0100 0101
69 0110 1001
SUB
45 0100 0101
44 0100 0100
DEC
45 0100 0101
46 0100 0110
INC
12 – Operações aritméticas
0005 3045 MOVLW 0x45
0007 3045 MOVLW 0x45
0008 3EAE ADDLW 0xAE
0009 00AB MOVWF 0x2b
000A 3045 MOVLW 0x45
000B 3CAE SUBLW 0xAE
000C 00AC MOVWF 0x2C
000D 3045 MOVLW 0x45
000E 00AD MOVWF 0x2D
000F 0AAD INCF 0x2D, 0x1
0010 3045 MOVLW 0x45
0011 00AE MOVWF 0x2E
0012 03AE DECF 0x2E, 0x1
Não usar letras (F ou W)
MPLAB® SIM1
; Programa 13 - Operações lógicas
ANDLW operador ;W = operador AND marqualrélio
IORLW operador ;W = operador IOR marqualrélio
XORLW operador ;W = operador XOR marqualrélio
COMF ondecadê+4,1 ;SRAM(ondecadê+4) = COM SRAM(ondecadê+4)
RLF ondecadê+5,1 ;SRAM(ondecadê+5) = RL SRAM(ondecadê+5)
RRF ondecadê+6,1 ;SRAM(ondecadê+6) = RR SRAM(ondecadê+6)
SWAPF ondecadê+7,1 ;SRAM(ondecadê+7) = SWAP SRAM(ondecadê+7)
end ;fim
2009/05/2016
13 – Operações lógicas
Cópia
AND
OR
XOR
COM
RL
RR
SWAP
MPLAB® SIM1
AE 1010 1110
45 0100 0101
04 0000 0100
AND
2109/05/2016
AE 1010 1110
45 0100 0101
EF 1110 1111
IOR
45 0100 0101
BA 1011 1010
COM
AE 1010 1110
45 0100 0101
EB 1110 1011
XOR
145 1 0100 0101
08B 0 1000 1011
RL
045 0 0100 0101
022 1 0010 0010
RR
45 0100 0101
54 0101 0100
SWAP
0005 3045 MOVLW 0x45
0007 3045 MOVLW 0x45
0008 39AE ANDLW 0xAE
0009 00AB MOVWF 0x2b
000A 3045 MOVLW 0x45
000B 38AE IORLW 0xAE
000C 00AC MOVWF 0x2C
000D 3045 MOVLW 0x45
000E 3AAE XORLW 0xAE
000F 00AD MOVWF 0x2D
0010 3045 MOVLW 0x45
0011 00AE MOVWF 0x2E
0012 09AE COMF 0x2E, 0x1
0013 3045 MOVLW 0x45
0014 00AF MOVWF 0x2F
0015 0DAF RLF 0x2F, 0x1
0016 3045 MOVLW 0x45
0017 00B0 MOVWF 0x30
0018 0CB0 RRF 0x30, 0x1
0019 3045 MOVLW 0x45
001A 00B1 MOVWF 0x31
001B 0EB1 SWAPF 0x31, 0x1
02A 0x45
02B 0x04
02C 0xEF
02D 0xEB
02E 0xBA
02F 0x3B
030 0x22
031 0x54
MPLAB® SIM1
2209/05/2016
145 1 0100 0101
08B 0 1000 1011
RL
045 0 0100 0101
022 1 0010 0010
RR
• Alguma instrução anterior configurou o carry para “1”
antes da efetuação da instrução RLF.
• Ao efetuar a instrução RLF, o nono bit vale “1”.
• Como o oitavo bit vale “0”, a operação RLF configura
o carry para “0”.
• Na efetuação da instrução RRF, o primeiro bit vale “1”.
• Ao efetuar a instrução RRF, o carry passa para “1”.
• RLF e RRF são operações de 9 bits.
• O resultado de RLF e RRF é uma palavra de 8 bits.
• O carry não faz parte do resultado.
MPLAB® SIM1
; Programa 14 - Operações com literais (LW)
constant ondecadê = 0x20 ;endereço
end ;fim
2309/05/2016
14 – Operações com literais (LW)
Cópia
ADD
SUB
AND
IOR
XOR
Trêslinhasporoperação
MPLAB® SIM1
2409/05/2016
14 – Operações com literais (LW)
AE 1010 1110
45 0100 0101
EB 1110 1011
XOR
AE 1010 1110
45 0100 0101
EF 1110 1111
IOR
AE 1010 1110
45 0100 0101
04 0000 0100
AND
AE 1010 1110
45 0100 0101
69 0110 1001
SUB
AE 1010 1110
45 0100 0101
F3 1111 0011
ADD
0005 3045 MOVLW 0x45
0006 00A0 MOVWF 0x20
0007 3045 MOVLW 0x45
0008 3EAE ADDLW 0xAE
0009 00A1 MOVWF 0x21
000A 3045 MOVLW 0x45
000B 3CAE SUBLW 0xAE
000C 00A2 MOVWF 0x22
000D 3045 MOVLW 0x45
000E 39AE ANDLW 0xAE
000F 00A3 MOVWF 0x23
0010 3045 MOVLW 0x45
0011 38AE IORLW 0xAE
0012 00A4 MOVWF 0x24
0013 3045 MOVLW 0x45
0014 3AAE XORLW 0xAE
0015 00A5 MOVWF 0x25
020 0x45
021 0xF3
022 0x69
023 0x04
024 0xEF
025 0xEB

09/05/2016
5
MPLAB® SIM1
2509/05/2016
15 – Operações sobre bytes (WF), d=1
; Programa 15 - Operações sobre bytes (WF), d=1
;esta etapa representa ações anteriores quaisquer
MOVLW operador ;W = operador
;esta é a etapa que interessa
ADDWF ondecadê+1,1 ;SRAM(ondecadê+1) = SRAM(ondecadê+1) ADD W
SUBWF ondecadê+2,1 ;SRAM(ondecadê+2) = SRAM(ondecadê+2) SUB W
ANDWF ondecadê+3,1 ;SRAM(ondecadê+3) = SRAM(ondecadê+3) AND W
IORWF ondecadê+4,1 ;SRAM(ondecadê+4) = SRAM(ondecadê+4) IOR W
XORWF ondecadê+5,1 ;SRAM(ondecadê+5) = SRAM(ondecadê+5) XOR W
end ;fim
MPLAB® SIM1
2609/05/2016
AE 1010 1110
45 0100 0101
EB 1110 1011
XOR
AE 1010 1110
45 0100 0101
EF 1110 1111
IOR
AE 1010 1110
45 0100 0101
04 0000 0100
AND
AE 1010 1110
45 0100 0101
69 0110 1001
SUB
AE 1010 1110
45 0100 0101
F3 1111 0011
ADD
0005 3045 MOVLW 0x45
0006 00A0 MOVWF 0x20
0007 30AE MOVLW 0xae
0008 00A1 MOVWF 0x21
0009 00A2 MOVWF 0x22
000A 00A3 MOVWF 0x23
000B 00A4 MOVWF 0x24
000D 3045 MOVLW 0x45
000E 07A1 ADDWF 0x21, 0x1
000F 02A2 SUBWF 0x22, 0x1
0010 05A3 ANDWF 0x23, 0x1
0011 04A4 IORWF 0x24, 0x1
0012 06A5 XORWF 0x25, 0x1
020 0x45
021 0xF3
022 0x69
023 0x04
024 0xEF
025 0xEB
MPLAB® SIM1
2709/05/2016
; Programa 16 - Operações sobre bytes (WF), d=0
constant marqualrélio = 0x45;dado 1
constant operador = 0xae;dado 2
constant ondecadê = 0x20;endereço
;esta etapa representa ações anteriores quaisquer
MOVLW operador ;W = operador
;esta é a etapa que interessa
ADDWF ondecadê+1,0 ;W = SRAM(ondecadê+1) ADD W
SUBWF ondecadê+2,0 ;W = SRAM(ondecadê+2) SUB W
ANDWF ondecadê+3,0 ;W = SRAM(ondecadê+3) AND W
IORWF ondecadê+4,0 ;W = SRAM(ondecadê+4) IOR W
XORWF ondecadê+5,0 ;W = SRAM(ondecadê+5) XOR W
end ;fim
ADD
SUB
AND
IOR
XOR
MPLAB® SIM1
2809/05/2016
AE 1010 1110
45 0100 0101
EB 1110 1011
XOR
AE 1010 1110
45 0100 0101
EF 1110 1111
IOR
AE 1010 1110
45 0100 0101
04 0000 0100
AND
AE 1010 1110
45 0100 0101
69 0110 1001
SUB
AE 1010 1110
45 0100 0101
F3 1111 0011
ADD
0005 3045 MOVLW 0x45
0006 00A0 MOVWF 0x20
0007 30AE MOVLW 0xae
0008 00A1 MOVWF 0x21
0009 00A2 MOVWF 0x22
000D 3045 MOVLW 0x45
000E 0721 ADDWF 0x21, 0x0
0010 3045 MOVLW 0x45
0011 0222 SUBWF 0x22, 0x0
0012 00A2 MOVWF 0x22
0013 3045 MOVLW 0x45
0014 0523 ANDWF 0x23, 0x0
0015 00A3 MOVWF 0x23
0016 3045 MOVLW 0x45
0017 0424 IORWF 0x24, 0x0
0018 00A4 MOVWF 0x24
0019 3045 MOVLW 0x45
001A 0625 XORWF 0x25, 0x0
020 0x45
021 0xF3
022 0x69
023 0x04
024 0xEF
025 0xEB
MPLAB® SIM1
2909/05/2016
• Para que o uso do d=0 seja útil, é preciso
que o registrador lido e o registrador
escrito não sejam os mesmos.
• No programa anterior, como esses
registradores são os mesmos, a opção
d=1 é a recomendada.
MPLAB® SIM1
; Programa 17 - Operações com três entradas literais
constant dado1 = 0x1 ;dado 1
MOVLW dado1 ;W = dado 1
ADDLW dado2 ;W = dado 2 + W
ADDLW dado3 ;W = dado 3 + W
end ;fim
3009/05/2016
17 – Operações com três entradas literais
0005 3001 MOVLW 0x01
0006 3E02 ADDLW 0x02
0007 3E04 ADDLW 0x04

09/05/2016
6
MPLAB® SIM1
3109/05/2016
17 – Operações com três entradas literais
• Um programa que não escreve em nenhum
registrador não tem utilidade alguma.
• O valor do work register pode ser observado no
status bar.
• O programa deve ser executado passo a passo.
MPLAB® SIM1
; Programa 18 – Operações com três entradas registradas
constant ondecadê1 = 0x21 ;endereço 1
MOVF ondecadê1,W ;W = SRAM(ondecadê1)
ADDWF ondecadê2,W ;W = SRAM(ondecadê2) + W
ADDWF ondecadê3,W ;W = SRAM(ondecadê3) + W
MOVWF ondecadê4 ;SRAM(ondecadê4) = W
end ;fim
3209/05/2016
18 – Operações com três entradas registradas
Digitar
0005 0821 MOVF 0x21, 0x0
0006 0722 ADDWF 0x22, 0x0
0007 0723 ADDWF 0x23, 0x0
0008 00A4 MOVWF 0x24
021 0x01
022 0x02
023 0x03
024 0x06
MPLAB® SIM1
3309/05/2016
18 – Operações com três entradas registradas
• Um programa que lê GPR´s sem que estes
tenham sido escrito antes não tem utilidade.
• No programa anterior, foi omitida a etapa
onde é realizada a necessária escrita prévia
destes GPR´s.
• É preciso digitar, manualmente, o valor dos
GPR´s empregados através da janela “file
registers” do MPLAB.
Digitar
MPLAB® SIM1
; Programa 19 – Operações de uma entrada
constant marqualrélio = 0x45 ;dado
INCF ondecadê+5,1 ;SRAM(ondecadê+5) = INC SRAM(ondecadê+5)
DECF ondecadê+6,1 ;SRAM(ondecadê+6) = DEC SRAM(ondecadê+6)
CLRF ondecadê+7 ;SRAM(ondecadê+7) = CLR SRAM(ondecadê+7)
MOFV ondecadê+6,0 ;W = SRAM(ondecadê+6)
end ;fim
3409/05/2016
19 – Operações de uma entrada
COM
RL
RR
SWAP
INC
DEC
CLR
Cópia
MPLAB® SIM1
3509/05/2016
19 – Operações de uma entrada
INCF ondecadê+5,1 ;SRAM(ondecadê+5) = INC SRAM(ondecadê+5)
DECF ondecadê+6,1 ;SRAM(ondecadê+6) = DEC SRAM(ondecadê+6)
CLRF ondecadê+7 ;SRAM(ondecadê+7) = CLR SRAM(ondecadê+7)
MOFV ondecadê+6,0 ;W = SRAM(ondecadê+6)
DEC 45 0100 0101
44 0100 0100
INC 45 0100 0101
46 0100 0110
SWAP
45 0100 0101
54 0101 0100
COM
45 0100 0101
BA 1011 1010
RL
145 1 0100 0101
08B 0 1000 1011
RR
045 0 0100 0101
022 1 0010 0010
0005 3045 MOVLW 0x45
0006 00A1 MOVWF 0x21
0007 09A1 COMF 0x21, 0x1
0008 3045 MOVLW 0x45
0009 00A2 MOVWF 0x22
000A 0DA2 RLF 0x22, 0x1
000B 3045 MOVLW 0x45
000D 0CA3 RRF 0x23, 0x1
000E 3045 MOVLW 0x45
0010 0EA4 SWAPF 0x24, 0x1
0011 3045 MOVLW 0x45
0012 00A5 MOVWF 0x25
0013 0AA5 INCF 0x25, 0x1
0014 3045 MOVLW 0x45
0015 00A6 MOVWF 0x26
0016 03A6 DECF 0x26, 0x1
0017 3045 MOVLW 0x45
0018 00A7 MOVWF 0x27
0019 01A7 CLRF 0x27
001A 0826 MOVF 0x26, 0x0
021 0xBA
022 0x8B
023 0x22
024 0x54
025 0x46
026 0x44
027 0x00
028 0x44
MPLAB® SIM1
3609/05/2016
; Programa 20 – Operações sobre bits – BSF
CLRF ondecadê ;SRAM(ondecadê) = 0x00
MOVF ondecadê,0 ;W = SRAM(ondecadê)
BSF ondecadê,0 ;SRAM(ondecadê), bit 0 = 1
end ;fim
00000000b
00000001b
00000011b
00000111b
00001111b
00011111b
10011111b
20 – Operações sobre bits – BSF
0005 01A0 CLRF 0x20
0006 0820 MOVF 0x20, 0x0
0007 00A1 MOVWF 0x21
0008 1420 BSF 0x20, 0x0
0009 0820 MOVF 0x20, 0x0
000B 14A0 BSF 0x20, 0x1
000C 0820 MOVF 0x20, 0x0
000D 00A3 MOVWF 0x23
000E 1520 BSF 0x20, 0x2
000F 0820 MOVF 0x20, 0x0
0010 00A4 MOVWF 0x24
0011 15A0 BSF 0x20, 0x3
0012 0820 MOVF 0x20, 0x0
0013 00A5 MOVWF 0x25
0014 1620 BSF 0x20, 0x4
0015 0820 MOVF 0x20, 0x0
0016 00A6 MOVWF 0x26
0017 17A0 BSF 0x20, 0x7
0018 0820 MOVF 0x20, 0x0
0019 00A7 MOVWF 0x27
021 0x00
022 0x01
023 0x03
024 0x07
025 0x0F
026 0x1F
027 0x9F

09/05/2016
7
MPLAB® SIM1
3709/05/2016
; Programa 21 – Operações sobre bits – BCF
COMF ondecadê,1 ;SRAM(ondecadê) = 0xFF
BCF ondecadê,0 ;SRAM(ondecadê), bit 0 = 0
end ;fim
11111111b
11111110b
11111100b
11111000b
11110000b
11100000b
01100000b
21 – Operações sobre bits – BCF
0005 01A0 CLRF 0x20
0006 09A0 COMF 0x20, 0x1
0007 0820 MOVF 0x20, 0x0
0008 00A1 MOVWF 0x21
0009 1020 BCF 0x20, 0x0
000A 0820 MOVF 0x20, 0x0
000C 10A0 BCF 0x20, 0x1
000D 0820 MOVF 0x20, 0x0
000E 00A3 MOVWF 0x23
000F 1120 BCF 0x20, 0x2
0010 0820 MOVF 0x20, 0x0
0011 00A4 MOVWF 0x24
0012 11A0 BCF 0x20, 0x3
0013 0820 MOVF 0x20, 0x0
0014 00A5 MOVWF 0x25
0015 1220 BCF 0x20, 0x4
0016 0820 MOVF 0x20, 0x0
0017 00A6 MOVWF 0x26
0018 13A0 BCF 0x20, 0x7
0019 0820 MOVF 0x20, 0x0
021 0xFF
022 0xFE
023 0xFC
024 0xF8
025 0xF0
026 0xE0
027 0x60
MPLAB® SIM1
3809/05/2016
; Programa 22 – Operações sobre bits: RRF, RLF, BCF, BSF
constant marqualrélio = 0x45 ;dado
BCF STATUS,C ;bit C do status register = 0
MOVF STATUS,W ;W = SRAM(STATUS)
BSF STATUS,C ;bit C do status register = 1
MOVF STATUS,W ;W = SRAM(STATUS)
end ;fim
0005 3045 MOVLW 0x45
0006 00A0 MOVWF 0x20
0007 1003 BCF 0x03, 0x0
0008 0803 MOVF 0x03, 0x0
0009 00A1 MOVWF 0x21
000A 1403 BSF 0x03, 0x0
000B 0803 MOVF 0x03, 0x0
000D 3045 MOVLW 0x45
000F 1003 BCF 0x03, 0x0
0010 0DA3 RLF 0x23, 0x1
0011 3045 MOVLW 0x45
0012 00A4 MOVWF 0x24
0013 1403 BSF 0x03, 0x0
0014 0DA4 RLF 0x24, 0x1
0015 3045 MOVLW 0x45
0016 00A5 MOVWF 0x25
0017 1003 BCF 0x03, 0x0
0018 0CA5 RRF 0x25, 0x1
0019 3045 MOVLW 0x45
001B 1403 BSF 0x03, 0x0
001C 0CA6 RRF 0x26, 0x1
01000101b
00010110b
00011011b
10001010b
10001011b
00100010b
10100010b
22 – Operações sobre bits: RRF, RLF, BCF, BSF
Status Register 020 0x45
021 0x1A
022 0x1B
023 0x8A
024 0x8B
025 0x22
026 0xA2
MPLAB® SIM1
3909/05/2016
23 – Não comutatividade da subtração
; Programa 23 – Não comutatividade da subtração
MOVLW 0x45 ;W = 0x45
MOVWF 0x20 ;SRAM(0x20) = W
MOVLW 0xae ;W = 0xAE
SUBLW 0xae ;W = 0xAE - 0x45
MOVLW 0xae ;W = 0xAE
SUBLW 0x45 ;W = 0x45 - 0xAE
end ;fim
174 – 69 = 105
256 + (69 – 174) = 151
W = L – W
W = 0xAE – 0x45
W = L – W
W = 0x45 – 0xAE
0000 3045 MOVLW 0x45
0001 00A0 MOVWF 0x20
0002 30AE MOVLW 0xAE
0003 00A1 MOVWF 0x21
0004 3045 MOVLW 0x45
0005 3CAE SUBLW 0xAE
0006 00A2 MOVWF 0x22
0007 30AE MOVLW 0xAE
0008 3C45 SUBLW 0x45
0009 00A3 MOVWF 0x23
020 0x45
021 0xAE
022 0x69
023 0x97
AEh – 45h = 69h
100h + 45h – AEh = 97h
AEh – 45h: C = 1
45h – AEh: C = 0
MPLAB® SIM1
4009/05/2016
24 – Endereçamento dos bancos sem rótulos
; Programa 24 – Endereçamento dos bancos sem rótulos
;0x020 = 00 0100000 RP1=0; RP0=0 banco 0
BCF 0x03,0x6
BCF 0x03,0x5
;0x0A0 = 01 0100000 RP1=0; RP0=1 banco 1
BCF 0x03,0x6 ;*
BSF 0x03,0x5
MOVWF 0x20 ;SRAM(0x0A0) = W
;0x120 = 10 0100000 RP1=1; RP0=0 banco 2
BSF 0x03,0x6
BCF 0x03,0x5
;0x1A0 = 11 0100000 RP1=0; RP0=1 banco 3
BSF 0x03,0x6 ;*
BSF 0x03,0x5
MOVWF 0x20 ;SRAM(0x1A0) = W
end ;fim
0000 3045 MOVLW 0x45
0001 1303 BCF 0x03, 0x6
0002 1283 BCF 0x03, 0x5
0003 00A0 MOVWF 0x20
0004 1303 BCF 0x03, 0x6
0005 1683 BSF 0x03, 0x5
0006 00A0 MOVWF 0x20
0007 1703 BSF 0x03, 0x6
0008 1283 BCF 0x03, 0x5
0009 00A0 MOVWF 0x20
000A 1703 BSF 0x03, 0x6
000B 1683 BSF 0x03, 0x5
Status Register
MPLAB® SIM1
4109/05/2016
25 – Endereçamento dos bancos com rótulos
; Programa 25 – Endereçamento dos bancos com rótulos
;0x020 = 00 0100000 RP1=0; RP0=0 banco 0
BCF STATUS,RP1
BCF STATUS,RP0
MOVWF ondecadê ;SRAM(0x020) = W
;0x0A0 = 01 0100000 RP1=0; RP0=1 banco 1
BCF STATUS,RP1 ;*
BSF STATUS,RP0
MOVWF ondecadê ;SRAM(0x0A0) = W
;0x120 = 10 0100000 RP1=1; RP0=0 banco 2
BSF STATUS,RP1
BCF STATUS,RP0
MOVWF ondecadê ;SRAM(0x120) = W
;0x1A0 = 11 0100000 RP1=0; RP0=1 banco 3
BSF STATUS,RP1 ;*
BSF STATUS,RP0
MOVWF ondecadê ;SRAM(0x1A0) = W
end ;fim
0005 3045 MOVLW 0x45
0006 1303 BCF 0x03, 0x6
0007 1283 BCF 0x03, 0x5
0008 00A0 MOVWF 0x20
0009 1303 BCF 0x03, 0x6
000A 1683 BSF 0x03, 0x5
000C 1703 BSF 0x03, 0x6
000D 1283 BCF 0x03, 0x5
000F 1703 BSF 0x03, 0x6
0010 1683 BSF 0x03, 0x5
0011 00A0 MOVWF 0x20
MPLAB® SIM1
4209/05/2016
26 – Efeito do overflow do endereço da SRAM
; Programa 26 – Efeito do overflow do endereço
constant ondecadê = 0x7F ;endereço
BCF STATUS,RP1 ;*
BCF STATUS,RP0 ;*
MOVWF ondecadê ;SRAM(0x07F) = W
MOVWF ondecadê+1 ;SRAM(0x000) = W
end ;fim
• O endereço 80h é inválido, pois podem ser
usados, somente, sete bits para o file.
• Isto significa que 80h é convertido para 00h.
• Há erro no endereçamento.
0005 3045 MOVLW 0x45
0006 1303 BCF 0x03, 0x6
0007 1283 BCF 0x03, 0x5
0008 00FF MOVWF 0x7f
0009 0080 MOVWF 0x00

09/05/2016
8
MPLAB® SIM1
4309/05/2016
Endereçamento por 7 ou 9 bits
• O opcode, o código de máquina e o código
disassembly usam 7 bits para endereço na SRAM.
• O MPLAB aceita um endereçamento de 9 bits,
eliminando automaticamente os dois bits mais
significativos.
• Aparece uma mensagem de aviso dizendo que o
registrador não se encontra no banco 0, indicando
que o endereço deve conter 7 bits.
• Este aviso indica que o MPLAB realizou
alterações no programa.
MPLAB® SIM1
4409/05/2016
Message[302] ...endereçamento.ASM 14 : Register in operand not in bank 0. Ensure that bank bits are correct.
• O programa contém erros, mas o MPLAB realiza as
correções automaticamente durante a montagem.
• Tais erros não serão admitidos nas avaliações.
Linha 14: MOVWF 0x0a0 ;SRAM(0x0A0) = W
Linha 19: MOVWF 0x120 ;SRAM(0x120) = W
Linha 24: MOVWF 0x1a0 ;SRAM(0x1A0) = W
Exemplo anterior, com endereçamento de 9 bits
0005 3045 MOVLW 0x45
0006 1303 BCF 0x03, 0x6
0007 1283 BCF 0x03, 0x5
0008 00A0 MOVWF 0x20
0009 1303 BCF 0x03, 0x6
000A 1683 BSF 0x03, 0x5
000C 1703 BSF 0x03, 0x6
000D 1283 BCF 0x03, 0x5
000F 1703 BSF 0x03, 0x6
0010 1683 BSF 0x03, 0x5
0011 00A0 MOVWF 0x20
MPLAB® SIM1
4509/05/2016
; Programa 27 – Endereçamento indireto da SRAM
MOVLW 0x20 ;W = 0x20 Banco 0
MOVWF FSR ;SRAM(FSR) = W
MOVLW 0xaa ;W = 0xAA
MOVWF INDF ;SRAM(0x20) = W
MOVLW 0xa0 ;W = 0xA0 Banco 1
MOVLW 0xaa ;W = 0xAA
MOVWF INDF ;SRAM(0xA0) = W
end ;fim
27 – Endereçamento indireto da SRAM
0005 3020 MOVLW 0x20
0006 0084 MOVWF 0x04
0008 0080 MOVWF 0x00
0009 30A0 MOVLW 0xA0
000A 0084 MOVWF 0x04
000B 30AA MOVLW 0xAA
000C 0080 MOVWF 0x00
MPLAB® SIM1
4609/05/2016
; Programa 28 – Endereçamento indireto da SRAM e IRP
BCF STATUS,IRP ;STATUS(IRP) = 0
MOVLW 0xbb ;W = 0xBB
MOVWF INDF ;SRAM(INDF) = W
BSF STATUS,IRP ;STATUS(IRP) = 0
MOVLW 0xbb ;W = 0xBB
end ;fim
28 – Endereçamento indireto da SRAM e IRP
0005 1383 BCF 0x03, 0x7
0006 3020 MOVLW 0x20
0007 0084 MOVWF 0x04
0008 30BB MOVLW 0xBB
0009 0080 MOVWF 0x00
000A 1783 BSF 0x03, 0x7
000B 3020 MOVLW 0x20
000C 0084 MOVWF 0x04
000D 30BB MOVLW 0xBB
000E 0080 MOVWF 0x00
MPLAB® SIM1
4709/05/2016
Endereçamento indireto da SRAM
IRP FSR
MPLAB® SIM1
4809/05/2016
Endereçamento indireto da SRAM
• O endereçamento indireto permite que o
programa decida qual o endereço a ser acessado.
• Com endereçamento direto, não é possível
interpretar o conteúdo de um registrador como o
endereço de outro registrador.
• Com endereçamento indireto, o conteúdo de um
registrador pode ser copiado para FSR, que é
usado como o endereço de 8 bits para outro
registrador.

09/05/2016
9
MPLAB® SIM1
4909/05/2016
; Programa 29 – Endereço e dado indiretos
constant ondecadê1 = 0x20;endereço que contém o endereço
constant ondecadê2 = 0x21;endereço que contém o dado
BCF STATUS,IRP ;STATUS(IRP) = 0
end ;fim
29 – Endereço e dado indiretos
Digitar
0005 1383 BCF 0x03, 0x7
0006 0820 MOVF 0x20, 0x0
0007 0084 MOVWF 0x04
0008 0821 MOVF 0x21, 0x0
0009 0080 MOVWF 0x00
020 0x25
021 0xAA
MPLAB® SIM1
0000 01A0 CLRF 0x20
0001 0820 MOVF 0x20, 0x0
0002 00A1 MOVWF 0x21
0003 1520 BSF 0x20, 0x2
0004 0820 MOVF 0x20, 0x0
0005 00A2 MOVWF 0x22
0006 281F GOTO 0x00A
0007 17A0 BSF 0x20, 0x7
0008 0820 MOVF 0x20, 0x0
0009 00A3 MOVWF 0x23
000A 3FFF
000B 3FFF
000C 3FFF
000D 3FFF
000E 3FFF
000F 3FFF
0010 3FFF
5009/05/2016
30 – GOTO com argumento numérico
; Programa 30 - GOTO com argumento numérico
CLRF ondecadê ;não importa
MOVF ondecadê,0 ;não importa
MOVWF ondecadê+1 ;não importa
BSF ondecadê,2 ;não importa
GOTO 0x00a ;11 bits
BSF ondecadê,7 ;não importa
end ;fim
Pulado
Pulado
020 0x04
021 0x00
022 0x05
023 0x00
• Experimente usar, como argumento do GOTO, um
valor inferior ao do endereço da instrução GOTO.
MPLAB® SIM1
5109/05/2016
GOTO
• É útil usar a função step into.
• Isso permite observar a ação do desvio.
• No status bar, é possível conferir o
valor do program counter.
• O botão reset permite retornar ao início
do programa.
MPLAB® SIM1
5209/05/2016
31 – GOTO com argumento simbólico
; Programa 31 - GOTO com argumento simbólico
constant ondecadê = 0x20 ;endereço SRAM
constant ondegoto = 0x00a;endereço FLASH; 11 bits
CLRF ondecadê
MOVF ondecadê,0
MOVWF ondecadê+1
BSF ondecadê,0
MOVF ondecadê,0
MOVWF ondecadê+2
GOTO ondegoto ;11 bits
BSF ondecadê,1
MOVF ondecadê,0
MOVWF ondecadê+3
end ;fim
0000 01A0 CLRF 0x20
0001 0820 MOVF 0x20, 0x0
0002 00A1 MOVWF 0x21
0003 1520 BSF 0x20, 0x2
0004 0820 MOVF 0x20, 0x0
0005 00A2 MOVWF 0x22
0006 281F GOTO 0x00A
0007 17A0 BSF 0x20, 0x7
0008 0820 MOVF 0x20, 0x0
0009 00A3 MOVWF 0x23
000A 3FFF
000B 3FFF
000C 3FFF
000D 3FFF
000E 3FFF
000F 3FFF
0010 3FFF
MPLAB® SIM1
0000 01A0 CLRF 0x20
0001 0820 MOVF 0x20, 0x0
0002 00A1 MOVWF 0x21
0003 1420 BSF 0x20, 0x0
0004 0820 MOVF 0x20, 0x0
0005 00A2 MOVWF 0x22
0006 14A0 BSF 0x20, 0x1
0007 0820 MOVF 0x20, 0x0
0008 00A3 MOVWF 0x23
0009 281C GOTO 0x00D
000A 1520 BSF 0x20, 0x2
000B 0820 MOVF 0x20, 0x0
000D 15A0 BSF 0x20, 0x3
000E 0820 MOVF 0x20, 0x0
0010 1620 BSF 0x20, 0x4
0011 0820 MOVF 0x20, 0x0
0012 00A6 MOVWF 0x26
0013 17A0 BSF 0x20, 0x7
0014 0820 MOVF 0x20, 0x0
0015 00A7 MOVWF 0x27
5309/05/2016
32 – GOTO com argumento numérico
Pulado
; Programa 32 – GOTO com argumento numérico
CLRF ondecadê
MOVF ondecadê,0
MOVWF ondecadê+1
BSF ondecadê,0
MOVF ondecadê,0
MOVWF ondecadê+2
BSF ondecadê,1
MOVF ondecadê,0
MOVWF ondecadê+3
GOTO 0x00d ;11 bits
BSF ondecadê,2
MOVF ondecadê,0
MOVWF ondecadê+4
BSF ondecadê,3
MOVF ondecadê,0
MOVWF ondecadê+5
BSF ondecadê,4
MOVF ondecadê,0
MOVWF ondecadê+6
BSF ondecadê,7
MOVF ondecadê,0
MOVWF ondecadê+7
end ;fim
Pulado
021 0x00
022 0x01
023 0x03
024 0x00
025 0x0B
026 0x1B
027 0x9B
Pulado
MPLAB® SIM1
5409/05/2016
• O endereço real fornece, diretamente, o valor da
posição da flash para onde o PC deve apontar após
a instrução GOTO.
• Este tipo de programação é o que aparece no
código assembly puro (disassembly).
• Este tipo de programação requer o conhecimento da
posição exata do próximo ponto de execução.
• Nem sempre a determinação deste endereço é fácil.
• Ao acrescentar ou remover linhas no programa,
pode ser necessário recalcular tais endereços.
GOTO com argumento numérico

09/05/2016
10
MPLAB® SIM1
000A 01A0 CLRF 0x20
000B 0820 MOVF 0x20, 0x0
000D 1420 BSF 0x20, 0x0
000E 0820 MOVF 0x20, 0x0
0010 14A0 BSF 0x20, 0x1
0011 0820 MOVF 0x20, 0x0
0012 00A3 MOVWF 0x23
0013 2817 GOTO 0x017
0014 1520 BSF 0x20, 0x2
0015 0820 MOVF 0x20, 0x0
0016 00A4 MOVWF 0x24
0017 15A0 BSF 0x20, 0x3
0018 0820 MOVF 0x20, 0x0
0019 00A5 MOVWF 0x25
001A 1620 BSF 0x20, 0x4
001B 0820 MOVF 0x20, 0x0
001D 17A0 BSF 0x20, 0x7
001E 0820 MOVF 0x20, 0x0
5509/05/2016
33 – GOTO com rótulo absoluto
Pulado
; Programa 33 - GOTO com rótulo absoluto
org 0xa ;alterar
GOTO ali ;11 bits
ali
end ;fim
ali = 17h
Pulado
Pulado
021 0x00
022 0x01
023 0x03
024 0x00
025 0x0B
026 0x1B
027 0x9B
MPLAB® SIM1
5609/05/2016
33 – GOTO com rótulo absoluto
• O rótulo pode ser colocado na própria
linha onde se encontra a instrução para
onde o salto é direcionado.
• Experimente colocar o rótulo “ali” antes da
linha onde a instrução GOTO se encontra.
MPLAB® SIM1
5709/05/2016
34 – Efeito do overflow do endereço da PM
• O endereço 0803h é inválido, pois podem ser
usados, somente, onze bits para a PM.
• Isto significa que 0803h é convertido para 003h.
• Há erro no endereçamento.
07F9 3FFF
07FA 0000 NOP
07FB 0000 NOP
07FC 0000 NOP
07FD 0000 NOP
07FE 2803 GOTO 0x003
07FF 0000 NOP
0800 0000 NOP
0801 0000 NOP
0802 0000 NOP
0803 0000 NOP
0804 0000 NOP
0805 0000 NOP
0806 0000 NOP
0807 3FFF
; Programa 34 - Efeito do overflow do endereço
org 0x7fa ;ponto de início
NOP
NOP
NOP
NOP
GOTO ali
NOP
NOP
NOP
NOP
ali
NOP
NOP
NOP
NOP
end
Página 0
Página 1
MPLAB® SIM1
5809/05/2016
• Ao usar a instrução GOTO, é preciso
cuidar para que o jump não tente passar
de uma página para outra.
• Na ocorrência do overflow do argumento
da instrução GOTO, os bits excedentes
são simplesmente ignorados.
• A instrução GOTO, naturalmente, não
permite a troca de página. Jumps entre
páginas não são permitidos.
• Mais adiante será visto um
procedimento para o uso da instrução
GOTO em jumps entre páginas.
34 – Efeito do overflow do endereço da PM
MPLAB® SIM1
5909/05/2016
GOTO – Endereço relativo
• GOTO $:
• Vai para o endereço da $ flash.
• $ indica o endereço atual apontado pelo PC, o
endereço da instrução GOTO.
• O símbolo “$” não pertence ao assembler puro,
é uma extensão do MPLAB que representa o
endereço atual da flash.
• O endereço $-1 aponta para a instrução
anterior, uma linha acima no programa.
• O endereço $+1 aponta para a instrução
seguinte, uma linha abaixo no programa.
• Pode-se usar avançar ou retornar várias linhas.
MPLAB® SIM1
09/05/2016
; Programa 35 - GOTO com rótulo relativo
org 0xa ;alterar
CLRF ondecadê
MOVF ondecadê,0
MOVWF ondecadê+1
BSF ondecadê,0
MOVF ondecadê,0
MOVWF ondecadê+2
BSF ondecadê,1
MOVF ondecadê,0
MOVWF ondecadê+3
GOTO $+4 ;11 bits
BSF ondecadê,2
MOVF ondecadê,0
MOVWF ondecadê+4
BSF ondecadê,3
MOVF ondecadê,0
MOVWF ondecadê+5
BSF ondecadê,4
MOVF ondecadê,0
MOVWF ondecadê+6
BSF ondecadê,7
MOVF ondecadê,0
MOVWF ondecadê+7
end ;fim
000A 01A0 CLRF 0x20
000B 0820 MOVF 0x20, 0x0
000D 1420 BSF 0x20, 0x0
000E 0820 MOVF 0x20, 0x0
0010 14A0 BSF 0x20, 0x1
0011 0820 MOVF 0x20, 0x0
0012 00A3 MOVWF 0x23
0013 2817 GOTO 0x017
0014 1520 BSF 0x20, 0x2
0015 0820 MOVF 0x20, 0x0
0016 00A4 MOVWF 0x24
0017 15A0 BSF 0x20, 0x3
0018 0820 MOVF 0x20, 0x0
0019 00A5 MOVWF 0x25
001A 1620 BSF 0x20, 0x4
001B 0820 MOVF 0x20, 0x0
001D 17A0 BSF 0x20, 0x7
001E 0820 MOVF 0x20, 0x0
60
35 – GOTO com rótulo relativo
$ = 0x13h
$+4 = 0x17h
• Este programa gera o
mesmo disassembly
do programa 33.
Pulado
Pulado

09/05/2016
11
MPLAB® SIM1
6109/05/2016
• Embora o valor $+n possa ser entendido
como linhas acima ou abaixo no código
assembly (arquivo “.asm”), ele indica, de fato,
linhas acima ou abaixo no código montado,
isto é, opcode’s acima ou abaixo.
• Códigos não-assembly, como linha em
branco, linha de comentário, linha de definição
de constantes, etc., não são considerados.
• Todas as linhas que não gerem opcode no
disassembler são ignoradas.
• Se linhas são adicionadas ou removidas entre
a instrução GOTO e o destino do salto, o
argumento deve ser recalculado.
GOTO com rótulo relativo
MPLAB® SIM1
0005 1283 BCF 0x03, 0x5
0006 1303 BCF 0x03, 0x6
0007 3003 MOVLW 0x03
0008 2005 CALL 0x00A
0009 3004 MOVLW 0x04
000A 3005 MOVLW 0x05
000B 0008 RETURN
000C 3006 MOVLW 0x06
6209/05/2016
36 – CALL
; Programa 36 – CALL - Errado
#include <p16f877.inc>
org 0x5
BCF STATUS,RP0
BCF STATUS,RP1
MOVLW 0x03
CALL Rotina
MOVLW 0x04
Rotina
MOVLW 0x05
RETURN
MOVLW 0x06
end
• O programa entra num laço infinito.
• É preciso impedir que a rotina “espera”
seja executada fora do chamado.
• Ocorre um stack underflow.
MPLAB® SIM1
6309/05/2016
35 – CALL
MPLAB® SIM1
6409/05/2016
37 – Seleção entre duas sub-rotinas
; Programa 37 - Duas sub-rotinas
org 0x5
BCF STATUS,C ;escolher entre BSF e BCF
BTFSS STATUS,C ;se C=0 então...
CALL RotinaC0 ;executa RotinaC0
BTFSC STATUS,C ;se C=1 então...
GOTO Fim ;evita que as rotinas sejam executadas
RotinaC0
MOVLW 0x03
MOVWF 0x20
CLRF 0x21
RETURN
RotinaC1
MOVLW 0x04
MOVWF 0x21
CLRF 0x20
RETURN
Fim
end
• Label para sub-rotina.
• Label para ponto específico.
MPLAB® SIM1
6509/05/2016
0005 1003 BCF 0x03, 0x0
0006 1C03 BTFSS 0x03, 0x0
0007 200B CALL 0x00B
0008 1803 BTFSC 0x03, 0x0
0009 200F CALL 0x00F
000A 2813 GOTO 0x13
000B 3003 MOVLW 0x03
000D 01A1 CLRF 0x21
000E 0008 RETURN
000F 3004 MOVLW 0x04
0010 00A1 MOVWF 0x21
0011 01A0 CLRF 0x20
0012 0008 RETURN
0005 1403 BSF 0x03, 0x0
0006 1C03 BTFSS 0x03, 0x0
0007 200B CALL 0x00B
0008 1803 BTFSC 0x03, 0x0
0009 200F CALL 0x00F
000A 2813 GOTO 0x13
000B 3003 MOVLW 0x03
000D 01A1 CLRF 0x21
000E 0008 RETURN
000F 3004 MOVLW 0x04
0010 00A1 MOVWF 0x21
0011 01A0 CLRF 0x20
0012 0008 RETURN
020 0x00
021 0x04
020 0x03
021 0x00
MPLAB® SIM1
6609/05/2016
• Sempre que for necessário optar por dois ou mais
caminhos diferentes, este procedimento deve ser adotado.
• Somente é possível decidir entre dois caminhos. Se há
mais de dois caminhos a serem escolhidos, mais
procedimentos de decisão devem ser aplicados.
• Um bit é usado como critério de decisão entre duas
opções.

09/05/2016
12
MPLAB® SIM1
09/05/2016
0005 BCF 0x03, 0x0
0006 BTFSS 0x03, 0x0
0007 CALL 0x00B
0008 BTFSC 0x03, 0x0
0009 CALL 0x00F
000A GOTO 0x13
000B MOVLW 0x03
000C MOVWF 0x20
000D CLRF 0x21
000E RETURN
000F MOVLW 0x04
0010 MOVWF 0x21
0011 CLRF 0x20
0012 RETURN
67
CALL e GOTO
• Antes de verificar a pilha, convém apagá-la.
• Ela não é apagada em um reset do debugger.
Faz o push
PC=7
Stack pointer
MPLAB® SIM1
6809/05/2016
38 – Programa anterior sem o uso de CALL
; Programa 38 - Programa anterior sem o uso de CALL
org 0x5
GOTO RotinaC0 ;executa RotinaC0
GOTO RotinaC1 ;executa RotinaC1
RotinaC0
MOVLW 0x03
MOVWF 0x20
CLRF 0x21
GOTO Fim ;evita RotinaC1
RotinaC1
MOVLW 0x04
MOVWF 0x21
CLRF 0x20
GOTO Fim ;*
Fim
end
0005 1003 BCF 0x03, 0x0
0006 1C03 BTFSS 0x03, 0x0
0007 2809 GOTO 0x009
0008 280D GOTO 0x00D
0009 3003 MOVLW 0x03
000B 01A1 CLRF 0x21
000C 2811 GOTO 0x011
000D 3004 MOVLW 0x04
000F 01A0 CLRF 0x20
0010 2811 GOTO 0x011
MPLAB® SIM1
6909/05/2016
39 – Programa anterior sem o uso de GOTO
; Programa 39 - Programa anterior sem o uso de GOTO
org 0x5
CLRF PCLATH ;*
MOVLW 0xc
MOVWF PCL ;executa RotinaC0
MOVLW 0x11
MOVWF PCL ;executa RotinaC1
;RotinaC0
MOVLW 0x03
MOVWF 0x20
CLRF 0x21
MOVLW 0x16 ;evita RotinaC1
MOVWF PCL ;evita RotinaC1
;RotinaC1
MOVLW 0x04
MOVWF 0x21
CLRF 0x20
MOVLW 0x16 ;*
MOVWF PCL ;*
end
0005 CLRF 0x0A
0006 BCF 0x03, 0x0
0007 MOVLW 0x0C
0008 BTFSS 0x03, 0x0
0009 MOVWF 0x02
000A MOVLW 0x11
000B MOVWF 0x02
000C MOVLW 0x03
000D MOVWF 0x20
000E CLRF 0x21
000F MOVLW 0x16
0010 MOVWF 0x02
0011 MOVLW 0x04
0012 MOVWF 0x21
0013 CLRF 0x20
0014 MOVLW 0x16
0015 MOVWF 0x02
MPLAB® SIM1
7009/05/2016
40 – CALL sem RETURN
; Programa 39 - CALL sem RETURN - Proibido
org 0x5
BTFSC STATUS,C ;se C=1 então...
RotinaC0
MOVLW 0x03
MOVWF 0x20
CLRF 0x21
GOTO Fim
RotinaC1
MOVLW 0x04
MOVWF 0x21
CLRF 0x20
GOTO Fim
Fim
end
• Este programa funciona, mas dá erro na pilha.
• Para cada CALL, deve existir um RETURN.
• Não é correto o uso de CALL sem RETURN.
0005 BCF 0x03, 0x0
0006 BTFSS 0x03, 0x0
0007 CALL 0x00A
0008 BTFSC 0x03, 0x0
0009 CALL 0x00E
000A MOVLW 0x03
000B MOVWF 0x20
000C CLRF 0x21
000D GOTO 0x012
000E MOVLW 0x04
000F MOVWF 0x21
0010 CLRF 0x20
0011 GOTO 0x012
MPLAB® SIM1
7109/05/2016
Não uso da instrução CALL
• A substituição do CALL por GOTO ajuda a
prevenir stack overflow.
• É recomendável o uso de GOTO nas situações:
1. Desvios que não envolvam sub-rotinas.
2. Desvios para sub-rotinas que sejam chamadas,
somente, em uma única linha do programa.
3. Desvios para sub-rotinas que, embora tenham
mais pontos de chamada, forçam, após a
execução, o PC a ir para o mesmo ponto.
MPLAB® SIM1
7209/05/2016
Não uso da instrução CALL
• Quando há desvios para sub-rotinas que tenham
mais pontos de chamada e, após o retorno, o
programa deve prosseguir a partir do ponto onde
estava antes da chamada, então é recomendado
o uso do CALL, pois, cada ponto de chamada
produzirá um RETURN diferente com base no
endereço diferente contido na TOS.
• Se, mesmo nesse tipo de situação, for
necessário eliminar o CALL, por motivo de stack
overflow, então é preciso criar várias cópias da
sub-rotina, uma para cada ponto de chamada.

09/05/2016
13
MPLAB® SIM1
0005 CALL 0x007
0006 GOTO 0x010
0007 MOVLW 0x03
0008 MOVWF 0x20
0009 CLRF 0x21
000A CALL 0x00C
000B RETURN
000C MOVLW 0x04
000D MOVWF 0x21
000E CLRF 0x20
000F RETURN
7309/05/2016
41 – Uma sub-rotina dentro de outra
; Programa 41 - Uma sub-rotina dentro da outra
org 0x5
GOTO Fim
RotinaC0
MOVLW 0x03
MOVWF 0x20
CLRF 0x21
RETURN
RotinaC1
MOVLW 0x04
MOVWF 0x21
CLRF 0x20
RETURN
Fim
end
020 0x03
021 0x04
MPLAB® SIM1
Escopo de GOTO e CALL
7409/05/2016
• O argumento das instruções GOTO e CALL tem 11 bits.
• O argumento pode variar de 000h até 7FFh.
• As instruções GOTO e CALL não permitem mudança de
página da program memory.
• Ao usar rótulo absoluto, é preciso verificar se o local do
programa onde este rótulo está colocado não pertence a
uma página diferente do local onde a instrução GOTO ou
CALL se encontram.
• Ao usar rótulo relativo ($), é preciso verificar se o
deslocamento do PC não apontaria para uma outra página.
• Qualquer tentativa de mudança de página nas instruções
GOTO e CALL implica na eliminação de PC<12:11>,
levando o PC para um local errado.
MPLAB® SIM1
Criação de um temporizador
• A MCU é muito rápida na percepção humana.
• Uma única variável de 8 bits não é suficiente para criar
um tempo de duração útil.
• Quanto maior for o tempo de espera, maior é o número
de variáveis (GPR´s) necessários.
• Por meio da escolha do valor inicial destas variáveis na
linha de código ASM, pode-se configurar a temporização.
7509/05/2016
MPLAB® SIM1
• A variável de contagem pode ser qualquer GPR.
• O modo mais fácil de comparação de um valor é
verificando se ele é zero.
• Um zero pode ser identificado por meio do bit “Z” do status
register ou por meio das instruções do tipo “skip if zero”.
• Como a verificação é feita sobre o zero, então este é o
valor final da contagem.
• A contagem é decrescente.
• A contagem é encerrada quando o valor zero é obtido.
• A máxima contagem é feita com o GPR valendo
inicialmente FFh ou um valor inferior.
• A mínima contagem é feita com o GPR valendo
inicialmente 01h.
7609/05/2016
Criação de um temporizador
MPLAB® SIM1
42 – Temporizador com uma variável
7709/05/2016
; Programa 42 - Temporizador com uma variável
org 0x5
constant TEMPO = 0x20
constant VALOR = 0x0f ;configurável
MOVLW VALOR
MOVWF TEMPO
DECFSZ TEMPO, 0x1
GOTO $-0x1
end
Valor que define
a temporização
Endereço
arbitrário
MOVLW 0x0F
MOVWF 0x20
DECFSZ 0x20, 0x1
GOTO 0x007
Use o comando animate para observar a contagem.
MPLAB® SIM1
42 – Temporizador com uma variável
7809/05/2016
Use o comando animate para observar a contagem.

09/05/2016
14
MPLAB® SIM1
; Programa 43 - Proteção do WDT
org 0x5
MOVLW VALOR
MOVWF TEMPO
CLRWDT
DECFSZ TEMPO, 0x1
GOTO $-0x2
end
43 – Proteção do WDT
7909/05/2016
• Dependendo da configuração do WDT, pode haver um reset
na PIC® antes do término da contagem.
• Convém reiniciar WDT no decorrer da contagem.
• Se o WDT está desabilitado, este cuidado não é necessário.
• A inclusão de instruções no ciclo de contagem aumenta o
tempo da contagem em 1TCY.
MOVLW 0x0F
MOVWF 0x20
CLRWDT
DECFSZ 0x20, 0x1
GOTO 0x007
MPLAB® SIM1
Cálculo aproximado do tempo
8009/05/2016
CLRWDT
DECFSZ TEMPO,1
GOTO $-0x2
• Na 1ª execução do CLRWDT, TEMPO = 0x0F.
• Na 2ª execução do CLRWDT, TEMPO = 0x0E.
• Na 15ª execução do CLRWDT, TEMPO = 0x01.
• Nesta repetição, o DECFSZ faz TEMPO = 0x00.
• Nesta repetição, o DECFSZ faz o skip.
• Nesta repetição, o GOTO não é executado.
• O ciclo de contagem é executado 15 vezes e não 16.
• O CLRWDT e o DECFSZ são executados 15 vezes.
• O GOTO é executado 14 vezes.
MPLAB® SIM1
Cálculo aproximado do tempo
8109/05/2016
• O CLRWDT é 1TCY.
• O DECFSZ e o GOTO são 2TCY.
• O ciclo de contagem é 1TCY + 2TCY + 2TCY = 5TCY.
• O ciclo total é (145TCY) + 3TCY = 73TCY.
• Considerar as duas operações de movimentação.
• Tempo = 73TCY + 1TCY + 1TCY = 75TCY.
• 1TCY = 4TOSC.
• 75TCY = 300TOSC.
• fOSC = 20MHz (suposição).
• TOSC = 50ns.
• 300TOSC = 15s.
CLRWDT
DECFSZ TEMPO,1
GOTO $-0x2
MPLAB® SIM1
8209/05/2016
44 – Contador de dois bytes
; Programa 44 - Contador de dois bytes
#include <P16F877.INC>
org 0x5
constant TEMPOA = 0x20
constant TEMPOB = 0x21
MOVLW VALOR
MOVWF TEMPOB
MOVWF TEMPOA
CLRWDT
DECFSZ TEMPOA, 0x1
GOTO $-0x2
DECFSZ TEMPOB, 0x1
GOTO $-0x5
end
TEMPOA: Variável menos significativa
TEMPOB: Variável mais significativa
MOVLW 0x0F
MOVWF 0x21
MOVWF 0x20
CLRWDT
DECFSZ 0x20, 0x1
GOTO 0x008
DECFSZ 0x21, 0x1
GOTO 0x007
MPLAB® SIM1
8309/05/2016
45 – Contador de três bytes
; Programa 45 – Contador de três bytes
org 0x5
constant TEMPOC = 0x22
constant VALOR = 0xff ;configurável
MOVLW VALOR
MOVWF TEMPOC
MOVWF TEMPOB
MOVWF TEMPOA
CLRWDT
DECFSZ TEMPOA, 0x1
GOTO $-0x2
DECFSZ TEMPOB, 0x1
GOTO $-0x5
DECFSZ TEMPOC, 0x1
GOTO $-0x8
end
MOVLW 0x03
MOVWF 0x22
MOVWF 0x21
MOVWF 0x20
CLRWDT
DECFSZ 0x20, 0x1
GOTO 0x009
DECFSZ 0x21, 0x1
GOTO 0x008
DECFSZ 0x22, 0x1
GOTO 0x007
MPLAB® SIM1
8409/05/2016
Criação do temporizador com três variáveis
Espera
MOVLW VALORC
MOVWF TEMPOC
MOVLW VALORB
MOVWF TEMPOB
MOVLW VALORA
MOVWF TEMPOA
CLRWDT
DECFSZ TEMPOA,0x1
GOTO $-0x2
DECFSZ TEMPOB,0x1
GOTO $-0x6
DECFSZ TEMPOC,0x1
GOTO $-0xa
RETURN
Retorna a quantidade
de linhas mencionada
Valores que definem a temporização
0x01 a 0xff
Não aceitam valor 0x00
Na lista de definições:
Rotina “Espera”
Endereços
arbitrários

09/05/2016
15
MPLAB® SIM1
; Programa 46 – Configuração 31h C2h 8Dh
org 0x5
constant VALORA = 0x31 ;configurável
constant VALORB = 0xc2 ;configurável
constant VALORC = 0x28 ;configurável
MOVLW VALORC
MOVWF TEMPOC
MOVLW VALORB
MOVWF TEMPOB
MOVLW VALORA
MOVWF TEMPOA
CLRWDT
DECFSZ TEMPOA, 0x1
GOTO $-0x2
DECFSZ TEMPOB, 0x1
GOTO $-0x6
DECFSZ TEMPOC, 0x1
GOTO $-0xa
end
8509/05/2016
46 – Configuração 31h C2h 8Dh
• 31h = 049d de 0d a 048d.
• C2h = 194d de 0d a 193d.
• 28h = 141d de 0d a 140d.
• 49  194  141 = 1.340.346 passos.
• A contagem é de 000000h a 1473B9h.
MOVLW 0x28
MOVWF 0x22
MOVLW 0xC2
MOVWF 0x21
MOVLW 0x31
MOVWF 0x20
CLRWDT
DECFSZ 0x20, 0x1
GOTO 0x00B
DECFSZ 0x21, 0x1
GOTO 0x009
DECFSZ 0x22, 0x1
GOTO 0x007
MPLAB® SIM1
8609/05/2016
47 – Quatro variáveis
; Programa 46 – Quatro variáveis
org 0x5
constant VALORA = 0x31
constant VALORB = 0xc2
constant VALORC = 0x8d
constant VALORD = 0xff
constant TEMPOD = 0x23
MOVLW VALORD
MOVWF TEMPOD
MOVLW VALORC
MOVWF TEMPOC
MOVLW VALORB
MOVWF TEMPOB
MOVLW VALORA
MOVWF TEMPOA
CLRWDT
DECFSZ TEMPOA, 0x1
GOTO $-0x2-0x0
DECFSZ TEMPOB, 0x1
GOTO $-0x2-0x4
DECFSZ TEMPOC, 0x1
GOTO $-0x2-0x8
DECFSZ TEMPOD, 0x1
GOTO $-0x2-0xc
end
MOVLW 0xFF
MOVWF 0x23
MOVLW 0x8D
MOVWF 0x22
MOVLW 0xC2
MOVWF 0x21
MOVLW 0x31
MOVWF 0x20
CLRWDT
DECFSZ 0x20, 0x1
GOTO 0x00D
DECFSZ 0x21, 0x1
GOTO 0x00B
DECFSZ 0x22, 0x1
GOTO 0x009
DECFSZ 0x23, 0x1
GOTO 0x007
MPLAB® SIM1
8709/05/2016
47 – Quatro variáveis
MOVLW VALORD
MOVWF TEMPOD
MOVLW VALORC
MOVWF TEMPOC
MOVLW VALORB
MOVWF TEMPOB
MOVLW VALORA
MOVWF TEMPOA
CLRWDT
DECFSZ TEMPOA, 0x1
GOTO $-0x2-0x0
DECFSZ TEMPOB, 0x1
GOTO $-0x2-0x4
DECFSZ TEMPOC, 0x1
GOTO $-0x2-0x8
DECFSZ TEMPOD, 0x1
GOTO $-0x2-0xc
Rotina a ser repetida
1 linha (n=1)
n+1 = 2
• O argumento da instrução GOTO foi parametrizado.
• Isto facilita a programação dos parâmetros.
• Ao inserir novas linhas na rotina a ser repetida,
basta corrigir o valor 0x02.
MPLAB® SIM1
8809/05/2016
48 – WDT não overflow
; Programa 48 – WDT não overflow
MOVLW 0x3b
MOVWF 0x22
MOVLW 0xff
MOVWF 0x21
MOVLW 0xfd
MOVWF 0x20
DECFSZ 0x20,0x1
GOTO 0x006
DECFSZ 0x21,0x1
GOTO 0x004
DECFSZ 0x22,0x1
GOTO 0x002
end
Output
CORE-W0014:Halted due to PC incrementing overthe Maximum PC address and wrapping back to Zero
• 3.806.385 passos de contagem.
• Não ocorre WDT overflow.
Executar um reset.
MPLAB® SIM1
8909/05/2016
49 – WDT overflow
; Programa 49 – WDT overflow
MOVLW 0x3b
MOVWF 0x22
MOVLW 0xff
MOVWF 0x21
MOVLW 0xfe
MOVWF 0x20
DECFSZ 0x20,0x1
GOTO 0x006
DECFSZ 0x21,0x1
GOTO 0x004
DECFSZ 0x22,0x1
GOTO 0x002
end
Output
CORE-W0003:WatchdogTimerevent occurred.Break in executionrequested
• 3.821.430 passos de contagem.
• Ocorre WDT overflow.
Executar um reset.
MPLAB® SIM1
9009/05/2016
; Programa 50 – Habilitação do WDT
__config _WDT_OFF
org 0x5
constant VALOR = 0xff
MOVLW VALOR
MOVWF TEMPO+2
MOVWF TEMPO+1
MOVWF TEMPO
DECFSZ TEMPO,1
GOTO $-1
DECFSZ TEMPO+1,1
GOTO $-4
DECFSZ TEMPO+2,1
GOTO $-7
end
50 – Habilitação do WDT
__config _WDT_ON
org 0x5
MOVLW VALOR
MOVWF TEMPO+2
MOVWF TEMPO+1
MOVWF TEMPO
DECFSZ TEMPO,1
GOTO $-1
DECFSZ TEMPO+1,1
GOTO $-4
DECFSZ TEMPO+2,1
GOTO $-7
end
CORE-W0003:WatchdogTimereventoccurred.Breakinexecutionrequested
CORE-W0014:HaltedduetoPCincrementingovertheMaximumPCaddressandwrappingbacktoZero

09/05/2016
16
MPLAB® SIM1
9109/05/2016
51 – Habilitação do WDT sem #include
__config _WDT_OFF
org 0x5
MOVLW VALOR
MOVWF TEMPO+2
MOVWF TEMPO+1
MOVWF TEMPO
DECFSZ TEMPO,1
GOTO $-1
DECFSZ TEMPO+1,1
GOTO $-4
DECFSZ TEMPO+2,1
GOTO $-7
end
; Programa 51 – Habilitação do WDT sem #include
__config 0x3ffb
org 0x5
MOVLW VALOR
MOVWF TEMPO+2
MOVWF TEMPO+1
MOVWF TEMPO
DECFSZ TEMPO,1
GOTO $-1
DECFSZ TEMPO+1,1
GOTO $-4
DECFSZ TEMPO+2,1
GOTO $-7
end
MPLAB® SIM1
; Programa 52 – Configuração do WDT
__config _WDT_ON
org 0x5
constant VALOR = 0x9c
;WDT Postscaler = 1:64
BCF STATUS, RP1
BSF STATUS, RP0
BSF OPTION_REG,PS2
BSF OPTION_REG,PS1
BCF OPTION_REG,PS0
MOVLW VALOR
MOVWF TEMPO+2
MOVWF TEMPO+1
MOVWF TEMPO
DECFSZ TEMPO,1
GOTO $-1
DECFSZ TEMPO+1,1
GOTO $-4
DECFSZ TEMPO+2,1
GOTO $-7
end
9209/05/2016
; Programa 52 – Configuração do WDT
__config _WDT_ON
org 0x5
constant VALOR = 0x9c
;WDT Postscaler = 1:128
BCF STATUS, RP1
BSF STATUS, RP0
BSF OPTION_REG,PS2
BSF OPTION_REG,PS1
BSF OPTION_REG,PS0
MOVLW VALOR
MOVWF TEMPO+2
MOVWF TEMPO+1
MOVWF TEMPO
DECFSZ TEMPO,1
GOTO $-1
DECFSZ TEMPO+1,1
GOTO $-4
DECFSZ TEMPO+2,1
GOTO $-7
end
52 – Configuração do WDT
CORE-W0003:WatchdogTimereventoccurred.Breakinexecutionrequested
CORE-W0014:HaltedduetoPCincrementingovertheMaximumPCaddressandwrappingbacktoZero
MPLAB® SIM1
9309/05/2016
EEPROM – Leitura direta
• Na leitura direta, o endereço da EEPROM a ser
lido é determinado diretamente no programa.
• Esta opção tem a vantagem de ser mais simples.
• Esta opção tem a desvantagem de não permitir
que o endereço da EEPROM esteja
condicionado a outras variáveis do sistema.
MPLAB® SIM1
9409/05/2016
53 – EEPROM – Leitura direta
; Programa 53 - EEPROM – Leitura direta
; Baseado no exemplo 4-1 do datasheet da pic16f877
org 0x5
constant ondecadê1 = 0x4f ;endereço da EEPROM data memory (8 bits)
constant ondecadê2 = 0x22 ;endereço da SRAM file memory (7 bits)
; Busca o endereço da posição da EEPROM a ser lida
MOVLW ondecadê1 ;W = ondecadê1
BSF STATUS,RP1
BCF STATUS,RP0 ;Seleciona o banco 2 (10b)
MOVWF EEADR ;SRAM(EEADR) = W
; Faz a leitura da EEPROM(ondecadê1)
BSF STATUS,RP1 ;*
BSF STATUS,RP0 ;Seleciona o banco 3 (11b)
BCF EECON1,EEPGD ;Configura para EEPROM
BSF EECON1,RD ;Inicia leitura
BSF STATUS,RP1 ;*
MOVF EEDATA,W ;W = SRAM(EEDATA)
; Copia para a SRAM(ondecadê2)
BCF STATUS,RP0 ;*
end
MOVLW 0x4F
BSF 0x03, 0x6
BCF 0x03, 0x5
MOVWF 0x0D
BSF 0x03, 0x6
BSF 0x03, 0x5
BCF 0x0C, 0x7
BSF 0x0C, 0x0
BSF 0x03, 0x6
BCF 0x03, 0x5
MOVF 0x0C, 0x0
BCF 0x03, 0x6
BCF 0x03, 0x5
MOVWF 0x22
MPLAB® SIM1
9509/05/2016
53 – EEPROM – Leitura direta – Testando
1 – Escolha o valor para a posição 04Fh da EEPROM.
• O GPR´s 022h recebe
o conteúdo da posição
047h da EEPROM.
2 – Execute o programa.
MPLAB® SIM1
9609/05/2016
53 – EEPROM – Leitura direta – Testando
Verificação dos registros.

09/05/2016
17
MPLAB® SIM1
9709/05/2016
53 – EEPROM – Leitura direta
• Três valores estão envolvidos:
• Endereço na EEPROM (ondecadê1,0x4F).
• Endereço do GPR que conterá o valor do
dado contido no endereço selecionado na
EEPROM (ondecadê2,0x22).
• Dado contido na EEPROM (0x88).
MPLAB® SIM1
9809/05/2016
54 – EEPROM – Leitura indireta
• Na leitura indireta, o endereço da EEPROM a ser lido
está localizado em um GPR.
• Esta opção tem a desvantagem de ser mais complexa.
• Esta opção tem a vantagem permitir que o endereço
da EEPROM esteja condicionado a outras variáveis do
sistema.
• Primeiramente, o GPR é gravado com um valor
determinado pelas variáveis em questão.
MPLAB® SIM1
9909/05/2016
; Programa 54 - EEPROM – Leitura indireta
org 0x5
constant ondecadê1 = 0x20 ;Endereço do GPR (7 bits) que contém o endereço da EEPROM (8 bits)
constant ondecadê2 = 0x21 ;Endereço do GPR (7 bits) que conterá o dado lido da EEPROM (8 bits)
; Busca o endereço da posição da EEPROM a ser lida
BCF STATUS,RP1
BCF STATUS,RP0 ;*
; Faz a leitura da EEPROM(SRAM(ondecadê1))
BSF STATUS,RP1 ;*
BCF EECON1,EEPGD ;Configura para EEPROM
BSF STATUS,RP1 ;*
MOVF EEDATA,W ;W = SRAM(EEDATA)
; Copia para a SRAM(0x21)
BCF STATUS,RP0 ;*
end
BCF 0x03, 0x6
BCF 0x03, 0x5
MOVF 0x20, 0x0
BSF 0x03, 0x6
BCF 0x03, 0x5
MOVWF 0x0D
BSF 0x03, 0x6
BSF 0x03, 0x5
BCF 0x0C, 0x7
BSF 0x0C, 0x0
BSF 0x03, 0x6
BCF 0x03, 0x5
MOVF 0x0C, 0x0
BCF 0x03, 0x6
BCF 0x03, 0x5
MOVWF 0x21
MPLAB® SIM1
10009/05/2016
54 – EEPROM – Leitura indireta – Testando
1 – Escolha um valor para o GPR 020h.
2 – Escolha o valor para a posição da EEPROM dada pelo valor do GPR 020h.
MPLAB® SIM1
10109/05/2016
54 – EEPROM – Leitura indireta – Testando
• O GPR 021h recebe o conteúdo
da posição da EEPROM indicada
pelo conteúdo do registrador 020h.
MPLAB® SIM1
10209/05/2016
• Quatro valores estão envolvidos:
• Endereço do GPR que contém o valor do endereço
na EEPROM a ser lido (ondecadê1=0x20).
• Endereço na EEPROM (0x5E).
• Endereço do GPR que conterá o valor do dado
contido no endereço selecionado na EEPROM
(ondecadê2=0x21).
• Dado contido na EEPROM (0xA9)

09/05/2016
18
MPLAB® SIM1
10309/05/2016
MOVF endereço, W ;W = endereço ,endereço para gravação
MOVF dado, W ;W = dado ,dado para gravação
MOVWF EEDATA ;SRAM(EEDATA) = W
• EEDATA contém o byte que será escrito na EEPROM.
• EEADR contém o endereço do byte na EEPROM.
• Importante é prestar atenção no controle dos bancos.
• As quatro linhas abaixo não podem faltar.
55 – EEPROM – Escrita direta
MPLAB® SIM1
10409/05/2016
1. BCF EECON1, EEPGD ;Configura para EEPROM
2. BSF EECON1, WREN ;Habilita escrita
3. MOVLW 0x55 ;W = 55h - primeira parte do código de escrita
4. MOVWF EECON2 ;SRAM(EECON2) = W
5. MOVLW 0xaa ;W = AAh - segunda parte do código de escrita
6. MOVWF EECON2 ;SRAM(EECON2) = W
7. BSF EECON1, WR ;Inicia escrita. Ao terminar,WR=0
8. BCF EECON1, WREN ;Desabilita escrita
• As oito linhas abaixo não podem faltar.
• A sequência deve ser preservada.
• A gravação é realizada após a instrução 7.
• Para várias escritas, as linhas 1 e 2 podem
ser usadas no início da primeira escrita e a
linha 8 no final da última escrita.
55 – EEPROM – Escrita direta
MPLAB® SIM1
; Programa 54 – EEPROM – Escrita direta
org 0x5
constant ondecadê = 0x05 ;endereço da EEPROM (8 bits)
constant marqualrélio = 0xca ;dado para a EEPROM (8 bits)
;Configura os registradores para a escrita
BSF STATUS, RP1
BCF STATUS, RP0
MOVLW ondecadê ;W = ondecadê1
BSF STATUS, RP1 ;*
BSF STATUS, RP0
BCF EECON1, EEPGD ;Configura para EEPROM
BSF EECON1, WREN ;Habilita escrita
;Realiza a escrita
MOVLW 0x55 ;W = 55h - primeira parte do código de escrita
MOVWF EECON2 ;SRAM(EECON2) = W
MOVLW 0xaa ;W = AAh - segunda parte do código de escrita
BSF EECON1, WR ;Inicia escrita
BCF EECON1, WREN ;Desabilita escrita
end
Escreve
Define endereço
Define dado
Configura
10509/05/2016
55 – EEPROM – Escrita direta BSF 0x03, 0x6
BCF 0x03, 0x5
MOVLW 0x05
MOVWF 0x0D
MOVLW 0xCA
MOVWF 0x0C
BSF 0x03, 0x6
BSF 0x03, 0x5
BCF 0x0C, 0x7
BSF 0x0C, 0x2
MOVLW 0x55
MOVWF 0x0D
MOVLW 0xAA
MOVWF 0x0D
BSF 0x0C, 0x1
BCF 0x0C, 0x2
MPLAB® SIM1
10609/05/2016
55 – EEPROM – Escrita direta – Testando
1 – Escolha um valor para o endereço de gravação.
2 – Escolha um valor para o dado a ser gravado.
MPLAB® SIM1
10709/05/2016
55 – EEPROM – Escrita direta – Testando
• A posição 033h recebe o valor 022h.
MPLAB® SIM1
Escreve
Define endereço
Define dado
Configura
10809/05/2016
56 – EEPROM – Escrita indireta
; Programa 56 – EEPROM – Escrita indireta
org 0x5
constant ondecadê1 = 0x20 ;Endereço do GPR (7 bits) que contém o dado para a EEPROM (8 bits)
;Configura os registradores para a escrita
BCF STATUS, RP1
BCF STATUS, RP0
MOVF ondecadê2, W ;W = SRAM(ondecadê2), endereço para gravação
BSF STATUS, RP1
BCF STATUS, RP0 ;*
BCF STATUS, RP1
BCF STATUS, RP0 ;*
MOVF ondecadê1, W ;W = SRAM(ondecadê1), dado para gravação
BSF STATUS, RP1
BCF STATUS, RP0 ;*do
BSF STATUS, RP1 ;*
BSF STATUS, RP0
;Realiza a escrita
end
BCF 0x03, 0x6
BCF 0x03, 0x5
MOVF 0x21, 0x0
BSF 0x03, 0x6
BCF 0x03, 0x5
MOVWF 0x0D
BCF 0x03, 0x6
BCF 0x03, 0x5
MOVF 0x20, 0x0
BSF 0x03, 0x6
BCF 0x03, 0x5
MOVWF 0x0C
BSF 0x03, 0x6
BSF 0x03, 0x5
BCF 0x0C, 0x7
BSF 0x0C, 0x2
MOVLW 0x55
MOVWF 0x0D
MOVLW 0xAA
MOVWF 0x0D
BSF 0x0C, 0x1

09/05/2016
19
MPLAB® SIM1
BSF STATUS, RP1
BSF STATUS, RP0
BCF EECON1, EEPGD
BSF EECON1, WREN
MOVLW 0x55
MOVWF EECON2
MOVLW 0xAA
MOVWF EECON2
BSF EECON1, WR
BCF EECON1, WREN
10909/05/2016
Não
interromper
• O acréscimo de um comando
qualquer (mesmo NOP) nos três
pontos mostrados impede a gravação.
• É preciso usar uma proteção contra
interrupção.
EEPROM – Escrita – Proteção contra interrup.
MPLAB® SIM1
11009/05/2016
Proteção
contra
interrupção
BCF INTCON, GIE
XXXXXXXXX
BSF INTCON, GIE
Área
protegida
Desabilita
interrupção
Reabilita
interrupção
INTCON: Interrupt Control register
GIE: Global Interrupt Enable bit
EEPROM – Escrita – Proteção contra interrup.
MPLAB® SIM1
11109/05/2016
• Como o tempo de gravação de uma palavra
na EEPROM pode ser maior do que o ciclo
de instrução, a execução do programa
prossegue enquanto a palavra é gravada.
• Ao iniciar uma gravação, deve-se verificar
que a EEPROM não se encontra em um outro
processo de gravação iniciado anteriormente.
EEPROM – Escrita – Verificação do estado
MPLAB® SIM1
11209/05/2016
;Verifica se está em processo de escrita
BSF STATUS, RP1
BSF STATUS, RP0
BTFSC EECON1, WR ;Se o bit WR de EECON1 for 0, pular a próxima linha
GOTO $-1 ;Retorna à linha anterior até que a escrita tenha terminado
• BTFSC EECON1, WR :
• Verifica se WR=0 ou WR=0.
• Se for 0, isto é, a EEPROM não está sendo gravada, pula a
instrução seguinte e prossegue com a execução.
• Se for 1, isto é, a EEPROM está em gravação, executa a
instrução seguinte.
• O programa fica paralisado até o término da escrita.
• Esta verificação somente é necessária se, anteriormente a
uma leitura ou escrita, foi feita uma escrita na EEPROM.
EEPROM – Escrita – Verificação do estado
MPLAB® SIM1
; Programa 57 – EEPROM – Proteções
org 0x5
constant ondecadê1 = 0x20 ;Endereço do GPR (7 bits) que contém o dado para a EEPROM (8 bits)
;Verifica se está em processo de escrita
BSF STATUS, RP1 ;
BSF STATUS, RP0 ;Banco 3
;Escreve
BCF STATUS, RP1 ;
BCF STATUS, RP0 ;Banco 0
MOVF ondecadê2, W ;W = SRAM(ondecadê2), endereço para gravação
MOVWF EEADR ;EEADR = W
BCF STATUS, RP1 ;Banco 0
MOVF ondecadê1, W ;W = SRAM(ondecadê1), dado para gravação
MOVWF EEDATA ;EEDATA = W
BCF INTCON, GIE ;Desabilita interrupções, caso use interrupção
MOVWF EECON2 ;EECON2 = W
BSF INTCON, GIE ;Habilita interrupções, caso use interrupção
end 11309/05/2016
57 – EEPROM – Proteções
Proteçãocontrainterrupção
BSF 0x03, 0x6
BSF 0x03, 0x5
BTFSC 0x0C, 0x1
GOTO 0x07
BCF 0x03, 0x6
BCF 0x03, 0x5
MOVF 0x21, 0x0
BSF 0x03, 0x6
MOVWF 0x0d
BCF 0x03, 0x6
MOVF 0x20, 0x0
BSF 0x03, 0x6
MOVWF 0x0C
BSF 0x03, 0x5
BCF 0x0C, 0x7
BSF 0x0C, 0x2
BCF 0x0B, 0x7
MOVLW 0x55
MOVWF 0x0D
MOVLW 0xAA
MOVWF 0x0D
BSF 0x0C, 0x1
BSF 0x0B, 0x7
BCF 0x0C, 0x2
MPLAB® SIM1
11409/05/2016
58 – EEPROM – Procedimentos múltiplos
• Vamos escrever a palavra “Marco” na SRAM.
• Depois, copiaremos esta palavra da SRAM
para a EEPROM.
• Depois, copiaremos esta palavra da
EEPROM para um outro local da SRAM.

09/05/2016
20
MPLAB® SIM1
11509/05/2016
Caractere ASCII
M 4Dh
a 61h
r 72h
c 63h
o 6Fh
American Standard Code for Information Interchange
MPLAB® SIM1
11609/05/2016
; Programa 57 – EEPROM – Procedimentos múltiplos
org 0x5
constant ondecadê1 = 0x11 ;endereço M origem
constant ondecadê2 = 0x12 ;endereço a origem
constant ondecadê3 = 0x13 ;endereço r origem
constant ondecadê4 = 0x14 ;endereço c origem
constant ondecadê5 = 0x15 ;endereço o origem
constant ondecadê6 = 0x16 ;endereço M destino
constant ondecadê7 = 0x17 ;endereço a destino
constant ondecadê8 = 0x18 ;endereço r destino
constant ondecadê9 = 0x19 ;endereço c destino
constant ondecadêA = 0x1a ;endereço o destino
constant ondeEEP1 = 0x01 ;endereço M na EEPROM
constant ondeEEP2 = 0x02 ;endereço a na EEPROM
constant ondeEEP3 = 0x03 ;endereço r na EEPROM
constant ondeEEP4 = 0x04 ;endereço c na EEPROM
constant ondeEEP5 = 0x05 ;endereço o na EEPROM
constant letraM = 0x4d ;dado para M
constant letraa = 0x61 ;dado para a
constant letrar = 0x72 ;dado para r
constant letrac = 0x63 ;dado para c
constant letrao = 0x6f ;dado para o
Parte 1: Declaração das constantes.
MPLAB® SIM1
11709/05/2016
;escreve "Marco" na SRAM
BSF STATUS,RP1
BCF STATUS,RP0
MOVLW letraM
MOVWF ondecadê1
MOVLW letraa
MOVWF ondecadê2
MOVLW letrar
MOVWF ondecadê3
MOVLW letrac
MOVWF ondecadê4
MOVLW letrao
MOVWF ondecadê5
Parte 2: Gravação dos registros.
111 0x4D
112 0x61
113 0x72
114 0x63
115 0x6F
MPLAB® SIM1
Parte 3: Cópia para a EEPROM.
11809/05/2016
M
a
r
c
o
BSF STATUS ,RP0
BCF EECON1 ,EEPGD
BSF EECON1 ,WREN
CALL EsperaEE
MOVLW ondeEEP1
MOVWF EEADR
MOVF ondecadê1,W
CALL EscreveEE
CALL EsperaEE
MOVLW ondeEEP2
MOVWF EEADR
MOVF ondecadê2,W
CALL EscreveEE
CALL EsperaEE
MOVLW ondeEEP3
MOVWF EEADR
MOVF ondecadê3,W
CALL EscreveEE
CALL EsperaEE
MOVLW ondeEEP4
MOVWF EEADR
MOVF ondecadê4,W
CALL EscreveEE
CALL EsperaEE
MOVLW ondeEEP5
MOVWF EEADR
MOVF ondecadê5,W
CALL EscreveEE
BCF EECON1, WREN
MPLAB® SIM1
Parte 3: Cópia para a EEPROM.
11909/05/2016
MPLAB® SIM1
Parte 4: Cópia para a SRAM.
12009/05/2016
MOVLW ondeEEP1
CALL EscreveSRAM
MOVWF ondecadê6
MOVLW ondeEEP2
CALL EscreveSRAM
MOVWF ondecadê7
MOVLW ondeEEP3
CALL EscreveSRAM
MOVWF ondecadê8
MOVLW ondeEEP4
CALL EscreveSRAM
MOVWF ondecadê9
MOVLW ondeEEP5
CALL EscreveSRAM
MOVWF ondecadêA
GOTO Fim
M
a
r
c
o
116 0x4D
117 0x61
118 0x72
119 0x63
11A 0x6F

09/05/2016
21
MPLAB® SIM1
Parte 5: Sub-rotinas
12109/05/2016
EsperaEE
BTFSC EECON1 ,WR
GOTO $-1
BCF STATUS ,RP0
RETURN
EscreveEE
MOVWF EEDATA
BSF STATUS ,RP0
MOVLW 0x55
MOVWF EECON2
MOVLW 0xaa
MOVWF EECON2
BSF EECON1 ,WR
RETURN
EscreveSRAM
BCF STATUS ,RP0
MOVWF EEADR
BSF STATUS ,RP0
BSF EECON1 ,RD
BCF STATUS ,RP0
MOVF EEDATA ,W
RETURN
end
MPLAB® SIM1
111 0x4D
112 0x61
113 0x72
114 0x63
115 0x6F
116 0x4D
117 0x61
118 0x72
119 0x63
11A 0x6F
Parte 6: Finalização.
12209/05/2016
MPLAB® SIM1
12309/05/2016
BSF 0x03, 0x6
BCF 0x03, 0x5
MOVLW 0x4D
MOVWF 0x11
MOVLW 0x61
MOVWF 0x12
MOVLW 0x72
MOVWF 0x13
MOVLW 0x63
MOVWF 0x14
MOVLW 0x6f
MOVWF 0x15
BSF 0x03, 0x5
BCF 0x0C, 0x7
BSF 0x0C, 0x2
BCF 0x0C, 0x2
MOVLW 0x01
CALL 0x049
MOVWF 0x16
MOVLW 0x02
CALL 0x049
MOVWF 0x17
MOVLW 0x03
CALL 0x049
MOVWF 0x18
MOVLW 0x04
CALL 0x049
MOVWF 0x19
MOVLW 0x05
CALL 0x049
MOVWF 0x1A
GOTO 0x051
BTFSC 0x0C, 0x1
GOTO 0x3D
BCF 0x03, 0x5
RETURN
MOVWF 0x0C
BSF 0x03, 0x5
MOVLW 0x55
MOVWF 0x0D
MOVLW 0xaA
MOVWF 0x0D
BSF 0x0C, 0x1
RETURN
BCF 0x03, 0x5
MOVWF 0x0D
BSF 0x03, 0x5
BSF 0x0C, 0x0
BCF 0x03, 0x5
MOVF 0x0C, 0x0
RETURN
CALL 0x03D
MOVLW 0x01
MOVWF 0x0D
MOVF 0x11, 0x0
CALL 0x041
CALL 0x03D
MOVLW 0x02
MOVWF 0x0D
MOVF 0x12, 0x0
CALL 0x041
CALL 0x03D
MOVLW 0x03
MOVWF 0x0D
MOVF 0x13, 0x0
CALL 0x041
CALL 0x03D
MOVLW 0x04
MOVWF 0x0D
MOVF 0x14, 0x0
CALL 0x041
CALL 0x03D
MOVLW 0x05
MOVWF 0x0D
MOVF 0x15, 0x0
CALL 0x041
MPLAB® SIM1
12409/05/2016
59,60 – FLASH – Leitura
• As versões antigas do código apresentaram erro.
• Elas foram desenvolvidas em um computador
antigo e, nele, funcionavam perfeitamente.
• Provavelmente existe uma falha no temporizador do
MPLAB® de modo que a performance do
computador está interferindo na simulação da
temporização do chip real.
• O problema foi solucionado adicionando-se a rotina
para aguardar o término do processo de leitura.
BTFSC EECON1,RD
GOTO $-1
MPLAB® SIM1
12509/05/2016
59 – FLASH – Leitura em posição baixa
; Universidade Federal de São João del-Rei
; Prof. Marco Aurélio Seluque Fregonezi
; Programa 59 – FLASH – Leitura indireta em posição baixa
org 0x5
constant ondecadê1 = 0x0b ;endereço LOW da FLASH
constant ondecadê2 = 0x22 ;GPR L
constant ondecadê3 = 0x23 ;GPR H
; Busca o endereço da posição da FLASH a ser lida
BSF STATUS,RP1
BCF STATUS,RP0 ;*
MOVLW ondecadê1
CLRF EEADRH ;SRAM(EEADRH) = 0
; Faz a leitura da FLASH(ondecadê1)
BSF STATUS,RP0 ;Banco 3
BSF EECON1,EEPGD ;Configura para FLASH
; Copia para a SRAM(ondecadê2 e ondecadê3)
BTFSC EECON1,RD
GOTO $-1
BCF STATUS,RP0
MOVF EEDATH,W
MOVWF ondecadê2 ;Banco 2, 122h
MOVF EEDATA,W
end
0005 1703 BSF 0x03, 0x6
0006 1283 BCF 0x03, 0x5
0007 300B MOVLW 0x0b
0008 008D MOVWF 0x0d
0009 018F CLRF 0x0f
000A 1683 BSF 0x03, 0x5
000B 178C BSF 0x0c, 0x7
000C 140C BSF 0x0c, 0x0
000D 180C BTFSC 0x0c, 0x0
000E 280D GOTO 0x00d
000F 1283 BCF 0x03, 0x5
0010 080E MOVF 0x0e, 0x0
0011 00A2 MOVWF 0x22
0012 080C MOVF 0x0c, 0x0
0013 00A3 MOVWF 0x23
122 0x17
123 0x8C
Banco 2
MPLAB® SIM1
0005 1703 BSF 0x03, 0x6
0006 1283 BCF 0x03, 0x5
0009 018F CLRF 0x0f
000A 1683 BSF 0x03, 0x5
000B 178C BSF 0x0c, 0x7
000C 140C BSF 0x0c, 0x0
000F 1283 BCF 0x03, 0x5
0010 080E MOVF 0x0e, 0x0
0011 00A2 MOVWF 0x22
0012 080C MOVF 0x0c, 0x0
0013 00A3 MOVWF 0x23
12609/05/2016
59 – FLASH – Leitura em posição baixa

09/05/2016
22
MPLAB® SIM1
12709/05/2016
60 – FLASH – Leitura em posição alta
; Programa 60 – FLASH – Leitura indireta em posição alta
org 0x5
constant ondecadê1 = 0x1b ;endereço H da FLASH
constant ondecadê2 = 0x68 ;endereço L da FLASH
constant ondecadê3 = 0x23 ;endereço H da SRAM
constant ondecadê4 = 0x24 ;endereço L da SRAM
; Busca o endereço da posição da FLASH a ser lida
BSF STATUS,RP1
MOVLW ondecadê1
MOVWF EEADRH ;SRAM(EEADRH) = W
MOVLW ondecadê2
; Faz a leitura da FLASH(ondecadê1 e ondecadê2)
BSF STATUS,RP0
BSF EECON1,EEPGD ;Configura para FLASH
; Copia para a SRAM(ondecadê3 e ondecadê4)
BTFSC EECON1,RD
GOTO $-1
BCF STATUS,RP0
MOVF EEDATH,W
MOVF EEDATA,W
end
0005 1703 BSF 0x03, 0x6
0007 008F MOVWF 0x0f
0008 3068 MOVLW 0x68
000A 1683 BSF 0x03, 0x5
000B 178C BSF 0x0c, 0x7
000C 140C BSF 0x0c, 0x0
000F 1283 BCF 0x03, 0x5
0010 080E MOVF 0x0e, 0x0
0011 00A3 MOVWF 0x23
0012 080C MOVF 0x0c, 0x0
0013 00A4 MOVWF 0x24
MPLAB® SIM1
123 0x21
124 0x30
1B67 3FFF
1B68 3021 MOVLW 0x21
1B69 3FFF
12809/05/2016
Digitar
60 – FLASH – Leitura em posição alta
Banco 2
MPLAB® SIM1
12909/05/2016
61 – FLASH – Escrita
; Programa 61
org 0x5
;Escreve
BCF STATUS, RP0
MOVLW 0x20 ;endereço L para gravação
MOVWF EEADR ;EEADR = W
MOVLW 0x00 ;endereço H para gravação
MOVWF EEADRH ;EEADRH = W
MOVLW 0x10 ;dado L para gravação
MOVWF EEDATA ;EEDATA = W
MOVLW 0x30 ;dado H para gravação
MOVWF EEDATH ;EEDATA = W
BSF EECON1, EEPGD ;Configura para FLASH
BCF INTCON, GIE ;Desabilita interrupções, caso use interrupção
BSF INTCON, GIE ;Habilita interrupções, caso use interrupção
end
0005 1283 BCF 0x03, 0x5
0006 1703 BSF 0x03, 0x6
0007 3020 MOVLW 0x20
0009 3000 MOVLW 0x00
000A 008F MOVWF 0x0f
000B 3010 MOVLW 0x10
000C 008C MOVWF 0x0c
000D 3030 MOVLW 0x30
000E 008E MOVWF 0x0e
000F 1683 BSF 0x03, 0x5
0010 178C BSF 0x0c, 0x7
0011 150C BSF 0x0c, 0x2
0012 138B BCF 0x0b, 0x7
0013 3055 MOVLW 0x55
0015 30AA MOVLW 0xaa
0017 148C BSF 0x0c, 0x1
0018 188C BTFSC 0x0c, 0x1
0019 2818 GOTO 0x018
001A 178B BSF 0x0b, 0x7
001B 110C BCF 0x0c, 0x2
MPLAB® SIM1
13009/05/2016
61 – FLASH – Escrita
• Este programa de escrita não pode ser testado
por meio do MPLAB® porque a program
memory do MPLAB® SIM não exibe alterações
no decorrer da execução do programa.
• Alterando o bit EEPGD para zero a gravação é
realizada na EEPROM, o que demonstra que o
programa está correto.
MPLAB® SIM1
; Programa 62 - ORG's múltiplos
org 0x5
MOVLW 0xaa
MOVWF 0x2a
MOVLW 0xaa+1
MOVWF 0x2a+1
org 0xf
MOVLW 0xbb
MOVWF 0x3a
MOVLW 0xbb+1
MOVWF 0x3a+1
end
13109/05/2016
62 – ORG’s múltiplos
0000 3FFF
0001 3FFF
0002 3FFF
0003 3FFF
0004 3FFF
0007 30AB MOVLW 0xAB
0009 3FFF
000A 3FFF
000B 3FFF
000C 3FFF
000D 3FFF
000E 3FFF
000F 30BB MOVLW 0xBB
0010 00BA MOVWF 0x3A
0011 30BC MOVLW 0xBC
0012 00BB MOVWF 0x3B
0013 3FFF
0014 3FFF
0015 3FFF
MPLAB® SIM1
0000 3FFF
0001 3FFF
0002 3FFF
0003 3FFF
0004 3FFF
0007 30AB MOVLW 0xAB
0009 3FFF
000A 3FFF
000B 3FFF
000C 3FFF
000D 3FFF
000E 3FFF
000F 30BB MOVLW 0xBB
0013 3FFF
0014 3FFF
0015 3FFF
13209/05/2016
62 – ORG’s múltiplos
• 3FFFh ADDLW 0xFF
• Esta operação subtrai 1 do W.
• É preciso tomar cuidado ao
deixar espaços vazios
ocupados com 3FFFh.
• É preciso considerar esses
espaços na determinação do
endereço real de rótulos da
flash.

09/05/2016
23
MPLAB® SIM1
13309/05/2016
63 – Uso do reset vector
; Programa 63 – Reset vector
org 0x0 ;pode ser removido
GOTO 0x5 ;pula o interrupt vector
org 0x5
MOVLW 0xbb
MOVWF 0x3a
MOVLW 0xbb+1
MOVWF 0x3a+1
end
Reset vector
Interrupt vector
0000 2805 GOTO 0x005
0001 3FFF
0002 3FFF
0003 3FFF
0004 3FFF
0005 30BB MOVLW 0xBB
MPLAB® SIM1
13409/05/2016
64 – Uso do interrupt vector
; Programa 63 – Interrupt vector
org 0x0
GOTO Início
org 0x4
GOTO RotinaInterrupção
org 0x5
Início
MOVLW 0xbb
MOVWF 0x3a
MOVLW 0xbb+1
MOVWF 0x3a+1
GOTO Fim
org 0x20
RotinaInterrupção
MOVLW 0xcc
MOVWF 0x3c
MOVLW 0xcc+1
MOVWF 0x3c+1
RETFIE
Fim
end
MPLAB® SIM1
13509/05/2016
65 – Bits de configuração
; Programa 64 – Bits de configuração
__config _WDT_OFF & _XT_OSC & _LVP_OFF
end
Apenas a configuração requerida pelo kit didático
• Todos os programas para o kit didático
devem possuir esta configuração.
• O WDT deve ser desligado a fim de
simplificar as atividades práticas.
• O oscilador deve ser XT porque essa é a
opção implementada em hardware.
• O LVP deve ser desligado.
• A não configuração do XT e do LVP gera erro
no momento da execução por meio do ICD2.
MPLAB® SIM1
13609/05/2016
Ajuste das mensagens de aviso
;-----Bank2------------------
EEDATA EQU H'010C'
EEADR EQU H'010D'
EEDATH EQU H'010E'
EEADRH EQU H'010F'
;-----Bank3------------------
EECON1 EQU H'018C'
EECON2 EQU H'018D'
;-----Bank2------------------
EEDATA EQU H'000C'
EEADR EQU H'000D'
EEDATH EQU H'000E'
EEADRH EQU H'000F'
;-----Bank3------------------
EECON1 EQU H'000C'
EECON2 EQU H'000D'
Alterar o arquivo p16f877.inc
Antes
Depois
MPLAB® SIM1
13709/05/2016
Ajuste das mensagens de aviso
Alterar o arquivo p16f877.inc
• Mesmo programando corretamente, a seguinte
mensagem de erro continua aparecendo:
• Message[302] H:2013_2ASSEMBLERAULAS59.ASM 24 : Register
in operand not in bank 0. Ensure that bank bits are correct.
• Isso acontece porque o arquivo “p16f877.inc”
apresenta os endereços dos SFR’s com 9 bits, porém
o endereçamento direto requer 7 bits.
• Para resolver esse problema, basta alterar todos os
endereços dos bancos 1, 2 e 3 para o seu respectivo
endereço no banco 0.
MPLAB® SIM1
13809/05/2016
• Montagem de opcode.
• Desmontagem de opcode.
• Geração do código disassembly a partir do código
MPASM.
• Determinação de valores da SRAM ou W a partir da
inspeção do programa.
• Determinação dos endereços dos opcodes.
• Determinação do argumento real para CALL e GOTO.
• Determinação dos valores da pilha.
• Identificação de stack overflow e stack underflow.
• Identificação de instruções que podem ser removidas.
• Identificação de endereços na EEPROM e na FLASH.
• Identificação de erros.
É preciso saber fazer:

09/05/2016
24
DISPLAY DE 7 SEGMENTOS2
DISPLAY DE 7 SEGMENTOS
13909/05/2016
Ciclo da automação industrial
14009/05/2016
Comandos
(Teclado)
Monitoração
(Display)
Entrada
proveniente do sensor
(Conversor A/D)
Saída
para o atuador
(PWM)
Controle
Configuração do kit didático
• J1: Para baixo
• J2: Para baixo
• J3: Para baixo
• J4: Para cima
• CH1: Para baixo
• CH2: Para baixo
• CH3: Para baixo
• CH4: Para cima
• CH5: Para baixo
• CH6: Para cima
14109/05/2016
Acionamento
14209/05/2016
RE<2:0>
RA<5>
Acionamento
8
7
6
5
4
3 2
1
14309/05/2016
RD<7:0>
Acionamento
• Posição A: LED’s
• Posição B: Display 7-seg.
• 8 bits de saída.
• Pode acionar os 8 LED’s <L7:L0>.
• Pode acionar os 8 LED’s do display.
14409/05/2016

09/05/2016
25
Acionamento
Ch4
Apostila Datapool PIC-2377
14509/05/2016
Funcionamento
• O sinal deve ser multiplexado.
• A multiplexação é feita por RE<2:0> e RA<5>.
• PORTD<7:0> controla o display (8 diodos).
• Os 4 displays são controlados por PORTD<7:0>.
• Somente um display pode ser controlado por vez.
• São 12 bits de controle:
• RD<7:0> , RE<2:0> , RA<5>
• Todos bits são ativos em nível baixo.
14609/05/2016
Funcionamento
• PORTD<7:0> está sempre ligada aos 4 displays.
• Se todos estiverem ligados, todos receberão o
mesmo valor.
• Para que recebam valores diferentes, devem ser
multiplexados.
• Na multiplexação (temporal), os displays ficam
piscando a uma frequência imperceptível.
• Esta multiplexação provoca uma leve perda na
luminosidade.
14709/05/2016
Multiplexação por display
t
tt
t
14809/05/2016
• São quatro palavras de sete bits.
• O ponto não é usado.
• São sete palavras de quatro bits.
• Quanto maior for o número de etapas de
multiplexação, maior é a redução do
número de bits envolvidos.
• Quanto maior for o número de LED’s
acionados individualmente por multiplexa-
ção, maior é a perda de luminosidade.
• Quanto maior for o número de etapas de
multiplexação, maior é o indesejável
efeito de cintilação.
Multiplexação por segmento
14909/05/2016
Multiplexação
Sel1
8-bit
14
DEMUX
A0
A7
B0
B7
C0
C7
D0
D7
Sel0
15009/05/2016

09/05/2016
26
Multiplexação
15109/05/2016
• Os mesmos programas construídos para acionar display’s
por multiplexação temporal podem ser empregados no
acionamento de motor de passo.
• Ao invés de selecionar o display, seleciona-se a bobina do
motor.
• A diferença é que motor de passo permite o acionamento de
mais de uma bobina por vez, permitindo passos fracionados.
Seleção de display
Display RA5 RE2 RE1 RE0
DPY1 1 1 1 0
DPY2 1 1 0 1
DPY3 1 0 1 1
DPY4 0 1 1 1
15209/05/2016
• É possível acionar mais de um display ao mesmo
tempo, mas, como não há memória, todos os
displays acionados apresentam o mesmo valor.
• A escolha pela lógica negativa foi feita pelo fabricante
do kit didático e nada tem a ver com a PIC®.
4-bit ring
counter
Sel1
8-bit
14
DEMUX
Sel0
24
ENC
RE0
RE1
RE2
RA5
Multiplexação
clk
15309/05/2016
A0
A7
B0
B7
C0
C7
D0
D7
Seleção de segmento
SEG RD7 RD6 RD5 RD4 RD3 RD2 RD1 RD0
1 1 1 1 1 1 1 1 0
2 1 1 1 1 1 1 0 1
3 1 1 1 1 1 0 1 1
4 1 1 1 1 0 1 1 1
5 1 1 1 0 1 1 1 1
6 1 1 0 1 1 1 1 1
7 1 0 1 1 1 1 1 1
8 0 1 1 1 1 1 1 1
8
7
6
5
4
3 2
1
15409/05/2016
Seleção de segmento
15509/05/2016
• A contagem em anel, a decodificação e a
multiplexação são implementadas em software.
• A escolha pela lógica negativa foi feita pelo
fabricante do kit didático e nada tem a ver com
a arquitetura da PIC®.
• A formação de outros símbolos do display é
obtida por meio da junção das palavras de
seleção de cada segmento por meio da
operação AND.
8
7
6
5
4
3 2
1
Seleção de segmento – Palavras com AND
SEG HEX BIN
1 FE 11111110
2 FD 11111101
3 FB 11111011
4 F7 11110111
5 EF 11101111
6 DF 11011111
7 BF 10111111
8 7F 01111111
15609/05/2016
8
7
6
5
4
3 2
1

09/05/2016
27
Palavras de interesse
Val. HEX BIN
0 03 0000 0011
1 9f 1001 1111
2 25 0010 0101
3 0d 0000 1101
4 99 1001 1001
5 49 0100 1001
6 41 0100 0001
7 1b 0001 1011
8 01 0000 0001
9 09 0000 1001
a 11 0001 0001
b c1 1100 0001
c 63 0110 0011
d 85 1000 0101
e 61 0110 0001
f 71 0111 0001 15709/05/2016
8
7
6
5
4
3 2
1
Criação das constantes
• Não é preciso memorizar os códigos.
• Basta usar estas declarações em todos os programas.
• As chamadas são feitas sobre os nomes das constantes.
15809/05/2016
constant Disp0 = 0x03
constant Disp1 = 0x9f
constant Disp3 = 0x0d
constant Disp7 = 0x1b
constant DispA = 0x11
constant DispB = 0xc1
constant DispC = 0x63
constant DispD = 0x85
constant DispE = 0x61
constant DispF = 0x71
Iniciação das portas
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BSF PORTE,RE0 ; Desabilita Display DPY1
BSF PORTA,RA5 ; Desabilita Display DPY4
BSF STATUS,RP0
CLRF TRISA ; Configura PORTA como saída
CLRF TRISD ; Configura PORTD como saída
CLRF TRISE ; Configura PORTE como saída
MOVLW 0x06 ; Carrega W com o valor 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
15909/05/2016
16009/05/2016
; Programa 66 - Display 7 segmentos – Programa 1
BCF STATUS,RP0
BCF STATUS,RP1
BCF PORTE,RE0 ; Habilita DPY1
BSF PORTE,RE1 ; Desabilita DPY2
BSF PORTA,RA5 ; Desabilita DPY4
BSF STATUS,RP0
MOVLW 0x06 ; Carrega W com 0x06
BCF STATUS,RP0
MOVLW 0x01 ; Carrega "8."
MOVWF PORTD
end
Exemplo 1
Escolher um ou mais
Escolher outros símbolos
Exemplo 2
16109/05/2016
• Este é um contador de 16 passos (0h a Fh).
• Não há manipulação na seleção de display.
• Todos os display’s apresentam o mesmo valor.
Exemplo 2 – programa parte 1
16209/05/2016
constant Disp7 = 0x1b
constant DispA = 0x11
constant DispB = 0xc1
constant DispC = 0x63
constant DispD = 0x85
constant DispE = 0x61
constant DispF = 0x71
Parâmetros iniciais
Escolher outros valores
entre 01h e FFh.
01h: Muito rápido
ffh: Muito lento

09/05/2016
28
16309/05/2016
BCF STATUS,RP0
BCF STATUS,RP1
BCF PORTE,RE0 ; Habilita DPY1
BSF PORTA,RA5 ; Desabilita DPY4
BSF STATUS,RP0
BCF STATUS,RP0
Rotina de iniciação
Escolher um ou mais
rotina
MOVLW Disp0
CALL Espera
MOVLW Disp1
CALL Espera
MOVLW Disp2
CALL Espera
MOVLW Disp3
CALL Espera
MOVLW Disp4
CALL Espera
MOVLW Disp5
CALL Espera
MOVLW Disp6
CALL Espera
MOVLW Disp7
CALL Espera
MOVLW Disp8
CALL Espera
MOVLW Disp9
CALL Espera
MOVLW DispA
CALL Espera
MOVLW DispB
CALL Espera
MOVLW DispC
CALL Espera
MOVLW DispD
CALL Espera
MOVLW DispE
CALL Espera
MOVLW DispF
CALL Espera
GOTO rotina
16409/05/2016
Manipulação dos displays e temporização
Espera
MOVWF PORTD
MOVLW VALOR
MOVWF TEMPOC
MOVLW VALOR
MOVWF TEMPOB
MOVLW VALOR
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-0x1
DECFSZ TEMPOB,F
GOTO $-0x5
DECFSZ TEMPOC,F
GOTO $-0x9
RETURN
end
Exemplo 2
16509/05/2016
• A constante VALOR é usada como parâmetro inicial
para os três GPR´s de contagem.
• Isto significa que, duplicando o valor atribuído à
constante VALOR, a temporização da rotina
Espera é, aproximadamente, multiplicada por oito.
• Este tempo deve ser grande para que o usuário
possa ler os valores apresentados no display.
Exemplo 3
16609/05/2016
• Este programa coloca a palavra “3210” no visor.
• Há seleção de display.
• Há multiplexação temporal.
• A multiplexação pode seguir qualquer ordem.
16709/05/2016
constant VALOR = 0x0f
Parâmetros iniciais
Escolher outros valores
entre 01h e FFh.
01h: Muito rápido
ffh: Muito lento
16809/05/2016
BCF STATUS,RP0
BCF STATUS,RP1
BSF PORTA,RA5 ; Desabilita Display DPY4
BSF STATUS,RP0
BCF STATUS,RP0
Todos os display’s
iniciam
desligados.
Rotina de iniciação

Exemplos de operações PIC

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (19)

Semelhante a Exemplos de operações PIC

Semelhante a Exemplos de operações PIC (20)

Último

Último (20)

Exemplos de operações PIC