UNIVERSIDADE ESTADUAL PAULISTA

JLIO DE MESQUITA FILHO

Faculdade de Engenharia de Ilha Solteira
Departamento de Engenharia Eltrica

4 Experimento
Pilhas e Subrotinas

Aluno: Nercival Buschieri Jnior

R.A.: 11052091
Discuplina: Microprocessadores I Turma: P4
Docente: Prof. Dr. Alexandre Csar Rodrigues da Silva

Grupo 7

Relatrio referente ao experimento realizado no dia 19/04 e entregue em 02/05.

Ilha Solteira 2013

Sumrio
1. Objetivos......................................................................................................................... 1
2. Introduo Terica.......................................................................................................... 3
2.1 Pilhas...............................................................................................................................3
2.2 Subrotinas.......................................................................................................................4
3. Procedimento Experimental e Apresentao de Resultados.......................................6
3.1 Contador Hexadecimal Crescente..............................................................................6
3.2 Contador Decimal Crescente......................................................................................8
3.3 Contador Decimal Decrescente................................................................................10
3.4 Visualizador de Programa.........................................................................................13
4. Concluso e Comentrios Finais...............................................................................16
5. Referncias..............................................................................................................17

1. Objetivos
Entender o conceito de PILHA e apresentar as instrues de Subrotinas do 8085.
2. Introduo Terica
2.1 Pilha
Como j foi dito anteriormente, a Pilha uma regio da memria RAM,
definida pelo usurio, para guardar valores que sero usados posteriormente.
Assim, o usurio pode guardar o contedo de qualquer registrador (dois a dois: A e
Flags, B e C, D e E, H e L) na pilha e o microprocessador guarda automaticamente
os endereos de retorno de subrotinas comuns e de subrotinas de interrupes. A
seguir ilustrada a regio da memria definida como Pilha (Stack).
Observaes:
(a) O contedo guardado na pilha sempre de 16 bits. Assim, o microprocessador
normalmente guarda o contedo de PC, que j de 16 bits, mas o usurio
normalmente guarda o contedo de registradores de 8 bits, que ento so
associados 2 a 2;
(b) Os registradores duplos que podem ser guardados na pilha so PSW (= A +
Flags), B (= B + C), D (=D + E) e H (= H + L);
(c) Para guardar o contedo de um desses registradores duplos usa-se a instruo
PUSH rp;
(d) Para recuperar o contedo que foi guardado na pilha usa-se a instruo POP rp;
(e) Quando uma informao enviada para a pilha o byte mais significativo
guardado primeiro; isso
significa que o byte menos significativo vai ser retirado primeiro porque o ltimo
dado armazenado o primeiro a ser retirado;
(f) A pilha do 8085 evolui do maior endereo para o menor, ou seja, a cada vez que
uma informao (2 bytes) enviada para a pilha, o endereo do topo da pilha
reduzido de 2. Ele acrescido de 2 quando a informao retirada da pilha;
(g) O apontador de pilha SP aponta sempre para o topo da pilha, mas ele
incrementado de 1 antes de cada byte ser armazenado.
Exemplo de armazenamento na pilha:
Supondo que inicialmente SP = 2090 h, A = 01 h, F = 23 h, B = 45 h e C = 67 h, as
figuras a seguir mostram a evoluo da pilha aps cada instruo dada. A regio
em destaque corresponde posio apontada por SP aps a instruo.

Figura 2.1.1 Exemplo de armazenagem na pilha.

Observaes:
(I) Apesar da regio da pilha continuar com o mesmo contedo aps as instrues
POP rp, eles no acessveis porque o Apontador de Pilha SP aponta para a posio
original, de quando a pilha estava vazia;
(II) POP B vem antes de POP PSW porque a ordem de retirada da pilha inversa
ordem de armazenagem.
2.2 Subrotinas
As subrotinas so mais um tipo de instruo de desvio, ou seja, alteram o
fluxo normal do programa. Trata-se de um grupo de instrues escrito
separadamente do programa principal, para executar uma funo que ocorre
repetidamente no programa principal. Seu principal objetivo dividir o programa
em tarefas simples e modulares e criar procedimentos que podem ser chamados
de diversos pontos do programa, facilitando assim a construo do programa.
As instrues das sub-rotinas no 8085 funcionam basicamente da seguinte
forma:
Temos as instrues incondicionais:
CALL<addr16> : usado no programa principal para chamar a sub-rotina.
RET: utilizado no final da sub-rotina para retornar ao programa principal.
Quando uma sub-rotina chamada, o contedo do PC (Program Counter),
que o endereo da instruo seguinte ao da instruo CALL, armazenado na
Pilha e a execuo do programa transferida para o endereo da sub-rotina.
Quando a instruo RET executada no final da sub-rotina, o endereo de
memria armazenado na Pilha retirado e a sequncia de execuo retomada
no programa principal a partir do endereo retirado do SP.

