Apostila MICRO

CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS
o
Departamento de Ensino do 2 grau - Coordenação de Eletrônica
Disciplina: Laboratório de Introdução a Programação
Sistemas
Microprocessados I
AUTORES:
1A versão
Prof. Marcos Antônio da Solva Pinto
Prof. Joel Augusto dos Santos
Prof. José Jonas da Silva Maia
Prof. Hércules M. Carvalho
2A versão – 2001
Prof. Marcos Antônio da Solva Pinto
Prof. John Kennedy Schettino de Souza
Prof. Paulo Sérgio Roque
3A versão – 2003
Prof. Marcos Antônio da Silva Pinto
Profa. Rosângela Fátima da Silva
A
4 versão – 2004
Prof. Marcos Antônio da Silva Pinto
5A versão – 2009
Profa. Rosângela Fátima da Silva
o
Disciplina: Laboratório de Sistemas Microprocessados
ÍNDICE
Introdução 03
Aula Prática 01 04
Ambiente de programação da IAR Systems
Aula Prática 02 13
Instruções de carga e transferência de 8 bits
Aula Prática 03 17
Instruções de carga e transferência de 16 bits
Aula Prática 04 20
Operações lógicas e aritméticas
Aula Prática 05 23
Tomada de decisão
Aula Prática 06 26
Instruções de salto (jumps)
Aula Prática 07 28
Subrotinas
Aula Prática 08 32
Programas
Aula Prática 09 34
Acionamento de LEDs com temporização de software
Aula Prática 10 40
Monitoração de chave com espera ocupado
Aula Prática 11 43
Monitoração de chave com interrupção
Aula Prática 12 47
Teclado
CEFET-MG 1
o
Aula Prática 13 50
Display de Cristal Líquido
Aula Prática 14 54
Modularização
Referências Bibliográficas 61
CEFET-MG 2
o
INTRODUÇÃO
Caríssimos alunos,
Como você pode observar na capa desta apostila, existem várias versões. Isto
significa que estamos, cada vez mais, tentando melhorar o material que você
utiliza. Parte destas versões é devido a mudamos da tecnologia. Mas o que nos
move é o desejo de que esta apostila seja a melhor possível, portanto gostaríamos
que você preste muita atenção em tudo que a partir deste momento vamos
oferecer e nos ajude nesta missão. Talvez assim consigamos atingir nossos
objetivos.
Já estudamos as estruturas básicas da linguagema C, assembly não e uma

linguagem estruturada é uma linguagem de máquina. Isto significa que a partir
deste momento é necessário que você conheça o hardware do processador a
programar. A maioria das disciplinas já estudadas está ligada ao hardware.
Modelar a solução de um problema, também você estudou. Não se lembra!!! É
bom dar uma olhadinha em fluxogramas. Então com um pouquinho mais de
estudo, você perceberá uma grande relação entre as estruturas de repetição e a
estrutura de tomada de decisão da linguagem C e da linguagem assembly.
No mais, desejo a todos um bom aproveitamento.
Atenciosamente,
Rosângela Fátima da Silva
CEFET-MG 3
o
AULA PRÁTICA 01
OBJETIVO:
Introduzir o ambiente de programação da IAR Systems
INTRODUÇÃO
O desenvolvimento de programas em linguagem assembly exige não apenas o

conhecimento de um ambiente de programação, mas também do processador em
questão. A Texas desenvolveu o microcontrolador MSP430F149. Este
microcontolador possui em seu chip além de um microprocessador, outros
dispositivos acoplados. A IAR System é a responsável pelo desenvolvimento do
software que nós estaremos utilizando ao longo deste curso.
O processo de criação de um programa em assembly é muito parecido com tudo

que fizemos ao criar os nossos programas em linguagem C, Observe a seqüência
na Figura 1, apresentada a seguir:
Figura 1 - Procediemto para criação de um programa
A edição consiste na digitação, de todos os mnemônicos pertencentes ao

programa, utilizando um editor de texto tipo ASCII. Neste estágio o programa está
em linguagem assembly e é conhecido como código fonte.
A montagem é a tradução do texto digitado (mnemônicos) para o respectivo

código de máquina (binário) da CPU. Caso seja obtido sucesso nesta etapa será
gerado o código objeto.
A linkedição insere informações relativas ao sistema operacional, que está sendo

utilizado, ao código fonte. Entretanto o papel mais relevante da linkedição é a
ligação de vários códigos objetos. Isto ocorre quando construímos programas
muito grandes que por questão de projeto é importante que o programa seja
construído em partes separadas.
Conforme a ferramenta que usarmos, os dois últimos processos podem ser feitos
em um único passo. Talvez seja necessário criar um projeto antes de executar os
CEFET-MG 4
o
passos mencionados. Sintetizando, tudo depende da ferramenta em uso e, de

fato, do queremos fazer.
IAR SYSTEMS
Para abrir o programa, vá ao botão Iniciar e clique com o lado direito do mouse e
selecione as seguintes opções, sequencialmente: Programas, IAR System, IAR
Embedded Workbench kickStart for MSP430 V4, IAR Embedded Workbench,
conforme você pode observar na Figura 2, apresentada a seguir.
Figura 2 - Janela de trabalho do Windows
Quando você clicar sobre a opção IAR Embedded Workbench, vai aparecer a
janela de Inicio do Embedded Workbench, veja a Figura 3:
Figura 3 - Janela de Inicio do Embedded Workbench
CEFET-MG 5
o
Observe que você tem as seguintes opções:
Criar um novo projeto dentro do workspace corrente
Adicionar um projeto já existente dentro do workspace corrente
Abrir um workspace já existente
Abrir um workspace de exemplo
Figura 4 - Opções apresentadas pela janela Embedded Workbench Startup
Atenção:
Se você clicar sobre a opção IAR Embedded Workbench e não aparecer a
janela mostrada na Figura 3. Vá ao menu principal escolha a opção Project
e em seguida Create New Project. A janela Create a New Project será
aberta, veja a Figura 5.
Como é a primeira vez que estamos trabalhando com esta ferramenta,

naturalmente você escolherá a opção Criar um novo projeto dentro do
wokspace corrente. Essa opção abre uma nova janela, que permite determinar
qual o projeto que você deseja criar, Figura 5.
Figura 5 - Janela de criação de um novo projeto
Como já conversamos, iniciaremos os nossos estudos pela linguagem Assembly.

Portanto você abrirá a opção asm e selecionará o item asm.
CEFET-MG 6
o
Uma vez determinado o tipo de projeto a ser criado, o próximo passo é salva-lo.
Quando a gente salva um arquivo, naturalmente temos que escolher uma pasta.
Vá a Meus documentos, lá existe uma pasta para a sua turma. Caso não exista,
faça a gentileza de criá-la. Dentro desta pasta crie a sua pasta, de preferência
com o seu nome. Ótimo assim você sabe onde estão as suas coisas. Agora crie
uma nova pasta, ela pode se chamar AULA_01, por exemplo. Cada
projeto que criarmos, terá uma pasta exclusiva para ele.
Atenção:
Todos os seus arquivos devem estar dentro de uma única pasta com o seu
nome.
Crie uma pasta exclusiva para cada projeto, ou seja, para cada novo
programa que você vai implementar.
NÃO se esqueça de salvar os seus arquivos no seu pendriver, ao final de
todas as aulas.
A janela Salvar como, que surgiu na tela, lhe dá a opção de escolher o nome do
projeto. Observe, neste caso, foi salvo na pasta AULA_01 o projeto com o nome
PROJ_01, Figura 6.
Figura 6 - Janela Salvar como
Enfim, surgiu na tela o editor de texto, Figura 7, onde você pode digitar o seu
programa.
CEFET-MG 7
o
Figura 7 - Janela com workspace e o editor de testo
A janela apresentada anteriormente possui duas partes básicas: a janela

workspace, que contém o projeto recém criado, bem como os arquivos
pertencentes a ele e a janela asm.43*, que contém o código fonte.
Digite o seguinte código a partir da linha 18 mostrada na Figura 7.
MOV.B #0xAA,R4 ;IMEDIATO −> REGISTRO

MOV.B R4,R5 ;REGISTRO −> REGISTRO
MOV.B R5,&0x200 ;REGISTRO −> MEMÓRIA
MOV.B &0x200, &0x201 ;MEMÓRIA −> MEMÓRIA
MOV.B &0x201,R6 ;MEMÓRIA −> REGISTRO
Uma vez digitado o programa é necessário salvá-lo. Vá ao menu principal e

selecione a opção File e em seguida Save Workspace. Surgirá a janela Save
Workspace As, Figura 8:
Figura 8 - Janela para salvar o Workspace
CEFET-MG 8
o
Escolha um nome para o workspace e salve. Neste caso foi escolhido o nome
AREA_01.
Agora é hora de verificar se o código digitado está correto e transformá-lo em

