Apostila HC Hcs 08

MICROCONTROLADORES
• BIBLIOGRAFIA:
• Microcontroladores HC908Q Teoria e prática – Editora Erica / Fábio Pereira
• Microcontroladores HCS08 Teoria e prática – Editora Erica / Fábio Pereira
• Apostila - HC_908.PDF
• Manual – HC08DEBUGGERRM.PDF
• Manual – MC68HC908QY4.PDF
• Manual – MCS9S08QG8.PDF
• Manual – CPU08RM.PDF
• Manual – NITRON TECHNICAL DATA BOOK.PDF
Versão Gama
Prof. Sérgio Tavares
MICROCONTROLADORES
Everywhere!
MICROCONTROLADORES – ENCAPSULAMENTOS
MICROCONTROLADORES - CARACTERISTICAS
• High Performance, Easy to Use 68HC08 CPU

• As fast as 125ns minimum instruction cycle time at 8 Mhz bus
HC08 CPU
• Memory
• 1.5K or 4K bytes of in-application re-programmable Flash
4K or 1.5K • 128 bytes of RAM
KBI
Flash • Peripherals
• 2-ch, 16-bit Timer with selectable IC, OC, or PWM
• Computer Operating Properly and LVI with selectable trip point
4-ch • Analog to Digital Converter (QT2/QT4/QY2/QY4 only)
128 RAM 8-Bit • Keyboard Interrupts
ADC
• Up to 13 general purpose I/O and 1 input
• Available Packages (First 6 MCUs in Family)
2-ch 16-bit • 8 PDIP, 8 SOIC, 16 PDIP, 16 SOIC, 16 TSSOP
COP
Timer • Development Tools/ Documentation
• FREE CodeWarrior Development Studio Special Edition includes
highly optimized C compiler, assembler, linker, debugger, and
Up to 13 auto-code generator for all QT/QY MCUs
LVI GPIO and • Hardware tools from low cost demo boards to high performance
1 input emulators
• Target Applications:
• Discrete replacement, appliances, control systems, home and
industrial security systems, fluorescent light ballasts,
electromechanical replacement, consumer and appliances
MICROCONTROLADORES – ENCAPSULAMENTOS / ELÉTRICA
MICROCONTROLADORES – OSCILADOR INTERNO
MICROCONTROLADORES – CODE WARRIOR
Estas informações tem a finalidade de inicializar um projeto utilizando o Code Warrior 5.1
Ao inicializar este programa logo é

apresentada esta tela inicial, onde podemos
escolher as seguintes opções:
Cria um novo projeto com auxilio do

programa (recomendável)
Carrega exemplos de programas existentes
Carrega um projeto já existente
Carrega o tutorial do Code Warrior
Inicia o programa normalmente sem

nenhum auxilio.
O Code Warrior tem um processo chamado de WIZARD onde ele auxilia passo a passo a construção do seu projeto
Escolha o nome do projeto

Coloque em Assembly
Este é o local onde

será gravado o projeto
O caminho pode ser
alterado pelo botão
SET
Ao termino da configuração click em

AVANÇAR
Nesta janela você pode fazer a escolha do microcontrolador que irá usar em seu projeto.
Para esta apresentação estará sendo escolhido o HC908QY4
Obs. Ainda não

foi escolhido
Familia de microcontroladores
da FREESCALE Ao escolher click em avançar
Continuando ainda na mesma tela de escolha do microcontrolador foi escolhido o HC68HC908QY4 em modo de simulação.
Obs. para um futuro podemos usar os gravadores.
Configurado em
modo de simulação
Gravadores
de microcontroladores
Microcontrolador Após a escolha click em avançar

escolhido
Caso tenha outras fontes a adicionar estas ficam em PROJECT FILES.

No momento não existe nenhum e podemos avançar direto
O processador expert é uma ferramenta de desenvolvimento que será visto futuramente.

Click em concluir como a tela se encontra originalmente para iniciar o projeto
Esta é a tela onde iremos trabalhar no software do microcontrolador
Click duas vezes em

MAIN para aparecer
a tela de CODIGO ASSEMBLY
no lado direito
O seu programa deve

ser escrito depois do
MAIN LOOP
Este icone faz ingressar

no simulador para os devidos
Nesta página discutiremos alguns itens testes antes da gravação no
importantes para começar a programar microcontrolador
Este ícone permite

a troca do microcontrolador
Nesta janela podemos

trocar a função de
simulação para gravação.
Os nossos gravadores são
configurados em
MON08INTERFACE
Este ícone faz a

compilação do
Para simular deixe em programa e localiza
FULL CHIP SIMULATION possíveis erros de
Para gravar deixe em escrituração.
MON08INTERFACE
Esta tela é o local onde podemos fazer a simulação e ver os resultados obtidos do desempenho do programa
Nestas páginas estaremos vendo com mais detalhes a funcionalidade das janelas do simulador e seu ícones
Faz rodar o Apaga todos

programa os dados da
passo a passo simulação
Faz rodar o Faz parar a

programa em simulação do
modo continuo programa
Estes comandos só
funcionam na emulação
Esta janela informa em que

linha o microcontrolador esta.
Aqui você vê o seu programa
original o qual foi escrito.
Para acionar a simulação use
o comando passo a passo
Esta janela mostra o resultado

da simulação.
se usar o passo a passo você
tem o resultado linha a linha, caso
contrário só irá ver o comando
running.
Ela também informa erros, dá
propostas de soluções e podemos
inserir comandos como por exemplo
acionar uma chave ou ver uma
saída energizada (pinos)
Nesta janela você vê o seu programa escrito anteriormente

mas de maneira mais detalhada. Ele fornece o endereço
do contador de programa (PC), os códigos digitados e os
dados ou endereços o qual foram as instruções
Dados ou endereços
Códigos
Endereço do PC
Nesta janela é possível ver todos os dados dentro

da memória flash do microcontrolador desde
0000 a FFFF
Ciclos gastos pela CPU ao rodar o programa
Família de
microcontroladores Valores contidos no acumulador
utilizado Valores contidos no Stack Pointer
Registrador de Status, onde este

Registrador informa como esta o microcontrolador
HX de 16 bits em negrito.
V =Indicador de estouro (+127 ou – 128)
H = Half – Carry entre os bits 3 e 4
I = Interrupção habilitada
Endereço em que se encontra o N = Resultado negativo na operação
programa dado pelo Program Counter (PC) Z = Resultado zero na operação
C = Transporte ou emprestimo
Carry/Borrow, onde ocorre operações de
soma acima de 255, resultados menores
que zero e deslocamento / rotação
Iremos colocar duas linhas de programa para fazer um carregamento no acumulador e salvar na memória
E logo em seguida analisar no simulador.
REGRAS DAS CORES
Azul = comando
reconhecido
Vermelho = comentários
Preto = comando não

reconhecido
Programa
Linhas de comentários são importantes para

lembrar do que foi programado. Isto é necessário
Use ponto e virgula ( ; ) para fazer comentários pois esta linguagem é abstrata.
Para compilar e simular use os ícones

e
Esta é a tela do simulador com o programa ainda não simulado. Para simular use os icones Step e Reset
Usando o Step by Step podemos acompanhar linha a linha do andamento do programa nas seguintes telas
A linha em
AZUL MARINHO
Informa que será
SIMULADA após
O comando STEP
Observe que quando o CODE WARRIOR faz as alterações no microcontrolador mediante o

prograna residente, ele deixa em vermelho a informação.
Para ver a simulação

novamente RESET o
programa com o ícone
Número 08 hexa inserido no acumulador
Número 08 hexa salvo na

memória 0080
MICROCONTROLADORES – AREA DE MEMÓRIA
Para que possamos fazer uma correta programação em um microcontrolador, devemos conhecer o
endereçamento de memória do microcontrolador.
Mapa de memória
HC908QY4/QT4
MICROCONTROLADORES – AREA DE MEMÓRIA
Mapa de memória
HC908QY4/QT4
MICROCONTROLADORES – COMANDOS
Nestas páginas futuras estaremos mostrando alguns comandos importantes para a devida programação de um
microcontrolador – Maiores informações consultem o manual CPU08RM.PDF e o livro
Microcontroladores HC908Q Teoria e prática – Editora Erica / Fábio Pereira
REGRAS IMPORTANTES
# = Indica valor decimal #% = Indica valor binário
#$ = Indica valor hexadecimal $ = Indica endereço
LDA – Carrega um valor de imediato ou pela memória
Ex. LDA #08 - Carregamento do numero 08 em decimal para o acumulador

