Parte 7 ASSEMBLER. ; Programa 2 Vazio end ;fim OP. LÓGICAS E ARITMÉTICAS OP. LÓGICAS E ARITMÉTICAS OPERAÇÕES LÓGICAS E ARITMÉTICAS

(1)

1 25/04/2017

Parte 7

ASSEMBLER

2 25/04/2017

1. OPERAÇÕES LÓGICAS E ARITMÉTICAS

2. ENDEREÇAMENTO DA SRAM

3. DESVIOS

4. TEMPORIZADORES

5. ACESSO À MEMÓRIA

6. OUTROS

OP. LÓGICAS E ARITMÉTICAS

1

3 25/04/2017

OPERAÇÕES LÓGICAS

E ARITMÉTICAS

OP. LÓGICAS E ARITMÉTICAS

1

4 25/04/2017

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

---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

OP. LÓGICAS E ARITMÉTICAS

1

5 25/04/2017

2 – Programa vazio com comentário

; Programa 2 – Vazio

end

;fim

• Este programa emprega umcomentário

e umadiretiva, 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.

OP. LÓGICAS E ARITMÉTICAS

1

6 25/04/2017

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.

(2)

OP. LÓGICAS E ARITMÉTICAS

1

7 25/04/2017

4 – Definição de constante

; Programa 4 - Definição de constante

constant marqualrélio=0x20 ;definição da constante

end ;fim

• Este programa emprega um comentário e

quatrodiretivas, 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.

OP. LÓGICAS E ARITMÉTICAS

1

8 25/04/2017

Constantes

Significado Tamanho Mínimo Máximo

Destiny address 1 bit 0x0 0x1

Bit address 3 bits 0x0 0x7

File address 7 bits 0x00 0x7f

Literal 8 bits 0x00 0xff

Program Address 11 bits 0x000 0x7ff

Os zeros à esquerda não podem ser eliminados.

OP. LÓGICAS E ARITMÉTICAS

1

9 25/04/2017

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.

OP. LÓGICAS E ARITMÉTICAS

1

10 25/04/2017

5 – Definição da posição inicial do programa

; Programa 5 - Definição da posição inicial do programa

org 0x5 ;posição inicial (13-bit)

constant marqualrélio= 0x0a ;definição da constante

end ;fim

• Este programa emprega um comentário e

cincodiretivas, 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.

OP. LÓGICAS E ARITMÉTICAS

1

11 25/04/2017

6 – Realização de uma escrita direta na SRAM

; Programa 6 - Gravação de registrador

org 0xfff ;posição inicial

MOVLW 0xaa ;W = 0xaa

MOVWF 0x2a ;SRAM(0x2a) = W

end ;fim

• Daqui por diante, a diretiva#include<p16f877.inc>

será usada somente quando necessário.

OP. LÓGICAS E ARITMÉTICAS

1

12 25/04/2017

7 – Efeito do valor inicial do acumulador

; Programa 7 - Efeito do valor inicial do acumulador

org 0x5 ;posição inicial

CLRW ;limpa o acumulador

ADDLW 0xaa ;W = 0xaa + W

end ;fim

0005 0103 CLRW 0006 3EAA ADDLW 0xaa 0007 00AA MOVWF 0x2a

Program Memory Address Opcode Disassembly

027 0x00 028 0x00 029 0x00 02A 0xAA 02B 0x00 02C 0x00 02D 0x00 File Registers Address Hex

(3)

OP. LÓGICAS E ARITMÉTICAS

1

13 25/04/2017

Limpeza do acumulador

• Ao ligar o chip, o valor do acumulador é zero e, a princípio, a limpeza do acumulador não seria necessária. • A não limpeza do acumulador, porém, provoca erros,

devido a dois motivos:

1. Na segunda vez em que o programa for executado, o acumulador contém o resultado prévio obtido na execução anterior.

2. Mesmo na primeira execução, as cinco primeiras linhas do programa, em branco (0x3fff), realizam,

cada uma delas, uma subtração unitária no

acumulador, de modo que, quando a adição é executada, o valor do acumulador não seria zero.

OP. LÓGICAS E ARITMÉTICAS

1

14 25/04/2017

8 – Realização de uma adição com label

; Programa 8 - Realização de uma adição com label

constant marqualrélio=0xaa ;dado

constant ondecadê = 0x2a ;endereço

CLRW ;limpa o acumulador

ADDLW marqualrélio ;W = marqualrélio + W

MOVWF ondecadê ;SRAM(ondecadê) = W

end ;fim

0005 0103 CLRW 0006 3EAA ADDLW 0xaa 0007 00AA MOVWF 0x2a 027 0x00 028 0x00 029 0x00 02A 0xAA 02B 0x00 02C 0x00 02D 0x00

OP. LÓGICAS E ARITMÉTICAS

1

; Programa 9 – Realização de uma cópia direta

MOVLW 0xaa ;W = 0xaa

MOVLW 0xaa-1 ;W = 0xa9

MOVWF 0x2a+1 ;SRAM(0x2b) = W

end ;fim

15 25/04/2017

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.

OP. LÓGICAS E ARITMÉTICAS

1

; Programa 10 – Realização de uma cópia indireta

constant marqualrélio= 0xaa ;dado

constant ondecadê = 0x2a ;endereço

MOVLW marqualrélio ;W = marqualrélio

MOVLW marqualrélio-1 ;W = marqualrélio-1

