MCU PIC CURSO BASICO - 001 - Microprocessdores

Todos os direitos reservados.
Proibida a distribuição total ou parcial deste

material, por qualquer meio ou processo, sem a expressa autorização do autor.
Essas proibições aplicam-se também às características gráficas da obra e à sua
editoração. A violação dos direitos autorais é punível como crime (art. 184 e
parágrafos, do Código Penal, cf. Lei no 6.895, de 17.12.80) com pena de prisão e
multa, conjuntamente com busca e apreensão e indenizações diversas (artigos
102, 103 parágrafo único, 104, 105, 106 e 107 itens 1, 2 e 3 da Lei no 9.610, de
19/06/98, Lei dos Direitos Autorais).
Certos materiais contidos neste arquivo foram incluídos com a permissão da
Microchip Technology Incorporated. Nenhuma distribuição, reimpressão ou
reprodução do material citado pode ser feita sem o consentimento por escrito da
Microchip Technology Inc.
Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Disciplina: Microprocessadores
Prof: Wagner Zanco
Ementa: Arquitetura básica de um microcomputador; microcontroladores;
microcontrolador PIC16F628A; Linguagem Assembly; desenvolvendo aplicações
com o MPLAB IDE; gravando o microcontrolador; Técnicas de programação.
Material didático:
Livro: Microcontroladores PIC16F628A/648A – Uma abordagem prática e objetiva
Autor: Wagner da Silva Zanco
Editora Érica
Tutorial sobre o microcontrolador PIC16F628A

Site: http://www.wagnerzanco.com.br

Disciplina: Microprocessadores
Objetivo:
Desenvolver habilidades e competências para o
desenvolvimento de projetos de circuitos eletrônicos
microcontrolados.

Um Resumo da
Evolução da Eletrônica

A função básica de um computador
O computador basicamente é um processador de informações. O
usuário introduz as informações no computador por meio de um
dispositivo de entrada como o teclado, mouse etc. O computador
processa as informações e retorna o resultado para o usuário por meio
de um dispositivo de saída como o Vídeo ou impressora.

Módulos Básicos de
um microcomputador

Arquitetura Von-Neumann
CPU – É um circuito integrado (CI) capaz de executar um conjunto de tarefas

denominadas instruções. A CPU gerencia todo o sistema e executa os
programas.
Memória – Armazena os dados que serão processados e os programas que

serão executados.
Dispositivos de I/O – São os responsáveis pela entrada e saída de dados do

sistema.
Arquitetura Harvard

Organização da Memória
A memória é composta por várias localidades podendo armazenar um
conjunto de bits em cada uma. Cada localidade possui seu próprio endereço,
sendo este um valor numérico representado no sistema hexadecimal.
A unidade padrão de armazenamento de dados na memória é o Byte.

Von-Neumann versus Harvard
CPU CISC – As CPUs utilizadas em computadores que seguem a arquitetura

Von-Neumann são do tipo CISC, as quais possuem um set de instruções ampliado
(muitas instruções).
CPU RISC – As CPUs utilizadas em computadores que seguem a arquitetura

Harvard são do tipo RISC, as quais possuem um set de instruções reduzido
(poucas instruções).

GERENCIANDO O SISTEMA
Para gerenciar o sistema a CPU precisa se comunicar

com a memória e com os dispositivos de I/O. Esta
comunicação pode ser de leitura ou de escrita.
Escrita - quando a CPU envia uma informação para ser armazenada numa
localidade de memória ou para um dispositivo de I/O. Por exemplo, quando a
CPU envia uma informação para o vídeo, dizemos que ela escreveu no vídeo.
Leitura - quando a CPU busca uma informação na memória ou num

dispositivo de I/O. Quando uma tecla é pressionada no teclado e aparece no
vídeo, é porque a CPU efetuou uma leitura no teclado e escreveu o dado lido no
vídeo.

“A CPU reconhece cada um dos dispositivos
de I/O, assim como cada localidade de
memória pelo seu respectivo endereço”.

CAPACIDADE DE PROCESSAMENTO DE UMA CPU
- SET(conjunto) de instruções;
- Velocidade com que as instruções são executadas;
- Multiprocessamento (execução de várias instruções simultâneas);
-Quantidade de memória que é capaz de endereçar;
- Comprimento da via de dados
- Etc.

MEMÓRIAS SEMICONDUTORAS
São memórias implementadas em
circuitos integrados (chips de memória).
Estão divididas em dois grupos: Volátil e não-volátil.
Volátil – É a memória que perde os dados armazenados quando a
energia é desligada.
Não-volátil – É a memória que não perde os dados armazenados
quando a energia é desligada.

ROM
- Somente leitura MEMÓRIA
- Vem programada de fábrica
- Não pode ser reprogramada
NÃO-VOLÁTIL
PROM
- Somente leitura
- É programada eletricamente pelo usuário
- Uma vez programada se transforma numa ROM
- Não pode ser reprogramada
EPROM
- Somente Leitura
- Programável Eletricamente pelo usuário
- Possui uma janela que quando exposta a raios ultravioletas, seus dados são apagados podendo ser reprogramada.
E2PROM
- Somente Leitura
- É semelhante a uma EPROM só que seus dados são apagados através de uma tensão elétrica aplicada a um de seus
pinos, podendo ser reprogramada da mesma forma que uma EPROM.
FLASH-ROM:
- Somente Leitura
- Pode ser reprogramada por software.
.
MEMÓRIA VOLÁTIL
DRAM
- Leitura e escrita
- Fabricada com capacitores
- Precisa de REFRESH para manter os dados armazenados, mesmo com a energia ligada.
SRAM
- Leitura e escrita
- Fabricada com Flip-flops
- Não precisa de refresh
REFRESH - É uma simulação de leitura que é feita em cada localidade de

memória com o objetivo de reforçar os dados ali armazenados. Isso é
necessário porque a memória DRAM é constituída de capacitores (armazena
energia e a perde em pouco tempo).

MICROCONTROLADOR
“É um computador em um único chip. O microcontrolador integra em um

único invólucro CPU, memória e dispositivos de I/O. O primeiro
microcontrolador, o 8048, foi desenvolvido pela empresa Intel no final da
década de setenta”.
Ao contrário do microcontrolador, para se construir um computador com um

microprocessador é necessário utilizar memória externa e dispositivos de I/O
externos.
FAMÍLIA PIC
Desenvolvida pela empresa
Microchip Technology Inc.
- PIC10 (8 bits) (menor microcontrolador do mundo)
- PIC12 (8 bits)
- PIC14 (8 bits)
- PIC16 (8 bits)
- PIC18 (8 bits)
- PIC24 (16 bits)
-PIC32 (32 bits)
Microcontroladores da Família PIC
- Arquitetura RISC (set de instruções reduzido)

- ATÉ 80MHz
- Memória de Programas de 12, 14, 16 ou 24 Bits
- Memória de programa FlASH-ROM
- USART, Conversor A/D, I2C, CAN, SPI, Comparador,
PWM, RF, ECCP, Ethernet, USB etc.

TIPOS DE MEMÓRIA DE PROGRAMA
ROM TIPO MÁSCARA - O chip já sai da fábrica com o programa gravado nele, não podendo ser regravado
de forma nenhuma pelo usuário. O custo destes componentes é bem reduzido, mas só são viáveis se
adquiridos em grande quantidade. Estes componentes são identificados pelo sufixo “CR”.
OTP - Estes dispositivos utilizam memória PROM para armazenar os programas. Eles vem de fábrica vazios,
sendo a gravação do programa feita pelo usuário, não podendo o mesmo ser regravado. Isto impede a
utilização destes componentes na fase de desenvolvimento e teste de programas. Os mesmos são identificados
pelo sufixo “C”.
EPROM - Estes componentes possuem uma janela onde podemos, através da exposição a raios ultravioletas,
apagar os programas gravados no chip. Embora seja trabalhoso efetuar o apagamento do programa, estes
componentes podem ser utilizados na fase de testes e desenvolvimento de programas. O sufixo pode ser “JW”
para dispositivos com encapsulamento do tipo DIP ou “CL” para dispositivos com encapsulamento do tipo
PLCC.
FLASH - Identificados pelo sufixo “F”, estes componentes permitem ser apagados/regravados milhares de
vezes através de sinais elétricos aplicados em alguns de seus pinos, o que pode ser feito automaticamente por
um circuito gravador de Flash como o Picstart Plus, fabricado pela Microchip ou o JDM, cujo hardware é
encontrado facilmente na internet. Estes componentes são a melhor opção para teste de programas e
implementação final dos circuitos, visto que estão ficando cada dia mais baratos.

ARQUITETURA INTERNA DO PIC16F628A