LDA #$08 - Carregamento do numero 08 em hexadecimal para o acumulador
LDA #%00001000 - Carregamento do número 08 em binário para o acumulador
LDA $80 - Carregamento de um número contido na memória na posição $0080 para o acumulador
STA – Carrega o valor do acumulador para a memória
Ex. STA $80 - Carrega o valor contido no acumulador para a posição de memória 0080
MOV – Movimenta um valor para a memória, e valores entre áreas de memória
Ex. MOV #02,$82 - Movimenta o valor 02 decimal para a área de memória $0082
MOV $82, $80 - Copia o valor na área de memória$ 0082 para $0080
Existe também a possibilidade de alterar somente um bit, como mostra abaixo com os comandos BSET e BCLR
Exemplo:
MOV #%00001111, $80 COLOCANDO O NUMERO HEXA 0F NA POISÇÃO $80 DA RAM
BCLR 0,$80 APAGANDO O BIT 0 DA MEMÓRIA $80
BSET 7,$80 INCREMENTANDO O BIT 7 DA MEMÓRIA $80
Também é possível fazer na porta de saída do microcontrolador.
Exemplo:
BCLR 1, PTB NÃO TERÁ TENSÃO NO PINO 1
BSET 6, PTB TERÁ TENSÃO NO PINO 6
Para o apagamento total de um determinado endereço de memória usamos o CLR
Exemplo:
MOV #FF,$80 COLOCA O NUMERO FF EM HEXA NA MEMÓRIA $80
CLR $80 APAGA TODO CONTEÚDO COLOCADO NO ENDEREÇO $80
Também é possível fazer na porta de saída do microcontrolador.
Exemplo:
CLR PTA LIMPA TODA A PORTA A DO MICROCONTROLADOR
CLR PTB LIMPA TODA A PORTA B DO MICROCONTROLADOR
Existe a possibilidade de fazer deslocamento de um determinado bit para a direita ou esquerda tanto na memória
como no acumulador.
Exemplo:
LDA #$2 CARREGA 2 NO ACUMULADOR
LSLA PROMOVE O DESLOCAMENTO DOS BITS PARA A ESQUERDA
LSLA
LSLA
LSRA PROMOVE O DESLOCAMENTO DOS BITS PARA A DIREITA
LSRA
LSRA
Obs. Observamos que quando deslocamos para a esquerda, ocorre uma multiplicação do valor,
enquanto que quando o deslocamento para direita ocorre uma divisão
No simulador do CODE WARRIOR

existe a possibilidade de analisar os
dados em várias bases numéricas.
Faça a análise do exemplo em
HEXA, DECIMAL e BINÁRIO
na interface do registrador.
CLICK COM O BOTÃO DIREITO

DO SEU MOUSE
O recurso de deslocamento pode ser feito também na área de memória do microcontrolador
Exemplo:
MOV #$4,$80 CARREGA 4 EM HEXA NA RAM DE ENDEREÇO $80
LSL $80 PROMOVE O DESLOCAMENTO A ESQUERDA DO VALOR
LSL $80
LSR $80 PROMOVE O DESLOCAMENTO A DIREITA DO VALOR
LSR $80
CLR $80 LIMPA A POSIÇÃO $0080 DA RAM
O comando de conversão
das bases numéricas
funciona na área de memória
Podemos fazer lógica AND e OR com os comando AND e ORA pelo carregamento direto ou valor contido na
memória
Exemplo
LDA #$55 CARREGA 55 NO ACUMULADOR EM HEXA
AND #$33 FAZ AND NO ACUMULADOR COM O VALOR IMEDIATO 33 EM HEXA
LDA #%11001100 CARREGA O VALOR CC EM HEXA OU 11001100 NO ACUMULADOR
ORA #%10100100 FAZ OR NO ACUMULADOR COM O VALOR A4 EM HEXA OU 10100100
Operações matemáticas também são possíveis na programação assembly com os comandos ADD e SUB
Exemplo
MOV #$2,$80 CARREGA 2 NA RAM
LDA #$5 CARREGA 5 NO ACUMULADOR
ADD $80 SOMA A RAM COM O ACUMULADOR
SUB #$3 SUBTRAI IMEDIATAMENTE 3 DO ACUMULADOR
ADD #$4 SOMA 4 IMEDIATAMENTE COM O ACUMULADOR
O Code Warrior consegue facilitar a estrutura do programa como mostra abaixo
Exemplo
MOV #$2+5,$80 ;SOMA NA MEMORIA RAM 80 <2+5>
MOV #$3-2,$81 ;SUBTRACAO NA MEMORIA 81 <3-2>
Multiplicações e divisões são também possíveis com este microcontrolador usando os comandos
MUL e DIV
Devemos ficar ciente de que este microcontrolador não consegue fazer cálculos com virgula
Exemplo de multiplicação:
O ACUMULADOR é
LDA #$3 CARREGA O NUMERO 3 EM HEXA NO ACUMULADOR uma área de trabalho
LDX #$2 CARREGA O NUMERO 2 EM HEXA NO REGISTRADOR do microcontrolador
MUL MULTIPLICA O ACUMULADOR COM O REGISTRADOR que esta sempre com
novos valores a medida
Exemplo de divisão: que o programa é
executado
LDA #$6 CARREGA O NUMERO 3 EM HEXA NO ACUMULADOR Por isso caso o valor seja
LDX #$2 CARREGA O NUMERO 2 EM HEXA NO REGISTRADOR Importante, este deve ser
DIV DIVIDE O ACUMULADOR COM O REGISTRADOR salvo na MEMÓRIA
Este tipo de construção de programa é básico para qualquer microcontrolador, onde os cálculos são executados
no no acumulador. O Code Warrior consegue simplificar calculos matemáticos da seguinte forma
Neste exemplo podemos ver soma, subtração mutiplicação e divisão em uma única linhas sendo executada
dentro do acumulador
LDA #((2*3)/(4-2))-1 CALCULO EXECUTADO NO ACUMULADOR
Uma caracteristica interessante neste componente é a possibilidade de fazer os calculos diretamente na memória
um recurso que poucos microcontroladores tem.
MOV #2+((4*2)/2),$80 CALCULO EXECUTADO NO ENDEREÇO 0080 DA MEMÓRIA

MICROCONTROLADORES – DECISÕES POR COMPARAÇÃO
Em programação de microcontroladores não só existem execuções, em algum momento devemos tomar

determinadas decisões, que podem ser de várias maneiras.
Estaremos abordando a parte de decisão por comparação
ALGUNS COMANDOS PARA EXEMPLO
CMP = Compara acumulador com a memória

BEQ = Desvia se igual
BNE = Desvia se diferente
CBEQA = Compara o acumulador com um valor imediato e desvia
caso seja igual
BRSET = Desvia se o bit N estiver em 1
BRCLR = Desvia se o bit N estiver em 0
N
?
Consulte também o arquivo

CPU08RM.pdf
pois existem todos os comandos
Este programa irá carregar o numero 10 na memória 88, quando o valor de memória 80 for igual ao
acumulador. Caso o valor seja diferente será colocado o número 05 na memória 86
PROCESSO:
1. COMPARAR - CMP
2. DESVIAR - BEQ
INICIO: INICIO:
LDA #$3 LDA #$4
MOV #$3,$80 MOV #$3,$80
CMP $80 CMP $80
BEQ DESVIA BEQ DESVIA
BRA NAO_DESVIA BRA NAO_DESVIA
DESVIA: DESVIA:
MOV #$10,$88 MOV #$10,$88
BRA INICIO BRA INICIO
NAO_DESVIA: NAO_DESVIA:
MOV #$5,$86 MOV #$5,$86
Este programa irá carregar o numero 10 na memória 88, quando o valor de memória 80 for diferente ao
acumulador. Caso o valor seja igual será colocado o número 05 na memória 86
PROCESSO:
1. COMPARAR - CMP
2. DESVIAR - BNE
INICIO: INICIO:
LDA #$4 LDA #$3
MOV #$3,$80 MOV #$3,$80
CMP $80 CMP $80
BNE DESVIA BNE DESVIA
DESVIA: DESVIA:
MOV #$10,$88 MOV #$10,$88
MOV #$5,$86 MOV #$5,$86
Este programa irá comparar o número 4, imediato inserido pelo CBEQA, com o valor dentro do acumulador.
Caso o número for igual, será colocado o valor 10 na posição de memória 88. Se for diferente o valor 5 será
colocado no endereço 86.
PROCESSO:
1. COMPARAR E DESVIA - CBEQA
INICIO: INICIO:
LDA #$4 LDA #$3
CBEQA #$4, DESVIA CBEQA #4, DESVIA
DESVIA: DESVIA:
MOV #$10,$88 MOV #$10,$88
MOV #$5,$86 MOV #$5,$86
Este programa irá certificar o bit 3 contido na área de memória $80 se esta em nivel alto.
Caso sim, será colocado o valor 10 na posição de memória 88. Se for zero o valor 5 será
PROCESSO:
1. TESTA O BIT E DESVIA - BRSET
INICIO: INICIO:
MOV #%00000100,$80 MOV #%00000000,$80
BRSET 2,$80, DESVIA BRSET 2,$80, DESVIA
DESVIA: DESVIA:
MOV #$10,$88 MOV #$10,$88
MOV #$5,$86 MOV #$5,$86
Este programa irá certificar o bit 3 contido na área de memória $80 se esta em nivel baixo.
Caso sim, será colocado o valor 10 na posição de memória 88. Se for um o valor 5 será
PROCESSO:
1. TESTA O BIT E DESVIA - BRCLR
INICIO: INICIO:
MOV #%11111011,$80 MOV #%11111111,$80
BRCLR 2,$80, DESVIA BRCLR 2,$80, DESVIA
DESVIA: DESVIA:
MOV #$10,$88 MOV #$10,$88
MOV #$5,$86 MOV #$5,$86
MICROCONTROLADORES – PORTAS
Nível 0 em DDRB Nível 1 em DDRB
libera este buffer e libera este buffer e
temos a porta temos a porta
configurada como configurada como
entrada. saída.
Configuramos o
PULL UP para
garantir o nível
baixo na porta
PTB, pode enviar um

