Professional Documents
Culture Documents
PIC - Microchip
A arte de criar um programa ou algoritmo para controlar alguma coisa envolve muito mais que o conhecimento de uma linguagem
de programação com suas instruções e recursos. Envolve o conhecimento do que deseja controlar. Como opera, funciona, responde,
envia e recebe informações. A maioria dos problemas não envolve exclusivamente informações digitais, mas informações
analógicas que devem ser manipuladas para atingir valores que podem ser lidos pelo sistema de controle. Envolve, ainda, a
compreensão destes valores e o que representam para o sistema controlado. Pior, o programador deve ter conhecimento dos valores
representados para transformá-los em valores digitais e interpretá-los adequadamente para que os sinais de controle enviados de
retorno para o sistema tenham o correto desempenho.
Em suma, o programador não deve e não pode ser um simples “organizador de instruções”, mas um profundo conhecedor do
processo para que o programa ou algoritmo desenvolvido seja o menor e o mais eficiente possível.
Assim como diz a frase do filósofo, o programador deve pensar o impensável, ver o invisível, imaginar o inimaginável para
produzir uma obra de arte.
INTRODUÇÃO
Assembler é uma linguagem de programação usada para desenvolver o código-fonte para uma determinada
aplicação que utilize microcontroladores.
É uma linguagem com códigos e mnemônicos (baixo nível) que permitem o controle do processamento no
nível de um bit de um registro portanto, aproxima o usuário da manipulação da informação dentro do núcleo
de processamento e das memórias de programa e dados individualmente.
Ainda assim, o Assembler é uma linguagem para compreensão humana e não da máquina. A máquina só
compreende informações na forma binária, que é de compreensão impossível pelo humano. Logo, deve
existir um elemento tradutor da linguagem Assembler (humana) para a linguagem de máquina (binária). O
tradutor é um programa residente elaborado pelo fabricante do dispositivo microcontrolador (compilador)
que reconhece os comandos e mnemônicos da linguagem Assembler (que normalmente é exclusiva para cada
fabricante) – um arquivo code.asm - e converte em linguagem de máquina – um arquivo code.hex – que será
gravado na memória de programa do microcontrolador através de um dispositivo gravador adequado. A fig.1
mostra, esquemáticamente, o processo:
CÓDIGO-FONTE (.asm)
Os programas usados para criar um código-fonte são, essencialmente, editores de texto. Enquanto o código
está sendo escrito, todas as facilidades encontradas nos editores de texto estão presentes.
O código só será transformado em um arquivo executável após a compilação bem sucedida do código-fonte.
Mesmo após a compilação, o que é apresentado para o programador na tela continua sendo um texto.
Lembre-se que o arquivo executável (aquele que é gravado na memória de programa do controlador) é
Bento Alves Cerqueira Cesar Filho - R 1.2 - JUN/07
2/28
ilegível para nós humanos. Portanto, escrever o código-fonte de uma aplicação é um exercício de
apresentação de texto.
Para facilitar o trabalho do programador, os programas para edição de código-fonte trazem uma série de
facilidades automáticas tais como colorir o texto de acordo com a função de cada palavra, mas não organiza
esse texto na tela. Isto é função do programador (trabalho braçal).
Um código-fonte bem elaborado (no aspecto visual, porque no aspecto lógico é outro assunto) tem
apresentação tal que facilite a leitura, compreensão do funcionamento, correção (quando necessário) e
evolução por qualquer outro programador, ou pelo seu criador (um ano depois).
A apresentação utilizada do código-fonte será aquela mostrada no arquivo BÁSICO.asm, desenvolvido a partir
de aplicações práticas e facilita as explicações e informações de como utilizar as diretivas e instruções do
microcontrolador bem como a maneira de escrever de tal forma que o compilador seja capaz de interpretar e
produzir o arquivo executável sem erros.
A formatação do texto do código-fonte foi organizada para permitir o fácil sequenciamento do procedimento
de programação utilizando, básicamente, tres grandes capítulos:
1- Área de Identificação
Nesta área são colocadas as informações que identificam o código-fonte.A fig.2 mostra parte da
Área de Identificação do arquivo BÁSICO.asm:
É claro que a fig.2 mostra apenas uma sugestão, visto que o tipo de informação constante na Área de
Identificação depende exclusivamente dos objetivos do programador.
Nesta área o programador coloca as instruções que orientam o compilador na formação do arquivo
executável. A fig.3 mostra parte da Área de Diretivas do arquivo BÁSICO.asm:
Nesta área é escrito o programa efetivo que será gravado na memória do controlador. O compilador
monta o arquivo executável com as instruções desta áre a partir das diretivas dadas na Área de
Diretivas.
Para escrever o código-fonte algumas regras básicas devem ser observadas. Como o código-fonte é um editor
de texto, a formatação do texto pode seguir algumas regras simples comuns a todo o código-fonte:
- não se usa acentuação do Portugues (acentos, til, cedilha etc.) – lembre-se que a língua de origem
do Assembler é o Ingles que não tem nenhum tipo de acentuação.
- para evitar possíveis problemas de identificação do tamanhodo caixa da letra, utilizar sempre letras
maiúsculas (caixa alta) para qualquer texto no código-fonte – o processador tem códigos diferentes
para identificar a mesma letra quando maiúscula (caixa alta) ou minúscula (caixa baixa), o que
pode causar erro de compilação e este erro não é identificado como tamanho do caixa da letra, mas
como Nome (label) inexistente.
Nas figuras 2, 3 e 4 podemos ver como é a apresentação do texto do código-fonte atendendo a estas regras
básicas - é trabalho braçal feito pelo programador. No entanto, essa preocupação facilita a leitura e
interpretação do código-fonte pelo programador a qualquer tempo.
- Nomes (labels)
Os elementos de uso geral (Registros e Bits) são identificados por Nomes criados pelo
programador e que, preferencialmente, devem ser relacionados à função proposta de cada um deles.
Os Nomes empregados no código-fonte não são interpretados pelo compilador – são apenas para
interpretação humana – durante a compilação serão substituídos pelos endereços físicos das
memórias (registros, bits e endereços).
Regras
- um Nome não pode ser repetido para elementos diferentes – uma vez criado um Nome,
ele é único e individual para aquele código-fonte.
- deve ser iniciado por um carácter alfabético ou under-line (não deve ser um carácter
numérico ou dois . under-line).
- pode ser formado por letras e números desde que o primeiro carácter não seja numérico.
- nomes compostos devem ser separados sempre por under-line (não usar hífen ( - )ou
espaço).
- não deve conter símbolos gráficos ou gramaticais.
EXEMPLO:
ROTINA
W_TEMP
_TEMPORARIO
FLAGS
CONTADOR_2
Bento Alves Cerqueira Cesar Filho - R 1.2 - JUN/07
7/28
- Diretivas
São comandos Assembler que são colocados no código-fonte mas, normalmente, não são
transformados em códigos operacionais (opcodes) pelo compilador.
Através das diretivas o programador informa como o compilador deve proceder para interpretar as
informações escritas na Área de Código e relacionar com as informações do controlador usado
através do arquivo de inclusão ([ arquivo ].inc).
Regras
Diretivas
#INCLUDE
#DEFINE
- devem ser posicionados sempre a partir da coluna 1 (junto à lateral esquerda da tela).
EXEMPLO:
Diretivas
CBLOCK
ENDC
ORG
- devem ser posicionados com um espaço (mínimo) da coluna 1, preferencialmente com um
espaço do tipo tab.
- separar o Endereço da Diretiva utilizando espaços ou tab.
EXEMPLO:
- Endereços (label)
São nomes criados pelo programador para indicar o destino de desvios condicionais do programa
ou início de sub-rotinas.
Regras
- o nome do Endereço não pode ser repetido para destinos diferentes – uma vez criado um
Endereço para um destino de desvio, ele é único e individual para aquele destino.
- deve ser iniciado por um carácter alfabético (não deve ser um carácter numérico).
- Endereços compostos devem ser separados sempre por under-line (não usar hífen ( - )ou
espaço).
- deve ser sempre posicionado na coluna 1 (junto à lateral esquerda da tela) uma única vez -
a partir do Endereço inicia-se a sequencia de instruções do desvio.
- um Endereço pode ser repetido inúmeras vezes dentro do código-fonte desde que
precedido pela instrução GOTO ou CALL.
a) Desvio Condicional
INICIO
BTFSS BOTAO ; VERIFICA O ESTADO DO BIT QUE REPRESENTA BOTAO
GOTO DESLIGA_LED ; BOTAO = 0 > VAI PARA DESLIGA_LED
BSF LED ; BOTAO = 1 > LIGA LED
GOTO INICIO ; RETORNA PARA INICIO
DESLIGA_LED
BCF LED ; DESLIGA LED
GOTO INICIO ; RETORNA PARA INICIO
SUB_ROTINA
┌
│• ; SEQUENCIA DE INSTRUÇÕES DE EXECUÇÃO
│• ; DA SUB-ROTINA
│•
└
RETURN ; SAÍDA DA SUB-ROTINA
- Instruções (mnemônicos)
As instruções informam ao processador as operações que devem ser realizadas com os registros e
bits dentro do código-fonte.
O termo “mnemônico” indica que cada instrução é a abreviatura de um texto indicativo da função
da instrução.
Regras
EXEMPLO:
- Operadores
Os Operadores informam a instrução sobre os dados que serão usados e a localização dos registros
onde os dados se encontram.
Os Operadores podem ser registros, variáveis ou constantes, normalmente identificados por um
Nome (existente, no caso dos Registros Especiais ,ou criado, no caso dos Registros de Usuário).
Regras
- operadores devem seguir instruções separados por espaços (utilizar um ou mais espaços
TAB).
- operadores múltiplos devem ser separados por vírgulas.
EXEMPLO:
- Comentários
Regras
- comentários devem começar sempre por ponto-e-vírgula (;) – o compilador ignora todo e
qualquer carácter após o ponto-e-vírgula (;) até o fim da linha.
- comentários que continuam na linha seguinte devem ser precedidos, também, por ponto-e-
vírgula (;), mesmo se precedidos por espaços.
- podem ser colocados em qualquer posição do texto do código-fonte (separados ou não por
um ou mais espaços ou TAB’s, antes ou depois de linhas de instrução).
EXEMPLO:
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; DEFINIÇÃO DE VARIÁVEIS
Para escrever um código-fonte vamos utilizar o arquivo BÁSICO.asm como referencia. Este arquivo foi
desenvolvido para facilitar o início de qualquer desenvolvimento novo, apresentando ao programador uma
tela que não esteja em branco. A extensão do nome do arquivo já é .asm, logo, o texto será como um código-
fonte válido.
O texto apresenta uma sequencia de atividades através de capítulos indicando o quê o programador deve
fazer durante a criação do código-fonte. Os capítulos podem ser excluídos (quando não usados), ou novos
podem ser acrescentados (de acordo com a necessidade).
Algumas sequencias de instruções e Nomes de variáveis de uso geral já se encontram listadas no texto. São
baseados na experiencia de uso e recomendações do fabricante logo, facilitam ao programador lembrar dos
detalhes necessários antes de encontrar dificuldades durante simulação. As instruções e Nomes não utilizados
podem ser descartados.
Inicialmente o texto BÁSICO.asm será apresentado sem comentários no mesmo formato encontrado no arquivo
quando aberto pelo MPLAB – Microchip.
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ÁREA DE IDENTIFICAÇÃO
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
;
; PIMIL – PICARETAGENS MIL LTDA. - SISTEMAS DE AUTOMAÇÃO
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; IDENTIFICAÇÃO DE PROJETO
;
; PROJETO .....................:
; CLIENTE ......................:
; NOME ARQUIVO .......:
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; DATAS E VERSÕES
;
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL.....
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL.....
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL.....
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL.....
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; DESCRIÇÃO OPERACIONAL
;
;
;
;
;
;
;
;
;
;
;
;
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; CONFIGURAÇÃO DO CONTROLADOR
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; PÁGINA DE MEMÓRIA
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; VARIÁVEIS
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; FLAG INTERNO
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; CONSTANTES
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ENTRADAS
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; SAÍDAS
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; VETOR DE INTERRUPÇÃO
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; TRATAMENTO DAS INTERRUPÇÕES
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; FIM DA INTERRUPÇÃO
SAI_INT
SWAPF STATUS_TEMP,W ; TROCA NIB_HI POR NIB_LO EM STATUS_TEMP E
; GRAVA EM W
MOVWF STATUS ; RECUPERA STATUS
SWAPF W_TEMP,F ; TROCA NIB_HI POR NIB_LO EM W_TEMP E
; GRAVA EM W_TEMP
SWAPF W_TEMP,W ; TROCA NIB_HI POR NIB_LO EM W_TEMP E
; RECUPERA EM W
RETFIE ; RETORNA DA INTERRUPÇÃO
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; INÍCIO DO SET_UP DO CONTROLADOR
SET_UP
MOVLW B'10000011'
MOVWF OPTION_REG ; RESISTORES PULL-UP DESABILITADOS
; TRANSIÇÃO RB0/INT NÃO UTILIZADA
; INCREMENTO TMR0 INTERNO (CM)
; TRANSIÇÃO T0CK1 NÃO UTILIZADA
; PRE SCALER SELECIONADO PARA TMR0
; DIVISÃO 1:16 NO PRE SCALER
MOVLW B'00000000'
MOVWF INTCON ; INTERRUPÇÕES NÃO HABILITADAS
MOVLW B'00001100'
MOVWF TRISA ; RA2:3 ENTRADA, DEMAIS SAÍDAS
MOVLW B'00000000'
MOVWF TRISB ; TODOS OS BITS SAÍDAS
MOVLW B'00000111'
MOVWF CMCON ; DESLIGA OS COMPARADORES ANALÓGICOS E
; HABILITA OS PINOS DO PORTA PARA I/O DIGITAL
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ROTINA PRINCIPAL
ROT_PRINC
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ROTINAS SECUNDÁRIAS
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; SUB-ROTINAS
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; FIM DO CÓDIGO
1- Área de Identificação
Esta área foi criada para que o projetista possa identificar e descrever o tipo de código-fonte que se encontra
no arquivo.
Como na abertura do programa a tela apresentada começa exatamente nesta posição, o programador
identifica a origem, destino, aplicação, datas etc. que interessam logo de início.
Observar que o texto da Área de Identificação é formado por Comentários – todas as linhas são iniciadas por
ponto-e-vírgula (;) – logo, como são ignoradas pelo compilador, pode-se usar a acentuação normal da língua
portuguesa.
Os comentários expressos em cada capítulo procuram orientar o programador para realizar o código-fonte da
melhor maneira possível.
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ÁREA DE IDENTIFICAÇÃO
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
;
; PIMIL – PICARETAGENS MIL LTDA. - SISTEMAS DE AUTOMAÇÃO
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; IDENTIFICAÇÃO DE PROJETO
;
; PROJETO .....................: [nome de identificação ou referencia do projeto]
; CLIENTE ......................: [nome do cliente ou mercado ou produto de aplicação]
; NOME ARQUIVO .......: [nome de localização do arquivo no servidor principal ou outro meio de arquivo[
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; DATAS E VERSÕES
;
; [cada linha pode conter informações desde o princípio do projeto, modificações e descrição sucinta de cada modificação realizada]
;
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL..... [nome ou sigla do programdor]
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL.....
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL.....
; INÍCIO.... 00/00/0000 VERSÃO..... 00.00 RESPONSÁVEL.....
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; DESCRIÇÃO OPERACIONAL
;
[Descrever a operação do código-fonte com informações suficientes para a correta compreensão do funcionamento. Deve existir documentação
com diagramas elétricos detalhados, lista de materiais e manual de instruções/operação/manutenção em outros tipos de documentos que podem
e devem ser referenciados neste capítulo. Procurre não se apoiar em documentação exclusivamente eletronica.]
;
;
;
;
;
;
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
2- Área de Diretivas
Nesta área o programador define todos os parametros de uso do controlador, identificando o modelo de
controlador, a configuração, os Nomes dos Registros e Bits de Uso Geral, a correlação existente entre os
Nomes dos dispositivos de Entrada/Saída e os Registros Especiais.
O compilador não interpreta a forma de capítulos agrupando as diretivas por função ou destinação. Durante a
execução da compilação do código-fonte, apenas as diretivas são buscadas e interpretadas. A sequencia em
que estão escritas e a distribuição organizada é ignorada – sua utilidade reside apenas na facilidade de leitura
e interpretação pelo programador. O Anexo 2 mostra uma comparação da Área de Diretivas comentada e
simples onde se pode ver a diferença de tamanho de texto com a compreensão deste mesmo texto.
Outros capítulos, além dos apresentados, podem ser acrescentados para melhorar o detalhamento das
diretivas bem como podem ser excluídos quando não utilizados no projeto.
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ÁREA DE DIRETIVAS
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ARQUIVO DE DEFINIÇÕES
[Neste capítulo o programador deve definir os arquivos de inclusão com o modelo do microcontrolador usado e as macros com sequencias de
instruções já estabelecidas – sub rotinas.]
[Neste capítulo coloca-se a configuração que o controlador vai operar. O acesso ao registro de configuração só é possível durante a gravação ds
memória de programa. As opções de configuração dependem do modelo de controlador e devem ser estabelecidas com as informações da folha
de dados do modelo escolhido no arquivo de inclusão.]
[Descrever as opções do registro CONFIG torna mais fácil interpretar as escolhas de funcionamento do componente. Para cada modelo de
controlador existe um registro específico, que o programador deve buscar na folha de dados.]]
[O processo de substituição de uma linha de instrução por um Nome pode ser interessante quando a linha se torna comum e repetitiva dentro do
código-fonte. Observar que este procedimento só é possível para a substituição de uma única linha de instrução. Para a substituição de duas ou
mais linhas de instrução (sequencia) deve-se criar uma Macro.]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; VARIÁVEIS
[Neste capítuloo programador declara todas as variáveis (registros) que vai empregar no código-fonte, com exceção dos Registros Especiais já
existentes. A diretiva CBLOCK pode ser empregada diversas vezes no código-fonte para alocar variáveis em diversas posições de memória. O
programador deve verificar no datasheet do componente as áreas disponíveis para uso geral nos diversos bancos de memória, bem como os
endereços disponíveis, e distribuir as variáveis adequadamente. O controlador não muda de banco de memória automáticamente – é função a
ser determinada pelo programador (ver Paginação de Memória).]
[A diretiva CBLOCK orienta o compilador no relacionamento entre o Nome da variável e o endereço de memória de uso geral onde será
colocado.]
[Este capítulo é destinado à descrição dos desvios condicionais – flags – que o sistema controlado necessita para operar A necessidade de
desvios condicionais é determinada pelo programador. O Nome de cada flag deve ser tal que indique a sua função no código-fonte para facilitar
a compreensão do funcionamento.]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; CONSTANTES
[Constantes são valores numéricos que o código-fonte emprega para iniciar contadores, temporizadores, realizar comparações lógicas, acionar
saídas etc..Neste capítulo o programador relaciona um Nome a um valor numérico que pode ser representado na forma decimal, binária ou
hexadecimal, ou ainda na forma de uma expressão aritmética.]
;------------------------------------------------------------------------------------------------------------------------------------------------------------
; ENTRADAS
[Neste capítulo são relacionados os Nomes associados aos dispositivos externos de controle que enviam sinais ao controlador – entradas (input)
– onde cada entrada corresponde a um bit de um registro PORT.]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; SAÍDAS
[Neste capítulo são relacionados os Nomes associados aos dispositivos externos que são comandados pelo controlador – sáidas (output) – onde
cada saída corresponde a um bit de um registro PORT.]
Nesta área o programador escrever as instruções que devem controlar os dispositivos externos de acordo com
o projeto eletro-eletronico de automação.
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ÁREA DE CÓDIGO
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; VETOR DE RESET
[O endereço 0X00 é relativo ao Vetor de Reset. Quando o controlador é ligado à fonte ou quando ocorre um reset interno (por qualquer motivo)
o programa inicia sempre neste endereço. O programador deve verificar no datasheet do controlador a disponibilidade de endereços livres para
colocação de instruções antes da ocorrencia de outro Vetor automático.]
[A diretiva ORG avisa o compilador que o texto seguinte refere-se às instruções que deverão ser gravadas na Memória de Programa a partir do
endereço indicado.}
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; VETOR DE INTERRUPÇÃO
[O endereço 0X04 é relativo ao Vetor de Interrupção. Quando interrupções são habilitadas, o programa é desviado para este endereço sempre
que ocorre uma interrupção. O programador pode iniciar a sequencia de instruções para tratamento das interrupções a partir deste endereço ou
fazer um desvio para um endereço da Memória de Programa a partir do qual estará escrito o código-fonte relativo ao tratamento das
interrupções.]
[O programador deve estar ciente de que o desvio para o Vetor de Interrupção ocorre para qualquer tipo de interrupção, bastando que esteja
habilitada (bit relativo à habilitação – enable – com valor 1 (um))]
[Depois de realizar todos os testes nos respectivos flags de sinalização das interrupções para verificar qual foi requisitada e na possibilidade de
nenhum flag habilitado (o desvio para o Vetor de Interrupção pode ter ocorrido devido a um ruído no controlador), o programa deve conter a
instrução de desvio para a rotina de Recuperar Contexto – SAI_INT]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; TRATAMENTO DAS INTERRUPÇÕES
[Neste capítulo, o programador deve escrever o código-fonte para o tratamento de cada interrupção habilitada e que tenha um teste de flag com
desvio para esta área. Cada interrupção deve ter seu próprio código-fonte completo e deve terminar sempre com a instrução de desvio para a
rotina de Recuperar Contexto – SAI_INT]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; FIM DA INTERRUPÇÃO
[A sequencia de instruções segue a recomendação da Microchip para recuperar os valores contidos nos registros STATUS_TEMP e W_TEMP
quando houvero retorno do Tratamento de Interrupções – no caso, Recuperar Contexto. O objetivo destas instruções é recuperar os valores
contidos nos registros STATUS_TEMP (em STATUS) e W_TEMP (em W) após o atendimento da Interrupção requisitada. Quando o tratamento
da interrupção for conpletado, o retorno à rotina normal implica na necessidade de se recuperar os valores existentes nos registros STATUS e W
antes da interrupção. O programador deve seguir esta recomendação e, se houver outro registro que seja necessária a recuperação do valor
contido, deve ser incluso na sequencia de Recuperarr Contexto.]
[A sequencia Recuperar Contexto pode ser considerada como padrão em todos os códigos-fonte realizados.]
SAI_INT
SWAPF STATUS_TEMP,W ; TROCA NIB_HI POR NIB_LO EM STATUS_TEMP E
; GRAVA EM W
MOVWF STATUS ; RECUPERA STATUS
SWAPF W_TEMP,F ; TROCA NIB_HI POR NIB_LO EM W_TEMP E
; GRAVA EM W_TEMP
SWAPF W_TEMP,W ; TROCA NIB_HI POR NIB_LO EM W_TEMP E
; RECUPERA EM W
[A saída do Tratamento das Interrupções só é completada com a instrução abaixo. O código-fonte retorna à rotina principal após a execução da
instrução RETFIE.]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; INÍCIO DO SET_UP DO CONTROLADOR
[Este capítulo é de grande importancia. Aqui o programador deve estabelecer as condições que o controlador vai operar. Consiste em colocar
valores (constantes) dentro de deteminados registros especiai para ativar/desativar recursos no controlador. Normalmente, os registros especiais
envolvidos neste capítulo são:
OPTION_REG: resisitores de pull-up, transição do TMR0 e definição do Pre Scaler
INTCON: habilitação ou não das interrupções
TRIS: identificação de Entrada/Saída utilizda pelo registro PORT
CMCON: escolha de aplicação dos Comparadores Analógicos (quando existentes no controlador escolhido)
OSCCAL: emprego do valor de calibração do oscilador interno (quando existente no controlador e habilitado no CONFIG)
O programador deve observar a paginação de memória para ter acesso a estes registros.]
[O endereço para início do SET_UP deve ser escrito na forma mostrada. Lembre-se que o nome do endereço é dado pelo programador e está
direcionado no Vetor de Reset utilizando um desvio incondicional - GOTO.]
SET_UP
[Verificar a página de memória onde estão os registros que serão operados – ver folha de dados do controlador. No caso de alteração da página
de memória, utilizar o Nome definido no capítulo Paginação de Memória para a ativação da área correspodente. No exemplo, os registros
especiais que serão operados estão localizados no BANK1.]
[A representação das constantes literais neste capítulo devem ser no formato binário para visualização do estado lógico de cada bit do registro.
Nos registros especiais, cada bit tem uma função operacional no controlador.]
MOVLW B'10000011'
MOVWF OPTION_REG ; RESISTORES PULL-UP DESABILITADOS
; TRANSIÇÃO RB0/INT NÃO UTILIZADA
; INCREMENTO TMR0 INTERNO (CM)
; TRANSIÇÃO T0CK1 NÃO UTILIZADA
; PRE SCALER SELECIONADO PARA TMR0
; DIVISÃO 1:16 NO PRE SCALER
MOVLW B'00000000'
MOVWF INTCON ; INTERRUPÇÕES NÃO HABILITADAS
MOVLW B'00001100'
MOVWF TRISA ; RA2:3 ENTRADA, DEMAIS SAÍDAS
MOVLW B'00000000'
MOVWF TRISB ; TODOS OS BITS SAÍDAS
[Se no CONFIG foi escolhida a opção de uso do oscilador interno, verificar se o modelo possui um valor de calibração gravado pelo fabricante
no último endereço da memória de programa. Se houver, utilizar a sequencia de instruções para colocar o valor da memória no registro
OSCCAL.]
[Encerradas as operações nos registros especiais na página de memória 1, retornar à página de memória 0 (zero).]
[O registro CMCON controla a configuração dos comparadoras analógicas do controlador. O fabricante inicia o controlador com os
comparadores habilitados por questão de menor consumo do componente. Se o programa elaborado para o controlador não usa os
comparadores, para desligá-los e utilizar as entradas analógicas como I/O digitais, carregar a constante B’00000111’no registro CMCON, que
desliga as entradas analógicas dos comparadores.]
MOVLW B'00000111'
MOVWF CMCON ; DESLIGA OS COMPARADORES ANALÓGICOS E
; HABILITA OS PINOS DO PORTA PARA I/O DIGITAL
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; INÍCIO DAS VARIÁVEIS
[Por segurança, o fabricante recomenda que os registros PORT sejam iniciados em valores conhecidos do programador antes de se iniciar a
Rotina Principal de comandos. Não existe garantia de que os bits destes registros sejam iniciados com valor 0 (zero) na energização do
controlador ou após um RESET de qualquer natureza. Para evitar acidentes, seguir a recomendação do fabricante. Observar que o comando
CLRF utilizado faz com que o registro contenha o valor 0 (zero), isto é, todos os bits estarão no nível lógico baixo. O programador deve ter
certeza de que estes valores são adequados para o código-fonte escrito.]
[Outras variáveis que podem ser iniciadas de um determinado valor conhecido pelo programador podem ser incluídas neste capítulo.]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; ROTINA PRINCIPAL
[Neste capítulo o programador escreve todas as sequencias de instruções necessárias ao correto funcionamento do projeto. O programdor pode
estabelecer a lógica funcional principal neste capítulo e direcionar as rotinas secundárias e sub-rotinas para outros capítulos. O compilador não
considera esta organização em capítulos desde que os endereços e retornos estejam corretamente colocados.]
ROT_PRINC
[Os desvios incondicionais ou condicionais existentes na Rotina Principal ou mesmo dentro das Rotinas Secundárias podem ser escritos neste
capítulo. O programador deve ter o cuidado de estabelecer os Nomes dos endereços de desvio para evitar erros no código-fonte.]
[Mesmo dentro das Rotinas Secundárias, o uso de Sub-Rotinas é importante. Os Nomes dos endereços de desvio não podem ser repetidos para
posições de memórias diferentes.]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; SUB-ROTINAS
[Escrever sub-rotinas em separado das demais rotinas facilita a interpretação do código-fonte. Este capítulo deve conter apenas as sub-rotinas
empregadas tanto pela Rotina Principal quanto pelas Rotinas Secundárias.]
[Toda a sub-rotina deve começar com um Nome de endereço (que deverá ser chamado a partir da instrução CALL), e deve terminar com a
instrução RETURN. ]
; -----------------------------------------------------------------------------------------------------------------------------------------------------------
; FIM DO CÓDIGO
[A instrução END indica para o compilador que as sequencias de instruções encerrou. É de uso obrigatório no final do código-fonte.]
A figura é uma cópia da página da folha de dados (datasheet) do controlador mostrando o registro de
Configuração do dispositivo. Em todos os controladores este registro dispõe de 14 bits, e cada bit (ou
conjunto de bits) determina o modo de operação do modelo. Como o acesso a esse registro está fora do
alcance dos endereços disponíveis de memória, a gravação dos valores em cada bit deve ser realizada no
momento da gravação da memória de programa.