ApostilaEE-1019-0420 - MICROCONTROLADOR

MARINHA DO BRASIL
CENTRO DE INSTRUÇÃO ALMIRANTE ALEXANDRINO
GUIA DE ESTUDO
INTRODUÇÃO AOS
MICROCONTROLADORES
2022
INTRODUÇÃO AOS
MICROCONTROLADORES
MARINHA DO BRASIL
CENTRO DE INSTRUÇÃO ALMIRANTE ALEXANDRINO
MÓDULO EE1019-0420
2022
FINALIDADE: DIDÁTICA
ATO DE APROVAÇÃO
APROVO, para emprego no Centro de Instrução Almirante Alexandrino, para as turmas

do Quadro Técnico de Praças do CPA e dos Cursos de Aperfeiçoamento em Eletrônica, o Guia de
Estudo da disciplina INTRODUÇÃO AOS MICROCONTROLADORES.
Rio de Janeiro, RJ
Em,__de___________de 2022.
JOSÉ AFONSO BARBOZA LOBIANCO

Capitão-de-Fragata (RM1)
Coordenador de Curso da Escola de Eletricidade e Eletrônica
ÍNDICE
 INTRODUÇÃO ................................................................................................................... 1.1
CAPÍTULO 1 – INTRODUÇÃO AOS MICROCONTROLADORES.
1.1. – Introdução....................................................................................................................1-2
1.2 – Família de microcontroladores......................................................................................1.2
1.3 – Funções internas comuns à maioria dos modelos de PIC.............................................1.9
1.4 – Arquitetura e instruções...............................................................................................1.13
CAPÍTULO 2 – VISÃO GERAL DO MICROCONTROLADOR PIC16F84.

2.1 – Introdução......................................................................................................................2.1
2.2 – Características...............................................................................................................2.1
2.3 – Arquitetura interna do PIC16F84..................................................................................2.3
2.4 – Ciclo de instrução do PIC..............................................................................................2.4
2.5 – Diagrama de pinagem....................................................................................................2.6
CAPÍTULO 3 – ORGANIZAÇÃO DA MEMÓRIA DO PIC.

3.1 – Introdução......................................................................................................................3.1
3.2 – Organização da memória de programa (Flash).............................................................3.1
3.3 – Organização da memória de dados (RAM)...................................................................3.5
3.4 – Classificação dos Registros...........................................................................................3.6
CAPÍTULO 4 – PORTAS DE ENTRADA E SAÍDA.

4.1 – Introdução......................................................................................................................4.1
4.2 – Porta A e registro TrisA................................................................................................4.1
4.3 – Porta B e registro TrisB.................................................................................................4.3
CAPÍTULO 5 – ESTUDO DOS TIMERS.

5.1 – Módulo Timer 0.............................................................................................................5.1
CAPÍTULO 6 – INSTRUÇÕES DO PIC16F84.
6.1 – Introdução.......................................................................................................................6.1
6.2 – Conjunto de instruções do PIC16F84...........................................................................6.17
6.3 – Programação em Linguagem Assembly.......................................................................6.17
6.4 – Exercícios Propostos.....................................................................................................6.28
CAPÍTULO 7 – INTRODUÇÃO AO ARDUINO.
7.1- Introdução.........................................................................................................................7.1
7.2- Arduino UNO...................................................................................................................7.8
7.3-Introdução ao Arduino MEGA
2560.................................................................................7.14
ANEXO .................................................................................................................... ...............A-1

OSTENSIVO CIAA-117/092A
INTRODUÇÃO
1 – PROPÓSITO.
Esta publicação foi elaborada para dar orientação sobre o Curso de Introdução aos
Microcontroladores e seus circuitos.
Os assuntos nela contidos preenchem as exigências dos currículos, com o propósito

de nortear a aprendizagem por parte dos alunos, dando ênfase as competências
exigidas através da teoria e prática. Ferramenta útil no dia a dia em locais que
trabalhem com Microcontroladores e Microprocessadores.
2 – DESCRIÇÃO.
Esta publicação está dividida em 7 (sete) Capítulos, a saber.
Capítulo 1 - Introdução aos microcontroladores; Capítulo 2 – Microcontrolador
Microchip PIC16F84; Capítulo 3 – Organização da memória do PIC16F84; Capítulo
4 – Portas de entrada e saída; Capítulo 5 – Estudo do Timer; Capítulo 6 – Instruções
do PIC16F84; Capítulo 7 – Introdução ao Arduino.
3 - AUTORIA E EDIÇÃO.
Esta publicação é de autoria do SO–RM1-ET/QTE – ALMEIDA e foi elaborada e
editada, no CENTRO DE INSTRUÇÃO ALMIRANTE ALEXANDRINO (CIAA).
4 - DIREITOS DE EDIÇÃO.
Reservados para o CENTRO DE INSTRUÇÃO ALMIRANTE ALEXANDRINO.
Proibida a reprodução total ou parcial, sob qualquer forma ou meio.
5 – CLASSIFICAÇÃO.
Esta publicação é classificada, de acordo com o EMA-411 (Manual de Publicações da
Marinha) em: Publicação da Marinha do Brasil, não controlada, ostensiva, didática e
manual
CAPÍTULO 1
INTRODUÇÃO AOS MICROCONTROLADORES.

1.1 – INTRODUÇÃO.
Um sistema computacional é composto por uma unidade de processamento, memória e
portas de entrada/saída (I/O).
A maioria das pessoas limita o conceito de sistema computacional ao computador que
temos em casa, vulgo PC (Personal Computer). No entanto todo sistema que a partir de
dados de entrada, executa algum processamento mediante um programa armazenado em
uma memória gerando uma saída, é chamado de Sistema computacional.
Um Microprocessador é um decodificador de uma sequência de códigos binários
(programa). Os códigos que um Microprocessador é capaz de decodificar são chamados
de Instruções. Estas instruções são fornecidas pelo fabricante do chip (geralmente em
torno de 100), os usuários devem entendê-las e organizá-las de forma lógica na Memória
de Programa. Este conjunto de números binários que são armazenados na Memória de
Programa com o objetivo de colocar um Microprocessador em operação é chamado de
Código Objeto ou Código Fonte.
Figura 1.1: Diagrama de um modelo computacional

Na figura 1.1 os dados guardados em memória de programa representam as instruções e
as setas não preenchidas marcam as instruções que já foram executadas, a seta preenchida
aponta para a instrução corrente e é ela que produziu o código presente no Pórtico. Além
dos Pórticos outras posições de memória podem receber o resultado da operação
1-1
OSTENSIVO 1° REVISÃO
desenvolvida pela CPU. As instruções que se seguem serão executadas de acordo com a
lógica do programa.
O Processador ou Microprocessador ou Unidade Central de Processamento (CPU) irá ler e
executar a tarefa referente ao código, a partir da primeira posição de memória seguindo a
sequência lógica do programa. A CPU gera todos os sinais de controle e trabalha em
conjunto uma Unidade Lógica e Aritmética (ULA).
A ULA é a parte mais importante de uma unidade de processamento, é neste setor que são
efetuadas as operações de cálculo. Na maioria das arquiteturas, as ULA são projetadas
com dois operadores, sendo um deles chamado de Acumulador (AC). Os resultados das
operações normalmente retornam ao Acumulador.
Este conjunto que integra o Microprocessador e estruturas de memória carregadas de

instruções que proporcionam algum tipo de atividade lógica é chamado de computador.
O bloco computacional responsável para apontar o código a ser executado pelo
microprocessador é chamado de Program Conter (PC), que é um contador binário de 0 a
2n com recarga paralela. O “n” é o número de bits do contador necessário ao
endereçamento de toda memória. Logo, podemos deduzir que o PC é na verdade um
registrador de endereço de memória de programa e deverá ser incrementado (próximo
endereço) ou desviado (endereço definido pela instrução - recarga) logo após a execução
da instrução anterior.
O bloco responsável em trocar dados com o ambiente externo ao chip é chamado de
Pórtico de I/O (In/Out). Os dispositivos ligados aos pórticos são chamados de Periféricos.
O objetivo de qualquer microcontrolador é de comandar ou trocar dados com os
Periféricos.
1-2
Todos os sinais digitais internos ou disponibilizados através dos pórticos utilizam vias
chamadas de barramento que são classificadas da seguinte forma:
 De Endereços (Address Bus);
 De Dados (Data Bus) e
 De Controle (Control Bus).
O Barramento de Endereços carrega o endereço de memória que a CPU quer selecionar.
O Barramento de Dados envia ou recebe um dado correspondente ao endereço de
memória selecionado.
O Barramento de Controle organiza os blocos para que as operações ocorram.
O tempo que leva desde a leitura de uma instrução até a sua execução pela CPU depende
do Ciclo de Máquina. Então podemos definir que o Ciclo de Máquina é o período que um
processador leva para decodificar um código básico.
O código básico é uma instrução que requer a menor complexidade de hardware:
LEITURA, OPERAÇÃO BÁSICA e ENVIO.
O clock é o sinal que sincroniza todas as tarefas de um processador. A cada descida ou
subida de clock um conjunto de tarefas foi cumprido.
Em qualquer sistema computacional, todos os componentes físicos são chamados de
Hardware, já o conjunto de instruções que são carregadas nas estruturas de memória é

chamado de Software.
Microcontroladores é o nome dado aos chips que possuem em sua estrutura interna
unidades computacionais completas e independentes para utilização em tarefas simples
quando comparadas a uma arquitetura computacional como o computador pessoal. O
microcontrolador possui como objetivo principal o processamento e controle dos dados
em “tempo real”. Por serem independentes, normalmente possuem uma quantidade
limitada de memória e por isso só são capazes de portar pequenos programas para
aplicações bem definidas e específicas.
A figura 1.2 representa os blocos internos de um microcontrolador. Nela podemos
observar os blocos básicos que são as memórias, os pórticos e o oscilador e também os
blocos considerados opcionais que são o conversor A/D, a porta de comunicação UART e
o Timer.
1-3
Figura 1.2: Diagrama em bloco de um microcontrolador
Figura 1.3
1-4
Para as Memórias de dados são usadas memórias voláteis, seu uso é restringido ao
armazenamento momentâneo de dados oriundos do processo natural do programa.
Tipos:
 SRAM (Static RAM)
 DRAM (Dynamic RAM)
A Memória de Programa uma vez gravada não perde mais a informação, por isso é
utilizada para guardar o programa (instruções) que define o funcionamento do Hardware
ou outros dados permanentes. O tipo de memória mais usada atualmente para Memória de
Programa é a EEPROM (Electrically Erasable Programmable Read-Only Memory).
O uso de memória RAM ao invés de ROM para o espaço da Memória de Dado é
justificado pela alta velocidade que as memórias RAM possuem, principalmente na
escrita. A operação natural de um microcontrolador exige constantes escritas e leituras na
Memória de Dados, enquanto na Memória de Programa são normalmente executadas
leituras sequenciais.
O Timer é um contador que tem a função básica de marcar tempos. Na utilização do
Timer é fundamental o programador saber o período do clock do sistema. É comum
durante a criação de um programa surgir à necessidade da marcação de um tempo para a
execução de uma determinada tarefa.
Os Pórticos de I/O são registradores com entrada e saída paralela que possuem a função
de trocar dados com os periféricos.
O Pórtico Serial USART é uma estrutura de hardware destinada a trocar dados do
microcontrolador com os periféricos. É chamada serial porque os dados em 8 bits são
enviados sob um protocolo (regra) e utilizam um único fio (um bit de cada vez). O
protocolo USART (Universal Assíncrono Recepção e Transmissão) é utilizado em toda
família AVR. Apesar de antigo, ainda é o protocolo assíncrono mais utilizado por
microcontroladores.
Existe um espaço da Memória de Dados que o programador do microcontrolador utiliza
para guardar ou ler dados que interagem diretamente com algum seguimento específico de
hardware podendo até alterar sua configuração, o próprio circuito do timer precisa de ler
alguns endereços específicos para operar no modo adequado a necessidade do
programador. Estes endereços são chamados de Registradores de Funções Especiais
1-5
(SFR). A possibilidade de alterar as configurações de hardware o torna versátil e utilizável

para aplicações distintas. Um exemplo simples de hardware versátil é de poder utilizar um
dos pinos do chip como entrada de dados em determinado momento e saída em outro.
Basta para isso saber durante o programa configurar corretamente os SFR relacionados ao
Pórtico de I/O. O ato de configurar nada mais é do que escrever o código binário correto
para a função esperada, este código é conhecido através do manual ou DataSheet do
microcontrolador. Os fabricantes de microcontroladores normalmente apelidam os SFR de
acordo com sua função, para que o programador utilize estes rótulos no desenvolvimento
do programa.
A programação se inicia com a montagem lógica das instruções que são fornecidas pelo
fabricante, essas instruções são apresentadas na forma de mneumônicos. O conjunto de
rótulos e/ou mneumônicos organizados em um editor de texto para desenvolver um
programa computacional é chamado de código fonte. Um mneumônico pode representar
um único código ou um conjunto de códigos, quando ele representa um código de
máquina dizemos que a programação é desenvolvida em linguagem de baixo nível titulada
como Linguagem Assembly. O software que transforma esta linguagem em seu respectivo
código de máquina é chamado de Assembler.
Existem linguagens que um mneumônico representa uma ação lógica e não mais um único
código de máquina. Para estas linguagens o termo mneumônico e substituído pelo termo
“comando” e representa um conjunto de códigos de máquina. A montagem destes códigos
é chamada de compilação e o resultado depende de vários fatores que envolvem desde a
lógica dos comandos até a técnica de compilação. Essas linguagens são classificadas
como Linguagem de Alto Nível (Linguagem C) e Linguagem de Baixo Nível (Assembly).
Assim, podemos definir microcontroladores como sendo um sistema computacional
integrado, que se caracterizam por incorporarem internamente em um único chip, CPU,
memórias de programa e dados e vários periféricos como Timers, Watchdog,
Comunicação serial, Conversor analógico/digital, Gerador de PWM, etc. Fazendo com
que a aplicação final fique extremamente compacta
1.2 - FAMÍLIAS DE MICROCONTROLADORES.
1-6
1.2.1 - Família 8051.

Um dos micros mais usados em aplicações industriais. Sua base inicial foi lançada no
começo da década de 80 pela INTEL. Vários fabricantes compraram sua patente e
começaram a produzir componentes que tem como base está família.
Muitos microcontroladores são conhecidos pelos desenvolvedores de projetos, no
Brasil podemos citar os seguintes:
Microcontroladores da família ATmega (ATMEL)
Microcontroladores da família 8051 (INTEL e outros fabricantes como a ATMEL)
Microcontroladores da família PIC (MICROCHIP)
Microcontroladores da família COP8 (NATIONAL SEMICONDUTORES)
Microcontroladores da TEXAS, exemplo: MSP430F13x/14x
Microcontroladores da HOLTEK, exemplo: HT48500
Microcontroladores da MOTOROLA.
1.2.2 - Família PIC (Peripheral Interface Controller) Interface Controladora de
Periféricos.
Fabricado pela Microchip e todos os modelos foram desenvolvidos a partir da mesma
filosofia de produto. Assim, os códigos das instruções são extremamente compatíveis
entre todos os modelos, permitindo a migração de um modelo de micro para outro sem
necessidade de grandes alterações no programa que estava sendo utilizado.
Esses micros começaram a ser comercializados na década de 70 e vem sendo aprimorados
e criado novas famílias, que possuem recursos que atendem plenamente às necessidades
de qualquer projeto desde as simples até as mais complexas aplicações e o que é mais
importante, com custo baixo.
Podemos classificar todos os modelos de PIC em três grandes grupos: Pequenas, médias e
grandes aplicações. Os modelos para pequenas aplicações possuem uma ou duas portas de
estrada/saída e memória de programação Flash de pequena capacidade. Eles estão
disponíveis em encapsulamentos DIP de 8, 16, 18 e 20 pinos. Já os modelos para
aplicações médias e grandes possuem cinco ou mais portas de entrada ou saídas, possuem
internamente comparadores analógicos, conversores A/D, portas seriais e vários
temporizadores, alguns possuem memória EEPROM de fácil programação. Estão
disponíveis em encapsulamentos DIP de 28 e 40 pinos.
1-7
Todos os modelos da família PIC possuem um conjunto de instruções e características

semelhantes.
1.3 – FUNÇÕES INTERNAS COMUNS À MAIORIA DOS MODELOS DE PIC.

Todos os modelos de microcontroladores PIC possuem uma arquitetura similar, embora
suas características sejam bem diferentes, pois depende do modelo que se está trabalhando.
Uma descrição geral pode ser perfeitamente aplicável a qualquer um dos tipos existentes.
1.3.1 - Unidade de memória.
Basicamente são de dois tipos:
a) ROM (memória de programa) - armazena instruções do programa e pode ser do tipo
EPROM, EEPROM ou FLASH.
b) RAM - memória de dados (usada como registros).
Obs: Alguns modelos possuem uma EPROM adicional como memória de dados.
1.3.2 - Unidade Central de Processamento (CPU).
Coordena o trabalho dos outros blocos e executa o programa do utilizador. Possui
memória interna chamada de registros. Estes registros são usados pela CPU para
armazenar dados temporários.
1.3.3 – Barramentos.
É usado na interligação entre a CPU e outros blocos. Fisicamente corresponde a um grupo
de 8, 16 ou mais condutores. Existem os barramentos de dados e de endereços. O número
de linhas do barramento de dados depende da largura da palavra de dados e normalmente
se liga a todos os blocos dentro do micro. O número de linhas do barramento de endereço
depende da quantidade de memória que se deseja endereçar, normalmente, serve para
transmitir endereços da CPU para a memória.
1.3.4 - Unidade de entrada/saída.

São ligações físicas, comumente chamadas de Portas, que liga o microcontrolador ao
mundo exterior. Existem portas de entrada, saída e entrada/saída. Quando se trabalha com
essas portas, é necessário selecionar qual a porta em que vamos enviar ou receber dados.
1-8
A porta funciona como um local de memória armazenando o dado que chega ou o dado
que sai.
1.3.5 - Comunicação série.

Na comunicação com o mundo exterior, um dos inconvenientes é o número de linhas que
é necessário para transferir dados, principalmente em longas distâncias onde o número de
linhas vezes o número de quilômetros afeta a economia do projeto. Assim, podemos usar
o barramento série com uma linha para receber, outra linha para transmitir e uma terceira
usada como referência das duas anteriores. Além disso, precisamos definir as regras
usadas na troca de dados, a isto chamamos de protocolo.
Na comunicação paralela, os dados são transmitidos de uma só vez enquanto na
comunicação série a transmissão é bit a bit.
Depois que os dados são recebidos eles são lidos e armazenados na memória. Na
transmissão, os dados vêm da memória através do barramento para o local de transmissão
e daí para a unidade de recepção de acordo com o protocolo.
1.3.6 - Unidade de temporização.

A unidade básica do temporizador é um contador que é na realidade um registro cujo
conteúdo aumenta de uma unidade num intervalo fixo de tempo, assim anotando o seu
valor durante os instantes de tempos T1 e T2 e calculando sua diferença, saberemos o
tempo decorrido.
1.3.7 – Watchdog.
O watchdog é um recurso disponível no PIC que parte do princípio de que todo sistema é
passível de falha. Se todo sistema pode falhar, cabe ao mesmo ter recursos para que, em
ocorrendo uma falha, algo seja feito de modo a tornar o sistema novamente operacional.
No nosso computador, de um modo geral, existe um botão de reset que deve ser usado
sempre que o sistema travar por qualquer motivo, no entanto, este botão não existe no
micro.
1-9
Dentro do PIC existe um contador incrementado por um oscilador (RC) independente.

Toda vez que este contador extrapola o seu valor máximo retornando a zero, é provocado
a reinicialização do sistema (reset).
Se o sistema estiver funcionado da maneira correta, de tempos em tempos uma instrução
denominada Clear Watchdog Timer (CLRWDT) zera o valor deste contador, impedindo o
mesmo chegar ao valor máximo. Desta maneira o Watchdog somente irá "estourar"
quando algo de errado ocorrer (travando o sistema). O período normal de estouro do
Watchdog Timer é de aproximadamente 18 ms. No entanto, algumas vezes este tempo é
insuficiente para que o programa seja normalmente executado. A saída neste caso é alocar
o recurso de um preescaler de modo a aumentar este período.
1.3.8 - Conversor analógico – digital.

Como os sinais dos periféricos são analógicos é preciso convertê-los para o formato
digital, a fim de que tais sinais possam ser compreendidos pelo micro, o que é feito por
um conversor A/D.
1.3.9 – Programa.
Programação é o ato de escrever um programa.
Programa é um conjunto completo de instruções que descreve exatamente o que fazer a
cada passo de sua operação. Este conjunto de instruções é preparado por uma ou mais
pessoas, programadores, para cada tarefa que o computador deva fazer. Os programas são
colocados na memória na forma binária, tendo cada instrução um código único. O micro
toma estes códigos de instruções da memória um por vez e realiza a operação associada
ao código.
Programar um micro para que este execute uma tarefa inteligente, é criar uma sequência
de códigos, numa linguagem que o mesmo entenda, denominada linguagem de máquina.
O programador será a pessoa responsável pela associação desta sequência de códigos que
implemente aplicações, para que outros usuários possam utilizar.
A linguagem de programação compreende um conjunto de regras, símbolos e palavras
especiais, que resulta em um programa. Esta linguagem poderá ser denominada como
linguagem de alto nível ou de baixo nível. A linguagem de alto nível se aproxima mais do
1-10
pensamento humano, enquanto a linguagem de baixo nível está mais próxima do tipo de
dado manuseado pelo micro.
Essas linguagens possuem vantagens e desvantagens em suas aplicações. A linguagem de
alto nível, como C, Basic, Visual C, etc é composta por sentenças estruturadas e com
procedimentos e funções independentes, menores, que permitem subdividir um programa
longo em partes que facilitam a compreensão do mesmo. Estes procedimentos ou funções
poderão ser utilizados em outros programas a serem desenvolvidos. Entretanto, a tradução
do programa feito em linguagem de alto nível para o código de máquina a ser usado pelo
micro não é direta e necessita de um tradutor, denominado compilador, que irá gerar
longas sequências de código de máquina para o micro.
A linguagem de baixo nível permite o desenvolvimento de programas com códigos bem
próximos aos códigos de máquina, o que resulta na geração do código de máquina
normalmente mais compacta, ocupando uma menor área de memória, que será executado
em maior velocidade pelo micro. A tradução da linguagem de baixo nível para o código
de máquina será feita manualmente pelo programador ou através de um programa
denominado assemblador. A linguagem de baixo nível é denominada linguagem
Assembly.
A tarefa de programação pode ser executada em várias linguagens tais como o Assembler,
C e Basic que são as mais usadas. O Assembler pertence ao grupo das linguagens de
baixo nível que implicam em um trabalho de programação lento, no entanto, ocupam
menos espaço em memória e uma maior rapidez na sua execução. Programas na
linguagem C são mais fáceis de escrever e compreender, no entanto, são mais lentos na
execução que o Assembler. Basic é a mais fácil de todas para se aprender e suas
instruções são semelhantes à maneira de um ser humano se exprimir, mais similar à C, é
também de execução mais lenta.
Depois que o programa foi escrito é introduzido no micro que recebe alimentação a fim de
que possa trabalhar corretamente.
1-11
Figura 1.4 - Compilador transforma o programa fonte em instruções de máquina.
Para a família PIC usa-se o programa denominado MPLAB, que contém vários programas
integrados em um só.
1.3.10 - Contador de Programa (PC).

