experiência 6: linguagem de alto nível “c” para 8051 e ... - PCS - USP

EXPERIÊNCIA 6:
LINGUAGEM DE ALTO NÍVEL “C” PARA 8051 E PROGRAMAÇÃO
ESTRUTURADA
Autores: Prof. Dr. André Riyuiti Hirakawa e Prof. Dr. Carlos Eduardo Cugnasca
Colaborador: Prof. Dr. Jorge Kinoshita
Versão 2.1 - 2007
1. OBJETIVO
Esta experiência visa exercitar a implementação de programas para
microprocessadores aplicando uma metodologia de desenvolvimento de programas estruturados. O
ambiente de desenvolvimento a ser utilizado é o software livre Small Device C Compiler (SDCC)
[01], que permitem mesclar trechos de programas escritos em Linguagem Assembly com programas
escritos em Linguagem “C”.
2. INTRODUÇÃO
O desenvolvimento de programas em linguagens de alto nível permite maior
modularização e organização das atividades, principalmente quando se utiliza uma linguagem
estruturada como a linguagem “C”. Entretanto, a linguagem por si só não inibe o desenvolvimento
de programas muitas vezes confusos e de difícil interpretação. Programas desestruturados, ou seja,
que efetuam desvios condicionais ou incondicionais sucessivos, são particularmente susceptíveis a
problemas, sendo de depuração demorada, além da dificuldade de alteração para adequação a
mudanças na especificação original. A utilização de metodologias e ferramentas para o
desenvolvimento se torna essencial e pode delinear o sucesso ou o insucesso de um projeto.
A programação estruturada se baseia em regras e convenções que devem ser
obedecidas durante todas as fases do desenvolvimento. Elas permitem que os programas se tornem
mais legíveis, modulares e mais fáceis de serem escritos, testados e modificados [4].
O desenvolvimento dos algoritmos pode obedecer à metodologia top-down, a qual
prescreve um gradual detalhamento e refinamento das soluções em etapas sucessivas, partindo da
especificação geral do problema até o detalhamento de cada módulo. Desta maneira, um programa é
elaborado a partir de uma definição abstrata, em termos de entidades e operações apropriadas ao
problema a ser solucionado, sendo tal definição refinada nas etapas seguintes, até se obter o
programa escrito na linguagem desejada [6].

2 Laboratório de Processadores-I - Experiência 6
Na primeira etapa o programa deve ser escrito como se existisse um computador que
pudesse entender as instruções utilizadas para resolver o problema em questão (esse computador
hipotético é também chamado de máquina virtual). As entradas e saídas do programa são
consideradas, mas sem a preocupação com a representação dos dados, e com a construção do
programa em termos de comandos de linguagem de programação, devendo inclusive permanecer
independente de detalhes de qualquer linguagem.
As etapas seguintes prevêem a divisão do programa num pequeno número de
módulos, cada um naturalmente de menor complexidade, mas que no conjunto representam uma
solução válida, e que pode por sua vez ser reparticionada até atingir um nível de detalhamento cuja
complexidade seja pequena, ou seja, onde praticamente o próximo passo natural seria escrever cada
módulo na linguagem de programação escolhida. Evidentemente existe algum grau de subjetividade
no processo que pode acarretar em alguns efeitos indesejados. Por exemplo, uma modularização
excessiva não traz tantos benefícios, pelo contrário, gera programas confusos e requer um tempo
maior na sua concepção e depuração; já a adoção de poucos módulos grandes e complexos também
torna o processo de desenvolvimento e depuração mais difícil. A diminuição dessa subjetividade
naturalmente vem com o aumento da experiência no projeto e implementação de muitos programas.
A representação gráfica dos algoritmos pode utilizar diversas formas, sendo as mais
usuais: os Fluxogramas [4][15] e os Diagrama Estruturados, como a Carta de Nassi-
Schneirdman ou Diagramas de Fluxo de Dados (DFDs) [4][7]. Podem ser encontrados diversos
programas de computador que auxiliam no desenho dos diagramas, e seu uso é recomendado [14]
[15].
O desenvolvimento do programa da experiência “Interface com Teclado e Display”
[10], apesar de aparentemente simples, requer muitos cuidados principalmente porque os eventos
envolvidos possuem limitação de tempo de execução e sincronismo entre as tarefas. Isto pôde ser
confirmado com o surgimento de problemas durante a execução do programa e também pela
dificuldade encontrada na solução destes.
Assim, nesta experiência será exercitado o processo de desenvolvimento de
programas utilizando-se as técnicas e recursos mencionados anteriormente. Será considerada a
mesma especificação do programa desenvolvido na experiência anterior. Dentre as rotinas
envolvidas no programa, a que retira o “bounce” das teclas, requer especial atenção. Existem várias
formas de se elaborar essa rotina, sendo duas delas são citadas a seguir:
a) Após ter sido detectada a variação de estado em uma tecla (do 0 para o 1 ou vice-versa), deve-se
aguardar um tempo t para se considerar o novo estado. O valor de t depende do tipo de tecla,
sendo da ordem de milisegundos.
b) A variação de uma tecla é considerada pela rotina somente se o estado da tecla for o mesmo
durante as últimas n leituras. Em função da alta velocidade do microcontrolador e da baixa
velocidade envolvida no acionamento de um teclado, é possível intercalar um outro
processamento entre duas leituras do teclado. Isso é particularmente útil quando existem outras