código de máquina. Este é o processo de montagem, para executá-lo vá ao menu
principal selecione a opção Project e clique sobre Make ou pressione a tecla F7.
Com o processo de montagem concluído, o seu ambiente de trabalho deve estar

com a aparência da Figura 9:
Figura 9 - Janela do Workspace
Observe que na parte inferior da tela apareceram algumas informações referentes

ao processo de montagem do programa, aba Build.
Se houver algum erro no seu programa, uma mensagem de erro aparecerá nesta
aba, descrevendo resumidamente o erro. Se você der um duplo clique sobre a
mensagem, o cursor será imediatamente movido para o ponto em que o erro foi
localizado.
CEFET-MG 9
o
Após corrigir o erro, basta clicar novamente sobre o ícone ou pressionar a

tecla F7 para que o processo de montagem ocorra novamente.
Quando não houver mais erros, a mensagem Total number of errors: 0, deve ser
apresentada. Repare que a existência de mensagem de alerta (Total number of
warnings: 1, trata-se apenas de um aviso. Indica ao programador que algo foi
encontrado no programa, podendo provocar falhas ou problemas.
Agora resta simular a execução do programa. Em outras palavras, fazer de conta

que o programa está sendo executado. Isso porque o simulador é um programa
que nos permite rodar um código escrito para um processador, indicando o que
aconteceria caso ele existisse de fato. Para carregar o programa no ambiente de
simulação, vá ao menu principal, selecione a opção Project e clique sobre Debug,
ou pressione as teclas CTRL + D, ou então clique sobre o ícone , disponível na
barra de ferramentas do Embedded Workbench. Um novo ambiente, o modo
depuração, é disponibilizado, veja a Figura 10:
Figura 10 - Ambiente de depuração
Observe a janela adicional de Disassembly que foi aberta no lado direito da tela.
Nela está exibido o conteúdo da memória de programa do processador, no
formato hexadecimal intercalado com o código-fonte original.
CEFET-MG 10
o
Uma nova barra de ferramentas IDE, a barra de depuração, também foi

adicionada. Essa barra disponibiliza vários botões para o usuário interagir com o
programa em simulação, permitindo a execução continua do programa, a
execução passo a passo, ré-inicio, parada e etc. Os botões da barra de ferramenta
IDE estão apresentados na Figura 12.
É possível acrescentar novas janelas neste ambiente. Vá ao menu principal, clique

sobre o botão View e observe a lista de opções. Dentre elas selecione Register, a
janela Register será apresentada na tela. Clique novamente no botão View e
selecione Memory. As janelas Register e Memory, geralmente, são as mais
usadas em nossas aplicações, veja a Figura 11:
Figura 11 - Ambiente para depuração com as janelas Register e Memory
Observe na figura anterior que nas janelas de Observação e de Disassembly

existe uma linha de código sobre um fundo verde. É a indicação da próxima linha
de programa a ser executada.
Agora basta você escolher uma das opções de execução do programa na barra de
ferramentas IDE, Figura 12, e verificar a simulação do mesmo.
CEFET-MG 11
o
Reinicia o programa
Para a execução do programa
Executa a próxima instrução ou comando, se for uma chamada de

sub-rotina ou função, ela é inteiramente executada e o controle
retorna para a instrução após a chamada
Executa a próxima instrução ou os comandos passo a passo
Executa o programa até o término da função atual
Pula para o próximo comando, o atual é executado sem a

visualização do depurador
Executa o programa até o ponto em que encontra o cursor
Executa o programa até um ponto de parada (breakpoint) ou o

término do programa
Cria/apaga um breakpoint
Saída do modo de depuração
Figura 12 - Botões da barra de ferramentas IDE
Atenção:
As opções de execução de programas presentes na barra de ferramentas
IDE, mostradas na Figura 12, podem ser acessadas através da seleção do
botão Debug no nenu principal.
ATIVIDADES
1.1Teste todos os botões da barra de ferramentas IDE.
Dica:
Dica:
Se você não observar diferenças entre alguns deles, fique ligado, pois é
apenas uma questão de tempo.
CEFET-MG 12
o
AULA PRÁTICA 02
OBJETIVO:
Estudar as instruções de carga e transferência de 8 bits
INTRODUÇÃO
Na aula anterior, você executou a maioria das instruções de transferência de oito

bits existentes no conjunto de instruções do MSP. E também aprendeu a elaborar
seus programas usando o ambiente de programação da IAR System. Vamos
agora aproveitar o projeto elaborado e aprender como abrir um projeto existente.
E também estudar mais atentamente as instruções de carga e transferência de
oito bits.
COMO CARREGAR UM PROJETO JÁ EXISTENTE
Basta abrir o ambiente de programação da IAR System e clicar sobre o botão:

- Open existing workspace.
Talvez, você não se lembre como abrir o IAR System. Então faça como na aula
anterior: clique sobre o botão Iniciar, e selecione sequencialmente as opções:
Programas, IAR System, IAR Embedded Workbench kickStart for MSP430 V4,
IAR Embedded Workbench, conforme foi mostrado na Figura 2. Quando você
clicar sobre a opção IAR Embedded Workbench, aparecerá a janela de Inicio do
Embedded Workbench, apresentada na Figura 3. Neste caso, escolha o botão
“Abrir um workspace já existente”.
Atenção:
Se você clicar sobre a opção IAR Embedded Workbench e não aparecer a
janela mostrada na Figura 3. Vá ao menu principal escolha a opção File e
em seguida as opções: Open e Workspace.... A janela Open workspace,
será apresentada, veja a Figura 13.
É provável que você tenha que localizar a sua pasta e em seguida a pasta relativa
ao seu projeto, AULA_01. Como você mandou abrir uma área de trabalho,
CEFET-MG 13
o
naturalmente, surgira na tela, a janela Open workspace, Figura 13. Então

selecione AREA_01 e clique sobre o botão Abrir.
Figura 13 - Janela para abrir o Workspace
INSTRUÇÕES DE CARGA E TRANSFERÊNCIA DE 8 BITS
Todos os registros do MSP são de dezesseis bits. Mas é possível carregar,

transferir e executar operações lógicas e aritméticas com apenas oito bits. Neste
caso, basta acrescentar um pequeno detalhe na instrução: MOV.B. Observe que
existe um ponto e um caractere B após a instrução. Se você omitir esse detalhe
ou colocar um “.W”, a instrução é então de dezesseis bits: MOV.W ou apenas
MOV.
Atenção:
O MSP possui 12 registros de uso geral: R4 a R15. Eles podem ser usados
em suas aplicações habituais: transferência de dados, operações lógicas,
aritméticas, jumps e etc. Eles armezenam dados ou endereços.
As operações de 8 bits são executadas apenas com a parte menos
significativa dos registros.
ATIVIDADES
2.1 Execute o programa da aula anterior, passo a passo. E preencha a tabela a

seguir:
CEFET-MG 14
o
Instruções/ MOV.B MOV.B MOV.B MOV.B MOV.B

Registros 0AAH,R4 R4,R5 R5,&200H &200H, &201H &201H, R6
R4
R5
R6
(200H)
(201H)
Tabela1 - Estado corrente de registros
Dica:
Dica:
Para executar o programa passo a passo, abra o módulo de simulação,
ciclando sobre o ícone e pressione sucessivamente a tecla F10 ou F11.
Consulte a Figura 12.
Para ver os registros. Vá ao menu principal, clique sobre o botão View e
observe a lista de opções. Dentre elas selecione Register.
2.2 Abra uma nova pasta e construa um novo projeto para testar as seguintes
instruções:
MOV.B #0AAH,R4 ;IMEDIATO −> REGISTRO

MOV.B #0BBH,R5 ;IMEDIATO −> REGISTRO
1. O que ocorreu com os valores carregados nos registros R4 e R5?

2. Porque foi usado o registro R6?
2.3 Elabore um programa que troque o conteúdo das posições de memórias

200H e 201H.
instruções:
MOV.W #0x200,R4
MOV.W #0x201,R5
MOV.B #0xCC,&0x200
MOV.B #0xDD,&0x201
MOV.B 0(R4),R6
MOV.B 0(R5),0(R4)
MOV.B R6,0(R5)
1. Qual é a diferença entre as seguintes instruções:

MOV.B R5,R4
MOV.B 0(R5),0(R4)
2. O que foi armazenado nos registros R4 e R5, dados ou endereços?
3. O que ocorreu com o conteúdo das posições de memória 0x200 e 0x201?
CEFET-MG 15
o
4. Explique o funcionamento do programa.
2.5 Faça um programa que execute as seguintes instruções:

1. Armazene no registro R14 o endereço 0x200. (Operração de byte ou
Word?)
2. Armazene na posição de memória endereçada pelo registro R14 o
conteúdo 0xEE.
3. Transfira o conteúdo endereçado por R14 para o registor R15.
CEFET-MG 16
o
AULA PRÁTICA 03
OBJETIVO:
Estudar as instruções de carga e transferência de 16 bits
INTRODUÇÃO
Você já estudou todas as instruções de carga e transferência de 8 bits. Isto

significa que você já sabe as instruções de carga e transferência de 16 bits, uma
vez que a única diferença é o número de bits. Agora, temos que prestar muita
atenção em alguns registros que são utilizados apenas em operações de 16 bits: o
contador de programa (PC) e o ponteiro da pilha (SP).
INSTRUÇÕES DE CARGA E TRANSFERÊNCIA DE 16 BITS
O Contador de Programa e o Ponteiro da Pilha armazenam apenas endereços de

posição de memória, portanto eles são utilizados em operações de 16 bits. Esses
registros são controlados pela própria CPU durante a execução de programas. O
máximo que podemos fazer é inicializá-los.
Na versão v4 do IAR System, que estamos usando, quando criamos um novo

projeto surge o editor de texto com algumas linhas de códigos. Observe as duas
linhas seguintes:
ORG 0FFFEh
DC16 init ;set reset vector to 'init' label
Elas iniciam o Program Counter para você. Observe que ao carregar o programa
no ambiente de simulação o PC sempre está com o valor de 0x1100. E não se
esqueça de observá-lo após a execução de cada instrução, ele é automaticamente
incrementado.
O Stach Pointer (SP) é inicializado pela seguinte linha de código:
init: MOV SFE(CSTACK), SP ; set up stack
Agora está um poquinho mais claro, pois a instrução MOV você conhece e SP
representa o próprio Ponteiro da Pilha. Esse registro é automaticamenente
incrementado ou decrementado, em situações bem detrminadas que veremos no
decorrer deste curso.
CEFET-MG 17
o
ATIVIDADES
instruções:
;Número da instrução
MOV.W #0x7777,R7 ;1
MOV.W #0x8888,R8 ;2
PUSH R7 ;3
PUSH R8 ;4
MOV.W #0x00,R7 ;5
MOV.W #0x00,R8 ;6
POP R8 ;7
POP R7 ;8
1. Execute o programa e preencha as colunas após ter executado as referidas

instruções:
INSTRUÇÕES/ 1 2 3 4 5 6 7 8
REG. e PILHA
PC
SP
R7
R8
R9
(09FFH)
(09FEH)
(09FDH)
(09FCH)
Tabela 2 - Estado corrente de registros (exercício 3.1)
2. Descreva o que ocorreu com PC após a execução de cada instrução.

3. O que ocorreu com o SP e com a pilha quando foram executadas as
instruções PUSH?
4. Descreva o que ocorreu quando foram executadas as instruções POP.
instruções:
; Número da instrução
MOV.W #0AAAAH,R10 ;1
MOV.W #0BBBBH,R11 ;2
PUSH R10 ;3
PUSH R11 ;4
POP R10 ;5
POP R11 ;6
CEFET-MG 18
o

instruções:
INSTRUÇÕES/ 1 2 3 4 5 6
REG. e PILHA
PC
SP
R10
R11
(09FFH)
(09FEH)
(09FDH)
(09FCH)
2. Explique o que o programa faz
instruções:
; Número da instrução
MOV #0xBBBB,R4 ;1 - IMEDIATO −> REGISTRO
MOV R4,R5 ;2 - REGISTRO −> REGISTRO
MOV R5,&0x200 ;3 - REGISTRO −> MEMÓRIA
MOV &0x200, &0x202 ;4 - MEMÓRIA −> MEMÓRIA
MOV &0x202,R6 ;5 - MEMÓRIA −> REGISTRO
MOV #0x202,R7 ;6 - IMEDIATO −> REGISTRO
MOV 0(R7),R8 ;7 - MEMÓRIA −> REGISTRO

instruções:
INSTRUÇÕES/ 1 2 3 4 5 6 7
REG. e PILHA
PC
R4
R5
R6
R7
R8
(0200H)
(0202H)
2. Qual é a diferença entre as seguintes instruções:

MOV &0x202,R6
MOV #0x202,R7
CEFET-MG 19
o
AULA PRÁTICA 04
OBJETIVO:
Estudar as instruções lógicas e aritméticas
INTRODUÇÃO
A CPU contém a Unidade de Controle e a Unidade Lógica e Aritmética. Essa

última, como o próprio nome diz, é responsável pelas operações lógicas e
aritméticas. Ela geralmente utiliza os doze registros de propósito gerais para fazer
as operações de soma, subtração, and, or e etc.
Algumas operações lógicas e aritméticas afetam flags. Eles são consultados para
tomada de decisão. Os flags existentes no MSP estão no Registro de Status (SR)
nos seguintes bits:
C (bit 0) – será setado caso ocorra um estouro de capacidade (vai um) e

para algumas instruções, apresenta lógica invertida, quando pede um
emprestado.
Z (bit 1) – será setado caso o resultado de uma operação seja zero.
N (bit 2) – será setado se o resultado de uma operação for negativa.
V (bit 8) – será setado quando houver erro aritmético sinalizadas.
Dica:
Dica:
É necessário consultar o conjunto de instruções do MSP para verificar quais
os flags que atuam após a execução de cada instrução e como eles são
afetados.
ATIVIDADES
4.1 Faça as seguintes operações aritméticas e sinalize os flags:

Operação Resultado V N Z C
79 -79
57H + 4B H
160H AND 54F9H
45H – 56H
8FH + 64H
Tabela 5 - Operações lógicas e aritméticas
CEFET-MG 20
o
4.2 Escreva em assembly o código para testar as instruções apresentadas no item

anterior. Execute o programa e aproveite para verificar se os flags sinalizados
por você estão corretos.
4.3 Analise o código apresentado a seguir:
MOV.B &0x200,R4
MOV.B &0x201,R5
ADD.B R4,R5
MOV.B &0x200,R6
MOV.B &0x201,R7
CLRC
DADD.B R7,R6
1. Digite no editor de texto do IAR System o programa.

2. Armazene nas posições de memória 200H e 201H os valores 35H e 47H
respectivamente.
Dica:
Se você quiser inserir um conteúdo em um espaço de memória RAM, siga
os seguintes passos:
a. Vá ao ambiente de depuração.
b. Acrescente a janela Memory.
c. Clique com o botão direito do mouse sobre a seta da caixa de texto
onde está escrito Memory e selecione RAM.
d. Marque com o botão direito do mouse a posição de memória que
você deseja modificar e escreva o valor desejado por cima.
3. Execute o programa e explique os valores contidos nos registros R5 e R6.

4. Explique a presença da instrução CLRC no programa.
5. Repita os itens 2 e 3 para os valores 49H e 67H.
4.4 Analise o código apresentado a seguir:
MOV.W #202H,R4
MOV.B 0(R4),R5
INC.W R4
MOV.B 0(R4),R6
INC.W R4
MOV.B 0(R4),R7
MOV.B R5,R15
AND.B R6,R15
INV.B R15
XOR.B R7,R15
INC.W R4
MOV.B R15,0(R4)
CEFET-MG 21
o
1. Digite no editor de texto do IAR System o programa.

2. Armazene nas posições de memória 202H, 203H e 204H os valores CCH,
BBH e AAH respectivamente.
3. Execute o programa e anote os resultados obtidos após executar as
seguintes instruções:
Instrução R15 Análise do resultado

AND.B R6,R15
INV.B R15
XOR.B R7,R15
Tabela 6 - Operações lógicas
4. Represente através de um circuito lógico seu funcionamento.
4.4 Observe o circuito lógico a seguir:
Figura 14 - Circuito lógico
1. Faça um programa que simule o diagrama apresentado.

2. Teste o seu programa fazendo A = B1H e B = 83H.
CEFET-MG 22
o
AULA PRÁTICA 05
OBJETIVO:
Estudar uma tomada de decisão em assembly

Verificar a implementação de um programa em assembly a partir de um
fluxograma.
INTRODUÇÃO
O que diferencia uma CPU de um hardware comum é capacidade de tomada de

decisão. Uma tomada de decisão é obtida através da consulta de um dos flags,
pois eles são os indicadores do estado corrente do programa. Ela é representada
em um fluxograma por um losango. Não sei se você observou, mas o losango é a
única figura que permite que o programa siga por um de dois caminhos possíveis.
O fluxograma para a transferência de dados de um bloco de memória para outro é

apresentada pela Figura 15, a seguir:
INÍCIO
DEFINIR O ENDEREÇO DO BLOCO DE ORIGEM

DEFINIR O ENDEREÇO DO BLOCO DE DESTINO
DEFINIR O TAMANHO DO BLOCO
TRANSFERIR UM BYTE
ATUALIZAR O ENDEREÇO DO BLOCO DE ORIGEM
ATUALIZAR O ENDEREÇO DO BLOCO DE DESTINO
ATUALIZAR O NÚMERO DE BYTES RESTANTES
F TODOS OS
BYTES FORAM
TRANSFERIDOS?
Figura 15 - Fluxograma de transferência de dados
Como você pode observar o fluxograma independe da linguagem de programação

e também não apresenta nenhum vínculo com CPU, uma vez que usaremos
programação em assembly. O fluxograma revela apenas o procedimento, ou seja,
revela o que será feito e não como será feito.
CEFET-MG 23
o
PROGRAMA EM ASSEMBLY
;*********************************************************************************************************
; Descrição: Este programa transfere dados de um bloco de memória para outro.
;*********************************************************************************************************
#include "msp430.h" ; #define controlled include file
NAME main ; module name
PUBLIC main ; make the main label vissible

; outside this module
ORG 0FFFEh
DC16 init ; set reset vector to 'init' label
RSEG CSTACK ; pre-declaration of segment

RSEG CODE ; place program in 'CODE' segment
init: MOV #SFE(CSTACK), SP ; set up stack
main: NOP ; main program

MOV.W #WDTPW+WDTHOLD,&WDTCTL ; Stop watchdog timer
MOV.W #200H,R4 ; Apontador do bloco 1
MOV.W #220H,R5 ; Apontador do bloco 2
MOV.B #10H,R6 ; Tamanho do bloco
volta MOV.B 0(R4),0(R5) ; Transferir o dado
INC.W R4 ; Atualizar apontadores
INC.W R5
DEC.B R6 ; Atualizar tamanho
JNZ volta
JMP $ ; jump to current location '$'
; (endless loop)
END
ATIVIDADES
5.1 Digite no editor de texto do IAR System o programa apresentado

anteriormente.
5.2 Armazene os valores 00, 01, 02, ...0F nos endereços 200H a 20FH
5.3 Execute o programa e observe através do espaço de memória compreendido

entre 210H a 21FH se o programa foi executado.
Dica:
Dica:
Para executar o programa, totalmente, acione a tecla F5 ou o ícone e
em seguida clicle sobre o ícone para parar.Consulte a Figura 12.
CEFET-MG 24
o
5.4 Reinicie o programa e o execute passo a passo até a instrução DEC.B R6.
Justifique os valores encontados no registro R6 e no flag Z (zero).
5.5 Saia do modo de depuração. Troque a instrução MOV.B #10H,R6 por MOV.B
#01H, R6e repita o item 5.4.
5.6 Novamente saia do modo de depuração e desfaça a troca, substituindo MOV.B

#01H,R6por MOV.B #10H,R6.
5.7 Troque a instrução JNZvolta por JZ volta, armazene o valor AA nos endereços
200H a 20FH. E execute o programa.
Dica:
Se você quiser inserir o mesmo valor em um bloco de memória RAM, siga
os seguintes passos:
1. Vá ao ambiente de depuração.
2. Acrescente a janela Memory.
3. Clique com o botão direito do mouse sobre a seta da caixa de texto
onde está escrito Memory e selecione RAM.
4. Clique com o botão esquerdo do mouse sobre uma posição de memória
qualquer e selecione Memory Fill... Aparecerá a Janela Fill.
5. .Preencha os seguites campos: Start address, Length e Value. No
nosso caso use respectivamente os seguintes valores 0x200, 0x10 e
0xAA.
5.8 Observe os blocos de memória e verifique se o programa foi executado.
5.9 Justifique sua resposta.
CEFET-MG 25
o
AULA PRÁTICA 06
OBJETIVO:
Estudar as instruções de tomadas de decisão (jump condicional)

Estudar os jumps relativo e absoluto
INTRODUÇÃO
As instruções lógicas e aritméticas afetam flags. Isto significa que logo após a
execução de qualquer uma delas é possível tomar decisões. As instruções que
usamos, neste caso são os jumps condicionais: JZ, JNZ, JL, JGE, JN, JC e etc.
Junps relativos são aqueles que desviam o programa para um endereço

calaculado a partir da posição do PC (Program Counter). Alem da instrução JMP,
todos os jumps condicionais dão saltos relativos ao apontador de programa.
A instrução BR (Branch) desvia o programa para qualquer uma das 64k posições
de memória endereçáveis. Ela salta para o destino, portanto é um jump absoluto.
ATIVIDADES
6.1 Digite no editor de texto do IAR System o programa apresentado a seguir:
;*********************************************************************************************************
; Descrição:
;*********************************************************************************************************

ORG 0F000h
APT1 DB 0,1,2,3,4,5,6,7,8,9
ORG 0F010h
APT2 DB 0,2,1,3,5,6,9,7,8,4
ORG 0F020h
APT3 DB 30H,30H,30H,30H,30H,30H,30H,30H,30H,30H
ORG 0FFFEh

CEFET-MG 26
o

MOV.W #APT1,R4
MOV.W #APT2,R5
MOV.W #APT3,R6
MOV.B #10,R7
volta CMP.B 0(R4),0(R5)
JZ igual
JL menor
MOV.B #02,0(R6)
cont INC.W R4
INC.W R5
INC.W R6
DEC.B R7
JNZ volta
; (endless loop)
igual
MOV.B #00,0(R6)
BR #cont
menor
MOV.B #01,0(R6)
JMP cont
END
6.2 Execute o programa passo a passo e verifique o que ele faz.
6.3 Elabore o fluxograma relativo ao programa.
6.4 Reinicie o programa e execute-o passo a passo até a instrução JZ igual e

justifique os valores dos flags C, Z, N e V
6.5 Explique o que ocorre nas instruções JZ XX, JNZ XX, JC XX e JNC XX, para os
valores encontrados nos flags Z e C do item anterior.
6.6 Troque a instução JMP cont por BR #cont e execute o programa.
6.7 Qual é a diferença entre as duas instuções apresentadas no item 6.6?
CEFET-MG 27
o
AULA PRÁTICA 07
OBJETIVO:
Estudar subrotinas
INTRODUÇÃO
Considere uma operação como a divisão, para a qual o MSP não dispõe de uma
única instrução capaz de executá-la. Torna-se necessário implementar um grupo
de instruções para realizar a operação de divisão. Um grupo de instruções que
executa uma tarefa específica é chamado de rotina. Portanto, para esse caso
especificamente, teremos a rotina de divisão.
Dentro de um programa pode ser necessário

executar a operação de divisão diversas
vezes. O que nos obriga a copiar a rotina de
divisão diversas vezes dentro do programa,
provocando um gasto excessivo de memória.
Uma forma mais eficiente de resolver esse
problema é fazer uma única cópia desse
programa e chamá-lo todas as vezes que for
necessário, observe a Figura 16.
Um programa implementado desta forma é

chamado de subrotina. O programa principal é
responsável por chamar a subrotina através
da instrução CALL. Essa instrução carrega no
PC o endereço inicial da subrotina, fazendo
mudar a seqüência de execução do programa.
E guarda na pilha o endereço de volta, o que
garante o retorna à seqüencial interrompida.
Essa operação é denominada chamada de
subrotina.
A subrotina é executada até a sua última instrução, que é obrigatoriamente a

instrução de retorno de subrotina - RET. Esta instrução retira da pilha o endereço
de volta ao programa, armazenado-o no PC.
CEFET-MG 28
o
ATIVIDADES
7.1 Analise a seguinte proposta de programa:

Faça o fluxograma e o programa em assembly que é constituído por um módulo
principal e uma subrotina que recebe através de R4 o valor do dividendo e de R5 o
divisor e retorna:
• R6 = -1 se divisor = 0 ou se o divisor > dividendo
• R6 = resultado da divisão
7.2 Verifique se os fluxogramas apresentados na Figura 17 e o programa em

assembly correspondem à proposta do item 7.1.
PRINCIPAL DIVISÃO
DIVIDENDO 15
SALVAR CONTEXTO
DIVISOR 3
DIVISÃO QUOC 0
S
DIVIDENDO = 0?
S
DIVISOR = 0?
DIVISOR > S
DIVIDENDO
DIVIDENDO DIVIDENDO - DIVISOR QUOC -1
S
DIVIDENDO < 0?
QUOC QUOC + 1 RESTAURAR CONTEXTO
RETORNA
Figura 17 - Fluxogramas: principal e subrotina de divisão
CEFET-MG 29
o
7.3 Digite no editor de texto do IAR System o programa e execute.
;*********************************************************************************************************
; Descrição:
;*********************************************************************************************************

ORG 0FFFEh


MOV.W #15,R4 ; determinar o dividendo

MOV.W #3,R5 ; determinar o divisor
CALL #DIVISAO
; (endless loop)
;*********************************************************************************************************
;Subrotina: DIVISAO
;Descrição: Executa da divisão entre dois números
;Entrada: DIVIDENDO
; DIVISOR
;Saída: QUOCIENTE = -1 se DIVISOR = 0 ou se DIVISOR >DIVIDENDO
; ou
; QUOCIENTE = resultado da divisão
;*********************************************************************************************************
DIVISAO
PUSH R4 ; dividendo
PUSH R5 ; divisor
MOV.W #00,R6 ; verificar se divisor = 0
CMP.W #00,R5 ; verificar de divisor =0
JZ menos_1
CMP.W R5,R4 ; verificar se divisor > dividendo
JL menos_1
volta SUB.W R5,R4 ; efetuar a divisão
JN fim
INC.W R6
JMP volta
menos_1
MOV.W #0FFFFH,R6
fim POP R5 ; restaurar contexto
POP R4
RET
CEFET-MG 30
o
END
7.4 Faça o fluxograma e o programa em assembly que é constituído por um

módulo principal e uma subrotina que troque o conteúdo de dois blocos de
memória. A subrotina recebe através de R4 o endereço inicial do bloco 1 (200H),
através de R5 o endereço do bloco 2 (220H) e de R6 o tamanho do bloco (20H)

módulo principal e uma subrotina que receba duas strings apontadas por R4 e R5
e faça a concatenação das duas strings, sendo a string inicial apontada por R4. A
string concatenada deverá ser retornada na posição de memória indicada por R6.
O fim da string será indicado pelo delimitador $.
CEFET-MG 31
o
AULA PRÁTICA 08
OBJETIVO:
Elaborar fluxogramas e os respectivos programas em assembly
INTRODUÇÃO
A única maneira de aprender é praticando. Naturalmente, cometeremos enganos,

mas podemos minimizá-los nos habituando a resolver os problemas da maneira
correta. O primeiro passo é elaborar o fluxograma e só depois elaboramos o
programa em assembly.
ATIVIDADES

módulo principal e uma subrotina que recebe uma string através da posição de
memória indicada por R4 e retorne a string escrita em ordem inversa na mesma
posição de memória. O tamanho da string está definida em R5.
8.2 Faça o fluxograma e o programa que é constituído por um módulo principal e

uma subrotia que desloca circulamente uma string. A subrotina recebe através de
R4 o endereço inicial e de R5 o tamanho da string e circula os seus caracteres da
direita para a esquerda, conforme figura apresentada a seguir:
Endereço 0F000 0F001 0F002 0F003 0F004 0F005 0F006 0F007

Posição B I M E S T R E
Posição I M E S T R E B
Posição M E S T R E B I
.
.
.
Posição B I M E S T R E
a) Imagine que as letras estivessem sendo deslocadas em um letreiro luminoso. O

