Aula 3 8051 (software)

Prévia do material em texto

*
*
8051 – Software ( Assembly ) 
Sistemas Microprocessados
Prof. Dr. Remy Eskinazi
Prof. Henrique Figueirôa
*
*
*
Apostilas em PDF :
Microcontrolador 8051(UFG).pdf
	prof.José Wilson Lima Nery
	Escola de Engenharia Elétrica e de Computação – UFG
Microcontroladores e 8051.pdf
	prof.Vitor Leão Filardi
	Faculdade de Ciencia e Tecnologia
Software para Simulação :
Simulador EDSIM
Livros (sugestão para consultas) :
Aplicações Práticas do Microcontrolador 8051. 
	Vidal Pereira da Silva Editora Erica, 1998. 
Microcontrolador 8051 Detalhado. 
	Denys E.C. Nicolosi - Editora _Erica, 2000.
Microcontroladores 8051
	GIMENEZ, S. P. - Editora Pearson Education do Brasil, 2002 
8051 – Software ( Assembly ) 
Recursos Didáticos
*
*
*
*
Revisão: Alguns Registradores Importantes
A
B
R0
R1
R2
R3
R4
R5
R6
R7
DPH
PC
DPL
SP
7F
00
08
10
18
20
30
Scratch Pad Area
RAM
Bit Addressable RAM
Bank 3
Bank 2
Bank 1
Bank 0
R0
R7
R0
R7
R0
R7
R0
R7
User & Stack
*
*
*
		Software do 8051
	111 Instruções
	Classificação das Instruções
 Tamanho ( nr. de bytes )
 Modos de Endereçamento
 Tipo de Instrução
*
*
*
		Software do 8051
Classificação por Tamanho ( nr. de Bytes )
1 - Um Byte ( inclui o Opcode e o Operando no mesmo Byte )
Mnemônico 	Código (Hexa)	Descrição	
ADD A,R0	 28h	; soma o conteúdo do Registrador R0 com o Acumu-
			; lador e o resultado é armazenado no Acumulador.
2 - Dois Bytes ( Opcode encontra-se no primeiro Byte e o Operando no segundo )
Mnemônico 	Código (Hexa)	Descrição	
MOV A,#3Fh	74h (Byte 1)	; carrega no Acumulador o valor 3Fh.
		3Fh (Byte 2)
3 - Três Bytes ( Opcode encontra-se no primeiro Byte e os Bytes seguintes ou são dois Operandos ou um endereço de Memória com 16 bits )
Mnemônico 	Código (Hexa)	Descrição	
ORL 33h,#3Fh	43h (Byte 1)	; efetua operação “OU” entre o valor 3Fh e
		33h (Byte 2)	;o conteúdo do endereço 33h da Memória. 			3Fh (Byte 3)	;O resultado é armazenado neste endereço.
*
*
*
		Software do 8051
Classificação por Modos de Endereçamento
	Define de que forma os dados são referenciados nas Instruções.
*
*
*
		Software do 8051
Classificação por Modos de Endereçamento
*
*
*
*
Movimentação de Dados
Aritméticas
Lógicas
Manipulação de Bit
Controle de programa (Saltos e Desvios)
		Software do 8051
Classificação por Tipo de Instruções
*
*
*
Software do 8051 
(Linguagem Assembly )
Em seguida, apresentamos as principais instruções. 
Consulte o conjunto completo nos materiais enviados em formato PDF.
*
*
*
Instruções 8051 – Movimentação de Dados
mov a,Direto  Cópia no Acumulador o conteúdo do Endereço Direto
*
*
*
Instruções 8051 – Movimentação de Dados
Movimentação com a Memória de Programas
Movimentação com a Memória de Dados Externa
MOVX A,@Ri  Carrega no Acc uma cópia do conteúdo do endereço ( de 8 bits ), da 		Memória Externa de Dados, apontada por Ri ( só R1 ou R0 ).
MOVX @DPTR,A  Carrega no endereço (de 16 bits), da Memória Externa de Dados, 			 apontada por DPTR, uma cópia do conteúdo do Acumulador.
( só R1 ou R0 )
*
*
*
Instruções 8051 – Aritméticas
ADD A,#dado  Soma número ao Acumulador e o resultado permanece neste.
	Exemplo :	add a,#32h ou add a,#0F1h