H tambm as instrues condicionais para a chamada e retorno das

subrotinas:
CALL condicional:
CC => Chama a sub-rotina se o Flag Carry 1 (CY = 1)
CNC => Chama a sub-rotina se o Carry 0 (CY = 0)
CZ => Chama a sub-rotina se o Flag Zero = 1 (Z = 1)
CNZ => Chama a sub-rotina se Zero = 0 (Z=0)
CM => Chama a sub-rotina se Sinal = 1 (S=1 Nmero negativo)
CP => Chama a sub-rotina se Sinal = 0 (S=0 = Nmero positivo)
CPE => Chama a sub-rotina se Paridade = 1 (P=1 paridade par)
CPO => Chama a sub-rotina se Paridade = 0 (P=0 paridade impar)
RET condicional:
RC => Retorna se o Flag Carry 1 (CY = 1)
RNC => Retorna se o Carry 0 (CY = 0)
RZ => Retorna se o Flag Zero = 1 (Z = 1)
RNZ => Retorna se Zero = 0 (Z=0)
RM => Retorna se Sinal = 1 (S=1 Nmero negativo)
RP => Retorna se Sinal = 0 (S=0 = Nmero positivo)
RPE => Retorna se Paridade = 1 (P=1 paridade par)
RPO => Retorna se Paridade = 0 (P=0 paridade impar)

3. Procedimento Experimental e Apresentao de resultados

3.1 Contador Hexadecimal Crescente
Devia-se fazer um programa para contar de 00H at FFH indefinidamente,
mostrando o valor da contagem de dados no display e usar a subrotina delay para
facilitar a sua visualizao.

O Fluxograma a seguir, mostra a ideia geral do programa.

Incio

Define a pilha

A<=00H

Joga o valor de
A na pilha

Call UPDAD

Pega o valor da pilha

e devolve para A

Define o tempo do
delay no reg. par DE

Call Delay

A<=A+1
6

A Tabela 3.1.1 mostra o programa elaborado:

Tabela 3.1.1 Contador de 00H at FFH utilizando pilha.

Endereo
2000
2003
2005

MNEMONIC
LXI SP, 20B0H
MVI A, 00H
PUSH PSW

Op. Code
31 B0 20
3E 00
F5

2006
2009

CALL 0363H
LXI D, 0F00H

CD 6E 03
11 00 0F

200C
200F

CALL 05F1H
POP PSW

CD F1 05
F1

2010
2011

INR A
JMP 2005

3C
C3 05 20

Comentrio
Define a posio inicial da pilha em 20B0H.
Carrega A com 00H.
Manda o valor dos regs. A e F pra pilha,
considerando A como byte superior.
Chama a subrotina UPDAD.
Carrega o par DE com 0F00H para ser usado
pela subrotina Delay.
Chama a subrotina Delay.
Devolve os valores armazenados na pilha para
os reg. A e F, na mesma ordem em que foram
retirados.
Incrementa o reg. A, fazendo sua contagem.
Pula para a instruo 2005.

A Figura 3.1.1 mostra a simulao do programa no Abacus.

Figura 4.1.1 Simulao do contador hexadecimal no Abacus.

3.2 Contador Decimal Crescente

Modificamos o programa anterior de para que ele apresente contagem em
decimal.
A ideia do programa a mesma, apenas fizemos o ajuste decimal, utilizando o
comando DAA.

Incio

Define a pilha

A<=00H

Ajuste decimal

Joga o valor de
A na pilha

Call UPDAD

Pega o valor da pilha

e devolve para A

Define o tempo do
delay no reg. par DE

Call Delay

A<=A+1

A Tabela 3.2.1 mostra o algoritmo do programa com comentrios.

Tabela 3.2.1 Contador decimal crescente.
Endereo
2000
2003
2005
2006
2007

MNEMONIC
LXI SP, 20B0H
MVI A, 00H
ORA A
DAA
PUSH PSW

Op. Code
31 B0 20
3E 00
B7
27
F5

2008
200B

CALL 0363H
LXI D, 0F00H

CD 6E 03
11 00 0F

200E
2011

CALL 05F1H
POP PSW

CD F1 05
F1

2012
2013

INR A
JMP 2005

3C
C3 05 20

Comentrio
Define a posio inicial da pilha em 20B0H.
Carrega A com 00H.

Manda o valor dos regs. A e F pra pilha,