CARACTERÍSTICAS DO PIC16F628A
- 16 pinos de I/O;
- Freqüência de até 20MHz;
- Oscilador interno de 4MHz/37KHz;
- 2Kx14 bits de memória FLASH de programa;
- 224x8 bits de memória RAM para dados;
- 128x8 bits de memória E2PROM interna;
- TIMER0 (timer /contador de 8 bits);
- TIMER1 (timer /contador de 16 bits);
- TIMER2 (timer de 8 bits);
- 1 canal PWM com captura e amostragem (CCP);
- 2 comparadores analógicos com referência interna programável de tensão;
- 1 canal de comunicação USART serial;
- 1 Timer Watchdog;
- Capacidade de corrente de 25 mA por pino de I/O;
- 35 instruções;
- 10 fontes de interrupção independentes;
- Modo de funcionamento Sleep;
- Tensão de operação entre 3V a 5V (2V a 5V para versão LF).

PINAGEM DO PIC16F628A

PORTAS DE I/O
PORTA(RA7:RA0)
PORTB(RB7:RB0)

PINAGEM DO PIC16F628A

OSCILADOR
Qualquer instrução executada pela CPU utiliza como

referência um sinal de clock que é gerado por um
oscilador. O Oscilador pode ser externo ou interno.

SINAL DE CLOCK
O sinal de clock é uma onda quadrada que sincroniza
a execução das instruções executadas pela CPU.
Os Microcontroladores PIC gastam quatro ciclos de clock

(ciclo de instrução) para executar uma instrução, salvo
algumas exceções. O ciclo de instrução também é
chamado de clock interno.
T(ciclo de instrução) = 1 / (Fosc/4)
MODOS DE FUNCIONAMENTO DO
OSCILADOR DO PIC16F628A

MODOS DE FUNCIONAMENTO DO
OSCILADOR DO PIC16F628A

MEMÓRIA DE PROGRAMA DO PIC16F628A

MEMÓRIA DE RAM DO PIC16F628A
A memória de RAM (ou de dados) do PIC16F628A é

dividida em dois grupos:
Registradores com finalidade específica

-Registradores de uso geral
Obs:. Cada registrador do PIC16F628A ocupa uma

localidade de memória e pode armazenar 8 bits.

MEMÓRIA DE RAM (DADOS) DO PIC16F628A

Bit 7: IRP: Bit de seleção de banco de memória (usado para endereçamento indireto)
1 = Bancos 2 e 3 (100h - 1FFh)
0 = Bancos 0 e 1 (000h - 0FFh)
Bit 6 - 5: RP1:RP0: Bits de seleção de banco de memória (usado para endereçamento direto)
11 = Banco 3 (180h - 1FFh)
10 = Banco 2 (100h - 17Fh)
01 = Banco 1 (080h - 0FFh)
00 = Banco 0 (000h - 07Fh)
Bit 4: /TO: Bit time out
1 = Depois de um power-up, instrução CLRWDT ou instrução SLEEP
0 = WDT gerou um Timeout

Bit 3: /PD: Bit power-down
1 = Ocorreu um power-up ou foi executada a instrução CLRWDT
0 = A instrução SLEEP foi executada
Bit 2: Z: Bit zero
1 = Indica que o resultado da última operação efetuada na ULA é zero
0 = Indica que o resultado da última operação efetuada na ULA é diferente de zero
Bit 1: DC: Digit carry/borrow
1 = A última operação de soma (instruções ADD) ocasionou um estouro entre os bits 3 e
4, isto é, o resultado ultrapassou os 4 bits menos significativos
0 = A última operação efetuada de soma não ocasionou um estouro entre os bits 3 e 4
Bit 0: C: Carry/borrow
1 = A última operação de soma (instruções ADD) ocasionou um estouro de carry, isto é,
o resultado ultrapassou os 8 bits mais significativos
0 = A última operação de soma não ocasionou um estouro de carry
Bit 7: /RBPU: Ativa os resistores pull-ups internos do PORTB
1 = Resistores pull-ups do PORTB desativados
0 = Resistores pull-ups do PORTB ativados
Bit 6: /INTEDG: Configura a borda que irá gerar interrupção no pino RB0/INT
1 = Interrupção ocorrerá na borda de subida
0 = Interrupção ocorrerá na borda de descida
Bit 5: T0CS: Define a origem do incremento do registrador TMR0

1 = TMR0 será incrementado externamente por uma mudança no pino RA4/T0KI
0 = TMR0 será incrementado internamente pelo ciclo de instrução
Bit 4: T0SE: Define a borda em RA4/T0CKI que irá incrementar o TMR0

1 = O incremento ocorrerá na borda de descida
0 = O incremento ocorrerá na borda de subida

INTERRUPÇÃO
Uma interrupção é um evento de hardware que, quando ocorre, provoca um desvio no programa, para
que o evento seja tratado. Ao término do tratamento do evento que deu origem à interrupção, o programa
retorna ao ponto em que parou quando ocorreu o desvio. O PIC16F628A possui dez fontes de interrupção
independentes:
Interrupções normais:
Estouro de TMR0
Interrupção externa RB0/INT
Mudança de estado num dos pinos (RB7:RB4)
Interrupções de periféricos:
Término de escrita na EEPROM
Módulo comparador
Interrupção de USART (recepção e transmissão) A interrupção pode ser tratada ou não. Para que uma
Módulo CCP interrupção seja tratada, ela precisa estar habilitada. A
Estouro do TMR1 habilitação é feita da seguinte forma:
Interrupção quando TMR2=PR2
1º - Habilitar a chave individual (INTCON ou PIE1).
2º - Habilitar a interrupção de periférico (INTCON<6>) se fonte
for um periférico.
3º - Habilitar a chave geral de interrupção(INTCON<7>).

SINALIZAÇÃO DE UMA INTERRUPÇÃO
Toda vez que ocorre um evento responsável por uma interrupção, é setado um bit ou flag de
sinalização. Para cada uma das fontes de interrupção existe um flag de sinalização. Se a interrupção estiver
habilitada o programa será desviado para a localidade 0004h. Ao ser encontrada a instrução RETFIE o
programa retorna ao programa principal e continua a execução do programa.

Bit 7: GIE: Chave geral de habilitação das interrupções
1 = As interrupções habilitadas individualmente serão tratadas
0 = Nenhuma interrupção será tratada
Bit 6: PEIE: Habilita interrupção dos periféricos
1 = Habilita todas as interrupções dos periféricos
0 = Desabilita todas as interrupções dos periféricos
Bit 5: T0IE: Habilita interrupção de estouro de TMR0
1 = Interrupção será tratada
0 = Interrupção não será tratada
Bit 4: INTE: Habilita interrupção externa no pino RB0/INT
Bit 3: RBIE: Habilita interrupção por mudança de estado nos pinos RB7:RB4
Bit 2:
‘
T0IF: Flag que informa ocorrência de estouro de TMR0
1 = TMR0 estourou (precisa ser apagado por software)
0 = TMR0 não estourou
Bit 1: INTF: Flag que informa ocorrência de interrupção no pino RB0/INT
1 = Ocorreu uma interrupção externa no pino RB0/INT (precisa ser apagado por
software)
0 = Não ocorreu uma interrupção externa no pino RB0/INT
Bit 0: RBIF: Flag que informa ocorrência de interrupção nos pinos RB7:RB4
1 = Ocorreu uma interrupção externa por mudança de estado num dos pinos
RB7:RB4 (precisa ser apagado por software)
0 = Não ocorreu uma interrupção externa por mudança de estado num dos pinos
RB7:RB4
Bit 7: EEIE: Bit de habilitação da interrupção de final de escrita na EEPROM
Bit 6: CMIE: Bit de habilitação da interrupção do comparador

Bit 5: RCIE: Bit de habilitação da interrupção de recepção de dados na USART

Bit 4: TXIE: Bit de habilitação da interrupção de transmissão de dados na USART

Bit 3: NÃO IMPLEMENTADO: LIDO COMO ' 0 '
Bit 2: CCP1IE: Bit de habilitação de interrupção do módulo CCP

Bit 1: TMR2IE: Habilita interrupção de estouro de TMR2

Bit 0: TMR1IE: Habilita interrupção de estouro de TMR1


Bit 7: EEIF: Bit de sinalização da interrupção de final de escrita na EEPROM
1 = Operação de escrita completa (limpar flag por software)
0 = Operação de escrita não terminada ou não começou
Bit 6: CMIF: Bit de sinalização da interrupção do comparador

1 = Houve mudança de nível lógico na saída do comparador
0 = Não houve mudança de nível lógico na saída do comparador
Bit 5: RCIF: Bit de sinalização da interrupção de recepção de dados na USART

1 = O buffer de recepção de USART está cheio
0 = O buffer de recepção de USART está vazio
Bit 4: TXIF: Bit de sinalização da interrupção de transmissão de dados na USART