MOVWF ondecadê+1 ;SRAM(ondecadê+1) = W

end ;fim

16 25/04/2017

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.

OP. LÓGICAS E ARITMÉTICAS

1

17 25/04/2017

11 – Realização de um incremento

; Programa 11 – Realização de um incremento

constant marqualrélio=0xaa ;dado

constant ondecadê= 0x2a ;endereço

INCF ondecadê,0 ;W = marqualrélio + 1

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

OP. LÓGICAS E ARITMÉTICAS

1

; Programa 12 – Operações aritméticas

constant marqualrélio= 0x45 ;dado 1 constant operador = 0xae ;dado 2 constant ondecadê= 0x2a ;endereço

MOVLW marqualrélio ;W = marqualrélio*

ADDLW operador ;W = operador ADD marqualrélio

SUBLW operador ;W = operador SUB marqualrélio

INCF ondecadê+3,1 ;SRAM(ondecadê+3) = SRAM(ondecadê+3) + 1

DECF ondecadê+4,1 ;SRAM(ondecadê+4) = SRAM(ondecadê+4) – 1

end ;fim 18 25/04/2017

12 – Operações aritméticas

Cópia Adição Subtração Incremento Decremento

(4)

OP. LÓGICAS E ARITMÉTICAS

1

029 0x00 02A 0x45 02B 0xF3 02C 0x69 02D 0x46 02E 0x44 02F 0x00 19 25/04/2017 AE 1010 1110 45 0100 0101 F31111 0011 ADD AE 1010 1110 45 0100 0101 690110 1001 SUB 45 0100 0101 44 0100 0100 DEC 45 0100 0101 46 0100 0110 INC

12 – Operações aritméticas

0005 3045 MOVLW 0x45 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)

OP. LÓGICAS E ARITMÉTICAS

1

; Programa 13 - Operações lógicas

constant marqualrélio=0x45 ;dado 1 constant operador = 0xae ;dado 2 constant ondecadê= 0x2a ;endereço

ANDLW operador ;W = operador AND marqualrélio

IORLW operador ;W = operador IOR marqualrélio

XORLW operador ;W = operador XOR marqualrélio

COMF ondecadê+4,1 ;SRAM(ondecadê+4) = COM SRAM(ondecadê+4)

RLF ondecadê+5,1 ;SRAM(ondecadê+5) = RL SRAM(ondecadê+5)

RRF ondecadê+6,1 ;SRAM(ondecadê+6) = RR SRAM(ondecadê+6)

SWAPF ondecadê+7,1 ;SRAM(ondecadê+7) = SWAP SRAM(ondecadê+7)

end ;fim 20 25/04/2017

13 – Operações lógicas

Cópia AND OR XOR COM RL RR SWAP

*Esta linha pode ser removida.

OP. LÓGICAS E ARITMÉTICAS

1

AE 1010 1110 45 0100 0101 04 0000 0100 AND 21 25/04/2017

13 – Operações lógicas

AE 1010 1110 45 0100 0101 EF1110 1111 IOR 45 0100 0101 BA1011 1010 COM AE 1010 1110 45 0100 0101 EB1110 1011 XOR 145 1 0100 0101 08B0 1000 1011 RL 045 0 0100 0101 0221 0010 0010 RR 45 0100 0101 540101 0100 SWAP 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

OP. LÓGICAS E ARITMÉTICAS

1

22 25/04/2017

13 – Operações lógicas

145 1 0100 0101 08B 0 1000 1011 RL RR 045 0 0100 0101₀₂₂_{1 0010 0010}

• 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.

OP. LÓGICAS E ARITMÉTICAS

1

; Programa 14 - Operações com literais (LW)

constant marqualrélio= 0x45 ;dado 1 constant operador = 0xae ;dado 2 constant ondecadê= 0x20 ;endereço

end ;fim

23 25/04/2017

14 – Operações com literais (LW)

Cópia ADD SUB AND IOR XOR T rê s lin h a s por o p e ra çã o

OP. LÓGICAS E ARITMÉTICAS

1

MOVLW marqualrélio;W = marqualrélio

MOVLW marqualrélio;W = marqualrélio*

24 25/04/2017

14 – Operações com literais (LW)

AE 1010 1110 45 0100 0101 EB1110 1011 XOR AE 1010 1110 45 0100 0101 EF1110 1111 IOR AE 1010 1110 45 0100 0101 040000 0100 AND AE 1010 1110 45 0100 0101 690110 1001 SUB AE 1010 1110 45 0100 0101 F31111 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

(5)

OP. LÓGICAS E ARITMÉTICAS

1

25 25/04/2017

15 – Operações sobre bytes (WF), d=1

; Programa 15 - Operações sobre bytes (WF), d=1

constantmarqualrélio=0x45 ;dado 1 constantoperador = 0xae ;dado 2 constantondecadê= 0x20 ;endereço

MOVWF ondecadê ;SRAM(ondecadê) = W ;esta etapa representa ações anteriores quaisquer

MOVLW operador ;W = operador

MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W ;esta é a etapa que interessa

ADDWF ondecadê+1,1 ;SRAM(ondecadê+1) = SRAM(ondecadê+1) ADD W

SUBWF ondecadê+2,1 ;SRAM(ondecadê+2) = SRAM(ondecadê+2) SUB W

ANDWF ondecadê+3,1 ;SRAM(ondecadê+3) = SRAM(ondecadê+3) AND W