ADDC A,Rn  Acumulador <= Acumulador + Rn + bit da Carry
SUBB A,Rn  Acumulador <= Acumulador - Rn - Carry
ADD A,direto  Acumulador <= Acumulador + conteúdo do endereço RAM interna 
Exemplo : ADD A,07h	
	se Acc=08h(antes) e RAM(end.07h)=03h  Acc = 0Bh (após a instrução)
INC A  Acumulador <= Acumulador + 1 ( idem Direto,Rn,@Rn e @DPTR ) 
DEC Rn  RegistradorN <= RegistradorN - 1 ( idem Direto,Acc,@Rn e @DPTR ) 
MUL AB  Multiplica A e B  resultado = B (parte mais significativa) e Acumulador (parte menos significativa )
DIV AB  Divide A e B  resultado = Acc (quociente parte inteira) e B (resto)
SUBB A,#dado  Acumulador <= Acumulador – dado - Carry
DA A  Ajuste decimal do Acumulador ( usado na conversão BCD ).
*
*
*
Instruções 8051 
Exemplo : programa simples
Soma de dois números de 1 Byte cada:
 	Carrega o Acc (Acumulador) com 04 (hex).
 Carrega o registrador R0 com 05 (hex).
 Soma os dois números. 
 Enviar o resultado para a Porta P1.(*)
 Fim
(*)No Simulador EDSIM, P1 aciona o Painel de Display de 7-segmentos.
*
*
*
Instruções 8051 
Exemplo : programa simples
Mnemônicos	Código(hexa)	End(ROM)	Nr.Bytes		Pulsos(Clock)
 MOV A,#04h	 74		 0000h		 2 12
		 04		 0001h
 MOV R0,#05h	 78		 0002h		 2		 12
		 05		 0003h
 ADD A, R0	 28		 0004h		 1		 12
 MOV P1,A	 F5		 0005h		 2		 12
		 90 (*)	 0006h
 SJMP $	 	 80 (**)	 0007h		2		 24
		 FE		 0008h				
	Ver prg_01(Soma_2N_1Byte).asm no EDSIM.
(*) 90h é o end. na RAM (interna) ref. a P1. Assim, pode-se escrever : MOV 90h,A
(**) Força uma parada no PC e, portanto, na execução do programa. 
*
*
*
Instruções 8051 – Lógicas
ANL A,#0Fh  Acc <= Acc ( AND ) 0Fh
	se Acc=35h(antes)  Acc = 05h (após a instrução)
CRL A  Acumulador <= Zero
ORL A,0Fh  Acumulador <= Acumulador ( OR ) conteúdo do end.0Fh da RAM int. 
	se Acc=20h(antes) e RAM(end.07h)=08h  Acc = 28h (após a instrução)
CPL A  Inverte todos os bits do Acumulador
*
*
*
Instruções 8051 – Manipulação de Bits
*
*
*
Instruções 8051 – Manipulação de Bits
Desvios Condicionais
PCatual é somado ou subtraído de “rel” ( de +128 até –127 ).Bit 7 de rel define o sinal. 
*
*
*
Instruções 8051 – Controle ou Fluxo de Execução ( Saltos e Desvios )
 Compara e Salta
	CJNE	A, #, rel		Compara o 1o operando com o 2o e
		A, D, rel 	desvia para “rel” se forem diferentes.
		R, #, rel 	
		@R,#, rel	
	 			
 Decrementa e Salta
	DJNZ	Rn, rel	 	 Decrementa Rn e, em seguida, desvia				 	se não der zero.
		Direto,rel 	  Idem para endereço Direto.
*
*
*
 Subrotinas (Chamadas de Funções)
	ACALL	end. de 11 bits ou Label	  Absolute Call - 11 bits (2K)
	LCALL	 end. de 16 bits ou Label 	  Long Call - 16 bits (64K)
	RET		  	Retorno de Subrotina	
	RETI		  	Retorno de Interrupção
Instruções 8051 – Controle ( Saltos e Desvios )
NOP		  	Nenhuma operação é executada.
(Short Jump)endereço relativo (ao PC atual) ou Label.
*
*
*
Linguagem Assembly do 8085
Declarações em Assembly poderão conter até 4 campos 
	Label	Opcode	 Operando	Comentário
	Início:	MOV	A,# 20		;Carrega Acumulador com 20(decimal)