1 = O buffer de transmissão de USART está vazio
0 = O buffer de transmissão de USART está cheio
Bit 3: NÃO IMPLEMENTADO: LIDO COMO ' 0 '
Bit 2: CCP1IF: Bit de sinalização de interrupção do módulo CCP
MODO DE CAPTURA
1 = O TMR1 fez a captura (limpar flag por software)
0 = O TMR1 não fez uma captura
MODO COMPARADOR
1 = Ocorreu uma igualdade (TMR1=CCPR1)
0 = Não ocorreu igualdade
MODO PWM
Sem uso para este modo
Bit 1: TMR2IF: Sinaliza interrupção de estouro de TMR2
1 = Ocorreu uma igualdade (TMR2=PR2) (limpar flag por software)
0 = Não ocorreu igualdade
Bit 0: TMR1IF: Sinaliza interrupção de estouro de TMR1
1 = Houve estouro de TMR1 (limpar flag por software)
0 = Não houve estouro de TMR1

Bit 7: 4, 2: NÃO IMPLEMENTADOS: LIDOS COMO ' 0 '
Bit 3: OSCF: Bit de modo de operação de oscilador interno

1 = Clock de 4MHz
0 = Clock de 37KHz
Bit 1: /POR: Bit de sinalização de Power-on Reset (equipamento energizado)

1 = Não houve um Power-on Reset
0 = Houve um Power-on Reset (setar flag por software depois do POR)
Bit 0: /BOR: Bit de sinalização de Brown-out Reset (reset por queda de tensão)
1 = Não houve um Brown-out Reset
0 = Houve um Brown-out Reset (setar flag por software depois do BOR)

PROGRAMAÇÃO ASSEMBLY
De uma maneira geral, as instruções são

formadas por dois campos distintos:
Código de Operação (Op. Code)
Operando

Código de Operação - é o campo da

instrução que especifica qual tarefa deve ser
realizada pelo microcontrolador quando a
instrução é processada.
Operando Comentário
Código de operação
MOVLW B’11010011’ ;W Í D3h

Operando – É o outro campo da instrução quando ele
existir. Nem todas as instruções possuem operando. Os
tipos de operandos que podem aparecer em uma
instrução são:
Registrador (F)
Bit de um registrador (B)
Dado (L) Operando Comentário
Código de operação
MOVLW B’11010011’ ;W Í D3h

TERMOS UTILIZADOS
W (work ou acumulador) - esse registrador não

possui um endereço dentro do mapeamento de
memória de dados, mas é muito utilizado, pois não é
possível escrever um dado em um registrador sem que
antes a informação passe pelo registrador W. O
registrador W pode ser representado no operando da
instrução pelo número 0 (zero).

TERMOS UTILIZADOS
F (file) - forma usada para representar uma posição de

memória de dados (ou registrador). É usada no
mnemônico da instrução para representar uma posição
válida de memória. O registrador F pode ser
representado pelo número 1 (um) no operando de uma
instrução.

TERMOS UTILIZADOS
L (literal) - valor numérico que pode ser representado
no programa nos sistemas decimal, binário, octal,
hexadecimal ou código ASCII.
d (destino) - local para onde será enviado o resultado

de uma operação matemática, ou uma determinada
informação. Existem dois destinos para uma
informação numa instrução: F, que fará com que a
informação seja guardada no mesmo registrador
especificado no operando da instrução ou W, que
colocará a informação no acumulador, ou seja, em W.

TERMOS UTILIZADOS
B (bit) - representa um bit dentro de um byte, sendo B
usado no mnemônico e b usado no operando da
instrução.
T (teste) - no mnemônico é usado para indicar que

será feito um teste num determinado bit de um byte,
para sabermos se ele é 0 (zero) ou 1 (um).
S (skip) - usado no mnemônico de algumas instruções

para indicar que a próxima linha do programa será
pulada se uma determinada condição for satisfeita.

TERMOS UTILIZADOS
S (set) - usado no mnemônico para informar que um
determinado bit de um byte será setado, ou seja, forçado a
assumir nível 1 (um). Não confunda S de set com S de skip,
que é a posição dele no mnemônico que definirá a sua
função.
C (clear) - informa que um determinado bit de um byte

será forçado a assumir nível 0 (zero). É usado também nas
instruções de desvio para saber se um bit está setado ou
apagado.
Z (zero) - utilizado para informar que o resultado da última

operação matemática foi zero.
OUTROS TERMOS UTILIZADOS
ADD - soma aritmética de dois números
AND - lógica AND entre dois números
CLR - limpar, zerar
COM - complemento (inverte o nível lógico de cada bit do byte)
DEC - decremento (subtrai uma unidade de um número)
INC - incremento (soma uma unidade a um número)
IOR - lógica OU entre dois números
MOV - copiar uma informação para algum lugar
RL - rotacionar um bit para a esquerda
RR - rotacionar um bit para a direita
SUB - subtração aritmética entre dois números
SWAP - inverte os nibbles alto e baixo de um byte (nibble = 4 bits)
XOR - lógica ou exclusivo entre dois números.

PORTAS DE I/O
PORTA(RA7:RA0)
PORTB(RB7:RB0)

NÍVEIS DE TENSÃO CORRESPONDENTES
AOS NÍVEIS LÓGICOS 0 e 1

CONFIGURANDO OS PINOS DE I/O COMO
ENTRADA OU COMO SAÍDA
Cada bit do TRISA configura o respectivo pino do PORTA.

0 – configura o pino como saída
1 – configura o pino como entrada
CONFIGURANDO OS PINOS DE I/O COMO
ENTRADA OU COMO SAÍDA
Cada bit do TRISB configura o respectivo pino do PORTB.

0 – configura o pino como saída
1 – configura o pino como entrada
INICIALIZANDO O PORTA
;***************************************************************************************************************************
BCF STATUS,RP1
BSF STATUS,RP0 ;SETA O BANCO 1
MOVLW B'00000110' ;BITS RA1 E RA2 CONFIGURADOS COMO ENTRADA

MOVWF TRISA ;E DEMAIS BITS CONFIGURADOS COMO SAIDA
BCF STATUS,RP1
BCF STATUS,RP0 ;SETA O BANCO 0
MOVLW B'00000111' ;CONFIGURA OS BITS RA3:RA0 COMO I/O <2:0>

MOVWF CMCON
;***************************************************************************************************************************

INICIALIZANDO O PORTB
;***************************************************************************************************************************
BCF STATUS,RP1
BSF STATUS,RP0 ;SETA O BANCO 1
MOVLW B'00000000' ;TODOS OS BITS DO PORTB

MOVWF TRISB ;SAO CONFIGURADOS COMO SAIDA
MOVLW B'10000000' ;DESABILITA OS RESISTORES DE PULL-UP <7>

MOVWF OPTION_REG ;DEMAIS BITS IRRELEVANTES
BCF STATUS,RP1
BCF STATUS,RP0 ;SETA O BANCO 0
;**************************************************************************************************************************

LENDO O PORT
;************************************************************************************************************
;ESTE CODIGO LE O BIT RB0 (PORTB<0>)
BTFSS PORTB,0 ;LE O PINO 6 (RB0), RB0=1?

GOTO PINO_ZERO ;NAO, DESVIA
GOTO PINO_UM ;SIM, DESVIA
;************************************************************************************************************
;************************************************************************************************************
;ESTE CODIGO LE TODOS OS BITS DO PORTB DE UMA SO VEZ E COLOCA O VALOR LIDO EM TEMP
MOVF PORTB,W ;LE PORTB E COLOCA VALOR EM WORK

MOVWF TEMP ;TEMP RECEBE CONTEUDO DO PORTB
;************************************************************************************************************

ESCREVENDO NO PORT
;************************************************************************************************************
;ESTE CODIGO ESCREVE INDIVIDUALMENTE NO BIT RA0 (PORTA<0>)
BCF PORTA,0 ;ESCREVE 0 NO PINO 17 (RA0)

;************************************************************************************************************
;************************************************************************************************************
;ESTE CODIGO ESCREVE NO PORTB O VALOR 0Fh, OU SEJA, O NIBBLE ALTO DO PORTB E APAGADO E
;O NIBBLE BAIXO E SETADO.
MOVLW B'00001111' ;W RECEBE 0Fh

MOVWF PORTB ;PORTB RECEBE 0Fh
;************************************************************************************************************

ELEMENTOS BÁSICOS DA LINGUAGEM
ASSEMBLY
Label
Mnemônico
Operando
Comentário
Diretivas