IORWF ondecadê+4,1 ;SRAM(ondecadê+4) = SRAM(ondecadê+4) IOR W

XORWF ondecadê+5,1 ;SRAM(ondecadê+5) = SRAM(ondecadê+5) XOR W

end ;fim

OP. LÓGICAS E ARITMÉTICAS

1

26 25/04/2017

15 – Operações sobre bytes (WF), d=1

AE 1010 1110 45 0100 0101 EB1110 1011 XOR AE 1010 1110 45 0100 0101 EF1110 1111 IOR AE 1010 1110 45 0100 0101 040000 0100 AND AE 1010 1110 45 0100 0101 690110 1001 SUB AE 1010 1110 45 0100 0101 F31111 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

OP. LÓGICAS E ARITMÉTICAS

1

27 25/04/2017

16 – Operações sobre bytes (WF), d=0

; Programa 16 - Operações sobre bytes (WF), d=0 org 0x5;posição inicial constant marqualrélio=0x45;dado 1 constant operador = 0xae;dado 2 constant ondecadê= 0x20;endereço

MOVWF ondecadê ;SRAM(ondecadê) = W ;esta etapa representa ações anteriores quaisquer

MOVLW operador ;W = operador

MOVWF ondecadê+5 ;SRAM(ondecadê+5) = W ;esta é a etapa que interessa

ADDWF ondecadê+1,0 ;W = SRAM(ondecadê+1) ADD W

SUBWF ondecadê+2,0 ;W = SRAM(ondecadê+2) SUB W

ANDWF ondecadê+3,0 ;W = SRAM(ondecadê+3) AND W

IORWF ondecadê+4,0 ;W = SRAM(ondecadê+4) IOR W

XORWF ondecadê+5,0 ;W = SRAM(ondecadê+5) XOR W

end ;fim ADD SUB AND IOR XOR

OP. LÓGICAS E ARITMÉTICAS

1

28 25/04/2017

16 – Operações sobre bytes (WF), d=0

AE 1010 1110 45 0100 0101 EB1110 1011 XOR AE 1010 1110 45 0100 0101 EF1110 1111 IOR AE 1010 1110 45 0100 0101 040000 0100 AND AE 1010 1110 45 0100 0101 690110 1001 SUB AE 1010 1110 45 0100 0101 F31111 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

OP. LÓGICAS E ARITMÉTICAS

1

29 25/04/2017

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ção d=1 é a recomendada.

• Outra aplicação para d=0 é quando se deseja preservar o dado obtido mas se precisa efetuar mais cálculos sobre ele.

OP. LÓGICAS E ARITMÉTICAS

1

; Programa 17 - Operações com três entradas literais

constant dado1 =0x01 ;dado 1

MOVLW dado1 ;W = dado 1

ADDLW dado2 ;W = dado 2 + W

ADDLW dado3 ;W = dado 3 + W

end ;fim

30 25/04/2017

17 – Operações com três entradas literais

0005 3001 MOVLW 0x01 0006 3E02 ADDLW 0x02 0007 3E04 ADDLW 0x04

(6)

OP. LÓGICAS E ARITMÉTICAS

1

31 25/04/2017

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.

OP. LÓGICAS E ARITMÉTICAS

1

; Programa 18 – Operações com três entradas registradas

constant ondecadê1 = 0x21;endereço 1

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

32 25/04/2017

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

OP. LÓGICAS E ARITMÉTICAS

1

33 25/04/2017

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

OP. LÓGICAS E ARITMÉTICAS

1

34 25/04/2017

19 – Operações de uma entrada

; Programa 19 – Operações de uma entrada

constantmarqualrélio=0x45 ;dado

constantondecadê= 0x20 ;endereço

COMF ondecadê+1,1 ;SRAM(ondecadê+1) = COM SRAM(ondecadê+1) RLF ondecadê+2,1 ;SRAM(ondecadê+2) = RL SRAM(ondecadê+2) RRF ondecadê+3,1 ;SRAM(ondecadê+3) = RR SRAM(ondecadê+3) SWAPF ondecadê+4,1 ;SRAM(ondecadê+4) = SWAP SRAM(ondecadê+4) INCF ondecadê+5,1 ;SRAM(ondecadê+5) = INC SRAM(ondecadê+5) DECF ondecadê+6,1 ;SRAM(ondecadê+6) = DEC SRAM(ondecadê+6) CLRF ondecadê+7 ;SRAM(ondecadê+7) = CLR SRAM(ondecadê+7)

end ;fim

OP. LÓGICAS E ARITMÉTICAS

1

35 25/04/2017

19 – Operações de uma entrada

DEC 45 0100 0101 440100 0100 INC 45 0100 0101 460100 0110 SWAP45 0100 0101₅₄_{0101 0100} COM45 0100 0101_BA_{1011 1010} RL 145 1 0100 0101₀_8B_{0 1000 1011}

RR 045 0 0100 0101₀₂₂_{1 0010 0010} 0005 3045 MOVLW 0x45 _{0006 00A1 MOVWF 0x21} 0007 00A2 MOVWF 0x22 0008 00A3 MOVWF 0x23 0009 00A4 MOVWF 0x24 000A 00A5 MOVWF 0x25 000B 00A6 MOVWF 0x26 000C 00A7 MOVWF 0x27 000D 09A1 COMF 0x21, 0x1 000E 0DA2 RLF 0x22, 0x1 000F 0CA3 RRF 0x23, 0x1 0010 0EA4 SWAPF 0x24, 0x1 0011 0AA5 INCF 0x25, 0x1 0012 03A6 DECF 0x26, 0x1 0013 01A7 CLRF 0x27 021 0xBA 022 0x8B 023 0x22 024 0x54 025 0x46 026 0x44 027 0x00 COMF ondecadê+1,1 RLF ondecadê+2,1 RRF ondecadê+3,1 SWAPF ondecadê+4,1 INCF ondecadê+5,1 DECF ondecadê+6,1 CLRF ondecadê+7