que você acrescentaria neste programa para que um pedestre percebesse o
deslocamento dos caracteres?
b) Acrescente no seu programa as modificações do item anterior e execute o

programa usando o comando Go (F5). Pare o programa usando o comando
Break.
CEFET-MG 32
o
8.3 Faça o fluxograma e o programa que é constituído por um módulo principal,

uma subrotina que atualiza as horas de um relógio digital e uma subrotina de
tempo. O relógio digital é representado na memória a partir do endereço 0F000H,
utilizando dois bytes para as horas, dois bytes para os minutos e dois bytes para
os segundos. As horas minutos e segundos serão separados por dois pontos,
conforme figura a seguir:
Endereço 0F000 0F001 0F002 0F003 0F004 0F005 0F006 0F007

Posição H H : M M : S S
Dicas:
Cada posição de memória deve conter o código ASCII do digito corrente.
A base de tempo, que nos relógios são de 1 segundo, deverá ser
acelerada para possibilitar o acompanhamento e execução do programa.
CEFET-MG 33
o
AULA PRÁTICA 09
OBJETIVO:
Acionar LEDs com temporização de software
INTRODUÇÃO
Até agora apenas simulamos os nossos programas. Isto foi conveniente porque os
programas executados usavam apenas os dispositivos internos do
microcontrolador, registros da CPU e espaço de memória. Agora imagine que
você queira acionar um dispositivo externo, como um led, e não possa vê-lo
piscando...
Acionar leds, displays, chaves, teclados, motor de passo e etc, requer que os
programas sejam carregados na memória do próprio microcontrolador. Isto
significa que serão executados, de fato. E poderemos acompanhar o andamento
da execução através do IAR System.
Nesta aula veremos como configurar um projeto para que o código fonte seja
carregado no micorcontrolador, relembrar como configurar as portas, para que
possamos usa-las e acionar os leds.
PROGRAMAÇÃO DE PORTAS
Como vocês sabem existe um conjunto de registros para a configuração de cada

