You are on page 1of 20

1

MICROCOMPUTADOR SAP-3


Novos registradores de uso geral (adicionais): D, E, H e L.
Registrador de flags F.
Registrador apontador de pilha (SP, Stack Pointer) de 16
bits.



Instrues de registradores

Sintaxe Operao Bytes
MOV reg1,reg2 (reg1) (reg2) 1
MVI reg,byte (reg) byte 2
onde reg1, reg2, reg = A,B,C,D,E,H ou L.

Mais registradores internos na UCP uso menos frequente da
memria programas mais simples, menores e mais rpidos.
Os programas do SAP-3 so mais rpidos do que os do SAP-2.




Instrues aritmticas

Dados de 8 bits: resultados sem sinal de 0 a 255, e com sinal
de -128 a +127.

Afetam o flag de transporte CY (Carry), que pode ser vai-
um (na adio) ou vem-um (na subtrao). A interpretao
depende da operao.


2

CY = CARRY para instrues ADD (SUB = 0)
CY = CARRY para instrues SUB (SUB = 1)

O resultado tem 8 bits e armazenado no acumulador. Nas subtraes, um CARRY alto
produz um CY baixo, e vice-versa.

Na adio, CY chamado de vai-um. Na subtrao, CY chamado de vem-um ou pede
emprestado. O transporte CY funciona como um bit adicional do acumulador (CY = A
8
).
3

Instrues aritmticas