OP. LÓGICAS E ARITMÉTICAS

1

36 25/04/2017

; Programa 20 – Operações sobre bits – BSF

org 0x5;posição inicial

constant ondecadê= 0x20 ;endereço

CLRF ondecadê ;SRAM(ondecadê) = 0x00

MOVF ondecadê,0 ;W = SRAM(ondecadê)

BSF ondecadê,0 ;SRAM(ondecadê), bit 0 = 1

end ;fim 00000000b 00000001b 00000011b 00000111b 00001111b 00011111b 10011111b

20 – Operações sobre bits – BSF

0005 01A0 CLRF 0x20 0006 0820 MOVF 0x20, 0x0 0007 00A1 MOVWF 0x21 0008 1420 BSF 0x20, 0x0 0009 0820 MOVF 0x20, 0x0 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

(7)

OP. LÓGICAS E ARITMÉTICAS

1

37 25/04/2017

; Programa 21 – Operações sobre bits – BCF

constant ondecadê= 0x20 ;endereço

COMF ondecadê,1 ;SRAM(ondecadê) = 0xFF

BCF ondecadê,0 ;SRAM(ondecadê), bit 0 = 0

end ;fim 11111111b 11111110b 11111100b 11111000b 11110000b 11100000b 01100000b

21 – Operações sobre bits – BCF

0005 01A0 CLRF 0x20 0006 09A0 COMF 0x20, 0x1 0007 0820 MOVF 0x20, 0x0 0008 00A1 MOVWF 0x21 0009 1020 BCF 0x20, 0x0 000A 0820 MOVF 0x20, 0x0 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

OP. LÓGICAS E ARITMÉTICAS

1

38 25/04/2017

; 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

BCF STATUS,C ;bit C do status register = 0

MOVF STATUS,W ;W = SRAM(STATUS)

BSF STATUS,C ;bit C do status register = 1

MOVF STATUS,W ;W = SRAM(STATUS)

end ;fim 0005 3045 MOVLW 0x45 0006 00A0 MOVWF 0x20 0007 1003 BCF 0x03, 0x0 0008 0803 MOVF 0x03, 0x0 0009 00A1 MOVWF 0x21 000A 1403 BSF 0x03, 0x0 000B 0803 MOVF 0x03, 0x0 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, BSF

Status Register 020 0x45 021 0x1A 022 0x1B 023 0x8A 024 0x8B 025 0x22 026 0xA2

• A diretiva#include<p16f877.inc>

é necessária.

OP. LÓGICAS E ARITMÉTICAS

1

39 25/04/2017

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

MOVLW 0x45 ;W = 0x45

SUBLW 0xae ;W = 0xAE - 0x45

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 – W W = 0xAE – 0x45 W = L – W W = 0x45 – 0xAE 0000 3045 MOVLW 0x45 0001 00A0 MOVWF 0x20 0002 30AE MOVLW 0xae 0003 00A1 MOVWF 0x21 0004 3045 MOVLW 0x45 0005 3CAE SUBLW 0xae 0006 00A2 MOVWF 0x22 0007 30AE MOVLW 0xae 0008 3C45 SUBLW 0x45 0009 00A3 MOVWF 0x23 020 0x45 021 0xAE 022 0x69 023 0x97 AEh – 45h = 69h 100h + 45h – AEh = 97h AEh – 45h: C = 1 45h – AEh: C = 0

ENDEREÇAMENTO DA SRAM

2 ENDEREÇAMENTO DA SRAM

40 25/04/2017

ENDEREÇAMENTO DA SRAM

2

41 25/04/2017

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=1; RP0=1 banco 3 BSF 0x03,0x6 ;* BSF 0x03,0x5 MOVWF 0x20 ;SRAM(0x1A0) = W end ;fim

0000 3045 MOVLW 0x45 0001 1303 BCF 0x03, 0x6 0002 1283 BCF 0x03, 0x5 0003 00A0 MOVWF 0x20 0004 1303 BCF 0x03, 0x6 0005 1683 BSF 0x03, 0x5 0006 00A0 MOVWF 0x20 0007 1703 BSF 0x03, 0x6 0008 1283 BCF 0x03, 0x5 0009 00A0 MOVWF 0x20 000A 1703 BSF 0x03, 0x6 000B 1683 BSF 0x03, 0x5 000C 00A0 MOVWF 0x20 Status Register

ENDEREÇAMENTO DA SRAM

2

42 25/04/2017

25 – Endereçamento dos bancos com rótulos

; Programa 25 – Endereçamento dos bancos com rótulos

#include<p16f877.inc> ;definição da PIC

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

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

(8)

ENDEREÇAMENTO DA SRAM

2

43 25/04/2017

26 – Efeito do overflow do endereço da SRAM

; Programa 26 – Efeito do overflow do endereço

constantondecadê= 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

• O endereço 80h é inválido, pois podem ser usados, somente, sete bits para o file address. • Isto significa que 80h é convertido para 00h. • Ocorre overflow 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