nível lógico para saída
do microcontrolador ou
receber um nível e
enviá-lo para CPU
Para fazer a configuração da porta devemos usar o DDR antes de enviar um comando PT.
DDRA, estaremos configurando a porta A do microcontrolador
DDRB, estaremos configurando a porta B do microcontrolador
PTA, estaremos enviando (1) ou recebendo (0) uma informação pela porta A
PTB, estaremos enviando (1) ou recebendo (0) uma informação pela porta B
Todos estes registradores são programáveis por software, sendo este programados individualmente.
Nível:
1 = Pull up Ativado
0 = Pull up Desativdado
Obs. Quando o DDRB, for
configurado como saída
o PTBPUE é desabilitado
automáticamente.
Nível
1 = Porta configurada como
saída.
0 = Porta configurada como
entrada.
Nível para DDRB = 1

1 = Porta esta enviando
5V para o exterior
0 = Porta esta enviando
0V para o exterior
Nível para DDRB = 0

1 = Porta esta recebendo
5V para o exterior
0 = Porta esta recebendo
0V para o exterior
Para podermos programar um microcontrolador, devemos conhecer todo o HARDWARE.

Este programa irá configurar as portas PTB 0 como entrada e PTB 1 a 7 como saídas. Ao acionar a chave
observaremos os leds trocarem a sua iluminação.
O comando BRSET fica testando a chave para poder tomar a devida decisão
Nos DEMO 1 e 2, podemos acionar ou desativar as portas pelos comandos MOV, BSET e BCLR
BSET 0,CONFIG1
MOV #%11111110, DDRB
Configurações iniciais MOV #$00, PTBPUE
CLR PTB
PRINCIPAL:
BRSET 0,PTB,DEMO1
Chave 01 esta pressionada? BRA DEMO2
DEMO1:
MOV #$02, PTB
SIM BRA PRINCIPAL
NÃO DEMO2:
BSET 2 , PTB
BCLR 1, PTB
BRA PRINCIPAL
LED 1 – ON LED 1 – OFF

LED 2 – OFF LED 2 – ON
MICROCONTROLADORES – SIMULAÇÃO VISUALIZATION TOOLS
Usando a ferramenta VISUALIZATIONS TOOLS podemos fazer vários testes no programa antes de gravá-lo no chip.
Para que possamos ter acesso a esta ferramenta, devemos estar no modo FULLCHIP SIMULATION e entrar no modo
DEBUG. O próximo passo é entrar no modo COMPONENT>OPEN e iremos observar a seguinte tela
Acesse este ícone

Esta é a área de trabalho do VISUALIZATION TOOLS.

Ao dar um click com o botão direito do mouse, observamos vários componentes disponíveis.
Neste exemplo estaremos inserindo um LED
No campo de propriedades, as configurações de maior importância é o PORT TO DISPLAY onde devemos
referenciar a porta (0x1 = PTB) e o BITNUMBER TO DISPLAY que referencia o pino desta porta (0 = PTB0)
Para podermos ver o LED em funcionamento devemos configurar o REFRESH MODE em PERIODICAL e
o REFRESH TIME (100ms) para 1.
O mesmo procedimento deve ser feito para a chave, mas lembrando que no programa ela esta em
PTA0, então as propriedades serão:
PORT TO DISPLAY = 0x0;
BITNUMBER TO DISPLAY = 0
Para ver a simulação, devemos acionar no modo simulador do CODE WARRIOR
Também deve ser acionada a CHAVE do VISUALIZATION TOOLS para o correto funcionamento
PTB=1
PTA=1
Com o comando INPUTA=01, podemos

perceber a chave vermelha levantar,
o LED trocar de cor e pela memória,
ver o estado das portas mudar.
O programa abaixo fica como referencia para devidos testes do explicado anteriormente.
MICROCONTROLADORES – GRAVANDO O FIRMWARE
Nesta parte estaremos fazendo a gravação do programa gerado no CODE WARRIOR no microcontrolador
da família HC. Os programas gravados em chips são chamados de FIRMWARE.
O primeiro passo e sair do modo FULL CHIP SIMULATION para MON08 INTERFACE
MODO DE SIMULAÇÃO MODO DE GRAVAÇÃO

Ao compilar o programa e acionar o comando teremos a seguinte tela abaixo para ser configurada.
1. Acione o comando REFRESH para limpeza total da porta

2. Acione ADD CONECTION para selecionar a classe do dispositivo
Quando acionamos ADD CONECTION teremos

a tela ao lado INTERFACE SELECTION onde devemos
selecionar em Power Swiching CLASS 1
Uma vez configurado o resultado fica em INTERFACE DETAILS
Certifique se o microcontrolador esta

correto, pois caso contrário não ocorrerá
a gravação
Configure a porta COM e o BAUD RATE

para que ocorra a transmissão do
firmware
Obs. Estes ajustes dependem do tipo

do computador e do gravador.
CLICK AQUI PARA GRAVAR

Uma vez configurado corretamente a tela anterior (Connection Manager), logo aparece a tela abaixo informando
que ira apagar e gravar um programa na flash do microcontrolador. Acione Yes.
Após a tela anterior teremos esta abaixo, que tem a finalidade de monitorar o processo da gravação. Uma vez
gravado o microcontrolador ela automaticamente desaparecerá e o firmware estará residente no chip
MICROCONTROLADORES – PROCESSADOR EXPERT
O PROCESSADOR EXPERT é uma ferramenta que tem por finalidade de auxiliar na configuração do microcontrolador.
Para que ele funcione devemos ao construir um determinado projeto utilizar este recurso.
Nos procedimentos abaixo iremos configurar a porta PTA0 como entrada e a PTB0 como saída pelo processador expert.
Ative o DEVICE INITIALIZATION para usar o PROCESSADOR EXPERT

Esta é a tela aonde podemos ver a pinagem do microcontrolador e as áreas que queremos configurar
Configurando o PTA como entrada, devemos dar um click em PTA (desenho do chip) e teremos a seguinte tela
Na figura abaixo temos todo o processo de configuração do PTA como entrada.

Ela mostra a configuração de DDRA, PTAPUE e PTA
Na figura abaixo temos todo o processo de configuração do PTB como saída.

Ela mostra a configuração de DDRA, PTAPUE e PTA
Uma vez configurado, podemos acionar o GENERATE CODE
ESTE CÓDIGO FOI

CRIADO
AUTOMATICAMENTE
PELO
PROCESSADOR EXPERT
Para ativar o código criado pelo

