microprocessadores - exemplos
TRANSCRIPT
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:\Documentos\marco2.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:\Documentos\marco2.o" is out of date.
Executing: "C:\Program Files\Microchip\MPASM Suite\MPASMWIN.exe" /q /p16F877 "marco2.asm"
/l"marco2.lst" /e"marco2.err" /d__DEBUG=1
Make: The target "E:\Documentos\marco2.cof" is out of date.
Executing: "C:\Program Files\Microchip\MPASM Suite\mplink.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:\Documentos\marco2.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.
• É gerado um código assembly vazio.
• 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
#include <p16f877.inc> ;definição da PIC
constant marqualrélio = 0x20 ;definição da constante
end ;fim
• Este programa emprega um comentário e
quatro diretivas, respectivamente.
• É gerado um código assembly vazio.
• 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
#include <p16f877.inc> ;definição da PIC
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.
• É gerado um código assembly vazio.
• 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
#include <p16f877.inc> ;definição da PIC
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
CLRW ;limpa o acumulador
ADDLW 0xaa ;W = 0xaa + W
MOVWF 0x2a ;SRAM(0x2a) = 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 primeiraslinhas 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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
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
0007 00AA MOVWF 0x2A
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
MOVLW 0xaa ;W = 0xaa
MOVWF 0x2a ;SRAM(0x2a) = W
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
0006 00AA MOVWF 0x2A
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0xaa ;dado
constant ondecadê = 0x2a ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
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
0005 30AA MOVLW 0xAA
0006 00AA MOVWF 0x2A
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 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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0xaa ;dado
constant ondecadê = 0x2a ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
INCF ondecadê,0 ;W = marqualrélio + 1
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
end ;fim
0005 30AA MOVLW 0xAA
0006 00AA MOVWF 0x2A
0007 0A2A INCF 0x2A, 0x0
0008 00AB MOVWF 0x2B
027 0x00
028 0x00
029 0x00
02A 0xAA
02B 0xAB
02C 0x00
02D 0x00
MPLAB® SIM1
; Programa 12 – Operações aritméticas
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0x45 ;dado 1
constant operador = 0xae ;dado 2
constant ondecadê = 0x2a ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
MOVLW marqualrélio ;W = marqualrélio*
ADDLW operador ;W = operador ADD marqualrélio
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
MOVLW marqualrélio ;W = marqualrélio
SUBLW operador ;W = operador SUB marqualrélio
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
INCF ondecadê+3,1 ;SRAM(ondecadê+3) = SRAM(ondecadê+3) + 1
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
DECF ondecadê+4,1 ;SRAM(ondecadê+4) = SRAM(ondecadê+4) – 1
end ;fim
1809/05/2016
12 – Operações aritméticas
Cópia
AdiçãoSubtração
IncrementoDecremento
*Esta linha pode ser removida.
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 0100DEC
45 0100 0101
46 0100 0110INC
12 – Operações aritméticas
0005 3045 MOVLW 0x45
0006 00AA MOVWF 0x2A
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0x45 ;dado 1
constant operador = 0xae ;dado 2
constant ondecadê = 0x2a ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
MOVLW marqualrélio ;W = marqualrélio*
ANDLW operador ;W = operador AND marqualrélio
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
MOVLW marqualrélio ;W = marqualrélio
IORLW operador ;W = operador IOR marqualrélio
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVLW marqualrélio ;W = marqualrélio
XORLW operador ;W = operador XOR marqualrélio
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
COMF ondecadê+4,1 ;SRAM(ondecadê+4) = COM SRAM(ondecadê+4)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
RLF ondecadê+5,1 ;SRAM(ondecadê+5) = RL SRAM(ondecadê+5)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+6 ;SRAM(ondecadê+6) = W
RRF ondecadê+6,1 ;SRAM(ondecadê+6) = RR SRAM(ondecadê+6)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+7 ;SRAM(ondecadê+7) = W
SWAPF ondecadê+7,1 ;SRAM(ondecadê+7) = SWAP SRAM(ondecadê+7)
end ;fim2009/05/2016
13 – Operações lógicas
Cópia
ANDOR
XORCOM
RLRR
SWAP
*Esta linha pode ser removida.
MPLAB® SIM1
AE 1010 1110
45 0100 0101
04 0000 0100
AND
2109/05/2016
13 – Operações lógicas
AE 1010 1110
45 0100 0101
EF 1110 1111
IOR
45 0100 0101
BA 1011 1010COM
AE 1010 1110
45 0100 0101
EB 1110 1011
XOR
145 1 0100 0101
08B 0 1000 1011RL
045 0 0100 0101
022 1 0010 0010RR
45 0100 0101
54 0101 0100SWAP
0005 3045 MOVLW 0x45
0006 00AA MOVWF 0x2A
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
13 – Operações lógicas
145 1 0100 0101
08B 0 1000 1011RL
045 0 0100 0101
022 1 0010 0010RR
• 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)
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0x45 ;dado 1
constant operador = 0xae ;dado 2
constant ondecadê = 0x20 ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
MOVLW marqualrélio ;W = marqualrélio*
ADDLW operador ;W = operador ADD marqualrélio
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
MOVLW marqualrélio ;W = marqualrélio
SUBLW operador ;W = operador SUB marqualrélio
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVLW marqualrélio ;W = marqualrélio
ANDLW operador ;W = operador AND marqualrélio
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
MOVLW marqualrélio ;W = marqualrélio
IORLW operador ;W = operador IOR marqualrélio
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
MOVLW marqualrélio ;W = marqualrélio
XORLW operador ;W = operador XOR marqualrélio
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
end ;fim
2309/05/2016
14 – Operações com literais (LW)
Cópia
ADDSUB
ANDIOR
XOR
Trê
slin
has
por
opera
ção
*Esta linha pode ser removida.
MPLAB® SIM1
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
MOVLW marqualrélio ;W = marqualrélio*
ADDLW operador ;W = operador ADD marqualrélio
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
MOVLW marqualrélio ;W = marqualrélio
SUBLW operador ;W = operador SUB marqualrélio
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVLW marqualrélio ;W = marqualrélio
ANDLW operador ;W = operador AND marqualrélio
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
MOVLW marqualrélio ;W = marqualrélio
IORLW operador ;W = operador IOR marqualrélio
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
MOVLW marqualrélio ;W = marqualrélio
XORLW operador ;W = operador XOR marqualrélio
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0x45 ;dado 1
constant operador = 0xae ;dado 2
constant ondecadê = 0x20 ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
;esta etapa representa ações anteriores quaisquer
MOVLW operador ;W = operador
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
;esta é a etapa que interessa
MOVLW marqualrélio ;W = marqualrélio
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
15 – Operações sobre bytes (WF), d=1
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
000C 00A5 MOVWF 0x25
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
16 – Operações sobre bytes (WF), d=0; Programa 16 - Operações sobre bytes (WF), d=0
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0x45;dado 1
constant operador = 0xae;dado 2
constant ondecadê = 0x20;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
;esta etapa representa ações anteriores quaisquer
MOVLW operador ;W = operador
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
;esta é a etapa que interessa
MOVLW marqualrélio ;W = marqualrélio
ADDWF ondecadê+1,0 ;W = SRAM(ondecadê+1) ADD W
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
MOVLW marqualrélio ;W = marqualrélio
SUBWF ondecadê+2,0 ;W = SRAM(ondecadê+2) SUB W
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVLW marqualrélio ;W = marqualrélio
ANDWF ondecadê+3,0 ;W = SRAM(ondecadê+3) AND W
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
MOVLW marqualrélio ;W = marqualrélio
IORWF ondecadê+4,0 ;W = SRAM(ondecadê+4) IOR W
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
MOVLW marqualrélio ;W = marqualrélio
XORWF ondecadê+5,0 ;W = SRAM(ondecadê+5) XOR W
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
end ;fim
ADD
SUBAND
IORXOR
MPLAB® SIM1
2809/05/2016
16 – Operações sobre bytes (WF), d=0
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
000C 00A5 MOVWF 0x25
000D 3045 MOVLW 0x45
000E 0721 ADDWF 0x21, 0x0
000F 00A1 MOVWF 0x21
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
001B 00A5 MOVWF 0x25
020 0x45
021 0xF3
022 0x69
023 0x04
024 0xEF
025 0xEB
MPLAB® SIM1
2909/05/2016
16 – Operações sobre bytes (WF), d=0
• 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çãod=1 é a recomendada.
MPLAB® SIM1
; Programa 17 - Operações com três entradas literais
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant dado1 = 0x1 ;dado 1
constant dado2 = 0x2 ;dado 2
constant dado3 = 0x4 ;dado 3
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant ondecadê1 = 0x21 ;endereço 1
constant ondecadê2 = 0x22 ;endereço 2
constant ondecadê3 = 0x23 ;endereço 3
constant ondecadê4 = 0x24 ;endereço 4
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0x45 ;dado
constant ondecadê = 0x20 ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
COMF ondecadê+1,1 ;SRAM(ondecadê+1) = COM SRAM(ondecadê+1)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
RLF ondecadê+2,1 ;SRAM(ondecadê+2) = RL SRAM(ondecadê+2)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
RRF ondecadê+3,1 ;SRAM(ondecadê+3) = RR SRAM(ondecadê+3)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
SWAPF ondecadê+4,1 ;SRAM(ondecadê+4) = SWAP SRAM(ondecadê+4)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
INCF ondecadê+5,1 ;SRAM(ondecadê+5) = INC SRAM(ondecadê+5)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+6 ;SRAM(ondecadê+6) = W
DECF ondecadê+6,1 ;SRAM(ondecadê+6) = DEC SRAM(ondecadê+6)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+7 ;SRAM(ondecadê+7) = W
CLRF ondecadê+7 ;SRAM(ondecadê+7) = CLR SRAM(ondecadê+7)
MOFV ondecadê+6,0 ;W = SRAM(ondecadê+6)
MOVWF ondecadê+8 ;SRAM(ondecadê+8) = W
end ;fim 3409/05/2016
19 – Operações de uma entrada
COM
RLRR
SWAPINC
DECCLR
Cópia
*Esta linha pode ser removida.
MPLAB® SIM1
3509/05/2016
19 – Operações de uma entradaMOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
COMF ondecadê+1,1 ;SRAM(ondecadê+1) = COM SRAM(ondecadê+1)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
RLF ondecadê+2,1 ;SRAM(ondecadê+2) = RL SRAM(ondecadê+2)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
RRF ondecadê+3,1 ;SRAM(ondecadê+3) = RR SRAM(ondecadê+3)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
SWAPF ondecadê+4,1 ;SRAM(ondecadê+4) = SWAP SRAM(ondecadê+4)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
INCF ondecadê+5,1 ;SRAM(ondecadê+5) = INC SRAM(ondecadê+5)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+6 ;SRAM(ondecadê+6) = W
DECF ondecadê+6,1 ;SRAM(ondecadê+6) = DEC SRAM(ondecadê+6)
MOVLW marqualrélio ;W = marqualrélio*
MOVWF ondecadê+7 ;SRAM(ondecadê+7) = W
CLRF ondecadê+7 ;SRAM(ondecadê+7) = CLR SRAM(ondecadê+7)
MOFV ondecadê+6,0 ;W = SRAM(ondecadê+6)
MOVWF ondecadê+8 ;SRAM(ondecadê+8) = W
DEC45 0100 0101
44 0100 0100
INC45 0100 0101
46 0100 0110
SWAP45 0100 0101
54 0101 0100
COM45 0100 0101
BA 1011 1010
RL145 1 0100 0101
08B 0 1000 1011
RR045 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
000C 00A3 MOVWF 0x23
000D 0CA3 RRF 0x23, 0x1
000E 3045 MOVLW 0x45
000F 00A4 MOVWF 0x24
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
001B 00A8 MOVWF 0x28
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant ondecadê = 0x20 ;endereço
CLRF ondecadê ;SRAM(ondecadê) = 0x00
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
BSF ondecadê,0 ;SRAM(ondecadê), bit 0 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
BSF ondecadê,1 ;SRAM(ondecadê), bit 1 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
BSF ondecadê,2 ;SRAM(ondecadê), bit 2 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
BSF ondecadê,3 ;SRAM(ondecadê), bit 3 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
BSF ondecadê,4 ;SRAM(ondecadê), bit 4 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+6 ;SRAM(ondecadê+6) = W
BSF ondecadê,7 ;SRAM(ondecadê), bit 7 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+7 ;SRAM(ondecadê+7) = W
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
000A 00A2 MOVWF 0x22
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant ondecadê = 0x20 ;endereço
CLRF ondecadê ;SRAM(ondecadê) = 0x00
COMF ondecadê,1 ;SRAM(ondecadê) = 0xFF
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
BCF ondecadê,0 ;SRAM(ondecadê), bit 0 = 0
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
BCF ondecadê,1 ;SRAM(ondecadê), bit 1 = 0
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
BCF ondecadê,2 ;SRAM(ondecadê), bit 2 = 0
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
BCF ondecadê,3 ;SRAM(ondecadê), bit 3 = 0
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
BCF ondecadê,4 ;SRAM(ondecadê), bit 4 = 0
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+6 ;SRAM(ondecadê+6) = W
BCF ondecadê,7 ;SRAM(ondecadê), bit 7 = 0
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+7 ;SRAM(ondecadê+7) = W
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
000B 00A2 MOVWF 0x22
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
001A 00A7 MOVWF 0x27
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant marqualrélio = 0x45 ;dado
constant ondecadê = 0x20 ;endereço
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê ;SRAM(ondecadê) = W
BCF STATUS,C ;bit C do status register = 0
MOVF STATUS,W ;W = SRAM(STATUS)
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
BSF STATUS,C ;bit C do status register = 1
MOVF STATUS,W ;W = SRAM(STATUS)
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
BCF STATUS,C ;bit C do status register = 0
RLF ondecadê+3,1 ;SRAM(ondecadê+3) = RL SRAM(ondecadê+1)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
BSF STATUS,C ;bit C do status register = 1
RLF ondecadê+4,1 ;SRAM(ondecadê+4) = RL SRAM(ondecadê+1)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
BCF STATUS,C ;bit C do status register = 0
RRF ondecadê+5,1 ;SRAM(ondecadê+5) = RR SRAM(ondecadê+1)
MOVLW marqualrélio ;W = marqualrélio
MOVWF ondecadê+6 ;SRAM(ondecadê+6) = W
BSF STATUS,C ;bit C do status register = 1
RRF ondecadê+6,1 ;SRAM(ondecadê+6) = RR SRAM(ondecadê+1)
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
000C 00A2 MOVWF 0x22
000D 3045 MOVLW 0x45
000E 00A3 MOVWF 0x23
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
001A 00A6 MOVWF 0x26
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, BSFStatus 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
MOVWF 0x21 ;SRAM(0x21) = W
MOVLW 0x45 ;W = 0x45
SUBLW 0xae ;W = 0xAE - 0x45
MOVWF 0x22 ;SRAM(0x22) = W
MOVLW 0xae ;W = 0xAE
SUBLW 0x45 ;W = 0x45 - 0xAE
MOVWF 0x23 ;SRAM(0x23) = W
end ;fim
174 – 69 = 105
256 + (69 – 174) = 151
W = L – WW = 0xAE – 0x45
W = L – WW = 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
MOVLW 0x45 ;W = 0x45
;0x020 = 00 0100000 RP1=0; RP0=0 banco 0
BCF 0x03,0x6
BCF 0x03,0x5
MOVWF 0x20 ;SRAM(0x020) = W
;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
MOVWF 0x20 ;SRAM(0x120) = W
;0x1A0 = 11 0100000 RP1=0; RP0=1 banco 3
BSF 0x03,0x6 ;*
BSF 0x03,0x5
MOVWF 0x20 ;SRAM(0x1A0) = W
end ;fim
*Esta linha pode ser removida.
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
000C 00A0 MOVWF 0x20
Status Register
MPLAB® SIM1
4109/05/2016
25 – Endereçamento dos bancos com rótulos; Programa 25 – Endereçamento dos bancos com rótulos
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant ondecadê = 0x20 ;endereço
MOVLW 0x45 ;W = 0x45
;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
*Esta linha pode ser removida.
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
000B 00A0 MOVWF 0x20
000C 1703 BSF 0x03, 0x6
000D 1283 BCF 0x03, 0x5
000E 00A0 MOVWF 0x20
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
constant ondecadê = 0x7F ;endereço
MOVLW 0x45 ;W = 0x45
BCF STATUS,RP1 ;*
BCF STATUS,RP0 ;*
MOVWF ondecadê ;SRAM(0x07F) = W
MOVWF ondecadê+1 ;SRAM(0x000) = W
end ;fim
*Esta linha pode ser removida.
• 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.
Message[302] ...\endereçamento.ASM 19 : Register in operand not in bank 0. Ensure that bank bits are correct.
Message[302] ...\endereçamento.ASM 24 : 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
000B 00A0 MOVWF 0x20
000C 1703 BSF 0x03, 0x6
000D 1283 BCF 0x03, 0x5
000E 00A0 MOVWF 0x20
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
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
MOVWF FSR ;SRAM(FSR) = W
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
0007 30AA MOVLW 0xAA
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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
BCF STATUS,IRP ;STATUS(IRP) = 0
MOVLW 0x20 ;W = 0x20
MOVWF FSR ;SRAM(FSR) = W
MOVLW 0xbb ;W = 0xBB
MOVWF INDF ;SRAM(INDF) = W
BSF STATUS,IRP ;STATUS(IRP) = 0
MOVLW 0x20 ;W = 0x20
MOVWF FSR ;SRAM(FSR) = W
MOVLW 0xbb ;W = 0xBB
MOVWF INDF ;SRAM(INDF) = W
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 umregistrador 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
#include <p16f877.inc> ;definição da PIC
org 0x5 ;posição inicial
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
MOVF ondecadê1,W ;W = SRAM(ondecadê1)
MOVWF FSR ;SRAM(FSR) = W
MOVF ondecadê2,W ;W = SRAM(ondecadê2)
MOVWF INDF ;SRAM(INDF) = W
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
#include <p16f877.inc> ;definição da PIC
constant ondecadê = 0x20 ;endereço
CLRF ondecadê ;não importa
MOVF ondecadê,0 ;não importa
MOVWF ondecadê+1 ;não importa
BSF ondecadê,2 ;não importa
MOVF ondecadê,0 ;não importa
MOVWF ondecadê+2 ;não importa
GOTO 0x00a ;11 bits
BSF ondecadê,7 ;não importa
MOVF ondecadê,0 ;não importa
MOVWF ondecadê+3 ;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
#include <p16f877.inc> ;definição da PIC
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
000C 00A4 MOVWF 0x24
000D 15A0 BSF 0x20, 0x3
000E 0820 MOVF 0x20, 0x0
000F 00A5 MOVWF 0x25
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
#include <p16f877.inc> ;definição da PIC
constant ondecadê = 0x20 ;endereço
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
000C 00A1 MOVWF 0x21
000D 1420 BSF 0x20, 0x0
000E 0820 MOVF 0x20, 0x0
000F 00A2 MOVWF 0x22
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
001C 00A6 MOVWF 0x26
001D 17A0 BSF 0x20, 0x7
001E 0820 MOVF 0x20, 0x0
001F 00A7 MOVWF 0x27
5509/05/2016
33 – GOTO com rótulo absoluto
Pulado
; Programa 33 - GOTO com rótulo absoluto
#include <p16f877.inc> ;definição da PIC
org 0xa ;alterar
constant ondecadê = 0x20 ;endereço
CLRF ondecadê ;SRAM(ondecadê) = 0x00
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W
BSF ondecadê,0 ;SRAM(ondecadê), bit 0 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+2 ;SRAM(ondecadê+2) = W
BSF ondecadê,1 ;SRAM(ondecadê), bit 1 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+3 ;SRAM(ondecadê+3) = W
GOTO ali ;11 bits
BSF ondecadê,2 ;SRAM(ondecadê), bit 2 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+4 ;SRAM(ondecadê+4) = W
ali
BSF ondecadê,3 ;SRAM(ondecadê), bit 3 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W
BSF ondecadê,4 ;SRAM(ondecadê), bit 4 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+6 ;SRAM(ondecadê+6) = W
BSF ondecadê,7 ;SRAM(ondecadê), bit 7 = 1
MOVF ondecadê,0 ;W = SRAM(ondecadê)
MOVWF ondecadê+7 ;SRAM(ondecadê+7) = W
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 dalinha 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 argumentoda 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çãoGOTO 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
#include <p16f877.inc> ;definição da PIC
org 0xa ;alterar
constant ondecadê = 0x20 ;endereço
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
000C 00A1 MOVWF 0x21
000D 1420 BSF 0x20, 0x0
000E 0820 MOVF 0x20, 0x0
000F 00A2 MOVWF 0x22
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
001C 00A6 MOVWF 0x26
001D 17A0 BSF 0x20, 0x7
001E 0820 MOVF 0x20, 0x0
001F 00A7 MOVWF 0x27
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 entrea 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
#include <p16f877.inc>
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...
CALL RotinaC1 ;executa RotinaC1
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
000C 00A0 MOVWF 0x20
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
000C 00A0 MOVWF 0x20
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
37 – Seleção entre duas sub-rotinas
MPLAB® SIM1
6609/05/2016
37 – Seleção entre duas sub-rotinas
• 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
#include <p16f877.inc>
org 0x5
BCF STATUS,C ;escolher entre BSF e BCF
BTFSS STATUS,C ;se C=0 então...
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
000A 00A0 MOVWF 0x20
000B 01A1 CLRF 0x21
000C 2811 GOTO 0x011
000D 3004 MOVLW 0x04
000E 00A1 MOVWF 0x21
000F 01A0 CLRF 0x20
0010 2811 GOTO 0x011*Esta linha pode ser removida.
MPLAB® SIM1
6909/05/2016
39 – Programa anterior sem o uso de GOTO; Programa 39 - Programa anterior sem o uso de GOTO
#include <p16f877.inc>
org 0x5
CLRF PCLATH ;*
BCF STATUS,C ;escolher entre BSF e BCF
MOVLW 0xc
BTFSS STATUS,C ;se C=0 então...
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*Esta linha pode ser removida.
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
#include <p16f877.inc>
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...
CALL RotinaC1 ;executa RotinaC1
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 é recomendadoo 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, fornecessá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
#include <p16f877.inc>
org 0x5
CALL RotinaC0 ;executa RotinaC1
GOTO Fim
RotinaC0
MOVLW 0x03
MOVWF 0x20
CLRF 0x21
CALL RotinaC1 ;executa RotinaC1
RETURN
RotinaC1
MOVLW 0x04
MOVWF 0x21
CLRF 0x20
RETURN
Fim
end
020 0x03
021 0x04
MPLAB® SIM1Escopo 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 auma 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çõesGOTO e CALL implica na eliminação de PC<12:11>,
levando o PC para um local errado.
MPLAB® SIM1Criaçã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 valendoinicialmente FFh ou um valor inferior.
• A mínima contagem é feita com o GPR valendoinicialmente 01h.
7609/05/2016
Criação de um temporizador
MPLAB® SIM142 – Temporizador com uma variável
7709/05/2016
; Programa 42 - Temporizador com uma variável
#include <p16f877.inc>
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® SIM142 – 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
#include <p16f877.inc>
org 0x5
constant TEMPO = 0x20
constant VALOR = 0x0f ;configurável
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® SIM1Cá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® SIM1Cá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 é (145TCY) + 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 = 15s.
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
constant VALOR = 0x0f ;configurável
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
#include <P16F877.INC>
org 0x5
constant TEMPOA = 0x20
constant TEMPOB = 0x21
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
constant TEMPOA = 0x20
constant TEMPOB = 0x21
constant TEMPOC = 0x22
Na lista de definições:
Rotina “Espera”
Endereços
arbitrários
09/05/2016
15
MPLAB® SIM1
; Programa 46 – Configuração 31h C2h 8Dh
#include <P16F877.INC>
org 0x5
constant VALORA = 0x31 ;configurável
constant VALORB = 0xc2 ;configurável
constant VALORC = 0x28 ;configurável
constant TEMPOA = 0x20
constant TEMPOB = 0x21
constant TEMPOC = 0x22
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
#include <P16F877.INC>
org 0x5
constant VALORA = 0x31
constant VALORB = 0xc2
constant VALORC = 0x8d
constant VALORD = 0xff
constant TEMPOA = 0x20
constant TEMPOB = 0x21
constant TEMPOC = 0x22
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
OutputCORE-W0014: Halted due to PC incrementing over the 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
OutputCORE-W0003: Watchdog Timer event occurred. Break in execution requested
• 3.821.430 passos de contagem.
• Ocorre WDT overflow.
Executar um reset.
MPLAB® SIM1
9009/05/2016
; Programa 50 – Habilitação do WDT
#include <P16F877.INC>
__config _WDT_OFF
org 0x5
constant VALOR = 0xff
constant TEMPO = 0x20
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; Programa 50 – Habilitação do WDT
#include <P16F877.INC>
__config _WDT_ON
org 0x5
constant VALOR = 0xff
constant TEMPO = 0x20
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
CO
RE
-W0003: W
atc
hdog T
imer e
vent o
ccurre
d. B
reak in
exe
cutio
n re
queste
d
CO
RE
-W0
01
4: H
alte
d d
ue
to P
C in
cre
me
ntin
g o
ver th
e M
axim
um
PC
ad
dre
ss a
nd w
rapp
ing
ba
ck to
Ze
ro
09/05/2016
16
MPLAB® SIM1
9109/05/2016
51 – Habilitação do WDT sem #include
; Programa 50 – Habilitação do WDT
#include <P16F877.INC>
__config _WDT_OFF
org 0x5
constant VALOR = 0xff
constant TEMPO = 0x20
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
constant VALOR = 0xff
constant TEMPO = 0x20
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
#include <P16F877.INC>
__config _WDT_ON
org 0x5
constant VALOR = 0x9c
constant TEMPO = 0x20
;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
#include <P16F877.INC>
__config _WDT_ON
org 0x5
constant VALOR = 0x9c
constant TEMPO = 0x20
;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 CO
RE
-W0003: W
atc
hdog T
imer e
vent o
ccurre
d. B
reak in
exe
cutio
n re
queste
d
CO
RE
-W0
01
4: H
alte
d d
ue
to P
C in
cre
me
ntin
g o
ver th
e M
axim
um
PC
ad
dre
ss a
nd w
rapp
ing
ba
ck to
Ze
ro
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
#include <p16f877.inc>
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 ;*
BCF STATUS,RP0 ;Seleciona o banco 2 (10b)
MOVF EEDATA,W ;W = SRAM(EEDATA)
; Copia para a SRAM(ondecadê2)
BCF STATUS,RP1 ;Seleciona o banco 0 (00b)
BCF STATUS,RP0 ;*
MOVWF ondecadê2 ;SRAM(ondecadê2) = W
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
*Esta linha pode ser removida.
MPLAB® SIM1
9509/05/2016
53 – EEPROM – Leitura direta – Testando1 – Escolha o valor para a posição 04Fh da EEPROM.
• O GPR´s 022h recebe
o conteúdo da posição047h da EEPROM.
2 – Execute o programa.
MPLAB® SIM1
9609/05/2016
53 – EEPROM – Leitura direta – TestandoVerificaçã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 naEEPROM (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
54 – EEPROM – Leitura indireta; Programa 54 - EEPROM – Leitura indireta
; Baseado no exemplo 4-1 do datasheet da pic16f877
#include <p16f877.inc>
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 ;Seleciona o banco 0 (00b)
MOVF ondecadê1,W ;W = SRAM(ondecadê1)
BSF STATUS,RP1 ;Seleciona o banco 2 (10b)
BCF STATUS,RP0 ;*
MOVWF EEADR ;SRAM(EEADR) = W
; Faz a leitura da EEPROM(SRAM(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 ;*
BCF STATUS,RP0 ;Seleciona o banco 2 (10b)
MOVF EEDATA,W ;W = SRAM(EEDATA)
; Copia para a SRAM(0x21)
BCF STATUS,RP1 ;Seleciona o banco 0 (00b)
BCF STATUS,RP0 ;*
MOVWF ondecadê2 ;SRAM(ondecadê2) = W
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
*Esta linha pode ser removida.
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
3 – Execute o programa.
• O GPR 021h recebe o conteúdo
da posição da EEPROM indicadapelo conteúdo do registrador 020h.
MPLAB® SIM1
10209/05/2016
54 – EEPROM – Leitura indireta
• Quatro valores estão envolvidos:
• Endereço do GPR que contém o valor do endereçona 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
MOVWF EEADR ;SRAM(EEADR) = W
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
; Baseado no exemplo 4-2 do datasheet da pic16f877
#include <p16f877.inc>
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
MOVWF EEADR ;SRAM(EEADR) = W
MOVLW marqualrélio ;W = marqualrélio
MOVWF EEDATA ;SRAM(EEDATA) = W
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
MOVWF EECON2 ;SRAM(EECON2) = W
BSF EECON1, WR ;Inicia escrita
BCF EECON1, WREN ;Desabilita escrita
end
Escreve
Define endereço
Define dado
Configura
10509/05/2016
55 – EEPROM – Escrita diretaBSF 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
*Esta linha pode ser removida.
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
3 – Execute o programa.
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
; Baseado no exemplo 4-2 do datasheet da pic16f877
#include <p16f877.inc>
org 0x5
constant ondecadê1 = 0x20 ;Endereço do GPR (7 bits) que contém o dado para a EEPROM (8 bits)
constant ondecadê2 = 0x21 ;Endereço do GPR (7 bits) que contém o endereço da 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 ;*
MOVWF EEADR ;SRAM(EEADR) = W
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
MOVWF EEDATA ;SRAM(EEDATA) = W
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
MOVWF EECON2 ;SRAM(EECON2) = W
BSF EECON1, WR ;Inicia escrita
BCF EECON1, WREN ;Desabilita 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
*Esta linha pode ser removida.
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
; Baseado no exemplo 4-2 do datasheet da pic16f877
#include <p16f877.inc>
org 0x5
constant ondecadê1 = 0x20 ;Endereço do GPR (7 bits) que contém o dado para a EEPROM (8 bits)
constant ondecadê2 = 0x21 ;Endereço do GPR (7 bits) que contém o endereço da EEPROM (8 bits)
;Verifica se está em processo de escrita
BSF STATUS, RP1 ;
BSF STATUS, RP0 ;Banco 3
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
;Escreve
BCF STATUS, RP1 ;
BCF STATUS, RP0 ;Banco 0
MOVF ondecadê2, W ;W = SRAM(ondecadê2), endereço para gravação
BSF STATUS, RP1 ;Banco 2
MOVWF EEADR ;EEADR = W
BCF STATUS, RP1 ;Banco 0
MOVF ondecadê1, W ;W = SRAM(ondecadê1), dado para gravação
BSF STATUS, RP1 ;Banco 2
MOVWF EEDATA ;EEDATA = W
BSF STATUS, RP0 ;Banco 3
BCF EECON1, EEPGD ;Configura para EEPROM
BSF EECON1, WREN ;Habilita escrita
BCF INTCON, GIE ;Desabilita interrupções, caso use interrupção
MOVLW 0x55 ;W = 55h - primeira parte do código de escrita
MOVWF EECON2 ;EECON2 = W
MOVLW 0xaa ;W = AAh - segunda parte do código de escrita
MOVWF EECON2 ;EECON2 = W
BSF EECON1, WR ;Inicia escrita
BSF INTCON, GIE ;Habilita interrupções, caso use interrupção
BCF EECON1, WREN ;Desabilita escrita
end 11309/05/2016
57 – EEPROM – Proteções
Pro
teção c
on
tra in
terr
up
çã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
58 – EEPROM – Procedimentos múltiplos
Caractere ASCII
M 4Dh
a 61h
r 72h
c 63h
o 6Fh
American Standard Code for Information Interchange
MPLAB® SIM1
11609/05/2016
58 – EEPROM – Procedimentos múltiplos
; Programa 57 – EEPROM – Procedimentos múltiplos
#include <p16f877.inc>
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
58 – EEPROM – Procedimentos múltiplos
;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
58 – EEPROM – Procedimentos múltiplos
Marco
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
58 – EEPROM – Procedimentos múltiplos
MPLAB® SIM1
Parte 4: Cópia para a SRAM.
12009/05/2016
58 – EEPROM – Procedimentos múltiplos
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
Marco
116 0x4D
117 0x61
118 0x72
119 0x63
11A 0x6F
09/05/2016
21
MPLAB® SIM1
Parte 5: Sub-rotinas
12109/05/2016
58 – EEPROM – Procedimentos múltiplos
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
58 – EEPROM – Procedimentos múltiplos
MPLAB® SIM1
12309/05/2016
58 – EEPROM – Procedimentos múltiplos
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
#include <p16f877.inc>
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
MOVWF EEADR ;SRAM(EEADR) = W
CLRF EEADRH ;SRAM(EEADRH) = 0
; Faz a leitura da FLASH(ondecadê1)
BSF STATUS,RP0 ;Banco 3
BSF EECON1,EEPGD ;Configura para FLASH
BSF EECON1,RD ;Inicia leitura
; 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
MOVWF ondecadê3 ;Banco 2, 123h
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
*Esta linha pode ser removida.
Banco 2
MPLAB® SIM1
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
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; Universidade Federal de São João del-Rei
; Prof. Marco Aurélio Seluque Fregonezi
; Programa 60 – FLASH – Leitura indireta em posição alta
#include <p16f877.inc>
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
MOVWF EEADR ;SRAM(EEADR) = W
; Faz a leitura da FLASH(ondecadê1 e ondecadê2)
BSF STATUS,RP0
BSF EECON1,EEPGD ;Configura para FLASH
BSF EECON1,RD ;Inicia leitura
; Copia para a SRAM(ondecadê3 e ondecadê4)
BTFSC EECON1,RD
GOTO $-1
BCF STATUS,RP0
MOVF EEDATH,W
MOVWF ondecadê3 ;Banco 2, 123h
MOVF EEDATA,W
MOVWF ondecadê4 ;Banco 2, 124h
end
0005 1703 BSF 0x03, 0x6
0006 301B MOVLW 0x1b
0007 008F MOVWF 0x0f
0008 3068 MOVLW 0x68
0009 008D MOVWF 0x0d
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 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
#include <p16f877.inc>
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 STATUS, RP0 ;Banco 3
BSF EECON1, EEPGD ;Configura para FLASH
BSF EECON1, WREN ;Habilita escrita
BCF INTCON, GIE ;Desabilita interrupções, caso use interrupção
MOVLW 0x55 ;W = 55h - primeira parte do código de escrita
MOVWF EECON2 ;EECON2 = W
MOVLW 0xaa ;W = AAh - segunda parte do código de escrita
MOVWF EECON2 ;EECON2 = W
BSF EECON1, WR ;Inicia escrita
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
BSF INTCON, GIE ;Habilita interrupções, caso use interrupção
BCF EECON1, WREN ;Desabilita escrita
end
0005 1283 BCF 0x03, 0x5
0006 1703 BSF 0x03, 0x6
0007 3020 MOVLW 0x20
0008 008D MOVWF 0x0d
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
0014 008D MOVWF 0x0d
0015 30AA MOVLW 0xaa
0016 008D MOVWF 0x0d
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últiplos0000 3FFF
0001 3FFF
0002 3FFF
0003 3FFF
0004 3FFF
0005 30AA MOVLW 0xAA
0006 00AA MOVWF 0x2A
0007 30AB MOVLW 0xAB
0008 00AB MOVWF 0x2B
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
0005 30AA MOVLW 0xAA
0006 00AA MOVWF 0x2A
0007 30AB MOVLW 0xAB
0008 00AB MOVWF 0x2B
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
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 vaziosocupados 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
0006 00BA MOVWF 0x3A
0007 30BC MOVLW 0xBC
0008 00BB MOVWF 0x3B
MPLAB® SIM1
13409/05/2016
64 – Uso do interrupt vector
; Universidade Federal de São João del-Rei
; Prof. Marco Aurélio Seluque Fregonezi
; 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
#include <P16F877.INC>
__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 avisoAlterar o arquivo p16f877.inc
• Mesmo programando corretamente, a seguinte
mensagem de erro continua aparecendo:• Message[302] H:\2013_2\ASSEMBLER\AULAS\59.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
DISPLAY DE 7 SEGMENTOS2Ciclo 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
DISPLAY DE 7 SEGMENTOS2Configuraçã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 cima14109/05/2016
DISPLAY DE 7 SEGMENTOS2Acionamento
14209/05/2016
RE<2:0>
RA<5>
DISPLAY DE 7 SEGMENTOS2Acionamento
8
7
6
5
4
3 2
1
14309/05/2016RD<7:0>
DISPLAY DE 7 SEGMENTOS2Acionamento
• 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
DISPLAY DE 7 SEGMENTOS2Acionamento
Ch4
Apostila Datapool PIC-2377
14509/05/2016
DISPLAY DE 7 SEGMENTOS2Funcionamento
• 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
DISPLAY DE 7 SEGMENTOS2Funcionamento
• 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
DISPLAY DE 7 SEGMENTOS2Multiplexação por display
t
tt
t
14809/05/2016
• São quatro palavras de sete bits.
• O ponto não é usado.
DISPLAY DE 7 SEGMENTOS2
• 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
DISPLAY DE 7 SEGMENTOS2Multiplexação
Sel1
8-bit
14
DEMUX
A0
A7
B0
B7
C0
C7
D0
D7
Sel0
15009/05/2016
09/05/2016
26
DISPLAY DE 7 SEGMENTOS2Multiplexaçã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.
DISPLAY DE 7 SEGMENTOS2Seleçã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®.
DISPLAY DE 7 SEGMENTOS2
4-bit ring
counter
Sel1
8-bit
14
DEMUX
Sel0
24
ENC
RE0
RE1
RE2
RA5
Multiplexação
clk
15309/05/2016
A0
A7
B0
B7
C0
C7
D0
D7
DISPLAY DE 7 SEGMENTOS2Seleçã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
DISPLAY DE 7 SEGMENTOS2Seleçã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
DISPLAY DE 7 SEGMENTOS2Seleçã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
DISPLAY DE 7 SEGMENTOS2Palavras de interesse
Val. HEX BIN0 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 000115709/05/2016
8
7
6
5
4
3 2
1
DISPLAY DE 7 SEGMENTOS2Criaçã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 Disp2 = 0x25
constant Disp3 = 0x0d
constant Disp4 = 0x99
constant Disp5 = 0x49
constant Disp6 = 0x41
constant Disp7 = 0x1b
constant Disp8 = 0x01
constant Disp9 = 0x09
constant DispA = 0x11
constant DispB = 0xc1
constant DispC = 0x63
constant DispD = 0x85
constant DispE = 0x61
constant DispF = 0x71
DISPLAY DE 7 SEGMENTOS2Iniciação das portas
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BSF PORTE,RE0 ; Desabilita Display DPY1
BSF PORTE,RE1 ; Desabilita Display DPY2
BSF PORTE,RE2 ; Desabilita Display DPY3
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
DISPLAY DE 7 SEGMENTOS2
16009/05/2016
; Programa 66 - Display 7 segmentos – Programa 1
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BCF PORTE,RE0 ; Habilita DPY1
BSF PORTE,RE1 ; Desabilita DPY2
BSF PORTE,RE2 ; Desabilita DPY3
BSF PORTA,RA5 ; Desabilita 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 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
MOVLW 0x01 ; Carrega "8."
MOVWF PORTD
end
Exemplo 1
Escolher um ou mais
Escolher outros símbolos
DISPLAY DE 7 SEGMENTOS2Exemplo 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.
DISPLAY DE 7 SEGMENTOS2Exemplo 2 – programa parte 1
16209/05/2016
; Programa 67 - Display 7 segmentos – Programa 2
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant TEMPOA = 0x20
constant TEMPOB = 0x21
constant TEMPOC = 0x22
constant VALOR = 0xff
constant Disp0 = 0x03
constant Disp1 = 0x9f
constant Disp2 = 0x25
constant Disp3 = 0x0d
constant Disp4 = 0x99
constant Disp5 = 0x49
constant Disp6 = 0x41
constant Disp7 = 0x1b
constant Disp8 = 0x01
constant Disp9 = 0x09
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
DISPLAY DE 7 SEGMENTOS2
16309/05/2016
Exemplo 2 – programa parte 2
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BCF PORTE,RE0 ; Habilita DPY1
BSF PORTE,RE1 ; Desabilita DPY2
BSF PORTE,RE2 ; Desabilita DPY3
BSF PORTA,RA5 ; Desabilita 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 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
Rotina de iniciação
Escolher um ou mais
DISPLAY DE 7 SEGMENTOS2Exemplo 2 – programa parte 3
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
DISPLAY DE 7 SEGMENTOS2Exemplo 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.
DISPLAY DE 7 SEGMENTOS2Exemplo 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.
DISPLAY DE 7 SEGMENTOS2Exemplo 3 – programa parte 1
16709/05/2016
; Programa 68 - Display 7 segmentos – Programa 3
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant TEMPOA = 0x20
constant TEMPOB = 0x21
constant TEMPOC = 0x22
constant VALOR = 0x0f
constant Disp0 = 0x03
constant Disp1 = 0x9f
constant Disp2 = 0x25
constant Disp3 = 0x0d
Parâmetros iniciais
Escolher outros valores entre 01h e FFh.01h: Muito rápido
ffh: Muito lento
DISPLAY DE 7 SEGMENTOS2
16809/05/2016
Exemplo 3 – programa parte 2
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BSF PORTE,RE0 ; Desabilita Display DPY1
BSF PORTE,RE1 ; Desabilita Display DPY2
BSF PORTE,RE2 ; Desabilita Display DPY3
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 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
Todos os display’s
iniciam desligados.
Rotina de iniciação
09/05/2016
29
DISPLAY DE 7 SEGMENTOS2Exemplo 3 – programa parte 3
Rotina
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLW Disp0 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTE,RE1 ; Habilita o Display DPY2
MOVLW Disp1 ; Carrega 1
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE1 ; Desabilita Display DPY2
BCF PORTE,RE2 ; Habilita o Display DPY3
MOVLW Disp2 ; Carrega 2
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE2 ; Desabilita Display DPY3
BCF PORTA,RA5 ; Habilita o Display DPY4
MOVLW Disp3 ; Carrega 3
CALL Espera ; Chamada da subrotina Espera
BSF PORTA,RA5 ; Desabilita Display DPY4
GOTO Rotina16909/05/2016
Manipulação dos displays
DISPLAY DE 7 SEGMENTOS2Exemplo 3 – programa parte 4
17009/05/2016
Temporização e encerramento
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
• No exemplo 2, o tempo precisa ser
grande para que o observador possa
identificar os símbolos apresentados.
• No exemplo 3, o tempo precisa ser
pequeno para que o observador não
possa identificar a multiplexação.
• No exemplo 3, poder-se-ia usar,
apenas, uma variável de contagem,
mas, para fins didáticos, foram
usadas três variáveis, para que se
possa aumentar o tempo e observar
a multiplexação.
DISPLAY DE 7 SEGMENTOS2Exemplo 3
t
t
t
t
17109/05/2016
DISPLAY DE 7 SEGMENTOS2Exemplo 3
17209/05/2016
• Diminuindo o tempo de espera entre as escritas, obtém-
se uma frequência tão alta que torne a multiplexação
temporal imperceptível ao usuário.
• O usuário tem a impressão de que os quatro números
estão sempre escritos.
• A rotina Espera poderia ser removida, gerando a máxima
frequência de multiplexação, porém é melhor mantê-la,
pois isso permite a escolha da frequência, idealmente a
menor possível e que seja invisível aos olhos humanos.
• Como o tempo é baixo, é possível remover um ou dois
GPR´s de contagem.
DISPLAY DE 7 SEGMENTOS2Exemplo 4
17309/05/2016
Multiplexação
DISPLAY DE 7 SEGMENTOS2
; Programa 69 - Display 7 segmentos – Programa 4
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant TEMPOA = 0x20
constant TEMPOB = 0x21
constant TEMPOC = 0x22
constant VALOR = 0x0f ; Configurar
constant Disp0 = 0x03
constant Disp1 = 0x9f
constant Disp2 = 0x25
constant Disp3 = 0x0d
constant Disp4 = 0x99
constant Disp5 = 0x49
constant Disp6 = 0x41
constant Disp7 = 0x1b
constant Disp8 = 0x01
constant Disp9 = 0x09
constant DispA = 0x11
constant DispB = 0xc1
constant DispC = 0x63
constant DispD = 0x85
constant DispE = 0x61
constant DispF = 0x71
Exemplo 4 – programa parte 1
17409/05/2016
Parâmetros iniciais e configuração das portas
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BSF PORTE,RE0 ; Desabilita Display DPY1
BSF PORTE,RE1 ; Desabilita Display DPY2
BSF PORTE,RE2 ; Desabilita Display DPY3
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 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
09/05/2016
30
DISPLAY DE 7 SEGMENTOS2
17509/05/2016
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLW Disp8 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTE,RE1 ; Habilita o Display DPY2
MOVLW Disp9 ; Carrega 1
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE1 ; Desabilita Display DPY2
BCF PORTE,RE2 ; Habilita o Display DPY3
MOVLW DispA ; Carrega 2
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE2 ; Desabilita Display DPY3
BCF PORTA,RA5 ; Habilita o Display DPY4
MOVLW DispB ; Carrega 3
CALL Espera ; Chamada da subrotina Espera
BSF PORTA,RA5 ; Desabilita Display DPY4
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLW DispC ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTE,RE1 ; Habilita o Display DPY2
MOVLW DispD ; Carrega 1
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE1 ; Desabilita Display DPY2
BCF PORTE,RE2 ; Habilita o Display DPY3
MOVLW DispE ; Carrega 2
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE2 ; Desabilita Display DPY3
BCF PORTA,RA5 ; Habilita o Display DPY4
MOVLW DispF ; Carrega 3
CALL Espera ; Chamada da subrotina Espera
BSF PORTA,RA5 ; Desabilita Display DPY4
GOTO Rotina ; Retorna ao nome Rotina
Rotina
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLW Disp0 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTE,RE1 ; Habilita o Display DPY2
MOVLW Disp1 ; Carrega 1
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE1 ; Desabilita Display DPY2
BCF PORTE,RE2 ; Habilita o Display DPY3
MOVLW Disp2 ; Carrega 2
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE2 ; Desabilita Display DPY3
BCF PORTA,RA5 ; Habilita o Display DPY4
MOVLW Disp3 ; Carrega 3
CALL Espera ; Chamada da subrotina Espera
BSF PORTA,RA5 ; Desabilita Display DPY4
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLW Disp4 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTE,RE1 ; Habilita o Display DPY2
MOVLW Disp5 ; Carrega 1
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE1 ; Desabilita Display DPY2
BCF PORTE,RE2 ; Habilita o Display DPY3
MOVLW Disp6 ; Carrega 2
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE2 ; Desabilita Display DPY3
BCF PORTA,RA5 ; Habilita o Display DPY4
MOVLW Disp7 ; Carrega 3
CALL Espera ; Chamada da subrotina Espera
BSF PORTA,RA5 ; Desabilita Display DPY4
Exemplo 4 – programa parte 2
DISPLAY DE 7 SEGMENTOS2Exemplo 4 – programa parte 3
17609/05/2016
Temporização e encerramento
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
DISPLAY DE 7 SEGMENTOS2
0D BCF 0x09, 0
0E MOVLW0x03
0F CALL 0x4e
10 BSF 0x09, 0
11 BCF 0x09, 0x1
12 MOVLW0x9f
13 CALL 0x4e
14 BSF 0x09, 0x1
15 BCF 0x09, 0x2
16 MOVLW0x25
17 CALL 0x4e
18 BSF 0x09, 0x2
19 BCF 0x05, 0x5
1A MOVLW0x0d
1B CALL 0x4e
1C BSF 0x05, 0x5
1D BCF 0x09, 0
1E MOVLW0x99
1F CALL 0x4e
20 BSF 0x09, 0
21 BCF 0x09, 0x1
22 MOVLW0x49
23 CALL 0x4e
24 BSF 0x09, 0x1
25 BCF 0x09, 0x2
26 MOVLW0x41
27 CALL 0x4e
28 BSF 0x09, 0x2
29 BCF 0x05, 0x5
2A MOVLW0x1b
2B CALL 0x4e
2C BSF 0x05, 0x5
2D BCF 0x09, 0
2E MOVLW0x01
2F CALL 0x4e
30 BSF 0x09, 0
31 BCF 0x09, 0x1
32 MOVLW0x09
33 CALL 0x4e
34 BSF 0x09, 0x1
35 BCF 0x09, 0x2
36 MOVLW0x11
37 CALL 0x4e
38 BSF 0x09, 0x2
39 BCF 0x05, 0x5
3A MOVLW0xc1
3B CALL 0x4e
3C BSF 0x05, 0x5
3D BCF 0x09, 0
3E MOVLW0x63
3F CALL 0x4e
40 BSF 0x09, 0
41 BCF 0x09, 0x1
42 MOVLW0x85
43 CALL 0x4e
44 BSF 0x09, 0x1
45 BCF 0x09, 0x2
46 MOVLW0x61
47 CALL 0x4e
48 BSF 0x09, 0x2
49 BCF 0x05, 0x5
4A MOVLW0x71
4B CALL 0x4e
4C BSF 0x05, 0x5
Exemplo 4
17709/05/2016
Disassembly00 BCF 0x03, 0x5
01 BCF 0x03, 0x6
02 BSF 0x09, 0
03 BSF 0x09, 0x1
04 BSF 0x09, 0x2
05 BSF 0x05, 0x5
06 BSF 0x03, 0x5
07 CLRF 0x05
08 CLRF 0x08
09 CLRF 0x09
0A MOVLW 0x06
0B MOVWF 0x1f
0C BCF 0x03, 0x5
4D GOTO 0x0d
4E MOVWF 0x08
4F MOVLW 0x0f
50 MOVWF 0x22
51 MOVLW 0x0f
52 MOVWF 0x21
53 MOVLW 0x0f
54 MOVWF 0x20
55 DECFSZ 0x20, 1
56 GOTO 0x55
57 DECFSZ 0x21, 1
58 GOTO 0x53
59 DECFSZ 0x22, 1
5A GOTO 0x51
5B RETURN
DISPLAY DE 7 SEGMENTOS2
• Para que se crie um display com informação
variável no tempo a uma taxa suficientemente
lenta para que seja perceptível ao usuário, é
preciso criar um loop de rotinas ou sub-
rotinas, cada uma delas consistindo de seu
próprio loop multiplexador.
• Pode ser necessário a criação de várias
variáveis de controle de temporização.
17809/05/2016
Exemplo 5
DISPLAY DE 7 SEGMENTOS2Exemplo 5
Etapa 1
Etapa 2
Etapa 3
Etapa 4
t2
17909/05/2016
Multiplexação – nível 1
DISPLAY DE 7 SEGMENTOS2Exemplo 5
Etapa 1 Etapa 2 Etapa 3 Etapa 4
t1
18009/05/2016
09/05/2016
31
DISPLAY DE 7 SEGMENTOS2
• t1: Tempo pequeno, imperceptível ao usuário.
• t2: Tempo grande, perceptível ao usuário.
• t1: Multiplexação temporal dos 4 display’s.
• t2: Multiplexação temporal dos 4 estados do display total.
• t1: Variável Tempo.
• t2: Variáveis TempoD e TempoE.
Exemplo 5
18109/05/2016
DISPLAY DE 7 SEGMENTOS2Exemplo 5 – Programa parte 1
18209/05/2016
; Programa 70 - Display 7 segmentos – Programa 5
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant TEMPO = 0x20
constant TEMPOD = 0x23
constant TEMPOE = 0x24
constant VALOR = 0x0f ; Configurar
constant Disp0 = 0x03
constant Disp1 = 0x9f
constant Disp2 = 0x25
constant Disp3 = 0x0d
constant Disp4 = 0x99
constant Disp5 = 0x49
constant Disp6 = 0x41
constant Disp7 = 0x1b
constant Disp8 = 0x01
constant Disp9 = 0x09
constant DispA = 0x11
constant DispB = 0xc1
constant DispC = 0x63
constant DispD = 0x85
constant DispE = 0x61
constant DispF = 0x71
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BSF PORTE,RE0 ; Desabilita Display DPY1
BSF PORTE,RE1 ; Desabilita Display DPY2
BSF PORTE,RE2 ; Desabilita Display DPY3
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 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
Parâmetros iniciais, rotina de iniciação e temporização
Espera
MOVLW VALOR
MOVWF TEMPO
DECFSZ TEMPO,F
GOTO $-0x1
RETURN
end
DISPLAY DE 7 SEGMENTOS2Exemplo 5 – Temporização da informação
MOVLW 0x07 ; Carrega W
MOVWF TEMPOE ; Carrega TEMPOE com W
Parte1a
MOVLW 0xff ; Carrega W
MOVWF TEMPOD ; Carrega TEMPOD com W
Parte1b
.
.
.
.
DECFSZ TEMPOD,F ; Decrementa TEMPOD e pula 1
GOTO Parte1b ; Retorna
DECFSZ TEMPOE,F ; Decrementa TEMPOE e pula 1
GOTO Parte1a ; Retorna
Manipulação dos display’s
18309/05/2016
DISPLAY DE 7 SEGMENTOS2
18409/05/2016
Exemplo 5 – Etapa 1MOVLW 0x07 ; Carrega W
MOVWF TEMPOE ; Carrega TEMPOE com W
Parte1a
MOVLW 0xff ; Carrega W
MOVWF TEMPOD ; Carrega TEMPOD com W
Parte1b
BCF PORTE,RE0; Habilita o Display DPY1
MOVLW Disp0 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0; Desabilita Display DPY1
BCF PORTE,RE1; Habilita o Display DPY2
MOVLW Disp1 ; Carrega 1
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE1; Desabilita Display DPY2
BCF PORTE,RE2; Habilita o Display DPY3
MOVLW Disp2 ; Carrega 2
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE2; Desabilita Display DPY3
BCF PORTA,RA5; Habilita o Display DPY4
MOVLW Disp3 ; Carrega 3
CALL Espera ; Chamada da subrotina Espera
BSF PORTA,RA5; Desabilita Display DPY4
DECFSZ TEMPOD,F ; Decrementa TEMPOD e pula 1
GOTO Parte1b ; Retorna
DECFSZ TEMPOE,F ; Decrementa TEMPOE e pula 1
GOTO Parte1a ; Retorna
DISPLAY DE 7 SEGMENTOS2
18509/05/2016
Exemplo 5
• Ao invés de empregar as os valores 0x07
e 0xff, é possível usar valores individuais,
para cada uma das quatro etapas.
• Isto significa que algumas etapas pode ser
mais demoradas, e outras podem ser mais
breves.
DISPLAY DE 7 SEGMENTOS2
18609/05/2016
Controle de potência luminosa
• A multiplexação temporal gera uma diminuição da
tensão média ou eficaz sobre o dispositivo luminoso.
• Essa diminuição de tensão leva à diminuição na
potência fornecida (não proporcionalmente), o que leva
a uma diminuição na luminosidade.
• Desta forma, é possível controlar o brilho dos
segmentos dos display’s.
• Esse controle é feito de forma parecida ao PWM.
• A relação percentual em que o segmento fica aceso em
relação ao período de multiplexação é o dutty-cycle.
09/05/2016
32
DISPLAY DE 7 SEGMENTOS2Exemplo 6
18709/05/2016
• Trata-se do exemplo 3 com mais passos de multiplexação.
• DPY1: Dutty-Cycle de 4/7 – 57,14%
• DPY2: Dutty-Cycle de 1/7 – 14,29%
• DPY3: Dutty-Cycle de 1/7 – 14,29%
• DPY4: Dutty-Cycle de 1/7 – 14,29%
DISPLAY DE 7 SEGMENTOS2Exemplo 6
18809/05/2016
DPY1
DPY2
DPY3
DPY4
H
L
H
L
H
L
H
L
t
t
t
t
T
• No PWM, há, somente, uma faixa alta e uma
faixa baixa por período.
• No controle de potência por multiplexação
temporal, é possível fragmentar essas faixas.
• Essa fragmentação reduz o efeito de cintilação.
DISPLAY DE 7 SEGMENTOS2Exemplo 6
18909/05/2016
; Programa 71 - Display 7 segmentos – Programa 6
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant TEMPOA 0x20
constant TEMPOB 0x21
constant TEMPOC 0x22
constant VALOR 0x0f ;configurar
constant Disp0 0x03
constant Disp1 0x9f
constant Disp2 0x25
constant Disp3 0x0d
;Rotina de iniciação
BCF STATUS,RP0
BCF STATUS,RP1
BSF PORTE,RE0 ; Desabilita Display DPY1
BSF PORTE,RE1 ; Desabilita Display DPY2
BSF PORTE,RE2 ; Desabilita Display DPY3
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 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
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
Rotina
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLWDisp0 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTE,RE1 ; Habilita o Display DPY2
MOVLWDisp1 ; Carrega 1
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE1 ; Desabilita Display DPY2
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLWDisp0 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTE,RE2 ; Habilita o Display DPY3
MOVLWDisp2 ; Carrega 2
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE2 ; Desabilita Display DPY3
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLWDisp0 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
BCF PORTA,RA5 ; Habilita o Display DPY4
MOVLWDisp3 ; Carrega 3
CALL Espera ; Chamada da subrotina Espera
BSF PORTA,RA5 ; Desabilita Display DPY4
BCF PORTE,RE0 ; Habilita o Display DPY1
MOVLWDisp0 ; Carrega 0
CALL Espera ; Chamada da subrotina Espera
BSF PORTE,RE0 ; Desabilita Display DPY1
GOTO Rotina
DISPLAY DE 7 SEGMENTOS2Matriz 5x7
19009/05/2016
• 5x7 = 35 segmentos.
• 235 = 34.359.738.368 de combinações.
DISPLAY DE 7 SEGMENTOS2Display 2x16 dígitos
19109/05/2016
• Geralmente o display acompanha um controlador serial.
• Os caracteres ASCII já estão codificados, não é preciso
desenhá-los, basta acessá-los por meio de uma look-up table.
• Os primeiros 32 endereços são para controle.
• Os primeiros 128 endereços são iguais para todos idiomas.
• Os últimos 128 endereços formam a parte estendida e são
específicos para o idioma selecionado.
• Cada modelo de display possui um protocolo para
configuração.
DISPLAY DE 7 SEGMENTOS2Motor de passo
19209/05/2016
Bobina1
Bobina2
Bobina3
Bobina4
H
L
H
L
H
L
H
L
t
t
t
t
T
• A multiplexação periódica pode ser usada na seleção de
outros dispositivos, como, por exemplo, as bobinas de
um motor de passo.
• Trata-se do tipo mais simples e barato de motor elétrico.
1 2 3 4
09/05/2016
33
DISPLAY DE 7 SEGMENTOS2
19309/05/2016
• É possível acionar duas bobinas ao mesmo
tempo para a obtenção de meio passo.
H
L
H
L
H
L
H
L
t
t
t
t
T
Bobina1
Bobina2
Bobina3
Bobina4
Motor de passo
1 2 3 4 5 6 7 8
TECLADO3
TECLADO
19409/05/2016
TECLADO3Configuração do kit didático
• J1: Para baixo
• J2: Para baixo
• J3: Para cima
• J4: Para cima
• CH1: Para baixo
• CH2: Para baixo
• CH3: Para cima (1 a 4)
• CH4: Para cima
• CH5: Para cima (1 a 4)
• CH6: Para baixo19509/05/2016
TECLADO3Teclado 4x4
PORTB
PORTC
1
2
3
4
4
3
2
1
Apostila Datapool PIC-2377
resistores limitadores de correnteSaídas
ativas em 0
Entradas
19609/05/2016
TECLADO3Multiplexação pelas linhas (usaremos)
t
tt
tLinha 1
Linha 2
Linha 3
Linha 4
19709/05/2016
TECLADO3Multiplexação pelas colunas
t
tt
tColuna1
Coluna 2
Coluna 3
Coluna 4
19809/05/2016
09/05/2016
34
TECLADO3Multiplexação total
t t t t t t t t t t t t t t t
t
Opção 1
Opção 2
19909/05/2016
TECLADO3Decodificação da multiplexação total
• Não permite o acionamento de mais de uma tecla por vez.
• Promove grande economia de bits de endereço.
I224
DECI3
24
DEC
I0 I1
4-b
it ring
co
un
ter
I0I1I2I3 20009/05/2016
CLK
TECLADO3Decodificação
20109/05/2016
24
DEC
I3
I4
38
DEC
I0 I1 I25
-bit rin
g
co
un
ter
CLK
I0I1I2I3I4
Teclado 5x4
TECLADO3Exemplo 1 – Configuração da porta B
MOVLW 0x0F
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
Saídasativas em 0
Entradas
TRIS 00 Saída1 Entrada
Entradas
Saídas
20209/05/2016
TECLADO3Exemplo 1
20309/05/2016
L3 L2 L1 L0L3 L2 L1 L0 L3 L2 L1 L0 L3 L2 L1 L0
TECLADO3Exemplo 1
20409/05/2016
; Programa 72 - Teclado – Programa 1
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
BCF STATUS,RP0
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVLW 0xfe
MOVWF PORTC ; Habilita o teclado linha 0 11111110
Rotina
MOVF PORTB,W ; Leitura do teclado
IORLW 0xf0 ; Mascara o nibble mais significativo
MOVWF PORTD ; Indicar as teclas nos LEDs
GOTO Rotina
end
09/05/2016
35
TECLADO3Exemplo 2
20509/05/2016
TECLADO3Exemplo 2 – Parte 1
; Programa 73 - Teclado – Programa 2
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
BCF STATUS,RP0
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVWF PORTC ; Teclado inativo 11111111
20609/05/2016
Igu
al a
o a
nte
rior
TECLADO3
Rotina
BCF PORTC,RC0 ; Habilita o teclado linha 0 11111110
CALL Subrotina
BSF PORTC,RC0 ; Desabilita teclado linha 0
BCF PORTC,RC1 ; Habilita o teclado linha 1 11111101
CALL Subrotina
BSF PORTC,RC1 ; Desabilita teclado linha 1
BCF PORTC,RC2 ; Habilita o teclado linha 2 11111011
CALL Subrotina
BSF PORTC,RC2 ; Desabilita teclado linha 2
BCF PORTC,RC3 ; Habilita o teclado linha 3 11110111
CALL Subrotina
BSF PORTC,RC3 ; Desabilita teclado linha 3
GOTO Rotina
Exemplo 2 – Parte 2
20709/05/2016
Subrotina
MOVF PORTB,W ; Leitura do teclado
IORLW 0xf0 ; Mascara o nibble mais significativo
MOVWF PORTD ; Indicar as teclas nos LEDs
RETURN
end
TECLADO3Exemplo 3
20809/05/2016
TECLADO3
;74 - Teclado – Programa 3
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
BCF STATUS,RP0
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVWF PORTC ; Teclado inativo 11111111
Rotina
constant marqualrélio = 0x20
BCF PORTC,RC0 ; Habilita o teclado linha 0 11111110
MOVF PORTB,W ; Leitura do teclado linha 0
IORLW 0xf0 ; Seta BITs não utilizados 11110000
MOVWF PORTD ; Indicar as teclas nos LEDs
BSF PORTC,RC0 ; Desabilita teclado linha 0
BCF PORTC,RC1 ; Habilita o teclado linha 1 11111101
MOVF PORTB,W ; Leitura do teclado linha 1
IORLW 0xf0 ; Mascara o nibble mais significativo
MOVWF marqualrélio
SWAPF marqualrélio,W ; Inverte os nibbles para os LEDs
MOVWF PORTD ; Indicar as teclas nos LEDs
BSF PORTC,RC1 ; Desabilita teclado linha 1
GOTO Rotina ; Retorna ao nome Rotina
end
20909/05/2016
Exemplo 3
Igu
al a
o a
nte
rior
; Programa 74 - Teclado – Programa 3
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant marqualrélio = 0x20
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
BCF STATUS,RP0
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVWF PORTC ; Teclado inativo 11111111
MOVWF PORTD ; LEDs apagados 11111111
BCF PORTC,RC0 ; Habilita o teclado linha 0 11111110
CLRF marqualrélio
Rotina
CALL Trava
COMF marqualrélio,W ; TOOGLE
MOVWF PORTD
GOTO Rotina
end
TECLADO3
21009/05/2016
Outros exemplos
• Exemplo 4: Implementação da função toogle-switch
usando push-button.
• Exemplo 5: Contador binário de 8 bits.
• Exemplo 6: Contador hexadecimal de 1 nibble.
• Em todos esses exemplos, o sistema possui
memória, é uma máquina de estados finitos, o estado
atual é preservado até que se pressione uma tecla.
• Em sistemas desse tipo, é preciso criar travamentos
de proteção contra transitórios no chaveamento.
09/05/2016
36
TECLADO3
21109/05/2016
Transitórios de alta frequência
t
t
Transitório de subida
Transitório de descida
Desejado
Obtido
TECLADO3
21209/05/2016
Causas dos transitórios
• Quando dois contatos separados se
aproximam, ou dois contatos ligados se
separam, existe a formação de um campo
elétrico.
• Por menor que seja a tensão aplicada, por mais
rápida que seja a mudança de posição dos
contatos, há instantes onde o campo elétrico é
elevadíssimo, suficiente para romper a rigidez
dielétrica do ar, formando um arco voltaico.
• O arco voltaico implica em uma corrente
elétrica de valores aleatórios, gerando uma
tensão nos contatos igualmente aleatória.
TECLADO3
21309/05/2016
Causas dos transitórios
• Quando dois sólidos indeformáveis colidem, surge
uma trepidação, decorrentes da colisão inelástica.
• Esta trepidação forma uma sucessão de pequenas
outras colisões, com intensidades cada vez menores.
• O arco voltaico implica em uma corrente elétrica de
valores aleatórios, gerando uma tensão nos contatos
igualmente aleatória.
• Esta trepidação faz com que o chaveamento elétrico
não forme uma função degrau, há uma oscilação entre
os níveis de tensão nos estados ligado e desligado.
TECLADO3
21409/05/2016
Efeito dos transitórios
• Em circuitos digitais, os transitórios de alta frequência
provocam múltiplos chaveamentos (oscilação
temporária) entre os níveis lógicos zero e um.
• Em circuitos digitais puramente combinacionais, isso
pode não ser um problema.
• Em circuitos digitais sequenciais (máquinas de estados
estáveis finitos), essa oscilação pode provocar múltiplas
transições de estados, um comportamento inadequado.
• Para resolver esse problema, é preciso criar um
temporizador dimensionado para paralisar o sistema por
um tempo superior ao máximo tempo de estabilização.
TECLADO3
21509/05/2016
Proteção contra transitórios de alta frequência
t
t
Desejado
Obtido
t
Temporizador
TECLADO3
21609/05/2016
Efeito toogle
• Toogle switch é toda chave com memória.
• Geralmente são dois estados, mas há chaves com mais
estados.
• Push button (botoeira) é um tipo de chave mais barata e
com maior durabilidade, porém sem memória.
• Transformar um push button em um toogle switch requer
o uso de um flip-flop como elemento de memória (1 bit).
• Em se tratando de MCU, é preciso que o programa aja
como um flip-flop.
• Para agir como memória, o FF precisa ter configuração
mestre-escravo, com sensibilidade à borda positiva ou
negativa do sinal de controle.
09/05/2016
37
TECLADO3
21709/05/2016
Efeito toogle
• A configuração toogle pode ser obtida com FF D e com
FF JK.
• A configuração master-slave realiza dois travamentos:
• Travamento do master: Sensível a um nível do controle.
• Travamento do slave: Sensível a outro nível do controle.
• Este duplo travamento permite o controle por borda.
• O programa deve realizar esse duplo travamento.
TECLADO3
21809/05/2016
Acionamento ao soltar a tecla
Tecla apertada?
Início
Não
Sim
Tecla apertada
Tecla solta?Não
Sim
Rotina
Master
Slave
TECLADO3
21909/05/2016
Tecla apertada?
Início
Não
Sim
Tecla apertada
Tecla solta?Não
Rotina
Espera
Sim
Espera
Opcional
Obrigatório
Acionamento ao soltar a tecla com temporização
TECLADO3
22009/05/2016
Efeito toogle
• Tecla apertada: RB=0
• Tecla solta: RB=1
Apertada
tApertada
0
1Solta
Execução Execução
TECLADO3
09/05/2016 221
Travamentos
Tecla apertada?
Início
NãoRB=1
SimRB=0
Tecla apertada
Tecla solta?
NãoRB=0
SimRB=1
Master
Slave
Apertada
t0
1Solta
Travamento
Master
Apertada
Travamento
Slave
TECLADO3
222
TravaM
BTFSS PORTB,RB0 ; Master
GOTO TravaS ; Master ; Saída
GOTO TravaM ; Master ; Laço
Travamento usando BTFSS
09/05/2016
TravaS
BTFSS PORTB,RB0 ; Slave
GOTO TravaS ; Slave ; Laço
RB=0 ?
Início
Não
Sim
Master
Tecla apertada
RB=1?Não
Sim
Slave
09/05/2016
38
TECLADO3
223
RB=0 ?
Início
Não
Sim
Master
TravaM
BTFSC PORTB,RB0 ; Master
GOTO TravaM ; Master ; Laço
09/05/2016
Tecla apertada
RB=1?Não
Sim
SlaveTravaS
BTFSC PORTB,RB0 ; Slave
GOTO Rotina ; Slave ; Saída
GOTO TravaS ; Slave ; Laço
Travamento usando BTFSC
TECLADO3
224
Trava
BTFSC PORTB,RB0 ; Master
GOTO $-1 ; Master
BTFSS PORTB,RB0 ; Slave
GOTO $-1 ; Slave
09/05/2016
RB=0 ?
Início
Não
Sim
Master
Tecla apertada
RB=1?Não
Sim
Slave
• A execução fica presa nesta rotina até que a tecla seja solta.
• Ao soltar a tecla, o PC vai para o próximo endereço.
A melhor opção de travamento
TECLADO3
22509/05/2016
Travamento com temporização
Trava
BTFSC PORTB,RB0 ; Master
GOTO $-1 ; Master
BTFSS PORTB,RB0 ; Slave
GOTO $-1 ; Slave
MOVLW VALOR
MOVWF TEMPOB
MOVLW VALOR
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-1
DECFSZ TEMPOB,F
GOTO $-5
RB=0 ?
Início
Não
Sim
Master
Tecla apertada
RB=1?Não
Sim
Slave
Espera
TECLADO3
22609/05/2016
Rotina principal
Tecla apertada?
Tecla solta
Não
Sim
Tecla apertada
Tecla solta?Não
Rotina
Sim
Espera
Tecla apertada?
Tecla solta
Não
Sim
Tecla apertada
Tecla solta?Não
Rotina
Sim
Espera
Opção 1 Opção 2
TECLADO3
22709/05/2016
Rotina TravaEmpregada nos exemplos 4, 5, 6 e 7
Trava
BTFSC PORTB,RC0
GOTO $-0x1
BTFSS PORTB,RC0
GOTO $-0x1
constant TEMPOA = 0x21
constant TEMPOB = 0x22
constant TEMPOC = 0x23
constant VALOR = 0x2f ;configurável
MOVLW VALOR
MOVWF TEMPOC
MOVWF TEMPOB
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-0x1
DECFSZ TEMPOB,F
GOTO $-0x4
DECFSZ TEMPOC,F
GOTO $-0x7
RETURN
TECLADO3
22809/05/2016
Rotina TravaEmpregada nos exemplos 4, 5, 6 e 7
constant VALOR = 0x2f ;configurável
• O parâmetro “valor = 0x2f” é obtido por tentativa e erro.
• Uma configuração muito mais baixa permite a ocorrência
de oscilações que farão com que uma única pressionada
no botão seja considerada como múltiplas pressionadas.
• Uma configuração muito mais alta gera um atraso irritante
entre o soltar da tecla e a efetuação da ação selecionada
pelo botão.
• Cada modelo de tecla requer uma configuração individual.
• O envelhecimento da tecla faz com que este parâmetro
precise ser maior, por isso é bom configurar um pouco
acima do mínimo.
09/05/2016
39
TECLADO3
22909/05/2016
Elemento de memóriaEmpregado nos exemplos 4, 5, 6 e 7
constant marqualrélio = 0x20
CLRF marqualrélio
COMF marqualrélio,W ; TOOGLE
• O toogle-switch obtido a partir de um push boton
requer um elemento armazenador do estado binário.
Um push boton pode ser transformado em toogle-
switch por meio de um flip-flop D ou JK.
• Usando MCU, um registrador precisa ser usado
como este elemento de memória.
TECLADO3
23009/05/2016
Exemplo 4 – Toogle
Usa a rotina “trava”.
L3 L2 L1 L0 L3 L2 L1 L0
TECLADO3
23109/05/2016
Exemplo 4 – Toogle; Programa 75 - Teclado – Programa 4
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant marqualrélio = 0x20
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
BCF STATUS,RP0
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVWF PORTC ; Teclado inativo 11111111
MOVWF PORTD ; LEDs apagados 11111111
BCF PORTC,RC0 ; Habilita o teclado linha 0 11111110
CLRF marqualrélio
Rotina
CALL Trava
COMF marqualrélio,W ; TOOGLE
MOVWF PORTD
GOTO Rotina
endUsa a rotina “trava”.
Igu
al a
o a
nte
rior
Mu
dou
TECLADO3
23209/05/2016
; Programa 76 - Teclado – Programa 5
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant marqualrélio = 0x20
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
BCF STATUS,RP0
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVWF PORTC ; Teclado inativo 11111111
MOVWF PORTD ; LEDs apagados 11111111
BCF PORTC,RC0 ; Habilita o teclado linha 0 11111110
CLRF marqualrélio
Rotina
CALL Trava
INCF marqualrélio,F ; Passo de contagem
COMF marqualrélio,W ; Ajusta à lógica negativa
MOVWF PORTD
GOTO Rotina
end
Exemplo 5 – Contador binário de 8 bits
Usa a rotina “trava”.
Igu
al a
o a
nte
rior
TECLADO3
23309/05/2016
Exemplo 6 – Contador anel de 9 bits
TECLADO3
23409/05/2016
; Programa 77 - Teclado – Programa 6
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant marqualrélio = 0x20
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
BCF STATUS,RP0
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVWF PORTC ; Teclado inativo 11111111
MOVWF PORTD ; LEDs apagados 11111111
BCF PORTC,RC0 ; Habilita o teclado linha 0 11111110
MOVLW 0x01
CLRF marqualrélio
Rotina
CALL Trava
RLF marqualrélio
MOVF marqualrélio,W
MOVWF PORTD
COMF PORTD
GOTO Rotina
end
Exemplo 6 – Contador anel de 9 bits
Usa a rotina “trava”.
Igu
al a
o a
nte
rior
09/05/2016
40
TECLADO3Exemplo 7 – Parte 1 – Definição das constantes
23509/05/2016
Mudar J3 para baixo
; Programa 78 - Teclado – Programa 7
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant Disp0 = 0x03
constant Disp1 = 0x9f
constant Disp2 = 0x25
constant Disp3 = 0x0d
constant Disp4 = 0x99
constant Disp5 = 0x49
constant Disp6 = 0x41
constant Disp7 = 0x1b
constant Disp8 = 0x01
constant Disp9 = 0x09
constant DispA = 0x11
constant DispB = 0xc1
constant DispC = 0x63
constant DispD = 0x85
constant DispE = 0x61
constant DispF = 0x71
TECLADO3Exemplo 7 – Parte 2 – Configurações
23609/05/2016
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISA ; Configura PORTA como saída
CLRF TRISC ; Configura PORTC como saída
CLRF TRISD ; Configura PORTD como saída
CLRF TRISE ; Configura PORTE como saída
MOVLW 0x0f
MOVWF TRISB ; Configura PORTB como 4 saídas e 4 entradas
MOVLW 0x06 ; Carrega W com 0x06
MOVWF ADCON1 ; PORTA e PORTE como digital
BCF STATUS,RP0
BCF PORTE,RE0 ; Habilita DPY1
BSF PORTE,RE1 ; Desabilita DPY2
BSF PORTE,RE2 ; Desabilita DPY3
BSF PORTA,RA5 ; Desabilita DPY4
MOVLW 0xff
MOVWF PORTB ; Teclado inativo 11111111
MOVWF PORTC ; Teclado inativo 11111111
MOVWF PORTD ; LED’s apagados 11111111
BCF PORTC,RC0 ; Habilita o teclado linha 0 11111110
TECLADO3Exemplo 7 – Parte 3 – Rotina
23709/05/2016
Rotina
CALL Trava
MOVLW Disp0
MOVWF PORTD
CALL Trava
MOVLW Disp1
MOVWF PORTD
CALL Trava
MOVLW Disp2
MOVWF PORTD
CALL Trava
MOVLW Disp3
MOVWF PORTD
CALL Trava
MOVLW Disp8
MOVWF PORTD
CALL Trava
MOVLW Disp9
MOVWF PORTD
CALL Trava
MOVLW DispA
MOVWF PORTD
CALL Trava
MOVLW DispB
MOVWF PORTD
CALL Trava
MOVLW Disp4
MOVWF PORTD
CALL Trava
MOVLW Disp5
MOVWF PORTD
CALL Trava
MOVLW Disp6
MOVWF PORTD
CALL Trava
MOVLW Disp7
MOVWF PORTD
CALL Trava
MOVLW DispC
MOVWF PORTD
CALL Trava
MOVLW DispD
MOVWF PORTD
CALL Trava
MOVLW DispE
MOVWF PORTD
CALL Trava
MOVLW DispF
MOVWF PORTD
GOTO Rotina
end
Usa a rotina “trava”.
PWM4
PWM
23809/05/2016
PWM4Configuração do kit didático
• J1: Para baixo
• J2: Para baixo
• J3: Para cima
• J4: Para cima
• CH1: Para baixo
• CH2: Para cima (2)
• CH3: Para cima (1)
• CH4: Para baixo
• CH5: Para cima (1 a 4)
• CH6: Para baixo23909/05/2016
PWM4
24009/05/2016
Conexões
• O módulo CCP1 está ligado à lâmpada.
• O módulo CCP2 está ligado ao motor.
• É fácil perceber mudança no brilho da lâmpada.
• É difícil perceber mudança na rotação do motor.
• Usaremos CCP1.
• Os módulos CCP são compartilhados com PORTC.
• Os pinos do módulo devem ser configurados como saída.
USAREMOS
09/05/2016
41
PWM4
24109/05/2016
Conexões
PWM2
USAREMOS
USAREMOS
PWM1
PWM4Terças aproximadas com 8 bits
24209/05/2016
• CCP1X=0
• CCP1Y=0
99609,01024
1020
66406,01024
680
33203,01024
340
01024
0
• 8 bits: 0d a 255d
• PR2 = FFh
• Passos totais = (FFh+1)×4 = 1024
• 00000000b = 0% de 256
• 01010101b = 33% de 256
• 10101010b = 67% de 256
• 11111111b = 100% de 256
DC CCPR1L CCP1X CCP1Y Decimal Passos Faixa
0%00000000b
00h 0 0 0 0 0 – 0
33%01010101b
55h 0 0 340 340 0 – 339
67%10101010b
AAh 0 0 680 680 0 – 679
100%11111111b
FFh 0 0 1020 1020 0 – 1019
PWM4Terças aproximados com 10 bits
24309/05/2016
• 10 bits: 0d a 1023d
• PR2 = FFh
• 0000000000b = 0% de 1024
• 0101010101b = 33% de 1024
• 1010101010b = 67% de 1024
• 1111111111b = 100% de 1024
99902,01024
1023
66602,01024
682
33301,01024
341
01024
0
DC CCPR1L CCP1X CCP1Y Decimal Passos Faixa
0%00000000b
00h 0 0 0 0 0 – 0
33%01010101b
55h 0 1 341 341 0 – 340
67%10101010b
AAh 1 0 682 682 0 – 681
100%11111111b
FFh 1 1 1023 1023 0 – 1022
PWM4Sensibilidade
24409/05/2016
• Como a percepção humana sobre o brilho da
lâmpada não possui grande sensibilidade,
não é necessário lidar com 10 bits.
• 8 bits são suficientes para esta aplicação.
• A configuração de <CCP1X:CCP1Y> também
se torna irrelevante.
PWM4Terças exatas com 8 bits
24509/05/2016
• CCP1X=0
• CCP1Y=0
• 8 bits: 0d a 255d
• PR2 = FEh
• Passos totais = (FEh+1)×4 = 1020
• 00000000b = 0% de 255
• 01010101b = 33% de 255
• 10101010b = 67% de 255
• 11111111b = 100% de 255
11020
1020
3
2
1020
680
3
1
1020
340
01020
0
DC CCPR1L CCP1X CCP1Y Decimal Passos Faixa
0% 00000000 0 0 0 0
33% 01010101 0 0 340 340 0 – 339
67% 10101010 0 0 680 680 0 – 679
100% 11111111 0 0 1020 1020 0 – 1019
PWM4Exemplo 1 – 8 bits
24609/05/2016
; Programa 79 - PWM – Programa 1
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ;Configura PORTC como saída
MOVLW 0xfe
MOVWF PR2 ;Configura o período do PWM
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON ;Habilita o Timer2 com 1:16
MOVLW 0x0f
MOVWF CCP1CON ;Habilita o PWM 1
MOVLW 0xff ;Dutty-cycle de 100% exatamente
MOVWF CCPR1L
end
CCPxCON
T2CON
Experimente
alterar
09/05/2016
42
PWM4Exemplo 2 – 10 bits
24709/05/2016
; Programa 80 - PWM – Programa 2
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ;Configura PORTC como saída
MOVLW 0xff
MOVWF PR2 ;Configura o período do PWM
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON ;Habilita o Timer2 com 1:16
MOVLW 0x0f
MOVWF CCP1CON ;Habilita o PWM 1
MOVLW 0xff
MOVWF CCPR1L
BSF CCP1CON,CCP1X
BSF CCP1CON,CCP1Y;11111111_11 ; 99,90234375%
end
Experimente
alterar
PWM4Exemplo 3 – Graduação em cinco níveis – 8 bits
24809/05/2016
VMÉDIA
100%
75%
50%
25%
0%
Espera
DC CCPR1L CCP1X CCP1Y Decimal
0%00000000b
00h 0 0 0
25%00111111b
3Fh 0 0 252
50%01111110b
7Eh 0 0 504
75%10111101b
BDh 0 0 756
100%11111100b
FCh 0 0 1008
• PR2 = FBh
• Passos: 1008
4
4
1008
1008
4
3
1008
756
4
2
1008
504
4
1
1008
252
4
0
1008
0
PWM4
; Programa 81 - PWM – Programa 3
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ;Configura PORTC como saída
MOVLW 0xfb ;Motivo: 0xfb = 0xfc(100%) - 1
MOVWF PR2 ;Configura o período do PWM
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON ;Habilita o Timer2 com 1:16
MOVLW 0x0f
MOVWF CCP1CON ;Habilita o PWM 1
Rotina
MOVLW 0x00 ;Dutty-cycle de 0% exatamente
CALL Espera
MOVLW 0x3f ;Dutty-cycle de 25% exatamente
CALL Espera
MOVLW 0x7e ;Dutty-cycle de 50% exatamente
CALL Espera
MOVLW 0xbd ;Dutty-cycle de 75% exatamente
CALL Espera
MOVLW 0xfc ;Dutty-cycle de 100% exatamente
CALL Espera
GOTO Rotina
end
Exemplo 3 – Parte principal
24909/05/2016
PWM4Exemplo 3 – Sub-rotina “Espera”
25009/05/2016
Espera
MOVWF CCPR1L
constant TEMPOA = 0x21
constant TEMPOB = 0x22
constant TEMPOC = 0x23
constant VALOR = 0x7f;configurável
MOVLW VALOR
MOVWF TEMPOC
MOVWF TEMPOB
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-0x1
DECFSZ TEMPOB,F
GOTO $-0x4
DECFSZ TEMPOC,F
GOTO $-0x7
RETURN
Empregada também no exemplo 4
PWM4Exemplo 4 – Graduação em três níveis – 10 bits
25109/05/2016
100%
67%
33%
0%
VMÉDIA
Espera
PWM4Exemplo 4 – Configuração
25209/05/2016
; Programa 82 - PWM – Programa 4
#include<P16F877.INC>
__config_WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ;Configura PORTC como saída
MOVLW 0xff
MOVWF PR2 ;Configura o período do PWM
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON ;Habilita o Timer2 com 1:16
MOVLW 0x0f
MOVWF CCP1CON ;Habilita o PWM 1
Utiliza a subrotina “Espera” do exemplo 3
09/05/2016
43
PWM4Exemplo 4 – Rotina
25309/05/2016
Rotina
MOVLW 0xff ;Dutty-cycle de 100% aproximadamente
MOVWF CCPR1L
BSF CCP1CON,CCP1X ;esta linha pode ser removida
BSF CCP1CON,CCP1Y ;11111111_11
CALL Espera
MOVLW 0xaa ;Dutty-cycle de 67% aproximadamente
MOVWF CCPR1L
BSF CCP1CON,CCP1X ;esta linha pode ser removida
BCF CCP1CON,CCP1Y ;10101010_10
CALL Espera
MOVLW 0x55 ;Dutty-cycle de 33% aproximadamente
MOVWF CCPR1L
BCF CCP1CON,CCP1X
BSF CCP1CON,CCP1Y ;01010101_01
CALL Espera
MOVLW 0x00 ;Dutty-cycle de 0% exatamente
MOVWF CCPR1L
BCF CCP1CON,CCP1X
BCF CCP1CON,CCP1Y ;00000000_00
CALL Espera
GOTO Rotina
end
PWM4
100%
0%
Exemplo 5 – Curva PWM de 8 bits
25409/05/2016
VMÉDIA
FFh
00h
marqualrélio
PWM4Exemplo 5 – Configuração
25509/05/2016
; Programa 83 - PWM – Programa 5
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant marqualrélio = 0x20
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISC ;Configura PORTC como saída
MOVLW 0xff
MOVWF PR2 ;Configura o período do PWM
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON ;Habilita o Timer2 com 1:16
MOVLW 0x0f
MOVWF CCP1CON ;Habilita o PWM 1
CLRF marqualrélio
Igu
al a
o a
nte
rior
• São 256 níveis diferentes.
• Usar o procedimento anterior geraria um programa grande.
• É mais fácil usar incremento.
• Um registrador precisa ser usado como elemento de
memória.
PWM4Exemplo 5 – Rotina
25609/05/2016
Rotina
INCF marqualrélio,F
MOVF marqualrélio,W
MOVWF CCPR1L
;Espera
constant TEMPOA = 0x21
constant TEMPOB = 0x22
constant VALOR = 0xbf ;Configurar
MOVLW VALOR
MOVWF TEMPOB
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-0x1
DECFSZ TEMPOB,F
GOTO $-0x4
GOTO Rotina
end
PWM4Exemplo 6 – PWM selecionado por teclas
25709/05/2016
1
100%
2/3
67%
1/3
33%
0
0%
PWM4Exemplo 6 – Parte principal
25809/05/2016
Rotina
BTFSS PORTB,RB0 ;Master
GOTO Tecla0
BTFSS PORTB,RB1 ;Master
GOTO Tecla1
BTFSS PORTB,RB2 ;Master
GOTO Tecla2
BTFSS PORTB,RB3 ;Master
GOTO Tecla3
GOTO Rotina
end
; Programa 84 - PWM – Programa 6
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISA
CLRF TRISC
CLRF TRISD
CLRF TRISE
MOVLW 0x0f
MOVWF TRISB
MOVLW 0x06
MOVWF ADCON1
MOVLW 0xff
MOVWF PR2
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON
MOVLW 0x0f
MOVWF CCP1CON
MOVLW 0xfe
MOVWF PORTC
09/05/2016
44
PWM4Exemplo 6 – Sub-rotinas
25909/05/2016
Tecla0
BTFSS PORTB,RB0 ;Slave
GOTO Tecla0
MOVLW 0x00
MOVWF CCPR1L ;Dutty-cycle de 0% exatamente
BCF CCP1CON,CCP1X
BCF CCP1CON,CCP1Y
GOTO Rotina
Tecla1
BTFSS PORTB,RB1 ;Slave
GOTO Tecla1
MOVLW 0x55
MOVWF CCPR1L ;Dutty-cycle de 33% aproximadamente
BCF CCP1CON,CCP1X
BSF CCP1CON,CCP1Y
GOTO Rotina
Tecla2
BTFSS PORTB,RB2 ;Slave
GOTO Tecla2
MOVLW 0xaa
MOVWF CCPR1L ;Dutty-cycle de 67% aproximadamente
BSF CCP1CON,CCP1X
BCF CCP1CON,CCP1Y
GOTO Rotina
Tecla3
BTFSS PORTB,RB3 ;Slave
GOTO Tecla3
MOVLW 0xff
MOVWF CCPR1L ;Dutty-cycle de 100% aproximadamente
BSF CCP1CON,CCP1X
BSF CCP1CON,CCP1Y
GOTO Rotina
PWM4Exemplo 7 – PWM selecionado por teclas
26009/05/2016
0% 25% 50% 75% 100%
PWM4Exemplo 7 – Parte principal
26109/05/2016
Rotina
MOVLW 0x00
CALL Trava
MOVLW 0x3f
CALL Trava
MOVLW 0x7e
CALL Trava
MOVLW 0xbd
CALL Trava
MOVLW 0xfc
CALL Trava
GOTO Rotina
end
; Programa 84 - PWM – Programa 6
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
;Rotina de iniciação
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISA
CLRF TRISC
CLRF TRISD
CLRF TRISE
MOVLW 0x0f
MOVWF TRISB
MOVLW 0x06
MOVWF ADCON1
MOVLW 0xfb
MOVWF PR2
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON
MOVLW 0x0f
MOVWF CCP1CON
MOVLW 0xfe
MOVWF PORTC
No anterior era 0xff
PWM4Exemplo 7 – Sub-rotina “Trava”
26209/05/2016
Trava
MOVWF CCPR1L
BTFSC PORTB,RC0
GOTO $-0x1
BTFSS PORTB,RC0
GOTO $-0x1
constant TEMPOA = 0x21
constant TEMPOB = 0x22
constant TEMPOC = 0x23
constant VALOR = 0x2f ;configurável
MOVLW VALOR
MOVWF TEMPOC
MOVWF TEMPOB
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-0x1
DECFSZ TEMPOB,F
GOTO $-0x4
DECFSZ TEMPOC,F
GOTO $-0x7
RETURN
PWM4
26309/05/2016
• O exemplo 6 não precisa de trava porque a função das
quatro teclas é sempre a mesma, não é necessário saber
qual o estado anterior, e, por isso, uma consideração de
múltiplas tecladas, da parte da MCU, decorrente de
oscilação, não provoca efeito cumulativo.
• O exemplo 7 precisa de trava porque a função da tecla é
variável, é necessário saber qual o estado anterior, e, por
isso, uma consideração de múltiplas tecladas, da parte da
MCU, decorrente de oscilação, provoca efeito cumulativo.
Exemplo 7 – Sub-rotina “Trava”
PWM4Exemplo 8 – PWM com teclas +/-
26409/05/2016
Decremento Incremento
09/05/2016
45
PWM4
26509/05/2016
; Programa 86 - PWM – Programa 8
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
constant marqualrélio = 0x20
;Rotina de iniciação
CLRF marqualrélio
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISA
CLRF TRISC
CLRF TRISD
CLRF TRISE
MOVLW 0x0f
MOVWF TRISB
MOVLW 0x06
MOVWF ADCON1
MOVLW 0xff
MOVWF PR2
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON
MOVLW 0x0f
MOVWF CCP1CON
MOVLW 0xfe
MOVWF PORTC
Rotina
BTFSS PORTB,RB0
GOTO Tecla0
BTFSS PORTB,RB1
GOTO Tecla1
GOTO Rotina
Tecla0
BTFSS PORTB,RB0
GOTO Tecla0
DECF marqualrélio
GOTO Escreve
Tecla1
BTFSS PORTB,RB1
GOTO Tecla1
INCF marqualrélio
GOTO Escreve
Escreve
MOVF marqualrélio, W
MOVWF CCPR1L
RLF CCPR1L
RLF CCPR1L
RLF CCPR1L
GOTO Rotina
end
Exemplo 8 – PWM com teclas +/-
PWM4
26609/05/2016
• Os três comandos RLF têm a função de multiplicar CCPR
por oito.
• Esta multiplicação tem o objetivo de tornar o efeito da
tecla mais grosso de modo que o controle da variação no
brilho ocorra mais rapidamente.
• O programa pode ser aprimorado eliminando o wrap back.
Exemplo 8 – PWM com teclas +/-
ENTRADA ANALÓGICA5
ENTRADA ANALÓGICA
26709/05/2016
ENTRADA ANALÓGICA5Conexões
26809/05/2016
USAREMOS
3
USAREMOS
ENTRADA ANALÓGICA5Automação industrial
26909/05/2016
Teclas
Conversor
A/D
Potenciômetros
Sensores
Contatos
Portas
paralelas
Processamento
PWM
Portas
paralelas
Atuadores
Displays
Processamento
ENTRADA ANALÓGICA5Configuração
27009/05/2016
ADCON0
ADCON1
AD Clock ADCS1 ADCS0
fOSC/2 0 0
fOSC/8 0 1
fOSC/32 1 0
fRCINT 1 1
AN CHS2 CHS1 CHS0
0 0 0 0
1 0 0 1
2 0 1 0
3 0 1 1
4 1 0 0
5 1 0 1
6 1 1 0
7 1 1 1
PCFG3
:PCFG0
AN7
RE2
AN6
RE1
AN5
RE0
AN4
RA5
AN3
RA3
AN2
RA2
AN1
RA1
AN0
RA0
0000 A A A A A A A A
0001 A A A A VREF+ A A A
0010 D D D A A A A A
0011 D D D A VREF+ A A A
0100 D D D D A D A A
0101 D D D D VREF+ D A A
011x D D D D D D D D
1000 A A A A VREF+ VREF- A A
1001 D D A A A A A A
1010 D D A A VREF+ A A A
1011 D D A A VREF+ VREF- A A
1100 D D D A VREF+ VREF- A A
1101 D D D D VREF+ VREF- A A
1110 D D D D D D D A
1111 D D D D VREF+ VREF- D A
09/05/2016
46
ENTRADA ANALÓGICA5Exemplo 1 – Configuração do kit didático
• J1: Para baixo
• J2: Para baixo
• J3: Para cima
• J4: Para cima
• CH1: Para cima (3)
• CH2: Para baixo
• CH3: Para baixo
• CH4: Para cima
• CH5: Para baixo
• CH6: Para baixo27109/05/2016
ENTRADA ANALÓGICA5Exemplo 1 – Palavra binária
27209/05/2016
ADRESL
PORTD
0d 0V
255d 5V
ENTRADA ANALÓGICA5Exemplo 1 – Palavra binária – Parte 1
27309/05/2016
;85 - Entrada analógica – Programa 1
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
BCF STATUS,RP0
BCF STATUS,RP1
CLRF PORTA
CLRF PORTD
BSF STATUS,RP0
CLRF TRISD
CLRF ADCON1 ; Habilita os oito canais AD
MOVLW 0x08 ; 00010000b
MOVWF TRISA ; Entrada AD
MOVLW 0xdf
MOVWF OPTION_REG
BCF STATUS,RP0
MOVLW 0x59
MOVWF ADCON0 ; 0101_10X1
; 01 - ADCLOCK = FOSC/8 = FCY/2
; 011 - AN3
; 0 - GODONE
; 1 – ADON
end
ENTRADA ANALÓGICA5Exemplo 1 – Palavra binária – Rotina
27409/05/2016
Rotina
BSF ADCON0,GO ; Inicia a conversão de dado
BTFSC ADCON0,GO ; Verifica fim da conversão
GOTO $-0x1
MOVF ADRESH,W ; Leitura do valor de tensão
XORLW 0xff ; Lógica negativa dos LED’s
MOVWF PORTD
constant TEMPOA = 0x21
constant TEMPOB = 0x22
constant TEMPOC = 0x23
constant VALOR = 0x3f ; Configurar
MOVLW VALOR
MOVWF TEMPOC
MOVLW VALOR
MOVWF TEMPOB
MOVLW VALOR
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-0x01
DECFSZ TEMPOB,F
GOTO $-0x05
DECFSZ TEMPOC,F
GOTO $-0x09
GOTO Rotina
ENTRADA ANALÓGICA5
27509/05/2016
• O AD clock é de fCY/2.
• TAD = TCY2.
• O tempo para a conversão é:
• tconv = 10TAD.
• tconv = 5TCY.
Exemplo 1 – Palavra binária
ENTRADA ANALÓGICA5Exemplo 2 – Configuração do kit didático
• J1: Para baixo
• J2: Para baixo
• J3: Para baixo
• J4: Para cima
• CH1: Para cima (3)
• CH2: Para baixo
• CH3: Para baixo
• CH4: Para cima
• CH5: Para baixo
• CH6: Para cima (1)27609/05/2016
09/05/2016
47
ENTRADA ANALÓGICA5Exemplo 2 – Palavra hexadecimal – 4 bits
27709/05/2016
ADRESL
PORTD
Val. Mín. Máx.0 00000000 00001111
1 00010000 00011111
2 00100000 00101111
3 00110000 00111111
4 01000000 01001111
5 01010000 01011111
6 01100000 01101111
7 01110000 01111111
8 10000000 10001111
9 10010000 10011111
a 10100000 10101111
b 10110000 10111111
c 11000000 11001111
d 11010000 11011111
e 11100000 11101111
f 11110000 11111111
ENTRADA ANALÓGICA5
constant Disp0 = 0x03
constant Disp1 = 0x9f
constant Disp2 = 0x25
constant Disp3 = 0x0d
constant Disp4 = 0x99
constant Disp5 = 0x49
constant Disp6 = 0x41
constant Disp7 = 0x1b
constant Disp8 = 0x01
constant Disp9 = 0x09
constant DispA = 0x11
constant DispB = 0xc1
constant DispC = 0x63
constant DispD = 0x85
constant DispE = 0x61
constant DispF = 0x71
Exemplo 2 – Palavra hexadecimal – Parte 1
27809/05/2016
;86 - Entrada analógica – Programa 1
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
BCF STATUS,RP0
BCF STATUS,RP1
CLRF PORTA
CLRF PORTD
BSF STATUS,RP0
CLRF TRISD
CLRF ADCON1 ; Habilita os oito canais AD
MOVLW 0x08
MOVWF TRISA ; Entrada AD
MOVLW 0xdf
MOVWF OPTION_REG
BCF PORTE,RE0 ; Habilita DPY1
BSF PORTE,RE1 ; Desabilita DPY2
BSF PORTE,RE2 ; Desabilita DPY3
BSF PORTA,RA5 ; Desabilita DPY4
BCF STATUS,RP0
MOVLW 0x59
MOVWF ADCON0 ; 0101_10X1
; 01 - ADCLOCK = FOSC/8 = FCY/2
; 011 - AN3
; 0 - GODONE
; 1 – ADON
ENTRADA ANALÓGICA5Exemplo 2 – Palavra hexadecimal – Parte 2
27909/05/2016
Rotina
BSF ADCON0,GO ; Inicia a conversão de dado
BTFSC ADCON0,GO ; Verifica fim da conversão
GOTO $-0x1; Não precisava verificar poque já tem a espera adiante
MOVF ADRESH,W ; Leitura do valor de tensão
ENTRADA ANALÓGICA5Exemplo 2 – Palavra hexadecimal – Parte 3
28009/05/2016
BTFSS ADRESH,7
GOTO R01234567
GOTO R89ABCDEF
R01234567
BTFSS ADRESH,6
GOTO R0123
GOTO R4567
R89ABCDEF
BTFSS ADRESH,6
GOTO R89AB
GOTO RCDEF
R0123
BTFSS ADRESH,5
GOTO R01
GOTO R23
R4567
BTFSS ADRESH,5
GOTO R45
GOTO R67
R89AB
BTFSS ADRESH,5
GOTO R89
GOTO RAB
RCDEF
BTFSS ADRESH,5
GOTO RCD
GOTO REF
R01
BTFSS ADRESH,4
GOTO R_0
GOTO R_1
R23
BTFSS ADRESH,4
GOTO R_2
GOTO R_3
R45
BTFSS ADRESH,4
GOTO R_4
GOTO R_5
R67
BTFSS ADRESH,4
GOTO R_6
GOTO R_7
R89
BTFSS ADRESH,4
GOTO R_8
GOTO R_9
RAB
BTFSS ADRESH,4
GOTO R_A
GOTO R_B
RCD
BTFSS ADRESH,4
GOTO R_C
GOTO R_D
REF
BTFSS ADRESH,4
GOTO R_E
GOTO R_F
R_0
MOVLW Disp0
GOTO TerminaSeleção
R_1
MOVLW Disp1
GOTO TerminaSeleção
R_2
MOVLW Disp2
GOTO TerminaSeleção
R_3
MOVLW Disp3
GOTO TerminaSeleção
R_4
MOVLW Disp4
GOTO TerminaSeleção
R_5
MOVLW Disp5
GOTO TerminaSeleção
R_6
MOVLW Disp6
GOTO TerminaSeleção
R_7
MOVLW Disp7
GOTO TerminaSeleção
R_8
MOVLW Disp8
GOTO TerminaSeleção
R_9
MOVLW Disp9
GOTO TerminaSeleção
R_A
MOVLW DispA
GOTO TerminaSeleção
R_B
MOVLW DispB
GOTO TerminaSeleção
R_C
MOVLW DispC
GOTO TerminaSeleção
R_D
MOVLW DispD
GOTO TerminaSeleção
R_E
MOVLW DispE
GOTO TerminaSeleção
R_F
MOVLW DispF
GOTO TerminaSeleção
ENTRADA ANALÓGICA5Exemplo 2 – Palavra hexadecimal – Parte 4
28109/05/2016
TerminaSeleção
MOVWF PORTD
constant TEMPOA = 0x21
constant TEMPOB = 0x22
constant TEMPOC = 0x23
constant VALOR = 0x3f
MOVLW VALOR
MOVWF TEMPOC
MOVLW VALOR
MOVWF TEMPOB
MOVLW VALOR
MOVWF TEMPOA
DECFSZ TEMPOA,F
GOTO $-0x01
DECFSZ TEMPOB,F
GOTO $-0x05
DECFSZ TEMPOC,F
GOTO $-0x09
GOTO Rotina
end
Tem
porizad
or
ENTRADA ANALÓGICA5Exemplos 3 e 4 – Configuração do kit didático
• J1: Para baixo
• J2: Para baixo
• J3: Para cima
• J4: Para cima
• CH1: Para cima (3)
• CH2: Para cima (2)
• CH3: Para cima (1)
• CH4: Para baixo
• CH5: Para baixo
• CH6: Para baixo28209/05/2016
09/05/2016
48
ENTRADA ANALÓGICA5Exemplos 3 e 4 – Princípio
28309/05/2016
Controle com 10 bits Controle com 8 bits
ENTRADA ANALÓGICA5Exemplo 3 – Controle PWM – 8 bits
28409/05/2016
ADRESL
CCPR1L
ENTRADA ANALÓGICA5Exemplo 3 – Controle PWM – 8 bits
28509/05/2016
;86 - Entrada analógica – Programa 3
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
BCF STATUS,RP0
BCF STATUS,RP1
CLRF PORTA
CLRF PORTD
BSF STATUS,RP0
CLRF TRISD
CLRF ADCON1 ; Habilita os oito canais AD
MOVLW 0x08
MOVWF TRISA ; Entrada AD
MOVLW 0xdf
MOVWF OPTION_REG
CLRF TRISC ;Configura PORTC como saída
MOVLW 0xff
MOVWF PR2 ;Configura o período do PWM
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON ;Habilita o Timer2 com 1:16
MOVLW 0x0f
MOVWF CCP1CON ;Habilita o PWM 1
BCF STATUS,RP0
MOVLW 0x59 ;0101_10X1
MOVWF ADCON0
Rotina
BSF ADCON0,GO ; Inicia a conversão de dado
BTFSC ADCON0,GO ; Verifica fim da conversão
GOTO $-0x1
MOVF ADRESH,W ; Leitura do valor de tensão
MOVWF CCPR1L
GOTO Rotina
end
ENTRADA ANALÓGICA5Exemplo 4 – Controle PWM – 10 bits – Parte 1
28609/05/2016
;87 - Entrada analógica – Programa 4
#include <P16F877.INC>
__config _WDT_OFF & _XT_OSC & _LVP_OFF
BCF STATUS,RP0
BCF STATUS,RP1
CLRF PORTA
CLRF PORTD
BSF STATUS,RP0
CLRF TRISD
CLRF ADCON1 ; Habilita os oito canais AD
MOVLW 0x08
MOVWF TRISA ; Entrada AD
MOVLW 0xdf
MOVWF OPTION_REG
CLRF TRISC ;Configura PORTC como saída
MOVLW 0xff
MOVWF PR2 ;Configura o período do PWM
BCF STATUS,RP0
MOVLW 0x07
MOVWF T2CON ;Habilita o Timer2 com 1:16
MOVLW 0x0f
MOVWF CCP1CON ;Habilita o PWM 1
BCF STATUS,RP0
MOVLW 0x59 ;0101_10X1
MOVWF ADCON0
ENTRADA ANALÓGICA5Exemplo 4 – Controle PWM – 10 bits – Parte 2
28709/05/2016
Rotina
BSF ADCON0,GO ; Inicia a conversão de dado
BTFSC ADCON0,GO ; Verifica fim da conversão
GOTO $-0x1
MOVF ADRESH,W ; Leitura do valor de tensão
MOVWF CCPR1L
BTFSS ADRESL,7
GOTO R0X
GOTO R1X
R0X
BCF CCP1CON,CCP1X
BTFSS ADRESL,6
GOTO R0Y
GOTO R1Y
R1X
BSF CCP1CON,CCP1X
BTFSS ADRESL,6
GOTO R0Y
GOTO R1Y
R0Y
BCF CCP1CON,CCP1Y
GOTO Rotina
R1Y
BSF CCP1CON,CCP1Y
GOTO Rotina
end
Cópia dos dois
bits menos significativos
ENTRADA ANALÓGICA5
28809/05/2016
• Foram usadas catorze linhas para a cópia dos dois bits
menos significativos, das quais dez são instruções 2TCY.
• São gastos 24TCY’s nesta cópia.
Controle PWM
BTFSS ADRESL,7
GOTO R0X
GOTO R1X
R0X
BCF CCP1CON,CCP1X
BTFSS ADRESL,6
GOTO R0Y
GOTO R1Y
R1X
BSF CCP1CON,CCP1X
BTFSS ADRESL,6
GOTO R0Y
GOTO R1Y
R0Y
BCF CCP1CON,CCP1Y
GOTO Rotina
R1Y
BSF CCP1CON,CCP1Y
• A rotina para 8 bits emprega,
apenas, seis linhas, das quais três
são instruções 2TCY.
• São gastos 9TCY’s.
• A cópia gasta, apenas, 2TCY’s.
Rotina
BSF ADCON0,GO
BTFSC ADCON0,GO
GOTO $-0x1
MOVF ADRESH,W
MOVWF CCPR1L
GOTO Rotina
09/05/2016
49
ENTRADA ANALÓGICA5
28909/05/2016
• O uso dos 10 bits do PWM requer pelo menos 24TCY’s.
• O uso de, apenas, 8 bits do PWM requer pelo menos 9TCY’s.
• tconv = 5TCY.
• O uso dos 10 bits do PWM requer 29TCY’s.
• O uso de, apenas, 8 bits do PWM requer pelo menos 14TCY’s.
• O uso de 10 bits torna a rotina mais de duas vezes mais lenta.
• A frequência de amostragens cai a menos da metade.
• Para cargas analógicas em malha aberta, isso não é problema.
Controle PWM
ENTRADA ANALÓGICA5
29009/05/2016
• Para sistemas em malha fechada (P, PI, PD ou PID) é
preciso realizar uma análise sofisticada para determinar
qual a melhor opção.
• Em alguns casos, é preferível diminuir a frequência das
amostragens para executar cálculos mais refinados.
• Em outros casos, é preferível diminuir o refinamento dos
cálculos para que a frequência das amostragens seja maior.
• Quando se trabalha com dez bits, as funções de
transferência para a ação de controle também se tornam
mais demoradas, contribuindo para um maior aumento no
tempo de execução da rotina, tornando esta diferença de
tempo bem maior do que o dobro.
Controle PWM
ENTRADA ANALÓGICA5
29109/05/2016
• Este programa transfere o resultado da conversão A/D
diretamente para o PWM.
• A relação entre a posição do potenciômetro e a tensão
média na lâmpada é linear.
Este efeito poderia ser obtido diretamente por meio de um
circuito analógico, não seria necessário o uso de uma MCU.
• A vantagem do uso da MCU é a possibilidade da alteração
da função de transferência da posição do potenciômetro
para o brilho da lâmpada.
• É possível, por exemplo, aplicar funções para linearização
de efeitos não lineares entre o potenciômetro e o atuador.
Controle PWM