ENDEREÇAMENTO DA SRAM

2

44 25/04/2017

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.

ENDEREÇAMENTO DA SRAM

2

45 25/04/2017

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

ENDEREÇAMENTO DA SRAM

2

46 25/04/2017

; Programa 27 – Endereçamento indireto da SRAM

#include<p16f877.inc>;definição da PIC

MOVLW 0x20 ;W = 0x20 Banco 0

MOVWF FSR ;SRAM(FSR) = W

MOVLW 0xaa ;W = 0xAA

MOVWF INDF ;SRAM(0x20) = W

MOVLW 0xa0 ;W = 0xA0 Banco 1

MOVLW 0xaa ;W = 0xAA

MOVWF INDF ;SRAM(0xA0) = W

end ;fim

27 – Endereçamento indireto da SRAM

0005 3020 MOVLW 0x20 0006 0084 MOVWF 0x04 0007 30AA MOVLW 0xaa 0008 0080 MOVWF 0x00 0009 30A0 MOVLW 0xa0 000A 0084 MOVWF 0x04 000B 30AA MOVLW 0xaa 000C 0080 MOVWF 0x00

ENDEREÇAMENTO DA SRAM

2

47 25/04/2017

; Programa 28 – Endereçamento indireto da SRAM e IRP #include <p16f877.inc>;definição da PIC

BCF STATUS,IRP ;STATUS(IRP) = 0

MOVLW 0x20 ;W = 0x20

MOVLW 0xbb ;W = 0xBB

MOVWF INDF ;SRAM(INDF) = W

BSF STATUS,IRP ;STATUS(IRP) = 0

MOVLW 0x20 ;W = 0x20

MOVLW 0xbb ;W = 0xBB

end ;fim

28 – Endereçamento indireto da SRAM e IRP

0005 1383 BCF 0x03, 0x7 0006 3020 MOVLW 0x20 0007 0084 MOVWF 0x04 0008 30BB MOVLW 0xbb 0009 0080 MOVWF 0x00 000A 1783 BSF 0x03, 0x7 000B 3020 MOVLW 0x20 000C 0084 MOVWF 0x04 000D 30BB MOVLW 0xbb 000E 0080 MOVWF 0x00

ENDEREÇAMENTO DA SRAM

2

48 25/04/2017

Endereçamento indireto da SRAM

(9)

ENDEREÇAMENTO DA SRAM

2

49 25/04/2017

Endereçamento indireto da SRAM

• O endereçamento indireto permite que o

programa decida qual o endereço a ser acessado. • Com endereçamento direto, não é possível interpretar o conteúdo de um registrador como o endereço de outro registrador.

• Com endereçamento indireto, o conteúdo de um registrador pode ser copiado para FSR, que é usado como o endereço de 8 bits para outro registrador.

ENDEREÇAMENTO DA SRAM

2

50 25/04/2017

; Programa 29 – Endereço e dado indiretos

constantondecadê1 = 0x20;endereço que contém o endereço

constantondecadê2 = 0x21;endereço que contém o dado BCF STATUS,IRP ;STATUS(IRP) = 0 MOVF ondecadê1,W ;W = SRAM(ondecadê1)

MOVF ondecadê2,W ;W = SRAM(ondecadê2)

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

DESVIOS

3 DESVIOS

51 25/04/2017

DESVIOS

3

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 52 25/04/2017

30 – GOTO com argumento numérico

; Programa 30 - GOTO com argumento numérico

CLRF ondecadê ;não importa

MOVF ondecadê,0 ;não importa

MOVWF ondecadê+1 ;não importa

BSF ondecadê,2 ;não importa

GOTO 0x00a ;11 bits

BSF ondecadê,7 ;não importa

end ;fim _Pulado

Pulado

020 0x04 021 0x00 022 0x05 023 0x00

• Experimente usar, como argumento do GOTO, um valor inferior ao do endereço da instrução GOTO.

DESVIOS

3

53 25/04/2017

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.

DESVIOS

3

54 25/04/2017

31 – GOTO com argumento simbólico

; Programa 31 - GOTO com argumento simbólico

constant ondecadê=0x20;endereço SRAM

constant ondegoto=0x00a;endereço FLASH; 11 bits CLRF ondecadê MOVF ondecadê,0 MOVWF ondecadê+1 BSF ondecadê,0 MOVF ondecadê,0 MOVWF ondecadê+2

GOTO ondegoto ;11 bits BSF ondecadê,1 MOVF ondecadê,0 MOVWF ondecadê+3 end ;fim 0000 01A0 CLRF 0x20 0001 0820 MOVF 0x20, 0x0 0002 00A1 MOVWF 0x21 0003 1520 BSF 0x20, 0x2 0004 0820 MOVF 0x20, 0x0 0005 00A2 MOVWF 0x22 0006 281F GOTO 0x00a 0007 17A0 BSF 0x20, 0x7 0008 0820 MOVF 0x20, 0x0 0009 00A3 MOVWF 0x23 000A 3FFF 000B 3FFF 000C 3FFF 000D 3FFF 000E 3FFF 000F 3FFF 0010 3FFF

(10)

DESVIOS

3

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 55 25/04/2017

32 – GOTO com argumento numérico

Pulado

; Programa 32 – GOTO com argumento numérico

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

DESVIOS

3

56 25/04/2017

• 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

DESVIOS

3

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 57 25/04/2017