PROCESSADOR EXPERT
devemos fazer os seguintes
procedimentos
Vá até o PROJECT.PRM
e coloque duas barras (//)
na frente da linha
VECTOR 0
Para que a o arquivo main.asm, consiga reconhecer os codigos gerados pelo processador expert contido
no arquivo MCUunit.asm deve ser retirado o ponto e virgula da linha JSR MCU_unit
Retire o ponto e virgula desta linha

MICROCONTROLADORES – HARDWARE
MICROCONTROLADORES – KIT DE TESTE – HC908QY4
g f a b
DISPLAY CATODO COMUM
e d c
7448
MICROCONTROLADORES – TIMER INTERNO
INICIO
Desabilitar COP para não dar RESET na CPU

CONFIGURAÇÕES Habilitar interrupção TOIE – para informar que a temporização
terminou. Quando isto acontece TOF vai para 1
Ajustar o PREESCALER – velocidade de contagem
CARREGAMENTO Usar TMODH e TMODL para colocar o valor de

DO TIMER temporização em hexa desejada no programa
DELAY
MANTENHA A CONTAGEM
N Caso o valor de TMODH e TMODL for igual ao

O TEMPO ACABOU? contador interno de 16bit ($21 e $22) a
temporização termina.
TOF fica em 1 ao terminar a temporização, para

APAGAR TOF E que ocorra uma nova devemos apaga-lo
RETORNE PARA O
CARREGAMENTO DO TIMER
MICROCONTROLADORES – TIMER INTERNO / CÓDIGO
INICIO
BSET 0,CONFIG1; DESABILITA O COP

MOV #%01000110,TSC HABILITA TOIE E AJUSTA O PREESCALE EM 1:64
TIMER:
MOV #$FF,TMODH CARREGA FF EM TMODH
MOV #$20,TMODL CARREGA 20 EM TMODL
BRA DELAY VAI PARA O DELAY
DELAY:
N BRCLR 7,TSC,DELAY TOF=0 VAI PARA DELAY

BRSET 7,TSC, SAIR_DELAY TOF=1 SAI DO DELAY
SAIR_DELAY:
BCLR 7, TSC APAGA TOF
BRA TIMER RETORNA AO CARREGAMENTO DO TIMER
MICROCONTROLADORES – TIMER INTERNO / PISCA PISCA
INICIO
SAIDA DO
CARREGAMENTO
DO TIMER
CONFIGURAÇÕES
N CARREGAMENTO
LED 1 ON? DO TIMER
S
PISCA PISCA
APAGAR LED 1
LIGAR LED 2 DELAY
MANTENHA A CONTAGEM
APAGAR LED 2
LIGAR LED 1
N
O TEMPO ACABOU?
S
APAGAR TOF E
ENTRADA DO RETORNE PARA O
DELAY CARREGAMENTO DO TIMER
MICROCONTROLADORES – TIMER INTERNO / PISCA PISCA - CÓDIGO
INICIO
SAIDA DO BSET 0,CONFIG1
CARREGAMENTO MOV #%01000110,TSC
DO TIMER MOV #%00000011, DDRB
MOV #$00, PTBPUE
CLR PTB
N CONDICAO: MOV #$FF,TMODH

BRSET 0,PTB,LED2 MOV #$20,TMODL
BRA LED1 TIMER:
BRA CONDICAO
S
PISCA PISCA
LED1:
MOV #%00000001, PTB
BRA DELAY
DELAY:
N
LED2: BRCLR 7,TSC,DELAY
MOV #%00000010, PTB BRSET 7,TSC, SAIR_DELAY
BRA DELAY
S
ENTRADA DO
DELAY SAIR_DELAY:
BCLR 7, TSC
BSET 4,TSC
BRA TIMER
MICROCONTROLADORES – TIMER INTERNO / PISCA PISCA - CÓDIGO
INICIO: DELAY:
BRCLR
BSET 0,CONFIG1 7,TSC,DELAY
MOV #%01000110,TSC BRSET 7,TSC,
MOV #%00000011, DDRB SAIR_DELAY
MOV #$00, PTBPUE
CLR PTB SAIR_DELAY:
BCLR 7, TSC
BSET 4,TSC
MOV #$FF,TMODH BRA TIMER
MOV #$20,TMODL
TIMER:
BRA CONDICAO
CONDICAO:
BRSET 0,PTB,LED2
BRA LED1
LED1:
MOV #%00000001, PTB APÓS DIGITAR O PROGRAMA
BRA DELAY
Localize a linha INCLUDE e abaixo
LED2: dela adicione as duas linhas como
MOV #%00000010, PTB Indicado. Isto fará o tratamento da
BRA DELAY interrupção do TIMER
MICROCONTROLADORES – SUB ROTINAS
PROGRAMA PRINCIPAL
As sub-rotinas
normalmente são
utilizadas para a
simplificação dos
programas criados.
Também são SUB-ROTINA
utilizadas para
serem repetidas
quantas vezes forem
necessárias pelo
programa principal.
Normalmente o
programa principal
chama este pequeno
programa
(sub-rotina),
executa-o e ao
termino de sua
função este retoma
de onde foi desviado
para seguir a
próxima tarefa.
PROGRAMA PRINCIPAL
Em alguns casos SUB-ROTINA 1

observamos sub-
rotinas chamarem
outra sub-rotinas.
Mas o que devemos
saber é que o
retorno do programa
sempre será para SUB-ROTINA 2
um ponto a frente do
seu inicio de partida.
PROGRAMA PRINCIPAL
JSR – Efetua o
desvio do fluxo do
programa para uma
sub-rotina.
O JSR pode ser feito JSR SUB-ROTINA 1

por endereço ou
label.
SUB-ROTINA 1
Ex.
JSR $20
JSR SUB_ROTINA JSR SUB-ROTINA 2
RTS
RTS – Provoca o SUB-ROTINA 2

retorno do fluxo do
programa ao ponto
seguinte ao de onde
RTS
ocorreu a chamada
da sub-rotina
INICIO
USANDO O TIMER INTERNO P/ PISCAR LEDS CONFIGURAÇÃO DO
TIMER, E PORTAS
CARREGAMENTO
O CAMINHO CRIADO PELOS COMANDOS DOS REGISTRADORES
TMODH E TMODL
JSR e RTS
ACIONAMENTO DO LED 1
Pelo caminho azul, temos o E DESVIA PARA DELAY
primeiro salto para a sub-rotina.
Já o caminho em verde mostra ACIONAMENTO DO LED 2 E

o segundo salto para a sub-rotina DESVIA PARA DELAY
Lembrando que podemos usar a
mesma sub-rotina para diversas DESVIA PARA O
aplicações, mas nada impede de ACIONAMENTO DO LED 1
usarmos sub-rotinas diferentes
DELAY:
MANTENHA A CONTAGEM
O TEMPO ACABOU?
N
S
APAGAR TOF E
RETORNE PARA A ULTIMA
CHAMADA DE SUB ROTINA
INICIO
BSET 0,CONFIG1
USANDO O TIMER INTERNO P/ PISCAR LEDS MOV #%01000110,TSC
MOV #%00000011, DDRB
MOV #$00, PTBPUE
CLR PTB
TIMER:
MOV #$FF,TMODH
MOV #$20,TMODL
Use PISCA:
JSR para MOV #%00000001, PTB
Ir a sub-rotina JSR DELAY
MOV #%00000010, PTB

JSR DELAY
BRA PISCA
DELAY:
BRCLR 7,TSC,DELAY
Use BRSET 7,TSC, SAIR_DELAY
RTS para N
sair da sub-rotina
S
SAIR_DELAY:
BCLR 7, TSC
RTS
USANDO O TIMER INTERNO P/ PISCAR LEDS
INICIO:
BSET 0,CONFIG1
MOV #%01000110,TSC
MOV #%00000011, DDRB
MOV #$00, PTBPUE
CLR PTB
TIMER:
MOV #$FF,TMODH
MOV #$00,TMODL
PISCA:
MOV #%00000001, PTB
JSR DELAY
MOV #%00000010, PTB

JSR DELAY
BRA PISCA
DELAY:
BRCLR 7,TSC,DELAY
BRSET 7,TSC, SAIR_DELAY
SAIR_DELAY:
BCLR 7, TSC
RTS
MICROCONTROLADORES – CONVERSOR ANALÓGICO / DIGITAL
CHANNEL SELECT
Responsável para habilitar os pinos
do HC para fazer a conversão A/D
ADC
Conversor Analógico Digital de 8 bits
ADC DATA REGISTER

Local onde ficará registrado o valor
Convertido em HEXADECIMAL
CLOCK GENERATOR
Responsável pela velocidade de
conversão do ADC
INTERRUPT LOGIC
Ao termino da conversão é habilitada
uma interrupção avisando que o dado
esta no ADC DATA REGISTER
ADSCR – É o registrador responsável para ativar as portas do conversor A/D
CH1 e CH2 – A combinação destes flags podemos escolher a porta do HC para fazer a conversão
ADCO – Seleciona o modo simples ou continuo de conversão

1 = Conversão continua 0 = Conversão simples
CONVERSÃO SIMPLES
O conversor realiza apenas uma única conversão
Após o seu termino, ativa o flag COCO e fica
aguardando o usuário iniciar nova conversão
CONVERSÃO CONTINUA
Este inicia automaticamente uma nova conversão
após o termino da outra.
O registrador ADSCR informa o processo de

Conversão pelos flags COCO e AIEN
COCO
0 = Conversão não completada
1 = Conversão completada
Para selecionar a porta devemos usar a tabela da verdade acima
AIEN
0 = Interrupção desabilitada
1 = Interrupção habilitada
ADICLK – Neste registrador podemos

controlar a velocidade de conversão
do conversor AD. Este pega o valor do
clock do barramento e dividir de 1 a 16 vezes
Os valores devem ser colocados nos flags

ADV2, ADV1 e ADV0 do ADICLK respeitando
a tabela ao lado
ADR – Este registrador contém a informação

do conversor AD que pode ser movimentado
para a memória ou acumulador
EXEMPLO: - Configure um conversor AD utilizando a porta PTA 0 usando a conversão continua e com a máxima velocidade
de conversão.
RESPOSTA:
MOV #%00100000,ADSCR
MOV #%00000000,ADICLK
O fluxograma abaixo mostra o processo de capturar uma conversão analógica / digital do PTA0
Armazenando no acumulador do HC para salvar na área de memória $80
Inicio
Desabilitando o COP
Habilitando PTA0 como entrada
Conversão em modo continuo

Porta PTA0 como entrada para o conversor A/D
Velocidade máxima de conversão
Carregar no acumulador
Salvar na memória $80

O fluxograma abaixo mostra o processo de capturar uma conversão analógica / digital do PTA0
Armazenando no acumulador do HC para salvar na área de memória $80
Inicio
BSET 0,CONFIG1
MOV #$00,DDRA
MOV #$20,ADSCR
MOV #$00,ADICLK
CARREGANDO:
LDA ADR
STA $80
BRA CARREGANDO
MICROCONTROLADORES – INTERRUPÇÃO DE TECLADO
A finalidade de ter interrupção em teclado é de deixar o microcontrolador mais eficiente. Ao fazer teste de entrada
a todo instante, faz com que o mesmo perca rendimento. O interessante é fazer o teste do determinado teclado
quando uma tecla realmente for acionada
METODO POR TESTE DE PORTA
INICIO
TESTE DO TECLADO
LINHAS DE PROGRAMA
O problema deste fluxograma é que
este sempre estará gastando tempo
testando o teclado, mesmo sem estar
LINHAS DE PROGRAMA sendo usado.
LINHAS DE PROGRAMA
Pelo processo da interrupção, as linhas de programa que gerenciam o teste de teclado ficam fora do programa
principal. Só serão executadas quando alguém acionar alguma tecla. Outro ponto importante que ao terminar
a rotina de teste do teclado, o programa volta a origem de onde foi interrompido
- O programa roda livremente sem a

rotina de teclado
METODO POR INTERRUPÇÃO POR TECLADO - Ao tocar no teclado o programa para
imediatamente e vai para a rotina de
Interrupção.
- Ao termino da interrupção esta retorna
a sua origem
INICIO
LINHAS DE PROGRAMA
LINHAS DE PROGRAMA TESTE DO TECLADO
LINHAS DE PROGRAMA
CONFIGURANDO OS REGISTRADORES
KBSCR – Registrador responsável pelo controle principal do módulo
KEYF – Flag de interrupção de teclado IMASKK – Flag de mascaramento de interrupção de teclado

0 = Não há interrupções pendentes no teclado 0 = Mascarado – ocorrerá interrupção se KEYF=1
1 = Existe uma interrupção pendente no teclado 1 = Não mascarado – não haverá interrupção
MODEK – Flag de sensibilidade do teclado ACKK – Bit de reconhecimento de teclado

0 = Sensibilidade a borda de descida
1 = Sensibilidade a borda de descida e nível baixo
KBIER – Registrador responsável pela habilitação individual dos pinos que farão parte da entrada do módulo KBI
AWUIE – Habilita a interrupção do módulo auto acordar KBIE0 a KBIE5 – habilita os pinos PTA0 a PTA5
0 = Interrupção desabilitada como entradas do módulo KBI (interrupções)
1 = Interrupção habilitada 0 = O pino não esta habilitado como interrupção
1 = O pino esta habilitado como interrupção
Ao fazer uma interrupção de teclado devemos fazer o tratamento do vetor de interrupção. Na tabela abaixo temos estes
vetores. Cada interrupção em especifico (teclado, conversor ADC, TIM e outro), possui sua prioridade. A interrupção irá
lançar para estes endereços, onde por através de um tratamento ORG ou ajustando o PROJECT.PRM em
PROJECT SETTINGS- LINKER FILES na tela a esquerda FILE
Estes tratamentos por ORG ou

alterando o PROJECT.PRM, e
Incluindo um LABEL, nada mais é
do que orientanto o programa a
Ter um fluxo organizado.
Para terminar devemos sempre

colocar um comando RTI para que
o programa saia do tratamento da
interrupção e volte ao programa principal
As interrupções tem prioridades e

podemos ter várias, mas sendo cada
uma tratada por vez respeitanto a
tabela de prioridades ao lado.
Neste fragmento de programa em MAIN, podemos ver como configuramos uma interrupção.
Escreva INTERRUPT ou
outro LABEL que desejar
Não esqueça de
Configurar o
PROJECT.PRM
Programa principal
Local onde esta acontecendo a interrupção
Comando de retorno p/ o programa principal

ARQUIVO PROJECT.PRM
Localizando o
Arquivo.
PROJECT.PRM
Esta linha
VECTOR 14 INTERRUPT
Faz o reconhecimento da
interrupção
Lembrando que o numero 14 é retirado da tabela

de vetores de interrupção.
Já o INTERRUPT é o LABEL encontrado no
arquivo MAIN, para o correto funcionamento
Existem várias maneiras de fazer a interrupção. Vamos analisar mais uma.
A diretiva ORG é utilizada para especificar um

endereço onde ocorre um evento a ser tratado
logo em seguida por um label
FBD define uma constante de memória. O tamanho

da memória a ser utilizada será a constante a ser
escolhida
Programa principal
Local onde esta acontecendo a interrupção
Comando de retorno p/ o programa principal

MICROCONTROLADORES
LINGUAGEM C
VARIÁVEIS GLOBAIS E LOCAIS
Quando declaramos as varáveis antes de uma função, esta fica considerada como
global, onde esta será aproveitada em todo momento do programa.
#include <hidef.h>
#include "derivative.h"
int a,b,c,d;
void main(void)
{ a=2;
b=3;
c=a+b;
d=b-a;}
Quando declaramos as varáveis dentro de uma função, esta fica considerada como
#include <hidef.h> local, onde esta será aproveitada somente dentro da função de origem.
void main(void)
{
int a,b,c,d;
a=2;
b=3;
c=a+b;
d=b-a;
inicio:
if (c) goto inicio;
}
PROGRAMA PARA HC908QY4

TIPOS DE DADOS
TIPO FAIXA DE VALORES TAMANHO EM BYTES
signed char -128 a 127 1
char 0 a 255 1
int -32.768 a 32767 2
unsigned int 0 a 65.535 2
unsigned long int 0 a 4.294.967.295 4

long int -2147483647 a 2147483647 4
float 1.17549e-38 a 3.40282e38 4
double 2.23e-308 a 1.7e308 8
long double 2.23e-308 a 1.7e308 8

TIPOS DE DADOS
#include <hidef.h>
signed char a,b;
char c;
int d,e;
unsigned int f;
unsigned long int i;
long int j,k;
float m,n;
double q,r;
long double s,t;
void main(void)
{
//Estes são os valores máximos para as variáveis declaradas acima
//Caso ocorra alteração do valor para maior, teremos valores incorretos
a=-128;
b=127;
c=255;
d=-32768;
e=32767;
f=65535;
i=4294967295;
j=-2147483647;
k=2147483647;
Escreva este programa no Code Warrior
m=1.17549e-38;
e confirme os valores das variáveis.
n=3.40282e38;
Logo em seguida altere o valor de algumas
q=2.23e-308;
para maior do que permitido e veja o resultado.
r=1,7e308;
s=2.23e-308;
t=1.7e308;
}
TIPOS DE DADOS
No programa abaixo podemos analisar o comportamento dentro da memória do microcontrolador
#include <hidef.h> /* for EnableInterrupts macro */

#include "derivative.h" /* include peripheral declarations */
char memoria_80 @0x80; // char - ocupa 1 byte de espaço

int memoria_81 @0x81; // int - ocupa 2 bytes de espaço
long memoria_83 @0x83; // long - ocupa 4 bytes de espaço
double memoria_88 @0x88; // double - ocupa 8 bytes de espaço
void main(void) {
inicio:
memoria_80=5; //Carrega na memória $80 o valor 5

memoria_81=6; //Carrega na memória $81 a $82 o valor 6
memoria_83=7; //Carrega na memória $83 a $86 o valor 7
memoria_88=8; //Carrega na memória $88 a $8F o valor 8
__RESET_WATCHDOG();
goto inicio; A função do @ e o endereço logo em seguida, informa

} a variável o inicio de seu armazenamento. O
esquecimento não permitirá a gravação na área de
memória desejada é tornar-se-á uma variável local ou
global.
TIPOS DE DADOS
Podemos fazer programas e guardar informações na memória

char a @0x80; // Direciona a variável a para a posição $80

char b @0x81; // Direciona a variável b para a posição $81
char c @0x82; // Direciona a variável c para a posição $82
void main(void) {
inicio:
a=2+1; // Salva o valor na memória $80

b=a*2; // Salva o valor na memória $81
c=b/3; // Salva o valor na memória $82
__RESET_WATCHDOG();
goto inicio;
}

PONTEIROS
Ponteiro é uma variável que contém um endereço de memória. Esse endereço é normalmente a posição de uma
outra variável de memória. Se uma variável contém o endereço de uma outra, então a primeira variável é dita
apontar para a segunda.
O programa abaixo orienta que a variável X comece a gravar os valores na memória de posição 88, logo em seguida
verifica se a variável X esta em 88 pelo ponteiro p1.

char x @0x88; // Orienta X estar no endereço 88

char *p; // Criação de um ponteiro *p
void main(void) {
p=&x; // Esta linha retorna o valor de endereço da variável X
& = Retorna o endereço de uma variável.

*p = Modelo de um ponteiro.
PONTEIROS
Os ponteiros podem ser orientados a determinadas posições para trabalharem. Caso o programador não
definir eles começam a trabalhar na posição 0x80 (Primeira posição da RAM).
O programa abaixo orienta o uma variável X a guardar suas constantes no endereço 88. O ponteiro foi
criado para armazenar endereços solicitados na posição de memória A0.
Ao executar este programa o número 1, será colocado em $88, o ponteiro será dirigido ao endereço $88
e irá resgatar o valor da memória $88 e salvar em $90

char x @0x88; // Orienta a variável X a guardar os seus valores na posição 88

char s @0x90; // Orienta a variável S a guardar os seus valores na posição 90
char *p @0xA0; // Orienta o ponteiro *p a guardar posições de memória no endereço A0
void main(void) {
x=1; // Constante 1 sendo gravada na posição de memória 88

p=&x; // Posição de memória 88 colocada no ponteiro A0.
s=*p; // Valor contido na memória 88 da posição do ponteiro AO será armazenado no endereço 90
}
& = Retorna o endereço de uma variável

* = Retorna o conteúdo de um endereço especificado.
PONTEIROS
Os ponteiros são muito utilizados para apontar para uma área de memória e descarregar o seu conteúdo
em outro local.
No programa abaixo foram declarada as variáveis x,t,u e v. O ponteiro foi direcionado para a variável x e
ira descarregar todo o conteúdo serialmente na variável s por um comando de incremento p++ do próprio
ponteiro. Mas tome muito cuidado pois quando perdemos o controle do ponteiro o programa para de funcionar

char x,t,u,v;
char s @0x90;
char *p @0xA0;
void main(void) {
x=1;
t=2;
u=3;
v=4;
p=&x; // Inicializa o ponteiro pela variável x
ponteiro_varredura:
s=*p; // Armazena os valores de x,t,u e v na variável s.

p++; // Incrementa para a próxima variável.
goto ponteiro_varredura;
}

MATRIZES
Matriz é uma coleção de variáveis do mesmo tipo que é referenciada por um nome comum. Em C todas as matrizes
consistem em posições continuas na memória. O endereço mais baixo corresponde ao primeiro elemento e o mais
alto ao último elemento.
Uma vez a matriz criada, podemos usar os valores em outras variáveis criadas no programa.
A leitura de uma matriz começa pelo zero como mostra o programa abaixo.
O programa exemplo, ira carregar os valores da matriz nas variáveis a,b,c e d.

char matriz [4]={6,7,8,9}; // carrega uma matriz de uma dimensão com 4 valores
char a,b,c,d;
void main(void) {
a= matriz [0]; // cada variável armazena um valor da matriz

b= matriz [1];
c= matriz [2];
d= matriz [3];
}

MATRIZES
Podemos fazer um carregamento automático de valores em uma matriz, neste caso o carregamento é sequêncial como
mostra o programa abaixo

char matriz [8];

char carga;
void main(void) {
for (carga=0;carga<8;carga++) matriz[carga]=carga; // carrega de um em um a matriz 8X1

MATRIZES
Sabendo que podemos com uma matriz colocar diversos valores rapidamente em um programa sem ficar usando
inúmeras variáveis, também podemos usar o recurso do ponteiro para trabalhar com estes dados.
O programa abaixo constrói uma matriz 4X1. Foi orientado um ponteiro para ler a matriz e descarregar todo o
seu conteúdo no endereço de memória $88. Isto é muito interessante para aplicações que necessitamos
lançar valores para as portas de um microcontrolador.

char matriz [4]={6,7,8,9};

char posiciona_ponteiro @0x80;
char recebe_ponteiro @0x88;
char *ponteiro @0xA0;
void main(void) {
posiciona_ponteiro=matriz[0]; //carrega a matriz do começo
ponteiro=&posiciona_ponteiro; // posiciona o ponteiro no inicio da matriz
ponteiro_varredura:
recebe_ponteiro=*ponteiro; // o ponteiro descarrega os valores da matriz no endereço 88

ponteiro++; // incrementa o ponteiro para o próximo valor da matriz
goto ponteiro_varredura;

COMANDOS CONDICIONAIS - IF
if (condição) comando;
O comando IF só é ativado em uma condição verdadeira, caso contrário o comando não tem efeito e o
programa lê a próxima linha. Para a linguagem C a condição verdadeira é nível 1 é falso é 0
1
IF
0 COMANDO
COMANDOS CONDICIONAIS - IF

void main (void) O comando IF só ativa quando

estiver em nível 1 caso contrário este
{ será ignorado e o programa continuará
SOPT1=0; //desliga o COP na próxima linha.
PTADD_PTADD0=0; //configura PTA0 como uma entrada
PTBDD_PTBDD7=1; //configura PTB7 como uma saída
inicio:
if (PTAD_PTAD0) goto liga; //Verifica a condição da entrada PTA0
PTBD_PTBD7=0; //desativa a saída PTB7
goto inicio;
liga:
PTBD_PTBD7=1; //ativa a saída PTB7
goto inicio;
}
PROGRAMA PARA HCS908QG

COMANDOS CONDICIONAIS – SWITCH CASE
switch (expressão)
{
case (expressão 1): comando; comando; comando n; break;
case (expressão 2): comando; comando; comando n; break;
case (expressão n): comando; comando; comando n; break;
default: comando; comando; comando n;
}
CASE (E1) COMANDOS BREAK
SWITCH
CASE (E2) COMANDOS BREAK
CASE (En) COMANDOS BREAK
DEFAULT
Este comando permite a escolha de uma opção entre várias variáveis.
Uma vez escolhida é comparada a SWITCH com o devido CASE. Uma vez escolhido,
os comandos contidos no CASE serão executados até a chegada do comando
BREAK. Logo em seguida retorna novamente ao comando SWITCH para novo
COMANDOS teste. Caso não exista nenhuma relação do SWITCH com os CASES disponíveis o
programa irá para o comando DEFAULT e executará um ou mais comandos
determinado pelo programador
COMANDOS CONDICIONAIS – SWITCH CASE

char S;
void main (void)
{
SOPT1=0; //desliga o cop
PTADD=0; //configura todos os bits da PTA como entrada
PTBDD=255; //configura todos os bits da PTB como saída
inicio:
S=PTAD; //transfere o valor de PTA para a variável S
switch(S) { //avalia o valor de S para o devido CASE
case (1): PTBD_PTBD0=1;goto inicio;break; //ativa PTB0
default: PTBD=0;goto inicio; //desativa PTB
}
}
CONCEITO DO PROGRAMA
Neste programa a combinação de chaveamento em PTA será convertido em um
número decimal e carregada em uma variável (S). Esta variável será analisada pelo
comando SWITCH e logo em seguida comparada com um dos CASE possíveis.
Caso ocorra a igualdade o determinado comando irá funcionar.

COMANDOS REPETIÇÃO – FOR
for (inicialização;condição;incremento) comando;
Para trabalharmos com o FOR, adotamos uma variável o qual fica na CONDIÇÃO, onde esta
pode ser INCREMENTADA (acima ou abaixo – X++ ou X--) o qual fica sempre comparada
com a INICIALIZAÇÃO. Quando este processo estiver em igualdade a CONDIÇÃO com a
INICIALIZAÇÃO o laço FOR terá terminado, mas enquanto isto não acontecer ele ficará em
seu laço e com o devido COMANDO funcionando.
INCREMENTO
COMANDO
? N
INICIALIZAÇÃO = CONDIÇÃO
S
COMANDOS REPETIÇÃO – FOR

int S,T;
void main (void)
{
SOPT1=0; //Desliga o COP
PTADD=0; //Configura todos os bits da PTA como entrada
PTBDD=255; //Configura todos os bits da PTB como saída
inicio:
S=T=PTAD*10000; //Transfere PTA para as variáveis S,T e multiplica por 10000
for(0;S;S--) PTBD=255; //Porta PTB ativada
for(0;T;T--) PTBD=0; //Porta PTB desativada
goto inicio;
}
Este programa faz as portas PTB oscilarem mediante informação contida em PTA.
O valor recebido em PTA será multiplicado por 10.000 e lançado nas variáveis S e T o qual estão contidas
no laço FOR.
Referente a temporização, observamos um DUTY CICLE de 50%.
Este tipo de estrutura é interessante, pois podemos alterar o DUTY CICLE e construir um PWM.

COMANDOS REPETIÇÃO – WHILE
while (condição) {comando 1; comando 2;comando n}
Este comando testa uma condição, caso esta seja verdadeira (1) permite a repetição dos comandos
contidos dentro de sua chave, caso seja falso (0) o comando não funciona e o programa segue
normalmente.
WHILE
0
COMANDO

char S,T;
void main (void) O comando WHILE só ativa quando
{ estiver em nível 1 caso contrário este
SOPT1=0; //Desliga o COP será ignorado e o programa continuará
PTADD=0; //Configura todos os bits da PTA como entrada na próxima linha.
inicio:
S=PTAD_PTAD0; //Transfere o valor de PTA0 para a variável S

T=PTAD_PTAD1; //Transfere o valor de PTA1 para a variável T
while(S) { PTBD=0;} //S=1 desativa PTB permanentemente

while(T) { PTBD=255;} //T=1 ativa PTB permanentemente
goto inicio;
}
PROBLEMA
Só vai mudar de estado
a saída mediante dar
RESET no programa.


char S,T;
void main (void)
{
inicio:

while(S) { PTBD=0;S=PTAD_PTAD0;} //S=1 desativa PTB mediante PTA0 acionada

while(T) { PTBD=255;T=PTAD_PTAD1;} //T=1 ativa PTB mediante PTA1 acionada
Resolvemos o problema da tela anterior
goto inicio;
colocando S=PTAD_PTAD0 e T=PTAD_PTAD1
}
dentro da rotina WHILE. Quando o estado destas
portas mudarem para zero este comando não
irá mais funcionar, mas quando estiverem em
nível um a primeira que for reconhecida pelo
WHILE ficará contida no laço.


char S,T;
void main (void)
{
inicio:

while(S) { PTBD=0;break;} //S=1 desativa PTB mediante PTA0 acionada

while(T) { PTBD=255;break} //T=1 ativa PTB mediante PTA1 acionada
goto inicio; Este programa
} faz a mesma
função do anterior
O comando BREAK faz liberar

do comando WHILE

COMANDOS REPETIÇÃO – DO WHILE
do {comando 1; comando 2;comando n} while (condição)
Este primeiro ele faz o comando DO e depois testa a condição WHILE. Caso seja verdadeiro (1)
promoverá novamente a repetição pelo DO, mas se for falso (0) este escapa do laço de repetição
DO
COMANDO
1
WHILE
0
COMANDOS REPETIÇÃO – DO WHILE

void main (void)

{ ATENÇÃO foi usado
SOPT1=0; //Desliga o COP Lógica não ( ! ) antes
PTADD=0; //Configura todos os bits da PTA como entrada do PTAD_PTAD0 para
PTBDD=255; //Configura todos os bits da PTB como saída Inverter o funcionamento
do comando IF
inicio:
if(!PTAD_PTAD0) {PTBD=0;goto inicio;} //PTA0=0 limpa a porta PTB
do { PTBD=170;} //PTA0=1 ativa a porta PTB

while (PTAD_PTAD0);
goto inicio;
}
Enquanto PTA0 estiver em nível baixo o programa

estará limpando a porta pelo IF, mas quando PTA0
estiver em nível alto, PTB estará ativado pelo comando
DO WHILE

C e ASM
O Code Warrior pode fazer programas onde temos as duas linguagens, C e Assembler. Para isto devemos colocar a
palavra reservada asm. Esta tecnologia é chamada de HLI (High Level Inline).
O programa abaixo executa uma equação de multiplicação e guarda o resultado na variável S, como os calculos
são feitos no acumulador, com um comando asm podemos salvar o seu conteúdo na memória 0x80.

char s,t;
void MCU_init(void); /* Device initialization function declaration */
void main(void) {
for(;;) { FOR INFINITO é um processo

onde as linhas do programa
t=2; ficam em loop infinito quando
s=2*t; usamos a estrutura abaixo.
FOR (; ;) { }
asm { O programa ao lado encontra-se
sta $80 desta maneira com explicado
}
__RESET_WATCHDOG(); /* feeds the dog */

}
}
IMPORTANTE: Caso escrevermos o código assembler asm { sta $80 } linearmente sem respeitar as linhas puladas
o Code Warrior considera errado, portanto devemos respeitar a estrutura do exemplo.

DEFINE
Para deixar o programa mais inteligível, podemos com o comando DEFINE, alterar o nome de alguns dados
deixando assim o programa mais amigável.

#define CHAVE PTA_PTA0

#define LED PTB_PTB0
Neste programa trocamos a porta
#define ENTRADA DDRA_DDRA0
PTA0 que é conhecida como PTA_PTA0 para
#define SAIDA DDRB_DDRB0
ser chamada de CHAVE, logo a porta PTB0
que é conhecida como PTB_PTB0 será
void main(void) {
chamada de LED.
Para a configuração da porta, chamaremos
ENTRADA=0;
DDRA_DDRA0 como ENTRADA e
SAIDA=1;
DDRB_DDRB0 como SAIDA
Desta maneira o programa principal ficará
for(;;) {
mais fácil de entender
if(CHAVE) LED=1; //LIGA O LED
else LED=0; //DESLIGA O LED

}
}

FUNÇÕES
Quando necessitamos de um determinado sub programa, ou uma rotina especifica no programa principal, nós
usamos funções na linguagem C. Em comparação com assembler, esta pode ser chamada de SUB ROTINA.


void configuracao ()
{ Quando simulamos o programa, este

DDRA_DDRA0=0; sempre começa pelo void main (void),
DDRB_DDRB0=1; mas quando ele vê a função configuracao ()
} logo o programa dá um salto para
void configuracao () e a executa, e quando
void main(void) { termina, este continua na linha que parou
do programa principal
configuracao ();
for(;;) {
if(CHAVE) LED=1; //LIGA O LED

else LED=0; //DESLIGA O LED

}
}

TEMPORIZAÇÃO – POR SOFTWARE


unsigned int a;
void main(void) {
CONFIG1_COPD=1;
DDRA_DDRA0=0;
DDRB_DDRB0=1;
for (;;) { while (CHAVE) { for (a=60000;a>0;a--)

LED=1;
for (a=60000;a>0;a--)
LED=0;
}}}

TEMPORIZAÇÃO – POR HARDWARE


void temporizar ()
{ delay:
if(!TSC_TOF) goto delay;}
void interrupt 6 transbordo_do_timer ()

{ TSC_TOF=0;
TSC_TRST=1;}
void main(void) {
EnableInterrupts;
CONFIG1_COPD=1;
DDRA_DDRA0=0;
DDRB_DDRB0=1;
TMODH=0x18;
TMODL=0x69;
TSC=0x46;
for(;;){ while(CHAVE) { LED=1;

temporizar();
LED=0;
temporizar();
}}} PROGRAMA PARA HC908QY4
INTERRUPÇÃO POR TECLADO - HARDWARE
+5V
HCS1
SW1
+5V
1
PTA5 PTA0
16 SW-SPST
2
PTA4 PTA1
15
3
VDD+5 PTA2 R1
14
1k
4
VSS/GND PTA3
13
5
PTB7 PTB0
12
6
PTB6 PTB1
11
7
PTB5 PTB2
10
R2 8
PTB4 PTB3
150 9
HCS908QG8
D1
LED
INTERRUPÇÃO POR TECLADO

#define LED PTBD_PTBD7

#define CHAVE PTAD_PTAD1
void interrupt 18 teclado(void)
{
KBISC_KBACK=1; //Apaga o flag KBF liberando da interrupção
LED=1; // PROGRAMA NA INTERRUPÇÃO - Ligar o LED
}
void main(void) {
EnableInterrupts;
SOPT1=0; // Watch dog desligado

PTADD_PTADD0=0; //PTA0 configurado como entrada
PTBDD_PTBDD7=1; //PTA7 configurado como saida
KBISC_KBIE=1; //Interrupção de teclado habilitada
KBISC_KBIMOD=1; //Ativa o flag KBF mediante a transição de estado ou um nivel lógico
KBIPE_KBIPE0=1; //Ativa o pino PTA0 como entrada de interrupção
for(;;) { LED=0;} // PROGRAMA PRINCIPAL – Apagar o LED

}

TRANSMISSÃO SERIAL - HARDWARE
HCS1 HCS2
+5V +5V
1 1
PTA5 PTA0 PTA5 PTA0
16 16
2 2
PTA4 PTA1 PTA4 PTA1
15 15
3 3
VDD+5 PTA2 VDD+5 PTA2
14 14
4 4
VSS/GND PTA3 VSS/GND PTA3
13 13
5 5
PTB7 PTB0 PTB7 PTB0
12 12
+5V
6 6
PTB6 PTB1 PTB6 PTB1
11 11
7 7
PTB5 PTB2 PTB5 PTB2
10 10
8 8
PTB4 PTB3 PTB4 PTB3
9 9
HCS908QG8 HCS908QG8 R3 R2
R1 150 150
1k
CONEXÃO SERIAL
D1 D2
LED LED
TRANSMISSÃO SERIAL - TX

#define CHAVE PTBD_PTBD4
void interrupt 15 TX(void)

{ SCIS1_TDRE=0; //Desabilita a interrupção do TX da SCI }
void main (void)

{ EnableInterrupts;
PTBDD_PTBDD4=0; //pino configurado como entrada
SCIBD=26; //velocidade de 9600 - Velocidade(bps)=(BUSCLK)/(BR*16) - padrão sem cristal => BUSCLK=4MHz
SCIC2_TIE=0; //desabilitado a interrupção de transmissão de caracteres
SCIC2_TE=1; //habilita o bit TE - faz o transmissor funcionar
for (;;)
{
while(SCIS1_TDRE) //verificar buffer de transmissão se esta livre
if (CHAVE==1) SCID=5; //carregando o buffer com o numero 5 para ser transmitido caso a chave esteja acionada
else SCID=1; //carregando o buffer com o número 1 para ser transmitido caso a chave não esteja acionada.
}}

TRANSMISSÃO SERIAL - RX

#define LED1 PTBD_PTBD2

#define LED2 PTBD_PTBD3
unsigned char S,T;
void interrupt 15 RX(void)

{
SCIS1_RDRF=0; //Desabilita a interrupção do RX da SCI
while(!SCIS1_RDRF); //aguarda o buffer ficar vazio
T=SCIS1; //leitura do registrador para apagar todos os indicadores existentes
S=SCID; //leitura do conteúdo do SCID para complementar o apagamento e retirada do dado recebido
if (S==5) //caso o valor da recepção seja o desejado ele altera a condição dos leds
{ LED1=1;
LED2=0; }
else
{ LED1=0;
LED2=1; } }
void main (void)

{ EnableInterrupts;

PTBDD_PTBDD2=1; //pino PTB2 configurado como saída
PTBDD_PTBDD3=1; //pino PTB3 configurado como saída
SCIBD=26; //velocidade de 9600 - Velocidade(bps)=(BUSCLK)/(BR*16) - padrão sem cristal => BUSCLK=4MHz
SCIC2_RIE=1; //habilitação da interrupção de recepção de caracteres
SCIC2_RE=1; //habilita o bit RE - faz o receptor funcionar
for(;;){ } }

ATIVIDADES
1. Em linguagem assembler crie um programa que execute:

a) Carregar o acumulador diretamente com o valor 04H
b) Armazenar o valor do acumulador na RAM ($0080)
c) Carregar o registrador X com o valor 02H
d) Armazenar o valor do registrador X na RAM ($0081)
e) Armazenar o número 03H na RAM ($0088)
f) Fazer um SHIFT RIGHT no acumulador, registrador e nas posições de memória ($0080 e $0081)
g) Fazer um SHIFT LEFT no acumulador, registrador e nas posições de memória ($0080 e $0081)
h) Somar imediatamente 02H no acumulador e subtrair com o valor contido em($0088)
i) Limpar acumulador e registrador X.
j) Transferir o valor de RAM ($0080) para o acumulador
k) Transferir o valor de RAM ($0081) para o registrador X
2. Dada a equação implemente no HC908QY4 via software em:

a. Linguagem assembler.
b. Linguagem C
2 ⋅ ((5 + 3) − (8 − 6))
f ( x) =
(5 − 3)
ATIVIDADES
3. Dada a equação desenvolva um programa que use as variáveis globais:
a ⋅b
r=
c+d
4. Faça um programa usando as variáveis int, char e float e propositalmente coloque valores acima do permitido e relate
o que acontece com os dados.
5. Construa um programa em C onde podemos colocar valores numéricos dentro da memória do HC908QY4 na seguinte
ordem:
a) char – usar endereço $80
b) int – usar endereço $81
c) long – usar endereço $83
d) double – usar endereço $88
Ao termino observe o espaço que ocupam estas variáveis dentro da área de memória
6. Dada a equação abaixo monte um programa em C na seguinte ordem:

a) As variáveis a, b, c e d devem conter números inteiros
b) As variáveis devem estar relacionadas nos seguintes endereços; a em $80, b em $82, c em $84 e d em $86.
c) O resultado da equação deve estar salvo na memória $86
a+b
d=
c2
ATIVIDADES
7. Usando a técnica do ponteiro, coloque os números 1,2,3,4 e 5 a partir do endereço de memória $80 e faça com que o
conteúdo destes números sejam deslocado para o endereço $88.
8. Construa uma matriz {0,1,2,3,4,5,6,7,8,9} e transfira o seu valor para as variáveis na seguinte seqüência:
a=0, b=1, c=2, d=3, e=4, f=5, g=6, h=7, i=8 e j=9.
9. Construa uma matriz {0,1,2,3,4,5,6,7,8,9} sendo que esta seja de preenchimento automático – via software.
10. Dada a matriz {0,1,2,3,4,5,6,7,8,9}, com um ponteiro, faça que ela seja descarregada na porta PTB do microcontrolador.
11. Com o HCS908QG8, faça um Hardware usando o PROTEUS onde os pinos PTB0 e PTB1 sejam considerado entradas
onde receberão níveis lógicos da seguinte ordem:
Nível 1 = +5V
Nível 0 = 0V
Obs. Para garantir 0V coloque um resistor de 1K nos pinos determinados, e que os mesmos fiquem em relação ao terra.
Também deixem os PULL UPS desabilitados. Com os pinos PTB2 e PTB3 deixem-os como saída e ligue LEDs nestas portas.
Mas atenção, pois um LED trabalha entre 1,5V a 2,0V por 20mA. Deve ser colocado um resistor de proteção, favor calcular
e deixar os cálculos para serem analisados pelo professor.
Estes pinos devem trabalhar da seguinte forma:
PTB2 = Ligado indica nível 0

