Instrução Assembler - Microcontrolador Pic

Transcript

INSTRUÇÕES ASSEMBLER PIC - Microchip Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 1/103 INSTRUÇÕES ASSEMBLER Introdução Através das Instruções o código-fonte pode executar as funções determinadas pelo programador para controlar o sistema externo de acordo com o projeto. A Instrução Assembler é formada por uma série de palavras (mnemônicos) que traduzem a função a ser realizada. Normalmente, cada fabricante desenvolve seu próprio conjunto de instruções que tem aplicação exclusiva nos seus componentes, sem nenhuma compatibilidade com outros fabricantes. Para o programador, cabe estudar cada instrução no seu formato, função e aplicação de acordo com o controlador empregado no projeto. É claro que, se existem vários projetos de aplicação desenvolvidos por uma única empresa, esta optará pelo uso de um só fabricante de controlador por uma simples questão de custo/investimento na educação dos programadores para a linguagem de programação (conjunto de instruções) e características de intercambio de programas ou trechos de programas em aplicações diversas. No geral, entre os diversos controladores existentes no mercado, a função que se deseja realizar com uma instrução em qualquer dispositivo não altera, apenas o nome da instrução (mnemônico) é que sofre uma alteração. Para o nosso caso, serão utilizadas as instruções da família PIC – Microchip, que reúne um conjunto de 37 instruções aplicadas em controladores de 8 bits (Mid Range MCU). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 2/103 Índice de Instruções As instruções são agrupadas em três categorias básicas de aplicação: INSTRUÇÃO ORIENTADA A BYTE (BYTE-ORIENTED OPERATION) MNEMONICO DESCRIÇÃO CM STATUS PÁG. ADDWF Soma o valor contido em W com valor contido em F 1 C, DC, Z * ANDWF Operação AND (E) entre o valor contido em W e valor contido em F 1 Z * CLRF Coloca valor 0 (zero) no registro F 1 Z * CLRW Coloca valor 0 (zero) no registro W 1 Z * COMF “Complemento de 1” (1’s complement) do valor contido em F 1 Z DECF 1 Z IORWF Decrementa uma unidade do valor contido em F Decrementa uma unidade do valor contido em F e salta a instrução seguinte se o resultado for 0 (zero) Incrementa uma unidade no valor contido em F Incrementa uma unidade no valor contido em F e salta a instrução seguinte se o resultao for 0 (zero) Operação OR (OU) entre o valor contido em W e valor contido em F 1 Z * MOVF Mover o valor contido no registro F para o destino especificado 1 Z * MOVWF Mover o valor contido em W para o registro F 1 * NOP Nenhuma operação (No Operation) 1 * RLF Rotaciona valor contido em F à esquerda através do bit CARRY 1 C RRF Rotaciona valor contido em F à direita através do bit CARRY 1 C SUBWF Subtrai o valor contido em W do valor contido em F 1 C, DC, Z SWAPF Troca NIB_LO com NIB_HI no registro F Operação EXCLUSIVE OR (OU EXCLUSIVO) entre o valor contido em W e valor contido em F 1 DECFSZ INCF INCFSZ XORWF 1 (2) 1 * Z 1 (2) 1 * * * * * Z * INSTRUÇÃO ORIENTADA A BIT (BIT-ORIENTED OPERATION) MNEMONICO DESCRIÇÃO CM BCF Coloca valor ‘0’ (clear) no bit F BSF Coloca valor ‘1’ (set) no bit F 1 Testa o valor (nível lógico) do bit F e salta a instrução seguinte se valor do 1 (2) bit for igual a ‘0’ (clear) Testa o valor (nível lógico) do bit F e salta a instrução seguinte se valor do 1 (2) bit for igual a ‘1’ (set) BTFSC BTFSS 1 STATUS PÁG. * * * * Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 3/103 INSTRUÇÃO LITERAL E CONTROLE (LITERAL AND CONTROL OPERATION) MNEMONICO DESCRIÇÃO CM STATUS PÁG. ADDLW Soma valor literal ao valor contido em W 1 C, DC, Z * ANDLW Operação AND (E) entre o valor literal e valor contido em W 1 Z * CALL Chama sub-rotina 2 /TO, /PD * CLRWDT Coloca valor zero no registro WDT (Watchdog Timer) 1 GOTO Vá para (o endereço indicado) 2 IORLW Operação OR (OU) entre o valor literal e valor contido em W 1 MOVLW Mover o valor literal para o registro W 1 * RETFIE Retorna do Tratamento das Interrupções 2 * RETLW Retorna o valor literal no registro W 2 RETURN Retorna de uma sub-rotina 2 SLEEP Vai para modo baixo consumo 1 /TO, /PD SUBLW Subtrai valor literal do valor contido em W Operação EXCLUSIVE OR (OU EXCLUSIVO) entre o valor literal e valor contido em W 1 C, DC, Z 1 Z XORLW * Z * * * Interpretando as Informações Cada instrução se apresenta como um capítulo onde é descrita em sua função com os detalhes necessários para a compreensão de sua operação, incluídos exemplos de aplicação com amostra da sintaxe no código_fonte e como ocorre o comportamento dos bits e registros quando a instrução é executada. Quadro Demonstrativo Contém as informações básicas para consulta de aplicação indicando a função e o uso a instrução. MNEMÔNICO Forma contraída da instrução - normalmente formado pelas iniciais da frase que descreve a operação - o compilador dispões dos códigos de conversão adequados para esta forma. INSTRUÇÃO Frase que descreve a operação realizada pela instrução reproduzindo o texto na língua de origem (ingles). SINTAXE Forma que as instruções devem ser escritas no código_fonte para que o compilador interprete corretamente a conversão para código de máquina. DESCRIÇÃO Descreve a operação da instrução com detalhes. Quantidade de Ciclos de Máquina necessários para que a instrução seja executada CICLO MÁQUINA completamente - tempo de execução da instrução, dependente da frequencia do clock do dispositivo aplicado. STATUS Bit do registro STATUS que sofre alteração quando a execução da instrução resulta em situação definida pelo fabricante (ver quadro descritivo do registro STATUS). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 4/103 Organização do Registro Lembrar que todos os sistemas processados tem como base as Técnicas Digitais fundamentais logo, a estrutura do registro onde a informação é armazenada segue todos os padrões habituais de formato, nomes, localização de bit etc., etc., etc.. Para a exposição do funcionamento das instruções e seu emprego, os exemplos serão sempre baseados nos elementos identificados como mostra a figura abaixo: ┌───────────────────────> [ posição bit ] ───> 6 │ │ ┌────────> [ nome bit ] ─────> BOTAO │ │ 7 6 5 4 3 2 1 0 1 0 1 0 1 0 0 1 PORTA MSB LSB │ └─────> Bit menos significativo │ LSB - Least Significant Bit │ └──────────────────────────> Bit mais significativo MSB - Most Significant Bit Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 5/103 Vocabulário [ posição bit ] - número inteiro, no intervalo de 0 a 7, que identifica a posição do bit em um registro, contado sempre da direita para a esquerda, começando no bit 0 (LSB - bit menos significativo). BTFSC [ nome registro ],[ posição bit ] ; VERIFICA O ESTADO DO BIT [ ; REG. [ nome registro ] BTFSC PORTA,6 ; VERIFICA O ESTADO DO BIT 6 DO REG. PORTA ┌──────> [ posição bit ] ───> 6 │ │ │ 7 6 5 4 3 2 1 0 1 0 1 0 1 0 0 1 MSB posição bit ] DO PORTA LSB _______________________________________________________________________________________ [ nome bit ] - nome que identifica o bit dentro do registro em substituição do número que identifica a [ posição bit ] - o nome do bit pode ser estabelecido pelo fabricante (Registros de Funções Especiais - SFR): BCF [ nome registro ],[ nome bit ] ; DESLIGA O BIT [ nome bit ] NO REGISTRO ; [ nome registro ] BCF INTCON,PEIE ; DESLIGA BIT PEIE NO REGISTRO INTCON ┌──> PEIE │ │ 0 0 0 0 0 0 0 0 INTCON Ou pode ser estabelecido pelo programador (Registros de Uso Geral) e devidamente declarado na área de Diretivas. BCF [ nome bit ] ; DESLIGA O BIT [ nome bit ] BCF F_CONT ; DESLIGA BIT F_CONT ┌──> F_CONT │ │ 0 0 0 0 0 0 0 0 FLAG Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 6/103 [ nome registro ] - identifica um registro na memória (Ram ou Programa) a partir de um nome - o nome do registro pode ser estabelecido pelo fabricante (Registros de Funções Especiais SFR): 0 1 0 0 0 0 0 0 TMR0 Ou pode ser estabelecido pelo programador (Registros de Uso Geral) e devidamente declarado na área de Diretivas: [ endereço ] [ nome registro ] CBLOCK ; REGISTRO USO GERAL ENDC CBLOCK 0x20 FLAG ENDC ; REGISTRO PARA FLAGS DE CONTROLE 0 1 0 0 0 0 0 0 FLAG _______________________________________________________________________________________ [ registro origem ] - identifica o registro de origem do valor a ser empregado pela instrução a partir de um nome - o nome do registro pode ser estabelecido pelo fabricante (Registros de Funções Especiais - SFR), ou pode ser estabelecido pelo programador (Registros de Uso Geral) e devidamente declarado na área de Diretivas. ADDWF [ registro origem ],[ registro destino ] ; SOMAR O VALOR DO [ registro origem ; COM O VALOR DO [ registro destino ] E COLOCAR O ; RESULTADO DA OPERAÇÃO NO [ registro destino ] ADDWF CONT,W ] ; SOMAR O VALOR DO REG. W COM O VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. W _______________________________________________________________________________________ [ registro destino ] - identifica o registro de destino do valor resultado da execução da instrução a partir de um nome - o nome do registro pode ser estabelecido pelo fabricante (Registros de Funções Especiais - SFR), ou pode ser estabelecido pelo programador (Registros de Uso Geral) e devidamente declarado na área de Diretivas. SUBWF [ registro origem ],[ registro destino ] ; SOMAR O VALOR DO [ registro origem ; COM O VALOR DO [ registro destino ] E COLOCAR O ; RESULTADO DA OPERAÇÃO NO [ registro destino ] SUBWF CONT,W ] ; SOMAR O VALOR DO REG. W COM O VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 7/103 [ nome literal ] - identifica um valor numérico (constante) a partir de um nome estabelecido pelo programador e devidamente declarado na área de Diretivas. A utilização do valor numérico (constante) no programa se faz utilizando sempre o nome dado. O compilador se encarrega de realizar a substituição do nome pelo valor no registro. [ nome literal ] EQU .XXX ; RELACIONA O NOME [ nome ; VALOR NUMÉRICO XXX REFERENCIA EQU .133 ; RELACIONA O NOME ‘REFERENCIA’ AO ; VALOR NUMÉRICO 133 MOVLW [ nome literal ] ; MOVER [ MOVLW REFERENCIA ; MOVER ‘REFERENCIA’ PARA REG. W literal ] AO nome literal ] PARA REG. W _______________________________________________________________________________________ [ endereço ] - identifica o destino de um desvio originado no código_fonte - o programador pode utilizar nomes para identificar os diversos endereços. O compilador se encarrega de realizara a substituição do nome pela posição numérica na memória. Não tem necessidade de se declarar os nomes dos endereços na área de Diretivas. CALL [ endereço ] ; DESVIA PARA SUB-ROTINA [ endereço ] CALL SINALIZACAO ; DESVIA PARA SUB-ROTINA DE SINALIZAÇÃO GOTO [ endereço ] ; VAI PARA O ENDEREÇO [ GOTO DESLIGA_LED ; VAI PARA O ENDEREÇO DESLIGA_LED endereço ] _______________________________________________________________________________________ [ valor ] - valor numérico diretamente declarado na instrução dentro do código_fonte - o programador não identificou o valor através de um nome declarado na área de Diretivas. MOVLW [ valor ] ; MOVER [ valor ] PARA REG. W MOVLW B'10000011' ; MOVER LITERAL PARA REG. W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 8/103 STATUS O registro STATUS dispõe de 6 bits de flag (sinalização) reagindo ao resultado das operações realizadas por diversas instruções. A tabela descreve apenas os bits relacionados às funções afetadas. R/W 7 R/W 6 R/W 5 IRP RP1 RP0 R /TO 4 R /PD 3 R/W 2 Z R/W 1 DC MSB BIT OPER INÍCIO 7 6:5 4 3 2 1 0 R/W R/W R R R/W R/W R/W 0 0 1 1 X X X R/W 0 C LSB NOME FUNÇÃO IRP Seleção da Página de Memória (usado para endereçamento indireto) 1 = Ativa Páginas de Memória 2 e 3 (Bank2 e Bank3) 0 = Ativa Páginas de Memória 0 e 1 (Bank0 e Bank1) RP1:RP0 Seleção da Página de Memória (usado para endereçamento direto) /TO /PD Z DC C 11 = Ativa Página de Memória 3 (Bank3) 10 = Ativa Página de Memória 2 (Bank2) 01 = Ativa Página de Memória 1 (Bank1) 00 = Ativa Página de Memória 0 (Bank0) Time-Out - Tempo esgotado – a CPU informa as seguintes ocorrências neste bit: 1 = após energização do controlador ou ocorrência da instrução CLRWDT ou ocorrência da instrução SLEEP 0 = tempo esgotado para ocorrência da instrução WDT (o programa está parado em um loop infinito) Power Down – Queda Alimentação/Redução de Consumo - a CPU informa as seguintes ocorrências neste bit: 1 = após energização do controlador ou ocorrência da instrução SLEEP 0 = execução da instrução SLEEP Zero - a CPU informa as seguintes ocorrências neste bit: 1 = o resultado da última operação aritmética/lógica foi zero 0 = o resultado da última operação aritmética/lógica não foi zero Digit Carry/Borrow - Dígito de Transporte/Empréstimo - a CPU informa as seguintes ocorrências neste bit: 1 = o resultado da última operação aritmética/lógica não excedeu os 4 bits menos significativos do registro. 0 = o resultado da última operação aritmética/lógica excedeu os 4 bits menos significativos do registro. Carry/Borrow - Transporte/Empréstimo - a CPU informa as seguintes ocorrências neste bit: 1 = o resultado da última operação aritmética/lógica não excedeu o valor 255. 0 = o resultado da última operação aritmética/lógica excedeu o valor 255. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 9/103 BCF MNEMÔNICO BCF INSTRUÇÃO Bit Clear F SINTAXE BCF BCF BCF DESCRIÇÃO Coloca o valor (nível lógico) ‘0’ (clear) no bit identificado por [ nome bit ] [ nome bit ] – bit pertence a Registro de Uso Geral [ nome registro ],[ nome bit ] – bit pertence a Registro Especial [ nome registro ],[ posição bit ] – uso geral CICLO MÁQUINA 1 STATUS Nenhum Esta instrução coloca o nível lógico ‘0’ (zero - clear) no bit específico em um determinado registro. Só afeta o bit considerado dentro do registro. A sintaxe da instrução depende do tipo de registro em que o bit está localizado: Bit em Registro de Uso Geral: BCF [ nome bit ] O programador indica o nome do Bit e relaciona ao nome do Registro de Uso Geral na área de Diretivas – no código_fonte, usar o nome do Bit após a instrução. Bit em Registro Especial: BCF [ nome registro ],[ nome bit ] O nome do Bit já existe (o fabricante estabelece no arquivo de inclusão) mas não tem relacionamento entre ele e os Registros Especiais (o fabricante não coloca este relacionamento no arquivo de inclusão) – no código_fonte o programador deve identificar o Registro Especial e o nome do Bit. Uso Geral: BCF [ nome registro ],[ posição bit ] O Registro Especial não possui nomes para os Bits (por exemplo: registros PORT) – no código_fonte, o programador indica o nome do registro (definido na área de Diretivas) e a posição do Bit. EXEMPLOS: Bit em Registro de Uso Geral Operação: → BCF [ nome bit ] Desligar o bit F_CONT * Definir o nome do bit na área de diretivas identificando qual o registro e qual a posição do bit no registro: #DEFINE F_CONT FLAG,6 ; IDENTIFICANDO COM O NOME ‘F_CONT’ O BIT 6 DO ; REGISTRO FLAG Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 10/103 * Valor contido no bit 6 (F_CONT) do registro FLAG antes da execução da instrução: ┌──> F_CONT │ │ 0 1 0 0 0 0 0 0 FLAG * Instrução BCF [ nome bit ] ; DESLIGA [ nome bit ] BCF F_CONT ; DESLIGA FLAG F_CONT * Valor contido no bit 6 (F_CONT) do registro FLAG depois da execução da instrução: ┌──> F_CONT │ │ 0 0 0 Bit em Registro Especial Operação: 0 → 0 0 0 0 FLAG BCF [ nome registro ],[ nome bit ] Desligar a interrupção do TMR0 no registro INTCON * Valor contido no bit 5 (T0IE) do registro INTCON antes da execução da instrução: ┌──> T0IE │ │ 1 0 1 0 0 0 0 0 INTCON * Instrução BCF [ nome registro ],[ nome bit ] ; DESLIGA [ nome registro ],[ nome bit ] BCF INTCON,T0IE ; DESLIGA INTERRUPÇÃO TMR0 * Valor contido no bit 5 (T0IE) do registro INTCON depois da execução da instrução: ┌──> T0IE │ │ 1 Uso Geral Operação: → 0 0 0 0 0 0 0 INTCON BCF [ nome registro ],[ posição bit ] Desligar o bit relacionado a um Led (apagar o Led elétricamente ligado a uma saída) * Valor contido no bit 6 (elétricamente ligado a um Led) do registro PORTA antes da execução da instrução (o estado do bit indica que o Led está ligado): ┌──> LED │ │ 0 1 0 0 0 0 0 0 PORT A Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 11/103 * Instrução BCF [ nome registro ],[ posição bit ] ; DESLIGA [ nome registro ],[ posição bit ] BCF PORTA,6 ; DESLIGA O BIT 6 DO REGISTRO PORTA * Valor contido no bit 6 (elétricamente ligado a um Led) do registro PORTA depois da execução da instrução (o estado do bit indica que o Led está desligado): ┌──> LED │ │ 0 0 0 0 0 0 0 0 PORT A Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 12/103 BSF MNEMÔNICO BSF INSTRUÇÃO Bit Set F SINTAXE BSF BSF BSF DESCRIÇÃO Coloca o valor (nível lógico) ‘1’ (set) no bit identificado por [ nome bit ] [ nome bit ] – bit pertence a Registro de Uso Geral [ nome registro ],[ nome bit ] – bit pertence a Registro Especial [ nome registro ],[ posição bit ] – uso geral CICLO MÁQUINA 1 STATUS Nenhum Esta instrução coloca o nível lógico (valor) ‘1’ (set) no bit específico em um determinado registro. Só afeta o bit considerado dentro do registro. A sintaxe da instrução depende do tipo de registro em que está localizado: Bit em Registro de Uso Geral: BSF [ nome bit ] O programador indica o nome do Bit e relaciona ao nome do Registro de Uso Geral na área de Diretivas – no código_fonte, usar o nome do Bit após a instrução Bit em Registro Especial: BSF [ nome registro ],[ nome bit ] O nome do Bit já existe (o fabricante estabelece no arquivo de inclusão) mas não tem relacionamento entre ele e os Registros Especiais (o fabricante não coloca este relacionamento no arquivo de inclusão) – no código_fonte o programador deve identificar o Registro Especial e nome do Bit Uso Geral: BSF [ nome registro ],[ posição bit ] O Registro Especial não possui nomes para os Bits (por exemplo: registros PORT) – no código_fonte, o programador indica o nome do registro (definido na área de Diretivas) e a posição do Bit. EXEMPLOS: Bit em Registro de Uso Geral Operação: → BSF [ nome bit ] Ligar o bit F_CONT * Definir o nome do bit na área de diretivas identificando qual o registro e qual a posição do bit no registro: #DEFINE F_CONT FLAG,6 ; IDENTIFICANDO COM O NOME ‘F_CONT’ O BIT 6 DO ; REGISTRO FLAG Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 13/103 * Valor contido no bit 6 (F_CONT) do registro FLAG antes da execução da instrução: ┌──> F_CONT │ │ 0 0 0 0 0 0 0 0 FLAG * Instrução BSF [ nome bit ] ; LIGA [ nome bit ] BSF F_CONT ; LIGA FLAG F_CONT * Valor contido no bit 6 (F_CONT) do registro FLAG depois da execução da instrução: ┌──> F_CONT │ │ 0 1 0 Bit em Registro Especial Operação: 0 → 0 0 BSF 0 0 FLAG [ nome registro ],[ posição bit ] Ligar a interrupção do TMR0 no registro INTCON * Valor contido no bit 5 (T0IE) do registro INTCON antes da execução da instrução: ┌──> T0IE │ │ 1 0 0 0 0 0 0 0 INTCON * Instrução BSF [ nome registro ],[ nome bit ] ; LIGA [ nome registro ],[ nome bit ] BSF INTCON,T0IE ; LIGA INTERRUPÇÃO TMR0 * Valor contido no bit 5 (T0IE) do registro INTCON depois da execução da instrução: ┌──> T0IE │ │ 1 Uso Geral Operação: → 0 1 BSF 0 0 0 0 0 INTCON [ nome registro ],[ posição bit ] Ligar o bit relacionado a um Led (acender o Led ligado a uma saída) * Valor contido no bit 6 (elétricamente ligado a um Led) do registro PORTA antes da execução da instrução (o estado do bit indica que o Led está desligado): ┌──> LED │ │ 0 0 0 0 0 0 0 0 PORT A Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 14/103 * Instrução BSF [ nome registro ],[ posição bit ] ; LIGA [ nome registro ],[ posição bit ] BSF PORTA,6 ; LIGA BIT 6 NO REGISTRO PORTA * Valor contido no bit 6 (elétricamente ligado a um Led) do registro PORTA depois da execução da instrução (o estado do bit indica que o Led está ligado): ┌──> LED │ │ 0 1 0 0 0 0 0 0 PORT A Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 15/103 BTFSC MNEMÔNICO BTFSC INSTRUÇÃO Bit Test F, Skip if Clear BTFSC [ nome bit ] – uso geral BTFSC [ nome registro ],[ nome bit ] – bit pertence a Registro Especial BTFSC [ nome registro ],[ posição bit ] - bit pertence a Reg de Uso Geral Testa o valor (nível lógico) do bit identificado por [ nome bit ] e salta a instrução DESCRIÇÃO seguinte se valor do bit for igual a ‘0’ (clear) 2 CM se valor do bit = ‘0’ (clear) – executa uma NOP CICLO MÁQUINA 1 CM se valor do bit = ‘1’ (set) SINTAXE STATUS Nenhum Esta instrução verifica o nível lógico (valor) de um bit específico em um determinado registro: - se o bit = ‘1’ (set) → executa a instrução seguinte (no caso um GOTO). - se o bit = ‘0’ (clear) → salta a instrução seguinte e executa as demais instruções. Atenção: a execução da instrução (teste de um bit) não altera o valor contido no bit. A sintaxe da instrução depende do tipo de registro em que está localizado: Bit em Registro de Uso Geral: BTFSC [ nome bit ] O programador indica o nome do Bit e relaciona ao nome do Registro de Uso Geral na área de Diretivas – no código_fonte, usar o nome do Bit após a instrução Bit em Registro Especial: BTFSC [ nome registro ], [ nome bit ] O nome do Bit já existe (o fabricante estabelece no arquivo de inclusão) mas não tem relacionamento entre ele e os Registros Especiais (o fabricante não coloca este relacionamento no arquivo de inclusão) – no código_fonte o programador deve identificar o Registro Especial e nome do Bit Uso Geral: BTFSC [ nome registro ], [ posição bit ] O Registro Especial não possui nomes para os Bits (por exemplo: registros PORT) – no código_fonte, o programador indica o nome do registro (declarado na área de Diretivas) e a posição do Bit. Nos EXEMPLOS DE SINTAXE podemos ver como a instrução deve ser escrita no código_fonte nas suas diversas formas, mas não explica como a instrução funciona. No EXEMPLO DE APLICAÇÃO utiliza-se um código_fonte funcional completo para explicar como a instrução opera com detalhe. EXEMPLOS DE SINTAXE: Bit em Registro de Uso Geral Operação: → BTFSC [ nome bit ] Testar o valor do bit F_CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 16/103 * Definir o nome do bit na área de diretivas identificando qual o registro e qual a posição do bit no registro: #DEFINE F_CONT FLAG,6 ; IDENTIFICANDO COM O NOME ‘F_CONT’ O BIT 6 DO ; REGISTRO FLAG * Valor contido no bit 6 (F_CONT) do registro FLAG: ┌──> F_CONT │ │ 0 0 0 0 0 0 0 0 FLAG * Instrução BTFSC [ nome bit ] ; VERIFICA ESTADO [ nome bit ] BTFSC F_CONT ; VERIFICA ESTADO FLAG F_CONT Bit em Registro Especial Operação: → BTFSC [ nome registro ],[ posição bit ] Verificar se a interrupção do TMR0 (no registro INTCON) está habilitada * Valor contido no bit 5 (T0IE) do registro INTCON: ┌──> T0IE │ │ 1 0 0 0 0 0 0 0 INTCON * Instrução BTFSC [ nome registro ],[ nome bit ] ; VERIFICA ESTADO [ nome registro ],[ nome bit ] BTFSC INTCON,T0IE ; VERIFICA ESTADO T0IE - INTERRUPÇÃO TMR0 Uso Geral Operação: → BTFSC [ nome registro ],[ posição bit ] Verificar o bit relacionado a um Led (verificar se o Led está ligado) * Valor contido no bit 6 (elétricamente ligado a um Led) do registro PORTA (o estado do bit indica que o Led está desligado): ┌──> LED │ │ 0 0 0 0 0 0 0 0 PORT A * Instrução BTFSC [ nome registro ],[ posição bit ] ; VERIFICA ESTADO [ nome registro ],[ posição bit ] BTFSC PORTA,6 ; VERIFCA ESTADO DO BIT 6 NO REGISTRO PORTA Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 17/103 EXEMPLO DE APLICAÇÃO: Para estudar a maneira como a instrução funciona dentro de um código_fonte, vamos desenvolver uma aplicação simples onde possamos verificar detalhadamente o comportamento dos bits controlados . Consideremos o diagrama funcional: VDD R1 MCU RA0 RA6 R2 B1 L1 VSS A operação proposta é bastante simples: - Aperta o botão B1, acende o led L1. - Solta o botão B1, apaga o led L1. Os estados lógicos que os componentes B1 e L1 podem apresentar para a operação proposta: B1 Livre Pressionado 1 0 L1 Apagado Aceso 0 1 Agora podemos elaborar o fluxograma representativo do funcionamento do sistema: INICIO = 1 B1 (B1 livre) L1 = 0 =0 (B1 pressionado) L1 = 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 18/103 No exemplo de aplicação vamos empregar a sintaxe da instrução: Bit em Registro de Uso Geral → BTFSC [ nome bit ] O programador deve indicar o nome do Bit e relacionar ao nome do Registro de Uso Geral na área de Diretivas – no código_fonte será usado o nome do Bit após a instrução * Definir o nome dos bits de entrada e saída na área de diretivas relacionando o nome ao registro e à posição do bit no registro: #DEFINE B1 PORTA,0 #DEFINE L1 PORTA,6 ; RELACIONANDO O NOME ‘B1’ AO BIT 0 DO ; REGISTRO PORTA ; RELACIONANDO O NOME ‘L1’ O BIT 6 DO ; REGISTRO PORTA ┌──> L1 → bit 6 │ │ 0 0 0 0 0 ┌──> B1 → bit 0 │ 0 0 1 PORT A Baseado no fluxograma, o código_fonte pode ser escrito como: INICIO BTFSC GOTO BSF GOTO B1 DESLIGA_L1 L1 INICIO ; VERIFICA O ESTADO DO BIT QUE REPRESENTA B1 ; B1 = 1 > VAI PARA DESLIGA_L1 ; B1 = 0 > LIGA L1 ; RETORNA PARA INICIO L1 INICIO ; DESLIGA L1 ; RETORNA PARA INICIO DESLIGA_L1 BCF GOTO A execução do código começa em INICIO, verifica o nível lógico (valor) do bit representado pelo nome B1 e adota uma das duas possibilidades que a instrução oferece, como o código_fonte indica abaixo: ┌──>INICIO │ ┌─┬ BTFSC B1 ; VERIFICA O ESTADO DE B1 │ │ │ │ =0 =1 ──> VALORES QUE B1 PODE ASSUMIR │ │ │ │ │ └> GOTO DESLIGA_L1 ┐ ; B1 = 1 > VAI PARA DESLIGA_L1 │ └──> BSF L1 │ ; B1 = 0 > LIGA L1 │ GOTO INICIO ┐ │ ; RETORNA PARA INICIO │ │ │ │ (BUSCA ENDEREÇO INICIO) │ │<───────────────────────┘ │ │ │ │ (BUSCA ENDEREÇO DESLIGA_L1) │ ┌────────────────────────┘ │ DESLIGA_L1 │ └──> BCF L1 ; DESLIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 19/103 Analisando as opções da instrução: * Se B1 = ‘1’ (set) - B1 livre → realiza a instrução seguinte (no caso, um GOTO). O fluxograma mostra o caminho que o código_fonte realiza para esta condição: INICIO =1 B1 L1 = 0 (B1 livre) =0 (B1 pressionado) L1 = 1 A sequencia do código_fonte é realizada na forma indicada (em vermelho, também): ┌──>INICIO │ ┌─┬ BTFSC B1 ; VERIFICA O ESTADO DE B1 │ │ │ │ =0 =1 ──> VALOR B1 = 1 │ │ │ │ │ └> GOTO DESLIGA_L1 ┐ ; B1 = 1 > VAI PARA DESLIGA_L1 │ └──> BSF L1 │ ; B1 = 0 > LIGA L1 │ GOTO INICIO ┐ │ ; RETORNA PARA INICIO │ │ │ │ (BUSCA ENDEREÇO INICIO) │ │<───────────────────────┘ │ │ │ │ (BUSCA ENDEREÇO DESLIGA_L1) │ ┌────────────────────────┘ │ DESLIGA_L1 │ └──> BCF L1 ; DESLIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ Analisando o comportamento dos bits envolvidos nas instruções dentro do registro PORTA: * Valor contido no bit 0 (B1) do registro PORTA antes da execução da instrução BTFSC: ┌──> L1 │ │ 0 0 0 ┌──> B1 │ │ 0 0 0 0 1 PORT A * Instrução - durante a execução do código_fonte, somente as instruções envolvidas são consideradas, as demais são completamente ignoradas - não existem - portanto, o controlador vai ver o código_fonte da seguinte forma: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 20/103 ┌──>INICIO │ ┬ BTFSC B1 ; VERIFICA O ESTADO DE B1 │ │ │ =1 │ │ │ └> GOTO DESLIGA_L1 ┐ ; B1 = 1 > VAI PARA DESLIGA_L1 │ │ │ │ │ (BUSCA ENDEREÇO DESLIGA_L1) │ ┌────────────────────────┘ │ DESLIGA_L1 │ └──> BCF L1 ; DESLIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ * Valor contido no bit 0 (B1) do registro PORTA depois da execução da instrução BTFSC - o valor contido no bit 0 (B1) não se altera com a execução da instrução; a execução da instrução BCF impõe o valor 0 (zero) no bit 6 (L1). ┌──> L1 │ │ 0 0 0 ┌──> B1 │ │ 0 0 0 0 1 PORT A * Se B1 = ‘0’ (clear) - B1 pressionado → salta a instrução seguinte e executa a instrução encontrada (no caso, um BSF). O fluxograma mostra o caminho que o código_fonte realiza para esta condição: INICIO =1 B1 (B1 livre) L1 = 0 =0 (B1 pressionado) L1 = 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 21/103 A sequencia do código_fonte é realizada na forma indicada (em vermelho, também): ┌──>INICIO │ ┌─┬ BTFSC B1 ; VERIFICA O ESTADO DE B1 │ │ │ │ =0 =1 ──> VALOR B1 = 0 │ │ │ │ │ └> GOTO DESLIGA_L1 ┐ ; B1 = 1 > VAI PARA DESLIGA_L1 │ └──> BSF L1 │ ; B1 = 0 > LIGA L1 │ GOTO INICIO ┐ │ ; RETORNA PARA INICIO │ │ │ │ (BUSCA ENDEREÇO INICIO) │ │<───────────────────────┘ │ │ │ │ (BUSCA ENDEREÇO DESLIGA_L1) │ ┌────────────────────────┘ │ DESLIGA_L1 │ └──> BCF L1 ; DESLIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ Analisando o comportamento dos bits envolvidos nas instruções dentro do registro PORTA: * Valor contido no bit 0 (B1) do registro PORTA antes da execução da instrução BTFSC: ┌──> L1 │ │ 0 0 0 ┌──> B1 │ │ 0 0 0 0 0 PORT A * Instrução - durante a execução do código_fonte, somente as instruções envolvidas são consideradas, as demais são completamente ignoradas - não existem - portanto, o controlador vai ver o código_fonte da seguinte forma: ┌──>INICIO │ ┌─┬ BTFSC B1 │ │ │ =0 │ │ │ └──> BSF L1 │ GOTO INICIO ┐ │ │ │ (BUSCA ENDEREÇO INICIO) │<───────────────────────┘ ; VERIFICA O ESTADO DE B1 ; B1 = 0 > LIGA L1 ; RETORNA PARA INICIO * Valor contido no bit 0 (B1) do registro PORTA depois da execução da instrução BTFSC - o valor contido no bit 0 (B1) não se altera com a execução da instrução; a execução da instrução BSF impõe o valor 1 (um) no bit 6 (L1). ┌──> L1 │ │ 0 1 0 ┌──> B1 │ │ 0 0 0 0 1 PORT A Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 22/103 BTFSS MNEMÔNICO BTFSS INSTRUÇÃO Bit Test F, Skip if Set BTFSS [ nome bit ] – uso geral BTFSS [ nome registro ],[ nome bit ] – bit pertence a Registro Especial BTFSS [ nome registro ],[ posição bit ] - bit pertence a Reg de Uso Geral Testa o valor (nível lógico) do bit identificado por F [ nome bit ] e salta a instrução DESCRIÇÃO seguinte se valor do bit for igual a ‘1’ (set) 2 CM se valor do bit = ‘1’ (set) – executa uma NOP CICLO MÁQUINA 1 CM se valor do bit = ‘0’ (clear) SINTAXE STATUS Nenhum Esta instrução verifica o nível lógico (valor) de um bit específico em um determinado registro: - se o bit = ‘0’ (clear) → executa a instrução seguinte (no caso um GOTO). - se o bit = ‘1’ (set) → salta a instrução seguinte e executa as demais instruções. Atenção: a execução da instrução (teste de um bit) não altera o valor contido no bit. A sintaxe da instrução depende do tipo de registro em que está localizado: Bit em Registro de Uso Geral: BTFSS [ nome bit ] O programador indica o nome do Bit e relaciona ao nome do Registro de Uso Geral na área de Diretivas – no código_fonte, usar o nome do Bit após a instrução Bit em Registro Especial: BTFSS [ nome registro ],[ nome bit ] O nome do Bit já existe (o fabricante estabelece no arquivo de inclusão) mas não tem relacionamento entre ele e os Registros Especiais (o fabricante não coloca este relacionamento no arquivo de inclusão) – no código_fonte o programador deve identificar o Registro Especial e nome do Bit Uso Geral: BTFSS [ nome registro ],[ posição bit ] O Registro Especial não possui nomes para os Bits (por exemplo: registros PORT) – no código_fonte, o programador indica o nome do registro (declarado na área de Diretivas) e a posição do Bit. Nos EXEMPLOS DE SINTAXE podemos ver como a instrução deve ser escrita no código_fonte nas suas diversas formas, mas não explica como a instrução funciona. No EXEMPLO DE APLICAÇÃO utiliza-se um código_fonte funcional completo para explicar como a instrução opera com detalhe. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 23/103 EXEMPLOS DE SINTAXE: Bit em Registro de Uso Geral Operação: → BTFSS [ nome bit ] Testar o valor do bit F_CONT * Definir o nome do bit na área de diretivas identificando qual o registro e qual a posição do bit no registro: #DEFINE F_CONT FLAG,6 ; IDENTIFICANDO COM O NOME ‘F_CONT’ O BIT 6 DO ; REGISTRO FLAG * Valor contido no bit 6 (F_CONT) do registro FLAG: ┌──> F_CONT │ │ 0 0 0 0 0 0 0 0 FLAG * Instrução BTFSS [ nome bit ] ; VERIFICA ESTADO [ nome bit ] BTFSS F_CONT ; VERIFICA ESTADO FLAG F_CONT Bit em Registro Especial Operação: → BTFSS [ nome registro ],[ posição bit ] Verificar se a interrupção do TMR0 (no registro INTCON) está habilitada * Valor contido no bit 5 (T0IE) do registro INTCON: ┌──> T0IE │ │ 1 0 0 0 0 0 0 0 INTCON * Instrução BTFSS [ nome registro ],[ nome bit ] ; VERIFICA ESTADO [ nome registro ],[ nome bit ] BTFSS INTCON,T0IE ; VERIFICA ESTADO T0IE - INTERRUPÇÃO TMR0 Uso Geral Operação: → BTFSS [ nome registro ],[ posição bit ] Verificar o bit relacionado a um Led (verificar se o Led está ligado) * Valor contido no bit 6 (elétricamente ligado a um Led) do registro PORTA (o estado do bit indica que o Led está desligado): ┌──> LED │ │ 0 0 0 0 0 0 0 0 PORT A Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 24/103 * Instrução BTFSS [ nome registro ],[ posição bit ] ; VERIFICA ESTADO [ nome registro ],[ posição bit ] BTFSS PORTA,6 ; VERIFCA ESTADO DO BIT 6 NO REGISTRO PORTA EXEMPLO DE APLICAÇÃO: Para estudar a maneira como a instrução funciona dentro de um código_fonte, vamos desenvolver uma aplicação simples onde possamos verificar detalhadamente o comportamento dos bits controlados . Consideremos o diagrama funcional: VDD R1 MCU RA0 RA6 R2 B1 L1 VSS A operação proposta é bastante simples: - Aperta o botão B1, acende o led L1. - Solta o botão B1, apaga o led L1. Os estados lógicos que os componentes B1 e L1 podem apresentar para a operação proposta: B1 Livre Pressionado 1 0 L1 Apagado Aceso 0 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 25/103 Agora podemos elaborar o fluxograma representativo do funcionamento do sistema: INICIO = 1 B1 L1 = 0 (B1 livre) =0 (B1 pressionado) L1 = 1 No exemplo de aplicação vamos empregar a sintaxe da instrução: Bit em Registro de Uso Geral → BTFSS [ nome bit ] O programador deve indicar o nome do Bit e relacionar ao nome do Registro de Uso Geral na área de Diretivas – no código_fonte será usado o nome do Bit após a instrução * Definir o nome dos bits de entrada e saída na área de diretivas relacionando o nome ao registro e à posição do bit no registro: #DEFINE B1 PORTA,0 #DEFINE L1 PORTA,6 ; RELACIONANDO O NOME ‘B1’ AO BIT 0 DO ; REGISTRO PORTA ; RELACIONANDO O NOME ‘L1’ O BIT 6 DO ; REGISTRO PORTA ┌──> L1 → bit 6 │ │ 0 0 0 0 0 ┌──> B1 → bit 0 │ 0 0 1 PORT A Baseado no fluxograma, o código_fonte pode ser escrito como: INICIO BTFSS GOTO BCF GOTO B1 LIGA_L1 L1 INICIO ; VERIFICA O ESTADO DO BIT QUE REPRESENTA B1 ; B1 = 0 > VAI PARA LIGA_L1 ; B1 = 1 > DESLIGA L1 ; RETORNA PARA INICIO L1 INICIO ; LIGA L1 ; RETORNA PARA INICIO LIGA_L1 BSF GOTO A execução do código começa em INICIO, verifica o nível lógico (valor) do bit representado pelo nome B1 e adota uma das duas possibilidades que a instrução oferece, como o código_fonte indica abaixo: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 26/103 ┌──>INICIO │ ┌─┬ BTFSS B1 ; VERIFICA O ESTADO DE B1 │ │ │ │ =1 =0 ──> VALORES QUE B1 PODE ASSUMIR │ │ │ │ │ └> GOTO LIGA_L1 ┐ ; B1 = 0 > VAI PARA LIGA_L1 │ └──> BCF L1 │ ; B1 = 1 > DESLIGA L1 │ GOTO INICIO ┐ │ ; RETORNA PARA INICIO │ │ │ │ (BUSCA ENDEREÇO INICIO) │ │<───────────────────────┘ │ │ │ │ (BUSCA ENDEREÇO LIGA_L1) │ ┌────────────────────────┘ │ LIGA_L1 │ └──> BSF L1 ; LIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ Analisando as opções da instrução: * Se B1 = ‘1’ (set) - B1 livre → salta a instrução seguinte e executa a instrução encontrada (BCF). O fluxograma mostra o caminho que o código_fonte realiza para esta condição: INICIO =1 B1 (B1 livre) L1 = 0 =0 (B1 pressionado) L1 = 1 A sequencia do código_fonte é realizada na forma indicada (em vermelho, também): ┌──>INICIO │ ┌─┬ BTFSS B1 ; VERIFICA O ESTADO DE B1 │ │ │ │ =1 =0 ──> VALOR B1 = 1 │ │ │ │ │ └> GOTO LIGA_L1 ┐ ; B1 = 0 > VAI PARA LIGA_L1 │ └──> BCF L1 │ ; B1 = 1 > DESLIGA L1 │ GOTO INICIO ┐ │ ; RETORNA PARA INICIO │ │ │ │ (BUSCA ENDEREÇO INICIO) │ │<───────────────────────┘ │ │ │ │ (BUSCA ENDEREÇO LIGA_L1) │ ┌────────────────────────┘ │ LIGA_L1 │ └──> BSF L1 ; LIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 27/103 Analisando o comportamento dos bits envolvidos nas instruções dentro do registro PORTA: * Valor contido no bit 0 (B1) do registro PORTA antes da execução da instrução BTFSS: ┌──> L1 │ │ 0 0 0 ┌──> B1 │ │ 0 0 0 0 1 PORT A * Instrução - durante a execução do código_fonte, somente as instruções envolvidas são consideradas, as demais são completamente ignoradas - não existem - portanto, o controlador vai ver o código_fonte da seguinte forma: ┌──>INICIO │ ┌─┬ BTFSS B1 │ │ │ =1 │ │ │ └──> BCF L1 │ GOTO INICIO ┐ │ │ │ (BUSCA ENDEREÇO INICIO) │<───────────────────────┘ ; VERIFICA O ESTADO DE B1 ; B1 = 1 > DESLIGA L1 ; RETORNA PARA INICIO * Valor contido no bit 0 (B1) do registro PORTA depois da execução da instrução BTFSS - o valor contido no bit 0 (B1) não se altera com a execução da instrução; a execução da instrução BCF impõe o valor 0 (zero) no bit 6 (L1). ┌──> L1 │ │ 0 0 0 ┌──> B1 │ │ 0 0 0 0 1 PORT A * Se B1 = ‘0’ (clear) - B1 pressionado → realiza a instrução seguinte (GOTO). O fluxograma mostra o caminho que o código_fonte realiza para esta condição: INICIO =1 B1 (B1 livre) L1 = 0 =0 (B1 pressionado) L1 = 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 28/103 A sequencia do código_fonte é realizada na forma indicada (em vermelho, também): ┌──>INICIO │ ┌─┬ BTFSS B1 ; VERIFICA O ESTADO DE B1 │ │ │ │ =1 =0 ──> VALOR B1 = 0 │ │ │ │ │ └> GOTO LIGA_L1 ┐ ; B1 = 0 > VAI PARA LIGA_L1 │ └──> BCF L1 │ ; B1 = 1 > DESLIGA L1 │ GOTO INICIO ┐ │ ; RETORNA PARA INICIO │ │ │ │ (BUSCA ENDEREÇO INICIO) │ │<───────────────────────┘ │ │ │ │ (BUSCA ENDEREÇO LIGA_L1) │ ┌────────────────────────┘ │ LIGA_L1 │ └──> BSF L1 ; LIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ Analisando o comportamento dos bits envolvidos nas instruções dentro do registro PORTA: * Valor contido no bit 0 (B1) do registro PORTA antes da execução da instrução BTFSS: ┌──> L1 │ │ 0 0 0 ┌──> B1 │ │ 0 0 0 0 0 PORT A * Instrução - durante a execução do código_fonte, somente as instruções envolvidas são consideradas, as demais são completamente ignoradas - não existem - portanto, o controlador vai ver o código_fonte da seguinte forma: ┌──>INICIO │ ┬ BTFSS B1 ; VERIFICA O ESTADO DE B1 │ │ │ =0 │ │ │ └> GOTO LIGA_L1 ┐ ; B1 = 0 > VAI PARA LIGA_L1 │ │ │ │ │ (BUSCA ENDEREÇO LIGA_L1) │ ┌────────────────────────┘ │ LIGA_L1 │ └──> BSF L1 ; LIGA L1 │ GOTO INICIO ┐ ; RETORNA PARA INICIO │ │ │ (BUSCA ENDEREÇO INICIO) └────────────────────────┘ * Valor contido no bit 0 (B1) do registro PORTA depois da execução da instrução BTFSS - o valor contido no bit 0 (B1) não se altera com a execução da instrução; a execução da instrução BSF impõe o valor 1 (um) no bit 6 (L1). ┌──> L1 │ │ 0 1 0 ┌──> B1 │ │ 0 0 0 0 1 PORT A Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 29/103 CALL MNEMÔNICO CALL INSTRUÇÃO Call Subroutine SINTAXE CALL DESCRIÇÃO Desvia o programa para uma sub-rotina (sequencia de instruções pré-definida) identificada por [ endereço ] [ endereço ] CICLO MÁQUINA 2 STATUS Nenhum Esta instrução desvia o programa para o endereço indicado em [ nome subrotina ] e executa a sequencia de instruções indicada. A sequencia de instruções do desvio deve ser encerrada com a instrução RETURN, que retorna à posição imediatamente seguinte à da instrução CALL. EXEMPLO: CALL SINALIZACAO ┐ ; DESVIA PARA SUB-ROTINA DE “SINALIZACAO” ┌──> ┌ │ │ │• │ ; SEQUENCIA DE INSTRUÇÕES DE EXECUÇÃO │ │• │ ; NORMAL DO PROGRAMA │ │• │ │ └ │ │ │ │ (BUSCA ENDEREÇO SINALIZACAO) │ ┌────────────────────┘ │ SINALIZACAO │ ┌ │ │• ; SEQUENCIA DE INSTRUÇÕES DE EXECUÇÃO │ │• ; DA SUB-ROTINA “SINALIZACAO” │ │• │ └ │ RETURN┐ ; SAÍDA DA SUB-ROTINA “SINALIZACAO” │ │ │ │ │ (BUSCA ENDEREÇO DE RETORNO - linha seguinte à da instrução CALL) └──────────┘ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 30/103 CLRF MNEMÔNICO CLRF INSTRUÇÃO Clear F SINTAXE CLRF DESCRIÇÃO Coloca o valor ‘0’ (clear) dentro do registro identificado por [ nome registro ] [ nome registro ] CICLO MÁQUINA 1 STATUS Z Esta instrução substitui todos os valores de cada bit de um registro pelo valor ‘0’ (clear). Atenção: colocar valor ‘0’ (zero) em todos os bits de um registro não significa apagar o valor contido anteriormente neste registro, uma vez que o número “zero” é representado por um registro com todos os bits com valor ‘0’ (zero). EXEMPLO: * Valor contido no registro PORTA antes da execução da instrução: 1 0 1 0 1 0 0 1 PORTA * Instrução CLRF PORTA ;COLOCA VALOR ZERO NO REGISTRO PORTA * Valor contido no registro PORTA depois da execução da instrução: 0 0 0 0 0 0 0 0 PORTA Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 31/103 CLRW MNEMÔNICO CLRW INSTRUÇÃO Clear W SINTAXE CLRW DESCRIÇÃO Coloca o valor ‘0’ (clear) dentro do registro W CICLO MÁQUINA 1 STATUS Z Esta instrução substitui todos os valores de cada bit do registro W pelo valor ‘0’ (clear). Atenção: colocar valor ‘0’ (zero) em todos os bits de um registro não significa apagar o valor contido anteriormente neste registro, uma vez que o número “zero” é representado por um registro com todos os bits com valor ‘0’ (zero). EXEMPLO: * Valor contido no registro W antes da execução da instrução: 1 0 1 0 1 0 0 1 W * Instrução CLRW ; COLOCA VALOR ZERO NO REGISTRO W * Valor contido no registro W depois da execução da instrução: 0 0 0 0 0 0 0 0 W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 32/103 DECF MNEMÔNICO DECF INSTRUÇÃO Decrement F SINTAXE DECF DESCRIÇÃO Decrementa de uma unidade o valor contido no registro F identificado por [ nome registro ] CICLO MÁQUINA 1 STATUS Z [ nome registro ] Esta instrução subtrai uma unidade ( 1 ) do registro. Se o resultado da subtração do registro resultar em valor zero (nulo), o bit Z do registro STATUS altera o valor para ‘1’. É necessário que o registro seja definido como variável nas diretivas. EXEMPLO: * Definir o registro como variável nas diretivas: CBLOCK 0x20 CONT ENDC ; REGISTRO CONTADOR * Valor contido no registro CONT antes da execução da instrução: 0 0 0 0 0 0 1 0 2 CONT * Instrução DECF CONT ; DECREMENTA UMA UNIDADE O REG. CONT 0 0 0 0 0 0 1 0 2 CONT − − 0 0 0 0 0 0 0 1 1 CONT − 1 0 0 0 0 0 0 0 1 1 CONT * Valor contido no registro CONT depois da execução da instrução DECF: 0 0 0 0 0 0 0 1 1 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 33/103 DECFSZ MNEMÔNICO DECFSZ INSTRUÇÃO Decrement F, Skip if Zero SINTAXE DECFSZ [ nome registro ] Decrementa de uma unidade o valor contido no registro F identificado por [ nome registro ] e salta a instrução seguine se o resultado da operação for zero. 2 CM se valor do registro for igual a zero – executa uma NOP CICLO MÁQUINA 1 CM se valor do registro for diferente de zero DESCRIÇÃO STATUS Nenhum Esta instrução subtrai uma unidade ( 1 ) do registro e verifica se o resultado da operação é zero (nulo): - se o resultado da operação = ‘0’ (igual a zero) → salta a instrução seguinte e executa as demais instruções. - se o resultado da operação ≠ ‘0’ (diferente de zero) → executa a instrução seguinte (no caso um GOTO). É necessário que o registro seja definido como variável nas diretivas. EXEMPLO: * Definir o registro como variável nas diretivas: CBLOCK 0x20 CONT ENDC ; REGISTRO CONTADOR Vamos considerar o código abaixo: INICIO DECFSZ GOTO BSF ┌ │• │• │• └ CONT INICIO FLAG ; DECREMENTA UMA UNIDADE O REG. CONT ; RESULTADO ≠ 0 > VAI PARA INICIO ; RESULTADO = 0 > COLOCA ‘1’ NO BIT FLAG ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA A execução do código começa em INICIO, subtrai uma unidade do registro CONT,verifica se o resultado da operação é zero e deve adotar uma das duas possibilidades que a instrução oferece: * Resultado da operação ≠ ‘0’ (diferente de zero) → executa a instrução seguinte (no caso um GOTO). * Valor contido no registro CONT antes da execução da instrução: 0 0 0 0 0 0 1 0 2 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 34/103 * Instrução DECFSZ CONT ; DECREMENTA UMA UNIDADE O REG. CONT 0 0 0 0 0 0 1 0 2 CONT − − 0 0 0 0 0 0 0 1 1 CONT − 1 0 0 0 0 0 0 0 1 1 CONT * Valor contido no registro CONT depois da execução da instrução DECFSZ: 0 0 0 0 0 0 0 1 1 CONT * Instrução seguinte GOTO INICIO ; RESULTADO ≠ 0 > VAI PARA INICIO * Resultado da operação = ‘0’ (clear) → salta a instrução seguinte e executa as demais instruções. * Valor contido no registro CONT antes da execução da instrução: 0 0 0 0 0 0 0 1 1 CONT * Instrução DECFSZ CONT ; DECREMENTA UMA UNIDADE O REG. CONT 0 0 0 0 0 0 0 1 1 CONT − − 0 0 0 0 0 0 0 1 1 CONT − 1 0 0 0 0 0 0 0 0 0 CONT * Valor contido no registro CONT depois da execução da instrução DECFSZ: 0 0 0 0 0 0 0 0 0 CONT * Instrução seguinte BSF ┌ │• │• │• └ FLAG ; RESULTADO = 0 > COLOCA ‘1’ NO BIT FLAG ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 35/103 Observando o código completo com as indicações de caminhos a serem seguidos em funçãodo resultado da operação INCFSZ, podemos notar que, uma vez escolhido o caminho de execução, as demais possbilidades são ignoradas: ┌───────────────────┐ │ (BUSCA ENDEREÇO) INICIO ┌─┬ DECFSZ =0 ≠0 │ └> GOTO └──> BSF ┌ │• │• │• └ │ CONT │ │ INICIO ┘ FLAG ; DECREMENTA UMA UNIDADE O REG. CONT ; RESULTADO ≠ 0 > VAI PARA INICIO ; RESULTADO = 0 > COLOCA ‘1’ NO BIT FLAG ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 36/103 GOTO MNEMÔNICO GOTO INSTRUÇÃO Go To SINTAXE GOTO DESCRIÇÃO Desvia para o [ endereço ] indicado [ endereço ] CICLO MÁQUINA 2 STATUS Nenhum Esta instrução cria um desvio incondicional para qualquer outra parte do programa de acordo com o nome do endereço indicado. Este desvio não tem retorno e não depende de condições internas ou externas ao programa. EXEMPLO: * Instrução GOTO DESLIGA_LED ┐ │ ; VAI PARA O ENDEREÇO DESLIGA_LED (BUSCA ENDEREÇO DESLIGA_LED) ┌────────────────────────┘ DESLIGA_LED │ └──> BCF LED ; DESLIGA LED Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 37/103 INCF MNEMÔNICO INCF INSTRUÇÃO Increment F SINTAXE INCF DESCRIÇÃO Incrementa de uma unidade o valor contido no registro F identificado por [ nome registro ] [ nome registro ] CICLO MÁQUINA 1 STATUS Z Esta instrução adiciona uma unidade ( 1 ) ao registro. Se o resultado da adição ao registro resultar em valor zero (nulo), o bit Z do registro STATUS altera o valor para ‘1’. É necessário que o registro seja definido como variável nas diretivas. EXEMPLO: * Definir o registro como variável nas diretivas: CBLOCK 0x20 CONT ENDC ; REGISTRO CONTADOR * Valor contido no registro CONT antes da execução da instrução: 1 1 1 1 1 1 1 0 254 CONT * Instrução INCF CONT ; INCREMENTA UMA UNIDADE O REG. CONT 1 1 1 1 1 1 1 0 254 CONT + + 0 0 0 0 0 0 0 1 1 CONT + 1 1 1 1 1 1 1 1 1 255 CONT * Valor contido no registro CONT depois da execução da instrução INCF: 1 1 1 1 1 1 1 1 255 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 38/103 INCFSZ MNEMÔNICO INCFSZ INSTRUÇÃO Increment F, Skip if Zero SINTAXE INCFSZ [ nome registro ] Incrementa de uma unidade o valor contido no registro F identificado por [ nome registro ] e salta a instrução seguine se o resultado da operação for zero. 2 CM se valor do registro for igual a zero – executa uma NOP CICLO MÁQUINA 1 CM se valor do registro for diferente de zero DESCRIÇÃO STATUS Nenhum Esta instrução adiciona uma unidade ( 1 ) ao registro e verifica se o resultado da operação é zero (nulo): - se o resultado da operação = ‘0’ (igual a zero) → salta a instrução seguinte e executa as demais instruções. - se o resultado da operação ≠ ‘0’ (diferente de zero) → executa a instrução seguinte (no caso um GOTO). É necessário que o registro seja definido como variável nas diretivas. EXEMPLO: * Definir o registro como variável nas diretivas: CBLOCK 0x20 CONT ENDC ; REGISTRO CONTADOR Vamos considerar o código abaixo: INICIO INCFSZ GOTO BSF ┌ │• │• │• └ CONT INICIO FLAG ; INCREMENTA UMA UNIDADE O REG. CONT ; RESULTADO ≠ 0 > VAI PARA INICIO ; RESULTADO = 0 > COLOCA ‘1’ NO BIT FLAG ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA A execução do código começa em INICIO, adiciona uma unidade ao registro CONT,verifica se o resultado da operação é zero e deve adotar uma das duas possibilidades que a instrução oferece: * Resultado da operação ≠ ‘0’ (diferente de zero) → executa a instrução seguinte (no caso um GOTO). * Valor contido no registro CONT antes da execução da instrução: 1 1 1 1 1 1 1 0 254 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 39/103 * Instrução INCFSZ CONT ; INCREMENTA UMA UNIDADE O REG. CONT 1 1 1 1 1 1 1 0 254 CONT + + 0 0 0 0 0 0 0 1 1 CONT + 1 1 1 1 1 1 1 1 1 255 CONT * Valor contido no registro CONT depois da execução da instrução INCFSZ: 1 1 1 1 1 1 1 1 255 CONT * Instrução seguinte GOTO INICIO ; RESULTADO ≠ 0 > VAI PARA INICIO * Resultado da operação = ‘0’ (igual a zero) → salta a instrução seguinte e executa as demais instruções. * Valor contido no registro CONT antes da execução da instrução: 1 1 1 1 1 1 1 1 255 CONT * Instrução INCFSZ CONT ; INCREMENTA UMA UNIDADE O REG. CONT 1 1 1 1 1 1 1 1 255 CONT + + 0 0 0 0 0 0 0 1 1 CONT + 1 0 0 0 0 0 0 0 0 0 CONT * Valor contido no registro CONT depois da execução da instrução INCFSZ: 0 0 0 0 0 0 0 0 0 CONT * Instrução seguinte BSF ┌ │• │• │• └ FLAG ; RESULTADO = 0 > COLOCA ‘1’ NO BIT FLAG ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 40/103 Observando o código completo com as indicações de caminhos a serem seguidos em funçãodo resultado da operação INCFSZ, podemos notar que, uma vez escolhido o caminho de execução, as demais possbilidades são ignoradas: ┌───────────────────┐ │ (BUSCA ENDEREÇO) INICIO ┌─┬ INCFSZ =0 ≠0 │ └> GOTO └──> BSF ┌ │• │• │• └ │ CONT │ │ INICIO ┘ FLAG ; INCREMENTA UMA UNIDADE O REG. CONT ; RESULTADO ≠ 0 > VAI PARA INICIO ; RESULTADO = 0 > COLOCA ‘1’ NO BIT FLAG ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 41/103 MOVLW MNEMÔNICO MOVLW INSTRUÇÃO Move Literal to W SINTAXE DESCRIÇÃO MOVLW [ nome literal ] MOVLW [ valor ] Mover o valor do literal identificado por [ nome literal ] ou [ valor ] para o registro W CICLO MÁQUINA 1 STATUS Nenhum Esta instrução é usada para copiar o valor de um número ou constante (literal) armazenado em um registro da memória de programa, para o registro W. Observar que não importa a forma que o valor é declarado (binário, decimal ou hexa) no programa, o valor que será colocado no registro W será sempre em binário. O valor do literal pode ser expresso de duas formas: - Nome Literal: o valor do literal é relacionado a um nome estabelecido pelo programador e declarado dentro das diretivas. - Valor: o valor do literal é declarado diretamente na forma numérica dentro da própria instrução. EXEMPLOS: - Nome Literal * Relacionar a constante a um nome e declarar o valor na área de diretivas: CT_TEMPO EQU .125 ; CONSTANTE DE TEMPO * Valor contido no registro W antes da execução da instrução: 0 0 0 0 0 0 0 0 W * Instrução MOVLW CT_TEMPO ; MOVER LITERAL PARA REG. W * Valor contido no registro W depois da execução da instrução: 0 1 1 1 1 1 0 1 W - Valor em binário * Valor contido no registro W antes da execução da instrução: 0 0 0 0 0 0 0 0 W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 42/103 * Instrução MOVLW B'10000011' ; MOVER LITERAL PARA REG. W * Valor contido no registro W depois da execução da instrução: 1 0 0 0 0 0 1 1 W - Valor em decimal * Valor contido no registro W antes da execução da instrução: 0 0 0 0 0 0 0 0 W * Instrução MOVLW .123 ; MOVER LITERAL PARA REG. W * Valor contido no registro W depois da execução da instrução: 0 1 1 1 1 0 1 1 W - Valor em hexadecimal * Valor contido no registro W antes da execução da instrução: 0 0 0 0 0 0 0 0 W * Instrução MOVLW 0x4F ; MOVER LITERAL PARA REG. W * Valor contido no registro W depois da execução da instrução: 0 1 0 0 1 1 1 1 W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 43/103 MOVF MNEMÔNICO MOVF INSTRUÇÃO Move F SINTAXE MOVF DESCRIÇÃO Mover o valor contido no registro F identificado em [registro origem] para o registro identificado em [ registro destino ] [ registro origem ], [ registro destino ] CICLO MÁQUINA 1 STATUS Z (ver observação) Esta instrução é usada para copiar o valor contido no registro F [registro origem] para o registro F identificado em [registro destino] da seguinte maneira: - se o registro de origem for o registro W, o registro de destino será sempre o registro W. - se o registro de origem for o registro F, o registro de destino será o registro F ou o registro W. - não é possível mover do registro de origem W para o registro de destino F. Observação: se o valor contido no registro de origem F for nulo (todos os bits contém o valor ‘0’), a execução da instrução MOVF muda o estado do bit Z do registro STATUS de 0 → 1, indicando que o resultado da operação foi nulo. O programador pode utilizar este evento para testar se o registro de origem F é nulo ou não. EXEMPLO: - Mover valor do registro de origem W para o registro de destino W * Valor contido no registro W antes da execução da instrução: 1 0 1 0 1 0 0 1 W * Instrução MOVF W,W ; MOVER O VALOR CONTIDO NO REG. W PARA O REG. W * Valor contido no registro W depois da execução da instrução: 1 0 1 0 1 0 0 1 W - Mover valor do registro de origem F (INTCON) para o registro de destino F (INTCON). * Valor contido no registro INTCON antes da execução da instrução: 1 0 1 0 1 1 1 1 INTCON * Instrução MOVF INTCON,F ; MOVER O VALOR CONTIDO NO REG. INTCON PARA ; O REG. INTCON Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 44/103 * Valor contido no registro INTCON depois da execução da instrução: 1 0 1 0 1 0 0 1 INTCON - Mover valor do registro de origem F (INTCON) para o registro de destino W * Valores contidos nos registros INTCON e W antes da execução da instrução: 1 0 1 0 1 0 0 1 INTCON 0 0 0 0 0 0 0 0 W * Instrução MOVF INTCON,W ; MOVER O VALOR CONTIDO NO REG. INTCON PARA ; O REG. W * Valores contidos nos registros INTCON e W depois da execução da instrução: 1 0 1 0 1 0 0 1 INTCON 1 0 1 0 1 0 0 1 W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 45/103 MOVWF MNEMÔNICO MOVFW INSTRUÇÃO Move W to F SINTAXE MOVWF DESCRIÇÃO Mover o valor contido no registro W para o registro F identificado em [ nome registro ] [ nome registro ] CICLO MÁQUINA 1 STATUS Nenhum Esta instrução é usada para copiar o valor contido no registro W para o registro F identificado em [ nome registro ] EXEMPLO: Vamos realizar o exemplo com uma sequencia de instruções bastante comum nos programas, colocando o valor de um literal no registro W e, na sequencia, colocar o valor contido no registro W no registro INTCON (já existente na memória RAM – área SFR). A sequencia de instruções fica como abaixo: MOVLW MOVWF B'10100000' INTCON ; GIE HABILITADO (INTERRUPÇÕES LIGADAS) ; INTERRUPÇÃO TMR0 HABILITADA Os valores dentro dos registros modificam-se de acordo com a sequencia de instruções: * Valores contidos nos registros W e INTCON antes da execução da instrução: 0 0 0 0 0 0 0 0 W 0 0 0 0 0 0 0 0 INTCON * Instrução MOVLW B'10100000' * Valores contidos nos registros W e INTCON depois da execução da instrução MOVLW: 1 0 1 0 0 0 0 0 W 0 0 0 0 0 0 0 0 INTCON * Instrução MOVWF INTCON ; GIE HABILITADO (INTERRUPÇÕES LIGADAS) ; INTERRUPÇÃO TMR0 HABILITADA * Valores contidos nos registros W e INTCON depois da execução da instrução MOVWF: 1 0 1 0 0 0 0 0 W 1 0 1 0 0 0 0 0 INTCON Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 46/103 NOP MNEMÔNICO NOP INSTRUÇÃO No Operation SINTAXE NOP DESCRIÇÃO Não executa nenhuma operação CICLO MÁQUINA 1 STATUS Nenhum Esta instrução não executa nenhuma operação específica em um código ou programa. A execução da instrução NOP consome 1 CM (um ciclo de máquina) que pode ser empregado para produzir um atraso equivalente. EXEMPLO: Vamos considerar o código abaixo: INICIO BTFSC GOTO BSF NOP NOP NOP GOTO BOTAO DESLIGA_LED LED INICIO ; VERIFICA O ESTADO DO BIT QUE REPRESENTA BOTAO ; BOTAO = 0 > VAI PARA DESLIGA_LED ; BOTAO = 1 > LIGA LED ; ; AGUARDA 3 CM ANTES DA INSTRUÇÃO GOTO ; ; RETORNA PARA INICIO Entre a instrução BSF e a instrução GOTO existem tres instruções NOP, isto é, o programa consome 3 CM sem realizar nenhuma operação. O número de vezes que a instrução NOP pode ser utilizada (sem sequencia ou não) não tem limite. Depende exclusivamente da necessidade de uso no programa. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 47/103 RETFIE MNEMÔNICO RETFIE INSTRUÇÃO Return From Interrupt Enable SINTAXE RETFIE DESCRIÇÃO Retorno de uma Interrupção CICLO MÁQUINA 2 STATUS Nenhum Esta instrução é empregada somente para retorno de interrupção (qualquer tipo). Para melhor visualização da aplicação da instrução, vamos considerar o código abaixo como uma sequencia padrão para tratamento de interrupções: ORG ┌ │• │• │• └ 0X04 ┌ │• │• │• └ GOTO SAI_INT ┌ │• │• │• └ RETFIE ; ENDEREÇO DO VETOR DE INTERRUPÇÃO ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA ; PARA PRESERVAR CONTEXTO (REGISTROS ; IMPORTANTES) ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA ; PARA DETERMINAR QUAL INTERRUPÇÃO ; FOI ATIVADA PARA TRATAMENTO SAI_INT ; VAI PARA ROTINA DE SAÍDA INTERRUPÇÃO ; QUANDO O TRATAMENTO TERMINAR ; SEQUENCIA DE INSTRUÇÕES DO PROGRAMA ; PARA RECUPERAR CONTEXTO (REGISTROS ; IMPORTANTES SALVOS) ; SAÍDA DO TRATAMENTO DE INTERRUPÇÃO Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 48/103 RETURN MNEMÔNICO RETURN INSTRUÇÃO Return SINTAXE RETURN DESCRIÇÃO Retorna de uma sub-rotina (sequencia de instruções pré-definida) executada completamente. CICLO MÁQUINA 2 STATUS Nenhum Esta instrução retorna ao programa após a execução das instruções de uma sub-rotina iniciada pela instrução CALL. EXEMPLO: CALL SINALIZACAO ┐ ; DESVIA PARA SUB-ROTINA DE “SINALIZACAO” ┌──> ┌ │ │ │• │ ; SEQUENCIA DE INSTRUÇÕES DE EXECUÇÃO │ │• │ ; NORMAL DO PROGRAMA │ │• │ │ └ │ │ │ │ (BUSCA ENDEREÇO SINALIZACAO) │ ┌────────────────────┘ │ SINALIZACAO │ ┌ │ │• ; SEQUENCIA DE INSTRUÇÕES DE EXECUÇÃO │ │• ; DA SUB-ROTINA “SINALIZACAO” │ │• │ └ │ RETURN┐ ; SAÍDA DA SUB-ROTINA “SINALIZACAO” │ │ │ │ │ (BUSCA ENDEREÇO DE RETORNO - linha seguinte à da instrução CALL) └──────────┘ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 49/103 SWAPF MNEMÔNICO SWAPF INSTRUÇÃO Swap Nibbles in F SINTAXE SWAPF DESCRIÇÃO Troca de posição o Nibble Alto (NIB_HI) com o Nibble Baixo (NIB_LO) do registro F identificado em [registro origem] e coloca o resultado da operação no registro identificado em [ registro destino ] [ registro origem ], [ registro destino ] CICLO MÁQUINA 1 STATUS Nenhum Esta instrução troca de posição os quatro bits menos significativos (Nibble Baixo (NIB_LO)) com os quatro bits mais significativos (Nibble Alto (NIB_HI)) do registro. 0 0 0 0 NIBBLE ALTO (NIB_HI) 1 1 1 1 Registro NIBBLE BAIXO (NIB_LO) O resultado da operação pode ser direcionado para um registro de destino da seguinte maneira: - se o registro de origem for o registro W, o registro de destino será sempre o registro W. - se o registro de origem for o registro F, o registro de destino será o registro F ou o registro W. Observação: quando a instrução for empregada no registro de origem F e o resultado da operação for colocado no registro de destino W, a instrução troca o Nibble Alto (NIB_HI) com o Nibble Baixo (NIB_LO) somente no registro de destino W, preservando a posição original no registro de origem F. EXEMPLO: - Trocar a posição no registro de origem W e colocar o resultado no registro de destino W * Valor contido no registro W antes da execução da instrução: 0 0 0 0 1 1 1 1 W * Instrução SWAPF W,W ; TROCA O NIB_HI COM O NIB_LO DO REG. W ; E COLOCA O RESULTADO DA OPERAÇÃO ; NO REG. W * Valor contido no registro W depois da execução da instrução: 1 1 1 1 0 0 0 0 W - Trocar a posição do registro de origem F (INTCON) e colocar o resultado no registro de destino F (INTCON). * Valor contido no registro INTCON antes da execução da instrução: 0 0 0 0 1 1 1 1 INTCON Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 50/103 * Instrução SWAPF INTCON,F ; TROCA O NIB_HI COM O NIB_LO DO REG. INTCON ; E COLOCA O RESULTADO DA OPERAÇÃO ; NO REG. INTCON * Valor contido no registro INTCON depois da execução da instrução: 1 1 1 1 0 0 0 0 INTCON - Trocar a posição no registro de origem F (INTCON) e colocar o resultado no registro de destino W * Valores contidos nos registros INTCON e W antes da execução da instrução: 0 0 0 0 1 1 1 1 INTCON 0 0 0 0 0 0 0 0 W * Instrução SWAPF INTCON,W ; TROCA O NIB_HI COM O NIB_LO DO REG. INTCON ; E COLOCA O RESULTADO DA OPERAÇÃO ; NO REG. W * Valores contidos nos registros INTCON e W depois da execução da instrução: 0 0 0 0 1 1 1 1 INTCON 1 1 1 1 0 0 0 0 W Observação: notar que a instrução foi empregada no registro de origem INTCON e o resultado da operação foi colocado no registro de destino W, enquanto a troca do Nibble Alto (NIB_HI) com o Nibble Baixo (NIB_LO) ocorreu somente no registro de destino W, preservando a posição original no registro de origem INTCON. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 51/103 IORWF MNEMÔNICO IORWF INSTRUÇÃO W logic OR with F SINTAXE IORWF DESCRIÇÃO Realiza a operação lógica OR (ou) entre o valor contido no registro W e o valor contido no registro F identificado em [registro origem], e coloca o resultado da operação no registro identificado em [ registro destino ] [ registro origem ], [ registro destino ] CICLO MÁQUINA 1 STATUS Z Esta instrução realiza a operação lógica OR (ou), bit a bit, entre o valor contido no registro W e o valor contido no registro F de acordo com a expressão booleana: - registro de destino W → - registro de destino F → W =W + F F =W + F A tabela verdade da lógica OR (ou) é representada abaixo para todas as possíveis combinações de W e F: W F 0 0 0 0 1 1 1 0 1 1 1 1 A Unidade Lógica do processador realiza a operação em cada bit dos registros individualmente, colocando o resultado da operação no bit correspondente do registro de destino (W ou F), onde o sinal “+” representa a operação lógica “ou”: Bit W F 0 0 + 0 = 0 1 0 + 1 = 1 2 1 + 0 = 1 3 1 + 1 = 1 4 0 + 0 = 0 5 0 + 1 = 1 6 1 + 0 = 1 7 1 + 1 = 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 52/103 EXEMPLO: - Realizar a lógica OR (ou) entre o registro W e o registro CONT e colocar o resultado no registro W * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 0 1 0 0 0 CONT * Instrução IORWF CONT,W ; LÓGICA OR ENTRE O REG. W E O REG. CONT COLOCAR O ; RESULTADO DA OPERAÇÃO NO REG. W 0 1 1 1 0 0 0 1 W + + + + + + + + (OR) + 0 1 1 0 1 0 0 0 CONT 0 1 1 1 1 0 0 1 W Atenção: o sinal “+” representa a operação lógica “ou”. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 1 0 0 1 W 0 1 1 0 1 0 0 0 CONT Observação: notar que o valor contido no registro W sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). - Realizar a lógica OR (ou) entre o registro W e o registro CONT e colocar o resultado no registro CONT * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 0 1 0 0 0 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 53/103 * Instrução IORWF CONT,F ; LÓGICA OR ENTRE O REG. W E O REG. CONT - COLOCAR ; O RESULTADO DA OPERAÇÃO NO REG. CONT 0 1 1 1 0 0 0 1 W + + + + + + + + (OR) + 0 1 1 0 1 0 0 0 CONT 0 1 1 1 1 0 0 1 CONT Atenção: o sinal “+” representa a operação lógica “ou”. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 1 1 0 0 1 CONT Observação: notar que o valor contido no registro CONT sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 54/103 ANDWF MNEMÔNICO ANDWF INSTRUÇÃO W logic AND with F SINTAXE ANDWF DESCRIÇÃO Realiza a operação lógica AND (e) entre o valor contido no registro W e o valor contido no registro F identificado em [registro origem], e coloca o resultado da operação no registro identificado em [ registro destino ] [ registro origem ], [ registro destino ] CICLO MÁQUINA 1 STATUS Z Esta instrução realiza a operação lógica AND (e), bit a bit, entre o valor contido no registro W e o valor contido no registro F de acordo com a expressão booleana: - registro de destino W → - registro de destino F → W =W •F F =W •F A tabela verdade da lógica AND (e) é representada abaixo para todas as possíveis combinações de W e F: W F 0 0 0 0 1 0 1 0 0 1 1 1 A Unidade Lógica do processador realiza a operação em cada bit dos registros individualmente, colocando o resultado da operação no bit correspondente do registro de destino (W ou F), onde o sinal “ • ” representa a operação lógica “e”: Bit W F 0 0 • 0 = 0 1 0 • 1 = 0 2 1 • 0 = 0 3 1 • 1 = 1 4 0 • 0 = 0 5 0 • 1 = 0 6 1 • 0 = 0 7 1 • 1 = 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 55/103 EXEMPLO: - Realizar a lógica AND (e) entre o registro W e o registro CONT e colocar o resultado no registro W * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 0 1 0 0 0 CONT * Instrução ANDWF CONT,W ; LÓGICA AND ENTRE O REG. W E O REG. CONT ; COLOCAR O RESULTADO DA OPERAÇÃO NO REG W 0 1 1 1 0 0 0 1 W • • • • • • • • 0 1 1 0 1 0 0 0 CONT 0 1 1 0 0 0 0 0 W (AND) • Atenção: o sinal “ • ” representa a operação lógica “e”. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 0 0 0 0 0 W 0 1 1 0 1 0 0 0 CONT Observação: notar que o valor contido no registro W sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). - Realizar a lógica AND (e) entre o registro W e o registro CONT e colocar o resultado no registro CONT * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 0 1 0 0 0 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 56/103 * Instrução ANDWF CONT,F ; LÓGICA AND ENTRE O REG. W E O REG. CONT ; COLOCAR O RESULTADO DA OPERAÇÃO NO REG W 0 1 1 1 0 0 0 1 W • • • • • • • • 0 1 1 0 1 0 0 0 CONT 0 1 1 0 0 0 0 0 CONT (AND) • Atenção: o sinal “ • ” representa a operação lógica “e”. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 0 0 0 0 0 CONT Observação: notar que o valor contido no registro CONT sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 57/103 XORWF MNEMÔNICO XORWF INSTRUÇÃO W logic EXCLUSIVE-OR with F SINTAXE XORWF DESCRIÇÃO Realiza a operação lógica EXCLUSIVE-OR (ou-exclusivo) entre o valor contido no registro W e o valor contido no registro F identificado em [registro origem], e coloca o resultado da operação no registro identificado em [ registro destino ] [ registro origem ], [ registro destino ] CICLO MÁQUINA 1 STATUS Z Esta instrução realiza a operação lógica AND (e), bit a bit, entre o valor contido no registro W e o valor contido no registro F de acordo com a expressão booleana: - registro de destino W → - registro de destino F → W =W ⊕ F F =W ⊕ F A tabela verdade da lógica EXCLUSIVE-OR (ou-exclusivo) é representada abaixo para todas as possíveis combinações de W e F: W F 0 0 0 0 1 1 1 0 1 1 1 0 A Unidade Lógica do processador realiza a operação em cada bit dos registros individualmente, colocando o resultado da operação no bit correspondente do registro de destino (W ou F), onde o sinal “ ⊕ ” representa a operação lógica “exclusive-or”: Bit W F 0 0 ⊕ 0 = 0 1 0 ⊕ 1 = 1 2 1 ⊕ 0 = 1 3 1 ⊕ 1 = 1 4 0 ⊕ 0 = 0 5 0 ⊕ 1 = 1 6 1 ⊕ 0 = 1 7 1 ⊕ 1 = 0 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 58/103 EXEMPLO: - Realizar a lógica EXCLUSIVE-OR (ou-exclusivo) entre o registro W e o registro CONT e colocar o resultado no registro W * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 0 1 0 0 0 CONT * Instrução XORWF CONT,W ; LÓGICA EXCLUSIVE-OR ENTRE O REG. W E O REG. CONT ; COLOCAR O RESULTADO DA OPERAÇÃO NO REG W 0 1 1 1 0 0 0 1 W ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ 0 1 1 0 1 0 0 0 CONT 0 0 0 1 1 0 0 1 W Atenção: o sinal “ ⊕ ” representa a operação lógica “ou-exclusivo”. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 0 0 1 1 0 0 1 W 0 1 1 0 1 0 0 0 CONT Observação: notar que o valor contido no registro W sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). - Realizar a lógica EXCLUSIVE-OR (ou-exclusivo) entre o registro W e o registro CONT e colocar o resultado no registro CONT * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 0 1 0 0 0 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 59/103 * Instrução XORWF CONT,F ; LÓGICA EXCLUSIVE-OR ENTRE O REG. W E O REG. CONT ; COLOCAR O RESULTADO DA OPERAÇÃO NO REG W 0 1 1 1 0 0 0 1 W ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ 0 1 1 0 1 0 0 0 CONT 0 0 0 1 1 0 0 1 CONT Atenção: o sinal “ ⊕ ” representa a operação lógica “ou-exclusivo”. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 W 0 0 0 1 1 0 0 1 CONT Observação: notar que o valor contido no registro CONT sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 60/103 ANDLW MNEMÔNICO ANDLW INSTRUÇÃO Literal logic AND with W SINTAXE ANDLW DESCRIÇÃO Realiza a operação lógica AND (e) entre o valor do literal identificado em [ nome literal ] e o valor contido no registro W; o resultado da operação será colocado no registro W. [ nome literal ] CICLO MÁQUINA 1 STATUS Z Esta instrução realiza a operação lógica AND (e), bit a bit, entre o valor de um número ou constante (literal) e o valor contido no registro W de acordo com a expressão booleana: W = Literal • W O valor do literal deve ser relacionado a um nome estabelecido pelo programador e declarado dentro das diretivas. A tabela verdade da lógica AND (e) é representada abaixo para todas as possíveis combinações do literal e W: Literal W 0 0 0 0 1 0 1 0 0 1 1 1 A Unidade Lógica do processador realiza a operação em cada bit dos registros individualmente, colocando o resultado da operação no bit correspondente do registro W, onde o sinal “ • ” representa a operação lógica “e”: Bit Literal W 0 0 • 0 = 0 1 0 • 1 = 0 2 1 • 0 = 0 3 1 • 1 = 1 4 0 • 0 = 0 5 0 • 1 = 0 6 1 • 0 = 0 7 1 • 1 = 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 61/103 EXEMPLO: - Realizar a lógica AND (e) entre o literal SOMA_REF e o registro W e colocar o resultado no registro W * Relacionar o literal (ou constante) a um nome e declarar o valor na área de diretivas: SOMA_REF EQU .125 ; VALOR DE REFERENCIA DA SOMA * Valores contidos nos registros W e SOMA_REF antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 1 1 1 0 1 SOMA_REF * Instrução ANDLW SOMA_REF,W ; LÓGICA AND ENTRE O LITERAL SOMA_REF E O REG. W ; COLOCAR O RESULTADO DA OPERAÇÃO NO REG W 0 1 1 1 0 0 0 1 W • • • • • • • • (AND) 0 1 1 1 1 1 0 1 SOMA_REF 0 1 1 1 0 0 0 1 W • Atenção: o sinal “ • ” representa a operação lógica “e”. * Valores contidos nos registros W e SOMA_REF depois da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 1 1 1 0 1 SOMA_REF Observação: notar que o valor contido no registro W sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro SOMA_REF permanece inalterado (o valor do literal não sofre alteração). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 62/103 IORLW MNEMÔNICO IORLW INSTRUÇÃO Literal logic OR with W SINTAXE IORLW DESCRIÇÃO Realiza a operação lógica OR (ou) entre o valor do literal identificado em [ nome literal ] e o valor contido no registro W; o resultado da operação será colocado no registro W. [ nome literal ] CICLO MÁQUINA 1 STATUS Z Esta instrução realiza a operação lógica OR (ou), bit a bit, entre o valor de um número ou constante (literal) e o valor contido no registro W de acordo com a expressão booleana: W = Literal + W O valor do literal deve ser relacionado a um nome estabelecido pelo programador e declarado dentro das diretivas. A tabela verdade da lógica OR (ou) é representada abaixo para todas as possíveis combinações de W e F: W F 0 0 0 0 1 1 1 0 1 1 1 1 A Unidade Lógica do processador realiza a operação em cada bit dos registros individualmente, colocando o resultado da operação no bit correspondente do registro W, onde o sinal “+” representa a operação lógica “ou”: Bit Literal W 0 0 + 0 = 0 1 0 + 1 = 1 2 1 + 0 = 1 3 1 + 1 = 1 4 0 + 0 = 0 5 0 + 1 = 1 6 1 + 0 = 1 7 1 + 1 = 1 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 63/103 EXEMPLO: - Realizar a lógica OR (ou) entre o literal SOMA_REF e o registro W e colocar o resultado no registro W * Relacionar o literal (ou constante) a um nome e declarar o valor na área de diretivas: SOMA_REF EQU .125 ; VALOR DE REFERENCIA DA SOMA * Valores contidos nos registros W e SOMA_REF antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 1 1 1 0 1 SOMA_REF IORLWSOMA_REF,W ; LÓGICA OR ENTRE O LITERAL SOMA_REF E O REG. W ; COLOCAR O RESULTADO DA OPERAÇÃO NO REG. W 0 1 1 1 0 0 0 1 W + + + + + + + + (OR) + 0 1 1 1 1 1 0 1 SOMA_REF 0 1 1 1 1 1 0 1 W Atenção: o sinal “+” representa a operação lógica “ou”. * Valores contidos nos registros W e SOMA_REF depois da execução da instrução: 0 1 1 1 1 1 0 1 W 0 1 1 1 1 1 0 1 SOMA_REF Observação: notar que o valor contido no registro W sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro SOMA_REF permanece inalterado (o valor do literal não sofre alteração). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 64/103 XORLW MNEMÔNICO XORLW INSTRUÇÃO Literal logic EXCLUSIVE-OR with W SINTAXE XORLW DESCRIÇÃO Realiza a operação lógica EXCLUSIVE-OR (ou-exclusivo) entre o valor do literal identificado em [ nome literal ] e o valor contido no registro W; e coloca o resultado da operação no registro W. [ nome literal ] CICLO MÁQUINA 1 STATUS Z Esta instrução realiza a operação lógica AND (e), bit a bit, entre o valor de um número ou constante (literal) e o valor contido no registro W de acordo com a expressão booleana: W = Literal ⊕ W A tabela verdade da lógica EXCLUSIVE-OR (ou-exclusivo) é representada abaixo para todas as possíveis combinações de W e F: W F 0 0 0 0 1 1 1 0 1 1 1 0 A Unidade Lógica do processador realiza a operação em cada bit dos registros individualmente, colocando o resultado da operação no bit correspondente do registro de destino (W ou F), onde o sinal “ ⊕ ” representa a operação lógica “exclusive-or”: Bit Literal F 0 0 ⊕ 0 = 0 1 0 ⊕ 1 = 1 2 1 ⊕ 0 = 1 3 1 ⊕ 1 = 1 4 0 ⊕ 0 = 0 5 0 ⊕ 1 = 1 6 1 ⊕ 0 = 1 7 1 ⊕ 1 = 0 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 65/103 EXEMPLO: - Realizar a lógica EXCLUSIVE-OR (ou-exclusivo) entre o literal SOMA_REF e o registro W e colocar o resultado no registro W * Relacionar o literal (ou constante) a um nome e declarar o valor na área de diretivas: SOMA_REF EQU .125 ; VALOR DE REFERENCIA DA SOMA * Valores contidos nos registros W e SOMA_REF antes da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 1 1 1 0 1 SOMA_REF * Instrução XORLW SOMA_REF,W 0 ; LÓGICA EXCLUSIVE-OR ENTRE O LITERAL SOMA_REF ; E O O REG. W - COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG W 1 1 1 0 0 0 1 W ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ ⊕ 0 1 1 1 1 1 0 1 SOMA_REF 0 0 0 1 1 1 0 0 W Atenção: o sinal “ ⊕ ” representa a operação lógica “ou-exclusivo”. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 W 0 1 1 1 1 1 0 1 SOMA_REF Observação: notar que o valor contido no registro W sofreu modificação (apresenta o resultado da operação após a execução da instrução), enquanto o registro SOMA_REF permanece inalterado (o valor do literal não sofre alteração). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 66/103 ADDWF MNEMÔNICO ADDWF INSTRUÇÃO Add W to F SINTAXE ADDWF DESCRIÇÃO Soma o valor contido no registro W com o valor contido no registro F identificado em [registro origem], e coloca o resultado da operação no registro identificado em [ registro destino ] [ registro origem ], [ registro destino ] CICLO MÁQUINA 1 STATUS C, Z Esta instrução realiza a operação aritmética da adição, bit a bit, entre o valor contido no registro W e o valor contido no registro F de acordo com a expressão algébrica: - registro de destino W → - registro de destino F → W =W + F F =W + F O processo aritmético de soma com números binários segue o procedimento: 0 1 + 0 + 1 + + 0 0 1 1 0 1 1 10 A operação aritmética de adição deve atender aos limites impostos pelo tamanho do registro (8 bits), isto é, o resultado final da operação deve ser necessáriamente menor ou igual a 255. Com operações onde o valor do resultado é maior que 255, a sinalização é feita através do bit (flag) C no registro STATUS, que muda de 0 (zero) para 1 (um) indicando a ocorrencia de resultado da operação com valor maior que 255 (overflow): ┌───> flag sinalização resultado operação >255 │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB Observação: 1. o valor “x” representa valor irrelevante (não influencia o resultado). 2. o retorno a 0 (zero) do flag é feito automaticamente pela Unidade Lógica. 3. uma vez indicada a ocorrencia de “overflow” (excesso) da operação, o flag C pode permanecer com valor 1 (um) por vários ciclos de máquina - a Unidade Lógica retorna o flag a 0 (zero) no ciclo imediatamente anterior a uma nova operação aritmética. O programador deve estabelecer procedimentos para determinar a ocorrencia de “overflow” (excesso) nas operações de adição previstas no código_fonte. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 67/103 EXEMPLO: W =W + F → - Registro de destino W - Somar o valor contido no registro W com o valor contido no registro CONT e colocar o resultado no registro W a) Resultado da operação menor ou igual a 255 * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 1 1 0 1 0 0 0 104 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Instrução ADDWF CONT,W ; SOMAR O VALOR DO REG. W COM O VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. W 0 1 1 1 0 0 0 1 113 W + + + + + + + + + (SOMA) + 0 1 1 0 1 0 0 0 104 CONT 1 1 0 1 1 0 0 1 217 W Atenção: o sinal “+” representa a operação aritmética da adição. * Valores contidos nos registros W e CONT depois da execução da instrução: 1 1 0 1 1 0 0 1 217 W 0 1 1 0 1 0 0 0 104 CONT Observação: notar que o valor contido no registro W apresenta o resultado da operação após a execução da instrução, enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 68/103 * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação foi um número menor que 255 logo, o flag de sinalização permanece igual a 0 (zero). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB b) Resultado da operação maior que 255 (uso do flag CARRY do registro STATUS) * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 0 1 0 0 0 1 113 W 1 0 0 1 0 0 0 1 145 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Instrução ADDWF CONT,W ; SOMAR O VALOR DO REG. W COM O VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. W 0 1 1 1 0 0 0 1 113 W + + + + + + + + + (SOMA) + 1 0 0 1 0 0 0 1 145 CONT 0 0 0 0 0 0 1 0 2 W Atenção: o sinal “+” representa a operação aritmética da adição. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 0 0 0 0 0 1 0 2 W 1 0 0 1 0 0 0 1 145 CONT Observação: notar que o valor contido no registro W apresenta o resultado da operação após a execução da instrução, enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 69/103 * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de adição foi um número maior que 255 logo, o flag de sinalização muda de estado, passando a 1 (um). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 1 STATUS MSB LSB Vamos olhar o resultado desta operação. Fizemos uma operação de adição entre dois valores (113 e 145) que deve apresentar o resultado esperado de 258 (maior que 255): 113 + 145 258 A resposta do flag C no registro STATUS aconteceu da forma esperada, isto é, mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor maior que 255: IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 1 MSB STATUS LSB Porém, o resultado apresentado no registro W não corresponde ao valor esperado (258), mas apresentou o valor 2: 0 0 0 0 0 0 1 0 2 W O valor 258 não cabe em 8 bits. Para representá-lo são necessários pelo menos 9 bits e, como pode ser observado, os 8 bits menos significativos representam o valor 2. ┌───> nono bit - inexistente - peso 29 = 256 │ 1 0 0 0 0 0 0 1 0 258 W Como toda a estrutura do microcontrolador é baseada em 8 bits, o flag C do registro STATUS representa o nono bit necessário para a composição de valores maiores do que 255. ┌───> flag C do registro STATUS - representa o nono bit com peso 29 = 256 │ 1 0 0 0 0 0 0 1 0 258 CONT └┬┘ └─────────┬─────────┘ │ │ │ └────────> 2 │ + └─────────────────────> 256 ─ ── 258 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 70/103 F =W + F → - Registro de destino F - Somar o valor contido no registro W com o valor contido no registro CONT e colocar o resultado no registro CONT a) Resultado da operação menor ou igual a 255 * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 1 1 0 1 0 0 0 104 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Instrução ADDWF CONT,F ; SOMAR O VALOR DO REG. W COM O VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. CONT 0 1 1 1 0 0 0 1 113 W + + + + + + + + + (SOMA) + 0 1 1 0 1 0 0 0 104 CONT 1 1 0 1 1 0 0 1 217 CONT Atenção: o sinal “+” representa a operação aritmética da adição. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 113 W 1 1 0 1 1 0 0 1 217 CONT Observação: notar que o valor contido no registro CONT apresenta o resultado da operação após a execução da instrução, enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 71/103 * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação foi um número menor que 255 logo, o flag de sinalização permanece igual a 0 (zero). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB b) Resultado da operação maior que 255 (uso do flag CARRY do registro STATUS) * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 0 1 0 0 0 1 113 W 1 0 0 1 0 0 0 1 145 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Instrução ADDWF CONT,F ; SOMAR O VALOR DO REG. W COM O VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. CONT 0 1 1 1 0 0 0 1 113 W + + + + + + + + + (SOMA) + 1 0 0 1 0 0 0 1 145 CONT 0 0 0 0 0 0 1 0 2 CONT Atenção: o sinal “+” representa a operação aritmética da adição. * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 0 0 0 0 0 1 0 2 CONT Observação: notar que o valor contido no registro CONT apresenta o resultado da operação após a execução da instrução, enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 72/103 * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de adição foi um número maior que 255 logo, o flag de sinalização muda de estado, passando a 1 (um). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 1 STATUS MSB LSB Vamos olhar o resultado desta operação. Fizemos uma operação de adição entre dois valores (113 e 145) que deve apresentar o resultado esperado de 258 (maior que 255): 113 + 145 258 A resposta do flag C no registro STATUS aconteceu da forma esperada, isto é, mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor maior que 255: IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 1 MSB STATUS LSB Porém, o resultado apresentado no registro CONT não corresponde ao valor esperado (258), mas apresentou o valor 2: 0 0 0 0 0 0 1 0 2 CONT O valor 258 não cabe em 8 bits. Para representá-lo são necessários pelo menos 9 bits e, como pode ser observado, os 8 bits menos significativos representam o valor 2. ┌───> nono bit - inexistente - peso 29 = 256 │ 1 0 0 0 0 0 0 1 0 258 CONT └────────┬─────────┘ │ └────────────> 2 - 8 bits menos significativos Como toda a estrutura do microcontrolador é baseada em 8 bits, o flag C do registro STATUS “representa” o nono bit necessário para a composição de valores maiores do que 255. ┌───> flag C do registro STATUS - representa o nono bit com peso 29 = 256 │ 1 0 0 0 0 0 0 1 0 258 CONT └┬┘ └─────────┬─────────┘ │ │ │ └────────> 2 │ + └─────────────────────> 256 ─ ── 258 Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 73/103 O programador deve prever técnicas de avaliação dos resultados da operação dentro do código_fonte para interpretar os resultados obtidos nas operações aritméticas realizadas e, se necessário, acrescentar um novo registro para representar valores com mais de 8 bits. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 74/103 ADDLW MNEMÔNICO ADDLW INSTRUÇÃO Add Literal to F SINTAXE ADDLW DESCRIÇÃO Soma o valor contido no registro W com o valor do literal identificado em [ nome literal] - o resultado da operação é sempre colocado no registro W. [ nome literal ] CICLO MÁQUINA 1 STATUS C, DC, Z Esta instrução realiza a operação aritmética da adição, bit a bit, entre e o valor de um número ou constante (literal) e o valor contido no registro W de acordo com a expressão algébrica: W = Literal + W O processo aritmético de soma com números binários segue o procedimento: 0 1 + 0 + 1 + + 0 0 1 1 0 1 1 10 A operação aritmética de adição deve atender aos limites impostos pelo tamanho do registro (8 bits), isto é, o resultado final da operação deve ser necessáriamente menor ou igual a 255. Com operações onde o valor do resultado é maior que 255, a sinalização é feita através do bit (flag) C no registro STATUS, que muda de 0 (zero) para 1 (um) indicando a ocorrencia de resultado da operação com valor maior que 255 (overflow): ┌───> flag sinalização resultado operação >255 │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB Observação: 1. o valor “x” representa valor irrelevante (não influencia o resultado). 2. o retorno a 0 (zero) do flag é feito automaticamente pela Unidade Lógica. 3. uma vez indicada a ocorrencia de “overflow” (excesso) da operação, o flag C pode permanecer com valor 1 (um) por vários ciclos de máquina - a Unidade Lógica retorna o flag a 0 (zero) no ciclo imediatamente anterior a uma nova operação aritmética. O programador deve estabelecer procedimentos para determinar a ocorrencia de “overflow” (excesso) nas operações de adição previstas no código_fonte. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 75/103 EXEMPLO: - Somar o valor contido no registro W com o valor do literal CTE_CONT - o resultado será sempre colocado no registro W a) Resultado da operação menor ou igual a 255 * Relacionar o literal (ou constante) a um nome e declarar o valor na área de diretivas: CTE_CONT EQU .104 ; VALOR DA CONSTANTE DE INÍCIO DO REG CONTADOR Atenção: valores numéricos declarados na área de diretivas são armazenados dentro da memória de programa - não é possível fazer alterações de valor através do código_fonte. * Valores contidos nos registros W e CTE_CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 1 1 0 1 0 0 0 104 CTE_CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Instrução ADDLW CTE_CONT ; SOMAR O VALOR DO REG. W COM O VALOR DO LITERAL ; CTE_CONT - O RESULTADO DA OPERAÇÃO SERÁ ; COLOCADO NO REG. W 0 1 1 1 0 0 0 1 113 W + + + + + + + + + (SOMA) + 0 1 1 0 1 0 0 0 104 CTE_CONT 1 1 0 1 1 0 0 1 217 W Atenção: o sinal “+” representa a operação aritmética da adição. * Valores contidos nos registros W e CTE_CONT depois da execução da instrução: 1 1 0 1 1 0 0 1 217 W 0 1 1 0 1 0 0 0 104 CTE_CONT Observação: notar que o valor contido no registro W apresenta o resultado da operação após a execução da instrução. O registro CTE_CONT permanece inalterado. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 76/103 * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação foi um número menor que 255 logo, o flag de sinalização permanece igual a 0 (zero). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x X x x 0 STATUS MSB LSB b) Resultado da operação maior que 255 (uso do flag CARRY do registro STATUS) * Relacionar o literal (ou constante) a um nome e declarar o valor na área de diretivas: CTE_CONT EQU .104 ; VALOR DA CONSTANTE DE INÍCIO DO REG CONTADOR Atenção: valores numéricos declarados na área de diretivas são armazenados dentro da memória de programa - não é possível fazer alterações de valor através do código_fonte. * Valores contidos nos registros W e CTE_CONT antes da execução da instrução: 1 0 0 1 1 0 1 0 154 W 0 1 1 0 1 0 0 0 104 CTE_CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x X x x 0 STATUS MSB LSB * Instrução ADDLW CTE_CONT ; SOMAR O VALOR DO REG. W COM O VALOR DO LITERAL ; CTE_CONT - O RESULTADO DA OPERAÇÃO SERÁ ; COLOCADO NO REG. W 1 0 0 1 1 0 1 0 154 W + + + + + + + + + (SOMA) + 0 1 1 0 1 0 0 0 104 CTE_CONT 0 0 0 0 0 0 1 0 2 W Atenção: o sinal “+” representa a operação aritmética da adição. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 77/103 * Valores contidos nos registros W e CTE_CONT depois da execução da instrução: 0 0 0 0 0 0 1 0 2 W 0 1 1 0 1 0 0 0 104 CTE_CONT Observação: notar que o valor contido no registro W apresenta o resultado da operação após a execução da instrução. O registro CTE_CONT permanece inalterado. * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de adição foi um número maior que 255 logo, o flag de sinalização muda de estado, passando a 1 (um). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 1 STATUS MSB LSB Vamos olhar o resultado desta operação. Fizemos uma operação de adição entre dois valores (154 e 104) que deve apresentar o resultado esperado de 258 (maior que 255): 154 + 104 258 A resposta do flag C no registro STATUS aconteceu da forma esperada, isto é, mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor maior que 255: IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 1 MSB STATUS LSB Porém, o resultado apresentado no registro W não corresponde ao valor esperado (258), mas apresentou o valor 2: 0 0 0 0 0 0 1 0 2 W O valor 258 não cabe em 8 bits. Para representá-lo são necessários pelo menos 9 bits e, como pode ser observado, os 8 bits menos significativos representam o valor 2. ┌───> nono bit - inexistente - peso 29 = 256 │ 1 0 0 0 0 0 0 1 0 258 W Como a estrutura do microcontrolador é baseada em 8 bits, o flag C do registro STATUS representa o nono bit necessário para a composição de valores maiores do que 255. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 78/103 ┌───> flag C do registro STATUS - representa o nono bit com peso 29 = 256 │ 1 0 0 0 0 0 0 1 0 258 W └┬┘ └─────────┬─────────┘ │ │ │ └────────> 2 │ + └─────────────────────> 256 ─── 258 O programador deve prever técnicas de avaliação dos resultados da operação dentro do código_fonte para interpretar os resultados obtidos nas operações aritméticas realizadas e, se necessário, acrescentar um novo registro para representar valores com mais de 8 bits. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 79/103 SUBWF MNEMÔNICO SUBWF INSTRUÇÃO Subtract W from F SINTAXE SUBWF DESCRIÇÃO Subtrai o valor contido no registro W do valor contido no registro F identificado em [registro origem], e coloca o resultado da operação no registro identificado em [ registro destino ] [ registro origem ], [ registro destino ] CICLO MÁQUINA 1 STATUS C, DC, Z Esta instrução realiza a operação aritmética da subtração entre o valor contido no registro W (método do “complemento de 2” - two’s complement), e o valor contido no registro F de acordo com a expressão algébrica: - registro de destino W → - registro de destino F → W = F −W F = F −W O mecanismo utilizado pela Unidade Lógica e Aritmética para a execução da subtração realiza a adição do primeiro operador (F) ao “complemento de 2” do segundo operador (W). O uso do “complemento de 2” do segundo operador considera o fato do valor ser negativo, o que coloca a expressão algébrica efetivamente empregada no formato: - registro de destino W → - registro de destino F → W = F + (−W ) F = F + (−W ) Os resultados obtidos com a operação de subtração são sinalizados pelos flags C e Z do registro STATUS: ┌───────> flag sinalização resultado operação nulo │ │ ┌─> flag sinalização resultado operação positivo/negativo │ │ IRP RP1 RP0 /TO /PD Z DC C x x x x x 0 x 0 STATUS MSB LSB Observação: 1. o valor “x” representa valor irrelevante (não influencia o resultado). 2. o retorno a 0 (zero) do flag é feito automaticamente pela Unidade Lógica. 3. uma vez indicada a ocorrencia de “overflow” (excesso) da operação, os flags C e Z podem permanecer com valor 1 (um) por vários ciclos de máquina - a Unidade Lógica retorna os flags a 0 (zero) no ciclo imediatamente anterior a uma nova operação aritmética. Considerando que os valores de F e W são sempre positivos (F>0 e W>0), o resultado da operação de subtração depende da ordem de grandeza dos valores envolvidos nos registros F e W, de acordo com as possibilidades: - F > W → o resultado da operação é um número positivo - o valor representado pelo registro que contém o resultado está na forma direta e o flag C do registro STATUS é colocado no valor 1 (um). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 80/103 - F < W → o resultado da operação é um número negativo - o valor representado pelo registro que contém o resultado está na forma do “complemento de 2” e o flag C do registro STATUS é mantido no valor 0 (zero). - F = W → o resultado da operação é nulo - o valor representado pelo registro que contém o resultado é nulo (todos os bits do registro tem valor 0 - zero), o flag C do registro STATUS é mantido no valor 0 (zero) e o flag Z do registro STATUS é colocado no valor 1 (um), indicando que o resultado da operação foi nulo (o flag Z sinaliza resultado nulo da última operação). O programador deve prever técnicas de avaliação da operação dentro do código_fonte para interpretar os resultados obtidos. EXEMPLO: W = F −W → - Registro de destino W - Subtrair o valor contido no registro W do valor contido no registro CONT e colocar o resultado no registro W a) F > W → o resultado da operação é um número positivo - o valor representado pelo registro que contém o resultado (W) está na forma direta e o flag C do registro STATUS é colocado no valor 1 (um). * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 0 1 0 0 0 104 W 0 1 1 1 0 0 0 1 113 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Instrução SUBWF CONT,W ; SUBTRAIR O VALOR DO REG. W DO VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. W 0 1 1 1 0 0 0 1 113 CONT - - - - - - - - - 0 1 1 0 1 0 0 0 104 W 0 0 0 0 1 0 0 1 9 W (SUBTRAI) - Atenção: o sinal “-” representa a operação aritmética da subtração. Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 81/103 * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de subtração foi um número positivo (CONT > W) logo, o flag de sinalização muda de estado, passando a 1 (um). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x X x 1 STATUS MSB LSB * Valores contidos nos registros W e CONT depois da execução da instrução: 0 0 0 0 1 0 0 1 9 W 0 1 1 1 0 0 0 1 113 CONT Observação: notar que o valor contido no registro W apresenta o resultado da operação após a execução da instrução, enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). Se na operação aritmética de subtração o flag C do registro STATUS muda seu estado de 0 (zero) para 1 (um), o programador deve estabelecer o procedimento adequado no código_fonte para interpretar o resultado como: - o valor contido no registro CONT é maior que o valor contido no registro W (CONT > W) antes da execução da operação de subtração. - o valor contido no registro W após a execução da operação de subtração é um número positivo e representa o resultado final da operação. _______________________________________________________________________________________ Vamos observar como a Unidade Lógica e Aritmética realizou a operação de subtração quando F > W: A operação efetivamente realizada foi: W = CONT + (−W ) Isto é, a ULA realizou uma operação de adição de um valor positivo (CONT) com um valor negativo (W). Para representar um valor negativo na forma binária utiliza-se o “complemento de 2” (two’s complement) deste valor, calculado da seguinte forma: a) determina-se o “complemento de 1” (one’s complement) invertendo os valores de todos os bits contidos no registro: * Valor contido no registro W antes da execução do “complemento de 1”: 0 1 1 0 1 0 0 0 104 W * Valor contido no registro W após a execução do “complemento de 1”: 1 0 0 1 0 1 1 1 151 (COMP 1) W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 82/103 b) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 1 0 0 1 0 1 1 1 151 (COMP 1) W + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 1 0 0 1 1 0 0 0 152 (COMP 2) W Com o valor do “complemento de 2” do registro W ((COMP 2) W), a ULA realiza a operação de adição dos valores de CONT e (COMP 2) W: 0 1 1 1 0 0 0 1 113 CONT + + + + + + + + + (SOMA) + 1 0 0 1 1 0 0 0 152 0 0 0 0 1 0 0 1 9 (COMP 2) W W * Valor contido no registro W depois da execução da adição: 0 0 0 0 1 0 0 1 9 W O resultado da operação de adição foi um número maior que 255 logo, o flag C do registro STATUS muda de estado, passando a 1 (um). IRP RP1 RP0 /TO /PD Z x x x x x x ┌───> flag sinalização após a execução da instrução │ DC C x 1 STATUS MSB LSB Vamos olhar o resultado desta operação. A ULA fez uma operação de adição entre dois valores (113 e 152) que deve apresentar o resultado maior que 255 (no caso, 265): 113 + 152 265 A resposta do flag C no registro STATUS mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor maior que 255. IRP RP1 RP0 /TO /PD Z x x x x x x MSB DC C x 1 STATUS LSB Porém, o resultado apresentado no registro W não corresponde ao valor esperado da adição (265), mas apresentou o valor 9: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 83/103 0 0 0 0 1 0 0 1 9 W O valor 265 não cabe em 8 bits. Para representá-lo são necessários pelo menos 9 bits e, como pode ser observado, os 8 bits menos significativos representam o valor 9. ┌───> nono bit - inexistente - peso 29 = 256 │ 1 0 0 0 0 1 0 0 1 265 W Na estrutura de 8 bits, o flag C do registro STATUS representa o nono bit necessário para a composição de valores maiores do que 255. Consequentemente, o resultado apresentado pela ULA fica: ┌───> flag C do registro STATUS - indica resultado da subtração positivo (CONT > W) │ 1 0 0 0 0 1 0 0 1 9 W └─────────┬─────────┘ └───────────> registro apresenta o valor real da subtração _______________________________________________________________________________________ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 84/103 b) F < W → o resultado da operação é um número negativo - o valor representado pelo registro que contém o resultado (W) está na forma “complemento de 2” e o flag C do registro STATUS mantém o valor 0 (zero). * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 1 1 0 1 0 0 0 104 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Instrução SUBWF CONT,W ; SUBTRAIR O VALOR DO REG. W DO VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. W 0 1 1 0 1 0 0 0 104 CONT - - - - - - - - - 0 1 1 1 0 0 0 1 113 W 1 1 1 1 0 1 1 1 247 W (SUBTRAI)) - Atenção: o sinal “-” representa a operação aritmética da subtração. * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de subtração foi um número positivo (CONT > W) logo, o flag de sinalização muda de estado, passando a 1 (um). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Valores contidos nos registros W e CONT depois da execução da instrução: 1 1 1 1 0 1 1 1 247 W 0 1 1 0 1 0 0 0 104 CONT Observação: notar que o valor contido no registro W apresenta o resultado da operação após a execução da instrução, enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 85/103 Se na operação aritmética de subtração o flag C do registro STATUS não muda seu estado de 0 (zero) para 1 (um), o programador deve estabelecer o procedimento adequado no código_fonte para interpretar o resultado como: - o valor contido no registro CONT é menor que o valor contido no registro W (CONT < W) antes da execução da operação de subtração. - o valor contido no registro W após a execução da operação de subtração é um número negativo e representa o “complemento de 2” do resultado final da operação. _______________________________________________________________________________________ Vamos observar como a Unidade Lógica e Aritmética realizou a operação de subtração quando F < W: A operação efetivamente realizada foi: W = CONT + (−W ) Isto é, a ULA realizou uma operação de adição de um valor positivo (CONT) com um valor negativo (W). Para representar um valor negativo na forma binária utiliza-se o “complemento de 2” (two’s complement) deste valor, calculado da seguinte forma: a) determina-se o “complemento de 1” (one’s complement) invertendo os valores de todos os bits contidos no registro: * Valor contido no registro W antes da execução do “complemento de 1”: 0 1 1 1 0 0 0 1 113 W * Valor contido no registro W após a execução do “complemento de 1”: 1 0 0 0 1 1 1 0 142 (COMP 1) W b) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 1 0 0 0 1 1 1 0 142 + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 1 0 0 0 1 1 1 1 143 (COMP 1) (COMP 2) W W Com o valor do “complemento de 2” do registro W ((COMP 2) W), a ULA realiza a operação de adição dos valores de CONT e (COMP 2) W: 0 1 1 0 1 0 0 0 104 CONT + + + + + + + + + (SOMA) + 1 0 0 0 1 1 1 1 143 1 1 1 1 0 1 1 1 247 (COMP 2) W W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 86/103 * Valor contido no registro W depois da execução da adição: 1 1 1 1 0 1 1 1 247 W O resultado da operação de adição foi um número menor que 255 logo, o flag C do registro STATUS não muda de estado, mantendo o valor 0 (zero). IRP RP1 RP0 /TO /PD Z x x x x x x ┌───> flag sinalização após a execução da instrução │ DC C x 0 STATUS MSB LSB Vamos olhar o resultado desta operação. A ULA fez uma operação de adição entre dois valores (104 e 143) que deve apresentar o resultado menor que 255 (no caso, 247): 104 + 143 247 A resposta do flag C no registro STATUS não mudou de valor, mantendo 0 (zero), indicando que o resultado final da operação tem valor menor que 255. IRP RP1 RP0 /TO /PD Z x x x x x x DC C x 0 MSB STATUS LSB O resultado apresentado no registro W não corresponde ao valor esperado da adição (247): 1 1 1 1 0 1 1 1 247 W No entanto, a operação solicitada pela instrução é uma subtração, cujo resultado deveria ser -9 (menos 9), isto é, o resultado da operação real é um número negativo: 104 113 - 9 A estrutura de registro do microcontrolador não consegue representar um número negativo incluindo o sinal, consequentemente, a forma de representá-lo é através do seu “complemento de 2” (two’s complement). O programador deve providenciar o cálculo do valor real do resultado da operação usando a seguinte sequencia: a) transferir o valor contido no registro W para um registro na memória RAM, por exemplo, W_TEMP, para usar a instrução COMF: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 87/103 * Valores contidos nos registros W e W_TEMP antes da execução da instrução MOVWF: MOVWF 1 1 1 1 0 1 1 1 247 W 0 0 0 0 0 0 0 0 0 W_TEMP W_TEMP ; TRANSFERE O VALOR DO REG. W PARA O ; REG. W_TEMP * Valores contidos nos registros W e W_TEMP após a execução da instrução MOVWF: 1 1 1 1 0 1 1 1 247 W 1 1 1 1 0 1 1 1 247 W_TEMP b) determina-se o “complemento de 1” (one’s complement) executando a instrução COMF no registro W_TEMP, que inverte os valores de todos os bits contidos no registro: * Valor contido no registro W_TEMP antes da execução da instrução COMF (“complemento de 1”): 1 COMF 1 1 1 0 1 W_TEMP 1 1 247 W_TEMP ; CALCULA “complemento 1”DO REG. W_TEMP * Valor contido no registro W_TEMP após a execução da instrução COMF (“complemento de 1”): 0 0 0 0 1 0 0 0 8 (COMP 1) W_TEMP c) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 0 0 0 0 1 0 0 0 8 (COMP 1) W_TEMP + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 0 0 0 0 1 0 0 1 9 (COMP 2) W_TEMP d) retornar o valor contido no registro W_TEMP para o registro W: * Valores contidos nos registros W e W_TEMP antes da execução da instrução MOVF: 1 1 1 1 0 1 1 1 247 0 0 0 0 1 0 0 1 9 W (COMP 2) W_TEMP Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 88/103 MOVF W_TEMP,W ; TRANSFERE O VALOR DO REG. W_TEMP ; PARA O REG. W * Valores contidos nos registros W e W_TEMP após a execução da instrução MOVF: 0 0 0 0 1 0 0 1 9 0 0 0 0 1 0 0 1 9 W (COMP 2) W_TEMP Agora o registro W contém o valor real da operação de subtração porém, sem indicação do sinal negativo. A interpretação do sinal negativo deve ser feita pelo programador. _______________________________________________________________________________________ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 89/103 c) F = W → o resultado da operação é nulo - o valor representado pelo registro que contém o resultado (W) está na forma direta e os flags Z e C do registro STATUS são colocados no valor 1 (um). * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 1 1 1 0 0 0 1 113 CONT * Valor dos flags Z e C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───────> flag sinalização antes da execução da instrução │ │ ┌─> flag sinalização antes da execução da instrução │ │ IRP RP1 RP0 /TO /PD Z DC C x x x x x 0 x 0 STATUS MSB LSB * Instrução SUBWF CONT,W ; SUBTRAIR O VALOR DO REG. W DO VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. W 0 1 1 1 0 0 0 1 113 CONT - - - - - - - - - 0 1 1 1 0 0 0 1 113 W 0 0 0 0 0 0 0 0 0 W (SUBTRAI)) - Atenção: o sinal “-” representa a operação aritmética da subtração. * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de subtração foi nulo (CONT = W) logo, o flag Z muda de estado, passando a 1 (um) e o flag C muda de estado também passando a 1 (um) ┌───────> flag sinalização depois da execução da instrução │ │ ┌─> flag sinalização depois da execução da instrução │ │ IRP RP1 RP0 /TO /PD Z DC C x x x x x 1 x 1 STATUS MSB LSB * Valores contidos nos registros W e CONT depois da execução da instrução: 0 0 0 0 0 0 0 0 0 W 0 1 1 1 0 0 0 1 113 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 90/103 Observação: notar que o valor contido no registro W apresenta o resultado da operação após a execução da instrução, enquanto o registro CONT permanece inalterado (o valor contido originalmente é preservado). Se na operação aritmética de subtração os flags Z e C do registro STATUS mudam seus estados de 0 (zero) para 1 (um), o programador deve estabelecer o procedimento adequado no código_fonte para interpretar o resultado como: - o valor contido no registro CONT é igual ao valor contido no registro W (CONT = W) antes da execução da operação de subtração. - o valor contido no registro W após a execução da operação de subtração é nulo e representa o resultado final da operação. _______________________________________________________________________________________ Vamos observar como a Unidade Lógica e Aritmética realizou a operação de subtração quando F = W: A operação efetivamente realizada foi: W = CONT + (−W ) Isto é, a ULA realizou uma operação de adição de um valor positivo (CONT) com um valor negativo (W). Para representar um valor negativo na forma binária utiliza-se o “complemento de 2” (two’s complement) deste valor, calculado da seguinte forma: a) determina-se o “complemento de 1” (one’s complement) invertendo os valores de todos os bits contidos no registro: * Valor contido no registro W antes da execução do “complemento de 1”: 0 1 1 1 0 0 0 1 113 W * Valor contido no registro W após a execução do “complemento de 1”: 1 0 0 0 1 1 1 0 142 (COMP 1) W b) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 1 0 0 0 1 1 1 0 142 + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 1 0 0 0 1 1 1 1 143 (COMP 1) (COMP 2) W W Com o valor do “complemento de 2” do registro W ((COMP 2) W), a ULA realiza a operação de adição dos valores de CONT e (COMP 2) W: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 91/103 0 1 1 1 0 0 0 1 113 CONT + + + + + + + + + (SOMA) + 1 0 0 0 1 1 1 1 143 0 0 0 0 0 0 0 0 0 (COMP 2) W W * Valor contido no registro W depois da execução da adição: 0 0 0 0 0 0 0 0 0 W O resultado da operação de adição foi um número maior que 255 logo, o flag C do registro STATUS muda de estado, passando a 1 (um). IRP RP1 RP0 /TO /PD Z x x x x x x ┌───> flag sinalização após a execução da instrução │ DC C x 1 STATUS MSB LSB Vamos olhar o resultado desta operação. A ULA fez uma operação de adição entre dois valores (113 e 143) que deve apresentar o resultado maior que 255 (no caso, 256): 113 + 143 256 A resposta do flag C no registro STATUS mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor maior que 255, e o flag Z no registro STATUS mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor nulo. IRP RP1 RP0 /TO /PD Z x x x x x 1 DC C x 1 MSB STATUS LSB O resultado apresentado no registro W corresponde ao valor esperado da adição (256): 0 0 0 0 0 0 0 0 0 W _______________________________________________________________________________________ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 92/103 W = F −W → - Registro de destino F - Subtrair o valor contido no registro W do valor contido no registro CONT e colocar o resultado no registro CONT a) F > W → o resultado da operação é um número positivo - o valor representado pelo registro que contém o resultado (CONT) está na forma direta e o flag C do registro STATUS é colocado no valor 1 (um). * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 0 1 0 0 0 104 W 0 1 1 1 0 0 0 1 113 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x X x x x 0 STATUS MSB LSB * Instrução SUBWF CONT,F ; SUBTRAIR O VALOR DO REG. W DO VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. CONT 0 1 1 1 0 0 0 1 113 CONT - - - - - - - - - 0 1 1 0 1 0 0 0 104 W 0 0 0 0 1 0 0 1 9 CONT (SUBTRAI) - Atenção: o sinal “-” representa a operação aritmética da subtração. * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de subtração foi um número positivo (CONT > W) logo, o flag de sinalização muda de estado, passando a 1 (um). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x X X x X x 1 STATUS MSB LSB * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 0 1 0 0 0 104 W 0 0 0 0 1 0 0 1 9 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 93/103 Observação: notar que o valor contido no registro CONT apresenta o resultado da operação após a execução da instrução, enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Se na operação aritmética de subtração o flag C do registro STATUS muda seu estado de 0 (zero) para 1 (um), o programador deve estabelecer o procedimento adequado no código_fonte para interpretar o resultado como: - o valor contido no registro CONT é maior que o valor contido no registro W (CONT > W) antes da execução da operação de subtração. - o valor contido no registro CONT após a execução da operação de subtração é um número positivo e representa o resultado final da operação. _______________________________________________________________________________________ Vamos observar como a Unidade Lógica e Aritmética realizou a operação de subtração quando F > W: A operação efetivamente realizada foi: W = CONT + (−W ) Isto é, a ULA realizou uma operação de adição de um valor positivo (CONT) com um valor negativo (W). Para representar um valor negativo na forma binária utiliza-se o “complemento de 2” (two’s complement) deste valor, calculado da seguinte forma: a) determina-se o “complemento de 1” (one’s complement) invertendo os valores de todos os bits contidos no registro: * Valor contido no registro W antes da execução do “complemento de 1”: 0 1 1 0 1 0 0 0 104 W * Valor contido no registro W após a execução do “complemento de 1”: 1 0 0 1 0 1 1 1 151 (COMP 1) W Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 94/103 b) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 1 0 0 1 0 1 1 1 151 + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 1 0 0 1 1 0 0 0 152 (COMP 1) (COMP 2) W W Com o valor do “complemento de 2” do registro W ((COMP 2) W), a ULA realiza a operação de adição dos valores de CONT e (COMP 2) W: 0 1 1 1 0 0 0 1 113 CONT + + + + + + + + + (SOMA) + 1 0 0 1 1 0 0 0 152 0 0 0 0 1 0 0 1 9 (COMP 2) W CONT * Valor contido no registro CONT depois da execução da adição: 0 0 0 0 1 0 0 1 9 CONT O resultado da operação de adição foi um número maior que 255 logo, o flag C do registro STATUS muda de estado, passando a 1 (um). IRP RP1 RP0 /TO /PD Z x x x X x x ┌───> flag sinalização após a execução da instrução │ DC C x 1 STATUS MSB LSB Vamos olhar o resultado desta operação. A ULA fez uma operação de adição entre dois valores (113 e 152) que deve apresentar o resultado maior que 255 (no caso, 265): 113 + 152 265 A resposta do flag C no registro STATUS mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor maior que 255. IRP RP1 RP0 /TO /PD Z x x x X x x MSB DC C x 1 STATUS LSB Porém, o resultado apresentado no registro CONT não corresponde ao valor esperado da adição (265), mas apresentou o valor 9: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 95/103 0 0 0 0 1 0 0 1 9 CONT O valor 265 não cabe em 8 bits. Para representá-lo são necessários pelo menos 9 bits e, como pode ser observado, os 8 bits menos significativos representam o valor 9. ┌───> nono bit - inexistente - peso 29 = 256 │ 1 0 0 0 0 1 0 0 1 265 CONT Na estrutura de 8 bits, o flag C do registro STATUS representa o nono bit necessário para a composição de valores maiores do que 255. Consequentemente, o resultado apresentado pela ULA fica: ┌───> flag C do registro STATUS - indica resultado da subtração positivo (CONT > W) │ 1 0 0 0 0 1 0 0 1 9 CONT └─────────┬─────────┘ └───────────> registro apresenta o valor real da subtração _______________________________________________________________________________________ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 96/103 b) F < W → o resultado da operação é um número negativo - o valor representado pelo registro que contém o resultado (CONT) está na forma “complemento de 2” e o flag C do registro STATUS mantém o valor 0 (zero). * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 1 1 0 1 0 0 0 104 CONT * Valor do flag C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───> flag sinalização antes da execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x X x x x 0 STATUS MSB LSB * Instrução SUBWF CONT,F ; SUBTRAIR O VALOR DO REG. W DO VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. CONT 0 1 1 0 1 0 0 0 104 CONT - - - - - - - - - 0 1 1 1 0 0 0 1 113 W 1 1 1 1 0 1 1 1 247 CONT (SUBTRAI) - Atenção: o sinal “-” representa a operação aritmética da subtração. * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de subtração foi um número positivo (CONT > W) logo, o flag de sinalização muda de estado, passando a 1 (um). ┌───> flag sinalização após a execução da instrução │ IRP RP1 RP0 /TO /PD Z DC C x x x x x x x 0 STATUS MSB LSB * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 113 W 1 1 1 1 0 1 1 1 247 CONT Observação: notar que o valor contido no registro CONT apresenta o resultado da operação após a execução da instrução, enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 97/103 Se na operação aritmética de subtração o flag C do registro STATUS não muda seu estado de 0 (zero) para 1 (um), o programador deve estabelecer o procedimento adequado no código_fonte para interpretar o resultado como: - o valor contido no registro CONT é menor que o valor contido no registro W (CONT < W) antes da execução da operação de subtração. - o valor contido no registro CONT após a execução da operação de subtração é um número negativo e representa o “complemento de 2” do resultado final da operação. _______________________________________________________________________________________ Vamos observar como a Unidade Lógica e Aritmética realizou a operação de subtração quando F < W: A operação efetivamente realizada foi: W = CONT + (−W ) Isto é, a ULA realizou uma operação de adição de um valor positivo (CONT) com um valor negativo (W). Para representar um valor negativo na forma binária utiliza-se o “complemento de 2” (two’s complement) deste valor, calculado da seguinte forma: a) determina-se o “complemento de 1” (one’s complement) invertendo os valores de todos os bits contidos no registro: * Valor contido no registro W antes da execução do “complemento de 1”: 0 1 1 1 0 0 0 1 113 W * Valor contido no registro W após a execução do “complemento de 1”: 1 0 0 0 1 1 1 0 142 (COMP 1) W b) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 1 0 0 0 1 1 1 0 142 + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 1 0 0 0 1 1 1 1 143 (COMP 1) (COMP 2) W W Com o valor do “complemento de 2” do registro W ((COMP 2) W), a ULA realiza a operação de adição dos valores de CONT e (COMP 2) W: 0 1 1 0 1 0 0 0 104 CONT + + + + + + + + + (SOMA) + 1 0 0 0 1 1 1 1 143 1 1 1 1 0 1 1 1 247 (COMP 2) W CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 98/103 * Valor contido no registro CONT depois da execução da adição: 1 1 1 1 0 1 1 1 247 CONT O resultado da operação de adição foi um número menor que 255 logo, o flag C do registro STATUS não muda de estado, mantendo o valor 0 (zero). IRP RP1 RP0 /TO /PD Z x x x x x x ┌───> flag sinalização após a execução da instrução │ DC C x 0 STATUS MSB LSB Vamos olhar o resultado desta operação. A ULA fez uma operação de adição entre dois valores (104 e 143) que deve apresentar o resultado menor que 255 (no caso, 247): 104 + 143 247 A resposta do flag C no registro STATUS não mudou de valor, mantendo 0 (zero), indicando que o resultado final da operação tem valor menor que 255. IRP RP1 RP0 /TO /PD Z x x x x x x DC C x 0 MSB STATUS LSB O resultado apresentado no registro CONT não corresponde ao valor esperado da adição (247): 1 1 1 1 0 1 1 1 247 CONT No entanto, a operação solicitada pela instrução é uma subtração, cujo resultado deveria ser -9 (menos 9), isto é, o resultado da operação real é um número negativo: 104 113 - 9 A estrutura de registro do microcontrolador não consegue representar um número negativo incluindo o sinal, consequentemente, a forma de representá-lo é através do seu “complemento de 2” (two’s complement). O programador deve providenciar o cálculo do valor real do resultado da operação usando a seguinte sequencia: a) determina-se o “complemento de 1” (one’s complement) utilizando a instrução COMF, que inverte os valores de todos os bits contidos no registro: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 99/103 * Valor contido no registro CONT antes da execução da instrução COMF (“complemento de 1”): 1 1 1 1 0 1 1 1 247 CONT * Valor contido no registro CONT após a execução da instrução COMF (“complemento de 1”): 0 0 0 0 1 0 0 0 8 (COMP 1) CONT b) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 0 0 0 0 1 0 0 0 8 + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 0 0 0 0 1 0 0 1 9 (COMP 1) (COMP 2) CONT CONT Agora o registro W contém o valor real da operação de subtração porém, sem indicação do sinal negativo. A interpretação do sinal negativo deve ser feita pelo programador. _______________________________________________________________________________________ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 100/103 c) F = W → o resultado da operação é nulo - o valor representado pelo registro que contém o resultado (W) está na forma direta e os flags Z e C do registro STATUS são colocados no valor 1 (um). * Valores contidos nos registros W e CONT antes da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 1 1 1 0 0 0 1 113 CONT * Valor dos flags Z e C no registro STATUS antes da execução da instrução (a Unidade Lógica sempre posiciona o valor do bit C no valor 0 (zero) antes de executar a instrução): ┌───────> flag sinalização antes da execução da instrução │ │ ┌─> flag sinalização antes da execução da instrução │ │ IRP RP1 RP0 /TO /PD Z DC C x x x x x 0 x 0 STATUS MSB LSB * Instrução SUBWF CONT,F ; SUBTRAIR O VALOR DO REG. W DO VALOR DO REG. ; CONT E COLOCAR O RESULTADO DA OPERAÇÃO ; NO REG. CONT 0 1 1 1 0 0 0 1 113 CONT - - - - - - - - - 0 1 1 1 0 0 0 1 113 W 0 0 0 0 0 0 0 0 0 CONT (SUBTRAI)) - Atenção: o sinal “-” representa a operação aritmética da subtração. * Valor do flag C no registro STATUS após a execução da instrução: O resultado da operação de subtração foi nulo (CONT = W) logo, o flag Z muda de estado, passando a 1 (um) e o flag C muda de estado também passando a 1 (um) ┌───────> flag sinalização depois da execução da instrução │ │ ┌─> flag sinalização depois da execução da instrução │ │ IRP RP1 RP0 /TO /PD Z DC C x x x x x 1 x 1 STATUS MSB LSB * Valores contidos nos registros W e CONT depois da execução da instrução: 0 1 1 1 0 0 0 1 113 W 0 0 0 0 0 0 0 0 0 CONT Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 101/103 Observação: notar que o valor contido no registro CONT apresenta o resultado da operação após a execução da instrução, enquanto o registro W permanece inalterado (o valor contido originalmente é preservado). Se na operação aritmética de subtração os flags Z e C do registro STATUS mudam seus estados de 0 (zero) para 1 (um), o programador deve estabelecer o procedimento adequado no código_fonte para interpretar o resultado como: - o valor contido no registro CONT é igual ao valor contido no registro W (CONT = W) antes da execução da operação de subtração. - o valor contido no registro CONT após a execução da operação de subtração é nulo e representa o resultado final da operação. _______________________________________________________________________________________ Vamos observar como a Unidade Lógica e Aritmética realizou a operação de subtração quando F = W: A operação efetivamente realizada foi: W = CONT + (−W ) Isto é, a ULA realizou uma operação de adição de um valor positivo (CONT) com um valor negativo (W). Para representar um valor negativo na forma binária utiliza-se o “complemento de 2” (two’s complement) deste valor, calculado da seguinte forma: a) determina-se o “complemento de 1” (one’s complement) invertendo os valores de todos os bits contidos no registro: * Valor contido no registro W antes da execução do “complemento de 1”: 0 1 1 1 0 0 0 1 113 W * Valor contido no registro W após a execução do “complemento de 1”: 1 0 0 0 1 1 1 0 142 (COMP 1) W b) somar 1 (um) ao valor do “complemento de 1” (one’s complement) para se obter o “complemento de 2” (two’s complement): 1 0 0 0 1 1 1 0 142 + + + + + + + + + (SOMA) + 0 0 0 0 0 0 0 1 1 UNIDADE 1 0 0 0 1 1 1 1 143 (COMP 1) (COMP 2) W W Com o valor do “complemento de 2” do registro W ((COMP 2) W), a ULA realiza a operação de adição dos valores de CONT e (COMP 2) W: Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 102/103 0 1 1 1 0 0 0 1 113 CONT + + + + + + + + + (SOMA) + 1 0 0 0 1 1 1 1 143 0 0 0 0 0 0 0 0 0 (COMP 2) W CONT * Valor contido no registro CONT depois da execução da adição: 0 0 0 0 0 0 0 0 0 CONT O resultado da operação de adição foi um número maior que 255 logo, o flag C do registro STATUS muda de estado, passando a 1 (um). IRP RP1 RP0 /TO /PD Z x x x x x x ┌───> flag sinalização após a execução da instrução │ DC C x 1 STATUS MSB LSB Vamos olhar o resultado desta operação. A ULA fez uma operação de adição entre dois valores (113 e 143) que deve apresentar o resultado maior que 255 (no caso, 256): 113 + 143 256 A resposta do flag C no registro STATUS mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor maior que 255, e o flag Z no registro STATUS mudou do valor 0 (zero) para o valor 1 (um), indicando que o resultado final da operação tem valor nulo. IRP RP1 RP0 /TO /PD Z x x x x x 1 DC C x 1 MSB STATUS LSB O resultado apresentado no registro CONT corresponde ao valor esperado da adição (256): 0 0 0 0 0 0 0 0 0 CONT _______________________________________________________________________________________ Bento Alves Cerqueira Cesar Filho - R 1.4 - Mai/09 103/103