bit das portas. Nesta prática necessitaremos apenas os seguintes registros:
1. Registro de Seleção
BIT = 0 => pino associado às portas

BIT = 1 => pino associados aos módulos periféricos
CEFET-MG 34
o
2. Registro de Direção
BIT = 0 => pino da porta é programado como entrada

BIT = 1 => pino da porta é programado como saída
3. Registro de Saída
4. Registro de Entrada
CONFIGURANDO UM PROJETO PARA EMULAÇÃO
O primeiro passo é criar um novo projeto, fazendo tudo como antes. O segundo é
configurá-lo: vá ao menu principal e selecione Projet e em seguida click em
Options, aparecerá a janela Options for node “PROJ”, Figura 18.
Figura 18 - Janela de Opções de Projeto (Debugger)
CEFET-MG 35
o
Observe que foram selecionados a categoria (Category) Debugger e o driver

(Driver) FET Debugger. Essas opções de projeto permitem a emulação do
programa, ou seja, que você verifique na tela do seu computador o que está
ocorrendo, de fato, no microcontrolador. Em seguida é necessário que você
escolha a interface pela qual o seu programa será transferido para o
microcontrolador, Figura 19.
Figura 19 - Janela de Opções de Projeto (FET Debugger)
HARDWARE ACIONADO
Os leds presentes no kit didático apresentam a configuração apresentada na