Estabelece o fluxo de controle dos direcionamentos da memória que o código do
programa contém.
Na maioria das instruções, o PC incrementa-se automaticamente para apontar a instrução
seguinte, no entanto, quando a instrução é de salto do tipo direto, o valor que é carregado
no PC provém de uma parte dos bits do código OP (operando) da própria instrução.
Nos saltos relativos, a ULA soma o valor que o PC contém o do salto, e volta a ser
armazenado no PC; por conseguinte esse será o novo endereço do salto. Disto deduz-se
que o PIC possui 3 tipos de endereçamento (direcionamento):
a) Imediato - o valor do dado está contido no OP da instrução
b) Direto - o endereço da área de memória de dados onde se encontra o operando está
contido no OP da instrução.
c) Indireto - endereço de dados que o operando guarda está contido em um registro.
1.4 – ARQUITETURAS E INSTRUÇÕES.

Dois tipos de arquiteturas são as mais utilizadas em microcontroladores e
microprocessadores:
1-12
1.4.1 - Arquitetura Von-Neumann.

Na arquitetura Von-Neumann, os barramentos de dados e endereços são compartilhados
entre memórias de programas e de dados na comunicação com a CPU. Nesse tipo de
arquitetura, quando a CPU está acessando a memória de programa não pode acessar a
memória de dados, porque usa os mesmos barramentos para as duas memórias (Fig.1.2).
Isto faz com que seja necessária uma quantidade maior de ciclos de máquina para
executar uma instrução.
Nesta arquitetura, para fazer uma operação de soma de dois números, precisamos de um
microcódigo. O microcódigo nada mais é do que uma sequência de operações que fará
com que a ULA faça a operação de soma. Assim, para somarmos dois números que serão
inseridos na entrada do microcontrolador e obtermos a resposta em sua saída, teremos que
fazer várias operações.
1.11
Figura 1.5 – Arquitetura Von-Neumann

1.4.2 - Arquitetura Harvard.
Sua principal característica é possuir dois barramentos um para dados e outro para
instruções, como visto na Figura 1.3.
Nesta arquitetura, para fazer uma operação de soma de dois números, é necessário apenas
um ciclo de máquina, uma vez que não são usados microcódigos, pois as operações são
feitas diretamente em cada um dos blocos e através dos barramentos de dados e de
instruções.
1-13
A vantagem disto é que, enquanto uma instrução é processada, outra já pode estar
executando o seu ciclo de busca, carregando assim, a próxima instrução. Isto faz com que
seja necessária uma quantidade menor de ciclos de máquina para executar uma instrução.
Esta arquitetura permite o processamento, ao mesmo tempo, de um ciclo de busca e um
ciclo de execução. Assim, a cada ciclo de máquina existirá uma instrução pronta para ser
executada. Este sistema de busca/execução é conhecido como Segmentação ou Pipeline.
Figura 1.6 – Arquitetura Harvard.

1.4.3 – Instruções.
As instruções estão ligadas ao tipo de arquitetura utilizada no microcontrolador, assim
temos:
a) Instruções CISC (Complex Instruction Set Computing) - Computação com
Conjunto Complexo de Instruções.
Para a arquitetura Von-Neumann, usam-se instruções CISC. São complexas
internamente, pois um simples comando de mover uma informação da porta de
entrada para a porta de saída necessitará de vários clocks, diversos ciclos de máquina
e precisará de um microcódigo para controlar a execução de cada uma das instruções.
1-14
b) Instruções RISC (Reduced Instruction Set Computing) - Computação com

Conjunto de Instruções Reduzidas.
Para a arquitetura Harvard, usam-se instruções RISC. São reduzidas porque o próprio
hardware interno do microcontrolador já está montado de maneira a, com um único
ciclo de máquina, fazer uma busca de nova instrução e executar a instrução que foi
buscada anteriormente, não necessitando de microcódigo para controlar a execução
das instruções.
c) Comparação CISC/RISC.
I) O RISC possui menor quantidade de instruções que o CISC com a mesma
capacidade de processamento.
II) Instruções fáceis de serem memorizadas no RISC.
III) Os programas se tornam maiores no RISC, pois nem todas as instruções
disponíveis para o CISC estão disponíveis para o RISC.
IV) Instruções que faltam no RISC devem ser criadas pelo programador, via software,
que deve ter bastante experiência em termos de programação.
Obs: A arquitetura do PIC segue o modelo Harvard, onde a CPU usa barramentos
diferentes com as memórias de instruções (programa) e de dados, e se tem acesso
simultaneamente a estas duas memórias. Além de maior velocidade e usar um
número reduzidos de instruções (RISC) é possível usar instruções com mais de 8 bits.
Em geral, uma instrução é executada em um único ciclo de máquina (corresponde a 4
ciclos de clock). Usa a técnica de Segmentação ou Pipeline e instruções Ortogonais
(contêm a fonte e o destino dos dados)
d) Entendendo instruções CISC/RISC.

Quando um novo microprocessador é fabricado, aumenta-se o seu conjunto de
instruções para que ele se torne mais poderoso.
Na construção de um novo processador, uma nova instrução substitui um grupo inteiro
de instruções que antes eram necessárias para a execução de uma determinada tarefa.
Para escrever um programa fica mais fácil, pois não há a necessidade de escrever um
pequeno programa (sub-rotinas) para executar o que a nova instrução fazia sozinha. Na
1-15
verdade, o pequeno programa continua sendo necessário só que ele já está escrito
dentro do microprocessador e que executará a ação quando uma determinada instrução
for acionada. Estes programas são armazenados em uma área do microprocessador
chamada de Microcódigo.
Um novo processador fabricado possuirá um maior conjunto de instruções, maior área
de microcódigo e fisicamente serão maiores.
Quando uma instrução é dada ao microprocessador, seu decodificador de instruções
verifica, no conjunto de instruções, se ela é válida e assim, executa ou não o
subprograma referente à instrução dentro do microcódigo. Quanto maior o conjunto de
instruções, mais lento ficará o microprocessador na procura da validade e, portanto, na
execução efetiva da instrução. Isto vai de encontro ao que imaginamos que um
processador mais avançado será muito mais rápido.
Para compensar a demora real um dos recursos usados para aumentar o desempenho é
a técnica de Pipeline. Enquanto uma área dentro do microprocessador está terminando
de executar uma instrução, a outra já estará lendo e decodificando a próxima instrução,
pois a execução e a decodificação da instrução ocorrem em áreas distintas do
microprocessador.
Outras técnicas também usadas são o cachê de memória, integração de circuitos de
apoio dentro do microprocessador, arquitetura super escalar, previsão de desvio, etc.
O aumento cada vez maior do conjunto de instruções dos novos microprocessadores
necessita também de novos recursos para aumentar seu desempenho, além disso,
chegou-se à conclusão de que só 20% das instruções, no geral, são realmente usadas
pelos programadores.
Com isso, surgiu a ideia de construção de microprocessadores com um conjunto
reduzido de instruções (RISC) e ainda a eliminação do microcódigo.
Para que isso aconteça devemos lembrar que instruções CISC não são padronizadas.
Apesar de existir, por exemplo, instruções MOV diferentes, cada uma é decodificada
de modo diferente, interpretada pelo microcódigo de maneira diferente, demora tempos
diferentes dentro do microprocessador e requer uma quantidade de parâmetros que
variará conforme o tipo de instrução (exemplo, MOV AL, precisa de dados de 8 bits,
1-16
enquanto MOV AX precisa de dados de 16 bits). A solução encontrada foi a completa

padronização.
A programação de um microprocessador RISC tende a ser mais complexa, por conter
menos instruções em comparação com o CISC equivalente. Quando uma instrução
mais complexa é necessária, o programador deverá criar um pequeno programa (sub-
rotina) com a tarefa que ele pretende executar, como acontecia com os
microprocessadores mais rudimentares. Mesmo com essa sub-rotina sendo executada
fora do microprocessador, ele será mais rápido do que se fosse executada dentro do
microprocessador, no microcódigo, isto graças ao “enxugamento” que foi feito no
processador.
Como essas arquiteturas são incompatíveis entre si (precisam de decodificador CISC
ou RISC), alguns microprocessadores podem usar uma arquitetura híbrida CISC/RISC.
Na execução das instruções RISC, é usada a técnica de Segmentação (Pipeline) o que
permite ao processador realizar duas funções ao mesmo tempo (execução da instrução
e localização do código da instrução seguinte em um único ciclo).
De um modo geral, essas instruções são ortogonais onde qualquer uma delas pode
controlar a fonte e o destino dos dados.
1-17
CAPÍTULO 2
VISÃO GERAL DO MICROCONTROLADOR MICROCHIP PIC16F84.
2.1 - INTRODUÇÃO.
O PIC16F84 da Microchip pertence ao tipo de processador RISC que é um processador
com instruções reduzidas e todas possuem o mesmo tempo de processamento, exceto
em instruções de salto. Este tipo de processador possui arquitetura Harvard o que
significa trabalhar com as memórias de programa e de dados de forma separadas.
2.2 – CARACTERÍSTICAS.
2.2.1 - As principais características deste microcontrolador são:
a) Processador com arquitetura Harvard e Instruções RISC avançada.
b) Jogo de 35 instruções com palavra de 14 bits. Todas elas executadas em um ciclo
de instrução exceto instruções de salto que demoram 2 ciclos.
c) Frequência externa máxima de 10 MHz. O PIC16F84A opera até 20Mhz
d) Ciclo de instrução de 400ns.
e) Memória Flash de programa com capacidade de 1K x 14.
f) Memória RAM de dados de 256 x 8 (136 x 8 para o programador).
g) Memória EEPROM de dados de 64 bytes (64 x 8).
h) Possui 4 fontes de interrupções internas e externas.
i) Pilha com 8 níveis.
j) Modos de endereçamento: direto, indireto e imediato.
k) Resets: Power-On Reset (POR), Power-up Timer (PWRT), Oscilador Start-upTimer
(OST) e Brown-out Reset (BOR)
l) Watchdog Timer (WDT) com seu próprio oscilador RC confiável.
m) Código de proteção programável.
n) Modo Sleep de baixo consumo.
o) Opções de seleção do oscilador.
p) Tecnologia CMOS de alta velocidade e baixo consumo para as memórias
Flash/EEPROM.
q) Larga faixa de voltagem de alimentação: 2V a 6,0V (típico 5V).
r) High Sink/Source current: 25mA.
2-1
s) Baixo consumo de potência (< 0,6 mA a 3 V e 4 MHz).

t) Portas I/O: A (5 pinos I/O) e B (8 pinos I/O).
2.3 - ARQUITETURA INTERNA DO PIC16F84.

Observamos que o micro possui vários blocos internos: processador, memória de
programa, memória de dados, periféricos, contadores, etc.
256x8
Figura 2.1: Diagrama de blocos do PIC16F84.
2-2
2.3.1 - No diagrama podemos identificar:

a) Memória de Programa, (FLASH) de 1K x 14 (1024 posições ou endereços de 14
bits cada).
b) Memória de Dados, (RAM) de 68 x 8 (68 posições ou endereços de 8 bits).
c) Memória EEPROM, 64 posições e 8 bits.
d) Processador propriamente dito é formado pela ALU (Unidade Lógica e
Aritmética) e o Registro de trabalho (W).
e) Periféricos I/O: Portas A, B.
f) Contador de Programa (PC) de 13 bits capaz de direcionar até 1K de memória
Flash de programa (14 bits). Este registro aponta sempre a próxima instrução a ser
executada o que nem sempre é sequencial.
g) Pilha ou Stack possui 8 níveis e não pode ser lida ou escrita diretamente. Funciona
como um buffer temporal onde se guarda o Contador de programa cada vez que se
solicita uma chamada a um procedimento I/O (incluindo interrupções). Quando de
uma instrução CALL, o endereço do PC é armazenado na Pilha para posterior
recuperação quando da primeira instrução RETURN, RETLW ou RETFIE que
encontrar.
h) Registro de Instruções, registrador de 14 bits que se carrega cada vez que a ALU
solicita uma nova instrução a ser processada.
i) Decodificador de instruções: identifica que operação será realizada; recebe a

instrução da memória via RI e gera os códigos do microprograma.
j) Status Reg. (Registro STATUS) que é um registro encarregado de anotar o estado

atual do sistema, todas as vezes em que uma instrução for executada. Cada um
desses eventos está associado a um bit desse registro.
k) FSR reg, (Registro FSR) que cumpre uma função similar à do Contador de
programa, direcionando, neste caso, para a RAM. O FSR é um ponteiro direcionado
para a RAM.
l) MUX, a existência de MUX se deve ás diferentes fontes de dados encontradas. Mas
adiante explicaremos sobre eles.
m) TMR0 (temporizador/contador de eventos, de 8 bits e prescaler de 8 bits).
2-3
2.4 - CICLO DE INSTRUÇÃO NO PIC.

O clock interno deste micro é equivalente ao clock externo dividido por 4.
CKint = CKext/4
Com um cristal de 4MHz a frequência interna é de 1MHz, com isso, o ciclo de
máquina (CM ou Tcy) será:
TCY = 1/CKint = 1us.
Isto se deve ao fato de que para a execução de uma única instrução pelo micro, várias
operações precisam ser realizadas. Como não existe capacidade de processamento
paralelo, essas operações são executadas em subciclos do ciclo de máquina originados
pela divisão do clock interno. Esses subciclos formam as fases Q1, Q2, Q3 e Q4.
O Contador de programa (PC) é incrementado automaticamente na fase Q1 do ciclo de
máquina e a instrução seguinte é buscada da memória de programa e armazenada no
registrador de instruções no ciclo Q4. Ela é decodificada e executada no próximo ciclo,
no intervalo de Q1 e Q4, sendo trocadas informações com a memória de dados e o
registro W (Work) sempre que necessário.
Essa característica de buscar a informação em um ciclo de máquina e executá-la no
próximo é conhecida como Pipeline (seguimentação).
Ela permite que quase todas as instruções sejam executadas em apenas um ciclo,
gastando assim 1μs para a frequência de 4MHz e tornando o sistema muito mais rápido.
As únicas exceções são para as instruções que geram saltos no programa, como
chamadas de sub-rotinas e retornos. Ao executar essas instruções o Pipeline deve ser
primeiramente limpo para depois poder ser carregado novamente com o endereço
correto, consumindo para isso dois ciclos de máquina.
De um modo geral, as instruções são ortogonais onde qualquer uma delas pode controlar
a fonte e o destino dos dados.
Normalmente um ciclo de instrução consome 4 ciclos de clock. Isto não se aplica às
instruções de salto, pois não se conhece o endereço da instrução seguinte até completar a
bifurcação, pelo que esta operação necessita de 2 ciclos de instrução.
2-4
Figura 2.2: Diagrama temporal do ciclo de máquina.
Ao ciclo de instrução abaixo, foram adicionadas 5 instruções como exemplo: Carregar

W com 55h, mover este valor para PORTB, chamar uma subrotina e cumprir essa
subrotina. A instrução 3 não será cumprida, pois a execução seguinte é uma subrotina.
Figura 2.3: Programa com os ciclos de extração e execução.
2-5
2.5 - DIAGRAMA DE PINAGEM.
Figura 2.4: Diagrama de pinagem.
Pino nº 1, RA2 Segundo pino do porto A. Não tem nenhuma função adicional.
Pino nº 2, RA3 Terceiro pino do porto A. Não tem nenhuma função adicional.
Pino nº 3, RA4 Quarto pino do porto A. O TOCK1 que funciona como entrada do
temporizador, também utiliza este pino.
Pino nº 4, MCLR Entrada de reset e entrada da tensão de programação do
microcontrolador
Pino nº 5, Vss massa da alimentação.
Pino nº 6, RB0, bit 0 do porto B. Tem uma função adicional que é a de entrada de
interrupção.
Pino nº 7, RB1 bit 1do porto B. Não tem nenhuma função adicional.
Pino nº 8, RB2 bit 2 do porto B. Não tem nenhuma função adicional.
Pino nº 12, RB6 bit 6 do porto B. No modo de programa é a linha de clock
Pino nº 13, RB7 bit 7 do porto B. Linha de dados no modo de programa
Pino nº 14, Vdd Pólo positivo da tensão de alimentação.
Pino nº 15, OSC2 para ser ligado a um oscilador.
Pino nº 16, OSC1 para ser ligado a um oscilador.
Pino nº 17, RA0 bit 0 do porto A. Sem função adicional.
Pino nº 18, RA1 bit 1 do porto A. Sem função adicional
2-6
CAPÍTULO 3.
ORGANIZAÇÃO DA MEMÓRIA DO PIC.
O PIC16F84 possui dois blocos de memórias separados (dados e programa), agrupados
em três tipos de memórias, que são:
a) Memória de Programa Flash – armazena o programa que se escreveu.
b) Memória de Dados:
I) RAM - parte é usada como registros SFR é parte é de dados como os registros GPR.
II) Memória de Dados EEPROM – armazena dados que não podem ser perdidos quando
o micro fica sem alimentação. Esta memória de dados possui capacidade de 64 x 8.
Obs: A memória EEPROM e os Registros de Uso Geral (GPR) na RAM, constituem o
bloco para dados.
3.2 - Organização da Memória de Programa (Flash).
A Memória de Programa é uma memória regravável eletronicamente do tipo Flash e
capacidade de 1K x 14 bits. Ela pode ser acessada por software, possibilitando que o
programa seja reescrito dinamicamente, ou ainda, que ela seja usada como expansão da
memória EEPROM de dados.
3.2.1 - Vetor de Reset.
Usa o primeiro endereço da Memória de programa (0x0000) que será executado após um
Start-up ou Reset.
3.2.2 - O Vetor de Interrupção.
Este micro possui 14 tipos de interrupções diferentes. Entretanto, quando qualquer uma
delas acontece (se habilitadas), o programa será desviado para o vetor de interrupção
endereço 0x0004.
3.2.3 - Mapa da Memória de Programa.
Para dispositivos com mais de 512 bytes de memória de programa usa-se um esquema
de páginas
O PIC16F84 tem dois blocos de memória separados, um para dados e o outro para o
programa. A memória EEPROM e os registos de uso genérico (GPR) na memória RAM
constituem o bloco para dados e a memória FLASH constitui o bloco de programa.
3-1
Memória de programa
A memória de programa é implementada usando tecnologia FLASH, o que torna
possível programar o microcontrolador muitas vezes antes de este ser instalado num
dispositivo, e, mesmo depois da sua instalação, podemos alterar o programa e
parâmetros contidos. O tamanho da memória de programa é de 1024 endereços de
palavras de 14 bits, destes, os endereços zero e quatro estão reservados respectivamente
para o reset e para o vector de interrupção.
Memória de dados
A memória de dados compreende memória EEPROM e memória RAM. A memória

EEPROM consiste em 64 posições para palavras de oito bits e cujos conteúdos não se
perdem durante uma falha na alimentação. A memória EEPROM não faz parte
diretamente do espaço de memória, mas é acedida indiretamente através dos registos
EEADR e EEDATA. Como a memória EEPROM serve usualmente para guardar
parâmetros importantes (por exemplo, de uma dada temperatura em reguladores de
temperatura), existe um procedimento estrito para escrever na EEPROM que tem que ser
seguido de modo a evitar uma escrita acidental. A memória RAM para dados, ocupa um
espaço no mapa de memória desde o endereço 0x0C até 0x4F, o que corresponde a 68
localizações. Os locais da memória RAM são também chamados registos GPR (General
Purpose Registers = Registos de uso genérico). Os registos GPR podem ser acedidos
sem ter em atenção o banco em que nos encontramos de momento.
Registos SFR
Os registos que ocupam as 12 primeiras localizações nos bancos 0 e 1 são registos

especiais e têm a ver com a manipulação de certos blocos do microcontrolador. Estes
registos são os SFR (Special Function Registers ou Registos de Funções Especiais).
3-2
Local de memória usado

pelo programador para
criar registros de
propósitos gerais
Organização da memória no microcontrolador PIC16F84

Bancos de Memória
Além da divisão em ‘comprimento’ entre registos SFR e GPR, o mapa de memória está
também dividido em ‘largura’ (ver mapa anterior) em duas áreas chamadas ‘bancos’. A
seleção de um dos bancos é feita por intermédio dos bits RP0 e RP1 do registo STATUS.
3-3
Exemplo:
bcf STATUS,RP0
A instrução BCF “limpa” o bit RP0 (RP0 = 0) do registo STATUS e, assim, coloca-nos
no banco0.
bsf STATUS,RP0
A instrução BSF põe a um, o bit RP0 (RP0 = 1) do registo STATUS e, assim, coloca-nos
no banco1.
3.2.5 - Pilha (Stack).

É um local, fisicamente separado da memória de programa, onde serão armazenados os
endereços de retorno quando utilizamos instruções de desvio para rotinas de chamadas.
Quando o programa é desviado para o começo de uma rotina através da instrução
correta (CALL ou Interrupção), o endereço seguinte ao ponto que estava sendo
executado é armazenado na Pilha para que, ao final da sub-rotina, o programa possa
retornar novamente ao ponto em que estava. Portanto, todas as instruções CALL antes
de serem executadas, salvam na Pilha o PC inicial incrementado de uma unidade.
Quando posteriormente encontrar e executar uma instrução RETURN (RETLW ou
RETFIE), o valor da Pilha é devolvido ao PC para que prossiga a execução normal do
programa.
Os PIC16F84 possuem oito níveis de Pilha com endereços de 13 bits, assim é possível
armazenar oito endereços de retorno, possibilitando oito desvios consecutivos. A pilha
não pode ser lida ou escrita diretamente. Se houver chamada para mais de oito sub-
rotinas, o programa apresentará erro, pois o primeiro endereço armazenado será
substituído pelo último e assim, haverá perda do endereço de retorno.
Como já visto, a função básica da Pilha é guardar o valor do PC quando ocorrem saltos
do programa principal para o endereço de um subprograma a ser executado. Depois de
ter executado o subprograma, para que o micro possa continuar com o programa
principal a partir do ponto em que deixou, ele tem que ir buscar na Pilha esse endereço e
carregá-lo no PC. Quando nos movemos de um programa para um subprograma, o
conteúdo do PC é empurrado para o interior da Pilha (exemplo é a instrução CALL).
Quando são executadas instruções tais como RETURN, RETLW ou RETFIE no fim de
3-4
um subprograma, o PC é retirado da Pilha, de modo a que o programa possa continuar

do ponto em que a sequência foi interrompida. Estas operações de colocar e extrair da
Pilha o PC, são designadas por PUSH (meter na pilha) e POP (tirar da pilha), estes
nomes provêm de instruções de micros de maior porte.
O PCLATH não é afetado pelas operações PUSH ou POP.
A Pilha opera como um buffer circular do tipo LIFO (Last In First Out), caracterizada
por apresentar um único ponto de acesso denominado Topo da Pilha (TOS – Top of
Stack). Isto significa que após ter usado os 8 níveis da Pilha (PUSH) o nono push
escreverá sobre o valor que estava armazenado no primeiro push. O décimo push
escreverá sobre o segundo push, e assim por diante.
Obs1: Não há bits de status para indicar condições de stack overflow (pilha cheia) ou
stack underflow (pilha vazia ou incompleta).
3.3 - ORGANIZAÇÃO DA MEMÓRIA DE DADOS (RAM).