Programa que gera uma Tabela de 0 a 9 na RAM a partir do endereço 30h
	Inicio :	MOV A,#00h	;Inicialização do Acumulador e de R0 que será
			MOV R0,#30h	; usado como Ponteiro.
	Armazena : 	MOV @R0,A	;Armazena Dado na célula da Tabela.	
	Incrementa: 	INC A		;Incrementa Dado.
		 	INC R0		;Incrementa Ponteiro. 
	Verifica :	CJNE R0,#3Ah,Armazena	;Verifica se preencheu toda a Tabela.
	Fim :		SJMP $			;parada
O uso do Label organiza o Programa em trechos e facilita o endereçamento dos desvios.
	Ver prg_02(Gera_Tabela).asm no EDSIM e
Iniciar Aula Prática 01
*
*
*
Processo de Desenvolvimento de um Programa em Assembly
Arquivo-Fonte em Linguagem Assembly ( linguagem de Montagem)- extensão .asm ( Editável )
Library -biblioteca de Macrofunções
Linker Script (alocação de RAM e ROM)
Arquivo-Objeto – Linguagem de Máquina ( arquivo binário intermediário ) extensão .obj 
Arquivo executável - extensão .exe pronto para gravação na ROM.
Assembler
Assembler – programa utilitário Montador-gera a codificação de um-para -um da instrução em Assembly p/ a linguagem de máquina (binário). 
Código Objeto de outros pro- gramas.
Macrofunções- trechos repetidos do código ou elaborado por terceiros (biblioteca), simplificando a programação(chamada de Macros).
Linker
*
*
*
Ferramentas para Desenvolvimento de Programas emAssembly
Assembler
programa que faz a tradução para linguagem de máquina
Assembly  Código binário (objeto)
Linker
Liga vários arquivos objeto, gerando um único executável
Cada µp tem seu próprio Assembler
	Programa em assembly para um microprocessador não é transferível (executável) para outro de arquitetura diferente
Cross-Assembler
Assembler que é executado em um determinado o processador para gerar a Linguagem de Máquina para um outro processador.
Uso no desenvolvimento de aplicações embarcadas onde o processador-alvo possui pouca capacidade de armazenamento/processamento para suportar um software de desenvolvimento (muitas vezes,incluindo um Compilador).
*
*
*
Introdução a Linguagem de Programação
Cada µp tem suas próprias palavras (Opcodes ), significados e linguagem
Tamanho dos Opcodes – nº de bits que o µp reconhece e processa de cada vez.
Opcodes são formados pelas várias combinações desses bits
8051: 111 instruções básicas que geram diversos opcodes.
		ex. : MOV A,Rn  MOV A,R0 ou MOV A,R1 , etc.