Figura 20. Para que o led seja ligado ou desligado basta colocar o nível lógico 0
ou 1, respectivamente, no terminal L0.
Figura 20 - Esquema de ligação de leds no kit didático
CEFET-MG 36
o
FLUXOGRAMAS
A Figura 21 apresenta o fluxograma principal e o fluxograma da subrotina PISCA_LED no

qual um led pisca na freqüência estabelecida pela rotina de temporização e o número de
vezes é determinado pelo contador.
Figura 21 - Fluxogramas para o acionamento de led
CEFET-MG 37
o
;*********************************************************************************************************
; Descrição: Este programa aciona LED
;*********************************************************************************************************

ORG 0FFFEh


BIS.B #0xFF,P1DIR ; programar todos os bits da porta 1
; como saída
repete
CALL #PISCA_LED
JMP repete
;*********************************************************************************************************
;Subrotina: PISCA_LED
;Descrição: Faz o led presente no BIT 0 da porta P1 piscar 3 vezes, em
; um intervalo de tempo definido pela rotina TEMPO_PISCA
;Entrada: -
;Saída: -
;*********************************************************************************************************
PISCA_LED
PUSH R4 ; salvar contexto

MOV.B #3,R4 ; definir o número de piscadas do led
pisca
BIS.B #1,P1OUT ; ligar o led
CALL #TEMPO_PISCA
BIC.B #1,P1OUT ; desligar o led
CALL #TEMPO_PISCA
DEC.B R4 ; atualizar o contador
JNZ pisca
POP R4
RET
CEFET-MG 38
o
;*********************************************************************************************************
;Subrotina: TEMPO_PISCA
;Descrição: Intervalo de tempo gasto pela CPU, para acionamento do led
;Entrada: -
;Saída: -
;Cálculo de tempo: 3+3+1+K1(1+K2(1+2)+1+2)+3=2+2+3
;*********************************************************************************************************
K1 EQU 1
K2 EQU 1
TEMPO_PISCA ; ciclos de instrução

PUSH R5 ;3
PUSH R6 ;3
MOV #K1,R6 ;1
cont_ext
MOV #K2,R5 ;1
cont_int
DEC R5 ;1
JNZ cont_int ;2
DEC R6 ;1
JNZ cont_ext ;2
POP R6 ;2
POP R5 ;2
RET ;3
;*********************************************************************************************************
END
ATIVIDADES
9.1. Execute o programa e verifique se o led piscou.
9.2. Faça o fluxograma da subrotina de tempo e calcule as constants K1 e K2 para