33 – GOTO com rótulo absoluto

Pulado

; Programa 33 - GOTO com rótulo absoluto

org 0xa ;alterar

constant ondecadê=0x20;endereço

GOTO ali ;11 bits

ali

end ;fim ali = 17h Pulado Pulado 021 0x00 022 0x01 023 0x03 024 0x00 025 0x0B 026 0x1B 027 0x9B

DESVIOS

3

58 25/04/2017

33 – GOTO com rótulo absoluto

• O rótulo pode ser colocado na própria linha onde se encontra a instrução para onde o salto é direcionado.

• Experimente colocar o rótulo “ali” antes da linha onde a instrução GOTO se encontra.

DESVIOS

3

59 25/04/2017

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

DESVIOS

3

60 25/04/2017

• Ao usar a instrução GOTO, é preciso cuidar para que o jump não tente passar de uma página para outra.

• Na ocorrência do overflow do argumento da instrução GOTO, os bits excedentes são simplesmente ignorados.

• A instrução GOTO, naturalmente, não permite a troca de página. Jumps entre páginas não são permitidos.

• Mais adiante será visto um

procedimento para o uso da instrução GOTO em jumps entre páginas.

(11)

DESVIOS

3

61 25/04/2017

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.

DESVIOS

3

62 25/04/2017

; Programa 35 - GOTO com rótulo relativo

org 0xa ;alterar

constantondecadê=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

35 – GOTO com rótulo relativo

$ = 0x13h $+4 = 0x17h • Este programa gera o

mesmo disassembly do programa 33. Pulado Pulado

DESVIOS

3

63 25/04/2017

• Embora o valor $+n possa ser entendido como linhas acima ou abaixo no código

assembly (arquivo“.asm”), ele indica, de fato,

linhas acima ou abaixo no código montado, isto é, opcode’s acima ou abaixo.

• Códigos não-assembly, como linha em

branco, linha de comentário, linha de definição de constantes, etc., não são considerados. • Todas as linhas que não gerem opcode no

disassembler são ignoradas.

• Se linhas são adicionadas ou removidas entre a instrução GOTO e o destino do salto, o argumento deve ser recalculado.

GOTO com rótulo relativo

DESVIOS

3

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 64 25/04/2017

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.

DESVIOS

3

65 25/04/2017

35 – CALL

DESVIOS

3

66 25/04/2017

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...

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.

(12)

DESVIOS

3

67 25/04/2017 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

DESVIOS

3

68 25/04/2017

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.

DESVIOS

3

69 25/04/2017 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

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

DESVIOS

3

70 25/04/2017

38 – Programa anterior sem o uso de CALL

; Programa 38 - Programa anterior sem o uso de CALL

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

DESVIOS

3

71 25/04/2017

39 – Programa anterior sem o uso de GOTO

; Programa 39 - Programa anterior sem o uso de GOTO

CLRF PCLATH ;*

BCF STATUS,C ;escolher entre BSF e BCF MOVLW 0x0c

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

DESVIOS

3

72 25/04/2017

40 – CALL sem RETURN

; Programa 39 - CALL sem RETURN - Proibido

BTFSC STATUS,C ;se C=1 então...

RotinaC0 MOVLW 0x03 MOVWF 0x20 CLRF 0x21 GOTO Fim RotinaC1 MOVLW 0x04 MOVWF 0x21 CLRF 0x20 GOTO Fim Fim end

• Este programa funciona, mas dá erro na pilha. • Para cada CALL, deve existir um RETURN. • Não é correto o uso de CALL sem RETURN.

0005 BCF 0x03, 0x0 0006 BTFSS 0x03, 0x0 0007 CALL 0x00a 0008 BTFSC 0x03, 0x0 0009 CALL 0x00e 000A MOVLW 0x03 000B MOVWF 0x20 000C CLRF 0x21 000D GOTO 0x012 000E MOVLW 0x04 000F MOVWF 0x21 0010 CLRF 0x20 0011 GOTO 0x012

(13)

DESVIOS

3

73 25/04/2017

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.

DESVIOS

3

74 25/04/2017

Não uso da instrução CALL

• Quando há desvios para sub-rotinas que tenham

mais pontos de chamada e, após o retorno, o programa deve prosseguir a partir do ponto onde estava antes da chamada, então é recomendado o uso do CALL, pois, cada ponto de chamada produzirá um RETURN diferente com base no endereço diferente contido na TOS.

• Se, mesmo nesse tipo de situação, for necessário eliminar o CALL, por motivo de stack overflow, então é preciso criar várias cópias da sub-rotina, uma para cada ponto de chamada.

DESVIOS

3

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 75 25/04/2017

41 – Uma sub-rotina dentro de outra

; Programa 41 - Uma sub-rotina dentro da outra

org 0x5

GOTO Fim

RotinaC0

MOVLW 0x03 MOVWF 0x20

CLRF 0x21

CALL RotinaC1 ;executa RotinaC1 RETURN RotinaC1 MOVLW 0x04 MOVWF 0x21 CLRF 0x20 RETURN Fim end 020 0x03 021 0x04

DESVIOS

3 Escopo de GOTO e CALL

76 25/04/2017

• O argumento das instruções GOTO e CALL tem 11 bits. • O argumento pode variar de 000h até 7FFh.

• As instruções GOTO e CALL não permitem mudança de página da program memory.