ASSEMBLY
Label
É uma string utilizada, entre outras coisas, para representar o
início de um bloco de instruções que executa uma tarefa definida
dentro do programa. O bloco de instruções é normalmente
chamado de sub-rotina. O label deve começar na coluna 1 e pode
ter um comprimento máximo de até 32 caracteres, tendo
obrigatoriamente que começar com um caractere alfanumérico ou
_(underline). O label pode ser sucedido pelo :(colon), o qual é
tratado como um operador do label e não como parte dele.

ASSEMBLY
Mnemônico
O PIC16F628A possui um conjunto de 35 instruções e sua
representação no programa segue uma lógica, definida por sua
sintaxe. A sintaxe define a forma correta de escrever uma
instrução. O mnemônico é parte da sintaxe de uma instrução e
especifica qual tarefa será executada. A parte da instrução que
especifica a tarefa que será realizada é chamada de Op Code
(código de operação). É aconselhável que todas as instruções
sejam escritas com letras maiúsculas para evitar problemas, visto
que alguns editores fazem distinção entre letras maiúsculas e
minúsculas.
ASSEMBLY
Operando
Pode ou não fazer parte da sintaxe de uma instrução. O operando

pode ser um registrador, uma constante, valor numérico, um bit ou
uma variável. Quando há mais de um operando na instrução, eles
são separados por vírgula. Assim como os Op Codes, os
operandos devem ser escritos com letras maiúsculas.

ASSEMBLY
Comentário
É um texto colocado após cada instrução para informar a tarefa
que está sendo executada, fazendo com que o programa fique
mais legível e fácil de entender. Todo comentário deve ser
precedido do ; (ponto-e-vírgula), fazendo com que tudo que esteja
escrito a partir do ponto-e-vírgula, até o final da linha, seja
desprezado pelo montador. O uso de comentários após cada
instrução é um hábito que deve ser cultivado pelos
programadores, principalmente pelos iniciantes. O comentário
deve ser escrito com letras maiúsculas, sem acento ou Ç (cedilha).

ASSEMBLY
Diretivas
Conhecidas também como pseudo-instruções, são comandos que
não fazem parte do set de instruções do microcontrolador, mas são
reconhecidos pelo programa montador (MPLAB IDE). As diretivas
não são convertidas diretamente em linguagem de máquina. Elas
são usadas para controlar o Assembly. As diretivas mais utilizadas
em programas escritos em Assembly são: #DEFINE, #INCLUDE,
ORG, EQU, MACRO, ENDM, CBLOCK, ENDC e END.

ESTRUTURANDO UM PROGRAMA FONTE EM ASSEMBLY
1º passo - Título, nome do projetista, data de conclusão e versão do programa
2º passo - Arquivos include
3º passo - Paginação de memória
4º passo - Criar variáveis
5º passo - Identificar flags utilizados no sistema
6º passo - Criar constantes
7º passo - Identificar os pinos que são usados como entrada e como saída
8º passo - Vetor reset
9º passo - Vetor de interrupção e rotinas de interrupção
10º passo - Configuração dos registradores com finalidades específicas
11º passo - Inicialização das variáveis
12º passo - Rotina principal
13º passo - Sub-rotinas

1º passo - Título, nome do projetista, data de conclusão e versão do programa
;**********************************************************************************************
; NOME DO PROGRAMA
; DESENVOLVIDO POR (AUTOR)
; VERSAO
; DATA
;**********************************************************************************************

2º passo - Arquivos include
;*********************************************************************************************************
#INCLUDE <P16F628A.INC> ;ARQUIVO PADRAO MICROCHIP PARA O PIC16F628A
;*********************************************************************************************************

3º passo - Paginação de memória

************************************************************************************************************************************************************
; PAGINACAO DA MEMORIA
;************************************************************************************************************************************************************
; COMANDOS PARA ALTERACAO DE PAGINA DE MEMORIA PARA ENDERECAMENTO DIRETO
BANK0 MACRO ;MACRO PARA SELECIONAR BANCO 0
BCF STATUS,RP0
BCF STATUS,RP1
ENDM ;FIM DA MACRO BANK0
BSF STATUS,RP0
BCF STATUS,RP1
BCF STATUS,RP0
BSF STATUS,RP1
BSF STATUS,RP0
BSF STATUS,RP1
;************************************************************************************************************************************************************

4º passo - Criar variáveis

;**********************************************************************************************************************************************
CBLOCK 0x20 ;ENDERECO INICIAL DA MEMORIA DO USUARIO
W_TEMP ;REGs TEMPORARIOS
STATUS_TEMP
CONTADOR
FILTRO1
FLAGS
TEMP1
ENDC ;FIM DO BLOCO DE MEMORIA
;**********************************************************************************************************************************************
OU
;**********************************************************************************************************************************************
W_TEMP EQU 0X20
STATUS_TEMP EQU 0X21
CONTADOR EQU 0X22
FILTRO1 EQU 0X23
FILTRO2 EQU 0X24
FLAGS EQU 0X25
TEMP1 EQU 0X26
;************************************************************************************************************************

5º passo – Flags de sinalização

;**********************************************************************************************************************************************
REGISTRADOR FLAGS
; BIT # |7|6 |5|4 |3|2 |1|0|
; |X|X|X|X|X|X|X|Y| STATUS DO BOTAO --> 1=SOLTO; 0=PRESSIONADO
; |X|X|X|X|X|X|Y|X| STATUS DO LED --> 1=ACESO; 0=APAGADO
; |X|X|X|X|X|Y|X|X| RESERVADO
; |X|X|X|X|Y|X|X|X| RESERVADO
; |X|X|X|Y|X|X|X|X| RESERVADO
; |X|X|Y|X|X|X|X|X| RESERVADO
; |X|Y|X|X|X|X|X|X| RESERVADO
; |Y|X|X|X|X|X|X|X| RESERVADO
;
;X = DEFINIDO EM OUTRO LUGAR DA TABELA
;Y = DEFINIDO COMO MOSTRADO (0/1)
;**********************************************************************************************************************************************
Declarando os flags no programa fonte
;**********************************************************************************************************************************************
#DEFINE STATUS_BOTAO FLAGS,0
#DEFINE STATUS_LED FLAGS,1
;**********************************************************************************************************************************************

6º passo – Criar constantes
Formas de representação de um valor numérico

Decimal D'xx' ou .xx
Hexadecimal H'xx' ou 0Xxx
Octal O'xx'
Binário B'xxxxxxxx'
ASCII A'x' ou 'x'
x - valor
Usando a diretiva EQU para criar constantes

;**********************************************************************************************************************
MIN EQU .0 ;VALOR MINIMO
MAX EQU .10 ;VALOR MAXIMO
T_FILTRO EQU .250 ;FILTRO PARA O BOTAO
;**********************************************************************************************************************

7º passo – Identificar os pinos utilizados na aplicação
;**********************************************************************************************************************
; ENTRADAS
;**********************************************************************************************************************
; PINOS QUE SERAO UTILIZADOS COMO ENTRADA
#DEFINE BOTAO1 PORTA,1 ;0 --> PRESSIONADO
;1 --> LIBERADO
#DEFINE BOTAO2 PORTA,2 ;0 --> PRESSIONADO
;1 --> LIBERADO
;**********************************************************************************************************************
; SAIDAS
;**********************************************************************************************************************
; PINOS QUE SERAO UTILIZADOS COMO SAIDA
#DEFINE LED1 PORTB,0 ;0 --> APAGADO
;1 --> ACESO
;*********************************************************************************************************************

8º passo – Vetor reset (início do programa)
;*********************************************************************************************************
ORG 0x00 ;ENDERECO INICIAL DE PROCESSAMENTO
GOTO INICIO ;DESVIA PARA INICIO
;*********************************************************************************************************

9º passo – Vetor de interrupção
;*********************************************************************************************************
ORG 0x04 ;ENDERECO INICIAL DA INTERRUPCAO
RETFIE ;RETORNA DA INTERRUPCAO
;*********************************************************************************************************

10º passo – Configuração dos registradores com

finalidades específicas
;****************************************************************************************************************************************
INICIO
BANK1 ;ALTERA PARA BANCO 1
MOVLW B'00000110'
MOVWF TRISA ;DEFINE RA1 e RA2 COMO ENTRADA E DEMAIS COMO SAIDA
MOVLW B'00000000'
MOVWF TRISB ;DEFINE O PORTB COMO SAIDA
MOVLW B'10000000'
MOVWF OPTION_REG ;RESISTORES PULL_UPS DESABILITADOS <7>
;DEMAIS BITS IRRELEVANTES
MOVLW B'00000000' ;DESLIGADA CHAVE GERAL DE INTERRUPÇÃO <7>
MOVWF INTCON ;DEMAIS BITS IRRELEVANTES
BANK0 ;ATIVA BANCO 0
MOVLW B'00000111' ;CONFIGURA RA3:RA0 COMO I/O <2:0>
MOVWF CMCON
;*******************************************************************************************************************************************