A memória de dados está composta por Registros ou bytes de memória RAM, de modo
que cada endereço de memória pode ser especificado pelo nome do Registro. Serve para
guardar as variáveis e os registros usados pelo programa, é de 8 bits e é volátil.
Esta memória como veremos adiante, é dividida em dois Bancos os quais contém:
a) General Purpose Registers – GPR (Registros de Propósitos Gerais)
b) Special Function Registers – SFR (Registros Especiais ou de Funções Especiais).
3.3.1 - General Purpose Register File (GPR).

Os Registros de Arquivos de Propósitos Gerais, são endereços livres de RAM para que o
programador disponha deles. Eles podem ser lidos ou escritos. Podendo ser acessados
direta e indiretamente.
3.3.2 - Registros de Funções Especiais (SFR).

São registros usados pela CPU e módulos periféricos para controlar a operação desejada
do dispositivo. Estes registros são implementados como SRAM e podem ser lidos ou
escritos tanto pelo usuário como pelo hardware e servem também para a configuração de
muitas funções e para a utilização de todos os periféricos.
a) Os SFR podem ser classificados em dois grupos:
3-5
I) Relacionados ao Núcleo (CPU), serão descritos a seguir.

II) Relacionados aos Periféricos, são relacionados à operação de periféricos e
serão vistos no trabalho com o periférico.
3.3.3 - Bancos de memória de dados

A arquitetura do PIC está preparada para operar com uma RAM de 256 bytes.
Entretanto, verificamos que nem toda a memória está disponível ao usuário. São 68
bytes para uso geral, 22 bytes para registros especiais (5 espelhados), 2 bytes
indisponíveis e 96 bytes (não fisicamente implementados). O espelhamento facilita ao
programador evitando trocas constantes de bancos.
3.4 - CLASSIFICAÇÃO DOS REGISTROS.

Aqui, faremos uma apresentação geral dos Registros de acordo com a função que
exercem dentro do micro. Na sequência, apresentaremos detalhes de alguns deles
enquanto outros serão vistos dentro do Capítulo referente ao Módulo junto com o qual
trabalham.
Cada bit dentro desses registros recebe um nome, sendo também especificado se o bit
pode ser lido (R) ou escrito (W). Caso não esteja implementado será lido como zero (0).
3.4.1 – Registro W (WORK).

O Registro W é um registro especial usado com características únicas:
a) Pode ser usado como destino de diversas operações aritméticas e lógicas;
b) Não pode ser usado como fonte de dados em diversas operações internas da CPU
(rotação, incremento, decremento, etc.);
c) Não é mapeado na memória RAM dos PIC como os registros SFR e GPR;
d) É principalmente usado como ponte entre os registros “f”, pois não é possível trocar
informações diretamente entre esses registros.
3.4.2 – Outros registros.
a) Registros gerais:
I) STATUS
II) OPTION_REG
III) PCL e PCLATH
3-6
IV) FSR e INDF

b) Registros das Portas:
I) PORTA e TRISA
II) PORTB e TRISB
c) Registros dos Temporizadores (Timer):
I) TMR0
d) Registros das Interrupções:
I) INTCON – controle de interrupções.
3.4.3 - Registro STATUS.

É um registro de arquivo usado para verificação do estado geral do micro. Este registro
contém o estado aritmético da ULA (<2:0>), estado do RESET (<4:3>) e os bits de
seleção do Banco para a Memória RAM de Dados (<7:5>). Os bits 5 e 6 são usados no
endereçamento direto e o bit 7 no endereçamento indireto. Este registro pode ser
também o destino para qualquer instrução, como qualquer outro registro.
Quando este registro for o destino de uma instrução que afeta os bits Z, DC ou C, então
a escrita nestes três bits fica desabilitada. Estes bits são setados ou resetados de acordo
com a lógica do dispositivo. Além disso, não se pode escrever nos bits /TO e /PD (só
leitura), por isso, o resultado de uma instrução com o Registro STATUS como destino,
pode ser diferente do esperado.
Por exemplo, a instrução CLRF STATUS, teoricamente, deveria colocar a zero (0) todos
os bits do registro e setar o bit Z. No entanto, temos:
a) Zera os 3 bits MSB (seleção de banco de memória, bits IRP:RP1:RP0);
b) Os bits /TO e /PD são somente de leitura, não se alteram;
c) Bits DC e C não são alterados;
d) Bit Z é setado.
Isto deixa o registro de STATUS com o valor 000u u1uu (u = bits não afetados). É
recomendado que somente as instruções BCF, BSF, SWAPF e MOVWF sejam usadas
para alterar o registro de STATUS, porque estas instruções não afetam os bits Z, C e DC
3-7
do registro de STATUS a não ser que estas instruções sejam dirigidas a eles, como
abaixo:
BSF STATUS, C ; seta o bit C.
bit 7 IRP: Register Bank Select bit (Seleção do banco de memória de dados no
endereçamento indireto).
0 = Banco 0 e 1 (00h - FFh)
1 = Banco 2 e 3 (100h - 1FFh)
bit 6-5 RP1:RP0: Register Bank Select bits (Seleção do banco de memória de dados no
endereçamento direto)
00 = Banco 0 (00h - 7Fh)
01 = Banco 1 ( 80h - FFh)
10 = Banco 2 (100h -17Fh)
11 = Banco 3 (180h -1FFh)
bit 4 /T0: Time-out bit (estouro de contagem de tempo do WDT)
1 = Ocorreu Power-up ou foram executadas instruções CLRWDT ou
SLEEP.
0 = Ocorreu um estouro do Watchdog Timer e provocou um reset no
micro.
bit 3/PD: Power-down bit (desligamento ou Sleep – indica o estado do controle
de energia do micro).
1 = Ocorreu Power-up (só alimentação) ou foi executada a instrução
CLRWDT.
0 = Indica que a instrução SLEEP (baixo consumo) foi executada.
bit 2 Z: Zero Bit (Bit zero)
1 = Quando o resultado de uma operação lógica ou aritmética for zero (0).
0 = Quando o resultado de operação lógica ou aritmética não for zero (0).
3-8
bit 1 DC: Digit carry/borrow bit (Transporte de dígito/Empréstimo de dígito).

Usado para as instruções ADDWF, ADDLW, SUBWF, SUBLW, na indicação de
transporte ou empréstimo no quarto bit - Niblle. Para borrow a polaridade é reversa.
ADDWF:
1 = Se ocorrer transporte do 4º bit do LSB.
0 = Se não ocorrer transporte do 4º bit do LSB.
SUBWF:
1 = Se não ocorrer empréstimo do 4º bit do LSB.
0 = Se ocorrer empréstimo do 4º bit do LSB.
bit 0 C: Carry/borrow bit (Transporte/empréstimo em instruções ADDWF, ADDLW,
SUBWF e SUBLW).
1 = Se ocorrer transporte no MSB.
0 = Se não ocorrer transporte no MSB.
ADDWF (C = 1, produz-se transporte no bit 7 e C = 0, não se produz
transporte).
SUBWF (C = 1, não ocorreu emprestimo no bit 7 e C = 0, ocorreu
emprestimo).
RRF/RLF (carrega bit C com LSB ou MSB respectivamente).
Legenda: R = só leitura, W = só escrita, U = sem implementar é lido como ‘0’, –n = valor ao

reiniciar (POR) e x = desconhecido.
Obs1: Os bits C e DC operam como transportes quando realizamos operações de subtração.
Obs2: Para borrow a polaridade do flag C é invertida. Sempre antes de uma subtração, o chip
irá setar o flag C, isto é, cria uma reserva de 256 para eventual empréstimo na subtração. A
subtração é executada pela adição a complemento a dois do segundo operando. Para instruções
de deslocamento (RRF e RLF), o bit deslocado no byte vai para o bit C e o bit que estava em C
retorna para o byte. O bit C ou é MSb ou LSb.
3-9
3.4.4 - Registro OPTION_REG.

É um registro de leitura e escrita que contêm vários bits de controle para configurar o
prescaler TMR0/WDT, resistores de pull-up na porta B, borda da interrupção externa,
borda que incrementa o TMR0, etc.
Os bits 2:0 (PS2:PS0) configuram o fator de divisão do prescaler e que é diferente
conforme seja atribuído ao TMR0 (Timer0) ou ao WDT (Watchdog). Os outros bits
agem diretamente no comportamento e não na configuração de alguns terminais. Como
exemplo, se colocarmos o bit RBPU a zero, habilitamos os resistores de pull-up internos
que são conectados entre os terminais da porta B e o positivo, mas não servem para nada
se a porta for colocada como saída (desconecta-se automaticamente o resistor de cada
uma das linhas que for configurada como saída). Se a interrupção externa no pino
RB0/INT estiver desabilitada, o estado do bit INTEDG, é irrelevante.
bit 7 RBPU: PORTB Pull-up Enable bit (Habilita o resistor de pull-up internos para a
PORTB)
1 = Resistores de pull-ups desabilitados
0 = Resistores de pull-ups habilitados para os pinos do PORTB configurados
como entrada.
bit 6 INTEDG: Interrupt Edge Select bit (Bit de seleção da borda que gera a interrupção
externa no RB0/INT)
1 = Interrupção ocorrerá na borda de subida no pino RB0/INT.
0 = Interrupção ocorrerá na borda de descida no pino RB0/INT.
bit 5 T0CS: TMR0 Clock Source Select bit (Bit de seleção de clock para TMR0 e que
determina se o Timer0 será um contador ou um temporizador).
1 = TMR0 funcionará como um contador e será incrementado externamente
pela mudança no pino RA4/T0CK1).
0 = TMR0 funcionará como um temporizador e será incrementado pelo
oscilador interno – CLKOUT = Fosc/4)
3 - 10
bit 4 T0SE: TMR0 Source Edge Select bit (Configuração da borda que incrementará o
TMR0, quando ajustado para um contador de eventos, no pino RA4/T0CKI, isto é,
T0CS = 1).
1 = É incrementado na transição de alto para baixo do pino RA4/T0CKI.
0 = É incrementado na transição de baixo para alto do pino RA4/T0CKI.
bit 3 PSA: Prescaler Assignment bit (Bit de atribuição do Prescaler)
1 = Prescaler é atribuido ao Watchdog.
0 = Prescaler é atribuído ao modulo Timer0 (TMR0)
bit 2-0 PS2:PS0: Prescaler Rate Select bits (Bits de seleção do fator de divisão do
prescaler)
O valor inicial da contagem pode ser ajustado diretamente no registro TMR0, e quando
estourar a contagem, isto é, passe de 255 para 0, irá acionar o flag T0IF (INTCON<2>).
Enquanto não houver estouro da contagem, o bit T0IF permanece apagado (0), se houver
estouro esse mesmo bit será setado e permanece assim até que seja zerado pelo usuário.
O estouro deste contador pode gerar uma interrupção no micro dependendo se o bit T0IE
(INTCON <5>) foi previamente setado.
Obs: Quando usando Low Voltage ICSP Programming (LVP) e pull-ups na PORTB
habilitados, o bit 3 no registro TRISB deve ser limpo para desabilitar o pull-up em RB3
e assegurar a operação adequada do dispositivo.
3.4.5 - PCL (endereços 02h, 82h) e PCLATH (endereços 0Ah, 8Ah).
O Contador de Programa (PC) é o responsável pelo controle da sequência da execução

das instruções no PIC. O registro PC aponta sempre para a próxima instrução a ser
executada pela CPU, desta forma, se desejarmos alterar o fluxo do programa, devemos
alterar o conteúdo do PC.
O PC é um registro de 13 bits dividido em dois outros registros:
a) PCL é um registro de leitura e escrita usado para acesso aos 8 bits menos
significativos do PC (bits 7:0).
b) PCH, registro para armazenar os 5 bits mais significativos do PC (bits 12:8). Este
registro não pode ser lido pelo usuário, mas pode ser alterado por intermédio de um
3 - 11
outro registro PCLATH. Portanto, o registro PCLATH (bits 4:0) é um registro usado
para acesso aos 5 bits mais significativos do PC.
Com qualquer reset, os bits mais significativos serão apagados (zerados). O PCLATH
não é modificado por chamadas CALL, RETURN, etc.
Nas instruções CALL e GOTO, estas só fornecem 11 bits do endereço de salto (2K) e o
PCLATH fornece mais 2 bits (PCLATH <4:3>).
Quando se realiza uma chamada a uma sub-rotina (CALL) ou um salto (GOTO), o
usuário tem de proporcionar estes bits (PCLATH<4:3>).
Se for executado o retorno de uma instrução CALL ou interrupção, os 13 bits completos
do PC estão na Pilha (Stack). Por isso, não é necessário acionar os bits PCLATH<4:3>
para instruções de retorno, pois o endereço do retorno é fornecido pela Pilha.
c) A interação entre os registros PC, PCL, PCH e PCLATH pode ocorrer de quatro
formas distintas:
I) Execução de uma instrução que tem como destino o registro PCL.
Neste caso, o registro PC será carregado, em sua parte baixa com o valor escrito no
registro PCL e em sua parte alta (PCH) com os cinco bits menos significativos do
registro PCLATH.
Figura 3.7: Instruções que tem como destino o registro PCL.
II) Execução de uma instrução GOTO.

Quando uma instrução GOTO (desvio incondicional) é executada, o conteúdo do PC e
carregado com os 11 bits do endereço incluso no opcode da instrução. Estes 11 bits são
carregados nos bits inferiores do PC. Os dois bits superiores do PC são carregados com
os bits 4 e 3 do registro PCLATH.
3 - 12
Figura 3.8: Instrução do tipo GOTO.

III) Execução de uma instrução CALL.
A execução de uma instrução CALL (chamada incondicional de sub-rotina) faz com que
o conteúdo atual do PC (que está apontando para a próxima instrução a ser executada
após a instrução CALL) seja armazenado na Pilha.
O PC é então, carregado com os 11 bits do endereço incluso no opcode da instrução.
Estes 11 bits são carregados nos bits inferiores do PC.
Os dois bits superiores do PC são carregados com os bits 4 e 3 do registro PCLATH.
Figura 3.9: Instrução do tipo CALL.

Obs: As instruções GOTO e CALL permitem saltos dentro de 2048 posições de
memória. Para saltos fora da página atual, será necessário programar o registro
PCLATH com o valor correto. Nos PICs com menos de 2K de memória de programa
não é necessário utilizar o registro PCLATH em qualquer desvio.
3 - 13
IV) Execução das instruções RETURN, RETLW ou RETFIE.

Nestes casos, o PC é carregado com o valor que é puxado da Pilha. Este valor já é de 13
bits, preenchendo totalmente o PC. Portanto, nas instruções de retorno, não é necessário
o uso do registro PCLATH em qualquer hipótese.
Figura 3.10: Carregando o PC nas instruções de retorno.
3.4.6 - Registros INDF (Indirect Addressing) e FSR (File Select Register –

endereços 04h, 84h, 104h e 184h).
Registros usados para acesso indireto a uma posição da memória RAM de dados.
a) Modos de endereçamento:
I) Direto, é feito por um endereço de nove bits sendo sete bits do endereço direto da
instrução mais dois bits (RP1 e RP0) do registro STATUS. Qualquer acesso aos
registros especiais (SFR), pode ser um exemplo de endereçamento direto. Veja Figura
3.11
Exemplo:
bsf STATUS,RP0 ;banco 1
movlw 0xFF ;w = 0xFF
movwf TRISA ;PORTA como entrada.
II) Indireto, não tira o endereço do código da instrução, mas sim com a ajuda do bit IRP
(STATUS<7>) e do registro FSR. O local endereçado é acessado através do registro
INDF e coincide com o endereço contido em FSR.
3 - 14
O Registro INDF não é um registro físico e ao ser acessado causará endereçamento

indireto. Qualquer instrução usando o INDF como registro, na verdade acessa um dado
cujo endereço está contido no registro FSR (File Select Register). Ler o registro INDF,
quando o registro FSR = 0 resulta em 00h. Escrever no registro INDF, indiretamente
resulta na instrução NOP (nenhuma operação), embora seja possível afetar bits de status.
FSR – usado para especificar o endereço de um registro a ser acessado
indiretamente.
INDF – usado para escrita/leitura do conteúdo do endereço especificado pelo
registro FSR.
No endereçamento indireto, os nove bits necessários são obtidos por oito bits do
registro FSR e o bit IRP (STATUS<7>), como na Figura 3.11.
Figura 3.11: Endereçamento direto/indireto da memória RAM de dados.
3 - 15
Figura. 12 - Mapa de memória de armazenamento de dado
3.4.7 - Registro INTCON (endereços 0Bh, 8Bh).

É um registro de leitura e escrita que possui bits de habilitações e bits de flags usados
no controle das interrupções do micro.
Basicamente se divide em:
a) Controle geral de interrupções;
b) Controles individuais de interrupções;
c) Flags sinalizadores da ocorrência da interrupção.
É preciso zerar os bits flag antes de habilitar as interrupções para que possam ter efeito.
Como exemplo, se o bit T0IF (transbordamento do Timer0) permanecer setado, nunca
saberemos se voltou a transbordar.
GIE- apagado (0), não será atendida nenhuma interrupção, independentemente do
modo em que se encontrem os diferentes bits de controle das interrupções individuais.
3 - 16
PEIE- possui controle dos periféricos, pois quando em zero, não permite que os
periféricos possam ocasionar uma interrupção. Há bits que habilitam ou não certas
interrupções e bits que agem como bandeiras (flags) indicadoras de que um evento
ocorreu em algum terminal ou módulo.
bit 7 GIE: Global Interrupt Enable bit (Habilitação geral das interrupções – chave
geral).
1 = Habilita todas as interrupções para controle individual.
0 = Desabilita todas as interrupções.
bit 6 PEIE: Peripheral Interrupt Enable bit (Habilitação das interrupções de periféricos
– chave geral de periféricos).
1 = Habilita todas as interrupções de periféricos para controle individual.
0 = Desabilita todas as interrupções de periféricos.
bit 5 T0IE: TMR0 Overflow Interrupt Enable bit (Habilitação da interrupção de
estouro de TMR0 – chave individual).
1 = Habilita a interrupção do TMR0.
0 = Desabilita a interrupção do TMR0.
bit 4 INTE: RB0/INT External Interrupt Enable bit (Habilitação de entrada externa de
interrupção pino RB0/INT – chave individual).
1 = Habilita a interrupção externa no pino RB0/INT.
0 = Desabilita a interrupção externa.
bit 3 RBIE: RB Port Change Interrupt Enable bit (Habilitação da interrupção por
mudança de estado nos pinos RB4 a RB7 – chave individual).
1 = Habilita a interrupção por mudança de estado
0 = Desabilita a interrupção por mudança de estado.
bit 2 T0IF: TMR0 Overflow Interrupt Flag bit (Identificação de estouro ou
transbordamento do TMR0).
1 = Ocorreu transbordamento do TMR0 (este bit deve ser limpo por
software).
3 - 17
0 = Não ocorreu transbordamento do TMR0.

bit 1 INTF: RB0/INT External Interrupt Flag bit (Flag de identificação de interrupção
externa no pino RB0/INT).
1 = RB0/INT ocasionou uma interrupção (este bit deve ser limpo por
software).
0 = RB0/INT não causou interrupção.
bit 0 RBIF: RB Port Change Interrupt Flag bit (Flag de identificação de interrupção
por mudança de estado nos pinos RB4 a RB7).
1 = Algum dos bits RB7:RB4 mudou de estado (deve ser limpo por
software).
0 = Nenhuma mudança de estado dos pinos RB7: RB4.
3 - 18
CAPÍTULO 4
PORTAS DE ENTRADA E SAÍDA.
Alguns pinos das portas de entrada/saída são multiplexados com funções alternadas para
características de periféricos no dispositivo. Em geral, quando um periférico está
habilitado, este pino pode não ser usado como um pino de entrada/saída de uso geral.
a) O PIC16F84 possui suas portas divididas da seguinte forma:
I) Uma (1) porta de 5 I/O (PORTA).
III) Uma (1) porta de 8 I/O (PORTB).
4.2 - PORTA (endereço 05H) e Registro TRISA (endereço 85H).
A porta A (PORTA) é uma porta bidirecional de 6 bits. O registro de direção de dados
correspondente é o TRISA. Um bit do registro TRISA setado, fará com que o pino
correspondente da porta A seja uma entrada (o driver correspondente da saída fica no
estado de alta Z). Um bit do registro TRISA apagado (0), fará com que o pino
correspondente da porta A seja uma saída (coloca o conteúdo do latch de saída no pino
selecionado).
Lendo-se o registro PORTA, temos o estado dos pinos, visto que escrevendo-se na porta
A será escrito no latch da mesma. Todas as operações de escrita são do tipo leitura-
modificação-escrita. Portanto, a escrita na porta implica que os pinos são lidos,
modificados e escritos novamente no latch de dados da porta.
A leitura é feita diretamente no pino, enquanto a escrita passa por um Latch. Isto pode
ocasionar um atraso entre o comando de escrita e a efetiva alteração da saída. É por este
motivo que não é recomendável efetuar uma operação de leitura imediatamente após a
alteração de uma saída. O certo é aguardar pelo menos um ciclo de máquina entre as
duas operações. O latch possibilita também que uma operação de escrita seja executada
mesmo que o pino esteja configurado como entrada, através do registro TRISA. O latch
é alterado e, quando o estado do pino for modificado para saída, o valor atual do latch
lhe será imposto. A configuração da porta como saída ou entrada é feita pelo registro
TRISA, enquanto a operação de escrita ou leitura é executada pelo registro PORTA.
4-1
Como visto no bloco da porta A, cinco pinos são do tipo TTL enquanto um é do tipo
Schmitt Trigger. Quando estamos operando com um pino como entrada isto interfere
diretamente no nível de tensão interpretado pelo PIC.
Os pinos RA0 a RA3 e RA5 se ligam também ao Conversor A/D. “Analog Input Mode”
representa a seleção entre modo digital ou analógico para esses pinos (Registro
ADCON1). Estes pinos possuem níveis TTL de entrada e drivers de saída CMOS.
O pino RA4 é multiplexado com a entrada do clock do módulo Timer0 tornando-se o
pino RA4/T0CKI. Isto possibilita que um clock imposto a esse pino incremente
automaticamente o TMR0, independentemente do clock real da máquina. Outra
característica desta saída e não possuir o FET canal P, capaz de impor Vdd à saída,
ficando uma saída dreno aberto. Para liberar Vdd em RA4 é necessário um resistror de
pull-up externo.
O pino RA4/T0CKI é uma entrada Schmitt Trigger e uma saída dreno aberto (É útil para
aplicações que compartilham a mesma ligação no pino [porta]).
Outros pinos da porta A são multiplexados com entradas analógicas e entrada de
referência (Vref) analógica. A operação de cada pino é selecionada pelos bits de controle
no registro ADCON1 (A/D Control Register1).
Obs: Na energização (Power-on Reset), esses pinos são configurados como entradas
analógicas e em leitura são zero (0).
O Registro TRISA controla a direção dos pinos RA, mesmo que eles estejam sendo
usados como entradas analógicas.
O usuário precisa garantir que os bits do registro TRISA sejam mantidos setados,
quando usados como entradas analógicas.
Exemplo de inicialização da PORTA A.
bcf STATUS, RP0
bcf STATUS, RP1 ;banco0
clrf PORTA ;inicialização da porta A pela limpeza dos Latches de
saída
bsf STATUS, RP0 ;seleciona o Banco1
movlw 0x06 ;configura todos os pinos como entradas
movwf ADCON1 ;digitais
movlw 0xCF ;valor usado para inicializar a direção de dados
4-2
movwf TRISA ;coloca RA0 a RA3 como entradas e RA4 e RA5 como
;saídas, TRISA 6 e 7 são sempre lidos como zero (0).
Diagrama de bloco dos pinos RA0 a RA3 e Digrama de bloco do pino RA4/T0CKI.
RA5.
Pinos E/S são protegidos por diodos para Vss.
Pinos E/S são protegidos por diodos para