PTB3 = Ligado indica nível 1
Desenvolva três firmwares (em versão ASM e C) distintos onde promovam as lógicas AND, OR e EXOR gravem no HC908
e comprovem o seu funcionamento.
ATIVIDADES
12. Dado o circuito abaixo, os seguintes programas que respeitem a tabela abaixo
SW1 SW2 LED1 / LED2

0 0 Piscando as duas portas ao mesmo tempo em intervalo de 1 segundo
0 1 Piscando as duas portas ao mesmo tempo em intervalo de 0,5 segundo
1 0 Piscando as duas portas alternadamente em intervalo de 1 segundo
1 1 Os dois leds ficarão permanentemente acessos sem piscar
a) O primeiro programa deve ser feito somente por software.

b) O segundo programa deve ser feito usando o timer interno do HCS908QG8
+5V
HCS1
SW1
+5V
1
PTA5 PTA0
16 SW -SPST
2
PTA4 PTA1
15
3
SW2
VDD+5 PTA2
14
4 SW -SPST
VSS/GND PTA3
13
5
PTB7 PTB0
12
6
PTB6 PTB1
11 R1 R3
7 1k 1k
PTB5 PTB2
10
R2 R4 8
PTB4 PTB3
150 150 9
HCS908QG8
D1 D2
LED LED
ATIVIDADES
13. Dado o circuito abaixo faça um programa que respeite a tabela abaixo
+5V
SW1 SW2 DISPLAY
HCS1
SW1 0 0 Zero no display
+5V
1
PTA5 PTA0
16
2
SW -SPST
0 1 Contador Crescente
PTA4 PTA1
15
SW2
3
VDD+5 PTA2
14 1 0 Contador Decrescente
4 SW -SPST
VSS/GND PTA3
5
13
1 1 Zero piscando
PTB7 PTB0
12
6
PTB6 PTB1
11 R8 R9
7 1k 1k
PTB5 PTB2
10
8
PTB4 PTB3
9
Recomenda-se em caso de dúvida
HCS908QG8
consultar o data sheet do 7448
3
5
4
6
2
1
7
U1
B
A
D
C
LT
RBI
BI/RBO
7448
QG
QD
QC
QE
QB
QA
QF
14
15
9
10
11
12
13
R1
150
R2
150
R3
150
R4
150
R5
150
R6
150
R7
150