11º passo – Inicialização das variáveis
;*************************************************************************************************************
CLRF PORTA ;LIMPA PORTA
CLRF PORTB ;LIMPA PORTB
MOVLW .250
MOVWF TEMP5 ;INICIALIZA TEMP5 COM 250
MOVLW .256-125 ;W RECEBE 131 (256 - 125)
MOVWF TMR0 ;INICIALIZA TMR0 COM 131
**************************************************************************************************************

12º e 13º passos – Rotina principal e Sub-rotinas
;*******************************************************************************************************************************************
;ROTINA PRINCIPAL. ESTE PROGRAMA ACENDE UM LED ENQUANTO O BOTAO 1 ESTIVER PRESSIONADO.
MAIN
BTFSC BOTAO1 ;BOTAO1 ESTA PRESSIONADO?
GOTO APAGA_LED ;NAO, DESVIA
GOTO ACENDE_LED ;SIM, DESVIA
APAGA_LED
BCF LED ;APAGA LED
GOTO MAIN ;RETORNA AO INICIO
ACENDE_LED
BSF LED ;ACENDE LED
GOTO MAIN ;DESVIA
;*******************************************************************************************************************************************
END ;FIM DO PROGRAMA
;*******************************************************************************************************************************************

FLUXOGRAMA
O fluxograma é uma arma poderosa que pode auxiliar o programador na
montagem do programa. Ele mostra como o programa está estruturado,
facilitando a montagem das sub-rotinas.

Exemplo 1: Acionando um LED com um botão

Acionando um led com um botão - FLUXOGRAMA

Inicializar Variáveis
A instrução CLRF pode ser utilizada para inicializar uma variável. Essa instrução zera a
variável (ou conteúdo da localidade de memória especificada no operando da instrução).
;**********************************************************************************************************
CLRF COUNT ;COUNT=0
;**********************************************************************************************************
Uma outra forma de inicializar uma variável é atribuir um valor diferente de zero a ela. Neste
caso, o valor numérico tem primeiro que ser colocado em W e depois ser passado para a
variável por meio da instrução MOVWF.
;**********************************************************************************************************
MOVLW H'17' ;W RECEBE 17h
MOVWF COUNT ;COUNT RECEBE CONTEUDO DE W
;**********************************************************************************************************

Desvio no Programa

Registradores PCL e PCLATH

Desvio no programa
- Desvio incondicional
- Desvio condicional
- Interrupção
- Reset

Desvio Incondicional
É quando o programa é desviado incondicionalmente para

um outro ponto da memória de programa, ou seja, o desvio
ocorre sem depender de nada. É preciso apenas informar o
endereço da memória de programa para onde ele será
desviado.

GOTO
Uma das maneiras de obter um desvio incondicional é por meio da instrução GOTO. Observe no
exemplo seguinte a sintaxe usada na instrução GOTO. O label LOOP na instrução é, na verdade,
um operando que representa o endereço de memória de programa para onde o programa será
desviado. O programa será desviado para o ponto do programa onde for encontrado o label LOOP.
;******************************************************************************************************************
GOTO LOOP ;desvia programa para LOOP
;******************************************************************************************************************
No lugar do label pode ser colocado o endereço em hexa. Para o MPLAB tanto faz o uso de um ou
de outro modo. Neste caso o programa será desviado para o ponto onde for encontrado o endereço
precedido da diretiva ORG.
;******************************************************************************************************************
GOTO 0x22 ;desvia programa para endereco 0x22 da memoria de programa
;******************************************************************************************************************
GOTO

GOTO
A instrução GOTO pode ser usada em conjunto com o caractere especial $ (dólar), quando o desvio
for de apenas algumas linhas.
;******************************************************************************************************************
GOTO $+2 ;SALTA DUAS LINHAS DE CODIGO PARA BAIXO
GOTO $-3 ;SALTA TRES LINHAS DE CODIGO PARA CIMA
;*****************************************************************************************************************
*

Escrever no Contador de Programa
;*****************************************************************************************************
;ESTE CODIGO CARREGA O CONTADOR DE PROGRAMA COM 0x150

MOVWF PCLATH ;PCLATH RECEBE 01h
MOVWF PCL ;PCL RECEBE 50h, PC RECEBE 0x150 E
;PROGRAMA DESVIA PARA O ENDERECO 0x150
;*****************************************************************************************************

Escrever no Contador de Programa
;*****************************************************************************************************
;A DIRETIVA ORG E USADA AQUI PARA INFORMAR QUE ESTE BLOCO DE CODIGO
COMECA NO ENDERECO 0x150 DA MEMORIA DE PROGRAMA
ORG 0x150

MOVWF COUNT ;COUNT RECEBE 45h
.
.
.
;*****************************************************************************************************

CALL (Chamada à Sub-Rotina)
;***************************************************
CALL LOOP ; DESVIA PARA LOOP
;***************************************************
O label LOOP está associado ao endereço da

memória de programa para onde o programa será
desviado. Veja na figura ao lado como ocorrem a
chamada e o retorno da sub-rotina LOOP por meio
da instrução CALL.
Quando o retorno é feito por meio da instrução
RETLW, o valor numérico especificado na instrução
é colocado em W.
;**************************************************
RETLW .25 ;RETORNA COM W = 25
;**************************************************

Pilha (Stack)
Para que o programa possa voltar ao ponto em que houve uma chamada à
sub-rotina, o endereço da primeira instrução após a instrução CALL (PC
+1) é salvo em uma pilha, que é nada mais que uma memória RAM com
algumas localidades. O PIC16F628A possui uma pilha com oito níveis, em
que podem estar armazenados até oito endereços de retorno. Isso significa
que uma sub-rotina pode ser chamada de dentro de outra sub-rotina num
limite de oito chamadas. Se o limite for ultrapassado, o primeiro endereço
de retorno será sobrescrito, impossibilitando o retorno ao primeiro nível de
chamada, provocando um sério erro no programa, com resultado
imprevisível.

Desvio Condicional
Este é um tipo de desvio que pode ou não ocorrer. Uma determinada condição tem de ser
satisfeita para que ocorra o desvio no programa. As seguintes instruções causam desvio
condicional no programa:
INCFSZ f,d d ← (f + 1) e salta a próxima linha se o resultado for zero
DECFSZ f,d d ← (f - 1) e salta a próxima linha se o resultado for zero
BTFSC f,b Testa o bit b do registrador f e salta a próxima linha se ele for zero
BTFSS f,b Testa o bit b do registrador f e salta a próxima linha se ele for um

Desvio Condicional
O desvio condicional está normalmente relacionado a uma decisão que precisa ser tomada pelo
programa a partir de uma determinada situação. O código seguinte testa o pino RB0, em que está
ligado um LED. Se ele estiver aceso (RB0=1), o programa desvia para uma rotina que irá apagá-lo
(APAGA_LED). Por outro lado, se o LED estiver apagado (RB0=0), o programa desvia para uma
rotina que irá acendê-lo (ACENDE_LED).
;***********************************************************************************************
BTFSS PORTB,0 ;LED ESTA ACESO? SE SIM PULA A PROXIMA LINHA
GOTO ACENDE_LED ;NAO, DESVIA
GOTO APAGA_LED ;SIM, DESVIA
;***********************************************************************************************

Desvio Condicional
No código seguinte vemos que a sub-rotina DELAY_100mSEG é
executada dez vezes até que COUNT chegue a zero, o que fará com
que o programa seja desviado para UM_SEG, informando que
transcorreu o tempo de um segundo. As instruções INCFSZ e
DECFSZ podem ser uma boa opção quando desejamos que uma
sub-rotina seja executada um determinado número de vezes, o que
chamamos de loop.
;************************************************************************************
DEC_COUNT
MOVLW .10 ;W RECEBE 10
MOVWF COUNT ;COUNT RECEBE 10
LOOP
CALL DELAY_100mSEG ;CHAMA SUB-ROTINA DE TEMPO 100mSEG
DECFSZ COUNT,F ;DECREMENTA COUNT. COUNT=0?
GOTO LOOP ;NAO, VOLTA AO LOOP
GOTO UM_SEG ;SIM, PASSOU UM SEGUNDO, DESVIA
;************************************************************************************
Desvio Provocado por uma Interrupção
Quando uma interrupção ocorre, estando habilitada, o programa é desviado para o endereço
0x04 no qual começa a sub-rotina que irá tratar o evento que deu origem à interrupção. Ao
encontrar a instrução RETFIE, o programa volta ao ponto em que foi interrompido.
O tratamento de uma interrupção e uma chamada à sub-rotina por meio da instrução CALL
funcionam de forma semelhante, sendo diferenciados pelo elemento responsável pelo desvio,
que, no caso da interrupção, é provocado por um evento de hardware.