Vdd e Vss.
Figura 4.1: Diagrama de blocos da PORTA A.
Option_Reg bits T0CS e T0SE também são usados.
Figura 4.2: Registros associados com PORTA.
4.3 - PORTA B (endereços 06h e 106h) e Registro TRISB (endereços 86h e 186h).
4-3
A porta B (PORTB) é bidirecional de 8 bits. O registro de direção de dados

correspondente é o TRISB. Um bit do registro TRISB setado, fará com que o pino
correspondente da porta B seja uma entrada (o driver correspondente da saída fica no
estado de alta Z). Um bit do registro TRISB apagado (0), fará com que o pino
correspondente da porta B seja uma saída (coloca o conteúdo do latch de saída no pino
selecionado).
Três dos pinos da porta B são multiplexados com a função de Programação em Baixa
Tensão (Low Voltage Programming function), são eles: RB3/PGM, RB6/PGC e
RB7/PGD. As funções alternadas desses pinos são descritas mais adiante.
Uma característica elétrica da porta B é ligação de pull-up interno (FET). Esta ligação para Vdd pode ser
feita ou não em todos os pinos ao mesmo tempo através do bit RBPU (OPTION_REG<7>). O pull-up é
automaticamente desligado quando um pino da porta é configurado como saída e durante a energização
(Power-on Reset).
Diagrama de bloco dos pinos RB0 a Diagrama de bloco dos pinos RB4 a RB7.
RB3.
Pinos de E/S são protegidos por diodos

para Vdd e Vss quando em modo de Pinos de E/S são protegidos por diodos para
programa. Vdd e Vss quando em modo de programa.
Para habilitar pull-ups, set o bit(s) TRIS Para habilitar pull-ups, set o bit(s) TRIS
correspondente e limpe o bit RBPU correspondente e limpe o bit RBPU
(OPTION_REG<7>). (OPTION_REG<7>).
Figura 4.3: Diagrama de blocos da PORTA B.
4-4
Toda a porta B é entrada TTL, exceto o pino RB0 quando configurado para utilizar a
interrupção externa e os pinos RB3, RB6 e RB7 quando em modo de programação série
onde são do tipo ST.
Os pinos RB4 a RB7 são interligados à interrupção de mudança de estado quando
configurados como entradas e o pino RB0 é associado à interrupção externa, desde que
configurado como entrada. Habilitações e identificações encontram-se no registro
INTCON e a configuração da borda que gera a interrupção externa é feita pelo bit
INTEDG (OPTION_REG<6>).
Os pinos de entrada (RB7:RB4) são comparados com os valores antigos armazenados na
última leitura da porta B. As saídas diferentes passam por uma operação “OU” para
gerar a interrupção por mudança na porta B (RB Port Change Interrupt) mudando a
interrupção com o bit de flag RBIF (INTCON<0>).
Esta interrupção pode dispertar o MCU do estado de SLEEP. O usuário, no Serviço da
Rotina de Interrupção (Interrupt Service Routine) pode desabilitar a interrupção das
seguintes maneiras:
a) Qualquer leitura ou escrita na porta B. Isto acabará com qualquer condição de
diferença.
b) Zerar o bit de flag RBIF.
A característica interrupção mudança de estado junto com os Pull-ups configuráveis
por software em quarto desses pinos, permite fácil interligação com teclado e torna
possível o despertar pelo pressionamento da tecla.
RB0/INT é um pino de entrada de interrupção externa e é configurado usando o bit
0Bh... INTCON GIE INTE RBIE INTF RBIF
Figura 4.4: Registros associados com a PORTA B.
4-5
*Aula Prática no laboratório: Manual de experimentos (Capítulo5 e 7)*
;Lendo a porta B:
movf PORTB,W ;escreve o valor da PortaB em W
movwf DADO ;registro DADO recebe o registro PORTB
;Inicializando as variáveis:
clrf PORTA ;zero em todas as saídas da PortaA
clrf PORTB ;zero em todas as saídas da portaB
movlw .10
movwf Contador ;inicia contador com 10 decimal
;Escrevendo na porta
bsf STATUS,RP0 ;muda para o banco 1
bsf TRISB,0 ;transforma RB0 em entrada
bcfSTATUS,RP0 ;retorna ao banco0
. ;vários comandos
bsf PORTB,0 ;escreve ‘1’ no latch do RB0 (ainda é entrada)
bsf STATUS,RP0 ;muda para banco1
bcf TRISB,0 ;transforma RB0 em saída. Neste momento o pino
será inicializado
;em ‘1’ devido ao latch
bcfSTATUS,RP0 ;retorna ao banco0
Obs: Não se deve escrever na porta em um ciclo e efetuar a leitura no ciclo seguinte,
deve-se ter pelo menos 1 ciclo de máquina entre escrita e leitura. Neste caso, usa-se a
instrução NOP que demora 1 ciclo.
movlw .10 ;escreve 10 em W

movwf PORTB ;transfere 10 para a porta B
NOP ;demora 1 ciclo para assegurar a escrita na portaB
movf PORTB, W ;lê o valor da portaB e coloca em W
movwf DADO ;transfere o valor de W para o registro DADO
4-6
CAPÍTULO 5.
ESTUDO DO TIMER.
.
5.1 - Módulo TIMER0.
É um contador de 8 bits, cujo valor é armazenado no registro TMR0 (01h), pode ser lido
ou escrito, possibilitando a inicialização do contador com um valor diferente de zero, por
software.
O conteúdo deste registro é sucessivamente incrementado usando um clock que tanto
pode ser interno (Fosc/4) como externo (pino RA4/T0CK1). Pode usar um prescaler para
poder ampliar a contagem.
5.1.1 – O módulo possui as seguintes características:
a) Opera como Temporizador ou Contador de 8 bits
b) Pode ser lido ou escrito
c) Prescaler de 8 bits programável por software
d) Seleção de clock interno (Fosc/4) ou externo (pino RA4/T0CK1)
e) Interrupção por estouro ou transbordamento (overflow) quando a contagem
passar de FFh para 00h (255 para 0), se habilitada.
f) Seleção da borda de subida ou descida para o clock externo
5.1.2 – O Timer0 pode operar de dois modos:
a) Modo Temporizador
O modo Temporizador (contagem de tempo) é selecionado no MUX pelo bit T0CS

(OPTION_REG<5>). Neste modo, o módulo Timer0 incrementará livremente a
cada ciclo de instrução, isto é, Fosc/4 (sem prescaler). Quando se escreve no
registro TMR0, o incremento é inibido para os dois ciclos de instruções seguintes
antes de começar a contar e isto deve ser levado em consideração pelo software.
b) Modo contador.
O modo Contador (contagem de eventos externos) é selecionado no MUX pelo bit

T0CS (OPTION_REG<5>). Neste modo, o módulo Timer0 incrementará a cada
pulso ou clock presente no pino RA4/T0CK1
T0CS = 0: incremento a cada ciclo de máquina (Fosc/4).
5-1
T0CS = 1: incremento a cada transição no pino RA4/T0CK1.

Quando selecionamos o incremento pelo pino T0CK1 (pulso ou clock externo) é
possível ainda selecionar se o incremento acontecerá na borda de subida ou na de
descida do sinal de entrada, através do bit T0SE (OPTION_REG<4>).
T0SE = 1: incremento na borda de descida.
T0SE = 0: incremento na borda de subida.
Para incremento externo ou interno, podemos aplicar um prescaler antes do registro
TMR0 ser realmente alterado. Caso o prescaler esteja configurado 1:4, por exemplo,
serão necessários quatro ciclos de máquina (ou pulsos externos) para que o TMR0
seja incrementado. O contador interno do prescaler é de 8 bits, mas não está
disponível nem para a leitura e nem para a escrita. Este prescaler será visto adiante.
Para usar o prescaler é necessário primeiramente direcioná-lo ao Timer0 ou ao
WDT, o que é feito através do bit PSA (OPTION_REG<3>). Depois é necessário
ainda configurar o prescaler com o fator de divisão através dos bits PS2:PS0
(OPTION_REG<2:0>).
PSA = 1: prescaler aplicado ao WDT
PSA = 0: prescaler aplicado ao Timer
Figura 5.1: Diagrama de blocos do Timer0/WDT/Prescaler
5-2
5.1.3 - Interrupção no Timer0.

O temporizador pode gerar uma interrupção quando o registro TMR0 transborda na sua
contagem de FFh para 00h (255 para 0), mas para isso, é preciso que as interrupções
(bits GIE e T0IE (INTCON<7 e 5>), estejam habilitadas. Este transbordamento ou
estouro seta o flag T0IF (INTCON<2>), gerando o pedido de interrupção (este bit deve
ser limpo por software durante o tratamento da interrupção). Neste caso, o endereço PC
+ 1 será salvo na Pilha e o programa é desviado para o endereço 04h onde tem início a
rotina de tratamento de interrupções. Esta interrupção pode ser mascarada pelo bit
T0IE (INTCON<5>). A interrupção do TMR0 não pode despertar o micro de um
SLEEP, visto que o temporizador está desligado durante um SLEEP.
5.1.4 - Parte do Registro INTCON usado com o Timer0.

bit 7 GIE: Habilitação geral das interrupções (chave geral).
1 = Habilita todas as interrupções para controle individual.
0 = Desabilita todas as interrupções.
bit 5 T0IE: Habilitação da interrupção de estouro de TMR0 (chave individual).

1 = Habilita a interrupção do TMR0.
0 = Desabilita a interrupção do TMR0.
bit 2 T0IF: Flag de identificação da interrupção por estouro do TMR0).

1 = Ocorreu estouro do registro TMR0 (este bit deve ser apagado por
software).
0 = Não ocorreu estouro do TMR0.
5.1.5 - Usando o Timer0 com clock externo.

Quando o prescaler não está sendo usado, a entrada de clock externa é a mesma da
saída do prescaler. A sincronização de T0CKI com a fase do clock interno é feita pela
amostra da saída do prescaler nos ciclos Q2 e Q4 da fase do clock interno. Portanto, é
necessário que T0CKI se mantenha em nível alto por 2Tosc (e um pequeno retardo RC
de 20 ns) e baixo por 2Tosc (e um pequeno retardo RC de 20 ns).
5-3
5.1.6 - Prescaler.
O prescaler nada mais é do que um contador/divisor programável que é utilizado para
dividir a frequência do sinal de clock aplicado ao Timer0 por um fator conhecido.
Existe somente um prescaler, o qual é compartilhado entre o modulo Timer0 ou o
Watchdog Timer (WDT). É um contador de 8 bits que não pode ser lido ou escrito e
seu fator de divisão é feito pelos bits PS2:PS0 (OPTION_REG<2:0>). É sincronizado
com clocks internos, e por isso podem ocorrer atrasos de até dois ciclos de clock até o
incremento do contador TMR0. Quando o prescaler for atribuído ao modulo Timer0
significa que o Watchdog Timer não poderá usá-lo, e vice-versa. O bit PSA
(OPTION_REG<3>), determina para quem o prescaler é atribuído, isto é, Timer0 ou
Watchdog.
Quando atribuído ao modulo Timer0, todas as instruções escritas no registro TMR0
(ex: clrf TMR0, movwf TMR0, bsf TMR0, etc.) limpam (zeram) o conteúdo do
contador do divisor (prescaler) e não o fator de divisão. Quando atribuído ao WDT, o
contador só pode ser apagado com a instrução CLRWDT. Esta instrução apaga o
prescaler e o Watchdog Timer.
Durante a execução de um programa é possível passar o prescaler do Tmer0 para o
Watchdog e vice-versa, porém o conteúdo será apagado na transferência.
Obs: Escrevendo no TMR0, quando o prescaler estiver atribuído ao Timer0, zera o
contador do prescaler, mas não mudará a atribuição do prescaler.
5.1.7 - Parte do registro OPTION_REG usado com o Timer0.
bit 5 T0CS: TMR0 Clock Source Select bit (Bit de seleção de clock para TMR0 e que
determina se o Timer0 será um contador ou um temporizador).
1 = TMR0 funcionará como um contador e será incrementado
externamente pela mudança no pino RA4/T0CK1).
0 = TMR0 funcionará como um temporizador e será incrementado pelo
oscilador interno (CLKOUT).
5-4
bit 4 T0SE: TMR0 Source Edge Select bit (Configuração da borda que incrementará o
TMR0, quando ajustado para um contador de eventos, no pino
RA4/T0CKI, isto é, T0CS = 1).
1 = É incrementado na transição de alto para baixo do pino RA4/T0CKI.
0 = É incrementado na transição de baixo para alto do pino RA4/T0CKI.
bit 3 PSA: Prescaler Assignment bit (Bit de atribuição do Prescaler)
1 = Prescaler é atribuido ao Watchdog.
0 = Prescaler é atribuído ao modulo Timer0 (TMR0)
bit 2-0 PS2:PS0: Prescaler Rate Select bits (Bits de seleção do fator de divisão do prescaler)
PS2-PS1-PS0 TMR0 WDT
000 1:2 1:1

001 1:4 1:2
010 1:8 1:4

011 1:16 1:8
100 1:32 1:16

101 1:64 1:32
110 1:128 1:64
111 1:256 1:128
- Programação do valor do divisor de frequência (prescaler)

BCF STATUS, RP0 ;Pode ser ignorado se estivermos no Bank 0
CLRWDT ;Apagar WDT
CLRF TMR0 ;Apagar TMR0 e Preescaler
BSF STATUS, RP0 ;Bank 1
MOVLW '00101110’b ; Registro W carregado
MOVWF OPTION_REG ;PS<0:2> é carregado com o valor 110
Suponhamos que o módulo Timer0 funcione como contador de eventos e o prescaler

está habilitado. O valor é 1:1, isso significa que cada pulso que entre incrementará o
valor no registro TMR0 (o valor máximo da contagem é 256). Se o prescaler vale 1:8
5-5
significa que para cada 8 eventos que se sucedam só aumentará uma contagem no
registro TMR0 (o valor máximo de contagem será 8x256 = 2048 eventos). O bit PSA
(OPTION_REG<3>), define se o prescaler funciona com o Watchdog ou com o
Timer0. Observamos que a única maneira de incrementar o TMR0 com uma relação de
1:1 é aplicar o prescaler ao WDT.
;Programa para mudar o prescaler do Timer0 para o Watchdog