3 Laboratório de Processadores-I - Experiência 6
tarefas que devem ser realizadas paralelamente ao tratamento do teclado. O uso de uma
interrupção periódica indicando os instantes de leitura do teclado facilitaria a implementação
nesse caso.
3. CARACTERÍSTICAS DO COMPILADOR “C”
O uso de uma linguagem de alto nível no desenvolvimento de programas para
microprocessadores e microcontroladores requer alguns cuidados adicionais. Mesmo se utilizando
linguagens padronizadas, como a Linguagem C, não existe um padrão de como o código deve ser
gerado para cada processador. Compiladores de fabricantes diferentes que geram código para um
mesmo processador não necessariamente adotam as mesmas convenções. Assim, cada compilador
apresenta características próprias para a geração das instruções em linguagem de máquina, tais
como passagem de parâmetros para subrotinas, retirada de valores de funções, tratamento de
interrupções, etc.
Além disso, muitos recursos existentes em uma implementação convencional de C,
utilizada em computadores, nem sempre são encontrados em implementações especificas para a
geração de código para determinados microprocessadores e microcontroladores (por exemplo, 8051,
8080/8085, Z80, 8086/8088, 68000, etc).
Com o advento do microcomputador pessoal (por exemplo, o PC, da IBM e
sucessores), surgiram compiladores C específicos para essas máquinas, com bibliotecas de rotinas
de manipulação dos seus periféricos típicos (teclado, vídeo, disco, etc), e gerando o programa
executável compatível com elas, e que nem sempre permitem que o mesmo possa ser utilizado para
a geração de programas para sistemas diferentes, baseados no mesmo processador (por exemplo,
baseados no 8086/8088). Tais sistemas costumam apresentar áreas de memória especificas,
diferente dos computadores pessoais, exigindo compiladores e outras ferramentas de geração de
programa, com capacidade de alocação de programas para qualquer região de memória escolhida
pelo programador.
Os manuais específicos de cada compilador devem ser sempre consultados,
observando-se as restrições existentes, os recursos de biblioteca disponíveis, os mecanismos de
geração de código e demais convenções adotadas.
O Apêndice I apresenta as principais características do compilador SDCC [01].
Informações genéricas a respeito da linguagem C podem ser obtidas em [4], [5], [6], e [7].