Desvio Provocado por uma Interrupção

Desvio Provocado pelo Reset
O reset faz com que o programa volte ao início, ou seja, ocorre um desvio para o endereço 0x00. Os
motivos que levam o MCU ao reset são:
- Power-on reset (POR - ocorre quando o chip é ligado)

- /MCLR reset durante operação normal
- /MCLR reset durante o sleep
- WDT reset (durante operação normal)
- Brown-out reset (BOR - reset por baixa tensão de alimentação)

Desvio Provocado pelo Reset

Reset por Software
Um reset por software pode ser provocado se o Contador de Programa for zerado. O código
seguinte mostra como fazê-lo.
;********************************************************************************************
MOVWF PCLATH ;PCLATH RECEBE 0
MOVWF PCL ;PCL RECEBE 0, RESET
;*******************************************************************************************
Uma outra forma de provocar um reset por software é usar a instrução GOTO, fazendo com que o
programa desvie para a localidade 0x00.
;********************************************************************************************
GOTO 0x00 ;RESET
;********************************************************************************************

Cálculos Matemáticos
- Soma
- Subtração
- Lógica OU
- Lógica And
- Ou-exclusivo

Soma
O PIC16F628A possui quatro instruções que efetuam a operação matemática da soma. Usando-
as corretamente, você pode criar uma série de sub-rotinas importantes como desvio condicional,
acesso à tabela, repetição de bloco de instruções, entre outras, que podem ser usadas em
qualquer programa.
INCF f,d d ← (f+ 1)
INCFSZ f,d d ← (f + 1) e salta a próxima linha se o resultado for zero
ADDWF f,d d ← (W + f)
ADDLW k W ← (W + K)

Incrementar Contadores Unitários
;*********************************************************************************************************
INC_DEBOUNCE
MOVLW .6 ;INICIALIZA DEBOUNCE COM 6

MOVWF DEBOUNCE
TESTA_BOTAO1
BTFSC BOTAO1 ;BOTAO1 ESTA PRESSIONADO?

GOTO INC_DEBOUNCE ;NAO, DESVIA
INCF DEBOUNCE,F ;SIM, INCREMENTA DEBOUNCE
BTFSS STATUS,Z ;DEBOUNCE=0?
GOTO TESTA_BOTAO1 ;NAO, DESVIA
MOVLW .6 ;SIM, INICIALIZA DEBOUNCE COM 6
MOVWF DEBOUNCE
GOTO TRATAR_BOTAO1 ;DESVIA
;********************************************************************************************************

Somar Dois Bytes
;***********************************************************************************************
SOMA_DOIS_BYTES
CLRF RESULTADO_AUTO ;ZERA RESULTADO_ALTO

MOVF NUM_A,W ;W RECEBE NUM_A
ADDWF NUM_B,W ;W RECEBE NUM_B + NUM_A
MOVWF RESULTADO_BAIXO ; RESULTADO_BAIXO RECEBE W
BTFSC STATUS,C ;HOUVE ESTOURO?
GOTO RESULT_9BITS ;SIM, DESVIA
RETURN ;NAO, RETORNA
RESULT_9BITS
INCF RESULTADO_AUTO,F ;RESULTADO_ALTO RECEBE 9º BIT DA SOMA

RETURN ;RETORNA
;***********************************************************************************************

Comparar Valores - Maior, Menor ou Igual
A sub-rotina seguinte verifica se COUNT é maior,

menor ou igual a (256 − X), sendo X o valor que
deve ser somado ao conteúdo de COUNT. Observe
no exemplo que X = 106. Sendo assim, a
comparação será feita entre COUNT e o valor 150
(256 − 106).
;******************************************************************************************************************************
;ESTA ROTINA VERIFICA SE O VALOR ARMAZENADO EM COUNT E MENOR, MAIOR OU IGUAL A 150
COMPARA_VALOR
MOVF COUNT,W ;W RECEBE COUNT
ADDLW .106 ;W = COUNT + 106
BTFSS STATUS,C ;W ESTOUROU?
GOTO MENOR ;NAO, COUNT E MENOR QUE 150, DESVIA
;SIM, COUNT E MAIOR OU IGUAL A 150, CONTINUA
BTFSS STATUS,Z ;W = 0?
GOTO MAIOR ;NAO, CONTEUDO DE COUNT E MAIOR QUE 150, DESVIA
GOTO IGUAL ;SIM, CONTEUDO DE COUNT E IGUAL A 150, DESVIA
;******************************************************************************************************************************

Somar Dois Bytes
As instruções ADD afetam os bits C, DC e Z do registrador STATUS. O bit Z (STATUS<2>) informa

se o resultado da soma deu zero, o bit DC (STATUS<1>) informa se houve estouro do terceiro para
o quarto bit e o bit C (STATUS<0>) informa se houve estouro do oitavo para o nono bit. Veja na
figura abaixo o conteúdo dos registradores RESULT_BAIXO e RESULT_ALTO e dos flags Z, C e
DC após a soma.

Subtração
Quatro são as instruções utilizadas em operações de subtração no PIC16F628A. Assim como
pode ser feito com as instruções de soma, várias sub-rotinas podem ser implementadas com as
instruções de subtração.
DECF f,d d ← (f − 1)
DECFSZ f,d d ← (f − 1) e salta a próxima linha se o resultado for zero
SUBWF f,d d ← (f − W)
SUBLW k W ← (K − W)

Decrementar Contadores Unitários
;*******************************************************************************************************************
TEST_SOM
BTFSS SOM ;EMITIR SOM?

MOVLW .10 ;SIM, INICIALIZA COUNT COM 10
MOVWF COUNT
LOOP
CALL EMITE_SOM ;CHAMADA A SUB-ROTINA QUE EMITIRA SOM
DECFSZ COUNT,F ;DECREMENTA COUNT, COUNT=0?
GOTO LOOP ;NAO, DESVIA
BCF SOM ;SIM, APAGA FLAG SOM
RETURN ;RETORNA
;*****************************************************************************************************************

Subtrair Dois Bytes
A operação da subtração difere um pouco da de soma, visto que o resultado pode ser positivo,
zero ou negativo. Os flags afetados por uma subtração são os mesmos da soma, ou seja, os bits
C, DC e Z do registrador STATUS. Os exemplos seguintes mostram a utilização da instrução SUB
para os três tipos de resultados possíveis.
Exemplo 1: Resultado positivo

;*********************************************************************************************************************************************
MOVLW .3 W RECEBE 3
SUBWF COUNT,F ;COUNT = COUNT - 3
;*********************************************************************************************************************************************
Exemplo 2: Resultado zero

;*********************************************************************************************************************************************
;*********************************************************************************************************************************************

Subtrair Dois Bytes
Exemplo 3: Resultado negativo
;*********************************************************************************************************************************************
;COMO O RESULTADO E NEGATIVO, O MESMO APARECE EM COUNT EM COMPLEMENTO DE DOIS (256 - 15).
;AS DUAS INSTRUCOES A SEGUIR RECUPERAM O MODULO DO RESULTADO.
COMF COUNT,F ;COMPLEMENTO DE UM DE COUNT

INCF COUNT,F ;COUNT = COUNT+1, MODULO DO RESULTADO
;*********************************************************************************************************************************************

Subtração em Complemento de Dois
Esta é uma técnica que permite efetuar uma subtração utilizando instruções de soma. Antes de
vermos o código, vamos aprender o que é complemento de dois. No exemplo seguinte nós
podemos observar como é obtido o complemento de dois de um número. Primeiro
complementamos todos os bits do número, ou seja, quem é (0)zero passa a ser (1)um e vice-
-versa. Este é o complemento de um do número. O complemento de dois de um número é o
complemento de um dele somado a uma unidade.

Subtração em Complemento de Dois
Veja a seguir um exemplo de uma subtração em
complemento de dois. O resultado da subtração
(COUNT - W) retorna em COUNT, enquanto o
status do resultado, isto é, se ele é positivo,
negativo ou zero, retorna em W.
;**********************************************************************************************************************
SUB_COMP_2
COMF COUNT,F ;COMPLENMENTO DE UM DE COUNT
INCF COUNT,F ;COMPLEMENTO DE DOIS DE COUNT
ADDWF COUNT,F ;COUNT=COUNT + W
BTFSC STATUS,C ;HOUVE ESTOURO?
GOTO RESULT_ZERO ;SIM, RESULTADO ZERO OU NEGATIVO, DESVIA
;NAO, RESULTADO POSITIVO, CONTINUA
RESULT_POSITIVO
COMF COUNT,F ;COMPLEMENTO DE UM DE COUNT
INCF COUNT,F ;COMPLEMENTO DE DOIS DE COUNT
RETLW .1 ;RESULTADO POSITIVO
RESULT_ZERO
BTFSS STATUS,Z ;RESULTADO E ZERO?
GOTO RESULT_NEGATIVO ;NAO, RESULTADO NEGATIVO, DESVIA
RETLW .0 ;SIM, RETORNA
RESULT_NEGATIVO
RETLW .2 ;RESULTADO NEGATIVO
;***********************************************************************************************************************

