Вы находитесь на странице: 1из 128

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.
MICROCONTROLADORES – CODE WARRIOR
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
MICROCONTROLADORES – CODE WARRIOR
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
MICROCONTROLADORES – CODE WARRIOR
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
MICROCONTROLADORES – CODE WARRIOR

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


No momento não existe nenhum e podemos avançar direto
MICROCONTROLADORES – CODE WARRIOR

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


Click em concluir como a tela se encontra originalmente para iniciar o projeto
MICROCONTROLADORES – CODE WARRIOR
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
MICROCONTROLADORES – CODE WARRIOR

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
MICROCONTROLADORES – CODE WARRIOR
Esta tela é o local onde podemos fazer a simulação e ver os resultados obtidos do desempenho do programa
MICROCONTROLADORES – CODE WARRIOR
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
MICROCONTROLADORES – CODE WARRIOR

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)
MICROCONTROLADORES – CODE WARRIOR

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
MICROCONTROLADORES – CODE WARRIOR

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
MICROCONTROLADORES – CODE WARRIOR

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
MICROCONTROLADORES – CODE WARRIOR
Esta é a tela do simulador com o programa ainda não simulado. Para simular use os icones Step e Reset
MICROCONTROLADORES – CODE WARRIOR

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
MICROCONTROLADORES – CODE WARRIOR

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
MICROCONTROLADORES – COMANDOS

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
MICROCONTROLADORES – COMANDOS

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
MICROCONTROLADORES – COMANDOS

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
MICROCONTROLADORES – COMANDOS

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>
MICROCONTROLADORES – COMANDOS

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
MICROCONTROLADORES – DECISÕES POR COMPARAÇÃO

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
BRA INICIO BRA INICIO
MICROCONTROLADORES – DECISÕES POR COMPARAÇÃO

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
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
BRA INICIO BRA INICIO
MICROCONTROLADORES – DECISÕES POR COMPARAÇÃO

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
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
BRA INICIO BRA INICIO
MICROCONTROLADORES – DECISÕES POR COMPARAÇÃO

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á
colocado no endereço 86.

PROCESSO:

1. TESTA O BIT E DESVIA - BRSET

INICIO: INICIO:
MOV #%00000100,$80 MOV #%00000000,$80
BRSET 2,$80, DESVIA BRSET 2,$80, 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
BRA INICIO BRA INICIO
MICROCONTROLADORES – DECISÕES POR COMPARAÇÃO

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á
colocado no endereço 86.

PROCESSO:

1. TESTA O BIT E DESVIA - BRCLR

INICIO: INICIO:
MOV #%11111011,$80 MOV #%11111111,$80
BRCLR 2,$80, DESVIA BRCLR 2,$80, 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
BRA INICIO BRA INICIO
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
MICROCONTROLADORES – PORTAS
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
MICROCONTROLADORES – PORTAS

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


MICROCONTROLADORES – PORTAS

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


MICROCONTROLADORES – SIMULAÇÃO VISUALIZATION TOOLS

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
MICROCONTROLADORES – SIMULAÇÃO VISUALIZATION TOOLS
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)
MICROCONTROLADORES – SIMULAÇÃO VISUALIZATION TOOLS

Para podermos ver o LED em funcionamento devemos configurar o REFRESH MODE em PERIODICAL e
o REFRESH TIME (100ms) para 1.
MICROCONTROLADORES – SIMULAÇÃO VISUALIZATION TOOLS

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
MICROCONTROLADORES – SIMULAÇÃO VISUALIZATION TOOLS
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.
MICROCONTROLADORES – SIMULAÇÃO VISUALIZATION TOOLS

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


MICROCONTROLADORES – GRAVANDO O FIRMWARE

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
MICROCONTROLADORES – GRAVANDO O FIRMWARE

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


MICROCONTROLADORES – GRAVANDO O FIRMWARE

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


MICROCONTROLADORES – PROCESSADOR EXPERT

Esta é a tela aonde podemos ver a pinagem do microcontrolador e as áreas que queremos configurar
MICROCONTROLADORES – PROCESSADOR EXPERT

Configurando o PTA como entrada, devemos dar um click em PTA (desenho do chip) e teremos a seguinte tela
MICROCONTROLADORES – PROCESSADOR EXPERT

Na figura abaixo temos todo o processo de configuração do PTA como entrada.


Ela mostra a configuração de DDRA, PTAPUE e PTA
MICROCONTROLADORES – PROCESSADOR EXPERT

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
MICROCONTROLADORES – PROCESSADOR EXPERT
Uma vez configurado, podemos acionar o GENERATE CODE
MICROCONTROLADORES – PROCESSADOR EXPERT