4 Laboratório de Processadores-I - Experiência 6
4. PARTE EXPERIMENTAL
Encontra-se disponível no laboratório o pacote de software envolvendo o compilador
C e recursos para a geração de código e depuração de programas:
• o Small Device C Compiler (SDCC) [01] é um software livre (freeware) para as famílias Intel
8051, Maxim 80DS390 e o Zilog MCUs Z80. Futuramente ele deverá atender às famílias
Motorola 68HC08 Microchip PIC16 e PIC18. Maiores informações, bem como os arquivos e
manuais para cópia podem ser obtidos na página http://sdcc.sourceforge.net/.
Para facilitar o aprendizado da geração de programas em linguagem C para a Placa
Experimental do 8051 encontra-se disponível no Apêndice II uma estrutura-exemplo de programa,
visando fornecer material inicial para ilustrar o roteiro de geração de código executável, destacando
as particularidades de cada um dos pacotes citados. Ela é baseada no uso das rotinas de escrita no
display [12], desenvolvidas na experiência correspondente. Tal estrutura deve ser completada com
as soluções específicas adotadas por cada grupo na escrita no display. Esse roteiro deverá ser
utilizado também nas demais experiências.
4.1 Compilação de programas
a) Editar, compilar, ligar/alocar, carregar e testar um programa em C baseado na estrutura-exemplo
apresentada no Apêndice II, que escreva PCS2497 no “display”. Explicar no relatório como os
parâmetros das rotinas são passados e acessados (para facilitar, avalie o código gerado pelo
compilador em linguagem assembly).
b) Repetir o item a), substituindo a rotina “delay ( )” por instruções em linguagem assembly, dentro
da linguagem C: consultar o manual do SDCC [01], página 39, comandos “_asm” e “_endasm”.
Verificar a possibilidade de utilização de alguma opção de visualização das instruções em
linguagem assembly, geradas pelo compilador. Tente substituir a rotina “delay ()” por uma
escrita em linguagem assembly em um arquivo *.asm separado.
4.2 Elaboração de rotinas básicas e programas
Como forma de direcionar a familiarização com o novo ambiente de
desenvolvimento e facilitar futuras tarefas de depuração, rotinas úteis para teste de programas são
apresentadas no Apêndice III. Algumas se encontram escritas em linguagem assembly. Sugestões
em linguagem C podem ser encontradas. Sugere-se que seja feito um bom estudo sobre o uso de
ponteiros em linguagem C, e como eles podem ser implementados no SDCC (por exemplo,
ponteiros podem ser alocados na memória interna, externa, etc). Avaliar, comentar e testar cada
uma delas, efetuando eventuais correções ou melhorias:
a) Testar as rotinas CRLF, CO, CHEX e PRINT (duas versões) em linguagem C, observando a
passagem de parâmetro (o que significa *dado ?). Estudar as formas de ponteiro da linguagem
C previstas no SDCC, resumindo-as no relatório.

5 Laboratório de Processadores-I - Experiência 6
b) Testar as rotinas CI e GETHEX, obtendo o valor lido por parâmetro de retorno. Testar o
funcionamento da rotina obtendo do terminal alguma informação, que deve ser devolvida ao
terminal através das rotinas testadas no item a).
c) Testar as rotinas COPY e FILL, com os parâmetros correspondentes.
d) Utilizando as rotinas testadas, elaborar um programa que continuamente faça (loop infinito):
• apresente no terminal os valores das posições de memória 0x9000 a 0x900F, solicite a
digitação no terminal de um valor 0xnn para preencher as mesmas posições, e após essa
operação, apresente novamente no terminal as posições com os novos valores. Exemplo:
supondo que as posições apresentem os valores de 0x00 a 0x0f, e que seja digitado 0x55, as
mensagens a serem apresentadas no vídeo são:
• Programa de preenchimento de memoria:
9000 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
Digite o valor de preenchimento (nnh):55
9000 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55
Digite o valor de preenchimento (nnh):
...
4.3 Procedimento de Projeto e Elaboração do Planejamento
As rotinas e os programas devem obrigatoriamente incorporar os seguintes itens:
1. Descrição do projeto, relacionando suas características principais e as entradas e saídas.
2. Especificação do programa com diagramas estruturados de todos os módulos envolvidos,
que podem ser desenhados manualmente ou com o auxílio de programas de computador.
3. Detalhamento de módulos e rotinas através de diagramas estruturados. Os módulos de
operações devem ser necessariamente separados para permitir a troca e inclusão de novas
operações apenas com a troca do módulo correspondente.
4. Implementação dos módulos e rotinas, inclusive a de testes apresentadas nos Apêndice III e
IV, com a descrição detalhada. Se necessário, faça comentário em cada linha do código.
5. Integração dos módulos e rotinas e elaboração do programa principal.
6. Teste do programa e avaliação dos resultados.
O planejamento deve possuir todos os itens acima, ser elaborado segundo moldes de um projeto de
software apresentados em [4] (sugere-se a leitura dos capítulos 13 a 16; alguns exemplares deste
livro estão disponíveis no laboratório para consulta) e [7], e deve possuir também um roteiro