bcf STATUS,RP0 ; banco 0
clrf TMR0 ; apaga o registro TMR0 e prescaler
bsf STATUS,RP0 ; banco 1
clrwdt ; apaga WDT
movlw b´xxxx1xxx´ ; carrega W com este valor
movwf OPTION_REG ; prescaler é atribuído ao WDT
;Programa para mudar o prescaler do Watchdog para o Timer0
clrwdt ; apaga WDT e prescaler
bsf STATUS,RP0 ; banco 1
movlw b`xxxx0xxx´ ; carrega W com este valor
movwf OPTION_REG ; prescaler é atribuído ao Timer0
Devemos ter em mente que, se as interrupções do temporizador estiverem habilitadas
quando prescaler é atribuído ao WDT, seria conveniente desabilitar as mesmas e voltar
a habilitá-las de novo quando este for transferido para o temporizador.
Cálculo da frequência com que vão ocorrer as interrupções, no modo temporizador, é
feita pela seguinte fórmula:
Fint = Clock/Prescaler/(256 – TMR0)
Clock = Fosc/4 ou T0CK1
Prescaler = fator de divisão
TMR0 = valor inicial do registro TMR0
Os registos do microcontrolador que estão associados ao funcionamento do
temporizador Timer0 devem ter sua consulta imprescindível para que nenhuma
configuração seja esquecida, quando se pretende utilizar este módulo.
5-6
CAPÍTULO 6
INSTRUÇÕES DO PIC16F84
Cada instrução de PIC16F84 é uma palavra de 14 bits, dividida em um OPCODE que
especifica o tipo da instrução e um ou mais operandos que posteriormente especificam a
operação da instrução. O conjunto de instruções do PIC16F84 é mostrado na Figura 6.3
que lista Operações orientadas a byte, orientadas a bit, e de Literal e de controle. A Figura
6.1 mostra as descrições do Campo do opcode.
6.1.1 - Para instruções orientadas a Byte, f representa um designador do registro de
arquivo e d representa um designador do destino. O designador do registro de arquivo
especifica qual registro de arquivo será usado pela instrução. O designador do destino
especifica onde o resultado da operação deve ser colocado. Se d for 0 ou W, o resultado é
colocado no registro W. Se d for 1 ou F, o resultado está colocado no registro de arquivo
especificado na instrução.
6.1.2 - Para instruções orientadas a bit, b representa o bit designador do campo que
seleciona o número do bit afetado pela operação, enquanto f representa o endereço do
arquivo no qual o bit ficado localizado.
6.1.3 - Para literal e operações de controle, k representa uma constante de 8 ou 11 bits
ou um valor literal.
Figura 6.1
6-1
Campo Descrição
F Endereço do arquivo do registro f especificado (0x00 a 0x7F)
W Registro de trabalho (acumulador)
B Bit de endereço dentro dos 8 bits do arquivo de registro f
K Campo literal, dado constante ou etiqueta
X Irrelevante (0 ou 1), o assembler gera um código com x = 0. É recomendado
para compatibilidade com todas as ferramentas de software da Microchip.
D Seleção de destino; d = 0 ou W: armazena o resultado em W
d = 1 ou F: armazena o resultado no arquivo de registro f
PC Contador de programa
TO Time-out bit
PD Power-down bit
Label Nome da etiqueta
TOS Topo da pilha
PCLAT Latch de maior peso do PC
H
GIE Bit de habilitação global de interrupções
WDT Temporizador/contador Watchdog
→ Atribuído a
<> Bit (s) de um registro
( ) Conteúdo
[ ] Opcional
Figura 6.2: Descrição do campo do Opcode.
Todas as instruções são executadas dentro de um ciclo de instrução, a menos que um

teste condicional seja verdadeiro ou o PC seja mudado como resultado de uma
instrução. Neste caso, a execução demora dois ciclos de instrução, com o segundo ciclo
executado como NOP.
Um ciclo de instrução consiste de quatro períodos do oscilador. Assim, para uma
frequência do oscilador de 4 MHz, o tempo normal de execução de uma instrução será
6-2
de 1us. Se um teste condicional for verdadeiro, ou mudar o PC como resultado de uma

instrução, o tempo da execução da instrução será de 2us.
Figura 6.3: Formato geral para as instruções.
6.2 – CONJUNTO DE INSTRUÇÕES DO PIC16F84.

Utiliza a arquitetura Harvard e conjunto de instruções reduzidas (RISC), com 35
instruções. Possui dois barramentos um de dados e outro de instruções. O barramento de
dados é de 8 bits e o de instrução de 14 bits, assim o OPCODE da instrução já possui o
dado e o endereço onde ela vai operar, se for o caso, utilizando uma posição de memória
por instrução.
Mnemônicos e Descrição Ciclo Código OP 14-bits Status Notas
6-3
Operandos (4) afetados

INSTRUÇÕES QUE USAM REGISTROS E SÃO ORIENTADAS A BYTE (guarda resultado em d)
MSB LSB
ADDWF f,d Soma W e f 1 00 0111 dfff ffff C,DC,Z 1, 2
ANDWF f, d AND entre W e f 1 00 0101 dfff ffff Z 1, 2
CLRF f Apaga f 1 00 0001 1fff ffff Z 2
CLRW - Apaga W 1 00 0001 0xxx xxxx Z
COMF f, d Complementa f 1 00 1001 dfff ffff Z 1, 2
DECF f, d Decrementa f 1 00 0011 dfff ffff Z 1, 2
DECFSZ f, d Decrementa f, salta se 0 1 (2) 00 1011 dfff ffff
INCF f, d Incrementa f 1 00 1010 dfff ffff Z 1, 2, 3
INCFSZ f, d Incrementa f, salta se 0 1 (2) 00 1111 dfff ffff
IORWF f, d OU entre W e f 1 00 0100 dfff ffff Z 1, 2
MOVF f, d Move f 1 00 1000 dfff ffff Z 1, 2
MOVWF f Move (copia) W para f 1 00 0000 1fff ffff
NOP - Não opera (gasta 1 ciclo) 1 00 0000 0xx0 0000
RLF f, d Rotaciona f um bit para a 1 00 1101 dfff ffff C 1, 2
esquerda através do carry.
RRF f, d Rotaciona f um bit para a direita 1 00 1100 dfff ffff C 1,2
através do carry.
SUBWF f, d Subtrai W de f 1 00 0010 dfff ffff C,DC, Z 1,2
SWAPF f, d Inversão entre nibbles de f. 1 00 1110 dfff ffff 1,2
XORWF f, d OU exclusivo entre W e f 1 00 0110 dfff ffff Z 1,2
INSTRUÇÕES QUE UTILIZAM BITS E SÃO ORIENTADAS A BIT (b é o bit afetado pela instrução)
BCF f, b Apaga o bit b de f 1 01 00bb bfff ffff 1, 2

BSF f, b Seta o bit b de f 1 01 01bb bfff ffff 1, 2
BTFSC f, b Testa o bit b de f, salta se 0 1 (2) 01 10bb bfff ffff 3
BTFSS f, b Testa o bit b de f, salta se 1 1 (2) 01 11bb bfff ffff 3
INSTRUÇÕES DE CONTROLE E DE OPERANDOS IMEDIATOS (gurda resultado em W)
ADDLW k Soma a constante k com W 1 11 111x kkkk kkkk C,DC,Z

ANDLW k AND entre a constante k e W 1 11 1001 kkkk kkkk Z
CALL k Executa subrotina 2 10 0kkk kkkk kkkk
CLRWDT - Apaga Watchdog Timer 1 00 0000 0110 0100 /TO,/PD
GOTO k Salto incondicional 2 10 1kkk kkkk kkkk
IORLW k OR entre constante k e W 1 11 1000 kkkk kkkk Z
MOVLW k Move (copia) literal k para W 1 11 00xx kkkk kkkk
RETFIE - Retorno de uma interrupção 2 00 0000 0000 1001
RETLW k Retorno de subrotina com k em W 2 11 01xx kkkk kkkk
RETURN - Retorno de subrotina 2 00 0000 0000 1000
SLEEP - Micro no modo de repouso 1 00 0000 0110 0011 /TO,/PD
SUBLW k Subtrai W da constante (literal) k 1 11 110x kkkk kkkk C,DC,Z
XORLW k OU exclusivo entre literal k e W 1 11 1010 kkkk kkkk Z
Nota 1: Quando um registo do I/O for modificado em função de si mesmo (exemplo, MOVF PORTB, 1), o valor
usado será o valor presente nos próprios pinos. Por exemplo, se o latch de dados for ‘1’ para um pino configurado
como entrada e for mudado para baixo por um dispositivo externo, o dado será escrito novamente com um zero (0).
2: Se esta instrução for executada no registro TMR0 (e, onde aplicável, d = 1), o preescaler será apagado se
designado ao módulo do Timer0.
3: Se o PC for modificado ou um teste condicional for verdadeiro, a instrução requer dois ciclos. O segundo
ciclo é executado como um NOP.
4: Mnemônico = Nome da instrução e Operando = Argumento
6-4
5: Instruções de controle, são: NOP, CALL, CLRWDT, GOTO, RETFIE, RETLW, RETURN e SLEEP.
Figura 6.4: Conjunto de instruções.

6.2.1 – Descrição das instruções.
Antes de estudarmos as instruções, vejamos como elas são construídas.
a) Instruções do tipo MNEMÔNICO k .
Neste tipo de instrução, encontramos um operando k cujo valor será usado pela
instrução de uma das duas formas:
I) Armazenado no registro W.
II) Usado como parte do endereço de destino em instruções de desvio.
b) Instruções do tipo MNEMÔNICO REG (MOVWF f).

I) Neste tipo de instrução, encontramos um operando REG que representa um dos
registros SFR ou GPR disponíveis no PIC.
II) Observe que REG é representado por um código binário de 7 bits, o que nos
limita a um máximo de 128 registros. Daí a necessidade de implementar os bancos
de memória no PIC.
c) Instruções do tipo MNEMÔNICO REG, DES (ADDWF f, d):

Neste tipo de instrução, encontramos dois operandos REG e DES:
6-5
I) REG, representa um dos registros SFR ou GPR disponíveis no PIC (W não é um

registro SFR ou GPR).
II) DES, consiste em um bit indicador do destino da instrução, onde podemos ter
duas possibilidades:
A) Se no lugar de DES tiver a letra W ou o número 0, o destino da instrução será
o registro W.
B) Se no lugar de DES tiver a letra f ou o número 1, o destino da instrução será o
próprio registro representado por REG.
d) Instruções do tipo MNEMÔNICO REG, BIT (BCF f, b):
Neste tipo de instrução, encontramos dois operandos: REG e BIT
I) REG, representa um dos registros SFR ou GPR disponíveis no PIC (W não é um
registro SFR ou GPR).
II) BIT, representa qual dos 8 bits que compõe o registro REG será o alvo da
instrução. Ex: “MNEMÔNICO PORTB,1”, o bit 1 da porta B será o alvo da
instrução.
Existem instruções que alteram indiretamente os flags no registro STATUS, ou seja,

devido à natureza de sua operação, certas instruções, após a realização de sua
operação, alterarem um ou mais flags de acordo com o resultado. Dessa forma, além
de alterar diretamente o registro de destino da operação, essas instruções alteram
também indiretamente o registro STATUS.
6.2.2 - Para a base numérica podemos usar qualquer uma delas desde que esteja de
acordo com as regras estabelecidas.
a) Para hexadecimal: 0xXX ou H’XX’
b) Para binário: B’XXXXXXXX’
c) Para decimal: D’XX’ ou .XX
6-6
d) Para ASCII: A’X’

6.2.3 – Observando o Registro de STATUS em algumas operações.
a) Quando o resultado alterar os flags C, DC e Z, em uma soma temos:
I) C = 1, se o resultado ultrapassar o valor 255;
II) C = 0, se o resultado não ultrapassar o valor 255;
III) DC = 1, se houver transbordo do bit 3 para o bit 4 do registro;
IV) DC = 0, se não houver transbordo do bit 3 para o bit 4 do registro;
V) Z = 1, se o valor armazenado em W for igual a zero;
VI) Z = 0, se o valor armazenado em W for diferente de zero.
Obs: Para determinar o valor real armazenado no destino (W) quando superior a 255,
basta subtrair 256 do resultado. O valor resultante será o efetivamente armazenado
no destino. Neste caso, o flag C estará setado, indicando que houve a condição de
estouro do registro.
b) Quando o resultado alterar os flags C, DC e Z, em uma subtração temos:
I) C = 1, indica que o resultado é positivo ou igual a zero (não houve empréstimo);
II) C = 0, indica que o resultado é negativo (houve empréstimo);
III) DC = 1, não houve empréstimo do bit 4 para o bit 3;
IV) DC = 0, houve empréstimo do bit 4 o bit 3;
V) Z = 1, se o valor armazenado em W for igual a zero;
VI) Z = 0, se o valor armazenado em W for diferente de zero.
Obs1: Para determinar o valor real armazenado no destino (W) quando negativo, basta
adicionar 256 decimais ao resultado. O novo valor resultante será o efetivamente
armazenado no registro de destino (W). Neste caso, o flag C estará apagado
(zero), indicando que houve a condição de empréstimo na subtração.
Obs2: Em algumas instruções podemos usar o número ou o nome do bit. Ex: BCF
STATUS,0 ou BCF STATUS,Z (zera o bit Z ou bit 0).
6.2.4 - Instruções de Desvios.
Dentre as instruções do PIC, algumas são consideradas de desvio. Instruções de desvio
são usadas para desviar o fluxo do programa para outro endereço.
a) Podem ser classificadas em:
6-7
I) Desvio com retorno – também chamadas de sub-rotinas, acontecem quando o

fluxo do programa é desviado para outro ponto (sub-rotina) e após a execução
dela, o fluxo retorna ao ponto inicial de desvio e segue adiante. As subrotinas
fazem uso da pilha. Ex: CALL
II) Desvios sem retorno – o fluxo do programa é desviado para outro endereço,
seguindo então a partir de lá. Os desvios sem retorno podem ser dos tipos
condicionais (IF) e incondicionais (GOTO k). Nos desvios condicionais, ocorre o
desvio do programa se a condição for verdadeira e nos incondicionais, o desvio
ocorre independente de qualquer condição.
b) São consideradas instruções de desvio:
I) Instruções de controle de desvio (GOTO e CALL)
II) Instruções de retorno de interrupções (RETFIE)
III) Instruções de retorno de subrotinas (RETURN e RETLW)
IV) BTFSS, BTFSC, DECFSZ e INCFSZ.
6.2.5 - Termos usados:
a) Work (registro W): Registro temporário para as operações da ULA
b) File: Referência a um registro, SFR ou GPR (endereço de memória). F no nome da
instrução e f no argumento
c) Literal: Um número qualquer no formato binário, decimal ou hexadecimal. L no nome da
instrução e k no argumento.
d) Destino: Local onde será armazenado o resultado da operação. Com (f ou 1), será
armazenado no próprio registro, com (w ou 0) será armazenado no registro Work (W).
e) Bit: Refere-se a um bit dentro do byte. B no nome da instrução e b no argumento.
f) Teste: Quando queremos testar um bit para saber se ele é 0 ou 1. T no nome da instrução.
g) Skip: Usado para criar um desvio, pulando a próxima linha. S no nome da instrução.
h) Set: Setar um bit. S no nome da instrução.
i) Clear: Limpar um bit (zerar). C no nome da instrução.
j) Zero: Algumas instruções podem gerar desvios se o resultado da operação for zero, neste
caso, usa-se Z para indicar tal condição.
6-8
AD D: soma AND: lógica “E” IOR: lógica “OU” COM: complemento

DEC: Decremento INC: incremento MOV: mover, copiar XOR: lógica “OU exclusivo”.
RL: rotacionar um bit para a esquerda RR: rotacionar um bit para a direita
SUB: subtração SWAP: inversão entre niblles
Exemplo: DECFSZ = Decrementa (DEC) o registro (F) e pula (S) se resultado for zero (Z).
6.2.6 – Comentando cada instrução.
ADDLW Soma uma literal com o ADDWF Soma entre os registros W e f.

registro W.
Sintaxe: [label] ADDLW k Sintaxe: [label] ADDWF f,d
Descrição: O valor da constante ou Descrição: O valor de W é somado ao do
literal passada no argumento k é somado registro f e o resultado é armazenado no lugar
ao valor de W e o resultado é armazenado definido por d.
no próprio W. Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1
Limites: 0 ≤ k ≤ 255 (f)
Operação: (W) + (k) → (W) Operação: (W) + (f) → (d)
Status afetados: C, DC, Z Status afetados: C, DC, Z
Código: 11 111x kkkk kkkk Código: 00 0111 dfff ffff
Palavra: 1 Palavra: 1
Ciclo: 1 Ciclo: 1
Exemplo1: ADDLW 0x15 Exemplo1: ADDWF INTCON, F
Antes da instrução: W = Antes da instrução: W = 0x20 e INTCON =
0x20 0x07
Após a instrução: W = Após a instrução: W = 0x20 e INTCON =
0x35 0x27
Z = 0; DC = 0; C = Z = 0; DC = 0; C = 0
0 Exemplo2: ADDWF PORTA,W
Exemplo2: ADDLW 0x15 Antes da instrução: W = 0xF1 e PORTA =
Antes da instrução: W = 0xF1 0x10
Após a instrução: W = 0x06 Após a instrução: W = 0x01
Z = 0; DC = 0; C = Z = 0; DC = 0; C = 1
1 Exemplo3: ADDWF FSR,1
Exemplo3: ADDLW 0x01 Antes da instrução: W = 0xFF e FSR =
Antes da instrução: W = 0x01
0xFF Após a instrução: W = 0xFF e FSR =
Após a instrução: W = 0x00 0x00
Z = 1; DC = 1; C = Z = 1; DC = 1; C = 1
1
COMF Complemento de f. DECF Decrementa o registro f.
6-9
Sintaxe: [label] COMF f,d Sintaxe: [label] DECF f,d

Descrição: Complemento do registro f (inverte Descrição: Decrementa de uma unidade o valor
os bits). O resultado é armazenado em d. do registro f. O resultado é armazenado no lugar
Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1 definido por d.
(f) Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1 (f)
Operação: (f) → (d) Operação: (f) – 1 → (d)
Status afetados: Z Status afetados: Z
Código: 00 1001 dfff ffff Código: 00 0011 dfff ffff
Ciclo: 1 Ciclo: 1
Exemplo: COMF PORTA,F Exemplo: DECF CNT,1
Antes da instrução: PORTA = 0x22 Antes da instrução: CNT = 0x01 e Z
Após a instrução: PORTA = 0xDD e =0
Z=0 Após a instrução: CNT = 0x00 e Z
=1
DECFSZ Decrementa f, pulando se zero. INCF Incrementa o registro f.

Sintaxe: [label] DECFSZ f,d Sintaxe: [label] INCF f,d
Descrição: Decrementa uma unidade do Descrição: Incrementa o valor do registro f
valor do registro f. O resultado é armazenado em uma unidade. O resultado é armazenado
no lugar definido por d. Se o resultado da no lugar definido por d.
operação for zero, a linha seguinte é pulada. Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d =
Quando isto acontece, a instrução demora 1 (f)
dois ciclos. É um desvio condicional. Operação: (f) + 1 → (d)
Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1 Status afetados: Z
(f) Código: 00 1010 dfff ffff
Operação: (f) – 1 → (d) Palavra: 1
Status afetados: nenhum Ciclo: 1
Código: 00 1011 dfff ffff Exemplo: INCF CNT,1
Palavra: 1 Antes da instrução: CNT = 0xFF e
Ciclo: 1 ou 2 Z=0
Exemplo: DECFSZ CNT, F Após a instrução: CNT = 0x00 e
GOTO continua Z=1
GOTO acabou
Antes da instrução: PC = Linha 1 e CNT =
0x10
Após a instrução: Se CNT – 1 ≠ 0
PC = GOTO continua
Se CNT – 1 = 0
PC = GOTO acabou
CNT = CNT - 1
6 - 10
INCFSZ Incrementa f, pulando se zero. SUBLW Subtrai W da literal ou

constante.
Sintaxe: [label] INCFSZ f,d Sintaxe: [label] SUBLW k
Descrição: Incrementa de uma unidade o Descrição: Subtrai o conteúdo do registro W
valor do registro f. O resultado é armazenado da constante k. O resultado é armazenado no
no lugar definido por d. Se o resultado da próprio W.
operação for zero, a linha seguinte é pulada. Limites: 0 ≤ k ≤ 255
Quando isto acontece, a instrução demora Operação: (k) – (W) → (W)
dois ciclos. É um desvio condicional. Status afetados: C, DC, Z
Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1 Código: 11 110x kkkk kkkk
(f) Palavra: 1
Operação: (f) + 1 → (d) Ciclo: 1
Status afetados: nenhum Exemplo1: SUBLW 0x09
Código: 00 1111 dfff ffff Antes da instrução: W = 0x01
Palavra: 1 Após a instrução: W = 0x08
Ciclo: 1 ou 2 Z = 0; DC = 1; C = 1
Exemplo: INCFSZ CNT, F (positivo)
GOTO continua Exemplo2: SUBLW 0x00
GOTO acabou Antes da instrução: W = 0x02
Antes da instrução: PC = Linha 1 e CNT Após a instrução: W = 0x02 (negativo) ou
= 0x00 0xFE
Após a instrução: Se CNT + 1 ≠ 0 Z = 0; DC = 0; C = 0
PC = GOTO (negativo)
continua Exemplo 3: SUBLW 0x10
Se CNT + 1 = 0 Antes da instrução: W = 0x10
PC = GOTO Após a instrução: W = 0x00
acabou Z = 1; DC = 1; C = 1 (positivo
CNT = CNT + 1 ou zero)
SUBWF Subtração entre W e f
6 - 11
Sintaxe: [label] SUBWF f,d

Descrição: Subtrai do registro f o valor de W. O resultado é armazenado no lugar definido
pelo operando d.
Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1 (f)
Operação: (f) – (W) → (d)
Status afetados: C, DC, Z
Código: 00 0010 dfff ffff
Palavra: 1
Ciclo: 1
Exemplo1: SUBWF REG,F
Antes da instrução: W = 0x20 e REG = 0x07
Após a instrução: W = 0x20 e REG = 0xE7 (7 – 32 = -25 decimal ou -25 + 256 = 231
decimal)
Z = 0; DC = 1; C = 0 (negativo)
Exemplo2: SUBWF PORTA,W
Antes da instrução: W = 0x09 e PORTA = 0x10
Após a instrução: W = 0x07 e PORTA = 0x10
Z = 0; DC = 0; C = 1 (positivo ou zero)
Exemplo 3: SUBWF REG,0
Antes da instrução: W 0x10 e REG = 0x10
Após a instrução: W 0x00 e REG = 0x10
Z = 1; DC = 1; C = 1 (positivo ou zero)
ANDLW Operação “E” entre uma literal ANDWF Operação “E” entre W e f.
e W.
Sintaxe: [label] ANDLW k Sintaxe: [label] ANDWF f,d
Descrição: Executa um “E” lógico entre o Descrição: Executa um “E” lógico entre o
valor da constante passado no argumento k e valor de W e o valor do registro f. O resultado
o valor de W. O resultado é armazenado em é armazenado no lugar definido por d.
W. Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1
Limites: 0 ≤ k ≤ 255 (f)
Operação: (W) AND (k) → (W) Operação: (W) AND (f) → (d)
Código: 11 1001 kkkk kkkk Código: 00 0101 dfff ffff
Ciclo: 1 Ciclo: 1
Exemplo: ANDLW 0x0F Exemplo: ANDWF FSR,W
Antes da instrução: W = 0x95 Antes da instrução: W = 0x77 e FSR = 0xFF
Após a instrução: W = 0x05 e Z Após a instrução: W = 0x77; FSR = 0xFF e
=0 Z=0
6 - 12
XORLW Operação “OU exclusivo” entre XORWF Operação “OU exclusivo” entre
k e W. W e f.
Sintaxe: [label] XORLW k Sintaxe: [label] XORWF f,d
Descrição: Executa um “OU” exclusivo Descrição: Executa um “OU” lógico
lógico entre o valor da constante passado no exclusivo entre o valor de W e o valor do
argumento k e o valor de W. O resultado é registro f. O resultado é armazenado no lugar
armazenado em W. definido por d.
Limites: 0 ≤ k ≤ 255 Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d =
Operação: (W) XOR (k) → (W) 1 (f)
Status afetados: Z Operação: (W) XOR (f) → (d)
Código: 11 1010 kkkk kkkk Status afetados: Z
Palavra: 1 Código: 00 0110 dfff ffff
Ciclo: 1 Palavra: 1
Exemplo: XORLW 0x12 Ciclo: 1
Antes da instrução: W = 0x04 Exemplo: XORWF REG,F
Após a instrução: W = 0x16 e Z = Antes da instrução: W = 0x22 e REG = 0x22
0 Após a instrução: W = 0x22, REG = 0x00 e
Z=1
BCF Limpa (clear) um bit do registro f. BTFSC Testa o bit de f, pula se zero.
Sintaxe: [label] BCF f,b Sintaxe: [label] BTFSC f,b
Descrição: Põe a 0 (zero) o bit b do registro Descrição: Se o bit d do registro f for 1, então
f. a próxima linha será executada. Caso seja 0, a
Limites: 0 ≤ f ≤ 127 0 ≤ b ≤ 7 próxima linha será pulada. Neste caso, a
Operação: 0 → (f,b) instrução leva 2 ciclos. É um desvio
Status afetados: nemhum condicional.
Código: 01 00bb bfff ffff Limites: 0 ≤ f ≤ 127 0≤ b≤7
Palavra: 1 Operação: pula se (f,b) = 0
Ciclo: 1 Status afetados: nenhum
Exemplo: BCF STATUS,0 ou BCF Código: 01 10bb bfff ffff
STATUS,C Palavra: 1
Antes da instrução: STATUS = Ciclo: 1 ou 2
B‘11111111’ Exemplo: BTFSC STATUS,2
Após a instrução: STATUS = CLRW
B’1111111 0’ ADDLW 0x02
Obs: Apesar da instrução não afetar Antes da instrução: PC = Linha 1 e STATUS
indiretamente nenum dos flags, neste caso, = 0x18
foi determinado que ela alterasse o flag de Após a instrução: Se bit2 = 0, pula para a
carry do registro de Status (C = 0). instrução ADDLW 0x02, caso seja = 1,
CLRW.
6 - 13
BSF Seta um bit do registro f. BTFSS Testa um bit de f, pula se 1.

Sintaxe: [label] BSF f,b Sintaxe: [label] BTFSS f,b
Descrição: Seta o bit b do registro f. Descrição: Se o bit b do registro f for 0,
Limites: 0 ≤ f ≤ 127 0 ≤ b ≤ 7 então a próxima linha será executada. Caso
Operação: 1 → (f,b) seja 1, a próxima linha será pulada. Neste
Status afetados: nemhum caso, a instrução leva 2 ciclos.
Código: 01 01bb bfff ffff É um desvio condicional.
Palavra: 1 Limites: 0 ≤ f ≤ 127 0≤ b≤7
Ciclo: 1 Operação: pula se (f,b) = 1
Exemplo: BSF TRISB,1 Status afetados: nenhum
Antes da instrução: TRISB = Código: 01 11bb bfff ffff
B‘00000000’ Palavra: 1
Após a instrução: TRISB = Ciclo: 1 ou 2
B’00000010’ Exemplo: BTFSS STATUS,2
Obs: Observe que o registro TRISB CLRW
encontra-se nos bancos 1 e 3. Esta instrução ADDLW 0x02
configura o pino RB1 da porta B como Antes da instrução: PC = Linha 1 e STATUS
entrada. = 0x18
Após a instrução: Se bit2 = 0, não pula a
próxima instrução e caso seja 1, pula para
ADDLW 0x02.
CALL Chama uma sub-rotina. CLRF Limpa (zera) o registro f.

Sintaxe: [label] CALL k Sintaxe: [label] CLRF f
Descrição: Chama a sub-rotina especificada Descrição: Apaga o valor do registro f e seta
por k, que é um endereço da memória de o flag Z.
programação mas normalmente é Limites: 0 ≤ f ≤ 127
representado por um nome (label). Antes do Operação: 0 → (f)
desvio, o endereço de retorno (PC + 1) é 1 → Z
armazenado na pilha e o endereço da sub- Status afetados: Z
rotina e colocado no PC. Call é um desvio Código: 00 0001 1ffff ffff
com retorno. Palavra: 1
Limites: 0 ≤ k ≤ 2047 Ciclo: 1
Operação: (PC) + 1 → (TOS) Exemplo1: CLRF TMR0
(k) → (PC, 10:0) Antes da instrução: TMR0 =
(PCLATH 4:3) → (PC, 12:11) B’11111111’
Status afetados: nemhum Após a instrução: TMR0 =
Código: 10 0kkk kkkk kkkk B’00000000’
Palavra: 1 Z=1
6 - 14
Ciclo: 2 Exemplo2: CLRF STATUS

Exemplo: CALL DELAY Antes da instrução: STATUS = B’00011111’
Antes da instrução: PC = Linha 1 Após a instrução: STATUS = B’00011111’
Após a instrução: PC = DELAY Z=1
Obs: IRP, RP1 e RP0 = 000
TO e PD (somete leitura)
DC e C (não mudam)
Z=1
CLRWDT Limpa o Watchdog Timer. GOTO Desvia para um outro endereço.

Sintaxe: [label] CLRWDT Sintaxe: [label] GOTO k
Descrição: Reseta o contador do WDT e seu Descrição: Desvia o programa para um outro
postscaler, impedindo que o WDT reset a endereço especificado por k, que é um
CPU. Bits /TO e /PD são setados. endereço da memória de programa,
Limites: nenhum. normalmente representado por um nome
Operação: 0 → (WDT) e WDT postscaler (lable). Este é um desvio incondicional e sem
1 → /TO e /PD retorno.
Status afetados: /TO, /PD Limites: 0 ≤ k ≤ 2047
Código: 00 0000 0110 0100 Operação: (k) → (PC, 10:0)
Palavra: 1 (PCLATH,4:3) → (PC,12:11)
Ciclo: 1 Status afetados: nenhum
Exemplo: CLRWDT Código: 10 1kkk kkkk kkkk
Antes da instrução: WDT Palavra: 1
contador = ? Ciclo: 2
WDT Exemplo: GOTO CONTINUA
prescaler = ? Antes da instrução: PC = Linha 1
Após a instrução: WDT contador Após a instrução: PC =
=0 CONTINUA
WDT prescaler
=0
/TO = 1 e /PD
=1
6 - 15
IORLW Operação “OU” entre uma IORWF Operação “OU” entre W e f.

literal e W.
Sintaxe: [label] IORLW k Sintaxe: [label] IORWF f,d
Descrição: Executa um “OU” lógico entre o Descrição: Executa um “OU” lógico entre o
valor da constante passado no argumento k e valor de W e o valor de f. O resultado é
o valor de W. O resultado é armazenado no armazenado no lugar definido por d.
próprio W. Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1
Limites: : 0 ≤ k ≤ 255 (f)
Operação: (W).OR.(k) → (W) Operação: (W).OR.(f) → (d)
Código: 11 1000 kkkk kkkk Código: 00 0100 dfff ffff
Ciclo: 1 Ciclo: 1
Exemplo: IORLW 0x0F Exemplo: IORWF REG,F
Antes da instrução: W = 0x95 Antes da instrução: W = 0x77 e REG =
Após a instrução: W = 0x9F e Z = 0xFF
0 Após a instrução: W = 0x77 e REG = 0xFF
eZ=0
MOVF Move o valor de f para o destino MOVWF Move o valor de W para f.

d.
Sintaxe: [label] MOVF f,d Sintaxe: [label] MOVWF f
Descrição: Copia o valor do registro f para o Descrição: Copia o valor do registro W para
local determinado pelo destino d. o registro f .
Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = Limites: 0 ≤ f ≤ 127
1 (f) Operação: (W) → (f)
Operação: (f) → (d) Status afetados: nenhum
Status afetados: Z Código: 00 0000 1fff ffff
Código: 00 1000 dfff ffff Palavra: 1
Palavra: 1 Ciclo: 1
Ciclo: 1 Exemplo: MOVWF OPTION
Exemplo: MOVF TRISB,W Antes da instrução: OPTION = 0xFF e
Antes da instrução: TRISB = 0x00 e W = 0x4F
W = 0x10 Após a instrução: OPTION = 0x4F e W
Após a instrução: W = 0x00, TRISB = 0x4F
= 0x00 e
Z=1
6 - 16
NOP Não executa nada. RETFIE Retorno de uma interrupção.

Sintaxe: [label] NOP Sintaxe: [label] RETFIE
Descrição: Esta instrução é usada somente Descrição: Retorna da interrupção,
para gastar tempo, pois produz retardo de 1 recuperando o último endereço da pilha e
ciclo de instrução. setando o bit GIE.
Limites: nenhum Limites: nenhum
Operação: nenhuma Operação: TOS → (PC)
Status afetados: nenhum 1 → GIE
Código: 00 0000 0xx0 0000 Status afetados: nenhum
Palavra: 1 Código: 00 0000 0000 1001
Ciclo: 1 Palavra: 1
Exemplo: NOP Ciclo: 2
Exemplo: RETFIE
Após a instrução: PC = TOS e GIE =
1
RETLW Retorna com uma literal em RETURN Retorno de uma sub-rotina.

W.
Sintaxe: [label] RETLW k Sintaxe: [label] RETURN
Descrição: Retorna de uma sub-rotina, Descrição: Retorna de uma sub-rotina,
recuperando o último endereço da pilha, e recuperando o último endereço da pilha.
colocando o valor passado por k em W. Limites: nenhum
Limites: 0 ≤ k ≤ 255 Operação: TOS → (PC)
Operação: (k) → (W) Status afetados: nenhum
TOS → (PC) Código: 00 0000 0000 1000
Status afetados: nenhum Palavra: 1
Código: 11 01xx kkkk kkkk Ciclo: 2
Palavra: 1 Exemplo: RETURN
Ciclo: 2 Após a instrução: PC = TOS
Exemplo: RETLW 0x50
Após a instrução: PC = TOS e W =
0x50
RLF Desloca f um bit para a esquerda. RRF Desloca f um bit para a direita.
6 - 17
Sintaxe: [label] RLF f,d Sintaxe: [label] RRF f,d

Descrição: Desloca o registro f um bit para a Descrição: Desloca o registro f um bit para a
esquerda. O valor do carry é colocado no bit direita. O valor do carry é colocado no bit 7 e
0, e o valor do bit 7 é colocado em carry. O o valor do bit 0 é colocado em carry. O
resultado é armazenado no lugar definido por resultado é armazenado no lugar definido por
d. d.
Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d =
= 1 (f) 1 (f)
Operação: conforme descrito Operação: Conforme descrito.
Status afetados: C Status afetados: C
Código: 00 1101 dfff ffff Código: 00 1100 dfff ffff
Ciclo: 1 Ciclo: 1
Exemplo1: RLF TRISB,W Exemplo1: RRF TRISB,0
Antes da instrução: W = 0x22 , TRISB = Antes da instrução: W = 0x22, TRISB = 0x42
0x42 e C = 1 eC=1
Após a instrução: W = 0x85, TRISB = 0x42 Após a instrução: W = 0xA1, TRISB = 0x42 e
eC=0 (bit exedente da rotação foi zero) C = 0 (bit excedente de rotação foi zero).
Exemplo2: RLF TRISB,F Exemplo2: RRF TRISB,F
Antes da instrução: W = 0x22 , TRISB = Antes da instrução: W = 0x22 , TRISB = 0x8F
0x8F e C = 0 eC=0
Após a instrução: W = 0x22, TRISB = 0x1E Após a instrução: W = 0x22, TRISB = 0x47 e
e C = 1 (bit exedente da rotação foi um) C = 1 (bit exedente da rotação foi um)
Obs: Rotação à esquerda consiste em uma Obs: Rotação à direita consiste em uma
multiplicação por 2 divisão por 2
SLEEP Entra em modo Sleep. SWAPF Inverte os nibbles do registro f.

Sintaxe: [label] SLEEP Sintaxe: [label] SWAPF f,d
Descrição: Coloca o MCU em modo Power- Descrição: Troca os 4 bits MSB com os 4 bits
Down ou Sleep (baixo consumo). O LSB do registro f. O resultado é armazenado
processamento é parado e o conteúdo da no lugar definido por d.
memória é preservado. Limites: 0 ≤ f ≤ 127 d = 0 (W) ou d = 1
Limites: nenhum (f)
Operação: 0 → WDT Operação: (f,3:0) → (d,7:4)
0 → WDT postscaler (f,7:4) → (d,3:0)
1 → /TO Status afetados: nenhum
0 → /PD Código: 00 1110 dfff ffff
Status afetados: /TO, /PD Palavra: 1
Código: 00 0000 0110 0011 Ciclo: 1
Palavra: 1 Exemplo: SWAPF REG,F ou SWAPF
Ciclo: 1 REG,1
Exemplo: SLEEP Antes da instrução: REG = 0x45
Após a instrução: /TO = 1 e /PD = Após a instrução: REG = 0x54
6 - 18
0 W=?
CLRW Limpa (zera) o registro W. MOVLW Move uma literal para W.

Sintaxe: [label] CLRW Sintaxe: [label] MOVLW k
Descrição: Apaga o valor do registro W e Descrição: Copia o valor da constante k
seta o flag Z. (literal) para o registro W.
Limites: nenhum Limites: 0 ≤ k ≤ 255
Operação: 0 → (W) Operação: k → (W )
1 → Z Status afetados: nenhum
Status afetados: Z Código: 11 00xx kkkk kkkk
Código: 00 0001 0000 0011 Palavra: 1
Palavra: 1 Ciclo: 1
Ciclo: 1 Exemplo: MOVLW 0x15
Exemplo: CLRW Antes da instrução: W = ?
Antes da instrução: W = Após a instrução: W = 0x15
B’11111111’
Após a instrução: W =
B’00000000’
Z=1
6.3 - Programação em Linguagem Assembly

Introdução:
A capacidade de comunicar é da maior importância nesta área. Contudo, isso só é possível se
ambas as partes usarem a mesma linguagem, ou seja, se seguirem as mesmas regras para
comunicarem. Isto mesmo se aplica à comunicação entre os microcontroladores e o homem. A
linguagem que o microcontrolador e o homem usam para comunicar entre si é designada por
“linguagem assembly”.
O próprio título não tem um significado profundo, trata-se de apenas um nome como por
exemplo inglês ou francês. Mais precisamente, “linguagem assembly” é apenas uma solução
transitória. Os programas escritos em linguagem assembly devem ser traduzidos para uma
“linguagem de zeros e uns” de modo a que um microcontrolador possa receber. “Linguagem
assembly” e “assembler” são coisas diferentes.
A primeira, representa um conjunto de regras usadas para escrever um programa para um
microcontrolador e a outra, é um programa que corre num computador pessoal que traduz a
linguagem assembly para uma linguagem de zeros e uns. Um programa escrito em “zeros” e
6 - 19
“uns” diz-se que está escrito em “linguagem máquina”. O processo de comunicação entre o
homem e o microcontrolador fisicamente, “Programa” representa um ficheiro num disco de
computador (ou na memória se estivermos a ler de um microcontrolador) e é escrito de acordo
com as regras do assembly ou qualquer outra linguagem de programação de microcontroladores.
O homem pode entender a linguagem assembly já que ela é constituída por símbolos alfabéticos
e palavras. Ao escrever um programa, certas regras devem ser seguidas para alcançar o efeito
desejado. Um Tradutor interpreta cada instrução escrita em linguagem assembly como uma série
de zeros e uns com significado para a lógica interna do microcontrolador.
Consideremos, por exemplo, a instrução “RETURN” que um microcontrolador utiliza para
regressar de um subprograma. Quando o assembler a traduz, nós obtemos uma série de uns e
zeros correspondentes a 14 bits que o microcontrolador sabe como interpretar. Exemplo:
RETURN 00 0000 0000 1000. Analogamente ao exemplo anterior, cada instrução assembly é
interpretada na série de zeros e uns correspondentes.
O resultado desta tradução da linguagem assembly, é designado por um ficheiro de “execução”.

Muitas vezes encontramos o nome de ficheiro “HEX”. Este nome provém de uma representação
hexadecimal desse ficheiro, bem como o sufixo “hex" no título, por exemplo “correr.hex".
Uma vez produzido, o ficheiro de execução é inserido no microcontrolador através de um
programador. Um programa em Linguagem Assembly é escrito por intermédio de um
processador de texto (editor) e é capaz de produzir um ficheiro ASCII no disco de um
computador ou em ambientes próprios como o MPLAB.
Linguagem Assembly
Os elementos básicos da linguagem assembly são:
• Labels (rótulos)
• Instruções
• Operandos
• Diretivas
• Comentários
Label - Um Label (rótulo) é uma designação textual (geralmente de fácil leitura) de uma linha
num programa ou de uma secção de um programa para onde um microcontrolador deve saltar ou,
ainda, o início de um conjunto de linhas de um programa. Também pode ser usado para executar
6 - 20
uma ramificação de um programa (tal como Goto....), o programa pode ainda conter uma
condição que deve ser satisfeita, para que uma instrução Goto seja executada. É importante que
um rótulo (label) seja iniciado com uma letra do alfabeto ou com um traço baixo “_”. O
comprimento de um rótulo pode ir até 32 caracteres. É também importante que o rótulo comece
na primeira coluna.
Instruções - As instruções são específicas para cada microcontrolador, assim, se quisermos
utilizar a linguagem assembly temos que estudar as instruções desse microcontrolador. O modo
como se escreve uma instrução é designado por "sintaxe". No exemplo que se segue, é possível
reconhecer erros de escrita, dado que as instruções movlp e gotto não existem no
microcontrolador PIC16F84.
Operandos - Operandos são os elementos da instrução necessários para que a instrução possa
ser executada. Normalmente são registros, variáveis e constantes. As constantes são designadas
por “literais”. A palavra literal significa “número”.
Comentários - Comentário é um texto que o programador escreve no programa a fim de tornar
este mais claro e legível. Ele é colocado logo a seguir a uma instrução e deve começar com um
ponto e vírgula ";".
Diretivas - Uma diretiva é parecida com uma instrução, mas ao contrário desta, é independente
do tipo de microcontrolador e é uma característica inerente à própria linguagem assembly.
As diretivas servem-se de variáveis ou registros para satisfazer determinados propósitos. Por
exemplo, NIVEL, pode ser uma designação para uma variável localizada no endereço 0Dh da
memória RAM.
Deste modo, a variável que reside nesse endereço, pode ser acedida pela palavra NIVEL. É
muito mais fácil a um programador recordar a palavra NIVEL, que lembra que o endereço 0Dh
contém informação sobre o nível Exemplo de como se escreve um programa.
O exemplo que se segue, mostra como um programa simples pode ser escrito em linguagem
assembly, respeitando regras básicas. Quando se escreve um programa, além das regras
fundamentais, existem princípios que, embora não obrigatórios é conveniente, serem seguidos.
Um deles, é escrever no seu início, o nome do programa, aquilo que o programa faz, a versão
deste, a data em que foi escrito, tipo de microcontrolador para o qual foi escrito e o nome do
programador.
6 - 21
Em linguagem Assembly usa-se a representação mnemônica para definir o código de uma

instrução.
Por exemplo: Addwf f,d
Addwf é o mnemônico para o comando de somar o conteúdo do registro f ao conteúdo
do registro w.
f,d são parâmetros que representam o registro da memória de dados (f) a ser usado e o
operando destino da operação (d).
w registro de trabalho (work) que será usado na maioria das operações lógicas e
aritméticas.
d operando que indica o destino do resultado da operação executada. Assim, se d =0 o
destino será o registro w e se d =1 o destino será o registro f em uso.
A instrução “addwf mem1,0”, efetua a soma do conteúdo do registro de dados apontado por
mem1 com o conteúdo do registro de trabalho w e guarda o resultado em w.
O que faz a instrução “addwf mem1,1?
Após a utilização do assemblador o código da instrução em mnemônico será transformado em
um código binário de 14 bits, denominado código operacional ou opcod. Este código é o
código de máquina que o micro entenderá.
Addwf f,d 000111 dfff ffff
;Programa na linguagem assembly para o micro PIC.
1 INCLUDE “P16C84.inc”
2 LIST P=P16C84
3 DADO1 EQU 0x20

4 DADO2 EQU 0x21
5 DADO3 EQU 0x22
6 ORG 0X00
7 INICIO movlw 03
8 movwf DADO1
9 movf DADO2,0
10 movf DADO3,1
11 end ;última linha do programa (fim).
Um programa em assembly é formado por:
6 - 22
a) Linhas contendo palavras reservadas denominadas diretivas que não são instruções para
o micro mas sim definições de tarefas interpretadas pelo assemblador.
b) Linhas contendo as instruções executadas pelo micro e por palavras definidas pelo
programador que apontarão posições de memória ou registros e/ou posições de endereços
de saltos dos programas. Estas palavras visam melhorar o entendimento do programa.
Deste modo, no exemplo anterior, numeramos as linhas de programação para facilitar a
explicação do mesmo. Assim temos:
Linha 1: contém a diretiva INCLUDE destinada a incluir definições específicas do micro
usado, que auxiliam o programador.
Linha 2: contép0m a diretiva LIST que possibilita a geração de um arquivo de extensão
.LIST, para impressão e arquivamento de relatório. Nem todos os programas precisam
desta diretiva.
Linhas em branco podem ser incluídas para possibilitar uma melhor visualização dos
passos do programa.
Linhas 3, 4 e 5: possuem a diretiva EQU destinada a atribuir ou substituir um valor de
expressão por um nome. O nome DADO1 recebe o valor 20H significando que se for
desejado movimentar um certo valor para a posição de endereço 20H, este endereço poderá
ser referido pelo nome DADO1.
Linha 6: possui a diretiva ORG que define onde será armazenado, na memória de
programa, a próxima instrução do programa.
Linha 7: inicia o programa, o valor 03 será movido para w.
Linha 8: o conteúdo do registro w será movido para o endereço correspondente a DADO1
(20H).
Linha 9: o conteúdo do registro fonte correspondente a DADO2 (21H) será movido para o
destino apontado por zero (0), que será o registro w.
Linha 10: o conteúdo do registro fonte correspondente a DADO3 (22H) será movido para o
destino apontado por um (1), que será o próprio DADO3.
Obs: O PIC possui três instruções de movimento de dados, que permitirão mover um valor
para o registro w, mover um valor do registro w para um registro da memória de dados e
mover um valor de um registro da memória de dados para o registro w.
Linha 11: termina o programa através da diretiva END.
6 - 23
Comentários devem ser incorporados, em qualquer linha do programa, desde que os

mesmos iniciem por um ponto e vírgula (;).
Normas para escrever um programa em assembly.

Existem muitas dificuldades ao se escrever um programa em qualquer linguagem,
principalmente pela falta de experiências.
O modelo abaixo facilita o desenvolvimento e ajuda a evitar erros, mostrando as partes
diferenciadas dentro do programa.
Modelo geral:
Parte Conteúdo Exemplo

1 Diretivas iniciais INCLUDE “P16F84”
2 Atribuição de variáveis e valores Valor EQU 0x25
3 Configurações ORG 0x00
GOTO INICIO
ORG 0x04
GOTO
INTERRUPÇÃO
4 Programa principal
5 Subrotina
6 Subrotina de interrupção
7 Fim do programa END
Parte1: o programa deverá começar pelas diretivas iniciais que darão ordens para o
assemble executar tarefas durante a tradução do programa fonte para o programa
hexadecimal (.HEX), ou linguagem de máquina.
Parte2: definimos nomes para referenciar registros e valores. Assim, no corpo do
programa serão utilizados os nomes ao invés de números, melhorando o entendimento.
Parte3: em configurações devem ser inicializados os registros que serão usados no
programa e também o uso da diretiva ORG, para definir as partes das regiões de memória
ocupadas pelo programa.
6 - 24
Parte4: o corpo principal do programa deve ser implementado e identificado por uma
etiqueta que permita utilizá-lo ou realizar saltos cíclicos durante a execução do programa.
Esta etiqueta nem sempre será obrigatória, porém é uma boa forma de programar.
Parte5: após o programa principal deverão aparecer as subrotinas necessárias para o
programa, que deverão ser encerradas pela instrução return ou retlw.
Parte6: para melhor organização do programa, a subrotina de manuseio de interrupção
deve ser deixada por último e finalizada pela instrução retfie.
Parte7: finaliza o programa com a diretiva END.
Nem todas as partes são obrigatórias ou existirão em um programa. Um programa não
necessita da diretiva LIST, não necessitaria de atribuições de variáveis, porque as
instruções poderiam trabalhar diretamente com os valores de endereços. Se não for usado a
diretiva ORG o programa será iniciado no endereço 00H e também não haverá a
necessidade de empregar subrotinas. Porém, neste caso, o entendimento do programa será
dificultado. Obrigatoriamente haverá a necessidade de terminar o programa com a diretiva
END.
Os programas fonte podem ser escritos em qualquer editor de texto, desde que seja no
formato ASCII. O software MPLAB contém o seu próprio editor de texto.
Com relação a sintaxe do programa, algumas perguntas podem ser feitas:
a) por que algumas palavras são colocadas na primeira coluna e outras não?
b) a escrita em maiúsculo ou minúsculo é obrigatória?
c) em que coluna deve ser colocado um mnemônico? As respostas são conseguidas
através do entendimento de como o assemblador interpretará o arquivo texto fonte e o
transformará no arquivo hexadecimal (.HEX).
Cada dado de todas as linhas do arquivo texto será interpretado como sendo uma etiqueta
(label), um mnemônico, um operando ou um comentário.
Assim estes dados deverão cumprir normas de escrita e normas de posição relativa na linha
ou posição em relação a outro dado. Como regra geral cada dado não deverá exceder 255
caracteres em uma mesma linha.
As etiquetas deverão iniciar na primeira coluna e podem ser seguidas por dois pontos (:),
espaços em branco, tabuladores ou mudança de linha. Contendo até 32 carcteres
6 - 25
alfanuméricos, desde que o primeiro carácter não seja um número, nem uma interrogação.
Porém elas são diferentes se escritas com letras maiúsculas ou minúsculas.
Os mnemônicos, as diretivas e as chamadas macros devem começar pelo menos na
segunda coluna. Se o mnemônico vier após uma etiqueta, deverá existir entre ambos dois
pontos (:), espaços ou tabuladores. Indistintamente podem ser escritos em maiúsculo ou
minúsculo.
Os operandos devem estar separados dos mnemônicos por um ou mais espaços ou por
tabuladores. Se a instrução tiver mais de um operando, a mesma deve estar separada por
vírgula.
Os comentários serão todos os caracteres que estiverem após um ponto e vírgula (;) e até o
final da linha. Se um comentário ocupar mais de uma linha, deverá ser colocado um ponto
e vírgula em cada linha.
O não cumprimento destas regras ocasionarão erros avisados pelo assemblador.
Apesar destas regras permitirem uma boa flexibilidade para o arquivo texto, devem ser
seguidas algumas orientações que melhoram o entendimento e a organização do programa.
São elas:
a) as diretivas e os nomes de variáveis costumam ser escritos em maiúsculo. Se isto não for
feito não haverá problema, porém, deste modo, torna-se fácil diferenciá-los dos
mnemônicos. Não é permitido escrever as variáveis ora de uma forma, ora de outra, pois o
assemblador é sensível a maiúsculo e minúsculo.
b) os mnemônicos devem ser escritos em minúsculo para diferenciar das variáveis e não
tornar o texto cansativo para leitura.
c) os programas devem ser tabulados e alinhados para identificar rapidamente as estruturas
do programa. Linhas em branco, entre partes da estrutura, auxiliam esta identificação.
d) Para posterior modificação ou análise, deve-se colocar o máximo de comentários em um
programa.
6 - 26
RESUMO DO SET DE INSTRUÇÃO.

Para melhor compreensão do conjunto de instruções do PIC é conveniente entender
corretamente os termos usados na construção dos nomes das instruções e seus argumentos.
a) Work (W): Registro temporário usado em operações da ULA (acumulador).
Ex: ADDWF f,d.
b) File: Referência a qualquer local de memória (registro). Usa-se F no nome da instrução e f no
argumento da mesma. Ex: ADDWF f,d.
6 - 27
c) Literal (L no nome da instrução (mnemônicos) e k no argumento (operando) da mesma): Um

número qualquer que pode ser escrito em decimal, hexadecimal ou binário. Ex: ADDLW k.
d) Destino (d): Local onde deve ser armazenar o resultado de uma operação. Se d = 1 ou d = F, o
resultado será guardado no próprio registro passado como argumento e se d = 0 ou d = W, o
resultado será guardado no registro W. Ex: ADDWF f,d.
e) Bit: Refere-se a um bit específico dentro de um registro f. Usa-se B no nome da instrução e b
no argumento da mesma. Ex: BSF f,b
f) Teste: Testa o estado de um bit para saber se ele é 0 ou 1. Usa-se T no nome da instrução. Ex:
BTFSS f,b.
g) Skip (pulo): Usado para criar desvios, pulando a próxima linha. Usa-se S no nome da
instrução. Ex: BTFSS f,b.
h) Set: Seta (“1”) um bit. Usa-se S no nome da instrução. Ex: BSF f,b.
i) Clear: Zera um bit (“0”). Usa-se C no nome da instrução. Ex: BCF f,b.
j) Zero: Algumas instruções podem gerar desvios se o resultado da operação for zero. Usa-se Z
para indicar tal condição. Ex: DECFSZ f,d.
k) ADD: Somatória.
l) AND: Lógica “E”.
m) CLR: Limpar, zerar (clear).
n) COM: Complemento.
o) DEC: Decremento de uma unidade.
p) INC: Incremento de uma unidade.
q) IOR: Lógica “OU”.
r) MOV: Mover, transferir para outro lugar.
s) RL: Rotacionar 1 bit para a esquerda (rotation left).
t) RR: Rotacionar 1 bit para a direita (rotation right).
u) SUB: Subtração.
v) SWAP: Inversão entre os 4 bits MSB com os 4 bits LSB de um registro.
x) XOR: Lógica “OU exclusivo”.
Exemplo de uma instrução:
DECFSZ = Decrementa (DEC) o registro (F) e pula (S) se o resultado for zero (Z)
Quando o resultado alterar os flags C, DC e Z, temos:
6 - 28
a) C = “1”, se o resultado ultrapassar o valor 255;

b) C = “0”, se o resultado não ultrapassar o valor 255;
c) DC = “1”, se houver transbordo do terceiro para o quarto bit do registro;
d) DC = “0”, se não houver transbordo do terceiro para o quarto bit de registro;
e) Z = “1”, se o valor armazenado em W for igual a zero;
f) Z = “0”, se o valor armazenado em W for diferente de zero.
Obs: Pra determinar o valor real armazenado no destino (W) quando superior a 255, basta
subtrair 256 do resultado. O valor resultante será o efetivamente armazenado no destino. Neste
caso, o flag C estará em nível “1”, indicando que houve a condição de estouro do registro.
Destino de um resultado (ex: ADDWF f,d):
a) d = 0 ou d = W, o resultado será armazenado em W.
b) d = 1 ou d = f, o resultado será armazenado no próprio registro f.
Parte Experimental
A Microchip disponibiliza ferramentas para desenvolvimento de aplicações para seus
microcontroladores PIC. Dentre estas ferramentas podemos citar o MPLAB e o PICShell. O
MPLAB é um IDE que fornece uma integração entre editor de texto, compiladores e
microcontroladores.
OBS: Normalmente, os grupos de instruções muito usados são ligados numa única unidade que
pode ser facilmente invocada por diversas vezes num programa, uma unidade desse tipo chama-
se genericamente Macro e, normalmente, essa unidade é designada por um nome especifico
facilmente compreensível. Com a sua utilização, a seleção entre os dois bancos torna-se mais
clara e o próprio programa fica mais legível.
BANK0 macro
bcf STATUS, RP0 ; Selecionar o banco 0 da memória
Endm
BANK1 macro
bsf STATUS, RP0 ; Selecionar o banco 1 da memória
Endm
6.4- Exercícios propostos:

1) Qual o valor dos bits Z, DC e C de registro STATUS no final do fragmento do programa
abaixo? Demonstre o processo lógico:
6 - 29
MOVLW 0x38
ADDLW0xDC
2) Em um PIC16F84, foi conectado um led no pino RB3. Sabendo-se que o led acende com nível
lógico baixo e sabendo-se que o registro TRISB = A3h e o PORTB = E4h. Pergunta-se: O led
estará acesso ou apagado? Justifique:
3) Qual o tempo de retardo (Delay) de um programa do PIC16F84 se o timer0 tiver valor inicial
de 0Ah e o prescaler estiver setado com um fator de divisão de 1:128?
4) Se o clock externo de um PIC qualquer for de 2Mhz, informe o tempo que o pulso leva para
chegar ao TMR0 :
5) Qual o tempo que o TMR0 leva para transbordar se for carregado com 1Ah e o clock interno
for de 1 microsegundo com o prescaler desabilitado?
6) O que o fabricante fez para permitir a migração de um modelo PIC para outro sem a
necessidade de grandes alterações?
7) Como é conhecido o bit em programação utilizado para indicar um evento?
6 - 30

MOVLW 0hAB
MOWF PORTB
MOVLW 0xBC
ADDWF PORTB,0

MOVLW0hBC
MOWF PORTA
MOVLW 0xBC
SUBWF PORTA,0
10) Escreva um programa em linguagem Assembly que leia o pino RB0 ligado a chave S1 tipo
push-botton acionada em nível lógico 0(zero), conforme diagrama esquemático. Caso a chave
S1 seja pressionada, o programa fará com que o led conectado ao pino RB7 fique piscando num
intervalo de 1segundo toda vez que a chave S1 estiver sendo pressionada.
Observe o diagrama esquemático, para sanar qualquer dúvida, depois execute este programa nas
aulas práticas no laboratório.
Diagrama Esquemático:
11) Escreva um programa em linguagem Assembly que irá ler os pinos RA3 e RA2 ligados a
chave T1 e T2 (chaves do tipo push-boton acionada em nível lógico 0(zero)). Caso a chave T1
6 - 31
seja pressionada, o programa fará com que o led fique piscando com intervalos de
aproximadamente 500ms. O led somente deixará de piscar, quando a chave T2 for pressionada.
Diagrama Esquemático ao lado
12) Implementação de
Programa.
Escreva um programa em linguagem
Assembly que irá ler o pino RA4 ligado a chave T1(push-boton acionada em nível lógico
0(zero)). Caso esta chave seja pressionada pela primeira vez, o programa fará os leds ficarem
piscando com intervalos de aproximadamente 250ms. Os leds somente deixarão de piscar,
quando a chave T1 for pressionada pela segunda vez e assim sucessivamente.
Diagrama Esquemático ao lado
6 - 32
CAPÍTULO 7
INTRODUÇÃO AO ARDUÍNO
7.1- Introdução
Na década de 90 surgem novas versões da arquitetura Harvard, uma dessas que
também se popularizou foi desenvolvida pela ATMEL com o nome AVR, e é uma
das primeiras famílias de microcontroladores a usar Memória de Programa do tipo
Flash. O AVR foi desenvolvido em uma House ASIC (Application Specific
Integrated Circuit) na Trondheim, Noruega, onde os dois fundadores da ATMEL
trabalhavam. O nome AVR não é uma sigla e também não é declarado pela ATMEL
o que representa.
O sistema Arduino é um conjunto de software e hardware estruturado em torno dos
microcontroladores do fabricante ATMEL.
Arduino é uma plataforma de prototipagem eletrônica open-source baseada no uso

fácil de hardware e software.
Arduino Mega2560
O ambiente de desenvolvimento contém um editor de texto para escrever código, uma

área de mensagem, um console de texto, uma barra de ferramentas com botões para
funções comuns, e uma série de menus.
7-1
As principais funcionalidades do IDE do

Arduino são:
- Escrever o código do programa
- Salvar o código do programa
- Compilar um programa
- Transportar o código compilado para a
placa do Arduino
O monitor serial é utilizado para

comunicação entre o Arduino e o
Softwares escritos usando Arduino são chamados de sketches e tem o mesmo efeito de um
código fonte. Os Sketches são as escritas no editor de texto e são salvos com a extensão do
arquivo “nome do arquivo.ino”. O console exibe saída de texto pelo ambiente Arduino,
incluindo mensagens de erro e outras informações, no canto direito inferior da janela exibe o
atual diretório e porta serial.
computador (PC).
7-2
Os comandos adicionais são encontrados dentro dos cinco menus: Arquivo, Editar,
Sketch, Ferramentas, Ajuda.
Editar
 Copiar para o Fórum
Copia o código do seu esboço para o clipboard em um formato adequado para a
postagem no fórum, preencha com coloração de sintaxe.
 Copiar como HTML
Copia o código do seu esboço para a área de transferência como HTML, apropriado
para inclusão em páginas da web.
Sketch
 Verificar/Compilar - Verifica o seu esboço para erros.
 Exibir pastas dos Sketch. - Abre a pasta esboço Sketch.
 Adicionar Arquivo... - Adiciona um arquivo de origem para o desenho. O novo
arquivo será exibido em uma nova aba na janela de desenho. Os arquivos podem ser
removidos do esboço usando o menu tab.
 Importar Biblioteca - Adiciona uma biblioteca para o seu esboço, inserindo
#include no início do seu código. Além disso, com a versão 1.0.5 e posterior do IDE,
você pode importar uma biblioteca de um arquivo “nome do arquivo.Zip”.
Ferramentas
 Auto Formatação - Isto formata o código facilmente. Pode recuá-lo para para
abertura e fechamento de linha de chaves e que também para as instruções dentro de
chaves fiquem mais recuadas.
 Arquivar o Sketch - Cria um arquivo formato zip do esboço atual. O arquivo é
colocado no mesmo diretório do esboço.
 Placa - Selecione a placa que você está usando.
 Port - Este menu contém todos os dispositivos seriais (real ou virtual) em sua
máquina. Deve atualizar automaticamente cada vez que você abrir o menu de
ferramentas de nível superior.
7-3
 Gravador - Para selecionar um programador de hardware quando se deseja programar

uma placa ou chip sem usar a conexão USB-serial onboard.
 Gravar Bootloader - Os itens neste menu permitem que você grave um bootloader
para o microcontrolador em uma placa Arduino. Isso não é necessário para o uso
normal de uma placa Arduino, mas é útil se você comprar um novo microcontrolador
Atmega (que normalmente vem sem um bootloader).
 Monitor Serial - Apresenta dados seriais sendo enviados da placa Arduino (USB ou
serial). Para enviar dados para a placa, digite o texto e clique no botão "enviar" ou
pressione enter. Escolha a taxa de transmissão a partir do drop-down que corresponde a
taxa que é configurada pela função “Serial.begin ( )” em seu código.
Arquivo
 Sketchbook - O ambiente Arduino usa o conceito de um caderno de desenho: um
local padrão para armazenar seus programas (ou desenhos). Os esboços em seu
caderno podem ser abertos a partir de Arquivo>Sketchbook menu ou no botão Open na
barra de ferramentas. A primeira vez que você executar o software Arduino, ele criará
automaticamente um diretório para o seu Sketchbook. Você pode visualizar ou alterar a
localização do local do sketchbook na janela Preferências.
 Carregar - Antes de carregar o seu código, você precisa selecionar os itens corretos.
No Windows, a porta é provavelmente a COM1 ou COM2 (para uma placa serial) e
COM4 ou superior (para uma placa USB). Para descobrir a porta basta olhar para o
dispositivo serial USB na seção portas do Gerenciador de Dispositivos do Windows.
 Preferências - Entre outras opções o item Preferências serve para mudar o idioma
manualmente. Selecione o seu idioma preferido no menu e reinicie o software para usar
o idioma selecionado. Se o seu idioma preferido não é suportado, a IDE usará o Inglês.
Placas Arduino atuais irão reiniciar automaticamente antes de iniciar o carregamento.
Com placas mais antigas que carecem de auto-reset, você precisa pressionar o botão de
reset na placa antes de iniciar um carregamento.
7-4
Na maioria das placas, você vai ver os LEDs RX e TX piscarem enquanto o código é
carregado. O ambiente Arduino irá exibir uma mensagem quando o carregamento
estiver completo, ou mostrar um erro.
Quando você carrega um código, você está usando o bootloader que é um pequeno
programa carregado no microcontrolador antes do seu código. Ele permite que você
faça o upload de código sem usar qualquer hardware adicional. O bootloader é ativo
durante alguns segundos quando a placa é reinicializada, então ele recebe qualquer
código que está sendo enviado ao microcontrolador. O bootloader vai piscar o on-
board (pino 13) LED quando ele começa.
Ao iniciar o Arduino, a janela de edição de códigos apresenta duas funções padrões.
Elas servem para orientar o programador nos primeiros passos de sua programação.
Em linguagem “C” é necessário a criação de uma estrutura (função) com o nome
“main” que deverá ser preparada pelo compilador na primeira execução de programa.
No caso da IDE arduino a criação da estrutura “main” se torna transparente aos olhos
do programador, neste sistema, um conjunto de softwares (linker) farão a montagem do
código mantendo todas as regras impostas ao padrão da linguagem.
A estrutura “loop” é padrão para todos os códigos fonte do Arduino e despensa a
necessidade do programador prover artifícios cíclicos para a montagem do código
principal. Já a estrutura “setup” tem o objetivo de acumular todos os códigos que
deverão ser executados uma única vês e no momento da inicialização do hardware.
O compilador GCC é um compilador C++ por trás de um editor de códigos que inclui,
entre outras facilidades, as funções loop e setup para dinamizar a rotina de montagem
dos códigos. Estas regras que foram incluídas no sistema arduino alteram a
originalidade da linguagem C++ e com isso o nome da linguagem.
A linguagem Arduino é baseada em programação open-source para microcontroladores
e está programação foi titulada como “Wiring”. O Wiring permite escrever software
multiplataforma para controlar dispositivos conectados a uma ampla gama de placas
arduino e criar todos os tipos de codificações criativas, objetos interativos, espaços ou
experiências físicas.
7-5
7.1.1-Características do Microcontrolador ATMEGA328P

O ATMEGA328P pertencente à família de microcontroladores AVR. O AVR é uma
das primeiras famílias de microcontroladores Harward a usar Memória de Programa do
tipo Flash e foi desenvolvida em uma House ASIC (Application Specific Integrated
Circuit) na Trondheim, Noruega, onde os dois fundadores da ATMEL trabalhavam. O
nome AVR não é uma sigla e, também não é declarado pela ATMEL o que representa.
As principais características do dispositivo são:

 Microcontrolador de 8 bit
 Arquitetura Harward/RISC
 131 Instruções
 32 Registros Working de 8 bit
 32K Bytes de memória de programa do tipo flash com sistema de gravação ISP
 1K Bytes de EEPROM
 1K Byte de SRAM
 Aceita 10.000 ciclos de escrita/apagamento na memória flash e 100.000 na EEPROM
 Retenção de dados: 20 anos a 85°C ou 100 anos a 25°C
 2 Timer/Counters de 8 bit
 1 Timer/Counters de 16 bit
 1 RTC com oscilador independente
 6 canais PWM
 8 canais ADC de 10 bit para encapsulamento TQFP, QFN e MLF
 3 interfaces seriais: TWI, USART e SPI
 1 Watchdog Timer com oscilador independente
 1 Comparador analógico
 1 Oscilador RC
 32 pinos de I/O
 Voltagem de operação: 1,8 a 5,5V
 Frequência de operação: 0 a 20MHz
 Consumo no modo ativo: 200μA
7-6
7.1.2 – Unidade Central de Processamento (CPU)
Diagrama em bloco do ATmega8
7-7
7.2- Ardino UNO

Blocos do Arduino
-CARACTERÍSTICAS:
• Microcontrolador: ATmega328
• Tensão de operação: 5V
• Tensão recomendada (entrada): 7-12V
• Limite da tensão de entrada: 6-20V
• Pinos digitais: 14 (seis pinos com saída PWM)
• Entrada analógica: 6 pinos
• Corrente contínua por pino de entrada e saída: 40 mA
• Corrente para o pino de 3.3 V: 50 mA
• Quantidade de memória FLASH: 32 KB (ATmega328) onde
0.5 KB usado para o bootloader
• Quantidade de memória SRAM: 2 KB (ATmega328)
• Quantidade de memória EEPROM: 1 KB (ATmega328)
• Velocidade de clock (cristal): 16 MHz
7-8
Internamente, o circuito do Arduino é alimentado com uma tensão de 5V.
O Arduino UNO pode ser alimentado pela porta USB ou por uma entrada do tipo “Power
Jack” (com o positivo ao centro) através de uma fonte externa DC.
A recomendação é que a fonte externa seja de 7 V a 12 V e pode ser ligada diretamente no
conector de fonte ou nos pinos Vin e Gnd.
3,3 V. - Fornece tensão de 3,3V. para alimentação de shield e módulos externos. Corrente
máxima de 50 mA.
5 V - Fornece tensão de 5 V para alimentação de shields e circuitos externos.
GND - pinos de referência, terra.
VIN - pino para alimentar a placa através de shield ou bateria externa. Quando a placa é
alimentada através do conector Jack, a tensão da fonte estará nesse pino.
Portas digitais e analógicas
O Arduino possui tanto portas digitais como

portas analógicas.
As portas servem para comunicação entre o Arduino e dispositivos externos, por exemplo: ler
um botão, acender um led ou uma lâmpada.
7-9
Conforme já mencionado, o Arduino UNO, possui 14 portas digitais e 6 portas analógicas (que
também podem ser utilizadas como portas digitais).
Os conversores analógicos-digitais (ADC) do Arduino são de 10 bits.
Os valores lidos numa porta analógica variam de 0 a 1023 (10 bits), onde 0 representa 0V e
1023 representa 5V.
Portas digitais
As portas digitais trabalham com valores bem definidos, ou seja, no caso do Arduino esses
valores são 0V e 5V.
0V indica a ausência de um sinal e 5V indica a presença de um sinal.
Para escrever numa porta digital basta utilizar a função digitalWrite (pin, estado).
Para ler um valor numa porta digital basta utilizar a função digitalRead (pin).
Portas Analógicas
As portas analógicas são utilizadas para entrada de dados.
O Arduino UNO possui 6 (seis) portas analógicas.
As portas analógicas no Arduino UNO são identificadas como A0, A1, A2, A3, A4 e A5.
Estas portas também podem ser identificadas por 14 (A0), 15 (A1), 16 (A2), 17 (A3), 18 (A4)
e 19 (A5).
Por padrão todas as portas analógicas são definidas como entrada de dados, desta forma não é
necessário fazer esta definição na função setup ( ).
Os valores lidos numa porta analógica variam de 0V a 5V.
Para ler um valor numa porta analógica basta utilizar a função analogRead(pin).
O que é PWM?
PWM, do inglês Pulse Width Modulation, é uma técnica utilizada por sistemas digitais para
variação do valor médio de uma forma de onda periódica. A técnica consiste em manter a
7 - 10
frequência de uma onda quadrada fixa e variar o tempo que o sinal fica em nível lógico alto.
Esse tempo é chamado de duty cycle, ou seja, o ciclo ativo da forma de onda. No gráfico ao
lado são exibidas algumas modulações PWM.
Diagrama em bloco do Atmega
7 - 11
O 1º passo consiste em efetuar o download do respectivo software de desenvolvimento, o

Arduino IDE 1.0.5, através do site oficial Arduino (www.arduino.cc\ )
O 2º passo consiste em descompactar o ficheiro “.ZIP” para uma pasta à sua escolha.
O 3º passo consiste em ligar a placa Arduino ao computador através do cabo USB e instalar os
drivers FTDI, para permitir uma conversão de USB para série.
O 4º passo consiste em configurar a porta série a ser utilizada e qual o tipo de modelo
Arduino, que nos encontramos a utilizar. Para tal, necessitamos de abrir o Software de
desenvolvimento e escolher na barra de separadores a opção “Tools”.
O 5º passo para a utilização do Software consiste em elaborar o seu Sketch (programa),

compilar e, caso não tenha erros, fazer o uploading para a placa Arduino.
7 - 12
Programando no Arduino
Exemplo (1) – Saída Digital
/*
-----------------------------------
1º Exercício
-----------------------------------
Ligar e desligar um LED por um segundo
*/
//------------------------------------
//Função principal
//------------------------------------
void setup() // Executa-se quando o arduino é ligado
{
pinMode(13,OUTPUT); // Inicializa o pin 13 como uma saída
}
//------------------------------------
//Função repetitiva
//------------------------------------
void loop( ) // Esta função executa-se o instante todo
// quando está ligado o Arduino
{
digitalWrite(13,HIGH); // Liga o LED
delay(1000); // Temporiza um segundo
digitalWrite(13,LOW); // Desliga o LED
delay(1000); // Temporiza um segundo
}
7 - 13
7.3-Introdução à Arduino MEGA 2560

A placa Arduino MEGA 2560 é uma ótima opção para expandir seus projetos, quando há a
necessidade de mais pinos ou quantidade de memória FLASH. Possui desempenho parecido
com a placa Arduino UNO, porém possibilitando maior quantidade de recursos, como mais
entradas analógicas e saídas PWM. Pode ser aplicada em automação residencial, robótica e em
vários projetos eletrônicos que necessitem de muitos pinos digitais ou analógicos.
Ela é mais uma placa da plataforma Arduino que possui recursos bem interessantes para
prototipagem e projetos mais elaborados. Baseada no microcontrolador ATmega2560, possui
54 pinos de entradas e saídas digitais onde 15 destes podem ser utilizados como saídas PWM.
Possui 16 entradas analógicas, 4 portas de comunicação serial. Além da quantidade de pinos,
ela conta com maior quantidade de memória que Arduino UNO, sendo uma ótima opção para
projetos que necessitem de muitos pinos de entradas e saídas além de memória de programa
com maior capacidade. A seguir serão apresentadas as suas características construtivas,
passando pelos principais recursos que essa placa apresenta.
Alimentação da placa Arduino MEGA
A alimentação da placa Arduino Mega, como ocorre na Arduino UNO pode ser feita tanto pela
USB, como por uma alimentação externa. A seguir são apresentados os conectores para
alimentação:
Figura 1 - Alimentação da placa Arduino Mega
Como na placa Arduino UNO, a alimentação externa é feita através do conector Jack com
positivo no centro, onde o valor de tensão da fonte externa deve estar entre os limites 6V. a
20V., porém se alimentada com uma tensão abaixo de 7V., a tensão de funcionamento da
7 - 14
placa, que no Arduino MEGA 2560 é de 5V, pode ficar instável e quando alimentada com
tensão acima de 12V, o regulador de tensão da placa pode sobreaquecer e danificar a placa.
Dessa forma, é recomendado para tensões de fonte externa valores de 7V. a 12V.
O circuito regulador para entrada externa é idêntico ao da Arduino Uno e o CI responsável

pela regulação de tensão é o OnSemi NCP1117
Quando o cabo USB é plugado a um PC, por exemplo, a tensão não precisa ser estabilizada
pelo regulador de tensão, dessa forma a placa é alimentada diretamente pela USB. O circuito
da USB apresenta alguns componentes que protegem a porta USB do computador em caso de
alguma anormalidade.
Nele existe um fusível resetável (F1) de 500 mA. impede que a porta USB do computador
queime, caso ocorra algum problema de projeto ou uma falha no circuito e ultrapasse a
corrente de 500 mA. quando a placa estiver conectada ao PC. O ferrite L1 foi incluído no
circuito para que ruídos da USB externa não entrem no circuito da placa Arduino através do
terra.
Além dos recursos apresentados anteriormente a placa conta com um circuito para comutar a
alimentação automaticamente entre a tensão da USB e a tensão da fonte externa. Caso haja
uma tensão no conector DC e a USB é conectada, a tensão de 5V será proveniente da fonte
externa e USB servirá apenas para comunicação com o PC.
Na placa um regulador de 3,3V. (U2- LP2985). Este componente é responsável por fornecer
uma tensão contínua de 3,3V para alimentação de circuitos ou shields que necessitem desse
valor de tensão. Deve-se ficar atento ao limite máximo valor de corrente que este regulador
pode fornecer, que no caso é de 50 mA.
A seguir são exibidos os conectores de alimentação para conexão de shields e módulos na

placa Arduíno MEGA:
7 - 15
Figura 5 - Conectores de alimentação para conexão de shields e módulos na placa MEGA
IOREF - Fornece uma tensão de referência para que shields possam selecionar o tipo de
interface apropriada, dessa forma shields que funcionam com a placas Arduino que são
alimentadas com 3,3V. podem se adaptar para ser utilizados em 5V. e vice-versa.
RESET - pino conectado a pino de RESET do microcontrolador. Pode ser utilizado para um
reset externo da placa Arduino.
3,3 V - Fornece tensão de 3,3V. para alimentação de shield e módulos externos. Corrente
máxima de 50 mA.
5 V - Fornece tensão de 5 V para alimentação de shields e circuitos externos.
GND - pinos de referência, ground, terra.
VIN - pino para alimentar a placa através de shield ou bateria externa. Quando a placa é
alimentada através do conector Jack a tensão da fonte estará nesse pino
EXEMPLO: Se a placa for alimentada com 12V, nesse pino Vin terá 12V.
Comunicação USB
Como interface USB para comunicação com o computador, há na placa um microcontrolador

ATMEL ATMEGA16U2.
7 - 16
Figura 6 - Conversor USB-serial com ATmega16u2
Este microcontrolador é o responsável pela forma transparente como funciona a placa

ARDUINO MEGA 2560, possibilitando o upload do código binário gerado após a compilação
do programa feito pelo usuário. Possui um conector ICSP para gravação de firmware através
de um programador ATMEL, para atualizações futuras.
Nesse microcontrolador também estão conectados dois leds (TX, RX), controlados pelo
software do microcontrolador, que indicam o envio e recepção de dados da placa para o
computador. Ele possui um cristal externo de 16 MHz. É interessante notar a conexão entre
este microcontrolador com o ATMEL ATMEGA2560 onde é feita pelo canal serial desses
microcontroladores. Outro ponto interessante que facilita o uso da placa Arduino é a conexão
do pino 13 do ATMEGA16U2 ao circuito de RESET do ATMEGA2560, possibilitando a
entrada no modo bootloader automaticamente quando é pressionado o botão Upload na IDE.
Essa característica não acontecia nas primeiras placas Arduino onde era necessário pressionar
o botão de RESET antes de fazer o Upload na IDE.
Microcontrolador da placa Arduino MEGA 2560
O microcontrolador utilizado na Arduino MEGA 2560 é o ATMEL ATmega2560, um

microcontrolador de 8 bits de arquitetura RISC avançada. Esse microcontrolador possui mais
recursos comparado ao ATmega328 da Arduino UNO. Ele conta com 256 KB de Flash (mais
7 - 17
8 KB são utilizados para o bootloader), 8 KB de RAM e 4 KB de EEPROM. Chega 16 MIPS,

operando em 16 MHz.
Possui multiplicador por Hardware e diversos periféricos que aumentam as possibilidades da

plataforma Arduino baseada em Atmel ATMEGA, dentre as quais pode-se destacar 4 canais
de comunicação serial, 16 entradas analógicas e 15 saídas PWM. Possui ainda comunicação
SPI, I2C e 6 pinos de interrupções externas.
Segue abaixo uma imagem deste microcontrolador com encapsulamento TQFP, o mesmo
utilizado na placa Arduino Mega 2560:
Figura 8 - Microcontrolador ATmega2560
Pinos de entradas e Saídas da placa Arduino MEGA 2560
A placa Arduino MEGA 2560 possui 54 pinos de entradas e saídas digitais que podem ser
utilizadas como entrada ou saída conforme a necessidade de seu projeto, através das
funções pinMode(), digitalWrite(), e digitalRead(). Os pinos operam com tensão de 5V e
podem fornecer ou drenar até 40 mA. Cada pino possui resistor de pull-up interno que pode
ser habilitado por software ( INPUT_PULLUP). Alguns desses pinos possuem funções
especiais como exibido a seguir:
 Comunicação Serial - Serial 0 (RX) e 1 (TX); Serial 1: 19 (RX) e 18 (TX); Serial 2: 17

(RX) e 16 (TX); Serial 3: 15 (RX) e14 (TX). Os pinos 0 e 1 estão conectados aos pinos
do ATmega16U2 responsável pela comunicação USB
 Interrupções externas - 2 (interrupt 0), 3 (interrupt 1), 18 (interrupt 5), 19 (interrupt 4),
20 (interrupt 3), and 21 (interrupt 2). Estes pinos podem ser configurados para disparo
da interupção tanto na borda de subida ou descida, ou em niveis lógicos alto ou baixo,
7 - 18
conforme a necessidade do projeto. Veja a função attachInterrupt() para mais

detalhes.
 PWM: os pinos 2 a 13 e 44 a 46 podem ser utilizados como saídas PWM. O sinal

PWM possui 8 bits de resolução e é implemetado com a função analogWrite().
 Comunicação SPI: Pinos: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS). A comunicação

SPI pode ser manipulada pela função SPI library. Estes pinos estão ligados ao
conector ICSP.
 Comunicação I2C: (TWI): pinos 20 (SDA) and 21 (SCL).
A Arduino Mega2560 possui 16 entradas analógicas (pinos A0 a A15), onde pode ser feita a
conversão com uma resolução de 10 bits, ou seja, o valor será convertido entre 0 e 1023. Por
padrão a tensão de referência é conectada a 5V. Porém é possível mudar o valor de referência
através do pino AREF e a função analogReference().
Características físicas
A placa Arduino MEGA 2560 possui dimensões relativamente pequenas para as quantidades
de pinos disponíveis. Possui dimensões de 4”X 2,1” (10cm x 5,5cm). A imagem a seguir dá
uma ideia da dimensão desta placa:
Figura 9 - Dimensões da Arduino Mega 2560
7 - 19
Resumo da placa Arduino MEGA 256
Figura 10 - resumo de recursos da Arduino MEGA 2560
Shields
É possível agregar novas funcionalidades a uma placa do Arduino.
As extensões das placas do Arduino são chamadas de shields.
Existem shields para as mais diversas funcionalidades, por exemplo:
Comunicação ethernet
Comunicação wifi
Comunicação bluethooth
Ponte H
Banco de relês
Ethernet Shield
Adicionar uma biblioteca
Possivelmente algum dia vai precisar de adicionar uma biblioteca para trabalhar com algum
sensor ou outro componente no Arduino. Existem diversas bibliotecas disponíveis na internet,
que pode baixar e utilizar. Entretanto tem que adicioná-las ao seu IDE para que o mesmo
7 - 20
reconheça os comandos que está a utilizar. Para mostrar como proceder, vamos adicionar a
biblioteca MsTimer2.h como exemplo. Podemos baixá-la na página do Arduino
(http://arduino.cc/playground/Main/MsTimer2). Feito isso, descompacte o arquivo.zip que foi
baixado. Agora vá até à pasta onde “instalou” o seu IDE para o Arduino e procure pela pasta
libraries. Dentro deste diretório copie a pasta que foi extraída anteriormente.
Por fim, vamos verificar se a biblioteca foi mesmo detectada pelo IDE. Vá a Files > Examples
e verifique se a biblioteca que acabamos de adicionar está ali. Se sim, a instalação ocorreu
bem e já pode começar a utilizar a sua nova biblioteca. Agora é só “chamá-la” no seu
código,que neste caso ficaria: #include <MsTimer2.h>.
Módulo de Reconhecimento de Voz ELECHOUSE V3

O Módulo de Reconhecimento de Voz ELECHOUSE é uma placa de reconhecimento de fala
compacta e fácil de controlar. Este produto é um módulo de reconhecimento de voz
dependente de alto-falante. Ele suporta até 80 comandos de voz no total. No máximo 7
comandos de voz podem funcionar ao mesmo tempo. Qualquer som pode ser treinado como
comando. Os usuários precisam treinar o módulo antes de deixá-lo reconhecer qualquer
comando de voz. Esta placa possui 2 formas de controle: Porta serial (função completa), Pinos
de entrada geral ( parte da função). Os pinos de saída geral na placa podem gerar vários tipos
de ondas enquanto o comando de voz correspondente é reconhecido.
Especificações Rápidas
 Tensão: 4,5-5,5V
 Corrente: <40mA
 Interface digital: nível 5V TTL para
interface UART e GPIO
 Interface analógica: conector de microfone
de canal mono de 3,5 mm + interface de pino de
microfone
 Tamanho: 31 mm x 50 mm
7 - 21
 Precisão de reconhecimento: 99% (em ambiente ideal)

 Suporta no máximo 80 comandos de voz, com cada voz 1500ms (uma ou duas palavras
falando)
 Máximo de 7 comandos de voz eficazes ao mesmo tempo
 Saída de pino geral de controle do usuário
Arduino Nome e n° Descrição

do Pin VR3
Habilitar / Este pino é usado para alternar entre o Modo de Dados (definido como
chave -1 baixo) e o modo de comando AT (definido como alto). Por padrão,
está no modo de dados
Vcc Vcc - 2 Alimenta o módulo. Conecte a tensão de alimentação de + 5V
Terra Terra -3 Pino de aterramento do módulo, conecte ao aterramento do sistema.
1 TX- 4 - Transmite dados seriais. Tudo o que for recebido via Bluetooth será
Transmissor fornecido por este pino como dados seriais.
0 RX 5 Receber dados seriais. Todos os dados seriais fornecidos a este pino

Receptor serão transmitidos via Bluetooth
Estado O pino de estado é conectado ao LED integrado e pode ser usado

como um feedback para verificar se o Bluetooth está funcionando
corretamente.
CONDUZIU Indica o status do Módulo
7  Pisca uma vez em 2 segundos: o módulo entrou no modo de

comando
 Piscando repetidamente: Aguardando conexão em modo de
dados
 Piscar duas vezes em 1 segundo: conexão bem-sucedida no
modo de dados
Botão - 8 Usado para controlar o pino Chave / Habilitar para alternar entre
Dados e Modo de comando
7 - 22
Módulo HC-05 Bluetooth
Configurações padrão do HC-05
Nome Bluetooth padrão: “HC-05”
Senha padrão: 1234 ou 0000
Comunicação padrão: Slave
Modo padrão: modo de dados
Taxa de Baud do modo de dados: 9600, 8, N, 1
Taxa de Baud do Modo de Comando: 38400, 8, N, 1
Firmware padrão: LINVOR
Especificações Técnicas HC-05
 Módulo Bluetooth serial para Arduino e outros microcontroladores

 Tensão operacional: 4V a 6V (normalmente + 5V)
 Corrente operacional: 30mA
 Alcance: <100m
 Funciona com comunicação serial (USART) e compatível com TTL
 Segue o protocolo padronizado IEEE 802.15.1
 Usa espectro de propagação de salto de frequência (FHSS)
 Pode operar no modo Master, Slave ou Master / Slave
 Pode ser facilmente conectado a laptops ou telefones celulares com Bluetooth
 Taxa de transmissão suportada: 9600,19200,38400,57600,115200,230400,460800.
Onde usar o módulo HC-05 Bluetooth
O HC-05 é um módulo que pode adicionar funcionalidade sem fio bidirecional (full-
duplex). Você pode usar este módulo para se comunicar entre dois microcontroladores como o
Arduino ou se comunicar com qualquer dispositivo com funcionalidade Bluetooth, como um
telefone ou laptop. O módulo se comunica com a ajuda do USART a uma taxa de transmissão
de 9600, portanto, é fácil fazer a interface com qualquer microcontrolador que suporte
USART. Também podemos configurar os valores padrão do módulo usando o modo de
7 - 23
comando. Portanto, ele é um módulo sem fio que pode transferir dados do seu computador ou
telefone celular para o microcontrolador ou vice-versa.. No entanto, não espere que este
módulo transfira multimídia, como fotos ou músicas
Como usar o módulo HC-05 Bluetooth
O HC-05 possui dois modos de operação, um é o modo Dados, no qual pode enviar e receber
dados de outros dispositivos Bluetooth, e o outro é o modo Comando AT, onde as
configurações padrão do dispositivo podem ser alteradas. Podemos operar o dispositivo em
qualquer um desses dois modos usando o pino-chave, conforme explicado na descrição do
pino.
É muito fácil emparelhar o módulo HC-05 com microcontroladores porque ele opera usando o
protocolo de porta serial (SPP). Basta alimentar o módulo com + 5V e conectar o pino Rx do
módulo ao Tx do MCU e o pino Tx do módulo ao Rx do MCU como mostrado na figura
abaixo
Durante a inicialização, o pino da chave pode ser aterrado para entrar no modo de comando; se
for deixado livre, ele entrará por padrão no modo de dados. Assim que o módulo for ligado,
você deve ser capaz de descobrir o dispositivo Bluetooth como “HC-05” e conectar-se a ele
usando a senha padrão 1234 e começar a se comunicar com ele.
Formulários
1. Comunicação sem fio entre dois microcontroladores
2. Comunique-se com laptop, desktops e telefones celulares
3. Aplicativo de registro de dados
4. Aplicativos do consumidor
5. Robôs sem fio
6. Domóti
7 - 24
Analisando seu primeiro programa
Dedique um tempo para analisar o programa Blink a fim de entender a estrutura básica dos
programas escritos para o Arduino. Considere a Figura 13. Os textos explicativos numerados
mostrados na figura correspondem à seguinte lista.
Eis como o código funciona, parte por parte:
1. Comentário de várias linhas. Comentários são importantes para documentar seu código.
Tudo o que você escreve entre esses símbolos não serão compilados e nem mesmo visto pelo
Arduino. Comentários de várias linhas começam com / * e terminam com */ . Comentários de
várias linhas são geralmente usados quando você tem muito a dizer (como a descrição do
programa).
2. Comentário de uma única linha. Quando você colocar // em qualquer linha, o compilador
ignora todo o texto após esse símbolo na mesma linha. Isso é ótimo para a anotação de linhas
específicas de código ou para desativar uma determinada linha código que você acredita que
pode estar causando problemas.
3. Declaração de variável. Uma variável é um lugar na memória do Arduino que contém

informações. As variáveis têm diferentes tipos. Nesse caso, ela é do tipo int, o que significa
que irá armazenar um número inteiro. Então, uma variável do tipo inteiro chamada led está
sendo definida com o valor de programa, podemos simplesmente usar led sempre que
quisermos controlar o pino 13. Configurar variáveis é útil porque você pode simplesmente
mudar essa linha se mais tarde você conectar o LED a um pino de E/S diferente; o resto do
código ainda funcionará como esperado.
4. void setup () é uma das duas funções que devem ser incluídos em todo programa Arduino.
Uma função é um trecho de código que faz uma tarefa específica. O código dentro das chaves
da função setup () é executado uma vez no início do programa. Isso é útil para configurações
que você só faz uma vez, como configurar a direção de pinos, inicializar interfaces de
comunicação e assim por diante.
Figura 13
7 - 25
5. Pinos digitais do Arduino podem funcionar como entrada ou saídas.
Para configurar sua direção, use o comando pinMode(). Esse comando usa dois argumentos.
Um argumento fornece informações aos comandos sobre como estes devem funcionar.
Argumentos são colocados dentro dos parênteses que se seguem a um comando. O primeiro
argumento para pinMode determina o pino que está tendo sua direção configurada. Como você
configurou a variável led no início do programa, você está dizendo ao comando que quer
configurar a direção do pino 13. O segundo argumento configura a direção do pino: INPUT ou
OUTPUT. Os pinos são entradas por padrão e, portanto, você precisa configurá-los
explicitamente como saídas se quiser que eles funcionem como saídas. Como você quer
acender um LED, o pino de led deve ser configurado como uma saída (corrente está fluindo a
partir do pino de E/S). Note que você tem de fazer isso apenas uma vez. O pino funcionará
então como uma saída para o resto do programa, ou até que você o modifique para uma
entrada.
6. A segunda função obrigatória em todos os programas Arduino é VOID LOOP().
O conteúdo da função loop se repete indefinidamente enquanto o Arduino estiver estiver

ligado. Se quiser que o Arduino faça algo somente uma vez na inicialização, você ainda
precisa incluir a função de loop, mas pode deixá-la vazia.
7. DIGITALWRITE() é utilizado para configurar o estado de um pino de saída. Essa função

pode configurar o pino para 5V ou 0V. Quando um LED e um resistor é conectado a um pin o,
configurá-lo como 5V permitirá que você acenda o LED. (Você aprenderá mais sobre isso no
próximo capítulo). O primeiro argumento para DIGITALWRITE() é o pino que você quer
controlar. O segundo argumento é o valor com que você deseja configurá-lo, o que pode ser
HIGH (5V) ou LOW(0V). O pino permanece nesse estado até ser alterado no código.
8. A função DELAY() aceita um argumento: um tempo de retardo em milissegundos. Ao

chamar DELAY(), o Arduino deixa de fazer qualquer coisa pelo período de tempo
especificado. Nesse caso, você está atrasando o programa por 1000ms, ou 1 segundo. Isso faz
o LED ficar aceso por 1 segundo antes de executar o próximo comando.
9. Aqui, DIGITALWRITE() é utilizado para desligar o LED, configurando o estado do pino

como LOW.
10. Novamente, atrasamos por 1 segundo para manter o LED no estado desligado antes de o
loop se repetir e mudar para o estado ligado de novo.
Isso é tudo que há para saber sobre esse código. Não se deixe intimidar, se você não entender
completamente todo código ainda. À medida que mais exemplos são juntados nos próximos
capítulos, você vai se tornar cada vez mais proficiente em compreender o fluxo do programa, e
escrever seu próprio código.
7 - 26
// Exemplo (2)
Na função void Setup(), é preciso configurar qual pino será usado como saída e qual será
usado como entrada. Depois de configurar os pinos, para acioná-los basta chamar a função
digitalWrite(pino,HIGH).
A função digitalWrite() aciona ou desaciona um pino digital dependendo do valor passado no

argumento. Se for “HIGH”, o pino é acionado. Se for “LOW”, o pino é desligado.
Na função void Loop(), fizemos um if no qual a função digitalRead é usada para saber se o
pushButton está acionado ou não. Caso ele esteja acionado, nós acendemos o Led, caso ele
esteja desligado, nós desligamos o led.
- Entradas e saídas digitais - push-button + led
#define PinButton 8 // define pino digital D8
#define ledPin 7 // define pino digital D7
void setup() {
pinMode(PinButton, INPUT); // configura D8 como entrada digital pinMode(ledPin,

OUTPUT); // configura D7 como saída digital
Serial.begin(9600); // monitor serial - velocidade 9600 Bps
delay(100); // atraso de 100 milisegundos }
void loop() {
if ( digitalRead(PinButton) == HIGH) // se chave = nível alto {
digitalWrite(ledPin, HIGH); // liga LED com 5V
Serial.print("Acendendo Led"); // imprime no monitor serial }
else // senão chave = nivel baixo
digitalWrite(ledPin, LOW); // desliga LED com 0V
Serial.print("Desligando led"); // imprime no monitor serial
delay(100); // atraso de 100 milisegundos
7 - 27
ANEXO A
BIBLIOGRAFIA
a) BRASIL. Microcontroladores e microprocessadores. Revista Eletrônica. Editora

Multipress. Rio de Janeiro, 2000;
b) PEREIRA, Fabio - Microcontrolador PIC – Técnicas Avançadas. 4ª ed, São Paulo,
Érica, 2002;
c) SOUZA, Daniel José e LAVINIA, Nicolas Cezar - Conectando o PIC – Recursos
Avançados. 3ª ed, São Paulo, Erica, 2003;
d) TORRES, Gabriel – Hardware – Curso Completo – 2a ed, Rio de Janeiro, Axcel Books
do Brasil Editora, 1998.
e) ZANCO, Wagner da Silva – Microcontroladores PIC – Técnicas de Software e
Hardware para Projetos de Circuitos Eletrônicos. 1a ed, São Paulo, Erica, 2006.
f) http://blog.arduino.cc/2011/01/05/nice-drawings-of-the-arduino-uno-and-mega-2560/
g) Microchip PIC16F8X Datasheet – www.microchip.com
h) Projetos de Hardware e Software utilizando Microcontroladores PIC – Edmur Canazian –
1999
i) P16Pro Programmer for MicroChip microcontrollers – Short Manual
j)BLUM, Jeremy – Explorando o Arduino – Técnicas e Ferramentas para Mágicas de
Engenharia – Alta Books,Rio de Janeiro, 2016.
A–1

ApostilaEE-1019-0420 - MICROCONTROLADOR

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

ApostilaEE-1019-0420 - MICROCONTROLADOR

Enviado por

Direitos autorais:

Formatos disponíveis

MARINHA DO BRASIL

CENTRO DE INSTRUÇÃO ALMIRANTE ALEXANDRINO

CENTRO DE INSTRUÇÃO ALMIRANTE ALEXANDRINO

APROVO, para emprego no Centro de Instrução Almirante Alexandrino, para as turmas

JOSÉ AFONSO BARBOZA LOBIANCO

 INTRODUÇÃO ................................................................................................................... 1.1

CAPÍTULO 1 – INTRODUÇÃO AOS MICROCONTROLADORES.

CAPÍTULO 2 – VISÃO GERAL DO MICROCONTROLADOR PIC16F84.

CAPÍTULO 3 – ORGANIZAÇÃO DA MEMÓRIA DO PIC.

CAPÍTULO 4 – PORTAS DE ENTRADA E SAÍDA.

CAPÍTULO 5 – ESTUDO DOS TIMERS.

ANEXO .................................................................................................................... ...............A-1

Os assuntos nela contidos preenchem as exigências dos currículos, com o propósito

INTRODUÇÃO AOS MICROCONTROLADORES.

Figura 1.1: Diagrama de um modelo computacional

Este conjunto que integra o Microprocessador e estruturas de memória carregadas de

Hardware, já o conjunto de instruções que são carregadas nas estruturas de memória é

Figura 1.2: Diagrama em bloco de um microcontrolador

(SFR). A possibilidade de alterar as configurações de hardware o torna versátil e utilizável

1.2 - FAMÍLIAS DE MICROCONTROLADORES.

1.2.1 - Família 8051.

Todos os modelos da família PIC possuem um conjunto de instruções e características

1.3 – FUNÇÕES INTERNAS COMUNS À MAIORIA DOS MODELOS DE PIC.

1.3.4 - Unidade de entrada/saída.

1.3.5 - Comunicação série.

1.3.6 - Unidade de temporização.

Dentro do PIC existe um contador incrementado por um oscilador (RC) independente.

1.3.8 - Conversor analógico – digital.

Figura 1.4 - Compilador transforma o programa fonte em instruções de máquina.

1.3.10 - Contador de Programa (PC).

1.4 – ARQUITETURAS E INSTRUÇÕES.

1.4.1 - Arquitetura Von-Neumann.

Figura 1.5 – Arquitetura Von-Neumann

Figura 1.6 – Arquitetura Harvard.

b) Instruções RISC (Reduced Instruction Set Computing) - Computação com

d) Entendendo instruções CISC/RISC.

enquanto MOV AX precisa de dados de 16 bits). A solução encontrada foi a completa

s) Baixo consumo de potência (< 0,6 mA a 3 V e 4 MHz).

2.3 - ARQUITETURA INTERNA DO PIC16F84.

Figura 2.1: Diagrama de blocos do PIC16F84.

2.3.1 - No diagrama podemos identificar:

i) Decodificador de instruções: identifica que operação será realizada; recebe a

j) Status Reg. (Registro STATUS) que é um registro encarregado de anotar o estado

2.4 - CICLO DE INSTRUÇÃO NO PIC.

Figura 2.2: Diagrama temporal do ciclo de máquina.

Ao ciclo de instrução abaixo, foram adicionadas 5 instruções como exemplo: Carregar

Figura 2.3: Programa com os ciclos de extração e execução.

2.5 - DIAGRAMA DE PINAGEM.

Figura 2.4: Diagrama de pinagem.

A memória de dados compreende memória EEPROM e memória RAM. A memória

Os registos que ocupam as 12 primeiras localizações nos bancos 0 e 1 são registos

Local de memória usado

Organização da memória no microcontrolador PIC16F84

3.2.5 - Pilha (Stack).

um subprograma, o PC é retirado da Pilha, de modo a que o programa possa continuar

3.3 - ORGANIZAÇÃO DA MEMÓRIA DE DADOS (RAM).

3.3.1 - General Purpose Register File (GPR).

3.3.2 - Registros de Funções Especiais (SFR).

I) Relacionados ao Núcleo (CPU), serão descritos a seguir.

3.3.3 - Bancos de memória de dados

3.4 - CLASSIFICAÇÃO DOS REGISTROS.

3.4.1 – Registro W (WORK).

IV) FSR e INDF

3.4.3 - Registro STATUS.

Aula Prática no laboratório: Manual de experimentos (Capítulo5 e 7)