que o led permaneça aceso e apagado cerca de 1 segundo, considerando a
freqüência do oscilador 750KHz.
9.3. Faça um novo fluxograma e o programa em assembly para a subrotina

PISCA_LED, em que o led permaneça aceso o dobro do tempo de apagado.
CEFET-MG 39
o
AULA PRÁTICA 10
OBJETIVO:
Monitorar uma chave através da técnica espera ocupada
INTRODUÇÃO
Na aula anterior acionamos um led, em outras palavras, a CPU enviou sinais para
o led. Para executar essa operação, primeiro tivemos que programar um bit de
uma portas como saída. Naturalmente, o bit no qual estava ligado o led. A
programação foi efetuda através do registro de direção, PnDIR. Em seguida, foi
possível enviar o sinal para o led através do registro de saída PnOUT.
Imagine que você queira ler o sinal de uma chave... Naturalmente o bit no qual
está ligado a chave será programada como entrada. E o sinal da chave também
será obtido pelo registro PnOUT?
HARDWARE ACIONADO
O diagrama das chaves presentes no kit é apresentado a seguir, na Figura 22.
Figura 22 - Chave ON-OFF
Observe que no terminal CH0 sempre existe um sinal bem definido, terra ou VCC.
FLUXOGRAMAS
Os fluxogramas para leitura da chave são apresentados na Figura 23. Note que no
fluxograma ESPERA_CHAVE a CPU permanece lendo a chave até que ela seja
ligada. Essa técnica é chamada Espera Ocupada.
CEFET-MG 40
o
Figura 23 - Fluxogramas para leitura de chave utilizando a técnica Espera Ocupada
;*********************************************************************************************************
; Descrição: Este programa monitora uma chave através da técnica de espera ocupada
;*********************************************************************************************************

ORG 0FFFEh


BIC.B #0xFF,P1DIR ; programar todos os bits da porta 1
; como entrada
repete
CALL #ESPERA_CHAVE
JMP repete
;*********************************************************************************************************
;Subrotina: ESPERA_CHAVE
;Descrição: Monitora o estado de uma chave
;Entrada: -
;Saída: -
;*********************************************************************************************************
CEFET-MG 41
o
ESPERA_CHAVE
BIT.B #1,P1IN ; monitorar chave
JZ ESPERA_CHAVE
CALL #TRATA_EVENTO
RET
;*********************************************************************************************************
;Subrotina: TRATA_EVENTO
;Descrição: Quatro leds piscam sucessivamente
;Entrada: -
;Saída: -
;*********************************************************************************************************
TRATA_EVENTO
RET
END
ATIVIDADES
10.1. Faça o fluxograma e o programa em assembly da subrotina

TRATA_EVENTO, na qual quatro leds piscam sucessivamente, enquanto um
estiver acesso os outros estarão apagados.
CEFET-MG 42
o
AULA PRÁTICA 11
OBJETIVO:
Monitorar uma chave através da técnica de interrupção
INTRODUÇÃO
Quando fazemos leitura de chave através da técnica de Espera Ocupada,

observamos que a CPU permanece por um tempo indetermidado lendo a chave.
Este fato justifica o nome da técnica, pois ela está ocupada lendo a chave e está
esperando a chave ser ligada para processar a atividade para a qual foi destinada.
Você acha que esta técnica é utilizada no seu PC? Imagine então que a CPU
lesse o seu teclado atraves dessa técnica... Seria possível você escutar música,
baixar um texto pela internete e visualizar a tecla digitada por você no monitor de
vídeo, “simultaneamente”? Não se esqueça que a CPU executa uma atividade de
cada vez.
Nesta aula utilizaremos a técnica de interrupção para a leitura da chave. Nesta

técnica a CPU permanece livre para executar uma atividade qualquer e quando a
chave é acionada a CPU é interrompida e depois de processar a rotina de
tratamento de interrupção ela retorna as sua atividade anterior.
Além da técnica de interrupção nesta aula trataremos do problema de repique.

Quando ligamos ou desligamos uma chave mecância ocorre uma trepidação.
Acarretando a geração de mais um pulso. Como os sistemas microprocessados
são extremanete rápidos esses pulsos são percebidos pelo sistema podendo
provocar alteração no seu processamento.
PROGRAMAÇÃO DE PORTAS
Nesta aula precisamos programar e acionar registros relativos à interrupção:
1. Registro de Habilitação de Interrupção
CEFET-MG 43
o
BIT = 0 => interrupção desabilitada

BIT = 1 => interrupção habilitada
2. Registro de Seleção de Borda de Interrupção
BIT = 0 => o flag de interrupção é setado com uma transição de baixo para alta
BIT = 1 => o flag de interrupção é setado com uma transição de alto para baixo
3. Registro de Flag de Interrupção
BIT = 0 => não existe interrupção pendente

BIT = 1 => existe interrupção pendente
FLUXOGRAMAS
Os fluxogramas para monitoração de chave através da técnica de interrupção são

apresentados na Figura 24. Obseve que não está explicito a leitura da chave nos
fluxogramas e nem tão pouco o programa principal chama a subrotina de
tratamento da interrupção...
TRATA
INTERRUPÇÃO
DESABILITAR INTERRUPÇÃO
RESETAR FLAG DE INTERRUPÇÃO
TRATA_EVENTO
HABILITAR INTERRUPÇÃO
RETORNA
DA INT.
Figura 24 - Fluxogramas para leitura de chave utilizando a técnica Interrupção
CEFET-MG 44
o
;*********************************************************************************************************
; Descrição: Este programa monitora uma chave através da técnica de interrupção
;*********************************************************************************************************

ORG 0FFFEh


BIS.B #0xF0,P1DIR ; programar os quatro bits mais
;significativos da da porta 1 como saída
BIC.B #0x0F,P1DIR ; programar os quatro bits menos
;significativos da da porta 1 como ent.
BIC.B #0x01,P1IES ; estabelecer borda de subidanono no
; bit 0 da porta 1
BIS.B #0x01,P1IE ; habilitar interrupção do bit 0 da
; da porta 1
EINT ; habilitar intrrupção geral
repete
CALL #PROCESSO_BASICO
JMP repete
;*********************************************************************************************************
;Subrotina: PROCESSO_BÁSICO
;Descrição: A CPU poderá executar qualquer tarefa sem se preocupar com a interrupção
;Entrada: -
;Saída: -
;*********************************************************************************************************
PROCESSO_BASICO
RET
;*********************************************************************************************************
;Subrotina: TRATA_INTERRUPCAO
;Descrição: Espera que a chave seja colocada no estado ligado
;Entrada: -
;Saída: -
;*********************************************************************************************************
CEFET-MG 45
o
TRATA_INTERRUPCAO
DINT ; desabilitar intrrupção geral
BIC.B #0x01,P1IFG ; reseta flag de interrupção
CALL #TRATA_EVENTO
EINT ; habilitar intrrupção geral
RETI
;*********************************************************************************************************
;Subrotina: TRATA_EVENTO
;Descrição: Define a operação que deve ser executada após o acionamento da chave
;Entrada: -
;Saída: -
;*********************************************************************************************************
TRATA_EVENTO
RET
END
ATIVIDADES
11.1. Faça o fluxograma e o programa em assembly das seguintes subrotinas:

TRATA_EVENTO – conta o número de vezes que a chave foi acionada;
PROCESSO_BÁSICO – envia o valor da contangem executada na
subrotina TRATA_EVENTO para os quatro leds do módulo didático.
Dicas:
Todo contador deve ser inicializado, caso contrário você contará lixo.
11.2. Acione a chave e analise o conteúdo exibido nos leds. Justifique o ocorrido.
11.3. Proponha uma solução para resolver o problema do repique.
CEFET-MG 46
o
AULA PRÁTICA 12
OBJETIVO:
Implementar uma rotina básica de tratamento de um teclado
INTRODUÇÃO
Alguns sistemas dedicados utilizam as chaves push-bottom e ou on-off como

entrada de dados. Entretanto, a medida que o grau de complexidade do sistema
aumenta é necessário o uso de interfaces mais amigáveis. Uma das principais
interfaces de entrada de dados em sistemas microprocessados é o teclado.
Nesta prática partiremos de uma proposta de tratamento de teclado básica, com

algumas limitações que serão tratadas num segundo momento.
HARDWARE ACIONADO
O teclado existente no kit didático é constituído por uma matriz 4x3 possibilitando
a identificação de doze teclas, Figura 25.
Figura 25 - Hardware do teclado
Como você pode observar o teclado já está internemente ligado às portas P6 e P2