6 Laboratório de Processadores-I - Experiência 6
adequado das atividades a serem desenvolvidas em aula, envolvendo a seqüência de testes
apropriada.
4.4 Opcional
a) Sugira outras rotinas que poderiam ser de interesse à depuração. Implemente-as e teste-as.
Observação:
As rotinas apresentadas no Apêndice III são úteis para a depuração de programas. Sugere-se
fortemente que elas sejam utilizadas nas demais experiências.
5. BIBLIOGRAFIA
[1] SDCC - Small Device C Compiler, http://sdcc.sourceforge.net/ /cópias do compilador e manual
disponíveis no site e em cada bancada/
[2] ANDRADE, M.T.C.; Cugnasca, C.E.; HIRAKAWA, A.R.; Apostila da Experiência
LINGUAGEM DE ALTO NÍVEL “C” PARA 8051 E GRAVAÇÃO de programas em
EPROM, Disciplina PCS 597 - Laboratório de Microprocessadores I, 2001.
[3] CUGNASCA, C.E.; ZERBINI, R.C.; Apostila da Experiência Desenvolvimento de Programas
em Linguagem de Alto Nível “C”, Disciplina PCS 599 - Laboratório de
Microprocessadores, 1995.
[4] LEVENTHAL, L.A. 8080A-8085 ASSEMBLY LANGUAGE PROGRAMMING. McGraw-
Hill. 1986. /cópias disponíveis no laboratório/
[5] KERNIGHAN, B.W.; RITCHIE, D.M.C. A Linguagem de Programação. Padrão ANSI. Rio de
Janeiro, Editora Campus, 1990. 289p.
[6] CUGNASCA, C. E. Linguagem PL/M. Apostila FDTE, São Paulo, 1986.
[7] PRESSMAN R.S. Engenharia de Software, Makron Books, 1995.
[8] PHILIPS; 80C51-Based 8-Bit Microcontrollers – Data Handbook IC20, Philips Electronics
North America Corporation, USA, 1997.
[9] PHILIPS; Application Notes and Development Tools for 80C51 – Data Handbook, Philips
Electronics North America Corporation, USA, 1997.
[10] CUGNASCA, C.E.; HIRAKAWA, A.R. Apostila da Experiência Interface com Teclado e
Display, Disciplina PCS 2497 - Laboratório de Processadores I, 2007.
[11] MATSUNAGA, A.M.; TSUGAWA, M.O. Sistema de Pesagem Dinâmica. Projeto de
Formatura (disciplina PCS-588). Escola Politécnica da USP, 1997.
[12] ALFACOM; Módulos Multi-Matrix – Manual de Utilização.
[13] MC8051 – Diagrama Lógico da Placa Experimental do 8051.
[14] EasyCODE(SPX). Programa para a Edição de Diagramas Estruturados da Siemens.
http://www.easycode.de/de/faq.htm
[15] SFC - A Structured Flow Chart Editor. Programa para a Edição de Fluxogramas.
http://www.cs.sonoma.edu/~tiawatts/SFC/

7 Laboratório de Processadores-I - Experiência 6
APÊNDICE I – ALGUMAS CARACTERÍSTICAS DO SMALL DEVICE C COMPILER
Recomenda-se a leitura atenta do manual desse compilador. A seguir, serão
apresentadas algumas informações de interesse ao programador. Maiores informações, bem como o
manual do compilador podem ser obtidos em http://sdcc.sourceforge.net/.
a) Declarações.
A seguir são apresentadas algumas recomendações para seu uso.
Para especificar áreas de memória utilizar at. Exemplo: definição da variável var na posição
98H da área SRF do 80C51,
unsigned char far at 0x98 var;
b) Uso de Linguagem Assembly dentro da Linguagem C.
Embora possível, não é recomendável, pelos efeitos colaterais que pode causar (por exemplo,
alteração de valores de registradores que o compilador também utiliza).
_asm
_endasm;
Observação: o ; da última instrução não pode ser esquecido, bem como o símbolo _.
c) Chamada do Compilador.
Utilizar o comando SDCC em uma janela DOS, colocando-se as informações de alocação na
mesma linha. Exemplo: compilação do programa progr.c, alocando a área de código em
A000H e a área de dados em 8000H.
c:>sdcc –-code-loc 0xA000 --xram-loc 0x8000 progr.c
d) Passagem de Parâmetros em Subrotinas.
seguintes registradores:
O primeiro parâmetro, de acordo com o seu tamanho (em bytes) é passado pelos
- 1 o . byte: DPL
- 2 o . byte: DPH
- 3 o . byte: B
- 4 o . byte: A
Do segundo em diante, caso a subrotina seja não reentrante, os parâmetros são
passados pela memória; em caso de subrotinas reeentrates, pela pilha (para maiores detalhes,
consultar documentação do SDCC).