Comparar Valores - Maior, Menor ou Igual
Assim como as instruções ADD, as instruções SUB podem ser usadas para fazer comparações
entre valores. A sub-rotina seguinte verifica se o conteúdo de COUNT é maior, menor ou igual a
10, retornando o status do resultado em W.
W=0 ;COUNT=10
W=1 ;COUNT<10
W=2 ;COUNT>10
;********************************************************************************************
COMPARA_VALOR2

SUBWF COUNT,W ;W = COUNT - 10
BTFSS STATUS,C ;COUNT<10?
RETLW .1 ;SIM, RETORNA
BTFSS STATUS,Z ;NAO, COUNT=10?
RETLW .2 ;NAO, COUNT>10, RETORNA
RETLW .0 ;SIM, COUNT=10, RETORNA
;*****************************************************************************************************

Funções Lógicas
As funções lógicas são úteis quando for necessário efetuar operações lógicas entre os diversos
bits de um byte. A função lógica não leva em conta o valor numérico do byte, e sim o nível lógico
de cada bit dentro dele, devido ao fato de as operações serem feitas bit a bit.
IORWF f,d d ← (W ou f)
ANDWF f,d d ← (W and f)
XORWF f,d d ← (W xor f)
IORLW k W ← (W ou K)
ANDLW k W ← (W and K)
XORLW k W ← (W xor K)

Função Lógica da Soma IOR (IORWF e IORLW)
As instruções IOR executam a função lógica da soma bit a bit. A tabela seguinte mostra o
resultado de uma operação lógica de soma entre dois bits, para cada combinação possível.
Apenas o bit Z do registrador STATUS é afetado pelas instruções IOR, sendo setado quando
todas as somas bit a bit tiverem como resultado 0.

Função Lógica da Soma IOR (IORWF e IORLW)

Função Lógica da Multiplicação AND (ANDLW e ANDWF)
As instruções AND executam a função lógica da multiplicação. Ao contrário das instruções IOR, o
resultado da multiplicação será 1 somente se todos os bits forem iguais a 1, como mostra a tabela
seguinte. O bit Z do registrador STATUS é o único afetado pelas instruções AND, e será setado
quando o resultado de todas as multiplicações for igual a 0.

Máscara de Bits
A utilização mais comum das instruções AND é a de mascarar bits dentro de um byte. O termo
máscara é utilizado aqui para informar que alguns bits serão forçados a assumir nível 0. No
exemplo a seguir, a instrução ANDLW é utilizada para mascarar o nibble alto do registrador MULT,
ou seja, os quatro bits mais significativos. Para isso, o conteúdo de MULT é multiplicado por W, que
tem armazenado o valor B'00001111'. Observe que os bits W<7:4> estão em nível 0, o que fará
com que, no resultado da multiplicação, esses bits também assumam 0. Os bits
MULT <3:0> manterão seus respectivos níveis lógicos, visto que serão multiplicados por 1.

Função Lógica OU-EXCLUSIVO (XORLW e XORWF)
Esta é uma função lógica que compara dois bits, fornecendo 1 na saída se eles forem diferentes, e 0
na saída se eles forem iguais. As instruções XOR afetam apenas o bit Z do registrador STATUS, que
será setado quando o resultado for zero.

A função XOR é muito utilizada na comparação de valores para verificar se um valor é igual a outro.
Observe no exemplo a seguir que isso é feito por meio da instrução XORWF TEMP,W. Se os valores
armazenados em W e TEMP forem iguais, o resultado será 0. O teste no bit Z do registrador STATUS,
após a instrução XOR, tem o objetivo de verificar se o resultado é 0; se for, o bit Z (STATUS<2>) estará
setado. Se forem diferentes, o bit Z estará apagado.

A função XOR é muito utilizada na comparação de valores para verificar se um valor é igual a outro.
Observe no exemplo a seguir que isso é feito por meio da instrução XORWF TEMP,W. Se os valores
armazenados em W e TEMP forem iguais, o resultado será 0. O teste no bit Z do registrador STATUS,
após a instrução XOR, tem o objetivo de verificar se o resultado é 0; se for, o bit Z (STATUS<2>) estará
setado. Se forem diferentes, o bit Z estará apagado.

Verificar Modo de Operação
Suponha que um equipamento possui quatro modos de operação diferentes, representados pelos bits
FLAGS<1:0>, como mostra a tabela seguinte. A sub-rotina detecta em qual modo de operação o
equipamento está funcionando no momento. Como só os bits FLAGS<1:0> importam, os demais serão
mascarados por meio da instrução ANDLW.

Verificar Modo de Operação

Operações com Bytes
As instruções estudadas neste item não executam funções lógicas ou aritméticas diretamente,
embora possam ser usadas em sub-rotinas com estes fins.
-COMF (Complemento)
- SWAPF (Troca ou Inversão)
- Rotação (RRF e RLF)

COMF (Complemento)
Essa instrução complementa todos os bits de um byte, ou seja, o bit que está em nível 1 vai para
0 e vice-versa. A inversão de nível lógico em todos os bits de um byte é chamada de
complemento de um.

SWAPF (Troca ou Inversão)
Essa instrução inverte o nibble alto do byte (quatro bits mais significativos <7:4>) com o nibble
baixo (quatro bits menos significativos <3:0>). Ela é amplamente utilizada em operações
matemáticas no código BCD.

Rotação (RRF e RLF)
O PIC16F628A possui duas instruções que rotacionam os bits de um byte para a esquerda e para a direita. A
instrução RRF desloca os bits de um byte para a direita, ao passo que a instrução RLF desloca-os para a
esquerda. No exemplo a seguir, o conteúdo de TEMP é rotacionado para a direita. Quando a instrução RRF
TEMP é executada, todos os bits são deslocados para a direita, sendo o bit C (STATUS<0>) deslocado para a
posição TEMP<7> e o bit TEMP<0> deslocado para C (STATUS<0>). O código seguinte mostra como é feito o
rotacionamento de um byte para a direita.

Rotação (RRF e RLF)
O rotacionamento para a esquerda funciona de forma semelhante ao rotacionamento para a direita. O código
seguinte mostra como isso é feito.

Paridade
Quando os chips de memória começaram a ser fabricados e utilizados em projetos de computadores,
apresentavam defeitos com uma certa freqüência. Um defeito muito comum era um bit armazenado numa
determinada localidade de memória mudar de nível lógico. Para reduzir os transtornos provocados por defeitos
de memória, foi utilizada a técnica de verificação de defeitos chamada paridade. Essa técnica consiste em
acrescentar um bit à informação armazenada em cada localidade de memória. Este é o bit de paridade. A
paridade pode:
- Par
- Impar
O projetista determina qual das duas ele utilizará no projeto. O bit de paridade pode ser
utilizado em outras aplicações, como transmissão de dados serial, por exemplo.

Paridade Par

Paridade Ímpar

Gerar o Bit de Paridade
A sub-rotina seguinte gera o bit de paridade par e retorna-o em W. O
conteúdo do regis-trador SERIAL será usado para gerar o bit de
paridade. Para o código seguinte gerar paridade ímpar, basta
inicializar W com o valor 1 (MOVLW .1) em vez de zero (CLRW).

Código BCD
Este é um código amplamente usado em aplicações com microcontroladores. No código BCD, cada
dígito do número representado no sistema decimal é convertido no sistema binário, utilizando quatro
bits. Veja nos exemplos como é feita a conversão.

Código BCD
A tabela seguinte mostra a equivalência entre os sistemas decimal, binário-padrão e o código BCD.

Conversão de Binário
Padrão em BCD
Vários dispositivos trabalham com valores

numéricos representados em BCD, como muitos
teclados e interfaces de vídeo, por exemplo. A
sub-rotina seguinte converte um número decimal
na faixa de 00 a 99(representado em binário-
padrão) no código BCD. Quando você se
deparar com um dispositivo que trabalhe com o
código BCD, essa sub-rotina será útil.

Conversão de BCD em Binário-Padrão
A sub-rotina seguinte é o complemento do
exemplo anterior, ou seja, converte um valor de
00 a 99 em BCD no sistema decimal
(representado em binário-padrão). O valor em
BCD é recebido por meio de TEMP e o valor
convertido é retornado em W.