Apostila HC Hcs 08

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Apostila HC Hcs 08

Transféré par

Droits d'auteur :

Formats disponibles

MICROCONTROLADORES

• High Performance, Easy to Use 68HC08 CPU

Ao inicializar este programa logo é

Cria um novo projeto com auxilio do

Carrega exemplos de programas existentes

Carrega um projeto já existente

Carrega o tutorial do Code Warrior

Inicia o programa normalmente sem

Escolha o nome do projeto

Este é o local onde

Ao termino da configuração click em

Obs. Ainda não

Microcontrolador Após a escolha click em avançar

Caso tenha outras fontes a adicionar estas ficam em PROJECT FILES.

O processador expert é uma ferramenta de desenvolvimento que será visto futuramente.

Click duas vezes em

O seu programa deve

Este icone faz ingressar

Este ícone permite

Nesta janela podemos

Este ícone faz a

Faz rodar o Apaga todos

Faz rodar o Faz parar a

Esta janela informa em que

Esta janela mostra o resultado

Nesta janela você vê o seu programa escrito anteriormente

Nesta janela é possível ver todos os dados dentro

Ciclos gastos pela CPU ao rodar o programa

Registrador de Status, onde este

REGRAS DAS CORES

Preto = comando não

Linhas de comentários são importantes para