8 Laboratório de Processadores-I - Experiência 6
e) Declaração de uma Função Escrita em Linguagem Assembly Presente em um Arquivo
Externo.
Exemplo: rotina no arquivo rot.asm:
extern tipo_retorno nome_função (tipo_parametro1, tipo_parametro2, ...);
Os nomes dos parâmetros não devem ser passados.
Deve ser declarado que a rotina é de uso global e que o código é relocável. Exemplo:
.globl _delay
.área CSEG
_delay: ...
RET
Observação: não se utiliza a pseudo-instrução END.
Deve-se primeiramente chamar o montador para gerar o código da função, e depois o compilador
para gerar o código do programa que invoca a função e ligá-lo com o código deste. Exemplo:
c:>asx8051 –losg rot.asm
gera o arquivo rot.rel
c:>sdcc –-code-loc 0xA000 --xram-loc 0x8000 progr.c rot.rel
• a opção –-code-loc 0xA000 aloca o código a partir do endereço A000H.
• a opção --xram-loc 0x8000 aloca a área de variáveis externas a partir do endereço
8000H.
• além do rot.rel outros arquivos relocáveis escritos na linguagem assembly/C que já
foram montados/compilados poderiam ser acrescentados (inclusive bibliotecas prontas ou
criadas pelo usuário); ele será ligado ao programa progr.c que está sendo compilado
através deste comando, e o resultado será alocado, gerando o programa absoluto
progr.ihx no formato hexadecimal Intel (a ser transferido para aplaca experimental);
outros arquivos .rel poderiam ser colocados neste comando, sendo que o primeiro da
lista (no caso progr.c deve necessariamente conter o main).

9 Laboratório de Processadores-I - Experiência 6
APÊNDICE II - ESTRUTURA-EXEMPLO EM LINGUAGEM C
Editar o programa abaixo no modo texto sem formatação (por exemplo, Bloco de
Notas do Windows). Após o último símbolo da última linha digitar ENTER.
/************************************************************************
* PCS-2497 PROGRAMA EM C SDCC *
************************************************************************
* Este programa deve mostrar a mensagem "PCS2497" no display. *
************************************************************************/
#define WDATA 0x2010 /* Posicao de escrita de dados no display */
#define RDATA 0x2030 /* Posicao de leitura de dados do display */
#define WCOMMAND 0x2000 /* Posicao de escrita de comandos no display */
#define RSTATUS 0x2020 /* Posicao de leitura de estado do display */
unsigned char far at @WDATA wdata;
unsigned char far at @RDATA rdata;
unsigned char far at @WCOMMAND wcommand;
unsigned char far at @RSTATUS rstatus;
/* Rotina de espera de tempo */
void delay (int tempo) {
int i,j;
for (i=tempo;i>0;i--) {
for (j=50;j>0;j--) {
};
};
}
/* Rotina que envia comandos ao display */
void displaycommand (int cmd) {
delay (2);
wcommand = cmd;
}
/* Rotina que envia um caractere ao display */
void displaydata (int car){
/* Testa Busy Flag antes de escrever */
_asm
BUSY: MOV DPTR,#_rstatus
MOVX A,@DPTR
ANL A,#0x80
JNZ BUSY
_endasm;
}
wdata = car;
/* Rotina que programa o display */
void progrdisplay (void){
displaycommand (0x38); /* 2 linhas 5x7 */
displaycommand (0x0C); /* sem cursor */
displaycommand (0x06); /* escreve deslocando para a direita */
}

10 Laboratório de Processadores-I - Experiência 6
/* Rotina que limpa o display */
void cleardisplay (void) {
displaycommand (0x01);
}
/* Rotina que seleciona a linha do display que será escrita */
void line (int lin) { /* seleciona a linha do display */
if (lin==1) displaycommand (0x80); /* desloca cursor 1a.lin e 1a.col */
else displaycommand (0xC0); /* desloca cursor 2a.lin e 1a.col */
}
/* Inicio do programa */
main()
{
progrdisplay(); /* programa display */
line(1); /* seleciona linha 1 do display */
cleardisplay(); /* limpa display */
/* envia PCS2497 ao display */
displaydata (0x50);
displaydata (0x43);
displaydata (0x53);
displaydata (0x32);
displaydata (0x34);
displaydata (0x39);
displaydata (0x37);
while (1) {}; /* loop infinito */
}

