Parte 7 ASSEMBLER. OPERAÇÕES LÓGICAS E ARITMÉTICAS 2. ENDEREÇAMENTO DA SRAM.... 2 Programa vazio OPERAÇÕES LÓGICAS E ARITMÉTICAS ---------------------------------------------------------------------- Debug build of project `E:\Documentos\marco2.mcp' started. Language tool versions: MPASMWIN.exe v., mplink.exe v.2, mplib.exe v.2 Preprocessor symbol ` DEBUG' is defined. Fri May :7: 202 ---------------------------------------------------------------------- Make: The target "E:\Documentos\marco2.o" is out of date. Executing: "C:\Program Files\Microchip\MPASM Suite\MPASMWIN.exe" /q /pf877 "marco2.asm" /l"marco2.lst" /e"marco2.err" /d DEBUG= Make: The target "E:\Documentos\marco2.cof" is out of date. Executing: "C:\Program Files\Microchip\MPASM Suite\mplink.exe" /pf877 "marco2.o" /u_debug /z MPLAB_BUILD= /z MPLAB_DEBUG= /o"marco2.cof" /M"marco2.map" /W /x MPLINK.2, Linker Device Database Version.7 Copyright (c) 998-20 Microchip Technology Inc. Errors : 0 ---------------------------------------------------------------------- Debug build of project `E:\Documentos\marco2.mcp' succeeded. Language tool versions: MPASMWIN.exe v., mplink.exe v.2, mplib.exe v.2 Preprocessor symbol ` DEBUG' is defined. Fri May :7:9 202 ---------------------------------------------------------------------- BUILD SUCCEEDED 2 Programa vazio com comentário ; Programa 2 Vazio Este programa emprega um comentário e uma diretiva, respectivamente. Nenhuma instrução é usada. É gerado um código assembly vazio. É recomado que a primeira linha do código assembly seja um comentário explicativo do programa. Definição da PIC ; Programa - Arquivo de inclusão #include <pf877.inc> ;definição da PIC 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 Definição de constante Constantes ; Programa - Definição de constante #include <pf877.inc> ;definição da PIC constant marqualrélio = 0x20 ;definição da constante 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. 7 Significado Tamanho Mínimo Máximo Destiny address bit 0x0 0x Bit address bits 0x0 0x7 File address 7 bits 0x00 0x7f Literal 8 bits 0x00 0xff Program Address bits 0x000 0x7ff Os zeros à esquerda não podem ser eliminados. 8 Constantes do tipo File Definição da posição inicial do programa ; Programa - Definição da posição inicial do programa #include <pf877.inc> ;definição da PIC 0x ;posição inicial (-bit) constant marqualrélio = 0x0a ;definição da constante 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 ereço escolhido corresponde a um SFR, o nome da constante não aparece na lista. 9 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 bits. A rigor, a diretiva deveria ser 0x000. 0 Realização de uma escrita direta na SRAM Daqui por diante, a diretiva #include <pf877.inc> será usada somente quando necessário. ; Programa - Gravação de registrador 0xfff ;posição inicial 0xaa ;W = 0xaa 0x2a ;SRAM(0x2a) = W 7 Efeito do valor inicial do acumulador ; Programa 7 - Efeito do valor inicial do acumulador 0x ;posição inicial CLRW ;limpa o acumulador ADDLW 0xaa ;W = 0xaa + W 0x2a ;SRAM(0x2a) = W File Registers Address Hex 027 0x00 028 0x00 029 0x00 02A 0xAA 02B 0x00 02C 0x00 02D 0x00 Program Memory Address Opcode Disassembly 000 00 CLRW 000 EAA ADDLW 0xaa 0007 00AA 0x2a 2
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:. 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 (0xfff), 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. 8 Realização de uma adição com label ; Programa 8 - Realização de uma adição com label 0x ;posição inicial constant marqualrélio = 0xaa ;dado constant ondecadê = 0x2a ;ereço CLRW ;limpa o acumulador ADDLW marqualrélio ;W = marqualrélio + W ondecadê ;SRAM(ondecadê) = W 027 0x00 028 0x00 029 0x00 02A 0xAA 02B 0x00 02C 0x00 02D 0x00 000 00 CLRW 000 EAA ADDLW 0xaa 0007 00AA 0x2a 9 Realização de uma cópia direta 0 Realização de uma cópia indireta ; Programa 9 Realização de uma cópia direta 0x ;posição inicial 0xaa ;W = 0xaa 0x2a ;SRAM(0x2a) = W 0xaa- ;W = 0xa9 0x2a+ ;SRAM(0x2b) = W Aqui, a cópia direta significa que foram usados os valores numéricos. 027 0x00 028 0x00 029 0x00 02A 0xAA 02B 0xA9 02C 0x00 02D 0x00 000 0AA 0xaa 000 00AA 0x2a 0007 0AB 0xa9 0008 00AB 0x2b ; Programa 0 Realização de uma cópia indireta 0x ;posição inicial constant marqualrélio = 0xaa ;dado constant ondecadê = 0x2a ;ereço ondecadê ;SRAM(ondecadê) = W marqualrélio- ;W = marqualrélio- ondecadê+ ;SRAM(ondecadê+) = W Aqui, a cópia indireta significa que foram usados rótulos. 027 0x00 028 0x00 029 0x00 02A 0xAA 02B 0xA9 02C 0x00 02D 0x00 000 0AA 0xaa 000 00AA 0x2a 0007 0AB 0xa9 0008 00AB 0x2b Realização de um incremento 2 Operações aritméticas ; Programa Realização de um incremento 0x ;posição inicial constant marqualrélio = 0xaa ;dado constant ondecadê = 0x2a ;ereço ondecadê ;SRAM(ondecadê) = W INCF ;W = marqualrélio + ondecadê+ ;SRAM(ondecadê+) = W 027 0x00 028 0x00 029 0x00 02A 0xAA 02B 0xAB 02C 0x00 02D 0x00 000 0AA 0xaa 000 00AA 0x2a 0007 0A2A INCF 0x2a, 0x0 0008 00AB 0x2b 7 Cópia Adição Subtração Incremento Decremento ; Programa 2 Operações aritméticas 0x ;posição inicial constant marqualrélio = 0x ;dado constant operador = 0xae ;dado 2 constant ondecadê = 0x2a ;ereço ondecadê ;SRAM(ondecadê) = W * ADDLW operador ;W = operador ADD marqualrélio ondecadê+ ;SRAM(ondecadê+) = W SUBLW operador ;W = operador SUB marqualrélio ondecadê+2 ;SRAM(ondecadê+2) = W ondecadê+ ;SRAM(ondecadê+) = W INCF ondecadê+, ;SRAM(ondecadê+) = SRAM(ondecadê+) + ondecadê+ ;SRAM(ondecadê+) = W DECF ondecadê+, ;SRAM(ondecadê+) = SRAM(ondecadê+) *Esta linha pode ser removida. 8
2 Operações aritméticas Operações lógicas AE 00 0 ADD 000 00 F 00 SUB AE 00 0 000 00 9 00 00 000 00 INC 000 00 000 00 DEC 000 000 029 0x00 02A 0x 02B 0xF 02C 0x9 02D 0x 02E 0x 02F 0x00 Não usar letras (F ou W) 000 0 0x 000 00AA 0x2a 0007 0 0x 0008 EAE ADDLW 0xae 0009 00AB 0x2b 000A 0 0x 000B CAE SUBLW 0xae 000C 00AC 0x2c 000D 0 0x 000E 00AD 0x2d 000F 0AAD INCF 0x2d, 0x 000 0 0x 00 00AE 0x2e 002 0AE DECF 0x2e, 90x Cópia AND OR XOR COM RL RR SWAP *Esta linha pode ser removida. ; Programa - Operações lógicas 0x ;posição inicial constant marqualrélio = 0x ;dado constant operador = 0xae ;dado 2 constant ondecadê = 0x2a ;ereço ondecadê ;SRAM(ondecadê) = W * ANDLW operador ;W = operador AND marqualrélio ondecadê+ ;SRAM(ondecadê+) = W IORLW operador ;W = operador IOR marqualrélio ondecadê+2 ;SRAM(ondecadê+2) = W XORLW operador ;W = operador XOR marqualrélio ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W COMF ondecadê+, ;SRAM(ondecadê+) = COM SRAM(ondecadê+) ondecadê+ ;SRAM(ondecadê+) = W RLF ondecadê+, ;SRAM(ondecadê+) = RL SRAM(ondecadê+) ondecadê+ ;SRAM(ondecadê+) = W RRF ondecadê+, ;SRAM(ondecadê+) = RR SRAM(ondecadê+) ondecadê+7 ;SRAM(ondecadê+7) = W SWAPF ondecadê+7, ;SRAM(ondecadê+7) = SWAP SRAM(ondecadê+7) 20 AE 00 0 AND 000 00 0 0000 000 IOR XOR RL RR AE 00 0 000 00 EF 0 AE 00 0 000 00 EB 0 0 000 00 COM BA 0 00 000 00 08B 0 000 0 0 0 000 00 022 000 000 000 00 SWAP 00 000 Operações lógicas 02A 0x 02B 0x0 02C 0xEF 02D 0xEB 02E 0xBA 02F 0xB 00 0x22 0 0x 000 0 0x 000 00AA 0x2a 0007 0 0x 0008 9AE ANDLW 0xae 0009 00AB 0x2b 000A 0 0x 000B 8AE IORLW 0xae 000C 00AC 0x2c 000D 0 0x 000E AAE XORLW 0xae 000F 00AD 0x2d 000 0 0x 00 00AE 0x2e 002 09AE COMF 0x2e, 0x 00 0 0x 00 00AF 0x2f 00 0DAF RLF 0x2f, 0x 00 0 0x 007 00B0 0x0 008 0CB0 RRF 0x0, 0x 009 0 0x 00A 00B 0x 00B 0EB SWAPF 0x, 2 0x RL Operações lógicas 000 00 08B 0 000 0 RR 0 0 000 00 022 000 000 Alguma instrução anterior configurou o carry para antes da efetuação da instrução RLF. Ao efetuar a instrução RLF, o nono bit vale. 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. Ao efetuar a instrução RRF, o carry passa para. 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. 22 Cópia ADD SUB AND IOR XOR *Esta linha pode serremovida. Operações com literais (LW) ; Programa - Operações com literais (LW) 0x ;posição inicial constant marqualrélio = 0x ;dado constant operador = 0xae ;dado 2 constant ondecadê = 0x20 ;ereço ondecadê ;SRAM(ondecadê) = W * ADDLW operador ;W = operador ADD marqualrélio ondecadê+ ;SRAM(ondecadê+) = W SUBLW operador ;W = operador SUB marqualrélio ondecadê+2 ;SRAM(ondecadê+2) = W ANDLW operador ;W = operador AND marqualrélio ondecadê+ ;SRAM(ondecadê+) = W IORLW operador ;W = operador IOR marqualrélio ondecadê+ ;SRAM(ondecadê+) = W XORLW operador ;W = operador XOR marqualrélio ondecadê+ ;SRAM(ondecadê+) = W 2 Três linhas por operação 000 0 0x 000 00A0 0x20 0007 0 0x 0008 EAE ADDLW 0xae 0009 00A 0x2 000A 0 0x 000B CAE SUBLW 0xae 000C 00A2 0x22 000D 0 0x 000E 9AE ANDLW 0xae 000F 00A 0x2 000 0 0x 00 8AE IORLW 0xae 002 00A 0x2 00 0 0x 00 AAE XORLW 0xae 00 00A 0x2 Operações com literais (LW) ondecadê ;SRAM(ondecadê) = W * ADDLW operador ;W = operador ADD marqualrélio ondecadê+ ;SRAM(ondecadê+) = W SUBLW operador ;W = operador SUB marqualrélio ondecadê+2 ;SRAM(ondecadê+2) = W ANDLW operador ;W = operador AND marqualrélio ondecadê+ ;SRAM(ondecadê+) = W IORLW operador ;W = operador IOR marqualrélio ondecadê+ ;SRAM(ondecadê+) = W XORLW operador ;W = operador XOR marqualrélio ondecadê+ ;SRAM(ondecadê+) = W 020 0x 02 0xF 022 0x9 02 0x0 02 0xEF 02 0xEB ADD SUB AND IOR XOR AE 00 0 000 00 F 00 AE 00 0 000 00 9 00 00 AE 00 0 000 00 0 0000 000 AE 00 0 000 00 EF 0 AE 00 2 0 000 00 EB 0 0
Operações sobre bytes (WF), d= Operações sobre bytes (WF), d= ; Programa - Operações sobre bytes (WF), d= 0x ;posição inicial constant 0x ;dado marqualrélio = constant operador = 0xae ;dado 2 constant ondecadê = 0x20 ;ereço ondecadê ;SRAM(ondecadê) = W ;esta etapa representa ações anteriores quaisquer operador ;W = operador ondecadê+ ;SRAM(ondecadê+) = W ondecadê+2 ;SRAM(ondecadê+2) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W ;esta é a etapa que interessa ADDWF ondecadê+, ;SRAM(ondecadê+) = SRAM(ondecadê+) ADD W SUBWF ondecadê+2, ;SRAM(ondecadê+2) = SRAM(ondecadê+2) SUB W ANDWF ondecadê+, ;SRAM(ondecadê+) = SRAM(ondecadê+) AND W IORWF ondecadê+, ;SRAM(ondecadê+) = SRAM(ondecadê+) IOR W XORWF ondecadê+, ;SRAM(ondecadê+) = SRAM(ondecadê+) XOR W AE 00 0 ADD 000 00 F 00 AE 00 0 SUB 000 00 9 00 00 AE 00 0 AND 000 00 0 0000 000 AE 00 0 IOR 000 00 EF 0 AE 00 0 XOR 000 00 EB 0 0 000 0 0x 000 00A0 0x20 0007 0AE 0xae 0008 00A 0x2 0009 00A2 0x22 000A 00A 0x2 000B 00A 0x2 000C 00A 0x2 000D 0 0x 000E 07A ADDWF 0x2, 0x 000F 02A2 SUBWF 0x22, 0x 000 0A ANDWF 0x2, 0x 00 0A IORWF 0x2, 0x 002 0A XORWF 0x2, 0x 020 0x 02 0xF 022 0x9 02 0x0 02 0xEF 02 0xEB 2 2 Operações sobre bytes (WF), d=0 ADD SUB AND IOR XOR ; Programa - Operações sobre bytes (WF), d=0 0x ;posição inicial constant marqualrélio = 0x;dado constant operador = 0xae;dado 2 constant ondecadê = 0x20;ereço ondecadê ;SRAM(ondecadê) = W ;esta etapa representa ações anteriores quaisquer operador ;W = operador ondecadê+ ;SRAM(ondecadê+) = W ondecadê+2 ;SRAM(ondecadê+2) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W ;esta é a etapa que interessa ADDWF ondecadê+,0 ;W = SRAM(ondecadê+) ADD W ondecadê+ ;SRAM(ondecadê+) = W SUBWF ondecadê+2,0 ;W = SRAM(ondecadê+2) SUB W ondecadê+2 ;SRAM(ondecadê+2) = W ANDWF ondecadê+,0 ;W = SRAM(ondecadê+) AND W ondecadê+ ;SRAM(ondecadê+) = W IORWF ondecadê+,0 ;W = SRAM(ondecadê+) IOR W ondecadê+ ;SRAM(ondecadê+) = W XORWF ondecadê+,0 ;W = SRAM(ondecadê+) XOR W ondecadê+ ;SRAM(ondecadê+) = W 27 Operações sobre bytes (WF), d=0 ADD SUB AND IOR XOR AE 00 0 000 00 F 00 AE 00 0 000 00 9 00 00 AE 00 0 000 00 0 0000 000 AE 00 0 000 00 EF 0 AE 00 0 000 00 EB 0 0 000 0 0x 000 00A0 0x20 0007 0AE 0xae 0008 00A 0x2 0009 00A2 0x22 000A 00A 0x2 000B 00A 0x2 000C 00A 0x2 000D 0 0x 000E 072 ADDWF 0x2, 0x0 000F 00A 0x2 000 0 0x 00 0222 SUBWF 0x22, 0x0 002 00A2 0x22 00 0 0x 00 02 ANDWF 0x2, 0x0 00 00A 0x2 00 0 0x 007 02 IORWF 0x2, 0x0 008 00A 0x2 009 0 0x 00A 02 XORWF 0x2, 0x0 00B 00A 0x2 020 0x 02 0xF 022 0x9 02 0x0 02 0xEF 02 0xEB 28 Operações sobre bytes (WF), d=0 7 Operações com três entradas literais 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= é a recomada. Outra aplicação para d=0 é quando se deseja preservar o dado obtido mas se precisa efetuar mais cálculos sobre ele. ; Programa 7 - Operações com três entradas literais 0x ;posição inicial constant dado = 0x0 ;dado constant dado2 = 0x02 ;dado 2 constant dado = 0x0 ;dado dado ;W = dado ADDLW dado2 ;W = dado 2 + W ADDLW dado ;W = dado + W 29 000 00 0x0 000 E02 ADDLW 0x02 0007 E0 ADDLW 0x0 0
7 Operações com três entradas literais 8 Operações com três entradas registradas 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. ; Programa 8 Operações com três entradas registradas 0x ;posição inicial constant ondecadê = 0x2 ;ereço constant ondecadê2 = 0x22 ;ereço 2 constant ondecadê = 0x2 ;ereço constant ondecadê = 0x2 ;ereço ondecadê,w ;W = SRAM(ondecadê) ADDWF ondecadê2,w ;W = SRAM(ondecadê2) + W ADDWF ondecadê,w ;W = SRAM(ondecadê) + W ondecadê ;SRAM(ondecadê) = W 02 0x0 022 0x02 02 0x0 02 0x0 Digitar 000 082 0x2, 0x0 000 0722 ADDWF 0x22, 0x0 0007 072 ADDWF 0x2, 0x0 0008 00A 0x2 2 8 Operações com três entradas registradas 9 Operações de uma entrada 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 ; Programa 9 Operações de uma entrada 0x ;posição inicial constant marqualrélio = 0x ;dado constant ondecadê = 0x20 ;ereço ondecadê+ ;SRAM(ondecadê+) = W ondecadê+2 ;SRAM(ondecadê+2) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+ ;SRAM(ondecadê+) = W ondecadê+7 ;SRAM(ondecadê+7) = W COMF ondecadê+, ;SRAM(ondecadê+) = COM SRAM(ondecadê+) RLF ondecadê+2, ;SRAM(ondecadê+2) = RL SRAM(ondecadê+2) RRF ondecadê+, ;SRAM(ondecadê+) = RR SRAM(ondecadê+) SWAPF ondecadê+, ;SRAM(ondecadê+) = SWAP SRAM(ondecadê+) INCF ondecadê+, ;SRAM(ondecadê+) = INC SRAM(ondecadê+) DECF ondecadê+, ;SRAM(ondecadê+) = DEC SRAM(ondecadê+) CLRF ondecadê+7 ;SRAM(ondecadê+7) = CLR SRAM(ondecadê+7) COM RL RR SWAP INC DEC 000 00 BA 0 00 000 00 00 000 000 00 000 00 000 00 000 000 02 0xBA 022 0x8B 02 0x22 02 0x 02 0x 02 0x 027 0x00 9 Operações de uma entrada 000 00 08B 0 000 0 0 0 000 00 022 000 000 COMF RLF RRF SWAPF INCF DECF CLRF ondecadê+, ondecadê+2, ondecadê+, ondecadê+, ondecadê+, ondecadê+, ondecadê+7 000 0 0x 000 00A 0x2 0007 00A2 0x22 0008 00A 0x2 0009 00A 0x2 000A 00A 0x2 000B 00A 0x2 000C 00A7 0x27 000D 09A COMF 0x2, 0x 000E 0DA2 RLF 0x22, 0x 000F 0CA RRF 0x2, 0x 000 0EA SWAPF 0x2, 0x 00 0AA INCF 0x2, 0x 002 0A DECF 0x2, 0x 00 0A7 CLRF 0x27 000 0A0 CLRF 0x20 0007 00A 0x2 20 Operações sobre bits ; Programa 20 Operações sobre bits 0x ;posição inicial constant ondecadê = 0x20 ;ereço CLRF ondecadê ;SRAM(ondecadê) = 0x00 ondecadê+ ;SRAM(ondecadê+) = W ;SRAM(ondecadê), bit 0 = ondecadê+2 ;SRAM(ondecadê+2) = W ondecadê, ;SRAM(ondecadê), bit = ondecadê+ ;SRAM(ondecadê+) = W ondecadê,2 ;SRAM(ondecadê), bit 2 = ondecadê+ ;SRAM(ondecadê+) = W ondecadê, ;SRAM(ondecadê), bit = ondecadê+ ;SRAM(ondecadê+) = W ondecadê, ;SRAM(ondecadê), bit = ondecadê+ ;SRAM(ondecadê+) = W ondecadê,7 ;SRAM(ondecadê), bit 7 = ondecadê+7 ;SRAM(ondecadê+7) = W 000 0820 0x20, 0x0 0008 20 0x20, 0x0 0009 0820 0x20, 0x0 000A 00A2 0x22 000B A0 0x20, 0x 000C 0820 0x20, 0x0 000D 00A 0x2 000E 20 0x20, 0x2 000F 0820 0x20, 0x0 000 00A 0x2 00 A0 0x20, 0x 002 0820 0x20, 0x0 00 00A 0x2 00 20 0x20, 0x 00 0820 0x20, 0x0 00 00A 0x2 007 7A0 0x20, 0x7 008 0820 0x20, 0x0 009 00A7 0x27 02 0x00 00000000b 022 0x0 0000000b 02 0x0 000000b 02 0x07 00000b 02 0x0F 0000b 02 0xF 000b 027 0x9F 00b
7 000 0A0 CLRF 0x20 000 09A0 COMF 0x20, 0x 0007 0820 0x20, 0x0 2 Operações sobre bits BCF ; Programa 2 Operações sobre bits BCF 0x ;posição inicial constant ondecadê = 0x20 ;ereço CLRF ondecadê ;SRAM(ondecadê) = 0x00 COMF ondecadê, ;SRAM(ondecadê) = 0xFF ondecadê+ ;SRAM(ondecadê+) = W BCF ;SRAM(ondecadê), bit 0 = 0 ondecadê+2 ;SRAM(ondecadê+2) = W BCF ondecadê, ;SRAM(ondecadê), bit = 0 ondecadê+ ;SRAM(ondecadê+) = W BCF ondecadê,2 ;SRAM(ondecadê), bit 2 = 0 ondecadê+ ;SRAM(ondecadê+) = W BCF ondecadê, ;SRAM(ondecadê), bit = 0 ondecadê+ ;SRAM(ondecadê+) = W BCF ondecadê, ;SRAM(ondecadê), bit = 0 ondecadê+ ;SRAM(ondecadê+) = W 02 0xFF 022 0xFE 02 0xFC 02 0xF8 02 0xF0 02 0xE0 027 0x0 0008 00A 0x2 0009 020 BCF 0x20, 0x0 000A 0820 0x20, 0x0 000B 00A2 0x22 000C 0A0 BCF 0x20, 0x 000D 0820 0x20, 0x0 000E 00A 0x2 000F 20 BCF 0x20, 0x2 000 0820 0x20, 0x0 00 00A 0x2 002 A0 BCF 0x20, 0x 00 0820 0x20, 0x0 00 00A 0x2 00 220 BCF 0x20, 0x 00 0820 0x20, 0x0 007 00A 0x2 008 A0 BCF 0x20, 0x7 009 0820 0x20, 0x0 00A 00A7 0x27 b 0b 00b 000b 0000b 00000b 000000b 22 Operações sobre bits: RRF, RLF, BCF, Status Register ; Programa 22 Operações sobre bits: RRF, RLF, BCF, #include <pf877.inc> ;definição da PIC 0x ;posição inicial constant marqualrélio 0x ;dado = constant ondecadê = 0x20 ;ereço ondecadê ;SRAM(ondecadê) = W BCF STATUS,C ;bit C do status register = 0 STATUS,W ;W = SRAM(STATUS) ondecadê+ ;SRAM(ondecadê+) = W STATUS,C ;bit C do status register = STATUS,W ;W = SRAM(STATUS) ondecadê+2 ;SRAM(ondecadê+2) = W 020 0x 02 0xA 022 0xB 02 0x8A 02 0x8B 02 0x22 02 0xA2 ondecadê+ ;SRAM(ondecadê+) = W BCF STATUS,C ;bit C do status register = 0 RLF ondecadê+, ;SRAM(ondecadê+) = RL SRAM(ondecadê+) ondecadê+ ;SRAM(ondecadê+) = W STATUS,C ;bit C do status register = RLF ondecadê+, ;SRAM(ondecadê+) = RL SRAM(ondecadê+) ondecadê+ ;SRAM(ondecadê+) = W BCF STATUS,C ;bit C do status register = 0 RRF ondecadê+, ;SRAM(ondecadê+) = RR SRAM(ondecadê+) 00000b 00000b 0000b 00000b 0000b 000000b 00000b 000 0 0x 000 00A0 0x20 0007 00 BCF 0x0, 0x0 0008 080 0x0, 0x0 0009 00A 0x2 000A 0 0x0, 0x0 000B 080 0x0, 0x0 000C 00A2 0x22 000D 0 0x 000E 00A 0x2 000F 00 BCF 0x0, 0x0 000 0DA RLF 0x2, 0x 00 0 0x 002 00A 0x2 00 0 0x0, 0x0 00 0DA RLF 0x2, 0x 00 0 0x 00 00A 0x2 007 00 BCF 0x0, 0x0 008 0CA RRF 0x2, 0x 009 0 0x 00A 00A 0x2 00B 0 0x0, 0x0 00C 0CA RRF 0x2, 0x BCF ondecadê,7 ;SRAM(ondecadê), bit 7 = 0 ;W = SRAM(ondecadê) ondecadê+7 ;SRAM(ondecadê+7) = W 7 ondecadê+ ;SRAM(ondecadê+) = W STATUS,C RRF ondecadê+, ;bit C do status register = ;SRAM(ondecadê+) = RR SRAM(ondecadê+) A diretiva #include <pf877.inc> 8 é necessária. 2 Não comutatividade da subtração ; Programa 2 Não comutatividade da subtração 0x ;W = 0x 0x20 ;SRAM(0x20) = W 7 9 = 0 2 + (9 7) = 2 ENDEREÇAMENTO DA SRAM 0xae ;W = 0xAE 0x2 ;SRAM(0x2) = W 0x ;W = 0x SUBLW 0xae ;W = 0xAE - 0x 0x22 ;SRAM(0x22) = W 0xae ;W = 0xAE SUBLW 0x ;W = 0x - 0xAE 0x2 ;SRAM(0x2) = W AEh h: C = h AEh: C = 0 W = L W W = 0xAE 0x W = L W W = 0x 0xAE 020 0x 02 0xAE 022 0x9 02 0x97 AEh h = 9h 00h + h AEh = 97h 0000 0 0x 000 00A0 0x20 0002 0AE 0xae 000 00A 0x2 000 0 0x 000 CAE SUBLW 0xae 000 00A2 0x22 0007 0AE 0xae 0008 C SUBLW 0x 0009 00A 9 0x2 ENDEREÇAMENTO DA SRAM 0 2 ENDEREÇAMENTO DA SRAM 2 Endereçamento dos bancos sem rótulos ; Programa 2 Endereçamento dos bancos sem rótulos 0x ;W = 0x ;0x020 = 00 000000 RP=0; RP0=0 banco 0 BCF 0x0,0x BCF 0x0,0x 0x20 ;SRAM(0x020) = W ;0x0A0 = 0 000000 RP=0; RP0= banco BCF 0x0,0x ;* 0x0,0x 0x20 ;SRAM(0x0A0) = W ;0x20 = 0 000000 RP=; RP0=0 banco 2 0x0,0x BCF 0x0,0x 0x20 ;SRAM(0x20) = W ;0xA0 = 000000 RP=; RP0= banco 0x0,0x ;* 0x0,0x 0x20 ;SRAM(0xA0) = W *Esta linha pode serremovida. 0000 0 0x 000 0 BCF 0x0, 0x 0002 28 BCF 0x0, 0x 000 00A0 0x20 000 0 BCF 0x0, 0x 000 8 0x0, 0x 000 00A0 0x20 0007 70 0x0, 0x 0008 28 BCF 0x0, 0x 0009 00A0 0x20 000A 70 0x0, 0x 000B 8 0x0, 0x 000C 00A0 0x20 Status Register 2 ENDEREÇAMENTO DA SRAM 2 Endereçamento dos bancos com rótulos ; Programa 2 Endereçamento dos bancos com rótulos #include <pf877.inc> ;definição da PIC 0x ;posição inicial constant ondecadê = 0x20 ;ereço 0x ;W = 0x ;0x020 = 00 000000 RP=0; RP0=0 banco 0 BCF STATUS,RP BCF STATUS,RP0 ondecadê ;SRAM(0x020) = W ;0x0A0 = 0 000000 RP=0; RP0= banco BCF STATUS,RP ;* STATUS,RP0 ondecadê ;SRAM(0x0A0) = W ;0x20 = 0 000000 RP=; RP0=0 banco 2 STATUS,RP BCF STATUS,RP0 ondecadê ;SRAM(0x20) = W ;0xA0 = 000000 RP=0; RP0= banco STATUS,RP ;* STATUS,RP0 ondecadê ;SRAM(0xA0) = W *Esta linha pode ser removida. 000 0 0x 000 0 BCF 0x0, 0x 0007 28 BCF 0x0, 0x 0008 00A0 0x20 0009 0 BCF 0x0, 0x 000A 8 0x0, 0x 000B 00A0 0x20 000C 70 0x0, 0x 000D 28 BCF 0x0, 0x 000E 00A0 0x20 000F 70 0x0, 0x 000 8 0x0, 0x 00 00A0 0x20 Status Register 2
8 2 ENDEREÇAMENTO DA SRAM 2 Efeito do overflow do ereço da SRAM ; Programa 2 Efeito do overflow do ereço #include <pf877.inc> ;definição da PIC 0x ;posição inicial constant ondecadê = 0x7F ;ereço 0x ;W = 0x BCF STATUS,RP ;* BCF STATUS,RP0 ;* ondecadê ;SRAM(0x07F) = W ondecadê+ ;SRAM(0x000) = W O ereç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 ereçamento. 000 0 0x 000 0 BCF 0x0, 0x 0007 28 BCF 0x0, 0x 0008 00FF 0x7f 0009 0080 0x00 2 ENDEREÇAMENTO DA SRAM Endereçamento por 7 ou 9 bits O opcode, o código de máquina e o código disassembly usam 7 bits para ereço na SRAM. O MPLAB aceita um ereçamento de 9 bits, eliminando automaticamente os dois bits mais significativos. Aparece uma mensagem de aviso dizo que o registrador não se encontra no banco 0, indicando que o ereço deve conter 7 bits. Este aviso indica que o MPLAB realizou alterações no programa. *Esta linha pode serremovida. 2 ENDEREÇAMENTO DA SRAM Exemplo anterior, com ereçamento de 9 bits 2 ENDEREÇAMENTO DA SRAM 27 Endereçamento indireto da SRAM Message[02]...\ereçamento.ASM : Registerin operand not in bank 0. Ensure that bank bits are correct. Message[02]...\ereçamento.ASM 9 : Registerin operand not in bank 0. Ensure that bank bits are correct. Message[02]...\ereçamento.ASM 2 : Registerin 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 : 0x0a0 ;SRAM(0x0A0) = W Linha 9: 0x20 ;SRAM(0x20) = W Linha 2: 0xa0 ;SRAM(0xA0) = W 000 0 0x 000 0 BCF 0x0, 0x 0007 28 BCF 0x0, 0x 0008 00A0 0x20 0009 0 BCF 0x0, 0x 000A 8 0x0, 0x 000B 00A0 0x20 000C 70 0x0, 0x 000D 28 BCF 0x0, 0x 000E 00A0 0x20 000F 70 0x0, 0x 000 8 0x0, 0x 00 00A0 0x20 ; Programa 27 Endereçamento indireto da SRAM #include <pf877.inc> ;definição da PIC 0x ;posição inicial 0x20 ;W = 0x20 Banco 0 FSR ;SRAM(FSR) = W 0xaa ;W = 0xAA INDF ;SRAM(0x20) = W 0xa0 ;W = 0xA0 Banco FSR ;SRAM(FSR) = W 0xaa ;W = 0xAA INDF ;SRAM(0xA0) = W 000 020 0x20 000 008 0x0 0007 0AA 0xaa 0008 0080 0x00 0009 0A0 0xa0 000A 008 0x0 000B 0AA 0xaa 000C 0080 0x00 2 ENDEREÇAMENTO DA SRAM 28 Endereçamento indireto da SRAM e IRP ; Programa 28 Endereçamento indireto da SRAM e IRP #include <pf877.inc> ;definição da PIC 0x ;posição inicial BCF STATUS,IRP ;STATUS(IRP) = 0 0x20 ;W = 0x20 FSR ;SRAM(FSR) = W 0xbb ;W = 0xBB INDF ;SRAM(INDF) = W STATUS,IRP ;STATUS(IRP) = 0 0x20 ;W = 0x20 FSR ;SRAM(FSR) = W 0xbb ;W = 0xBB INDF ;SRAM(INDF) = W 000 8 BCF 0x0, 0x7 000 020 0x20 0007 008 0x0 0008 0BB 0xbb 0009 0080 0x00 000A 78 0x0, 0x7 000B 020 0x20 000C 008 0x0 000D 0BB 0xbb 000E 0080 0x00 2 ENDEREÇAMENTO DA SRAM Endereçamento indireto da SRAM IRP FSR 7 8
9 2 ENDEREÇAMENTO DA SRAM Endereçamento indireto da SRAM 2 ENDEREÇAMENTO DA SRAM 29 Endereço e dado indiretos O ereçamento indireto permite que o programa decida qual o ereço a ser acessado. Com ereçamento direto, não é possível interpretar o conteúdo de um registrador como o ereço de outro registrador. Com ereçamento indireto, o conteúdo de um registrador pode ser copiado para FSR, que é usado como o ereço de 8 bits para outro registrador. ; Programa 29 Endereço e dado indiretos #include <pf877.inc> ;definição da PIC 0x ;posição inicial constant ondecadê = 0x20;ereço que contém o ereço constant ondecadê2 = 0x2;ereço que contém o dado BCF STATUS,IRP ;STATUS(IRP) = 0 ondecadê,w ;W = SRAM(ondecadê) FSR ;SRAM(FSR) = W ondecadê2,w ;W = SRAM(ondecadê2) INDF ;SRAM(INDF) = W 000 8 BCF 0x0, 0x7 000 0820 0x20, 0x0 0007 008 0x0 0008 082 0x2, 0x0 0009 0080 0x00 020 0x2 02 0xAA Digitar 9 0 0 com argumento numérico 020 0x0 ; Programa 0 - com argumento numérico 02 0x00 0x20 constant ondecadê = ;ereço 022 0x0 CLRF ondecadê ;não importa 02 0x00 ;não importa ondecadê+ ;não importa ondecadê,2 ;não importa ;não importa 0000 0A0 CLRF 0x20 ondecadê+2 ;não importa 000 0820 0x20, 0x0 0002 00A 0x2 000 20 0x20, 0x2 0x00a ; bits Pulado 000 0820 0x20, 0x0 000 00A2 0x22 ondecadê,7 ;não importa 000 28F 0x00a ;não importa 0007 7A0 0x20, 0x7 ondecadê+ ;não importa 0008 0820 0x20, 0x0 0009 00A 0x2 Pulado 000A FFF 000B FFF 000C FFF 000D FFF 000E FFF 000F FFF 000 FFF Experimente usar, como argumento do, um valor inferior ao do ereço da instrução. 2 com argumento simbólico É ú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. ; Programa - com argumento simbólico constant ondecadê = 0x20 ;ereço SRAM constant ondegoto = 0x00a;ereço FLASH; bits CLRF ondecadê ondecadê+ ondecadê+2 ondegoto ; bits ondecadê, ondecadê+ 0000 0A0 CLRF 0x20 000 0820 0x20, 0x0 0002 00A 0x2 000 20 0x20, 0x2 000 0820 0x20, 0x0 000 00A2 0x22 000 28F 0x00a 0007 7A0 0x20, 0x7 0008 0820 0x20, 0x0 0009 00A 0x2 000A FFF 000B FFF 000C FFF 000D FFF 000E FFF 000F FFF 000 FFF
0 2 com argumento numérico ; Programa 2 com argumento numérico constant ondecadê = 0x20 ;ereço CLRF ondecadê ondecadê+ ondecadê+2 ondecadê, ondecadê+ 0x00d ; bits ondecadê,2 ondecadê+ ondecadê, ondecadê+ ondecadê, ondecadê+ ondecadê,7 ondecadê+7 Pulado 02 0x00 022 0x0 02 0x0 02 0x00 Pulado 02 0x0B 02 0xB 0000 0A0 CLRF 0x20 027 0x9B 000 0820 0x20, 0x0 0002 00A 0x2 000 20 0x20, 0x0 000 0820 0x20, 0x0 000 00A2 0x22 000 A0 0x20, 0x 0007 0820 0x20, 0x0 0008 00A 0x2 0009 28C 0x00D 000A 20 0x20, 0x2 000B 0820 0x20, 0x0 000C 00A 0x2 000D A0 0x20, 0x 000E 0820 0x20, 0x0 000F 00A 0x2 000 20 0x20, 0x 00 0820 0x20, 0x0 002 00A 0x2 00 7A0 0x20, 0x7 00 0820 0x20, 0x0 00 00A7 0x27 Pulado com argumento numérico O ereço real fornece, diretamente, o valor da posição da flash para onde o PC deve apontar após a instrução. 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 ereço é fácil. Ao acrescentar ou remover linhas no programa, pode ser necessário recalcular tais ereços. ; Programa - com rótulo absoluto 0xa ;alterar constant 0x20 ;ereço ondecadê = ali ondecadê,7 ;SRAM(ondecadê), bit 7 = ondecadê+7 ;SRAM(ondecadê+7) = W com rótulo absoluto CLRF ondecadê ;SRAM(ondecadê) = 0x00 ondecadê+ ;SRAM(ondecadê+) = W ;SRAM(ondecadê), bit 0 = ondecadê+2 ;SRAM(ondecadê+2) = W ondecadê, ;SRAM(ondecadê), bit = ondecadê+ ;SRAM(ondecadê+) = W ali ; bits ondecadê,2 ;SRAM(ondecadê), bit 2 = ondecadê+ ;SRAM(ondecadê+) = W ondecadê, ;SRAM(ondecadê), bit = ondecadê+ ;SRAM(ondecadê+) = W ondecadê, ;SRAM(ondecadê), bit = ondecadê+ ;SRAM(ondecadê+) = W 02 0x00 022 0x0 02 0x0 02 0x00 Pulado 02 0x0B 02 0xB 000A 0A0 CLRF 0x20 027 0x9B 000B 0820 0x20, 0x0 000C 00A 0x2 000D 20 0x20, 0x0 000E 0820 0x20, 0x0 000F 00A2 0x22 000 A0 0x20, 0x 00 0820 0x20, 0x0 Pulado 002 00A 0x2 00 287 0x07 00 20 0x20, 0x2 00 0820 0x20, 0x0 00 00A 0x2 007 A0 0x20, 0x 008 0820 0x20, 0x0 009 00A 0x2 00A 20 0x20, 0x 00B 0820 0x20, 0x0 00C 00A 0x2 00D 7A0 0x20, 0x7 00E 0820 0x20, 0x0 00F 00A7 0x27 ali = 7h Pulado 7 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 se encontra. 8 Efeito do overflow do ereço da PM ; Programa - Efeito do overflow do ereço 0x7fa ;ponto de início ali NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP ali O ereço 080h é inválido, pois podem ser usados, somente, onze bits para a PM. Isto significa que 080h é convertido para 00h. Há erro no ereçamento. 07F9 FFF 07FA 0000 NOP 07FB 0000 NOP 07FC 0000 NOP 07FD 0000 NOP 07FE 280 0x00 07FF 0000 NOP 0800 0000 NOP 080 0000 NOP 0802 0000 NOP 080 0000 NOP 080 0000 NOP 080 0000 NOP 080 0000 NOP 0807 FFF Página 0 Página 9 Efeito do overflow do ereço da PM Ao usar a instrução, é 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, os bits excedentes são simplesmente ignorados. A instrução, 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 em jumps entre páginas. 0
Endereço relativo $: Vai para o ereço da $ flash. $ indica o ereço atual apontado pelo PC, o ereço da instrução. O símbolo $ não pertence ao assembler puro, é uma extensão do MPLAB que representa o ereço atual da flash. O ereço $- aponta para a instrução anterior, uma linha acima no programa. O ereço $+ aponta para a instrução seguinte, uma linha abaixo no programa. Pode-se usar avançar ou retornar várias linhas. ; Programa - com rótulo relativo 0xa ;alterar constant 0x20 ;ereço ondecadê = CLRF ondecadê ondecadê+ ondecadê+2 ondecadê, ondecadê+ $+ ; bits ondecadê,2 ondecadê+ ondecadê, ondecadê+ ondecadê, ondecadê+ ondecadê,7 ondecadê+7 com rótulo relativo Pulado Este programa gera o mesmo disassembly do programa. 000A 0A0 CLRF 0x20 000B 0820 0x20, 0x0 000C 00A 0x2 000D 20 0x20, 0x0 000E 0820 0x20, 0x0 000F 00A2 0x22 000 A0 0x20, 0x 00 0820 0x20, 0x0 002 00A 0x2 00 287 0x07 00 20 0x20, 0x2 00 0820 0x20, 0x0 00 00A 0x2 007 A0 0x20, 0x 008 0820 0x20, 0x0 009 00A 0x2 00A 20 0x20, 0x 00B 0820 0x20, 0x0 00C 00A 0x2 00D 7A0 0x20, 0x7 00E 0820 0x20, 0x0 00F 00A7 0x27 $ = 0xh $+ = 0x7h Pulado 2 com rótulo relativo Embora o valor $+n possa ser entido 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 e o destino do salto, o argumento deve ser recalculado. ; Programa CALL - Errado #include <pf877.inc> 0x BCF BCF CALL Rotina STATUS,RP0 STATUS,RP 0x0 Rotina 0x0 0x0 0x0 CALL 000 28 BCF 0x0, 0x 000 0 BCF 0x0, 0x 0007 00 0x0 0008 200 CALL 0x00a 0009 00 0x0 000A 00 0x0 000B 0008 000C 00 0x0 O programa entra num laço infinito. É preciso impedir que a rotina espera seja executada fora do chamado. Ocorre um stack underflow. CALL 7 Seleção entre duas sub-rotinas ; Programa 7 - Duas sub-rotinas #include <pf877.inc> 0x BCF STATUS,C ;escolher entre e BCF BTFSS STATUS,C ;se C=0 então... CALL RotinaC0 ;executa RotinaC0 BTFSC STATUS,C ;se C= então... CALL RotinaC ;executa RotinaC Fim ;evita que as rotinas sejam executadas RotinaC0 0x0 0x20 CLRF 0x2 RotinaC 0x0 0x2 CLRF 0x20 Label para sub-rotina. Label para ponto específico. Fim
2 7 Seleção entre duas sub-rotinas 000 00 BCF 0x0, 0x0 000 0 0x0, 0x0 000 C0 BTFSS 0x0, 0x0 000 C0 BTFSS 0x0, 0x0 0007 200B CALL 0x00b 0007 200B CALL 0x00b 0008 80 BTFSC 0x0, 0x0 0008 80 BTFSC 0x0, 0x0 0009 200F CALL 0x00f 0009 200F CALL 0x00f 000A 28 0x 000A 28 0x 000B 00 0x0 000C 00A0 0x20 000B 00 0x0 000C 00A0 0x20 000D 0A CLRF 0x2 000D 0A CLRF 0x2 000E 0008 000E 0008 000F 00 0x0 000 00A 0x2 000F 00 0x0 000 00A 0x2 00 0A0 CLRF 0x20 00 0A0 CLRF 0x20 002 0008 002 0008 020 0x00 02 0x0 020 0x0 02 0x00 7 7 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. 8 CALL e Antes de verificar a pilha, convém apagá-la. Ela não é apagada em um reset do debugger. 8 Programa anterior sem o uso de CALL ; Programa 8 - Programa anterior sem o uso de CALL #include <pf877.inc> 0x Faz o push PC=7 Stack pointer 000 BCF 0x0, 0x0 000 BTFSS 0x0, 0x0 0007 CALL 0x00b 0008 BTFSC 0x0, 0x0 0009 CALL 0x00f 000A 0x 000B 0x0 000C 0x20 000D CLRF 0x2 000E 000F 0x0 000 0x2 00 CLRF 0x20 002 9 BCF STATUS,C ;escolher entre e BCF BTFSS STATUS,C ;se C=0 então... RotinaC0 ;executa RotinaC0 RotinaC ;executa RotinaC 000 00 BCF 0x0, 0x0 RotinaC0 000 C0 BTFSS 0x0, 0x0 0x0 0007 2809 0x009 0x20 CLRF 0x2 0008 280D 0x00d Fim ;evita RotinaC 0009 00 0x0 RotinaC 000A 00A0 0x20 0x0 000B 0A CLRF 0x2 0x2 000C 28 0x0 CLRF 0x20 Fim ;* 000D 00 0x0 000E 00A 0x2 Fim 000F 0A0 CLRF 0x20 70 000 28 0x0 *Esta linha pode ser removida. ;RotinaC 0x0 0x2 CLRF 0x20 0x ;* PCL ;* 9 Programa anterior sem o uso de ; Programa 9 - Programa anterior sem o uso de #include <pf877.inc> 0x CLRF PCLATH ;* BCF STATUS,C ;escolher entre e BCF 0x0c BTFSS STATUS,C ;se C=0 então... PCL ;executa RotinaC0 0x PCL ;executa RotinaC ;RotinaC0 0x0 0x20 CLRF 0x2 0x ;evita RotinaC PCL ;evita RotinaC 000 CLRF 0x0a 000 BCF 0x0, 0x0 0007 0x0c 0008 BTFSS 0x0, 0x0 0009 0x02 000A 0x 000B 0x02 000C 0x0 000D 0x20 000E CLRF 0x2 000F 0x 000 0x02 00 0x0 002 0x2 00 CLRF 0x20 00 0x 00 0x02 7 *Esta linha pode ser removida. Fim 0 CALL sem ; Programa 9 - CALL sem - Proibido #include <pf877.inc> 0x BCF STATUS,C ;escolher entre e BCF BTFSS STATUS,C ;se C=0 então... CALL RotinaC0 ;executa RotinaC0 BTFSC STATUS,C ;se C= então... CALL RotinaC ;executa RotinaC RotinaC0 CLRF RotinaC CLRF 0x0 0x20 0x2 Fim 0x0 0x2 0x20 Fim 000 BCF 0x0, 0x0 000 BTFSS 0x0, 0x0 0007 CALL 0x00a 0008 BTFSC 0x0, 0x0 0009 CALL 0x00e 000A 0x0 000B 0x20 000C CLRF 0x2 000D 0x02 000E 0x0 000F 0x2 000 CLRF 0x20 00 0x02 Este programa funciona, mas dá erro na pilha. Para cada CALL, deve existir um. 72 Não é correto o uso de CALL sem.
Não uso da instrução CALL Não uso da instrução CALL A substituição do CALL por ajuda a prevenir stack overflow. É recomável o uso de nas situações:. Desvios que não envolvam sub-rotinas. 2. Desvios para sub-rotinas que sejam chamadas, somente, em uma única linha do programa.. 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. 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 é recomado o uso do CALL, pois, cada ponto de chamada produzirá um diferente com base no ereç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. 7 7 Uma sub-rotina dentro de outra ; Programa - Uma sub-rotina dentro da outra 0x CALL RotinaC0 ;executa RotinaC0 Fim RotinaC0 0x0 0x20 CLRF 0x2 CALL RotinaC ;executa RotinaC RotinaC 0x0 0x2 CLRF 0x20 Fim 020 0x0 02 0x0 000 CALL 0x007 000 0x00 0007 0x0 0008 0x20 0009 CLRF 0x2 000A CALL 0x00c 000B 000C 0x0 000D 0x2 000E CLRF 0x20 000F 7 Escopo de e CALL O argumento das instruções e CALL tem bits. O argumento pode variar de 000h até 7FFh. As instruções 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 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 e CALL implica na eliminação de PC<2:>, levando o PC para um local errado. 7 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. 77 78
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 valo inicialmente FFh. A mínima contagem é feita com o GPR valo inicialmente 0h. Criação de um temporizador 79 2 Temporizador com uma variável ; Programa 2 - Temporizador com uma variável 0x constant TEMPO = 0x20 constant VALOR = 0x0f ;configurável TEMPO, F $-0x Endereço arbitrário VALOR TEMPO Valor que define a temporização 0x0f 0x20 0x20, 0x 0x007 Use o comando animate para observar a contagem. 80 2 Temporizador com uma variável Use o comando animate para observar a contagem. 2 Temporizador com uma variável Experimente abaixar a frequência até que aconteça um WDT time out. 8 82 ; Programa - Proteção do WDT 0x constant TEMPO = 0x20 constant VALOR = 0x0f ;configurável VALOR TEMPO TEMPO, F $-0x2 Proteção do WDT 0x0f 0x20 0x20, 0x 0x007 Depo 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 8 tempo da contagem em T CY. Cálculo aproximado do tempo TEMPO,F $-0x2 Na ª execução do, TEMPO = 0x0F. Na 2ª execução do, TEMPO = 0x0E. Na ª execução do, TEMPO = 0x0. Nesta repetição, o faz TEMPO = 0x00. Nesta repetição, o faz o skip. Nesta repetição, o não é executado. O ciclo de contagem é executado vezes e não. O e o são executados vezes. O é executado vezes. 8
Cálculo aproximado do tempo Contador de dois bytes O é T CY. O e o são 2T CY. O ciclo de contagem é T CY + 2T CY + 2T CY = T CY. O ciclo total é ( T CY ) + T CY = 7T CY. Considerar as duas operações de movimentação. Tempo = 7T CY + T CY + T CY = 7T CY. T CY = T OSC. 7T CY = 00T OSC. f OSC = 20MHz (suposição). T OSC = 0ns. 00T OSC = s. TEMPO,F $-0x2 8 ; Programa - Contador de dois bytes 0x constant TEMPOA = 0x20 constant TEMPOB = 0x2 constant VALOR = 0x0f ;configurável VALOR TEMPOB TEMPOA TEMPOA, F $-0x2 TEMPOB, F $-0x 0x0f 0x2 0x20 0x20, 0x 0x008 0x2, 0x 0x007 TEMPOA: Variável menos significativa TEMPOB: Variável mais significativa 8 Contador de três bytes ; Programa Contador de três bytes 0x constant TEMPOA = 0x20 constant TEMPOB = 0x2 constant TEMPOC = 0x22 constant VALOR = 0xff ;configurável VALOR TEMPOC TEMPOB TEMPOA TEMPOA, F $-0x2 TEMPOB, F $-0x TEMPOC, F $-0x8 0xff 0x22 0x2 0x20 0x20, 0x 0x009 0x2, 0x 0x008 0x22, 0x 0x007 TEMPOA: Variável menos significativa TEMPOC: Variável mais significativa 87 Espera constant constant constant Parâmetros iniciais indepentes Na lista de definições: TEMPOA = 0x20 TEMPOB = 0x2 TEMPOC = 0x22 Rotina Espera VALORC TEMPOC VALORB TEMPOB VALORA TEMPOA TEMPOA,F $-0x2 TEMPOB,F $-0x TEMPOC,F $-0xa Endereços arbitrários Valores quedefinem a temporização 0x0 a 0xff Não aceitam valor 0x00 Retorna a quantidade de linhas mencionada 88 Configuração h C2h 28h h = 09d de 0d a 08d. C2h = 9d de 0d a 9d. 28h = d de 0d a 0d. 9 9 =.0. passos. A contagem é de 000000h a 7B9h. 0x28 0x22 0xc2 0x2 0x 0x20 0x20, 0x 0x00b 0x2, 0x 0x009 0x22, 0x 0x007 ; Programa Configuração h C2h 28h 0x constant VALORA = 0x ;configurável constant VALORB = 0xc2 ;configurável constant VALORC = 0x28 ;configurável constant TEMPOA = 0x20 constant TEMPOB = 0x2 constant TEMPOC = 0x22 VALORC TEMPOC VALORB TEMPOB VALORA TEMPOA TEMPOA, F $-0x2 TEMPOB, F $-0x TEMPOC, F $-0xa 89 ; Programa 7 Quatro variáveis 0x 7 Contador de quatro bytes constant VALORA = 0x ;configurável constant VALORB = 0xc2 ;configurável constant VALORC = 0x8d ;configurável constant VALORD = 0xff ;configurável constant TEMPOA = 0x20 constant TEMPOB = 0x2 constant TEMPOC = 0x22 constant TEMPOD = 0x2 VALORD TEMPOD VALORC TEMPOC VALORB TEMPOB 0xff VALORA 0x2 TEMPOA 0x8d 0x22 0xc2 TEMPOA, F 0x2 $-0x2-0x0 0x TEMPOB, F 0x20 $-0x2-0x TEMPOC, F 0x20, 0x $-0x2-0x8 0x00d TEMPOD, F 0x2, 0x $-0x2-0xc 0x00b 0x22, 0x 0x009 0x2, 90 0x 0x007
7 Contador de quatro bytes O argumento da instrução foi parametrizado. Isto facilita a programação dos parâmetros. Ao inserir novas linhas na rotina a ser repetida, basta corrigir o valor 0x02. VALORD TEMPOD VALORC TEMPOC VALORB TEMPOB VALORA TEMPOA TEMPOA, F $-0x2-0x0 TEMPOB, F $-0x2-0x TEMPOC, F $-0x2-0x8 TEMPOD, F $-0x2-0xc Rotina a ser repetida linha (n=) n+ = 2 9 7 Contador de quatro bytes TEMPOA, F $-0x2-0x0 TEMPOB, F $-0x2-0x TEMPOC, F $-0x2-0x8 TEMPOD, F $-0x2-0xc A progressão de quatro em quatro existe porque há quatro instruções para cada variável (,, e ). Se as variáveis tivessem todas o mesmo valor inicial, a progressão seria de três em três. 92 8 WDT sem time out ; Programa 8 WDT sem time out 0xb 0x22 0xff 0x2 Executar um reset. 0xfd 0x20 9 WDT com time out ; Programa 9 WDT com time-out 0xb 0x22 0xff 0x2 Executar um reset. 0xfe 0x20 0x20,0x 0x00 0x2,0x 0x00 0x22,0x 0x002.80.8 passos de contagem. Não ocorre WDT overflow. 0x20,0x 0x00 0x2,0x 0x00 0x22,0x 0x002.82.0 passos de contagem. Ocorre WDT time out. Output CORE-W00: Halted due to PC incrementing over the Maximum PC address and wrapping back to Zero Output CORE-W000: Watchdog Timer event occurred. Break in execution requested 9 9 ; Programa 0 Habilitação do WDT #include <PF877.INC> config _WDT_OFF 0x constant VALOR = 0xff constant TEMPO = 0x20 0 Habilitação do WDT VALOR TEMPO+0x2 TEMPO+0x TEMPO TEMPO,F $-0x TEMPO+0x,F $-0x TEMPO+0x2,F $-0x7 CORE-W00: Halted due to PC incrementing over the Maximum PC address and wrapping back to Zero ; Programa 0 Habilitação do WDT #include <PF877.INC> config _WDT_ON 0x constant VALOR = 0xff constant TEMPO = 0x20 VALOR TEMPO+0x2 TEMPO+0x TEMPO TEMPO,F $-0x TEMPO+0x,F $-0x TEMPO+0x2,F $-0x7 9 CORE-W000: Watchdog Timer event occurred. Break in execution requested Habilitação do WDT sem #include ; Programa 0 Habilitação do WDT ; Programa Desabilitação do WDT sem #include #include <PF877.INC> config _WDT_OFF config 0xffb 0x 0x constant VALOR = 0xff constant VALOR = 0xff constant TEMPO = 0x20 constant TEMPO = 0x20 VALOR VALOR TEMPO+0x2 TEMPO+0x2 TEMPO+0x TEMPO+0x TEMPO TEMPO TEMPO,F TEMPO,F $-0x $-0x TEMPO+0x,F TEMPO+0x,F $-0x $-0x TEMPO+0x2,F TEMPO+0x2,F $-0x7 $-0x7 9
7 2 Configuração do WDT ; Programa 2 Configuração do WDT #include <PF877.INC> config _WDT_ON 0x constant VALOR = 0x9c constant TEMPO = 0x20 ;WDT Postscaler = :28 BCF STATUS, RP STATUS, RP0 OPTION_REG,PS2 OPTION_REG,PS OPTION_REG,PS0 VALOR TEMPO+0x2 TEMPO+0x TEMPO TEMPO,F $-0x TEMPO+0x,F $-0x TEMPO+0x2,F $-0x7 0x07 IORWF OPTION_REG,F CORE-W00: Halted due to PC incrementing over the Maximum PC address and wrapping back to Zero ; Programa 2 Configuração do WDT #include <PF877.INC> config _WDT_ON 0x constant VALOR = 0x9c constant TEMPO = 0x20 ;WDT Postscaler = : BCF STATUS, RP STATUS, RP0 OPTION_REG,PS2 OPTION_REG,PS BCF OPTION_REG,PS0 VALOR TEMPO+0x2 TEMPO+0x TEMPO TEMPO,F $-0x TEMPO+0x,F $-0x TEMPO+0x2,F $-0x7 0x0 IORWF OPTION_REG,F 97 CORE-W000: Watchdog Timer event occurred. Break in execution requested 98 EEPROM Leitura direta Na leitura direta, o ereç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 ereço da EEPROM esteja condicionado a outras variáveis do sistema. EEPROM Leitura direta ; Programa - EEPROM Leitura direta ; Baseado no exemplo - do datasheet da picf877 #include <pf877.inc> 0x constant ondecadê = 0xf ;ereço da EEPROM data memory (8 bits) constant ondecadê2 = 0x22 ;ereço da SRAM file memory (7 bits) ; Busca o ereço da posição da EEPROM a ser lida 0x0, 0x STATUS,RP BCF STATUS,RP0 ;Seleciona o banco 2 (0b) BCF 0x0, 0x ondecadê ;W = ondecadê 0xf EEADR ;SRAM(EEADR) = W 0x0d ; Faz a leitura da EEPROM(ondecadê) 0x0, 0x STATUS,RP ;* 0x0, 0x BCF STATUS,RP0 EECON,EEPGD ;Seleciona o banco (b) ;Configura para EEPROM* BCF 0x0c, 0x7 EECON,RD ;Inicia leitura 0x0c, 0x0 STATUS,RP ;* 0x0, 0x BCF STATUS,RP0 EEDATA,W ;Seleciona o banco 2 (0b) ;W = SRAM(EEDATA) BCF 0x0, 0x 0x0c, 0x0 ; Copia para a SRAM(ondecadê2) BCF STATUS,RP BCF 0x0, 0x ;Seleciona o banco 0 (00b) BCF 0x0, 0x BCF STATUS,RP0 ;* ondecadê2 ;SRAM(ondecadê2) = W 0x22 99 *Esta linha pode ser removida. 00 EEPROM Leitura direta Testando Escolha o valor para a posição 0Fh da EEPROM. EEPROM Leitura direta Testando Verificação dos registros. 2 Execute o programa. O GPR s 022h recebe o conteúdo da posição 07h da EEPROM. 0 02
8 EEPROM Leitura direta EEPROM Leitura indireta Três valores estão envolvidos: Endereço na EEPROM (xf). Endereço do GPR que conterá o valor do dado contido no ereço selecionado na EEPROM (ondecadê2,0x22). Dado contido na EEPROM (0x88). Na leitura indireta, o ereço da EEPROM a ser lido está localizado em um GPR. Esta opção tem a vantagem permitir que o ereç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. 0 0 EEPROM Leitura indireta ; Programa - EEPROM Leitura indireta ; Baseado no exemplo - do datasheet da picf877 #include <pf877.inc> 0x constant ondecadê = 0x20 ;Endereço do GPR (7 bits) que contém o ereço da EEPROM (8 bits) constant ondecadê2 = 0x2 ;Endereço do GPR (7 bits) que conterá o dado lido da EEPROM (8 bits) BCF 0x0, 0x ; Busca o ereço da posição da EEPROM a ser lida BCF 0x0, 0x BCF STATUS,RP BCF STATUS,RP0 ;Seleciona o banco 0 (00b) 0x20, 0x0 ondecadê,w ;W = SRAM(ondecadê) 0x0, 0x STATUS,RP ;Seleciona o banco 2 (0b) BCF STATUS,RP0 ;* BCF 0x0, 0x EEADR ;SRAM(EEADR) = W 0x0d ; Faz a leitura da EEPROM(SRAM(ondecadê)) 0x0, 0x STATUS,RP ;* 0x0, 0x STATUS,RP0 ;Seleciona o banco (b) BCF EECON,EEPGD ;Configura para EEPROM BCF 0x0c, 0x7 EECON,RD ;Inicia leitura 0x0c, 0x0 STATUS,RP ;* BCF STATUS,RP0 ;Seleciona o banco 2 (0b) 0x0, 0x EEDATA,W ;W = SRAM(EEDATA) BCF 0x0, 0x 0x0c, 0x0 ; Copia para a SRAM(0x2) BCF STATUS,RP ;Seleciona o banco 0 (00b) BCF 0x0, 0x BCF STATUS,RP0 ;* BCF 0x0, 0x ondecadê2 ;SRAM(ondecadê2) = W 0x2 0 *Esta linha pode serremovida. EEPROM Leitura indireta Testando Escolha um valor para o GPR 020h. 2 Escolha o valor para a posição da EEPROM dada pelo valor do GPR 020h. 0 EEPROM Leitura indireta Testando EEPROM Leitura indireta Execute o programa. O GPR 02h recebe o conteúdo da posição da EEPROM indicada pelo conteúdo do registrador 020h. Quatro valores estão envolvidos: Endereço do GPR que contém o valor do ereço na EEPROM a ser lido (ondecadê=0x20). Endereço na EEPROM (0xE). Endereço do GPR que conterá o valor do dado contido no ereço selecionado na EEPROM (ondecadê2=0x2). Dado contido na EEPROM (0xA9) 07 08
9 EEPROM Escrita direta EEDATA contém o byte que será escrito na EEPROM. EEADR contém o ereço do byte na EEPROM. Importante é prestar atenção no controle dos bancos. As quatro linhas abaixo não podem faltar. EEPROM Escrita direta 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 instruções e 2 podem ser usadas no início da primeira escrita e a instrução 8 no final da última escrita. ereço, W ;W = ereço,ereço para gravação EEADR ;SRAM(EEADR) = W dado, W ;W = dado,dado para gravação EEDATA ;SRAM(EEDATA) = W. BCF EECON, EEPGD ;Configura para EEPROM 2. EECON, WREN ;Habilita escrita. 0x ;W = h - primeira parte do código de escrita. EECON2 ;SRAM(EECON2) = W. 0xaa ;W = AAh - segunda parte do código de escrita. EECON2 ;SRAM(EECON2) = W 7. EECON, WR ;Inicia escrita. Ao terminar,wr=0 8. BCF EECON, WREN ;Desabilita escrita 09 0 Define ereço Define dado Configura Escreve EEPROM Escrita direta ; Programa EEPROM Escrita direta ; Baseado no exemplo -2 do datasheet da picf877 #include <pf877.inc> 0x constant ondecadê = 0x0 ;ereço da EEPROM (8 bits) constant marqualrélio = 0xca ;dado para a EEPROM (8 bits) ;Configura os registradores para a escrita STATUS, RP BCF STATUS, RP0 ondecadê ;W = ondecadê EEADR ;SRAM(EEADR) = W EEDATA ;SRAM(EEDATA) = W STATUS, RP ;* STATUS, RP0 BCF EECON, EEPGD ;Configura para EEPROM EECON, WREN ;Habilita escrita ;Realiza a escrita 0x ;W = h - primeira parte do código de escrita EECON2 ;SRAM(EECON2) = W 0xaa ;W = AAh - segunda parte do código de escrita EECON2 ;SRAM(EECON2) = W EECON, WR ;Inicia escrita BCF EECON, WREN ;Desabilita escrita *Esta linha pode serremovida. 0x0, 0x BCF 0x0, 0x 0x0 0x0d 0xca 0x0c 0x0, 0x 0x0, 0x BCF 0x0c, 0x7 0x0c, 0x2 0x 0x0d 0xaa 0x0d 0x0c, 0x BCF 0x0c, 0x2 EEPROM Escrita indireta ; Programa EEPROM Escrita indireta ; Baseado no exemplo -2 do datasheet da picf877 #include <pf877.inc> 0x constant ondecadê = 0x20 ;Endereço do GPR (7 bits) que contém o dado para a EEPROM (8 bits) constant ondecadê2 = 0x2 ;Endereço do GPR (7 bits) que contém o ereço da EEPROM (8 bits) ;Configura os registradores para a escrita BCF 0x0, 0x BCF STATUS, RP BCF STATUS, RP0 BCF 0x0, 0x ondecadê2, W ;W = SRAM(ondecadê2), ereço para gravação 0x2, 0x0 Define ereço 0x0, 0x STATUS, RP BCF STATUS, RP0 ;* BCF 0x0, 0x EEADR ;SRAM(EEADR) = W 0x0d BCF 0x0, 0x BCF STATUS, RP BCF STATUS, RP0 ;* BCF 0x0, 0x ondecadê, W ;W = SRAM(ondecadê), dado para gravação 0x20, 0x0 Define dado 0x0, 0x STATUS, RP BCF STATUS, RP0 ;* BCF 0x0, 0x EEDATA ;SRAM(EEDATA) = W 0x0c 0x0, 0x STATUS, RP ;* Configura STATUS, RP0 0x0, 0x BCF EECON, EEPGD ;Configura para EEPROM BCF 0x0c, 0x7 EECON, WREN ;Habilita escrita 0x0c, 0x2 ;Realiza a escrita 0x 0x ;W = h - primeira parte do código de escrita 0x0d EECON2 ;SRAM(EECON2) = W 0xaa 0xaa ;W = AAh - segunda parte do código de escrita Escreve EECON2 ;SRAM(EECON2) = W 0x0d EECON, WR ;Inicia escrita 0x0c, 0x BCF EECON, WREN ;Desabilita escrita 2 *Esta linha pode ser removida. EEPROM Escrita indireta EEPROM Escrita indireta Escolha um valor para o dado a ser gravgado. Execute o programa. 2 Escolha um valor para ereço de gravação. A posição h recebe o valor 22h.
Proteção contra interrupção 20 EEPROM Escrita Proteção contra interrup. EEPROM Escrita Proteção contra interrup. 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. Não interromper STATUS, RP STATUS, RP0 BCF EECON, EEPGD EECON, WREN 0x EECON2 0xAA EECON2 EECON, WR BCF EECON, WREN Proteção contra interrupção BCF XXXXXXXXX INTCON, GIE INTCON, GIE INTCON: Interrupt Control register GIE: Global Interrupt Enable bit Desabilita interrupção Área protegida Reabilita interrupção EEPROM Verificação do estado EEPROM Verificação de estado de leitura Como o tempo de R/W 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 ou lida. Ao iniciar um R/W, deve-se verificar que a EEPROM não se encontra em um outro processo de R/W iniciado anteriormente. O processo de leitura (R) é muito mais rápido do que o de escrita (W). 7 ;Verifica se está em processo de leitura STATUS, RP STATUS, RP0 BTFSC EECON, RD ;Se o bit RD de EECON for 0, pular a próxima linha $- ;Retorna à linha anterior até que a leitura tenha terminado BTFSC EECON, RD : Verifica se RD=0 ou RD=. Se é 0, isto é, a EEPROM não está em processo de leitura, pula a instrução seguinte e prossegue com a execução. Se é, isto é, a EEPROM está em processo de leitura, executa a instrução seguinte. O programa fica paralisado até o término da leitura. Esta verificação somente é necessária se, anteriormente a um R/W, foi feita uma leitura na EEPROM. 8 EEPROM Verificação de estado de escrita ;Verifica se está em processo de leitura STATUS, RP STATUS, RP0 BTFSC EECON, WR ;Se o bit WR de EECON for 0, pular a próxima linha $- ;Retorna à linha anterior até que a escrita tenha terminado BTFSC EECON, WR : Verifica se WR=0 ou WR=. Se é 0, isto é, a EEPROM não está em processo de escrita, pula a instrução seguinte e prossegue com a execução. Se é, isto é, a EEPROM está em processo de escrita, executa a instrução seguinte. O programa fica paralisado até o término da escrita. Esta verificação somente é necessária se, anteriormente a um R/W, foi feita uma escrita na EEPROM. 9 7 EEPROM Proteções ; Programa 7 EEPROM Proteções ; Baseado no exemplo -2 do datasheet da picf877 #include <pf877.inc> 0x constant ondecadê = 0x20 ;Endereço do GPR (7 bits) que contém o dado para a EEPROM (8 bits) constant ondecadê2 = 0x2 ;Endereço do GPR (7 bits) que contém o ereço da EEPROM (8 bits) 0x0, 0x ;Verifica se está em processo de escrita 0x0, 0x STATUS, RP ; STATUS, RP0 ;Banco BTFSC 0x0c, 0x BTFSC EECON, WR ;Se o bit WR de EECON for 0, pular a próxima linha 0x07 $- ;Retorna à linha anterior até que a escrita tenha terminado BCF 0x0, 0x ;Escreve BCF 0x0, 0x BCF STATUS, RP ; 0x2, 0x0 BCF STATUS, RP0 ;Banco 0 0x0, 0x ondecadê2, W ;W = SRAM(ondecadê2), ereço para gravação STATUS, RP ;Banco 2 0x0d EEADR ;EEADR = W BCF 0x0, 0x BCF STATUS, RP ;Banco 0 0x20, 0x0 ondecadê, W ;W = SRAM(ondecadê), dado para gravação STATUS, RP ;Banco 2 0x0, 0x EEDATA ;EEDATA = W 0x0c STATUS, RP0 ;Banco 0x0, 0x BCF EECON, EEPGD ;Configura para EEPROM EECON, WREN ;Habilita escrita BCF 0x0c, 0x7 0x0c, 0x2 BCF INTCON, GIE ;Desabilita interrupções, caso use interrupção BCF 0x0b, 0x7 0x ;W = h - primeira parte do código de escrita EECON2 ;EECON2 = W 0x 0xaa ;W = AAh - segunda parte do código de escrita 0x0d EECON2 ;EECON2 = W 0xaa EECON, WR ;Inicia escrita 0x0d INTCON, GIE ;Habilita interrupções, caso use interrupção 0x0c, 0x BCF EECON, WREN ;Desabilita escrita 0x0b, 0x7 BCF 0x0c, 0x2 20
2 8 EEPROM Procedimentos múltiplos 8 EEPROM Procedimentos múltiplos American Standard Code for Information Interchange 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. Caractere ASCII M Dh a h r 72h c h o Fh 2 22 8 EEPROM Procedimentos múltiplos Parte : Declaração das constantes. 8 EEPROM Procedimentos múltiplos Parte 2: Gravação dos registros. ; Programa 7 EEPROM Procedimentos múltiplos #include <pf877.inc> 0x constant ondecadê = 0x ;ereço M origem constant ondecadê2 = 0x2 ;ereço a origem constant ondecadê = 0x ;ereço r origem constant ondecadê = 0x ;ereço c origem constant ondecadê = 0x ;ereço o origem constant ondecadê = 0x ;ereço M destino constant ondecadê7 = 0x7 ;ereço a destino constant ondecadê8 = 0x8 ;ereço r destino constant ondecadê9 = 0x9 ;ereço c destino constant ondecadêa = 0xa ;ereço o destino constant ondeeep = 0x0 ;ereço M na EEPROM constant ondeeep2 = 0x02 ;ereço a na EEPROM constant ondeeep = 0x0 ;ereço r na EEPROM constant ondeeep = 0x0 ;ereço c na EEPROM constant ondeeep = 0x0 ;ereço o na EEPROM constant letram = 0xd ;dado para M constant letraa = 0x ;dado para a constant letrar = 0x72 ;dado para r constant letrac = 0x ;dado para c constant letrao = 0xf ;dado para o ;escreve "Marco" na SRAM STATUS,RP BCF STATUS,RP0 letram ondecadê letraa ondecadê2 letrar ondecadê letrac ondecadê letrao ondecadê 0xD 2 0x 0x72 0x 0xF 2 2 8 EEPROM Procedimentos múltiplos Parte : Cópia para a EEPROM. 8 EEPROM Procedimentos múltiplos Parte : Cópia para a EEPROM. M a r c o STATUS,RP0 BCF EECON,EEPGD EECON,WREN CALL EsperaEE ondeeep EEADR ondecadê,w CALL EscreveEE CALL EsperaEE ondeeep2 EEADR ondecadê2,w CALL EscreveEE CALL EsperaEE ondeeep EEADR ondecadê,w CALL EscreveEE CALL EsperaEE ondeeep EEADR ondecadê,w CALL EscreveEE CALL EsperaEE ondeeep EEADR ondecadê,w CALL EscreveEE BCF EECON, WREN EsperaEE BTFSC EECON,WR $- BCF STATUS,RP0 EscreveEE EEDATA STATUS,RP0 0x EECON2 0xaa EECON2 EECON,WR 2 2
22 8 EEPROM Procedimentos múltiplos Parte : Cópia para a SRAM. 8 EEPROM Procedimentos múltiplos Parte : Sub-rotinas EscreveSRAM BCF STATUS,RP0 EEADR STATUS,RP0 EECON,RD BCF STATUS,RP0 EEDATA,W M a r c o ondeeep CALL EscreveSRAM ondecadê ondeeep2 CALL EscreveSRAM ondecadê7 ondeeep CALL EscreveSRAM ondecadê8 ondeeep CALL EscreveSRAM ondecadê9 ondeeep CALL EscreveSRAM ondecadêa Fim 0xD 7 0x 8 0x72 9 0x A 0xF 27 EsperaEE BTFSC EECON,WR $- BCF STATUS,RP0 EscreveEE EEDATA STATUS,RP0 0x EECON2 0xaa EECON2 EECON,WR EscreveSRAM BCF STATUS,RP0 EEADR STATUS,RP0 EECON,RD BCF STATUS,RP0 EEDATA,W 28 0xD 2 0x 0x72 0x 0xF 0xD 7 0x 8 0x72 9 0x A 0xF 8 EEPROM Procedimentos múltiplos Parte : Finalização. Altere este programa para o seu nome. 29 8 EEPROM Procedimentos múltiplos 0x0, 0x BCF 0x0, 0x 0xd 0x 0x 0x2 0x72 0x 0x 0x 0xf 0x 0x0, 0x BCF 0x0c, 0x7 0x0c, 0x2 CALL 0x0d 0x0 0x0d 0x, 0x0 CALL 0x0 CALL 0x0d 0x02 0x0d 0x2, 0x0 CALL 0x0 CALL 0x0d 0x0 0x0d 0x, 0x0 CALL 0x0 CALL 0x0d 0x0 0x0d 0x, 0x0 CALL 0x0 CALL 0x0d 0x0 0x0d 0x, 0x0 CALL 0x0 BCF 0x0c, 0x2 0x0 CALL 0x09 0x 0x02 CALL 0x09 0x7 0x0 CALL 0x09 0x8 0x0 CALL 0x09 0x9 0x0 CALL 0x09 0xa 0x0 BTFSC 0x0c, 0x 0xd BCF 0x0, 0x 0x0c 0x0, 0x 0x 0x0d 0xaa 0x0d 0x0c, 0x BCF 0x0, 0x 0x0d 0x0, 0x 0x0c, 0x0 BCF 0x0, 0x 0x0c, 0x0 0 FLASH Leitura Um acesso à flash por meio de EECON significa que, nos ereços em questão, ela atua como uma data memory e não como uma program memory. O processo de R/W na flash data memory implica no uso do seu address bus, paralisando, assim, a execução do programa até a conclusão do processo. Por causa desta paralização, não seria necessário verificar o estado dos bits RD e WR. Porém, mesmo assim, usando o MPLAB, foi constatada a necessidade do uso do código abaixo. BTFSC EECON,RD $- 9 FLASH Leitura em posição baixa ; Universidade Federal de São João del-rei ; Prof. Marco Aurélio Seluque Fregonezi ; Programa 9 FLASH Leitura indireta em posição baixa #include <pf877.inc> 0x constant ondecadê = 0x0b ;ereço LOW da FLASH constant ondecadê2 = 0x22 ;GPR H constant ondecadê = 0x2 ;GPR L ; Busca o ereço da posição da FLASH a ser lida STATUS,RP BCF STATUS,RP0 ;* ondecadê EEADR ;SRAM(EEADR) = W CLRF EEADRH ;SRAM(EEADRH) = 0 ; Faz a leitura da FLASH(ondecadê) STATUS,RP0 ;Banco EECON,EEPGD ;Configura para FLASH EECON,RD ;Inicia leitura ; Copia para a SRAM(ondecadê2 e ondecadê) BTFSC EECON,RD $- BCF STATUS,RP0 EEDATH,W ondecadê2 ;Banco 2, 22h EEDATA,W ondecadê ;Banco 2, 2h *Esta linha pode ser removida. 000 70 0x0, 0x 000 28 BCF 0x0, 0x 0007 00B 0x0b 0008 008D 0x0d 0009 08F CLRF 0x0f 000A 8 0x0, 0x 000B 78C 0x0c, 0x7 000C 0C 0x0c, 0x0 000D 80C BTFSC 0x0c, 0x0 000E 280D 0x00d 000F 28 BCF 0x0, 0x 000 080E 0x0e, 0x0 00 00A2 0x22 002 080C 0x0c, 0x0 00 00A 0x2 Banco 2 22 0x7 2 0x8C 2
2 9 FLASH Leitura em posição baixa 000 70 0x0, 0x 000 28 BCF 0x0, 0x 0007 00B 0x0b 0008 008D 0x0d 0009 08F CLRF 0x0f 000A 8 0x0, 0x 000B 78C 0x0c, 0x7 000C 0C 0x0c, 0x0 000D 80C BTFSC 0x0c, 0x0 000E 280D 0x00d 000F 28 BCF 0x0, 0x 000 080E 0x0e, 0x0 00 00A2 0x22 002 080C 0x0c, 0x0 00 00A 0x2 0 FLASH Leitura em posição alta ; Universidade Federal de São João del-rei ; Prof. Marco Aurélio Seluque Fregonezi ; Programa 0 FLASH Leitura indireta em posição alta #include <pf877.inc> 0x constant ondecadê = 0xb ;ereço H da FLASH constant ondecadê2 = 0x8 ;ereço L da FLASH constant ondecadê = 0x2 ;ereço H da SRAM constant ondecadê = 0x2 ;ereço L da SRAM ; Busca o ereço da posição da FLASH a ser lida STATUS,RP ondecadê EEADRH ;SRAM(EEADRH) = W ondecadê2 EEADR ;SRAM(EEADR) = W ; Faz a leitura da FLASH(ondecadê e ondecadê2) STATUS,RP0 EECON,EEPGD ;Configura para FLASH EECON,RD ;Inicia leitura ; Copia para a SRAM(ondecadê e ondecadê) BTFSC EECON,RD $- BCF STATUS,RP0 EEDATH,W ondecadê ;Banco 2, 2h EEDATA,W ondecadê ;Banco 2, 2h 000 70 0x0, 0x 000 0B 0xb 0007 008F 0x0f 0008 08 0x8 0009 008D 0x0d 000A 8 0x0, 0x 000B 78C 0x0c, 0x7 000C 0C 0x0c, 0x0 000D 80C BTFSC 0x0c, 0x0 000E 280D 0x00d 000F 28 BCF 0x0, 0x 000 080E 0x0e, 0x0 00 00A 0x2 002 080C 0x0c, 0x0 00 00A 0x2 0 FLASH Leitura em posição alta FLASH Escrita Digitar B7 FFF B8 02 0x2 B9 FFF Banco 2 2 0x2 2 0x0 ; Programa #include <pf877.inc> 0x 000 28 BCF 0x0, 0x 000 70 0x0, 0x ;Escreve BCF STATUS, RP0 0007 020 0x20 0x20 ;ereço L para gravação 0008 008D 0x0d EEADR ;EEADR = W 0x00 ;ereço H para gravação 0009 000 0x00 EEADRH ;EEADRH = W 000A 008F 0x0f 0x0 ;dado L para gravação 000B 00 0x0 EEDATA ;EEDATA = W 0x0 ;dado H para gravação 000C 008C 0x0c EEDATH ;EEDATA = W 000D 00 0x0 STATUS, RP0 ;Banco 000E 008E 0x0e EECON, EEPGD ;Configura para FLASH 000F 8 0x0, 0x EECON, WREN ;Habilita escrita 000 78C 0x0c, 0x7 BCF INTCON, GIE ;Desabilita interrupções, caso use interrupção 0x ;W = h - primeira parte do código de escrita 00 0C 0x0c, 0x2 EECON2 ;EECON2 = W 002 8B BCF 0x0b, 0x7 0xaa ;W = AAh - segunda parte do código de escrita EECON2 ;EECON2 = W 00 0 0x EECON, WR ;Inicia escrita 00 008D 0x0d BTFSC EECON, WR ;Se o bit WR de EECON for 0, pular a próxima linha $- ;Retorna à linha anterior até que a escrita tenha terminado 00 0AA 0xaa BCF INTCON, GIE EECON, WREN ;Habilita interrupções, caso use interrupção ;Desabilita escrita 00 008D 0x0d 007 8C 0x0c, 0x 008 88C BTFSC 0x0c, 0x 009 288 0x08 Último ereço 00A 78B 0x0b, 0x7 00B 0C BCF 0x0c, 0x2 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. O MPLAB SIM não exibe a flash data memory. Alterando o bit EEPGD para zero a gravação é realizada na EEPROM, o que demonstra que o programa está correto. 7 8