Para compilar e simular use os ícones

Observe que quando o CODE WARRIOR faz as alterações no microcontrolador mediante o

Para ver a simulação

Número 08 hexa inserido no acumulador

Número 08 hexa salvo na

LDA – Carrega um valor de imediato ou pela memória

Ex. LDA #08 - Carregamento do numero 08 em decimal para o acumulador

STA – Carrega o valor do acumulador para a memória

MOV – Movimenta um valor para a memória, e valores entre áreas de memória

Também é possível fazer na porta de saída do microcontrolador.

Para o apagamento total de um determinado endereço de memória usamos o CLR

Também é possível fazer na porta de saída do microcontrolador.

No simulador do CODE WARRIOR

CLICK COM O BOTÃO DIREITO

O recurso de deslocamento pode ser feito também na área de memória do microcontrolador

O Code Warrior consegue facilitar a estrutura do programa como mostra abaixo

LDA #((2*3)/(4-2))-1 CALCULO EXECUTADO NO ACUMULADOR

MOV #2+((4*2)/2),$80 CALCULO EXECUTADO NO ENDEREÇO 0080 DA MEMÓRIA

Em programação de microcontroladores não só existem execuções, em algum momento devemos tomar

ALGUNS COMANDOS PARA EXEMPLO

CMP = Compara acumulador com a memória

Consulte também o arquivo

1. COMPARAR E DESVIA - CBEQA

1. TESTA O BIT E DESVIA - BRSET

1. TESTA O BIT E DESVIA - BRCLR

PTB, pode enviar um

Nível para DDRB = 1

Nível para DDRB = 0

Para podermos programar um microcontrolador, devemos conhecer todo o HARDWARE.

LED 1 – ON LED 1 – OFF

Acesse este ícone