11 Laboratório de Processadores-I - Experiência 6
APÊNDICE III – ROTINAS-EXEMPLO PARA UTILIZAÇÃO EM TESTES
1) Rotina para envio de um caractere ao terminal de video:
Sugestão em linguagem assembly:
; Rotina para envio de caractere ao terminal
; Parametros:
; entrada: o valor do Reg. B e' enviado ao terminal através do canal serial
;
CO: JNB TI,$ ; verifica o estado de transmissão do canal serial
; caso seja=0 (canal ocupado) pula para ele mesmo
CLR TI ; indica que o canal de transmissão esta´ ocupado
MOV SBUF,B ; envia caractere
JNB TI,$ ; espera o envio
RET ;
Sugestão em linguagem C:
/* Rotina para envio de caractere ao terminal */
void CO (unsigned char dado){
while (TI==0){}; /* ou while (!TI){} */
TI=0;
SBUF=dado;
while (TI==0){}; /* ou while (!TI){} */
}
2) Rotina para voltar para a 1a. coluna do terminal de vídeo, e pular linha:
Sugestão em linguagem C:
/* Rotina para voltar para a 1 a . coluna do terminal de video e pular uma linha*/
void CRLF(){
CO (0x0D);
CO (0x0A);
}
3) Rotina para imprimir um string ASCII no terminal. Fim de string 0x00:
Sugestão em linguagem assembly:
; Rotina para impressao de mensagem no terminal de video
; Parametros:
; entrada: DPTR – aponta para o 1o. dado a ser enviado ao terminal de video
: a sequencia deve ser terminada em 0x00
;
PRINT: MOV A,#00H ;
MOVC A,@A+DPTR ;
JZ PFIM ;
MOV B,A ;
ACALL CO ;
INC DPTR ;
SJMP PRINT ;
PFIM: RET ;
1a. Sugestão em linguagem C:
/* Rotina para imprimir um string ASCII no terminal. Fim de string 0x00 */
/* Parâmetro: endereco inicial do conjunto de caracteres */
void PRINT(unsigned char *dado){
while ((*dado)!=0x00{
CO (*dado);
dado=dado++;
}

12 Laboratório de Processadores-I - Experiência 6
2a. Sugestão em linguagem C:
/* Rotina para imprimir um string ASCII no terminal. Fim de string 0x00 */
/* Parâmetro: endereco inicial do conjunto de caracteres */
/* xdata unsigned char: o dado e´ armazenado na RAM externa */
/* *xdata pont: o ponteiro para os dados e´ armazenado na RAM externa */
void PRINT(xdata unsigned char *xdata pont){
dado=*pont;
unsigned char dado;
while (dado!=0x00){
dado=*pont;
CO (dado);
pont=pont+1);
}
}
4) Rotina que recebe um caractere ASCII do terminal de vídeo:
Sugestão em linguagem assembly:
; Rotina para recebe um caractere ASCII do terminal de video
; Parametros:
; saida: registrador A - valor do caractere
;
CI: JNB RI,$ ; verifica se o canal serial possui um dado
; caso seja=0 (sem dados) pula para ele mesmo
CLR RI ; indica que o dado foi lido
MOV A,SBUF ; le dado
RET ;
Sugestão em linguagem C:
/* Rotina para recebe um caractere ASCII do terminal de video */
char CI (void){
while (RI==0){}; /* ou while (!RI){} */
RI=0;
return SBUF;
}
5) Rotina que envia um byte hexadecimal ao terminal de vídeo – [0xAB] ASCII (A) ASCII (B):
Sugestão em linguagem C:
/* Rotina que envia um caractere ASCII do terminal de video */
void CHEX (unsigned char dado){
unsigned char aux;
aux=dado/0x10; /* desloca 4 bits para a direita - dado AB: pega 0x0A */
if (aux

13 Laboratório de Processadores-I - Experiência 6
6) Rotina que recebe um byte hexadecimal ao terminal de vídeo – ASCII (A) ASCII (B) [0xAB]:
Sugestão em linguagem C:
/* Rotina que recebe um caractere ASCII ao terminal de video */
unsigned char GETHEX (){
int i;
unsigned char dado;
unsigned char vetordados[2];
for (i=0;i