Contador BCD de 0 a 59
Essa sub-rotina, cada vez que é
executada, incrementa COUNT,
um contador em BCD que conta
de 0 a 59, quando ele é, então,
resetado. O nibble baixo de
COUNT (COUNT<3:0>)
armazena a unidade enquanto o
nibble alto COUNT <7:4>
armazena a dezena.
Aqui está uma boa oportunidade
para falarmos novamente sobre
inicialização de variáveis. Para
que o contador seguinte funcione
corretamente, a variável COUNT
precisa ser inicializada com zero
(CLRF COUNT), antes que a sub-
rotina CONTADOR_0_59 seja
executada pela primeira vez.


;*********************************************************************************************************************************************
CONTADOR_0_23
SUBWF COUNT,W ;W = COUNT – 20
BTFSS STATUS,C ;COUNT ≥ 20?
GOTO COUNT_MENOR ;NAO, DESVIA
;SIM, CONTINUA
COUNT_MAIOR
INCF COUNT,F ;INCREMENTA UNIDADE
ANDLW B'00001111' ;MASCARA NIBBLE SUPERIOR DE W
XORLW B'00000100' ;W = W xor H'4'
BTFSS STATUS,Z ;UNIDADE > 3?
CLRF COUNT ;SIM, RESETA CONTADOR
COUNT_MENOR
INCF COUNT,F ;INCREMENTA UNIDADE
ANDLW B'00001111' ;MASCARA NIBBLE SUPERIOR DE W
XORLW B'00001010' ;W = W xor H'0A'
BTFSS STATUS,Z ;UNIDADE > 9?
MOVLW B'11110000' ;SIM, W = H'F0'
ANDWF COUNT,F ;ZERA UNIDADE
SWAPF COUNT,F ;INVERTE DEZENA COM UNIDADE
INCF COUNT,F ;INCREMENTA DEZENA
SWAPF COUNT,F ;DEZENA E UNIDADE VOLTAM AS SUAS POSICOES
RETURN ;RETORNA
;*********************************************************************************************************************************************

Contador
crescente/decrescente de 0 a 9

Contador
crescente/decrescente de 0 a 9
Contador
crescente/decrescente de 0 a F

Endereçamento Indireto
O acesso à memória via endereçamento indireto é feito por meio dos registradores INDF e
FSR, que ocupam, respectivamente, os endereços 00h e 03h do banco 0, com espelho
nos demais bancos de memória (ver mapeamento de memória RAM).
Diferentemente do endereçamento direto, em que o endereço da localidade de memória
que será acessada aparece no operando da instrução, no endereçamento indireto, o que
aparece na instrução é um ponteiro para a localidade de memória que será acessada.
Neste contexto, o conteúdo do registrador FSR aponta para o endereço de memória,
enquanto o valor contido em INDF é o valor armazenado no endereço apontado por FSR.

Diferentemente do endereçamento direto, em que o endereço da localidade de memória

que será acessada aparece no operando da instrução, no endereçamento indireto, o que
aparece na instrução é um ponteiro para a localidade de memória que será acessada.
Neste contexto, o conteúdo do registrador FSR aponta para o endereço de memória,
enquanto o valor contido em INDF é o valor armazenado no endereço apontado por FSR.

O endereçamento indireto é uma ferramenta muito poderosa, principalmente quando o
programa está manipulando blocos de memória. No código seguinte, o endereçamento
indireto é usado para preencher com 0xFF o bloco de memória RAM de 70h até 7Fh.
;**************************************************************************************************************
PREENCHE_MEM
MOVLW H'70'
MOVWF FSR ;FSR APONTA PARA END 70h
INICIA_RAM
MOVLW H'FF'
MOVWF INDF ;LOC. ENDERECADA POR FSR RECEBE H'FF'
MOVLW H'7F' ;W RECEBE 7Fh
XORWF FSR,W ;W = FSR xor 7Fh
BTFSC STATUS,Z ;BLOCO DE MEMORIA CHEGOU AO FIM?
RETURN ;SIM, RETORNA
INCF FSR ;NAO, INCREMENTA FSR
GOTO INICIA_RAM ;DESVIA
;**********************************************************************************************
Se a sub-rotina anterior for implementada utilizando o
endereçamento direto, o número de instruções será muito
maior. O endereçamento indireto pode ser usado em muitas
outras aplicações, reduzindo significativamente o código, ser
for utilizado de forma conveniente.
Tabelas
Tabela é um recurso muito poderoso que podemos utilizar para armazenar informações.
Tanto a memória RAM quanto a memória de programa podem ser utilizadas para o
armazenamento dos dados de uma tabela.

Tabelas
O fragmento de código seguinte mostra um exemplo da utilização do contador de programa para
efetuar um desvio com o objetivo de acessar um dado numa tabela criada na memória de programa.
A sub-rotina CONV_DISP recebe um valor numérico no sistema hexa e o converte em display de
sete segmentos por meio de uma tabela, retornando o valor em W.
;*********************************************************************************************************************************************
CONV_DISP
MOVLW H'05' ;W RECEBE 5
ADDWF PCL,F ;SOMA PCL E W
;OS COMENTARIOS ABAIXO SE REFEREM AOS VALORES VISTOS NO DISPLAY
; GFEDCBA ;POSICAO DOS SEGMENTOS DO DISPLAY LIGADO NO PORTB
RETLW B'00111111' ;0
RETLW B'00000110' ;1
RETLW B'01011011' ;2 A sub-rotina CONV_DISP faz acesso a uma tabela que retorna valores que devem
RETLW B'01001111' ;3 ser escritos no PORTB, para que possamos visualizar num display de sete
RETLW B'01100110' ;4
RETLW B'01101101' ;5 segmentos ligado nesse PORT o valor que é introduzido na tabela por meio de W.
RETLW B'01111101' ;6 O cuidado que deve ser tomado no uso de tabelas, como mostra o exemplo a
RETLW B'00000111' ;7
RETLW B'01111111' ;8 seguir, é que, quando o PCL for somado com W, ele não pode estourar. Observe
RETLW B'01100111' ;9 que o resultado da soma é armazenado no próprio PCL, e se ele estourar, o
RETLW B'01110111' ;A
RETLW B'01111100' ;B
programa será desviado para o início, provocando um erro grave. No código
RETLW B'00111001' ;C seguinte, o conteúdo do PCL não pode ser um valor acima de 240 (antes da
RETLW B'01011110' ;D
RETLW B'01111001' ;E
soma), para que não haja estouro.
RETLW B'01110001' ;F
;**********************************************************************************************************************************************

MCU PIC CURSO BASICO - 001 - Microprocessdores

Enviado por

Dados do documento

Título original

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

MCU PIC CURSO BASICO - 001 - Microprocessdores

Enviado por

Direitos autorais:

Formatos disponíveis

Todos os direitos reservados.

Proibida a distribuição total ou parcial deste

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Tutorial sobre o microcontrolador PIC16F628A

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

CPU – É um circuito integrado (CI) capaz de executar um conjunto de tarefas

Memória – Armazena os dados que serão processados e os programas que

Dispositivos de I/O – São os responsáveis pela entrada e saída de dados do

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

CPU CISC – As CPUs utilizadas em computadores que seguem a arquitetura

CPU RISC – As CPUs utilizadas em computadores que seguem a arquitetura

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Para gerenciar o sistema a CPU precisa se comunicar

Leitura - quando a CPU busca uma informação na memória ou num

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

REFRESH - É uma simulação de leitura que é feita em cada localidade de

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

“É um computador em um único chip. O microcontrolador integra em um

Ao contrário do microcontrolador, para se construir um computador com um

- Arquitetura RISC (set de instruções reduzido)

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Qualquer instrução executada pela CPU utiliza como

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Os Microcontroladores PIC gastam quatro ciclos de clock

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

A memória de RAM (ou de dados) do PIC16F628A é

Registradores com finalidade específica

Obs:. Cada registrador do PIC16F628A ocupa uma

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Bit 5: T0CS: Define a origem do incremento do registrador TMR0

Bit 4: T0SE: Define a borda em RA4/T0CKI que irá incrementar o TMR0

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Bit 6: CMIE: Bit de habilitação da interrupção do comparador

Bit 5: RCIE: Bit de habilitação da interrupção de recepção de dados na USART

Bit 4: TXIE: Bit de habilitação da interrupção de transmissão de dados na USART

Bit 2: CCP1IE: Bit de habilitação de interrupção do módulo CCP

Bit 1: TMR2IE: Habilita interrupção de estouro de TMR2

Bit 0: TMR1IE: Habilita interrupção de estouro de TMR1

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Bit 6: CMIF: Bit de sinalização da interrupção do comparador

Bit 5: RCIF: Bit de sinalização da interrupção de recepção de dados na USART

Bit 4: TXIF: Bit de sinalização da interrupção de transmissão de dados na USART

Microcontroladores PIC16F628A/648A – Curso Básico Wagner da Silva Zanco

Código de Operação (Op. Code)