do kit didático.
CEFET-MG 47
o
FLUXOGRAMA
TECLADO
CONFIGURAÇÃO DO
TECLADO
APT_TEC TAB_TEC TAB_TEC + 0 NULL
TECLA (APT_TEC) TAB_TEC + 1 3 TECLADO
COL_0 = COL_1 = COL_2 1 TAB_TEC + 2 6
TAB_TEC + 3 9 1 2 3
TAB_TEC + 4 E
Todas TAB_TEC + 5 2 4 5 6
S
linhas RETORNA TAB_TEC + 6 5
= 0? TAB_TEC + 7 8 7 8 9
TAB_TEC + 8 0
N A 0 E
TAB_TEC + 9 1
TEMPO_REPIQUE TAB_TEC + 10 4
TAB_TEC + 11 7
TAB_TEC + 12 A
COL_0 1
COL_1 = COL_2 0
Todas N S
linhas LINHA_0 = 1? APT_TEC APT_TEC + 1
= 0?
S N
COL_1 1 S
COL_0 = COL_2 0 LINHA_1 = 1? APT_TEC APT_TEC + 2
APT_TEC APT_TEC + 4
N
Todas S
N LINHA_2 = 1? APT_TEC APT_TEC + 3
linhas
= 0?
N
S
S
COL_2 1 LINHA_3 = 1? APT_TEC APT_TEC + 4
COL_0 = COL_1 0
APT_TEC APT_TEC + 4 N
Todas TECLA (APT_TEC)

N
linhas
= 0?
S RETORNA
APT_TEC TAB_TEC
Figura 26 - Fluxograma da subrotina de tratamento do teclado
CEFET-MG 48
o
O fluxogrma apresentado na Figura 26, utiliza a técnica de espera ocupada

(polling) para detecção e captura de tecla. Este algoritmo permite que as teclas
sejam identificadas através do armazenamento de seus conteúdos em uma tabela
presente na memória.
ATIVIDADES
12.1. Faça o fluxograma e o programa em assembly do programa principal que

programa as portas referentes ao teclado e chama a subrotina para ler uma tecla.
Faça o programa em assembly da subrotina apresentada na Figura 26. Verifique
se o seu programa é capaz de ler todas as teclas do teclado.
12.2. Faça uma subrotina que armazena as dez últimas teclas pressionadas.
Implemete nesta subrotina a função de repetição de tecla, ou seja, caso a tecla
acionada fique pressionada por mais de 1s, considere que a tecla foi pressionada
novamente.
CEFET-MG 49
o
AULA PRÁTICA 13
OBJETIVO:
Implemetar as rotinas básicas de tratamento de um Display de Cristal

Líquido
INTRODUÇÃO
Assim como as chaves push-bottom e on-off para entrada de dados utilizamos

freqüentemente LEDs para sinalizar a ocorrência de eventos. Entretanto, em muita
aplicações é necessário o envio de mensagens para informar o estado do sistema
ao operador permitindo ao mesmo atuar junto ao sistema. Os LCDs são
freqüentemente utilizados para estas tarefas.
HARDWARE ACIONADO
O display presente no kit didático, Figura 27, é um módulo microcontrolado,

baseado em caracteres, com capacidade de apresentar um total de 16 caracteres,
sendo estes distribuídos em apenas uma linha.
Figura 27 - Diagrama de ligação do LCD
Através do diagrama apresentado na Figura 27 podemos observar que o LCD está

utilizando oito bits para receber e enviar dados ao MCU. Esses dados são
controlados pelos seguintes sinais: RS, R/W e E.
CEFET-MG 50
o
R/W = 0 – operação de escrita no LCD

R/W = 1 – operação de leitura da memória interna do LCD
Observe que no nosso kit didático o pino R/W está aterrado.
RS = 0 – comando (palavras de programação ou endereço de memória)

RS = 0 – dado (caractere a ser apresentado no LCD)
O pino E corresponde ao sinal de habilitação das operações do LCD.
O endereço de memória de cada campo presente no LCD é apresentado na

Figura 28:
80 81 82 83 84 85 86 87 C0 C1 C2 C3 C4 C5 C6 C7
Figura 28 - Endereçamento do LCD
FLUXOGRAMA
Três subrotinas são básicas na implementação de programas para acionar o LCD.

A primeira refere-se a programação do mesmo, Figura 29.
Figura 29 - Progrmação do LCD
CEFET-MG 51
o
As caixas de processamento de 1 a 4 presentes no fluxograma definem as

características do display. Esses comandos são interpretados pelo módulo LCD
pelas words apresentadas na Tabela 1:
Comando Código Descrição

Fixação das condições de utilização 00111000 8bits de dados – display 1 linha – M 7x5
M 7x5
Controle Ativo/Inativo do display 00001110 Display e cursor ativos sem piscar
Fixação do modo 00000110 Deslocamento do cursor p/ direita
Limpeza do display 00000001 Limpa display
Tabela 1 - Comandos usados na programação do LCD
Essas palavras foram obtidas através da Tabela 2, fornecida pelo fabricante.

W/R
RS
D7
D6
D5
D4
D3
D2
D1
D0
INSTRUÇÃO DESCRIÇÃO
Limpa todo display
Limpa Display 0 0 0 0 0 0 0 0 0 1
Retorna cursor à primeira posição da primeira linha
Retorna cursor à primeira posição da primeira linha
Retorno 0 0 0 0 0 0 0 0 1 *
Retorna mensagem deslocada a sua posição original
I/D ->Sentido de deslocamento do cursor
I/D
Fixação do modo 0 0 0 0 0 0 0 1 S
S ->Define se mensagem deve ou ser deslocada
Controle Ativo/ (D) Ativa / Desativa display - (C) Ativa / Desativa
0 0 0 0 0 0 1 DCB
Inativo do display cursor - (B) Ativa / Desativa intermitência do cursor
Deslocamento do
R/L
S/C
0 0 0 0 0 1 * *
cursor/mensagem
Fixação das condições (DL) Número de bits da interface - (N) Número de linhas
DL
0 0 0 0 1 NF * *
de utilização (F) Formato do caracter
Endereçamento da CG Endereço
0 0 0 1
RAM da RAM CG
Endereçamento da DD Endereço da
0 0 1
da RAM RAM ADD
Leitura do contador B Contador de
0 1
de endereço F endereços AC
Escrita de dados na
1 0
CG ou DD RAM
Leitura de dados na
1 1
CG ou DD RAM
(*) irrelevante
Tabela 2 - Comandos Básicos do LCD
CEFET-MG 52
o
Para enviar comandos para o display é preciso respeitar a seqüência sinais

apresentada na Figura 30, garantindo que as temporizações sejam atendidas. E
para escrever mensagens no display é necessário, programar o LCD e em
seguida enviar os caracteres em ACII seguidos da seqüência de comandos
apresentados na Figura 31.
Figura 30 - Envio de Comandos Figura 31 - Envio de Dados
ATIVIDADES
13.1. Faça o fluxograma e o programa em assembly do programa principal que

envia a letra “A” para o display. Implemente o programa em assembly das
subrotinas de programação e controle do LCD.
13.2. Faça uma subrotina que envie uma string para o LCD.
CEFET-MG 53
o
AULA PRÁTICA 14
OBJETIVO:
Modularizar um programa
INTRODUÇÃO
Vocês sabem muito bem qual é a importância de dividir os programas em

módulos: clareza do código, facilidade de desenvolvemento, facilidade de
atualização, facilidade de correção e etc. Em Pascal a modularização era obtida
através de Procedimentos e Funções, na linguagem C através das funções e em
assembly através das subrotinas.
Agora vamos avançar um pouco mais no conceito de modularização, pois além de

subdividir os programas em subrotinas, eles serão armazenados em arquivos
distintos.
MODULARIZAÇÃO
Imagine que você queira elaborar um programa que capture uma tecla
pressionada e apresente o conteúdo da mesma no LCD, Figura 32. Creio que
colocaríamos o programa principal e todas as subrotina do teclado e do LCD num
único arquivo. Mas convenhamos!!! Você não acha que este arquivo conteria
códigos com papeis totalmente distintos (teclado e display)?
Para resolver este problema são criados arquivos independentes para códigos
distintos. No nosso caso criaremos três arquivos fonte: o primeiro para o programa
principal, o segundo para o teclado e último para o display.
CRIAÇÃO DE VÁRIAS ARQUIVOS DE EDIÇÃO
Quando criarmos um novo projeto automaticamente surgirá na tela uma janela