• Ao usar rótulo absoluto, é preciso verificar se o local do programa onde este rótulo está colocado não pertence a uma página diferente do local onde a instrução GOTO ou CALL se encontram.

• Ao usar rótulo relativo ($), é preciso verificar se o deslocamento do PC não apontaria para uma outra página. • Qualquer tentativa de mudança de página nas instruções

GOTO e CALL implica na eliminação de PC<12:11>, levando o PC para um local errado.

TEMPORIZADORES

4 TEMPORIZADORES

77 25/04/2017

TEMPORIZADORES

4 Criação de um temporizador

• A MCU é muito rápida na percepção humana.

• Uma única variável de 8 bits não é suficiente para criar um tempo de duração útil.

• Quanto maior for o tempo de espera, maior é o número de variáveis (GPR´s) necessários.

• Por meio da escolha do valor inicial destas variáveis na linha de código ASM, pode-se configurar a temporização.

78 25/04/2017

(14)

TEMPORIZADORES

4

• A variável de contagem pode ser qualquer GPR.

• O modo mais fácil de comparação de um valor é verificando se ele é zero.

• Um zero pode ser identificado por meio do bit “Z” do status

register ou por meio das instruções do tipo“skip if zero”.

• Como a verificação é feita sobre o zero, então este é o valor final da contagem.

• A contagem é decrescente.

• A contagem é encerrada quando o valor zero é obtido. • A máxima contagem é feita com o GPR valendo

inicialmente FFh.

• A mínima contagem é feita com o GPR valendo inicialmente 01h. 79 25/04/2017

Criação de um temporizador

TEMPORIZADORES

4 42 – Temporizador com uma variável

80 25/04/2017

; Programa 42 - Temporizador com uma variável

org 0x5

constant TEMPO = 0x20

constant VALOR = 0x0f ;configurável

MOVLW VALOR

MOVWF TEMPO

DECFSZ TEMPO, F

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.

TEMPORIZADORES

4 42 – Temporizador com uma variável

81 25/04/2017

Use o comando animate para observar a contagem.

TEMPORIZADORES

4 42 – Temporizador com uma variável

82 25/04/2017

Experimente abaixar a frequência até que aconteça um WDT time out.

TEMPORIZADORES

4

; Programa 43 - Proteção do WDT

org 0x5

constant TEMPO = 0x20

MOVLW VALOR MOVWF TEMPO CLRWDT DECFSZ TEMPO, F GOTO $-0x2 end

43 – Proteção do WDT

83 25/04/2017

• 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

TEMPORIZADORES

4 Cálculo aproximado do tempo

84 25/04/2017 CLRWDT DECFSZ TEMPO,F 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.

(15)

TEMPORIZADORES

4 Cálculo aproximado do tempo

85 25/04/2017

• O CLRWDT é 1TCY.

• O DECFSZ e o GOTO são 2TCY.

• O ciclo de contagem é 1TCY+ 2TCY+ 2TCY= 5TCY.

• O ciclo total é (145TCY) + 3TCY= 73TCY.

• Considerar as duas operações de movimentação.

• Tempo = 73TCY+ 1TCY+ 1TCY= 75TCY. • 1TCY = 4TOSC. • 75TCY = 300TOSC. • fOSC = 20MHz (suposição). • TOSC = 50ns. • 300TOSC = 15s. CLRWDT DECFSZ TEMPO,F GOTO $-0x2

TEMPORIZADORES

4

86 25/04/2017

44 – Contador de dois bytes

; Programa 44 - Contador de dois bytes

org 0x5

constant TEMPOA =0x20 constant TEMPOB =0x21

MOVLW VALOR MOVWF TEMPOB MOVWF TEMPOA CLRWDT DECFSZ TEMPOA, F GOTO $-0x2 DECFSZ TEMPOB, F 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

TEMPORIZADORES

4

87 25/04/2017

45 – Contador de três bytes

; Programa 45 – Contador de três bytes

org 0x5

constantTEMPOA =0x20 constantTEMPOB =0x21 constantTEMPOC =0x22 constantVALOR = 0xff ;configurável

MOVLW VALOR MOVWF TEMPOC MOVWF TEMPOB MOVWF TEMPOA CLRWDT DECFSZ TEMPOA, F GOTO $-0x2 DECFSZ TEMPOB, F GOTO $-0x5 DECFSZ TEMPOC, F GOTO $-0x8 end MOVLW 0xff MOVWF 0x22 MOVWF 0x21 MOVWF 0x20 CLRWDT DECFSZ 0x20, 0x1 GOTO 0x009 DECFSZ 0x21, 0x1 GOTO 0x008 DECFSZ 0x22, 0x1 GOTO 0x007

TEMPOA: Variável menos significativa TEMPOC: Variável mais significativa

TEMPORIZADORES

4

88 25/04/2017

Parâmetros iniciais independentes

Espera MOVLW VALORC MOVWF TEMPOC MOVLW VALORB MOVWF TEMPOB MOVLW VALORA MOVWF TEMPOA CLRWDT DECFSZ TEMPOA,F GOTO $-0x2 DECFSZ TEMPOB,F GOTO $-0x6 DECFSZ TEMPOC,F GOTO $-0xa RETURN Retorna a quantidade de linhas mencionada Valores que definem a temporização 0x01 a 0xff

Não aceitam valor 0x00 constantTEMPOA =0x20 constantTEMPOB =0x21 constantTEMPOC =0x22 Na lista de definições: Rotina “Espera” Endereços arbitrários