considerando A como byte superior.
Chama a subrotina UPDAD.
Carrega o par DE com 0F00H para ser usado
pela subrotina Delay.
Chama a subrotina Delay.
Devolve os valores armazenados na pilha para
os reg. A e F, na mesma ordem em que foram
retirados.
Incrementa o reg. A, fazendo sua contagem.
Pula para a instruo 2005.

A Figura 3.2.1 mostra a simulao do programa no Abacus.

Figura 3.2.1 Simulao do contador decimal crescente.

9

3.3 Contador Decimal Decrescente

Agora, devia-se fazer um programa que faa a contagem hexadecimal em
ordem decrescente e usar a subrotina DELAY de modo que se obtivesse intervalo
de 1 segundo entre as contagens.
Incio

Deifniu-se a pilha:
SP<=20B0H

A<=99H
Coloca o valor
de A na pilha
(PUSH PSW)

Call UPDDT

Call DELAY
1segundo
Devolve o valor da
pilha para o reg. A
(POP PSW)

A=A-1

A<=B

B<=A

A<=A-06H

B<=A
Pega nibble menos
significativo
(mascara nibble
mais significativo)

YES
A-0FH=00 ?
NO

A<=B
ANI 9FH

A-F9H=00 ?

YES

NO
Jump

10

A ideia principal ainda consistia na mesma dos programas anteriores,

entretanto agora, ns mesmos tivemos que fazer o ajuste decimal. Para isso,
partimos de 99 e fomos decrementando esse numero. Ao chegar 90, como a
mquina conta em hexadecimal, o prximo nmero seria 8FH. Para fazer o ajuste
decimal, subtramos 06H do nibble menos significativo, de forma a obter 89 e
continuar a contagem, usando o mesmo procedimento.
Ao chegarmos em 00, o prximo nmero que a maquina iria seria FFH. O
ajuste do nibble menos significativo foi mesmo procedimento utilizado para os
outros nmeros. O nibble mais significativo, fizemos uma opereo de AND FH
com 9H, o que resulta em 9 e, portanto, ajusta a contagem do programa voltando
para 99.
Para obtermos um intervalo de 1 segundo, chamamos a subrotina DELAY
duas vezes, uma com temporizao FFFFH e outra 7D7EH. Usando o mdulo MC-1,
de fato tivemos cerca de 1s de intervalo, entretanto no simulador Abacus, o
intervalo foi bem maior, talvez porque os tempos de processamento de dados
sejam diferentes. A Tabela 3.3.1 mostra o algoritmo do programa com
comentrios.
Tabela 3.3.1 Contador decimal decrescente.
Endereo
2000
2003
2005
2006
2009
200C
200F
2012
2015
2016
2018
2019
201B
201D
2020
2021
2022
2024
2027
202A
202B
202D
202E
202F
2031

MNEMONIC
LXI SP, 20B0
MVI A, 99H
PUSH PSW
CALL 036E
LXI D, 7D7EH
CALL 05F1H
LXI D, FFFFH
CALL 05F1H
POP PSW
SUI 01H
MOV B,A
ANI 0FH
CPI 0FH
CZ 202AH
MOV A, B
ORA A
CPI F9H
CZ 202FH
JMP 2005H
MOV A, B
SUI 06H
MOV B, A
RET
ANI 9FH
RET

Op. Code
31 B0 20
3E 99
F5
CD 6E 03
11 7E 7D
CD F1 05
11 FF FF
CD F1 05
F1
D6 01
47
E6 0F
FE 0F
CC 2A 20
78
B7
FE F9
CC 2F 20
C3 05 20
78
D6 06
47
C9
E6 9F
C9

Comentrio
Define a posio inicial da pilha em 20B0H.
Carrega A com 99H.
Coloca o valor de A na pilha.
Chama a subrotina UPDDT para exibir o dado no Dislpay.
Carrega DE com 7E7EH, que ser um tempo para o delay.
Chama a subrotina DELAY.
Carrega DE com 7E7EH, que outro tempo para o delay.
Chama a subrotina DELAY.
Transfere o valor da pilha para o reg. A.
Decrementa A.
Move o valor de A para o reg. B.
Mascara o nibble mais significativo.
Compara com 0FH para ajustar a decrementao decimal.
Se Z=1, chama a subrotina em 202A.
Move o contedo do reg. B para o reg. A.
Faz CY=0.
Compara com F9H. para fazer o ajuste para decimal.
Se Z=1, ento vai para a subrotina em 202F.
Pula para a instruo presente no endereo 2005H.
Move o valor contido em B para o reg. A.
Subtrai 06H, para obtermos 9, fazendo assim o ajuste decimal
Move o contedo de A para o reg. B.
Volta para o endereo 2020D e continua a execuo do programa.
Faz com que FH ajuste-se para 9.
Volta para o endereo 2027H.