contendo o projeto recém criado e a janela de edição, identificada pela aba
asm.43*, com a estrutura básica de um programa. A janela asm.43* é usada para
digitar o programa principal, Figura 33, que no nosso caso é o algoritmo
TecladoLCD. Além da janela asm.43*, outras janelas de texto devem ser criadas,
uma para cada módulo.
CEFET-MG 54
o
Figura 33 - Primeira janela de edição (programa principal)
Para criar novas janelas de edição, vá ao menu principal escolha a opção File, em
seguida selecione a opção New, e clique em File. Sugirá uma nova janela de
edição totalmente em branco, e a sua respectiva aba Untitled1, Figura 34.
Figura 34 - Segunda janela de edição
CEFET-MG 55
o
O próximo passo é salvar e inserir esse novo módulo em seu projeto:
Para salvar vá a File, no menu principal, e escolha a opção Save As. Obseve que
na janela Save As, Figura 35, o Nome do arquivo é igual ao nome da aba da
janela de edição. Não se esqueça de selecionar Salvar como tipo: Asm Files
(“.s”, “.msa”, “.asm d”) antes de escolher o nome apropriado para esse módulo,
que deve ter extensão .s43 (teclado.s43 ). E finalmente, clique sobre o botão
Salvar.
Figura 35 - Janela para salvar
Para inserir o novo arquivo no seu projeto vá à janela Workspace, selecione

PROJ, clicando com o botão esquedo do mouse sobre ele. Selecione Add e clique
sobre Add “teclado.s43”, Figura 36. Você perceberá no Workspace que o
arquivo teclado.s43 será inserido no PROJ.
CEFET-MG 56
o
Figura 36 - Adicionar um novo arquivo fonte ao projeto
CÓDIGO FONTE
Uma vez que já sabemos criar, salvar e adicionarnovos arquivos fonte em um

projeto, está na hora de nos preocuparmos com o código que devemos colocar em
cada um deles.
Para escrever o código fonte do programa principal vamos nos orientar pelo
fluxograma da Figura 32, já mencionado. O algoritmo configura IOs do MSP e testa
se uma tecla foi pressionada. Quando ocorre tal evento a tecla é apresentada no
display.
Observe bem o algoritmo, parte dele já foi refinado e implementado por você: as
subrotinas do LCD e do TECLADO. Como aproveitar esses códigos já escritos? O
procedimento é bem simples e envolve o conceito de localidade de funções.
Uma função é denominda global quando a mesma pode ser acessada por outros
módulos do programa e é local quando só pode ser acessada dentro do próprio
módulo.
Vamos pegar como exemplo o módulo do TECLADO que é constituído por uma
função global e uma local.
CEFET-MG 57
o
A função TECLADO foi declarada como pública, observe a diretiva PUBLIC antes
do nome da função. Ela poderá ser chamada por qualquer outro módulo do
projeto. A função TEMPO_REPIQUE é uma função local, portanto só poderá ser
chamada dentro do módulo corrente, que neste caso é o módulo teclado.s43.
Observe que a variável TECLA e o label TAB_TEC foram declarados como

externos. Isso significa que as definições dos referidos termos estão em outro
módulo, mas a diretiva EXTERN permite que eles sejam acessados no módulo
corrente, teclado.s43.
Módulo teclado.s43:
#include “msp430x14x.h”
;Função global
PUBLIC TECLADO
;Variável externa
EXTERN TECLA
;Label externo
EXTERN TAB_TECLA
RSEG CODE
;**************************
;SUBROTINA: TECLADO
;DESCRIÇÃO: verifica se alguma tecla foi pressionada
;ENTRADA: -
;SAÍDA: TECLA – retorna o valor da tecla prossionada
;**************************
TECLADO
.
.
.
MOV.W #TAB_TEC,R4
.
.
.
CALL #TEMPO_REPIQUE a\\\\\\\;função loca
.
.
.
MOV.B 0(R4),TECLA
.
.
.
RET
;**************************
END
CEFET-MG 58
o
No módulo teclado.s43, a função TECLADO foi definida e declarada como

publica. Agora, nessitamos acessa-la no módulo principal, então é necessário
informar ao montador que ela está externa ao módulo corrente (asm.s43), através
da diretiva EXTERN.
Modulo asm.s43 (principal):

.
.
.
;Função externa
EXTERN TECLAD0
;Variável global
PUBLIC TECLA
;Label global
PUBLIC TAB_TECLA
.
.
.
ler_tecla
CALL #TECLADO
CMP.B #0,TECLA
JZ ler_tecla
.
.
.
;**************************
END
ATIVIDADE
14.1. Com base no que foi apresentado monte o código do algoritmo

TecladoLCD, apresentado na Figura 32, a seguir:
CEFET-MG 59
o
Figura 32 - Fluxograma TECLADO_LCD
CEFET-MG 60
o
REFERÊNCIAS BIBLIOGRÁFICAS
1 SCHETTINO, John Kennedy S. Sistemas Microprocessados II. Belo

Horizonte: CEFET-MG, 2005, 138p.
2 Texas Instrumentos. MSP430x1xx Family: User´s Guide 2003 424p.
CEFET-MG 61

Apostila MICRO

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila MICRO

Enviado por

Direitos autorais:

Formatos disponíveis

CENTRO FEDERAL DE EDUCAÇÃO TECNOLÓGICA DE MINAS GERAIS

Já estudamos as estruturas básicas da linguagema C, assembly não e uma

No mais, desejo a todos um bom aproveitamento.

Rosângela Fátima da Silva

Introduzir o ambiente de programação da IAR Systems

O desenvolvimento de programas em linguagem assembly exige não apenas o

O processo de criação de um programa em assembly é muito parecido com tudo

Figura 1 - Procediemto para criação de um programa

A edição consiste na digitação, de todos os mnemônicos pertencentes ao

A montagem é a tradução do texto digitado (mnemônicos) para o respectivo

A linkedição insere informações relativas ao sistema operacional, que está sendo

passos mencionados. Sintetizando, tudo depende da ferramenta em uso e, de

Figura 2 - Janela de trabalho do Windows

Figura 3 - Janela de Inicio do Embedded Workbench

Observe que você tem as seguintes opções:

Criar um novo projeto dentro do workspace corrente

Adicionar um projeto já existente dentro do workspace corrente

Abrir um workspace já existente

Abrir um workspace de exemplo

Figura 4 - Opções apresentadas pela janela Embedded Workbench Startup

Como é a primeira vez que estamos trabalhando com esta ferramenta,

Figura 5 - Janela de criação de um novo projeto

Como já conversamos, iniciaremos os nossos estudos pela linguagem Assembly.

Figura 6 - Janela Salvar como

Figura 7 - Janela com workspace e o editor de testo

A janela apresentada anteriormente possui duas partes básicas: a janela

Digite o seguinte código a partir da linha 18 mostrada na Figura 7.

MOV.B #0xAA,R4 ;IMEDIATO −> REGISTRO

Uma vez digitado o programa é necessário salvá-lo. Vá ao menu principal e

Figura 8 - Janela para salvar o Workspace

Agora é hora de verificar se o código digitado está correto e transformá-lo em

Com o processo de montagem concluído, o seu ambiente de trabalho deve estar

Figura 9 - Janela do Workspace

Observe que na parte inferior da tela apareceram algumas informações referentes

Após corrigir o erro, basta clicar novamente sobre o ícone ou pressionar a

Agora resta simular a execução do programa. Em outras palavras, fazer de conta

Figura 10 - Ambiente de depuração

Uma nova barra de ferramentas IDE, a barra de depuração, também foi

É possível acrescentar novas janelas neste ambiente. Vá ao menu principal, clique

Figura 11 - Ambiente para depuração com as janelas Register e Memory

Observe na figura anterior que nas janelas de Observação e de Disassembly

Para a execução do programa

Executa a próxima instrução ou comando, se for uma chamada de

Executa a próxima instrução ou os comandos passo a passo

Executa o programa até o término da função atual

Pula para o próximo comando, o atual é executado sem a

Executa o programa até o ponto em que encontra o cursor

Executa o programa até um ponto de parada (breakpoint) ou o

Saída do modo de depuração

Figura 12 - Botões da barra de ferramentas IDE

1.1Teste todos os botões da barra de ferramentas IDE.

Estudar as instruções de carga e transferência de 8 bits

Na aula anterior, você executou a maioria das instruções de transferência de oito

COMO CARREGAR UM PROJETO JÁ EXISTENTE

Basta abrir o ambiente de programação da IAR System e clicar sobre o botão:

naturalmente, surgira na tela, a janela Open workspace, Figura 13. Então

Figura 13 - Janela para abrir o Workspace

INSTRUÇÕES DE CARGA E TRANSFERÊNCIA DE 8 BITS

Todos os registros do MSP são de dezesseis bits. Mas é possível carregar,

2.1 Execute o programa da aula anterior, passo a passo. E preencha a tabela a

Instruções/ MOV.B MOV.B MOV.B MOV.B MOV.B

MOV.B #0AAH,R4 ;IMEDIATO −> REGISTRO

1. O que ocorreu com os valores carregados nos registros R4 e R5?