TEMPORIZADORES

4

; Programa 46 – Configuração 31h C2h 28h 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, F GOTO $-0x2 DECFSZ TEMPOB, F GOTO $-0x6 DECFSZ TEMPOC, F GOTO $-0xa end 89 25/04/2017

46 – Configuração 31h C2h 28h

• 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

TEMPORIZADORES

4

90 25/04/2017

; Programa 47 – Quatro variáveis

org 0x5

constantVALORA = 0x31 ;configurável

constantVALORB = 0xc2 ;configurável

constantVALORC = 0x8d ;configurável

constantVALORD = 0xff ;configurável

constantTEMPOA = 0x20 constantTEMPOB = 0x21 constantTEMPOC = 0x22 constantTEMPOD = 0x23 MOVLW VALORD MOVWF TEMPOD MOVLW VALORC MOVWF TEMPOC MOVLW VALORB MOVWF TEMPOB MOVLW VALORA MOVWF TEMPOA CLRWDT DECFSZ TEMPOA, F GOTO $-0x2-0x0 DECFSZ TEMPOB, F GOTO $-0x2-0x4 DECFSZ TEMPOC, F GOTO $-0x2-0x8 DECFSZ TEMPOD, F 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

47 – Contador de quatro bytes

(16)

TEMPORIZADORES

4

91 25/04/2017 MOVLW VALORD MOVWF TEMPOD MOVLW VALORC MOVWF TEMPOC MOVLW VALORB MOVWF TEMPOB MOVLW VALORA MOVWF TEMPOA CLRWDT DECFSZ TEMPOA, F GOTO $-0x2-0x0 DECFSZ TEMPOB, F GOTO $-0x2-0x4 DECFSZ TEMPOC, F GOTO $-0x2-0x8 DECFSZ TEMPOD, F 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.

47 – Contador de quatro bytes

TEMPORIZADORES

4

92 25/04/2017 DECFSZ TEMPOA, F GOTO $-0x2-0x0 DECFSZ TEMPOB, F GOTO $-0x2-0x4 DECFSZ TEMPOC, F GOTO $-0x2-0x8 DECFSZ TEMPOD, F GOTO $-0x2-0xc

47 – Contador de quatro bytes

• A progressão de quatro em quatro existe

porque há quatro instruções para cada

variável (MOVLW, MOVWF,DECFSZeGOTO).

• Se as variáveis tivessem todas o mesmo valor inicial, a progressão seria de três em três.

TEMPORIZADORES

4

; Programa 48 – WDT sem time out

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 93 25/04/2017

48 – WDT sem time out

Output

CORE-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.

TEMPORIZADORES

4

94 25/04/2017

49 – WDT com time out

; Programa 49 – WDT com time-out

MOVLW 0x3b MOVWF 0x22 MOVLW 0xff MOVWF 0x21 MOVLW 0xfe MOVWF 0x20 DECFSZ 0x20,0x1 GOTO 0x006 DECFSZ 0x21,0x1 GOTO 0x004 DECFSZ 0x22,0x1 GOTO 0x002 end Output

CORE-W0003: Watchdog Timer event occurred. Break in execution requested • 3.821.430 passos de contagem. • Ocorre WDT time out.

Executar um reset.

TEMPORIZADORES

4

95 25/04/2017 ; Programa 50 – Habilitação do WDT #include <P16F877.INC> __config _WDT_OFF org 0x5 constant VALOR = 0xff constant TEMPO = 0x20 MOVLW VALOR MOVWF TEMPO+0x2 MOVWF TEMPO+0x1 MOVWF TEMPO DECFSZ TEMPO,F GOTO $-0x1 DECFSZ TEMPO+0x1,F GOTO $-0x4 DECFSZ TEMPO+0x2,F GOTO $-0x7 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+0x2 MOVWF TEMPO+0x1 MOVWF TEMPO DECFSZ TEMPO,F GOTO $-0x1 DECFSZ TEMPO+0x1,F GOTO $-0x4 DECFSZ TEMPO+0x2,F GOTO $-0x7 end C O R E -W 0 0 0 3 : W a tc h d o g T im e r e v e n t o c c u rre d . Bre a k in e x e c u tio n re q u e s te d C O R E -W 0 0 1 4 : H a lte d d u e to PC in cre m e n tin g o ve r th e M a xim u m PC a d d re s s a n d w ra p p in g b a ck to Z e ro

TEMPORIZADORES

4

96 25/04/2017

51 – Habilitação do WDT sem #include

; Programa 50 – Habilitação do WDT #include<P16F877.INC> __config_WDT_OFF org 0x5 constantVALOR = 0xff constantTEMPO = 0x20 MOVLW VALOR MOVWF TEMPO+0x2 MOVWF TEMPO+0x1 MOVWF TEMPO DECFSZ TEMPO,F GOTO $-0x1 DECFSZ TEMPO+0x1,F GOTO $-0x4 DECFSZ TEMPO+0x2,F GOTO $-0x7 end

; Programa 51 – Desabilitação do WDT sem #include __config 0x3ffb org 0x5 constant VALOR = 0xff constant TEMPO = 0x20 MOVLW VALOR MOVWF TEMPO+0x2 MOVWF TEMPO+0x1 MOVWF TEMPO DECFSZ TEMPO,F GOTO $-0x1 DECFSZ TEMPO+0x1,F GOTO $-0x4 DECFSZ TEMPO+0x2,F GOTO $-0x7 end