microprocessadores - exemplos

49
09/05/2016 1 1 09/05/2016 Parte 6 EXEMPLOS 2 09/05/2016 1. MPLAB ® SIM 2. DISPLAY DE 7 SEGMENTOS 3. TECLADO 4. PWM 5. ENTRADA ANALÓGICA 1 3 09/05/2016 MPLAB ® SIM MPLAB ® SIM 1 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 ® SIM 1 5 09/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 ® SIM 1 6 09/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.

Upload: alexandre-lomeu

Post on 14-Apr-2017

98 views

Category:

Education


0 download

TRANSCRIPT

Page 1: Microprocessadores - exemplos

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.

Page 2: Microprocessadores - exemplos

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

Page 3: Microprocessadores - exemplos

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.

Page 4: Microprocessadores - exemplos

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

Page 5: Microprocessadores - exemplos

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

Page 6: Microprocessadores - exemplos

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

Page 7: Microprocessadores - exemplos

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

Page 8: Microprocessadores - exemplos

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.

Page 9: Microprocessadores - exemplos

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

Page 10: Microprocessadores - exemplos

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

Page 11: Microprocessadores - exemplos

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.

Page 12: Microprocessadores - exemplos

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.

Page 13: Microprocessadores - exemplos

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.

Page 14: Microprocessadores - exemplos

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

Page 15: Microprocessadores - exemplos

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

Page 16: Microprocessadores - exemplos

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.

Page 17: Microprocessadores - exemplos

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)

Page 18: Microprocessadores - exemplos

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.

Page 19: Microprocessadores - exemplos

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.

Page 20: Microprocessadores - exemplos

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

Page 21: Microprocessadores - exemplos

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

Page 22: Microprocessadores - exemplos

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.

Page 23: Microprocessadores - exemplos

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:

Page 24: Microprocessadores - exemplos

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

Page 25: Microprocessadores - exemplos

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

Page 26: Microprocessadores - exemplos

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

Page 27: Microprocessadores - exemplos

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

Page 28: Microprocessadores - exemplos

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

Page 29: Microprocessadores - exemplos

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

Page 30: Microprocessadores - exemplos

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

Page 31: Microprocessadores - exemplos

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.

Page 32: Microprocessadores - exemplos

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

Page 33: Microprocessadores - exemplos

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

Page 34: Microprocessadores - exemplos

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

Page 35: Microprocessadores - exemplos

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.

Page 36: Microprocessadores - exemplos

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.

Page 37: Microprocessadores - exemplos

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

Page 38: Microprocessadores - exemplos

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.

Page 39: Microprocessadores - exemplos

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

Page 40: Microprocessadores - exemplos

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

Page 41: Microprocessadores - exemplos

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

Page 42: Microprocessadores - exemplos

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

Page 43: Microprocessadores - exemplos

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

Page 44: Microprocessadores - exemplos

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

Page 45: Microprocessadores - exemplos

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

Page 46: Microprocessadores - exemplos

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

Page 47: Microprocessadores - exemplos

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

Page 48: Microprocessadores - exemplos

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

Page 49: Microprocessadores - exemplos

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