Projetista da CPU cria instruções:
seleciona combinações de padrões de bits
Atribui um significado especifico para cada combinação
A Unidade de Controle, interna à CPU, aciona os blocos internos/externos necessários à execução de cada instrução.
Cada µp tem seu próprio conjunto de instruções(intruction set)
. Programa em assembly para um microprocessador não é transferível (executável) para outro de arquitetura diferente.
*
*
*
Linguagem de Alto Nível
Linguagem (textual-próxima à linguagem humana) na qual o programador não precisa conhecer os detalhes da execução no hardware;uma vez que, não está associada a nenhum microprocessador, especificamente.
Ex. : C, C++, Pascal , Java, etc
Compilador- programa que transforma o programa em Alto Nível na Linguagem de Máquina específica do microprocessador. Ex.: Compilador da Linguagem “C” para o 8051.
*
*
*
Assembly x Linguagem de Alto Nível
Linguagem de Alto Nível
Linguagem textual (mais familiar) facilitando o desenvolvimento dos programas.
Não exige conhecimento do Hardware.
Portáveis (independe do Hardware).Os programas gerados “rodam” em processadores diversos.
Bibliotecas de Domínio Público.
Desvantagem : Consomem muita memória e baixo desempenho (velocidade baixa de execução) .
Assembly 
Arquivo final dos programas são bem menores.
Requerem menos memória.
Maior velocidade de execução(otimizados para aquela arquitetura-alvo).
Aplicações em Sistemas Embarcados.
Desvantagem : desenvolvimento passo-a-passo das operações (trabalhoso) e exige conhecimento do hardware.
*
*
*
*
Diretivas do Assembler (de Montagem) do 8051
Pseudo instruções 
Permitem definir símbolos	 (Em C: #define PI 3.14)
Simplificam o desenvolvimento e as futuras modificações dos programas.
É possível dividir o programa em blocos, estabelecendo endereços específicos para cada um deles.
Reservar áreas de memória para Variáveis globais, Dados e Tabelas.
Não fazem parte do conjunto de instruções (instruction set).
Não geram código binário
*
*
*
*
Diretivas do Assembler do 8051
Diretiva ORG (Origin)
Através do ORG é possível definir em que endereço ( da ROM) o Assembler ( Montador ) colocará :
A instrução inicial do programa;
Outros trechos do código ( ex.: subrotinas )
Um Dado( de uso geral ) ou uma Tabela.
- Um programa poderá conter várias diretivas ORG
Exemplo :
org 30h
Mov sp,#2fh	;O Assembler colocará esta instrução no endereço
		;30h da ROM.
*
*
*
*
Diretivas do Assembler do 8051
Diretiva DB (Define Byte)
Permite reservar áreas de memória ROM e identifica-las com um NOME. A partir daí, o NOME passa a ser reconhecido com um ENDEREÇO. 
Informa ao Assembler que o Byte a seguir é uma Dado e não uma Instrução.
Sintaxe :	<nome> DB <valor inicial>
<nome> torna-se um sinônimo para o endereço do 1º byte reservado
É possível atribuir valores iniciais e criar Tabelas:
V1 DB	200	; cria um Dado de 1 byte c/ valor 200
V2 DB 1,2,3	; cria um Dado de 3 bytes (ou uma Tabela)
P1 DB “MIC”	; cria uma string, ocupando 3 bytes
Memória: 4DH, 49H e 43H (Tabela ASCII )
A escolha desse endereço: pelo programador (uso do ORG) ou pelo Assembler
*
*
*
*
Diretiva EQU (Equate)
Permite associar um NOME a um VALOR. 
Sintaxe :	<NOME> EQU <valor>
Exemplo :
LIMITE EQU 0FFH	; permite utilizar o símbolo LIMITE em qualquer parte 				;do programa
MOV A,#LIMITE	;O Acumulador é “carregado” com o valor FFh.
O uso da Diretiva EQU é altamente recomendável:
Aumenta a qualidade do programa: facilita entendimento
Facilita a manutenção se o valor precisar ser modificado. Basta alterar a linha da diretiva.
O VALOR poderá ser uma constante (exemplo acima) ou um endereço da RAM. Neste caso, NOME passa a ser usado como uma variável.
Exemplo :
		SOMA equ 07h 	;cria o símbolo SOMA, que será usado como uma Variável, a qual armazenará,
				;no endereço 07h da RAM, o resultado de uma adição.
		ADD A,R1
		MOV SOMA,A	;o resultado da soma será armazenado no endereço 07h da RAM.
Diretivas do Assembler do 8051
*
*
*
*
Diretiva END
Indica o fim do programa-fonte ao Assembler
O Assembler ignora qualquer linha após a diretiva
Diretivas do Assembler do 8051
*
*
*
Estrutura do Programa ( uso das Diretivas do Assembler do 8051)
Definição NOMES
uso de EQU
Criação de Dados/Tabelas na ROM	uso de ORG e DB
Início do programa
uso de ORG
Sub-rotinas
uso de ORG
*
*
*
*
Diretivas do Assembler do 8051
A seguir, alguns exemplos de Programas que exploram o uso de:
 Labels 
 Diretivas do Assembler.
*
*
*
;***************************************************************
;PROGRAMA 01 :	USO DAS DIRETIVAS DO 8051
;***************************************************************
Nomes :		;Declaração de nomes para Constantes, Variáveis, Parâmetros, etc. 
 
CONST equ 	05h	;cria o símbolo CONST com valor 05h, o qual poderá ser utilizado como
			;uma constante, em qualquer parte do programa.
SOMA 	 equ 	07h 	;cria o símbolo SOMA, o qual será usado como uma Variável que irá
			;armazenar ( no end.07h da RAM) o resultado de uma adição. A variável
			;SOMA, também, poderá ser utilizado em qualquer parte do programa.
;----------------------------------------------------------------------------------
Dados_Tabelas :  
org 0020h		;Definição do endereço para Dados e Tabelas.
	N1: DB 03		;cria o dado N1, no endereço 0020h,com o valor inicial a 03(decimal).
						
	N2: DB 10h,0Fh 	;cria o dado N2 ( de 2 bytes),nos endereços 0021h e 0022h,com o valores
			;iniciais, respectivamente, iguais a 10h (16 em decimal) e 0Fh (decimal 15).
 LEDcodes:		;Cria uma Tabela para o código de acendimento dos LEDs nos Displays de
			;7-segmentos acionados através da Porta P1.
DB 11000000B, 11111001B, 10100100B, 10110000B, 10011001B, 10010010B, 10000010B, 11111000B, 10000000B, 10010000B
;-----------------------------------------------------------------------------------
org 0000h
Inicio:
	mov a,#00h		;"zera" o Acumulador.
	mov DPTR,#N1		;carrega o ponteiro de Memória (ROM) com o endereço 0020h.
	movc a,@a+DPTR	;move o conteúdo de N1 para o Acumulador.
	mov R1,#CONST	;move o valor de CONST ( equivalente a 05h) p/ o registrador R1.
Somar:
	add a,R1		;soma o conteúdo de N1 com o valor da constante (CONST).
			;O resultado permanece no Acumulador.
Armazena:
	mov SOMA,a		;armazena no endereço 07h da RAM, o resultado da soma ,na variável SOMA.
Display :
	mov a,#00h		;"zera" o Acumulador.
	mov DPTR,#LEDcodes	;carrega o ponteiro da ROM com o endereço da Tabela dos LEDs.
	movc a,@a+DPTR	;soma o valor do endereço inicial da Tabela dos LEDs com o valor do Acumulador para 
			;localizar o código binário de acionamento dos LEDs.	
	mov P1,a		;transfere o código para o acionamento dos segmentos do Display na porta P1.		
Fim :	SJMP $		;parada
end 
Ver programa prog_3(Diretivas).asm*
*
*
;***************************************************************
;PROGRAMA 2 :	USO DAS DIRETIVAS DO 8051
;***************************************************************
Nomes :		;Declaração de nomes para Constantes, Variáveis, Parâmetros, etc. 
 
SOMA 	 equ 	07h 	;cria o símbolo SOMA que será usado como uma Variável que irá
			;armazenar ( no end.07h da RAM) do resultado de uma adição.
SUBTR	 equ	09h	;idem para uma subtração, cujo resultado será armazenado no end.09h.
;----------------------------------------------------------------------------------
Dados_Tabelas : 
 
org 0030h		;Definição do endereço para Dados e Tabelas.
Dado1: DB 12h		;cria o Dado1, no endereço 0030h da ROM,com o valor inicial 12h.
Dado2: DB 14h,0Fh	;cria Dado2 ( de 2 bytes) nos endereços 0031h e 0032h, da ROM.
;-----------------------------------------------------------------------------------
org 0000h
Inicio:
	mov a,#00h		;"zera" o Acumulador.
	mov DPTR,#Dado1	;carrega o ponteiro da ROM com o endereço de Dado1
			;( end.0030h da ROM).
	movc a,@a+DPTR	;;move o conteúdo de Dado1 para o Acumulador.
	mov R1,a		;guarda o conteúdo de Dado1 em R1.
Subtracao:
	mov a,#00h		;"zera" o Acumulador.
	mov DPTR,#Dado2	;carrega o ponteiro da ROM com o endereço do primeiro byte
			;de Dado2 ( end. 0031h da ROM).
	movc a,@a+DPTR	;move o conteúdo de Dado2 para o Acumulador.
	subb a,R1		;subtrai o conteúdo do Acumulador ( byte1 de Dado2 )de Dado1.
			;O resultado permanece no Acumulador.
	mov SUBTR,a	;armazena na RAM, no endereço 09h, o resultado da subtração na variável SUBTR.
Somar:
	mov a,#00h		;”zera” o Acumulador.
	inc DPTR 		;incrementa o ponteiro.
	movc a,@a+DPTR	;move o conteúdo do byte 2 de Dado2 para o Acumulador.
	add a,SUBTR		;soma o segundo byte de Dado2 com o resultado da subtração
			;(variável SUBTR) armazenado na RAM.
	mov SOMA,a		;armazena na RAM, no endereço 07h, o resultado da soma na variável SOMA.	
Fim :	SJMP $		;parada
END 
Ver programa prog_4(Diretivas).asm
*
*
*
;****************************************
;PROGRAMA 3 :	Conversor BCD até 99
;****************************************
;Este programa converte o valor binário no Acumulador em dois caracteres
;decimais para armazenamento ou apresentação em dois displays. 
Nomes :		 
Unidade	equ 	40h 	;Variável que irá armazenar a parte da Unidade, após a conversão.	
Dezena	equ	41h	;Variável que irá armazenar a parte da Dezena.
;----------------------------------------------------------------------------------
Dados_Tabelas : 
 
org 0030h		;Definição do endereço para Dados e Tabelas. 
	Dado:	DB 1Ah	;cria Dado, no end. 0030h da ROM,com o valor inicial 1Ah.
;-----------------------------------------------------------------------------------
org 0000h
Inicio:
	mov a,#00h		;"zera" o Acc.
	mov DPTR,#Dado	;carrega o ponteiro da ROM com o endereço de Dado
	movc a,@a+DPTR	;move o conteúdo de Dado para o Acumulador.
	mov R1,a		;guarda o Dado em R1.
	mov a,#00h		
Loop:
	inc a		;incrementa Acc
	da a		;ajuste BCD do Acc			
	djnz R1,Loop
	mov R1,a
	anl a,#0Fh		;isola a parte baixa, referente à Unidade.
	mov Unidade,a	;armazena a Unidade no endereço 40h da RAM.
	mov a,R1		
	anl a,#0F0h		;isola a parte alta, referente à Dezena.		
	rl a
	rl a
	rl a
	rl a
	mov Dezena,a	;armazena a Dezena no endereço 41h da RAM.
Fim :	SJMP $		;parada
end
Ver programa prog_7(Conversor_BCD).asm
*
*
*
Uso de Fluxograma
 Dá uma visão estratégica de elaboração do programa
 Facilita futuras alterações
*
*
*
Uso de Fluxograma
*
*
*
*
Programa Acha Zero 
Fluxograma do Algoritmo
INÍCIO
R0  ENDEREÇO INICIAL
A  M(R0)
A=0 ?
FD  1
 R0  R0+1
FIM?
 END
 S
 N
 S
 N
Objetivo: Determinar se em um range (trecho) da Memória existe um byte 0.
*
*
*
;************************************************************************************************
; 			Programa Acha Zero
;-----------------------------------------------------------------------------------------------------------------
; Descrição: O Programa faz a busca de um Byte 00h, no trecho de 70h a 7Ah da
; ROM. Se existir, sinaliza com flag FD=1 e encerra com DPTR = Posição do byte 0.
;----------------------------------------------------------------------------------------------------------------
INTERVALO :
	PRIMEIRO equ 70h		;posição do primeiro byte do trecho.
 	ULTIMO equ 7Ah		;posição do último byte do trecho.
;------------------------------------------------------------------------------------------------------------------
DADOS :
ORG 70h	;inserção dos Dados a partir do endereço 70h da ROM.
	DB	10h,33h,45h,100,33,0,44h,255,40h,10	.
;------------------------------------------------------------------------------------------------------------------
ORG 00h
 
INICIO:	MOV DPTR,#PRIMEIRO		; Inicia Ponteiro
		CLR F0			; Limpa Flag F0
REPETE:	MOV A,#00h
		MOVC A,@A+DPTR		; Acc recebe o dado indicado por DPTR
		CJNE A, #0h, CONTINUA		; Pula para CONTINUA se A =! 0 (diferente).
ACHOU:	SETB F0			; Sinaliza o encontro do valor zero com F0=1
		SJMP FIM			;Desvia para o fim.			
CONTINUA: 	INC DPTR	 	;Se não encontrou byte zero, aponta para proxima posicao
		MOV R0,DPL	
		CJNE R0, #ULTIMO, REPETE	; Se R0<7Ah pula para REPETE
FIM:		SJMP $			;FIM
		END			; Fim de Arquivo p/ compilação
;-------------------------------------------------------------------------------------------------------------------- 
Ver programa prog_5(Acha_Zero).asm
*
*
*
*
Programa Acha Maior
Acc <-- (Ponteiro)
(Acc <-- ( R0 ))
Próxima posição
(R0 <-- R0 + 1)
Preserva dado e end.
( B <-- Acc ) 
( R1 <-- R0 )
INICIO
S
N
S
N
Subrotina
AchaMaior
Ent.: R0 = End. Inicial
Saída.: Acc = Maior valor
 R0 = End. Maior dado
Exercício : a partir do Fluxograma , elabore o programa que localiza o maior Byte no trecho de 70h a 79h da ROM.