ESTE CÓDIGO FOI


CRIADO
AUTOMATICAMENTE
PELO
PROCESSADOR EXPERT
MICROCONTROLADORES – 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
MICROCONTROLADORES – PROCESSADOR EXPERT

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.
MICROCONTROLADORES – SUB ROTINAS
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.
MICROCONTROLADORES – SUB ROTINAS
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
MICROCONTROLADORES – SUB ROTINAS
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
MICROCONTROLADORES – SUB ROTINAS
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
MICROCONTROLADORES – SUB ROTINAS
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
MICROCONTROLADORES – CONVERSOR ANALÓGICO / DIGITAL

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
MICROCONTROLADORES – CONVERSOR ANALÓGICO / DIGITAL

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
MICROCONTROLADORES – CONVERSOR ANALÓGICO / DIGITAL

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


MICROCONTROLADORES – CONVERSOR ANALÓGICO / DIGITAL

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
MICROCONTROLADORES – INTERRUPÇÃO DE TECLADO

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
MICROCONTROLADORES – INTERRUPÇÃO DE TECLADO
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
MICROCONTROLADORES – INTERRUPÇÃO DE TECLADO

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.
MICROCONTROLADORES – INTERRUPÇÃO DE TECLADO
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


MICROCONTROLADORES – INTERRUPÇÃO DE TECLADO
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
MICROCONTROLADORES – INTERRUPÇÃO DE TECLADO
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
MICROCONTROLADORES – CODE WARRIOR
MICROCONTROLADORES – CODE WARRIOR
MICROCONTROLADORES – CODE WARRIOR
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.
#include "derivative.h"
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>
#include "derivative.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;
}
PROGRAMA PARA HC908QY4
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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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;
}

PROGRAMA PARA HC908QY4


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.

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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.
PROGRAMA PARA HC908QY4
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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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.
PROGRAMA PARA HC908QY4
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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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;
}

PROGRAMA PARA HC908QY4


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.

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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];
}

PROGRAMA PARA HC908QY4


MATRIZES

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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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

PROGRAMA PARA HC908QY4


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.

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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;

PROGRAMA PARA HC908QY4


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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */
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
case (2): PTBD_PTBD1=1;goto inicio;break; //ativa PTB1
case (3): PTBD_PTBD2=1;goto inicio;break; //ativa PTB2
case (4): PTBD_PTBD3=1;goto inicio;break; //ativa PTB3
case (5): PTBD_PTBD4=1;goto inicio;break; //ativa PTB4
case (6): PTBD_PTBD5=1;goto inicio;break; //ativa PTB5
case (7): PTBD_PTBD6=1;goto inicio;break; //ativa PTB6
case (8): PTBD_PTBD7=1;goto inicio;break; //ativa PTB7
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.

PROGRAMA PARA HCS908QG


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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */
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.

PROGRAMA PARA HCS908QG


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
COMANDOS REPETIÇÃO – WHILE

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */
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.
PTBDD=255; //Configura todos os bits da PTB como saída

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.

PROGRAMA PARA HCS908QG


COMANDOS REPETIÇÃO – WHILE

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */
char 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=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=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.

PROGRAMA PARA HCS908QG


COMANDOS REPETIÇÃO – WHILE

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */
char 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=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;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

PROGRAMA PARA HCS908QG


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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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

PROGRAMA PARA HCS908QG


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.

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

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.

PROGRAMA PARA HCS908QG


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.

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

#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

__RESET_WATCHDOG(); /* feeds the dog */


}
}

PROGRAMA PARA HC908QY4


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.

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

#define CHAVE PTA_PTA0


#define LED PTB_PTB0

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

__RESET_WATCHDOG(); /* feeds the dog */


}
}

PROGRAMA PARA HC908QY4


TEMPORIZAÇÃO – POR SOFTWARE

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

#define LED PTB_PTB0


#define CHAVE PTA_PTA0

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;
}}}

PROGRAMA PARA HC908QY4


TEMPORIZAÇÃO – POR HARDWARE

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

#define LED PTB_PTB0


#define CHAVE PTA_PTA0

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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

#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


}

PROGRAMA PARA HCS908QG


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

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */
#define CHAVE PTBD_PTBD4

void interrupt 15 TX(void)


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

void main (void)


{ EnableInterrupts;
SOPT1=0; // Watch dog desligado
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.
}}

PROGRAMA PARA HCS908QG


TRANSMISSÃO SERIAL - RX

#include <hidef.h> /* for EnableInterrupts macro */


#include "derivative.h" /* include peripheral declarations */

#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;

SOPT1=0; // Watch dog desligado


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(;;){ } }

PROGRAMA PARA HCS908QG


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