11

A Figura 3.3.1 mostra a simulao do programa no Abacus.

Figura 3.3.1 Simulao do contador decimal decrescente no Abacus.

12

3.4 Visualizador de Programa

Finamente, fizemos um programa que mostra nos displays o endereo de
memria e seu contedo, de faixa de endereos 2000H 201FH indefinidamente.

Incio

Define a Pilha
SP<=20B0H

Define-se endereo
DE<=2000

Carrega A com o valor

especificado pelo
endereo de DE
Coloca DE na pilha
(PUSH DE)

Coloca A na pilha
(PUSH PSW)

Call UPDAD
(Display 16 bits)
Call UPDAD
(Display 16 bits)
Resgata a valor
de A da pilha
(POP PSW)
Call UPDDT
(Display 8 bits)
Define tempo
DE<=0F00H

Call DELAY

Resgata a valor
de A da pilha
(POP DE)

DE<= DE+1

A<= E

A-22H=0?

A-22H=0?

Jump

13

Nesse programa, definimos o registrador par DE para fazer o controle

do endereo, e utilizamos a pilha para no perdermos os valores que deviam ser
amostrados nos displays. A partir da, projetamos o programa com o cuidado de
observar a onde ele terminaria e aumentar esse valor em uma unidade, para que
assim, pudssemos mostrar todo o programa. A Tabela 3.4.1 mostra o algoritmo
do programa com comentrios.
Tabela 3.4.1 Visualizador de programa.
Endereo
2000
2003
2006

MNEMONIC
LXI SP, 20B0H
LXI D, 2000H
LDAX D

Op. Code
31 B0 20
11 00 20
1A

2007

PUSH D

2008
2009
200C
200D
2010
2013
2016
2017
2018
2019
201A

PUSH PSW
CALL 0363H
POP PSW
CALL 036EH
LXI D, 0F00H
CALL 05F1H
POP D
INX D
MOV A, E
ORA A
CPI 22H

F5
CD 63 03
F1
CD 6E 03
11 00 0F
CD F1 05
D1
13
7B
B7
FE 22

201C
201F

JZ 2003H
JMP 2006H

CA 03 20
C3 06 20

D5

Comentrio
Define a posio inicial da pilha em 20B0H.
Carrega o par DE com 2000H.
Carrega o reg. A com o valor contido no endereo especificado
pelo para DE.
Salva o valor do reg. par DE na pilha para no perde-lo, pois a
subrotina pode alterar valores de registradores.
Salva o valor do reg. par AF na pilha para no perde-lo.
Chama subrotina UPDAD (Display 16 bits).
Recupera o valor armazenado na pilha para A.
Chama subrotina UPDDT (Display 8 bits).
Carrega o reg. par DE com 0F00 (ser o tempo de delay).
Chama subrotina DELAY.
Recupera o valor armazenado na pilha para DE.
Incrementa o par DE.
Move o valor do reg. E para o Acumulador.
Faz CY=0.
Compara o valor do Acumulador com 22H, que o valor a partir
de quando no h mais programa..
Se Z=1, pula para instruo presente no endereo 2003H.
Pula para instruo presente no endereo 2006H.

14

Figura 3.4.1 Simulao do programa elaborado.

15

4. Concluso e Comentrios Finais

Nesse experimento pudemos ver o quanto as pilhas e subrotinas so
ferramentas essenciais na construo de um programa mais elaborado atravs do
Microprocessador 8085.
Pudemos notar que as subrotinas nos proporcionam cdigos mais compactos,
j que se necessrio executar vrias vezes uma mesma tarefa, podemos utilizar
apenas uma subrotina para isso. Alm disso, as subrotinas nos proporcionam um
cdigo mais ordenado e estruturado minimizando erros e facilitando o encontro de
erros, j que elas podem ser testadas uma a uma.
Quanto pilha, vimos que esta compartilhada tanto pelo programador
quanto pelo microprocessador. Ela utilizada para armazenamento temporrio na
execuo de subrotinas e o programador pode tambm utiliz-la para armazenar e
retirar informao, atravs das funes PUSH E POP, mostrando assim ferramenta
indispensvel na construo de qualquer programa mais complexo.

16

5. Referncias

http://www2.ufersa.edu.br/portal/view/uploads/setores/147/arquivos/MM/7047
549-Cpu-Process-Adores.pdf

CSAR R. DA SILVA, Alexandre. ELE 1078 Microprocessadores I: notas de aula. Ilha

Solteira, Abril 2013. < http://www.lpssd.feis.unesp.br/course/view.php?id=13>

17