Sintaxe Operao Bytes
STC (CY) 1 1
CMC
(CY) ) (CY
1
ADD reg (A) (A) + (reg) 1
ADI byte (A) (A) + byte 2
ADC reg (A) (A) + (reg) + (CY) 1
ACI byte (A) (A) + byte + (CY) 2
SUB reg (A) (A) (reg) 1
SUI byte (A) (A) byte 2
SBB reg (A) (A) (reg) (CY) 1
SBI byte (A) (A) byte (CY) 2


Adio sem sinal: use o CY. Adio com sinal: despreze o
CY.
o Exemplos:
(A) = 1111 0001 (E) = 0000 1000
ADD E
(CY) = 0 (A) = 1111 1001


(A) = 1111 1111 (L) = 0000 0001
ADD L
(CY) = 1 (A) = 0000 0000


A instruo ADC, pelo fato de incluir o transporte CY, torna
possvel somar nmeros de mais de 8 bits, por etapas.

4

Quando uma subtrao executada, CY funciona como um
flag de "pede emprestado" (borrow) ou "vem-um". O "pede
emprestado" final ocorre quando CY = 1. Se no h "vem-
um", ento CY = 0.

Exemplos: fazer a subtrao normal e em complemento de 2:

(A) = 0FH (D) = 01H
SUB D
(CY) = 0 (A) = 0EH


(A) = 0CH (E) = 12H
SUB E
(CY) = 1 (A) = FAH


A instruo SBB, pelo fato de incluir o transporte CY, torna
possvel subtrair nmeros de mais de 8 bits, por etapas.

SBB r eg primeiro soma (reg) e (CY), e ento subtrai esse
resultado do acumulador.

Exemplos: fazer a subtrao normal e em complemento de 2:

(A) = FFH (E) = 02H (CY) = 1
SBB E
(CY) = 0 (A) = FCH


Aplicao: Escrever um programa para somar 700
10
com
900
10
, e colocar o resultado nos registradores H e L.

700
10
= 02BCH 900
10
= 0384H

5


Instruo Comentrio
MVI B,02H
;Carrega o byte superior de 700
MVI C,BCH
;Carrega o byte inferior de 700
MVI D,03H
;Carrega o byte superior de 900
MVI E,84H
;Carrega o byte inferior de 900
MOV A,C
;Copia C em A
ADD E
;Soma o byte inferior de 900 com A
MOV L,A
;Salva o byte inferior da soma em L
MOV A,B
;Coloca o byte superior de 700 em A
ADC D
;Soma o byte superior de 900 e CY
MOV H,A
;Salva o byte superior da soma em H
HLT


A resposta em HL 0640H, igual a 1600
10
.


Aplicao: Escrever um programa para subtrair 700
10
de
900
10
, e colocar o resultado nos registradores H e L.

700
10
= 02BCH 900
10
= 0384H

Instruo Comentrio
MVI A,84H
;Carrega o byte inferior de 900 em A
SUI BCH
;Subtrai o byte inferior de 700 de A
MOV L,A
;Salva o byte inferior do resultado
MVI A,03H
;Coloca o byte superior de 900 em A
SBI 02H
;Subtrai o byte superior de 700 e CY
MOV H,A
;Salva o byte superior do resultado
HLT



6

Incrementos, decrementos e rotaes

Sintaxe Operao Bytes
INR reg (reg) (reg) + 1 1
DCR reg (reg) (reg) - 1 1
RAL
(A
i
) (A
i-1
); (A
0
) (CY);
(CY) (A
7
)
1
RAR
(A
i-1
) (A
i
); (A
7
) (CY);
(CY) (A
0
)
1
RLC
(A
i
) (A
i-1
); (A
0
) (A
7
);
(CY) (A
7
)
1
RRC
(A
i-1
) (A
i
); (A
7
) (A
0
);
(CY) (A
0
)
1

As instrues INR e DCR afetam os flags de sinal e de zero
(S e Z), mas no afetam o flag de transporte CY.

O flag de transporte CY permanece inalterado mesmo que
ocorra um estouro no registrador incrementado.

Exemplos:
(B) = 1111 1111 S = 1 Z = 0 CY = 0
INR B
(B) = 0000 0000 S = 0 Z = 1 CY = 0


(E) = 0000 0000 S = 0 Z = 1 CY = 0
DCR E
(E) = 1111 1111 S = 1 Z = 0 CY = 0





7

As instrues de rotao agora incluem o flag de transporte.
Nas instrues RAL e RAR, CY funciona como uma extenso
de A.

Nas instrues RLC e RRC, CY no uma extenso de A. O
acumulador rotaciona seus bits sozinho, para a esquerda
(RLC) ou para a direita (RRC).
o O contedo de CY perdido. Com uma RLC, CY recebe
o MSB. Com uma RRC, CY recebe o LSB.


As instrues de rotao servem para converter dados da
forma paralela para a forma serial, e vice-versa.

As instrues de rotao tambm servem para multiplicar ou
dividir por 2 o contedo do acumulador.

Com CY = 0, RAL multiplica por 2 e RAR divide por 2.

Exemplos:
CY = 0 (A) = 1110 1000
RAL
CY = 1 (A) = 1101 0000


CY = 0 (A) = 1110 1000
RAR
CY = 0 (A) = 0111 0100

RLC e RRC no garantem produzir um resultado correto logo
na primeira execuo.

8
Instrues lgicas


Sintaxe Operao Bytes
ANA reg (A) (A) AND (reg) 1
ANI byte (A) (A) AND byte 2
ORA reg (A) (A) OR (reg) 1
ORI byte (A) (A) OR byte 2
XRA reg (A) (A) XOR (reg) 1
XRI byte (A) (A) XOR byte 2
CMP reg
Z = 1 se (A) = (reg);
Z = 0 se (A) (reg)
1
CPI byte
Z = 1 se (A) = byte;
Z = 0 se (A) byte
2

Para a execuo de CMP r eg, (A) copiado para o
registrador TMP. Ento a ULA faz (TMP) (reg), afetando
o flag Z.

Por isso, se (A) = (reg), ento Z=1, e se (A) (reg), ento
Z=0. Como usado o registrador TMP, a instruo CMP
no afeta o contedo do acumulador ou de reg.

A instruo CMP, usada com uma instruo J Z, permite
controlar laos de uma nova maneira (com o contador
crescendo).

Rtulo Instruo Comentrio
MVI E,00H
;Inicializar o contador
LOOP: ...

...

INR E
;Incrementar o contador
MOV A,E
;Copiar E para A
CPI FFH
;Comparar A com 255
JNZ LOOP
;Repetir se A no for 255

9

Instrues de desvio de programa


Sintaxe Operao Bytes
JMP endereo (PC) endereo 3
JM endereo S = 1: (PC) endereo;
S = 0: (PC) (PC) + 1
3
JP endereo S = 0: (PC) endereo;
S = 1: (PC) (PC) + 1
3
JZ endereo Z = 1: (PC) endereo;
Z = 0: (PC) (PC) + 1
3
JNZ endereo Z = 0: (PC) endereo;
Z = 1: (PC) (PC) + 1
3
JC endereo CY = 1: (PC) endereo;
CY = 0: (PC) (PC) + 1
3
JNC endereo CY = 0: (PC) endereo;
CY = 1: (PC) (PC) + 1
3
JPE endereo P = 1: (PC) endereo;
P = 0: (PC) (PC) + 1
3
JPO endereo P = 0: (PC) endereo;
P = 1: (PC) (PC) + 1
3


J PE e J PO desviam com base no flag de paridade P:
o P=1: o resultado da ULA tem um nmero par de 1s.
o P=0: o resultado da ULA tem um nmero mpar de 1s.


10
Instrues de registradores extendidos

Certas instrues enxergam os registradores da UCP
encadeados aos pares, para assim processar dados de 16
bits.

Essas instrues tratam o par de registradores como um
nico registrador, tendo o nome do primeiro registrador do
par.

A associao dos registradores em pares feita sempre
assim:
B C

D E

H L


Sintaxe Operao Bytes
LXI B,word (B) byte superior;
(C) byte inferior
3
LXI D,word (D) byte superior;
(E) byte inferior
3
LXI H,word (H) byte superior;
(L) byte inferior
3
DAD B (HL) (HL) + (BC) 1
DAD D (HL) (HL) + (DE) 1
DAD H (HL) (HL) + (HL) 1
INX B (BC) (BC) + 1 1
INX D (DE) (DE) + 1 1
INX H (HL) (HL) + 1 1
DCX B (BC) (BC) - 1 1
DCX D (DE) (DE) - 1 1
DCX H (HL) (HL) - 1 1
11

DAD afeta o flag de transporte CY, se houver um transporte
do par HL de registradores (resultado da soma com mais de
16 bits).

DAD H duplica o valor de HL.

I NX e DCX no tm efeito sobre os flags.


12
Instrues de endereamento indireto

So instrues que usam o contedo do par HL como o
endereo de um dado na memria, isto , (HL) enviado
para o REM, para que seja feita uma leitura ou escrita na
memria.

Para essas instrues, o par HL aponta para a posio de
memria onde um dado est armazenado, ou onde um dado
deve ser armazenado. HL ento um apontador de dados.

Essas instrues usam o modo de endereamento indireto,
pois o endereo uma varivel, que pode mudar no decorrer
do programa. Podem-se fazer clculos com os endereos.

Por outro lado, no endereamento direto, os endereos so
constantes (por exemplo, LDA 5000H ou STA 2000H).

Nesta tabela, M = (HL).
Sintaxe Operao Bytes
MOV reg,M (reg) ((HL)) 1
MOV M,reg ((HL)) (reg) 1
MVI M,byte ((HL)) byte 2
ADD M (A) (A) + ((HL)) 1
ADC M (A) (A) + ((HL)) + (CY) 1
SUB M (A) (A) - ((HL)) 1
SBB M (A) (A) - ((HL)) - (CY) 1
INR M ((HL)) ((HL)) + 1 1
DCR M ((HL)) ((HL)) - 1 1
ANA M (A) (A) AND ((HL)) 1
ORA M (A) (A) OR ((HL)) 1
XRA M (A) (A) XOR ((HL)) 1
CMP M Z = 1 se (A) = ((HL));
Z = 0 se (A) ((HL))
1
13

Exemplo de programa em assembly


Programa para copiar 256 bytes dos endereos de memria
2000H a 20FFH para a faixa de endereos 3000H a 30FFH.

Rtulo Instruo Comentrio
LXI H,1FFFH
;Inicializar apontador HL
LOOP: INX H
;Incrementar HL
MOV B,M
;Ler o byte de (HL)
MOV A,H
;Carregar H (20H) em A
ADI 10H
;Adicionar para chegar a 30H
MOV H,A
;Devolver para H
MOV M,B
;Escrever o byte no novo endr
SUI 10H
;Subtrair para voltar a 20H
MOV H,A
;Restaurar H para 20H
MOV A,L
;Copiar para A para comparar
CPI FFH
;Comparar A com FFH
JNZ LOOP
;Se no for, voltar para LOOP
HLT




14

Instrues de manipulao de pilha

A pilha uma rea da memria, definida por instrues,
onde os dados so escritos e lidos de forma serializada, isto
, um aps o outro em sequncia.

No SAP-3, o programador decide onde iniciar a rea de pilha
na memria e que tamanho ela vai ter.

Uma pilha usada para:
o Guardar sucessivos endereos de retorno de sub-
rotinas.
o Guardar dados de uso geral.

Um registrador de 16 bits da UCP, chamado de SP (Stack
Pointer ou Apontador de Pilha), tem a funo de indicar a
posio de memria na pilha que deve ser acessada (lida ou
escrita) pelas instrues de pilha.

O apontador de pilha inicializado com uma instruo de
carga imediata:
LXI SP, wor d


15

Instrues de empilhamento

Os contedos do acumulador e do registrador de flags so
denominados conjuntamente de PSW (Program Status Word
ou Palavra de Estado de Programa).

PSW = (A)(F)

Quando se vai chamar uma sub-rotina, pode ser necessrio
guardar antes a PSW, para que o programa principal possa
prosseguir de forma correta depois que a sub-rotina retornar.

Pode ser necessrio guardar tambm os contedos dos
demais registradores, antes do incio da sub-rotina. Isso
preserva todo o estado da CPU antes da execuo da sub-
rotina.

A instruo de empilhamento PUSH, que guarda dados na
pilha. H quatro instrues PUSH, que enxergam os
registradores aos pares (B = BC, D = DE, H = HL).

Sintaxe Operao Bytes
PUSH B
(SP) (SP) 1; ((SP)) (B);
(SP) (SP) 1; ((SP)) (C)
1
PUSH D
(SP) (SP) 1; ((SP)) (D);
(SP) (SP) 1; ((SP)) (E)
1
PUSH H
(SP) (SP) 1; ((SP)) (H);
(SP) (SP) 1; ((SP)) (L)
1
PUSH PSW
(SP) (SP) 1; ((SP)) (A);
(SP) (SP) 1; ((SP)) (F)
1

As instrues PUSH empilham sempre palavras de 16 bits,
primeiro o byte superior e depois o byte inferior.


16

Exemplos de instrues PUSH

(BC) = 5612H (SP) = 2100H
PUSH B

1. SP decrementado para 20FFH;
2. O byte superior 56H guardado na memria, no
endereo 20FFH ;
3. SP decrementado para 20FEH;
4. O byte inferior 12H guardado na memria, no
endereo 20FEH.


(SP) = 2100H, (AF) = 1234H, (DE) = 5678H, (HL) = 9A25H
PUSH PSW
PUSH D
PUSH H

dados endereos


25H 20FAH
9AH 20FBH
78H 20FCH
56H 20FDH
34H 20FEH
12H 20FFH



A pilha cresce para cima a partir do endereo (SP1), no
sentido decrescente dos endereos da memria.

SP sempre aponta para o ltimo dado empilhado.

SP
17
Instrues de desempilhamento

Fazem o inverso das instrues PUSH, restaurando os
contedos dos registradores empilhados.

Sintaxe Operao Bytes
POP B
(C) ((SP)); (SP) (SP) + 1;
(B) ((SP)); (SP) (SP) + 1
1
POP D
(E) ((SP)); (SP) (SP) + 1;
(D) ((SP)); (SP) (SP) + 1
1
POP H
(L) ((SP)); (SP) (SP) + 1;
(H) ((SP)); (SP) (SP) + 1
1
POP PSW
(F) ((SP)); (SP) (SP) + 1;
(A) ((SP)); (SP) (SP) + 1
1

As instrues POP tambm enxergam os registradores aos
pares, e desempilham 2 bytes de cada vez.

A ordem do desempilhamento inversa ordem do
empilhamento. A pilha opera no modo LIFO (Last In, First
Out): o ltimo dado que entra na pilha o primeiro que sai.

Exemplo:
dados endereos



25H 20FAH
9AH 20FBH
78H 20FCH
56H 20FDH
34H 20FEH
12H 20FFH



SP
POP B :
(C) 25H;
(SP) 20FBH;
(B) 9AH;
(SP) 20FCH.
(BC) = 9A25H

POP PSW :
(AF) = 5678H

POP H:
(HL) = 1234H

(SP) = 2100H
18

Chamadas e retornos de sub-rotinas

Endereo Instruo
2000H LXI SP,FFFFH
2001H
2002H
2003H CALL 8050H
2004H
2005H
2006H MVI A,0EH
... ...
20FFH HLT
... ...
... ...
8050H ...
... ...
8059H RET

CALL provoca o empilhamento do endereo da prxima
instruo (endereo de retorno). Ento o PC carregado
com 8050H e a execuo vai para a sub-rotina.

dados endereos
. .
06H FFFDH
20H FFFEH
FFFFH

RET desempilha o endereo de retorno e o devolve ao PC.
SP volta a conter FFFFH.

SP precisa ser inicializado pelo programador com o limite
superior da pilha (seu maior endereo). preciso ter
cuidado para que a pilha no invada a rea de programa ou
outra rea de dados. Ela pode ficar no final da memria.
SP
19

Chamadas condicionais de sub-rotinas

Sintaxe Operao Bytes
CNZ endereo
Z = 0: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
Z = 1: (PC) (PC) + 1
3
CZ endereo
Z = 1: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
Z = 0: (PC) (PC) + 1
3
CNC endereo
CY = 0: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
CY = 1: (PC) (PC) + 1
3
CC endereo
CY = 1: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
CY = 0: (PC) (PC) + 1
3
CP endereo
S = 0: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
S = 1: (PC) (PC) + 1
3
CM endereo
S = 1: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
S = 0: (PC) (PC) + 1
3
CPE endereo
P = 1: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
P = 0: (PC) (PC) + 1
3
CPO endereo
P = 0: (SP)(SP)-1; ((SP))(PC
H
);
(SP)(SP)-1; ((SP))(PC
L
);
(PC) endereo.
P = 1: (PC) (PC) + 1
3
20

Retornos condicionais de sub-rotinas

Sintaxe Operao Bytes
RNZ endereo Z = 0: (PC) ((SP+1))((SP));
Z = 1: (PC) (PC) + 1
3
RZ endereo Z = 1: (PC) ((SP+1))((SP));
Z = 0: (PC) (PC) + 1
3
RNC endereo CY = 0: (PC) ((SP+1))((SP));
CY = 1: (PC) (PC) + 1
3
RC endereo CY = 1: (PC) ((SP+1))((SP));
CY = 0: (PC) (PC) + 1
3
RP endereo S = 0: (PC) ((SP+1))((SP));
S = 1: (PC) (PC) + 1
3
RM endereo S = 1: (PC) ((SP+1))((SP));
S = 0: (PC) (PC) + 1
3
RPE endereo P = 1: (PC) ((SP+1))((SP));
P = 0: (PC) (PC) + 1
3
RPO endereo P = 0: (PC) ((SP+1))((SP));
P = 1: (PC) (PC) + 1
3


Durante a execuo das instrues CALL e RET, as
operaes com a pilha so realizadas automaticamente pelo
computador.

You might also like