WRP1 User Manual

WRP1 MANUAL DO USUÁRIO
Arquitetura, Operação e Instruções do Processador
https://wrkits.com.br
WR Kits
Atualizado em Agosto de 2021
1
Sumário
Lista de Figuras .............................................................................................................................. 3
Lista de Tabelas ............................................................................................................................. 5
Lista de Códigos............................................................................................................................. 6
Introdução ..................................................................................................................................... 7
Arquitetura do WRP1 .................................................................................................................... 8
Program Counter ....................................................................................................................... 8
Memory Address Register ......................................................................................................... 8
Stack 10 Levels .......................................................................................................................... 9
User Register x10 ...................................................................................................................... 9
Argument Register .................................................................................................................... 9
Instruction Register ................................................................................................................... 9
Control Unity ............................................................................................................................. 9
Flags Register ............................................................................................................................ 9
Accumulator .............................................................................................................................. 9
Arithmetic Logic Unity ............................................................................................................... 9
B Register ................................................................................................................................ 10
OUTPUT Register ..................................................................................................................... 10
INPUT/INT Register ................................................................................................................. 10
UART 9600 bps ........................................................................................................................ 10
Registradores Especiais ............................................................................................................... 11
Descrição dos Pinos ..................................................................................................................... 13
Ciclo de Busca e Execução ........................................................................................................... 16
Set de Instruções ......................................................................................................................... 17
nop – No Operation................................................................................................................. 18
lda – Load Accumulator........................................................................................................... 19
add – Adição ............................................................................................................................ 20
sub – Subtração ....................................................................................................................... 21
ldi – Load Immediate ............................................................................................................... 22
and – Lógica E .......................................................................................................................... 23
orl – Lógica OU ........................................................................................................................ 24
xor – Lógica OU Exclusivo ........................................................................................................ 25
not – Complemento de ACC .................................................................................................... 26
hlt – Halt .................................................................................................................................. 27
gta – Go To Address ................................................................................................................ 28
ifz – Desvia se Z estiver setada ................................................................................................ 29
2
ifc – Desvia se C estiver setada ............................................................................................... 30

sta – Store Accumulator .......................................................................................................... 31
iti – Input Instruction............................................................................................................... 32
oti – Output Instruction .......................................................................................................... 33
csr – Call Subroutine................................................................................................................ 34
ret – Return ............................................................................................................................. 35
shl – Shift Left .......................................................................................................................... 36
shr – Shift Right ....................................................................................................................... 37
puh – Push to the top .............................................................................................................. 38
pop – Pull from the top ........................................................................................................... 39
ite – Interrupt Enable .............................................................................................................. 40
itd – Interrupt Disable ............................................................................................................. 41
cpa – Compare Accumulator ................................................................................................... 42
ife – Desvia se E estiver setada ............................................................................................... 43
swa – Swap Accumulator ........................................................................................................ 44
ada – Add Address Contents ................................................................................................... 45
sba – Subtract Address Contents ............................................................................................ 46
ana – AND Address Contents .................................................................................................. 47
ora – OR Address Contents ..................................................................................................... 48
xra – XOR Address Contents.................................................................................................... 49
rip – Return Interrupt .............................................................................................................. 50
Organização de Memória ............................................................................................................ 51
Interrupções ................................................................................................................................ 52
Conclusão .................................................................................................................................... 53
3
Lista de Figuras
Figura 1 - Arquitetura do processador WRP1. .............................................................................. 8
Figura 2 - Registradores especiais do WRP1. .............................................................................. 11
Figura 3 – Acumulador ................................................................................................................ 11
Figura 4 - Registrador B. .............................................................................................................. 11
Figura 5 - Registrador de Instruções. .......................................................................................... 12
Figura 6 - Registrador de Argumentos. ....................................................................................... 12
Figura 7 - Registrador de Saída. .................................................................................................. 12
Figura 8 - Registrador de Entrada. .............................................................................................. 12
Figura 9 - Registrador de FLAGS. ................................................................................................. 12
Figura 10 - Pinos do processador WRP1. .................................................................................... 13
Figura 11 - Circuito mínimo para o processador WRP1. ............................................................. 15
Figura 12 - Ciclo de Busca e Execução. ........................................................................................ 16
Figura 13 - Ciclos da instrução nop. ............................................................................................ 18
Figura 14 - Ciclos da instrução lda. .............................................................................................. 19
Figura 15 - Ciclos da instrução add.............................................................................................. 20
Figura 16 - Ciclos da instrução sub. ............................................................................................. 21
Figura 17 - Ciclos da instrução ldi. ............................................................................................... 22
Figura 18 - Ciclos da instrução and.............................................................................................. 23
Figura 19 - Ciclos da instrução orl. .............................................................................................. 24
Figura 20 - Ciclos da instrução xor. ............................................................................................. 25
Figura 21 - Ciclos de instrução not. ............................................................................................. 26
Figura 22 - Ciclos da instrução hlt. .............................................................................................. 27
Figura 23 - Ciclos da instrução gta. ............................................................................................. 28
Figura 24 - Ciclos da instrução ifz. ............................................................................................... 29
Figura 25 - Ciclos da instrução ifc. ............................................................................................... 30
Figura 26 - Ciclos da instrução sta. .............................................................................................. 31
Figura 27 - Ciclos da instrução iti. ............................................................................................... 32
Figura 28 - Ciclos da instrução oti. .............................................................................................. 33
Figura 29 - Ciclos da instrução da csr. ......................................................................................... 34
Figura 30 - Ciclos da instrução ret. .............................................................................................. 35
Figura 31 - Ciclos da instrução shl. .............................................................................................. 36
Figura 32 - Ciclos da instrução shr............................................................................................... 37
Figura 33 - Ciclos da instrução puh. ............................................................................................ 38
Figura 34 - Ciclos da instrução pop. ............................................................................................ 39
4
Figura 35 - Ciclos da instrução ite. .............................................................................................. 40

Figura 36 - Ciclos da instrução itd. .............................................................................................. 41
Figura 37 - Ciclos da instrução cpa. ............................................................................................. 42
Figura 38 - Ciclos da instrução ife. .............................................................................................. 43
Figura 39 - Ciclos da instrução swa. ............................................................................................ 44
Figura 40 - Ciclos da instrução ada. ............................................................................................. 45
Figura 41 - Ciclos da instrução sba. ............................................................................................. 46
Figura 42 - Ciclos da instrução ana. ............................................................................................. 47
Figura 43 - Ciclos da instrução ora. ............................................................................................. 48
Figura 44 - Ciclos da instrução xra............................................................................................... 49
Figura 45 - Ciclos da instrução rip. .............................................................................................. 50
Figura 46 - Organização de memória do WRP1. ......................................................................... 51
5
Lista de Tabelas
Tabela 1 - Descrição dos pinos do WRP1. ................................................................................... 15
Tabela 2 - Set Completo de Instruções do WRP1........................................................................ 17
Tabela 3 - Fontes de interrupção do WRP1. ............................................................................... 52
6
Lista de Códigos
Box 1 - Exemplo de código Assembly para nop.......................................................................... 18
Box 2 - Exemplo de código Assembly para lda. ........................................................................... 19
Box 3 - Exemplo de código Assembly para add........................................................................... 20
Box 4 - Exemplo de código Assembly para sub. .......................................................................... 21
Box 5 - Exemplo de código Assembly para ldi. ............................................................................ 22
Box 6 - Exemplo de código Assembly para and........................................................................... 23
Box 7 - Exemplo de código Assembly para orl. ........................................................................... 24
Box 8 - Exemplo de código Assembly para xor............................................................................ 25
Box 9 - Exemplo de código Assembly para not. .......................................................................... 26
Box 10 - Exemplo de código Assembly para hlt. ......................................................................... 27
Box 11 - Exemplo de código Assembly para gta.......................................................................... 28
Box 12 - Exemplo de código Assembly para ifz. .......................................................................... 29
Box 13 - Exemplo de código Assembly para ifc. .......................................................................... 30
Box 14 - Exemplo de código Assembly para sta. ......................................................................... 31
Box 15 - Exemplo de código Assembly para iti............................................................................ 32
Box 16 - Exemplo de código Assembly para oti. ......................................................................... 33
Box 17 - Exemplo de código Assembly para csr. ......................................................................... 34
Box 18 - Exemplo de código Assembly para ret. ......................................................................... 35
Box 19 - Exemplo de código Assembly para shl. ......................................................................... 36
Box 20 - Exemplo de código Assembly para shr.......................................................................... 37
Box 21 - Exemplo de código Assembly para puh. ....................................................................... 38
Box 22 - Exemplo de código Assembly para pop. ....................................................................... 39
Box 23 - Exemplo de código Assembly para ite. ......................................................................... 40
Box 24 - Exemplo de codigo Assembly para itd. ......................................................................... 41
Box 25 - Exemplo de código Assembly para cpa. ........................................................................ 42
Box 26 - Exemplo de código Assembly para ife........................................................................... 43
Box 27 - Exemplo de código Assembly para swa. ....................................................................... 44
Box 28 - Exemplo de código Assembly para ada. ........................................................................ 45
Box 29 - Exemplo de código Assembly para sba. ........................................................................ 46
Box 30 - Exemplo de código Assembly para ana. ........................................................................ 47
Box 31 - Exemplo de código Assembly para ora. ........................................................................ 48
Box 32 - Exemplo de código em Assembly para xra.................................................................... 49
Box 33 – Exemplo de código em Assembly para rip................................................................... 50
Box 34 - Exemplo de tratamento de interrupção com sub-rotina. ............................................. 52
7
Introdução
O processador WRP1 é um dispositivo de 8 bits desenvolvido para trabalhar na

arquitetura Von Neumann, onde os dados e as instruções estarão armazenados no mesmo
espaço de memória. Em sua arquitetura, temos em essência a memória, uma unidade lógica e
aritmética e uma unidade de controle, que realiza a busca do programa na memória executando-
o instrução por instrução de acordo com os dados de entrada.
Apresenta um PORT de entrada (ITR – input register) que contém 8 bits, porém só os 5
menos significativos (4..0) estão implementados. No mesmo PORT existem 5 entradas para
interrupção externa sensíveis à borda de subida e devidamente mapeadas (cada uma apresenta
seu próprio vetor de interrupção na memória). Existe disponível também um PORT de saída de
8 bits (OTR – output register) que pode ser utilizado para o acionamento das mais diversas
cargas, se utilizadas etapas de potência apropriadas. Todas as operações do processador, em
especial as que envolvem sua unidade lógica e aritmética, passam pelo ACC (acumulador), outro
registrador de 8 bits. O registrador de FLAGS indica o status atual do acumulador e existem 3
bits implementados no WRP1. O bit 0 é a flag Z (que é verdadeira quando ACC resultar em 0), o
bit 1 é o C (que é verdadeira quando ocorre um carry em operações de soma ou subtração) e o
bit 2 é o E (que é verdadeira se ACC for igual ao valor de comparação da instrução cpa).
Estão disponíveis 10 registradores de uso geral (UR0 a UR9) localizados nos endereços
50h a 59h respectivamente. Estes registradores são de 8 bits cada e deverão ser escritos através
da instrução sta e lidos através da instrução lda, sempre através do acumulador. Também
podem ser utilizados quando as instruções lógicas e aritméticas de endereçamento estendido
forem necessárias.
O WRP1 apresenta uma pilha de 10 níveis, utilizada para guardar endereços de retorno
de sub-rotinas e chamadas de interrupção. Além disso, a pilha pode ser utilizada para salvar o
conteúdo atual do acumulador através da instrução puh e recuperá-lo através de pop, para
eventuais salvamentos de contexto.
Vamos entender toda a arquitetura do WRP1 em detalhes agora.

8
Arquitetura do WRP1
A arquitetura do WRP1 pode ser conferida na Figura 1.
Figura 1 - Arquitetura do processador WRP1.
Vamos agora conhecer cada bloco do processador WRP1.
Program Counter (PC: contador de programa): consiste em um circuito contador de 8 bits que
fará a contagem fornecendo os endereços para o registrador de endereços de memória. Regido
pelo CLOCK principal, é o PC que determina em qual região de memória será realizada a busca
e execução das instruções. Neste tipo de operação o conteúdo do contador de programa é
enviado para o registrador de endereços de memória (MAR). Também é possível escrever um
valor neste contador, isso ocorre quando o processador executa instruções de desvio ou
chamada/retorno de sub-rotinas.
Memory Address Register (MAR: registrador de endereços de memória): armazena o valor do

contador de programa e fornece o endereço atual para uma memória ROM externa, que conterá
o código objeto a ser executado. Também pode ser utilizado para o controle de RAM externa.
Os bits A7 a A0 devem ser conectados aos respectivos pinos das memórias utilizadas e
9
normalmente só é necessária a utilização de uma ROM, já que o processador dispõe de alguns

bytes de RAM que podem ser utilizados pelo usuário.
Stack 10 Levels (SP: pilha de memória de 10 níveis): armazena pontos de entrada e saída de sub-
rotina para continuar a execução natural do programa e também, se necessário, dados para a
recuperação de contexto. Como toda a pilha, funciona com o método LIFO (last in, first out), ou
seja, o último dado a entrar, é o primeiro dado a sair. Também é utilizada para armazenar o
endereço de retorno de interrupções, bem como o registrador de FLAGS para preservação de
contexto.
User Register x10 (UR: registradores do usuário): são 10 registradores de 8 bits disponíveis para
o usuário para armazenamento de dados (uma pequena RAM auxiliar). Considerando também
a pilha, o WRP1 dispõe de 20 bytes de RAM disponíveis, sem considerar os demais registradores
especiais. Os registradores UR0 a UR9, estão mapeados dos endereços 50h a 59h.
Argument Register (AR: registrador de argumentos): utilizado para armazenar o argumento das
instruções executadas (quando houver). Quando uma instrução conter um argumento, ocorrerá
um novo ciclo de busca por este argumento. Ao final do processo, a opcode da instrução estará
no registrador de instruções e o argumento estará no registrador de argumentos (ambos de 8
bits).
Instruction Register (IR: registrador de instruções): armazena o opcode da instrução atual a ser
processada pela unidade de controle. Se a instrução não tiver argumento, ocorrerá o ciclo de
execução e no próximo ciclo de busca a instrução seguinte será armazenada em IR.
Control Unity (UC: unidade de controle): é a unidade de controle principal, que receberá o sinal
de CLOCK, RESET e enviará um sinal de HALT para o circuito de clock quando uma instrução hlt
for executada, provocando a parada imediata do processamento. A unidade recebe o opcode
para executar a instrução específica, pois contém todo o decodificador de instruções. Atua no
controle de todos os blocos do processador para o tráfego de dados e instruções pelo
barramento (isso é indicado pela seta ALL na Figura 1). Além disso, lê o status das flags contidas
no registrador FLAGS, para efetuar algoritmos de tomada de decisão. As entradas XT1 e XT2 são
para o clock da própria unidade de controle, sendo permitido até 20MHz. Este clock (XT1 e XT2)
é assíncrono em relação ao CLOCK principal, pois serve apenas para o funcionamento da
unidade. Todos os blocos do processador são sincronizados com o CLOCK principal.
Flags Register (registrador de flags): utilizado para informar status sobre o acumulador e o
transbordo de bits (carry). Apresenta 8 bits, mas atualmente só os bits 2, 1 e 0 estão
implementados, que são E, C e Z respectivamente, usados nas instruções ife, ifc e ifz.
Accumulator (ACC: acumulador): registrador de 8 bits por onde passam todas as operações do
processador, incluindo os resultados de soma, subtração e operações lógicas. Usado também
para armazenar dados de forma imediata com a instrução ldi e endereçamento estendido com
a instrução lda.
Arithmetic Logic Unity (ALU: unidade lógica e aritmética): responsável pelas operações de soma,
subtração, lógica E, lógica OU, lógica XOR e NOT. Também realiza operação de shift right e shift
left (deslocamento para direita e para a esquerda). Recebe o valor de 8 bits do acumulador e do
registrador auxiliar B (operandos) e armazena o resultado da operação no próprio acumulador.
10
B Register (registrador auxiliar B): um registrador de 8 bits para auxiliar nas operações lógicas e
aritméticas, recebendo sempre um dos operandos. Geralmente recebe o argumento das
instruções de soma, subtração e instruções lógicas.
OUTPUT Register (OTR: registrador de saída): um PORT para saída paralela de 8 bits, utilizado
para controle de dispositivos como LEDs, motores, relés, módulos e outros. Este PORT de saída
está mapeado internamento no processador WRP1 e para escrever o conteúdo do acumulador
no registrador de saída, só precisamos utilizar a instrução oti. Também pode ser utilizado para
comunicação paralela e serial, esta última deverá ser implementada por software.
INPUT/INT Register (ITR: registrador de entrada e interrupção externa): um PORT para entrada
paralela de 8 bits, sendo apenas os 5 menos significativos implementados, que poderá ser
utilizado para leitura de botões, teclados, sensores digitais e outros. Poderá receber dados de
forma paralela e serial, esta última devendo ser implementada por software. Estes pinos de
entrada também poderão ser utilizados para gerar interrupções no processador, por borda de
subida, quando devidamente configuradas.
UART 9600 bps (transmissão/recepção assíncrona universal em 9600 bits por segundo): esta
UART consiste em um hardware interno dedicado, configurado de forma fixa em 9600 bps, para
enviar por TX o status de todos os registradores do processador, permitindo o acompanhamento
de cada pulso de CLOCK aplicado e debug dos softwares na própria bancada do laboratório.
Embora ainda não implementada, também está disponível uma entrada RX para recepção de
dados externos via serial.
11
Registradores Especiais
Estão presentes no processador os registradores especiais conforme a Figura 2 e aqui

iremos apresentar os seus bits para maior compreensão.
Figura 2 - Registradores especiais do WRP1.
Os registradores especiais disponíveis são os utilizados para interfaces de entrada e

saída (INPUT e OUTPUT); os que utilizamos como operandos para a realização de cálculos
aritméticos e lógicos (ACC e B), sendo ACC também responsável por armazenar o resultado das
operações realizadas; os responsáveis por armazenar as instruções e seus argumentos quando
houverem (IR e AR); além do fundamental registrador de FLAGS, que armazena status de
operações permitindo tomadas de decisão (desvio condicional). Todos eles iniciam com 00h no
reset do processador.
O acumulador pode ser visto na Figura 3. Poderá conter valores de 00h a FFh, pois é um
registrador de 8 bits. Pode ser lido e escrito pelo usuário.
Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0
Figura 3 – Acumulador
Na Figura 4 apresentamos o Registrador B. Poderá conter valores de 00h a FFh, pois é

um registrador de 8 bits. É apenas escrito automaticamente quando utilizamos instruções
lógicas e aritméticas. Serve de operando auxiliar nas operações da ALU.
Figura 4 - Registrador B.
12
Confira na Figura 5 o Registrador de Instruções. É nele que o opcode de 8 bits referente

a cada instrução fica salvo para ser processado pelo decodificador de instruções.
Figura 5 - Registrador de Instruções.
O Registrador de Argumentos tem o mesmo aspecto e está explícito na Figura 6. Quando

uma instrução que contém argumento for encontrada no ciclo de busca, um novo ciclo ocorre
para buscar pelo seu argumento (também de 8 bits) na memória de programa.
Figura 6 - Registrador de Argumentos.
O Registrador de Saída é um PORT de saída convencional, que pode ser escrito pelo
usuário através do acumulador. Em outras palavras, quando executada a instrução oti, o
conteúdo de ACC é enviado para OTR. Confira na Figura 7 o aspecto do registrador de saída.
Out 7 Out 6 Out 5 Out 4 Out 3 Out 2 Out 1 Out 0
Figura 7 - Registrador de Saída.
O processador WRP1 contém um registrador de entrada, que poderá ser utilizado para
entrada de dados e interrupção externa vetorada e não mascarada. Apesar de conter 8 bits,
apenas os 5 menos significativos estão implementados, sendo os demais sempre lidos como
zero. Configura o ITR na Figura 8.
- - - In/Int 4 In/Int 3 In/Int 2 In/Int 1 In/Int 0
Figura 8 - Registrador de Entrada.
O registrador de FLAGS apresenta 8 bits, porém apenas os três menos significativos

estão implementados, que são os bits equal, carry e zero, conforme Figura 9.
- - - - - E C Z
Figura 9 - Registrador de FLAGS.
O bit E (equal) é setado após uma instrução cpa, que compara o conteúdo do
acumulador com o seu argumento. Se o conteúdo de ACC for igual ao argumento de cpa o bit E
é setado e o usuário poderá usar a instrução ife para desviar para algum endereço relativo.
Quando ocorre o overflow do acumulador, o bit de carry (C) é setado e essa condição pode ser
verificada pela instrução ifc. Quando o resultado de alguma operação resultar em 0, significa
que o acumulador conterá este valor e o bit Z é setado. Esta condição é verificada através da
instrução ifz.
13
Descrição dos Pinos
O processador WRP1 consiste em um circuito integrado de 40 pinos em encapsulamento

DIL (dual in line) e na Figura 10 apresentamos todos os pinos disponíveis.
Figura 10 - Pinos do processador WRP1.
Para utilizar o WRP1, será necessário um circuito de clock para a unidade de controle,
um circuito de reset, um circuito de CLOCK principal (responsável pelo sincronismo de todo o
processador) e uma memória externa. A memória poderá ser uma EPROM ou EEPROM, que
conterá o código objeto a ser executado pelo WRP1. Uma memória RAM externa também
poderá ser adicionada para expansão, porém não é totalmente necessário visto que o
processador já tem a pilha implementada internamente e mais 10 registradores do usuário.
O processador efetua a busca e a execução das instruções a partir do endereço 00h de

memória. A cada pulso do CLOCK principal, o conteúdo atual de todos os registradores é enviado
na linha UART TX, que poderá ser visto pelo projetista através de um terminal configurado para
9600 bps. O WRP1 funciona com a tensão de +5V.
14
A Tabela 1 apresenta a descrição de todos os pinos do processador WRP1, por ordem

numérica.
Nome do Pino Nº Descrição

Reset do processador. Quando recebe um sinal em nível baixo, devolve
RESET 1 o program counter para o endereço 00h de memória e reinicia todos os
registradores com o padrão de reset.
ITR0/INT0 2 Bit 0 do registrador de entrada/interrupção externa 0*.
Saída para parada do processamento. Vai a nível alto quando for
executada a instrução hlt, interrompendo o CLOCK do processador. A
HALT 7
saída HALT só volta para nível baixo com um reset ou com uma
interrupção externa.
OTR5 8 Bit 5 do registrador de saída**.
VCC 11 Entrada de alimentação 4,5V a 5,5V (sugerido: 5,0V).
GND 12 Terra do processador.
XT1 13 Clock1 da unidade de controle (até 20MHz).
XT2 14 Clock2 da unidade de controle (até 20MHz).
D0 19 Bit 0 do barramento de dados (bidirecional).
A7 24 Bit 7 do barramento de endereços.
Saída serial padrão UART 9600 bps para debug dos registradores
UART TX 25 através de um terminal. Envia informação sobre o conteúdo de todos
os registradores do processador.
UART RX 26 Entrada serial padrão UART 9600 bps para recepção de dados.
GND 31 Terra redundante do processador.
VCC 32 Entrada de alimentação redundante 4,5V a 5,5V (sugerido: 5,0V).
CLK 33 Clock principal da CPU, sensível a borda de subida.
15

Tabela 1 - Descrição dos pinos do WRP1.
*OBS.1: Interrupção externa por borda de subida.
**OBS.2: Fornece uma corrente máxima de 20mA (sink e source).
O circuito mínimo para utilização do processador WRP1 é apresentado na Figura 11.
Figura 11 - Circuito mínimo para o processador WRP1.
Como pode ser observado, temos uma memória externa, sugerimos a EEPROM 28C16,
que deve ser ligada no barramento de endereços e de dados do WRP1. Como não há
necessidade de mapearmos uma RAM externa, os pinos de habilitação e chip enable da memória
encontram-se ligados diretamente em GND. É na EEPROM que o arquivo binário estará, para ser
lido e executado pelo processador.
O pino de RESET deve ser mantido constantemente com nível lógico alto, para isso
utilizamos um resistor de pull-up. Um simples botão normalmente aberto poderá ser ligado
entre o pino de RESET e o GND, para provocar um reset no processador quando pressionado
pelo usuário. Também temos um cristal de 16MHz com capacitores de compensação para o
clock da unidade de controle. C3 é um capacitor de desacoplamento e deve situar-se próximo
aos terminais de alimentação do WRP1. O sinal de CLOCK principal pode ser qualquer sinal
retangular a níveis TTL (0 a 5V).
16
Ciclo de Busca e Execução
Na Figura 12 apresentamos o ciclo de busca por instrução e também o de execução, que

varia conforme a instrução encontrada. O ciclo de busca, independentemente da instrução, vai
necessitar de dois pulsos de clock (T0 e T1).
Figura 12 - Ciclo de Busca e Execução.
O sinal de CLOCK principal que aplicamos no pino 33 é o responsável por controlar os

ciclos de busca e execução – ou seja, a operação do processador em si – e apresenta os ciclos de
T0 até no máximo T5. Um período de clock é chamado de T Cycle. T0 e T1 são responsáveis pelo
ciclo de busca das instruções. Todas as instruções vão precisar destes dois ciclos para serem
transportadas da memória de programa para o registrador de instrução. O ciclo de execução vai
de T2 a T5, porém pode variar dependendo da instrução. Por exemplo, a instrução para enviar
o conteúdo de ACC para o registrador de saída é a oti e necessita apenas de T2 para ser
executada. Já as instruções que envolvem a unidade lógica e aritmética (por exemplo add, sub,
xor) precisam de T2 a T5.
Os ciclos de execução de cada uma das instruções serão abordados no tópico a seguir
deste manual. O período necessário para a busca e a execução completa de uma instrução
consiste no ciclo de máquina (machine cycle) do processador WRP1 e como podemos perceber,
varia de instrução para instrução pois apesar do ciclo de busca ser o mesmo, o ciclo de execução
é diferente.
17
Set de Instruções
Na Tabela 2 apresentamos o set completo de instruções do WRP1.
Set completo de instruções do Processador WRP1

Mnemônico Arg. OpCode Descrição T Cyc. Flags
nop - 00h Sem operação. 3 -
lda End. 01h ACC = UR [End.] 6 Z
add Lit. 02h ACC = ACC + B (Lit.) 6 C, Z
sub Lit. 03h ACC = ACC - B (Lit.) 6 C, Z
ldi Lit. 04h ACC = Lit. 5 Z
and Lit. 05h ACC = ACC AND B (Lit.) 6 Z
orl Lit. 06h ACC = ACC OR B (Lit.) 6 Z
xor Lit. 07h ACC = ACC XOR B (Lit.) 6 Z
not - 08h ACC = NOT ACC 3 Z
hlt - 09h Trava o processamento. 3 -
gta End. 0Ah Desvio incondicional para End. 5 -
ifz End. 0Bh Desvia para End. se flag Z estiver setada. 5 -
ifc End. 0Ch Desvia para End. se flag C estiver setada. 5 -
sta End. 0Dh UR [End.] = ACC 6 -
iti - 0Eh ACC = ITR 3 Z
oti - 0Fh OTR = ACC 3 -
csr End. 10h Chama sub-rotina localizada em End. 5 -
ret - 11h Retorna da sub-rotina. 3 -
shl Lit. 12h ACC = ACC << B (Lit.) 6 Z
shr Lit. 13h ACC = ACC >> B (Lit.) 6 Z
puh - 14h Stack [Level] = ACC 3 -
pop - 15h ACC = Stack [Level] 3 Z
ite - 16h Habilita interrupção externa. 3 -
itd - 17h Desabilita interrupção externa. 3 -
cpa Lit. 18h Compara ACC com Lit. 6 E
ife End. 19h Desvia para End. Se flag E estiver setada. 5 E
swa - 1Ah SWAP ACC (troca de nibbles) 3 -
ada End. 1Bh ACC = ACC + B (Conteúdo de End.) 6 C, Z
sba End. 1Ch ACC = ACC - B (Conteúdo de End.) 6 C, Z
ana End. 1Dh ACC = ACC AND B (Conteúdo de End.) 6 Z
ora End. 1Eh ACC = ACC OR B (Conteúdo de End.) 6 Z
xra End. 1Fh ACC = ACC XOR B (Conteúdo de End.) 6 Z
rip - 20h Retorna da interrupção. 3 -
Tabela 2 - Set Completo de Instruções do WRP1.
A seguir iremos descrever em maiores detalhes cada uma das instruções disponíveis no
processador WRP1. A Tabela 2 poderá ser utilizada como fonte de consulta rápida quando o
usuário estiver desenvolvendo softwares para o processador. Como pode ser observado, o set
é composto por um total de 33 instruções, que podem ser memorizadas com certa facilidade.
18
nop – No Operation
A instrução nop não faz nenhuma operação. Sua utilidade é justamente essa, gastar
tempo. Bastante útil quando precisamos estabilizar alguma função, gastar alguns ciclos do
processador e implementar rotinas de delay com maior precisão. Na Figura 13 apresentamos os
ciclos para executar a instrução nop e o seu OpCode. E no Box 13 um exemplo de código
Assembly usando nop.
Figura 13 - Ciclos da instrução nop.
nop ;sem operação, gasta 3 ciclos de clock

Box 1 - Exemplo de código Assembly para nop.
No Box 1 inserimos a instrução nop quatro vezes no código, totalizando 12 ciclos de

atraso do processamento. O tempo de atraso pode ser calculado como:
3
𝑡𝑑𝑒𝑙𝑎𝑦 = 𝑛º 𝑛𝑜𝑝′ 𝑠 ×
𝑓
O tempo de atraso nesse caso pode ser calculado com a equação:
3
𝑡𝑑𝑒𝑙𝑎𝑦 = 4 ×
𝑓
Sendo f a frequência de CLOCK aplicada no pino 33 do processador. A mesma equação
pode ser utilizada para calcular o tempo gasto pelas demais instruções, apenas substituindo o
numerador pelo número de ciclos pertinente a cada uma delas.
A instrução nop não afeta nenhuma flag.

19
lda – Load Accumulator
lda é uma instrução de endereçamento estendido, onde o seu argumento consiste em

um endereço localizado entre 50h e 59h na RAM interna do processador. Estes são os endereços
dos registradores do usuário, respectivamente UR0 a UR9. A instrução lda carrega o conteúdo
do endereço apresentado em seu argumento para o acumulador. Este conteúdo, se não for
carregado previamente com a instrução sta, será 00h a partir do reset. Na Figura 14 confira os
ciclos para a execução de lda e no Box 2 um exemplo de aplicação.
Figura 14 - Ciclos da instrução lda.
lda H’50’ ;carrega ACC com conteúdo de UR0

ldi H’AA’ ;carrega ACC com AAh
sta H’51’ ;salva ACC em UR1
Box 2 - Exemplo de código Assembly para lda.
Na primeira linha do Box 2, carregamos ACC com o conteúdo do endereço 50h (que
consiste no registrador UR0). Se isso ocorrer no reset ou antes de qualquer instrução sta, o
conteúdo será 00h. Após exemplificamos ldi, que carrega ACC imediatamente com o valor AAh.
Na terceira linha, sta armazena o conteúdo de ACC em UR1.
A instrução lda poderá afetar a flag Z, que será setada caso ACC receba o valor 00h.
20
add – Adição
Instrução de endereçamento imediato que soma a ACC com o conteúdo do próprio

argumento e salva o resultado no próprio ACC. Confira na Figura 15 os ciclos de operação de
uma instrução add e no Box 3 um exemplo Assembly.
Figura 15 - Ciclos da instrução add.
ldi D’011’ ;carrega ACC com 11d

add D’009’ ;ACC = 11+9
Box 3 - Exemplo de código Assembly para add.
Na primeira instrução do Box 3, carregamos ACC de forma imediata com 11 decimal e

após somamos com 9. Após a execução de add o acumulador conterá o valor 20 em decimal.
add poderá afetar as flags C e Z. Se o resultado da soma ultrapassar o limite de 8 bits

(for maior que 255), a flag C é setada. Se ACC obtiver 00h como resultado da operação, a flag Z
será setada.
21
sub – Subtração
sub também é uma instrução de endereçamento imediato que subtrai o seu argumento
de ACC e salva o resultado no próprio ACC. Na Figura 16 estão os ciclos de operação de uma
instrução sub e no Box 4 um exemplo em código Assembly.
Figura 16 - Ciclos da instrução sub.

sub D’007’ ;ACC = 53-7
Box 4 - Exemplo de código Assembly para sub.
Inicialmente ACC recebe 53 em decimal de forma imediata e após subtraímos 7. Após a

execução de sub o acumulador conterá o valor 46 em decimal.
A instrução sub poderá afetar as flags C e Z. Se o resultado da subtração for menor que
zero, a flag C é setada. Se ACC obtiver 00h como resultado da operação, a flag Z será setada.
22
ldi – Load Immediate
Esta instrução apresenta endereçamento imediato pois o seu argumento consiste em

uma literal que é carregada diretamente no acumulador. Em outras palavras, ACC recebe o
conteúdo de 8 bits do argumento de ldi. Podemos conferir na Figura 17 os ciclos de operação da
instrução e no Box 5 um código Assembly como exemplo.
Figura 17 - Ciclos da instrução ldi.
ldi H’0F’ ;carrega ACC com 15d

Box 5 - Exemplo de código Assembly para ldi.
Já vimos anteriormente alguns exemplos com ldi, no Box 5 carregamos ACC com 0Fh (ou
15d) e com auxílio de sta armazenamos este valor em UR4. Após carregamos 123d em ACC e
salvamos em UR2. Ao final da quarta instrução do Box 5, UR4 conterá 54d e tanto ACC quanto
UR2 conterão 123d.
A instrução ldi setará a flag Z caso ACC seja carregado com 00h.
23
and – Lógica E
Esta instrução realiza a operação lógica E bit a bit com endereçamento imediato. ACC
recebe o resultado da operação lógica E entre o próprio ACC e o argumento da instrução. Na
Figura 18 podemos verificar os ciclos de operação da instrução and e no Box 6 um exemplo de
utilização. Este tipo de instrução é muito útil para fazer máscara de bits, limpando os bits onde
for inserido 0.
Figura 18 - Ciclos da instrução and.
ldi H’BC’ ;carrega ACC com BCh

and H’F0’ ;and bit a bit entre ACC e B0h
Box 6 - Exemplo de código Assembly para and.
ACC recebe BCh de forma imediata (que é igual a 10111100b). Depois é realizada a
operação lógica bit a bit entre ACC e o argumento de and (no caso F0h ou 11110000b). Ao final
da operação, ACC conterá B0h pois o nibble menos significativo foi limpo (diz-se que o nibble
mais significativo recebeu uma máscara de bits).
A flag Z será setada caso ACC resulte em 00h.

24
orl – Lógica OU
Operação lógico OU bit a bit entre ACC e o próprio argumento da instrução, consistindo
portanto em instrução de endereçamento imediato. O resultado da operação é salvo no próprio
acumulador. Veja os ciclos de operação da instrução orl na Figura 19 e um exemplo de Assembly
no Box 7. Esta instrução é uma ótima alternativa para concatenar dois bytes.
Figura 19 - Ciclos da instrução orl.
ldi H’07’ ;carrega ACC com 07h

orl H’50’ ;or bit a bit entre ACC e 50h
Box 7 - Exemplo de código Assembly para orl.
Iniciamos o código carregando ACC com 07h. Após, realizamos a operação lógico OU bit
bit entre ACC e 50h. Ao final da operação, ACC conterá 57h.
A instrução orl afeta a flag Z. Caso ACC receba o valor 0 ao final de uma operação, a flag
Z será setada.
25
xor – Lógica OU Exclusivo
Operação lógica OU Exclusivo bit a bit entre o seu próprio argumento e ACC, logo é uma
instrução de endereçamento imediato. O resultado é depositado em ACC. Quando desejarmos
alterar o estado de um único bit, esta é a instrução indicada. Os bits verdadeiros do argumento
serão os responsáveis por complementar os respectivos bits do acumulador. Os ciclos de
operação da instrução xor podem ser conferidos na Figura 20 e um exemplo de software em
Assembly no Box 8.
Figura 20 - Ciclos da instrução xor.

xor H’80’ ;xor bit a bit entre ACC e 80h
xor H’80’ ;xor bit a bit entre ACC e 80h
Box 8 - Exemplo de código Assembly para xor.
ACC inicia com 00h. Fazendo xor bit a bit com 80h, o bit mais significativo de ACC ficará
com valor 1, portanto ACC conterá 80h. Repetindo a operação, ACC volta a conter 00h, pois
inverteremos novamente o bit mais significativo.
A instrução xor irá setar a flag Z se ACC contiver o valor 00h após uma operação.
26
not – Complemento de ACC
A instrução not realiza o complemento bit a bit do conteúdo do acumulador. Em outras

palavras, inverte cada um dos seus bits, o que é 0 passa a ter 1 e vice-versa. Consiste em uma
instrução de endereçamento implícito, onde a operação ocorre sempre com o acumulador, não
necessitando de argumentos. Na Figura 21 temos os ciclos de operação da not e no Box 9 um
exemplo de utilização em Assembly.
Figura 21 - Ciclos de instrução not.
ldi H’AA’ ;carrega ACC com AAh

not ;inverte todos os bits de ACC
Box 9 - Exemplo de código Assembly para not.
Após a execução de uma instrução not, o conteúdo de ACC é invertido bit a bit conforme
mencionado. No exemplo, ACC inicia com AAh (10101010b) e após a not estará com 55h
(01010101b).
A flag Z será setada caso o resultado de ACC seja 00h.

27
hlt – Halt
A instrução hlt provoca uma parada (halt) no processamento. Ao ser executada,

interrompe o sinal de CLOCK principal, se o hardware estiver configurado para isso. O pino 7 do
processador vai a nível lógico alto (HIGH) quando uma instrução hlt for encontrada. Este pino
deve ser utilizado para controle do sinal de CLOCK externo. A instrução pode ser utilizada para
avaliar resultados de operações, mantendo o valor atual em todos os registradores. As únicas
formas de fazer o processador continuar executando as instruções é através de um sinal de reset
ou de uma interrupção externa, se configurada previamente no código. Na Figura 22
apresentamos os ciclos de operação da instrução hlt e no Box 10 um exemplo de utilização em
Assembly.
Figura 22 - Ciclos da instrução hlt.
ldi D’002’ ;carrega ACC com AAh

add D’148’ ;ACC = 148+2
oti ;envia conteúdo de ACC para a saída
hlt ;para o processamento
Box 10 - Exemplo de código Assembly para hlt.
O programa do Box 10 é um teste para a instrução hlt. Iniciamos o ACC com 2d e

somamos ao valor 148d. Após add, ACC terá o valor 150d. Este valor é enviado para o registrador
de saída com a instrução oti e finalmente interrompemos o processamento com hlt, mantendo
os conteúdos de todos os registradores, que poderão ser analisados através de um terminal
configurado para 9600 bps.
A instrução hlt não afeta nenhuma flag.

28
gta – Go To Address
Instrução de desvio incondicional (go to address... / vai para endereço...). Como

argumento, requer o endereço para onde o fluxo será desviado. Este endereço pode ser um
valor em hexadecimal de acordo com o ponto em que se deseja o desvio ou realizado por
marcação de endereços relativos com labels (rótulos) no código Assembly. Instrução indicada
para a criação de loops. Os ciclos de operação da gta podem ser conferidos na Figura 23 e um
código exemplo no Box 11.
Figura 23 - Ciclos da instrução gta.
ldi H’99’ ;carrega ACC com 10011001b

loop: not ;inverte ACC agora em 01100110b
oti ;envia conteúdo de ACC para OTR
gta (loop) ;desvia para loop
Box 11 - Exemplo de código Assembly para gta.
No código do Box 11 inicialmente carregamos o acumulador com 10011001b. Inserimos

na primeira coluna do código uma label chamada de loop, que marca este endereço relativo na
memória de programa. A instrução not inverte todo o conteúdo do acumulador, que agora
conterá 01100110b. O resultado é enviado para o registrador de saída com a instrução oti, que
poderá ser inclusive visualizado através de LEDs conectados nos pinos do WRP1.
Ao executar a instrução gta, ocorre um desvio incondicional para a label loop. Em outras
palavras, program counter é carregado com o endereço onde se encontra a instrução not, que
invertá ACC novamente para 10011001b. O conteúdo é mostrado na saída e voltamos a executar
gta. E isso se repetirá enquanto o processador estiver energizado. As labels de argumento
devem estar entre parênteses para indicar que se trata de um endereço de memória.
A instrução gta não afeta nenhuma flag.

29
ifz – Desvia se Z estiver setada
ifz é uma das instruções de desvio condicional disponíveis para o WRP1. Ela requer um
endereço como argumento (também pode ser marcado através de label). Pode ser utilizada para
testes após operações de soma, subtração ou qualquer outra em que a flag Z é afetada (consulte
a Tabela 2). Se a flag Z estiver setada, significa que o conteúdo de ACC é zero. Uma instrução ifz
provocará o desvio para o endereço de seu argumento nesta situação. Os ciclos de ifz estão
explícitos na Figura 24 e também um código em Assembly no Box 12 pode ser conferido.
Figura 24 - Ciclos da instrução ifz.

loop:
sub D’001’ ;ACC = ACC-1. Decrementa ACC
ifz (final) ;desvia para label final se ACC=0
gta (loop) ;senão, desvia para loop
final:
nop ;sem operação
Box 12 - Exemplo de código Assembly para ifz.
Este exemplo do Box 12 é bem interessante e permite entendermos como utilizar

instruções de desvio condicional. Iniciamos o acumulador com o valor 25d e entramos em um
loop marcado pela respectiva label. Após subtraímos 1 do acumulador e salvamos o resultado
nele próprio com sub. Essa é a forma de fazermos decremento em Assembly para WRP1. Após,
testamos a flag Z com a instrução ifz.
Veja que na primeira iteração, ACC terá 24, que obviamente é diferente de zero, então
o desvio não ocorre. Em seguida processamos um desvio incondicional com gta, voltando para
o endereço relativo marcado pela label loop. Como continuaremos decrementando ACC, após
25 decrementos chegaremos em zero. Nesse momento, o programa desvia para a label final,
executa uma instrução nop e por fim o processador é parado com hlt.
Nenhuma flag é afetada com ifz.

30
ifc – Desvia se C estiver setada
A flag C será setada sempre que um resultado de soma ultrapassar o valor de 8 bits (255
decimal) ou quando um subtração resultar em valor negativo (BR conter um valor maior que
ACC). Podemos testar esta flag com a instrução de desvio condicional ifc, que requer um
argumento para o endereço de desvio. Se C estiver setada, o programa desvia para o endereço
(ou label) de argumento de ifc. Confira os ciclos de operação de ifc na Figura 25 e também um
código exemplo em Assembly no Box 13.
Figura 25 - Ciclos da instrução ifc.

loop:
add D’001’ ;ACC = ACC+1. Incrementa ACC
ifc (final) ;desvia se C estiver setada (valor>255)
final:
nop ;sem operação
Box 13 - Exemplo de código Assembly para ifc.
O exemplo do Box 13 é bem semelhante ao do Box 12, porém agora estamos

incrementando ACC com a instrução add. Após, testamos se passou do valor máximo de 8 bits
(255) e se isso for verdadeiro, a flag C estará setada. Portanto, desviamos para final para
interromper o processamento. Como carregamos o acumulador com 215, ele vai repetir o loop
41 vezes até extrapolar o valor.
Nenhuma flag é afetada com a execução de ifc.

31
sta – Store Accumulator
A instrução sta armazena o conteúdo do acumulador em um dos registradores do

usuário (RAM interna do WRP1). Requer um endereço de 50h a 59h, indicando em qual dos 10
registradores (UR0 a UR9) o conteúdo de ACC será armazenado para uso posterior. Veja os ciclos
de operação de sta na Figura 26 e no Box 14 um exemplo de código Assembly.
Figura 26 - Ciclos da instrução sta.

sta H’54’ ;armazena ACC no registrador UR4
add H’0A’ ;ACC = ACC+10
sta H’55’ ;armazena ACC no registrador UR5
lda H’54’ ;carrega ACC com o conteúdo de UR4
Box 14 - Exemplo de código Assembly para sta.
Com a instrução ldi salvamos a literal 31d no acumulador. Este valor é então armazenado
no registrador UR4 com a instrução sta. Os registradores disponíveis para o usuário no WRP1
são UR0 a UR9 localizados nos endereços 50h a 59h respectivamente. Em seguida somamos 10
ao acumulador (que conterá 41d). Este valor atual será armazenado em UR5. Por fim, com lda,
devolvemos o valor 31 ao acumulador, que havia sido armazenado previamente em UR4.
Nenhuma flag é alterada com a execução de sta.

32
iti – Input Instruction
A instrução iti é utilizada para a leitura do registrador ITR, que consiste no PORT de
entrada do processador WRP1. ITR tem os 5 bits menos significativos implementados (0 a 4), os
bits 5, 6 e 7 sempre serão sempre lidos como 0. Ao processar uma instrução iti o conteúdo
presente em ITR será transferido para o acumulador. Confira na Figura 27 os ciclos de operação
de uma instrução iti bem como um código exemplo no Box 15.
Figura 27 - Ciclos da instrução iti.
rdin:
iti ;armazena o conteúdo de ITR em ACC
xor H’01’ ;ACC = ACC xor 01h
ifz (press) ;desvia para press se bit 0 de ITR for HIGH
gta (rdin) ;senão, continua lendo
press:
oti ;aciona bit 7 de OTR
hlt ;interrompe o processamento
Box 15 - Exemplo de código Assembly para iti.
Um exemplo típico de leitura de uma entrada é apresentado no Box 15. Mantemos o

software no loop rdin para leitura da entrada até que o bit 0 de ITR esteja em HIGH. Isso pode
ser realizado com um botão conectado ao pino 2 do WRP1. Com a instrução xor, vamos verificar
se o bit 0 de ACC está em 1. Se estiver, xor fará com que ACC fique em zero, pois 01 xor 01
resultará no valor 0 e lembramos que o resultado sempre é salvo no acumulador. Após, a
instrução ifz fará o desvio para a label press, onde acionaremos o bit 7 do registrador de saída,
pausando a execução com hlt.
Iti não afeta nenhuma flag.

33
oti – Output Instruction
Quando desejamos escrever no PORT de saída, que consiste no registrador OTR,

utilizamos a instrução oti. Basicamente, a instrução transfere o conteúdo do acumulador para o
registrador de saída e já vimos alguns exemplos dela para ilustrar aplicações de instruções
anteriores. Na Figura 28, apresentamos os ciclos de operação da instrução oti e no Box 16 um
novo exemplo de aplicação em Assembly.
Figura 28 - Ciclos da instrução oti.
loop:
ldi H’AA’ ;carrega ACC com 10101010b
oti ;aciona saídas de OTR
oti ;aciona saída de OTR
gta (loop) ;loop infinito
Box 16 - Exemplo de código Assembly para oti.
No Box 16 temos um clássico exemplo de Hello World, que simplesmente aciona as

saídas do PORT OTR trocando os dados entre 10101010b e 01010101b. Pode-se verificar o
funcionamento deste código através de LEDs conectados ao PORT de saída.
Não temos alterações em quaisquer flags com a execução de oti.

34
csr – Call Subroutine
Esta instrução efetua a chamada de sub-rotinas localizadas no endereço do seu

argumento. Geralmente, utilizamos labels para nomear as sub-rotinas em nosso código,
marcando assim, o seu endereço relativo na memória de programa e deixando o código mais
inteligível. Após uma instrução csr, o conteúdo atual do program counter é salvo na pilha de
memória, pois o processador precisará executar no endereço seguinte após sair da sub-rotina
chamada. A csr tem os ciclos de operação exibidos na Figura 29 e um exemplo de código pode
ser analisado no Box 17.
Figura 29 - Ciclos da instrução da csr.
loop:
csr (adder) ;chama sub-rotina de soma
oti ;envia resultado para OTR
adder:
add H’02’ ;soma 2
ret ;retorna
Box 17 - Exemplo de código Assembly para csr.
No Box 17 apresentamos o exemplo de uma sub-rotina bem simples que soma 2 e depois
5 ao conteúdo do acumulador e então retorna para o código principal. No loop, temos a carga
inicial do acumulador, seguida da chamada da sub-rotina com csr. Nesse momento, o conteúdo
de PC é salvo na pilha e então ocorre o desvio para o endereço de adder. Ao executar uma
instrução ret (retorno), devolvemos o endereço para o program counter para executar a próxima
instrução, no caso oti, que mostrará o conteúdo de ACC no registrador de saída. Por fim,
desviamos de volta para loop com a instrução gta e mantemos em loop infinito.
csr também não afeta nenhuma flag.

35
ret – Return
Sempre que uma sub-rotina termina, precisamos inserir a instrução ret, para que o
processador restaure o conteúdo de PC da pilha de memória. Após e execução de ret, o program
counter recebe o conteúdo que tinha antes da chamada da sub-rotina, para executar a instrução
ligeiramente após a chamada. Na Figura 30 apresentamos os ciclos de operação da instrução ret
e no Box 18 o código Assembly exemplo.
Figura 30 - Ciclos da instrução ret.
setout:
oti ;envia para a sáida
oti ;envia para a saída
ret ;retorna
Box 18 - Exemplo de código Assembly para ret.
Apresentamos uma sub-rotina simples para acionar os bits 3 e 4 do PORT de saída e

depois retornar ao código principal. Lembrando que setout deverá ter sido chamada pela
instrução csr no código principal.
A instrução ret não afeta nenhuma flag.

36
shl – Shift Left
Deslocamento de ACC bit a bit para a esquerda. Utiliza uma literal como argumento, que
indica quantas vezes os bits serão deslocados para a esquerda. Na Figura 31 apresentamos os
ciclos de operação de shl e no Box 19 um código exemplo.
Figura 31 - Ciclos da instrução shl.

shl H’01’ ;desloca ACC 1x: 01100010b
shl H’04’ ;desloca ACC 4x: 00100000b
Box 19 - Exemplo de código Assembly para shl.
Iniciamos ACC com 31h e depois deslocamos todos os bits uma vez para a esquerda com
shl. Com uma nova shl deslocamos ACC para a esquerda mais 4 vezes. Observe que os bits são
perdidos quando ultrapassam o limite de 8 bits. Esta instrução pode ser utilizada para
multiplicação por 2, 4, 8, 16, etc.
shl afeta a flag Z.

37
shr – Shift Right
Deslocamento para a direita de ACC bit a bit. O argumento necessário para shr é uma
literal que indica o número de deslocamentos. Os ciclos de operação de shr estão expostos na
Figura 32 e no Box 20 temos um exemplo de código Assembly.
Figura 32 - Ciclos da instrução shr.

shr H’01’ ;desloca ACC 1x: 00011000b
shr H’04’ ;desloca ACC 4x: 00000001b
Box 20 - Exemplo de código Assembly para shr.
Utilizamos um exemplo bem semelhante ao do Box 19, pois shr é a instrução oposta a
shl. Como podemos ver, os bits do acumulador são deslocados para a direita e são perdidos se
ultrapassarem a faixa de 8 bits. Esta instrução poderá ser utilizada para divisão por 2, 4, 8, 16,
etc.
A flag Z é afetada com shr.

38
puh – Push to the top
A instrução puh empurra para o topo da pilha o conteúdo de ACC (push to the top). É
uma instrução de endereçamento implícito e não requer argumentos. Após sua execução, o
conteúdo atual de ACC é armazenado no topo da pilha de memória. Função bastante útil para
salvar algum contexto em nossos códigos. Os ciclos de operação da puh podem ser conferidos
na Figura 33, bem como um exemplo Assembly no Box 21.
Figura 33 - Ciclos da instrução puh.

puh ;”empurra” para o topo da pilha
add D’002’ ;soma 2
sta H’51’ ;armazena em UR1
pop ;recupera o ACC original (18d)
Box 21 - Exemplo de código Assembly para puh.
Quando desejamos salvar rapidamente o conteúdo de ACC, podemos recorrer à

instrução puh, efetuar outros cálculos e recuperar o conteúdo original com pop. No exemplo do
Box 21, recuperamos 18d após efetuar a soma com 2 e salvar em um registrador do usuário.
puh não afeta nenhuma flag.

39
pop – Pull from the top
É a dual da puh. Para recuperar o topo da pilha de volta para o acumulador (puxa do
topo), utilizamos pop, que também não requer argumentos e é de endereçamento implícito. Na
Figura 34 estão presentes os ciclos de operação de pop e um exemplo é dado Box 22.
Figura 34 - Ciclos da instrução pop.
ldi H’5E’ ;carrega ACC com 5Eh

puh ;salva no topo da pilha
sub D’015’ ;subtrai 15
pop ;”puxa” do topo da pilha e salva em ACC (5Eh)
Box 22 - Exemplo de código Assembly para pop.
Este exemplo é semelhante ao do Box 21, pois salvamos previamente ACC no topo da
pilha de memória com puh, efetuamos outros cálculos, salvando o resultado em UR6 e então
recuperamos o dado 5Eh do topo da pilha com pop.
A instrução pop afetará a flag Z se o conteúdo recuperado for zero.

40
ite – Interrupt Enable
O processador WRP1 apresenta interrupções externas em seu PORT de entrada, que são
sensíveis a borda de subida. Para habilitá-las, só precisamos da instrução ite. Após esta
instrução, o WRP1 irá desviar para os vetores de interrupção referentes a cada pino de
interrupção externa, quando estes receberem um sinal em borda de subida. Confira os ciclos de
operação de ite na Figura 35 e um exemplo no Box 23.
Figura 35 - Ciclos da instrução ite.
gta (begin) ;desvia para a label begin

isr0:
not ;complementa ACC
begin:
ite ;habilita interrupções
loop:
gta (loop) ;aguarda interrupção
Box 23 - Exemplo de código Assembly para ite.
No Box 23 temos um exemplo típico de uso da interrupção externa 0. Quando ocorrer

uma borda de subida no pino int0 (transição de low para high), o programa desvia para a label
isr0 e inverte todo o conteúdo do acumulador. Observe que antes do loop, que fica enviando
ACC para a saída e aguardando a interrupção, habilitamos as interrupções com ite.
Esta instrução não afeta nenhuma flag.

41
itd – Interrupt Disable
Esta instrução é utilizada para desabilitar as interrupções caso necessário. Obviamente,

itd só terá algum efeito no código se antes dela as interrupções forem devidamente habilitadas
com ite. Veja na Figura 36 os ciclos de operação de itd e um exemplo em Assembly no Box 24.
Figura 36 - Ciclos da instrução itd.
gta (begin) ;desvia para a label begin
isr0:
csr (count) ;chama sub-rotina count
rip ;retorna da interrupção
begin:
loop:
count:
sub D’001’ ;subtrai 1 de ACC
ifz (final) ;se chegou em zero, desvia para final
ret ;senão, retorna
final:
itd ;desabilita interrupções
ret ;retorna
Box 24 - Exemplo de codigo Assembly para itd.
Um contador de pulsos foi implementado no Box 24. Iniciamos carregando o valor 64h
em ACC e habilitando as interrupções. No loop, mostramos o conteúdo atual de ACC no
registrador de saída e aguardamos a interrupção. Com uma borda de subida em int0, o programa
desvia para isr0 que é a chamada para a sub-rotina count. Lá, decrementamos ACC em 1 e
verificamos se chegou em zero com ifz. Caso não, retornamos e continuamos o processo. Caso
tenha chegado em 0, desviamos para final, desabilitamos as interrupções e retornamos.
itd não afeta nenhuma flag.

42
cpa – Compare Accumulator
A instrução cpa compara o conteúdo do acumulador com sua literal. Se os conteúdos

forem iguais, a flag E (equal) é setada e poderá ser testada com a instrução ife. Quando
desejamos realizar um desvio condicional ao verificar que ACC contém um valor específico, esta
é a instrução indicada. Veja os ciclos de operação de cpa na Figura 37 e no Box 25 um exemplo
de código.
Figura 37 - Ciclos da instrução cpa.
loop:
add H’01’ ;incrementa ACC
cpa H’0A’ ;se chegou em 10, seta flag E
ife (final) ;se E setada, desvia para final
final:
oti ;mostra na saída
Box 25 - Exemplo de código Assembly para cpa.
Uma forma de compararmos o acumulador com o valor desejado é apresentada no Box

25. No caso, incrementamos ACC até o valor 10. Quando chegar em 10, desviamos para encerrar
o programa. Normalmente utilizaremos cpa em conjunto com ife.
A instrução cpa coloca a flag E em HIGH se o conteúdo de ACC for igual ao seu
argumento.
43
ife – Desvia se E estiver setada
Para testar a flag E do WRP1, utilizamos a instrução ife. A flag E será setada pela
instrução cpa caso o conteúdo do acumulador seja igual ao do argumento de cpa. ife realiza o
desvio para o endereço do seu argumento, se a flag E estiver setada. Na Figura 38 podem ser
verificados os ciclos de operação da ife bem como um código exemplo no Box 26.
Figura 38 - Ciclos da instrução ife.
loop:
sub H’02’ ;decrementa de 2 em 2 ACC
cpa D’026’ ;se chegou em 26, seta flag E
ife (final) ;se E setada, desvia para final
final:
oti ;mostra ACC na saída
Box 26 - Exemplo de código Assembly para ife.
No Box 26 iniciamos ACC com 100 e decrementamos de 2 em 2. Após comparamos com

o valor 26d e testamos a flag E. O loop repete até ACC atingir 26, onde a instrução ife provocará
o desvio para a label final, mostrando o valor na saída e interrompendo o processamento com
hlt.
A instrução ife limpa a flag E para que novos testes de comparação possam ocorrer.
44
swa – Swap Accumulator
A instrução swa é de endereçamento implícito e provocará uma troca entre os nibbles

do acumulador. Após a execução de um swap (troca), ACC terá os seus nibbles invertidos. Por
exemplo se ACC está com o conteúdo A7h, após um swa estará com 7Ah. Na Figura 39 é possível
verificar os ciclos de operação da swa e também um exemplo em Assembly no Box 27.
Figura 39 - Ciclos da instrução swa.

swa ;troca nibbles de ACC: 61h
and H’F0’ ;ACC=60h
orl H’05’ ;ACC=65h
swa ;troca nibbles de ACC: 56h
Box 27 - Exemplo de código Assembly para swa.
Efetuamos duas trocas de nibbles no acumulador no exemplo do Box 27. Primeiro o

iniciamos com 16h e invertemos para 61h com swa. Fazemos uma máscara de bits com and para
preservar o valor 6h. Depois concatenamos com orl 05h resultando em 65h no acumulador.
Invertemos novamente ACC com swa para resultar em 56h.
Nenhuma flag é afetada com o uso de swa.

45
ada – Add Address Contents
A instrução ada soma o conteúdo do acumulador com o conteúdo do endereço de seu

argumento, que será de 50h a 59h (registradores do usuário UR0 a UR9). É portanto, uma
instrução de endereçamento estendido. O resultado da soma é depositado no próprio
acumulador. Na Figura 40, pode-se observar os ciclos de operação da ada e também um
exemplo em Assembly no Box 28.
Figura 40 - Ciclos da instrução ada.

ada H’50’ ;ACC = ACC + UR0
oti ;mostra resultado
Box 28 - Exemplo de código Assembly para ada.
Outro método de realizar a soma de dois valores é apresentado no Box 28. A vantagem
em relação à instrução add é que poderemos ter o valor utilizado como segundo operando da
soma previamente armazenado no processador. Em códigos mais complexos isso pode ser
especialmente útil.
No exemplo, carregamos 64h em ACC e armazenamos em UR0 com sta. Em seguida,

carregamos ACC com 02h e realizamos a soma por endereçamento estendido com ada. Logo,
somamos ACC com o conteúdo do endereço 50h e salvamos no próprio ACC. Depois,
apresentamos o resultado no registro de saída (no caso 66h) e paramos o processamento.
Se ACC resultar em 0, a flag Z será setada com esta instrução. Se o resultado da soma
ultrapassar o range de 8 bits (maior que 255), a flag C será setada.
46
sba – Subtract Address Contents
sba funciona de forma semelhante à ada, porém realiza a subtração entre ACC e o
conteúdo do endereço usado como argumento, que deve ser na faixa entre 50h e 59h para
acessar os registradores do usuário UR0 a UR9. Confira os ciclos de operação de sba na Figura
41, bem como um exemplo em Assembly no Box 29.
Figura 41 - Ciclos da instrução sba.
ldi H’0A’ ;carrega ACC com 10d

add H’02’ ;ACC = ACC + 2
sba H’55’ ;ACC = ACC – UR5
Box 29 - Exemplo de código Assembly para sba.
Como podemos observar há uma diferença entre as instruções de endereçamento

imediato e estendido, analise o código do Box 29. Primeiro, o acumulador recebe 10 em decimal
e este valor é salvo em UR5 com sta. Após, somamos 2 a ACC, com add, que é a instrução de
endereçamento imediato para a soma. Logo, o acumulador conterá 12 em decimal. Por fim,
subtraímos 10 do acumulador, com sba, que utiliza endereçamento estendido (o conteúdo atual
de 55h é 10 que havia sido salvo por sta previamente). Mostramos o resultado e paramos o
processamento.
As flags C e Z serão afetadas com sba, se o resultado da subtração der um número

negativo ou se resultar em zero, respectivamente.
47
ana – AND Address Contents
A instrução ana realiza a operação AND bit a bit entre o acumulador e o conteúdo do
endereço usado como argumento. Portanto, também é uma instrução de endereçamento
estendido. O resultado é armazenado no próprio ACC. Poderemos com isso ter o conteúdo do
operando salvo previamente em um dos registradores do usuário, UR0 a UR9, localizados entre
50h e 59h. Os ciclos de operação da instrução ana podem ser verificados na Figura 42 e um
código Assembly exemplo no Box 30.
Figura 42 - Ciclos da instrução ana.
ldi H’0F’ ;carrega ACC com 0Fh

ana H’52’ ;ACC = ACC AND UR2
ldi H’8D’ ;carrega ACC com 8Dh
ana H’52’ ;ACC = ACC AND UR2
oti ;mostrará o valor 0Dh
lda H’54’ ;carrega ACC com conteúdo de UR4
oti ;mostrará o valor 05h
Box 30 - Exemplo de código Assembly para ana.
No código do Box 30 trabalhamos com uma máscara de bits que foi carregada
inicialmente no ACC, para preservar o nibble menos significativo (0Fh). Salvamos esta máscara
em UR2 para utilizar em mais operações. Sempre que quisermos utilizar 0Fh poderemos recorrer
à instrução ana com o endereço 52h como argumento. O código exibe dois resultados de
exemplo e depois interrompe o processamento.
Se o resultado da operação for 0, a instrução ana setará a flag Z.

48
ora – OR Address Contents
Lógica OU bit a bit entre ACC e o conteúdo do endereço usado como argumento para a
instrução ora. O resultado da operação é armazenado em ACC. Esta instrução também opera
com endereçamento estendido e poderemos fazer a lógica OU entre o acumulador e o conteúdo
de um dos registradores UR0 a UR9, localizados nos endereços 50h a 59h. Confira os ciclos de
operação de ora na Figura 43 e também um código Assembly no Box 31.
Figura 43 - Ciclos da instrução ora.

ldi H’0C’ ;carrega ACC com 0Ch
ora H’58’ ;ACC = ACC OR UR8
hlt ;interrompe processamento
Box 31 - Exemplo de código Assembly para ora.
No Box 31 concatenamos os bytes 70h com 0Ch. Primeiro salvamos 70h no registrador
do usuário UR8. Após carregamos 0Ch no acumulador e realizamos a OU lógica bit a bit entre
ACC e o conteúdo de UR8 (endereço 58h). O resultado será 7Ch.
Se o resultado da operação for 0, a flag Z será setada após uma ora.

49
xra – XOR Address Contents
Da mesma forma que as duas instruções anteriores (ana e ora), a instrução xra realiza a
operação bit a bit só que da lógica XOR entre o acumulador e o conteúdo do endereço utilizado
como argumento. Também é uma instrução de endereçamento estendido. O usuário poderá
salvar previamente um valor com sta e utilizar xra para inverter bits específicos de ACC. Os ciclos
de operação de xra estão explícitos na Figura 44 e no Box 32 há um exemplo em Assembly. A
faixa de endereços possíveis no WRP1 para xra é 50h a 59h, assim como as demais instruções
de endereçamento estendido, que trabalham com os registradores do usuário.
Figura 44 - Ciclos da instrução xra.

sta H’51’ ;salva em UR1
loop:
xra H’51’ ;inverte apenas os bits 5 e 4
oti ;mostra na saída
gta (loop) ;desvia para loop
Box 32 - Exemplo de código em Assembly para xra.
No Box 32, carregamos 30h no acumulador (00110000b) e depois salvamos em UR1,

visando utilizar com a lógica XOR para inverter apenas os bits 5 e 4. Entremos em um loop e
invertemos estes dois bits do acumulador com xra. Mostramos na saída e assim mantemos em
loop.
A instrução xra afeta a flag zero.

50
rip – Return Interrupt
A instrução rip é bastante semelhante à ret, porém deve ser utilizada para o processador
retornar de uma chamada de interrupção. A principal diferença, é que rip armazena o contexto
do registrador de FLAGS, pois seu conteúdo é necessário para desvios condicionais e uma
alteração em rotina de interrupção poderá causar um funcionamento errático quando estiver
de volta para o programa principal. Os ciclos de operação da instrução rip podem ser conferidos
na Figura 45 e um código Assembly de exemplo está no Box 33.
Figura 45 - Ciclos da instrução rip.
gta (princ) ;desvia do vetor de interrupção

isr0:
nop ;sem operação
princ:
ldi H’CC’ ;carrega ACC com CCh
loop:
oti ;envia ACC para OTR
Box 33 – Exemplo de código em Assembly para rip.
O código inicia com o desvio do vetor de interrupção 02h (vetor da interrupção externa
0). No programa principal, ACC é carregado com CCh e habilitamos as interrupções com ite. No
loop infinito, enviamos ACC para OTR e aguardamos uma borda de subida em int0. Quando
ocorrer, o processador desvia para o vetor de interrupção, complementa ACC, executa uma nop
para completar 3 bytes no vetor e em seguida retorna da interrupção com rip.
Em resumo, sempre que houver uma borda de subida no pino int0, inverteremos o
conteúdo de ACC bit a bit.
A instrução rip não afeta nenhuma flag.

51
Organização de Memória
O processador WRP1 foi desenvolvido para trabalhar principalmente com uma memória
ROM externa (pode-se utilizar EPROM ou EEPROM). Como seu barramento de endereços é de 8
bits, com uma organização simples é possível trabalhar com até 256 bytes de memória de
programa. O usuário poderá expandir esta memória, dividindo entre mais ROMs externas, além
de mapear uma memória RAM para expansão. No entanto a maioria das aplicações para o qual
o WRP1 foi projetado são atendidas com uma ROM de 256 bytes. Confira na Figura 46 a
organização de memória do dispositivo.
Figura 46 - Organização de memória do WRP1.
Como pode-se observar, temos o vetor de RESET localizado no endereço 00h de

memória e mais 5 vetores para as fontes de interrupção do processador. O restante fica
disponível para a memória de programa principal. Caso o código desenvolvido não apresente
interrupções, toda a área de memória (de 00h a FFh) poderá ser utilizada para a memória de
programa.
52
Interrupções
Conforme visto na organização de memória, o WRP1 tem 5 vetores de interrupção, pois

contém 5 entradas para interrupção externa por borda de subida, habilitadas através da
instrução ite e desabilitadas através da instrução itd. Na Tabela 3 apresentamos as 5 fontes de
interrupção disponíveis, onde o usuário deverá organizar os seus algoritmos de tratamento das
mesmas.
Interrupção Vetor (End.) Descrição

int0 02h Desvia para 02h após uma borda de subida no pino int0
int3 0Bh Desvia para 0Bh após uma borda de subida no pino int3
int4 0Eh Desvia para 0Eh após uma borda de subida no pino int4
Tabela 3 - Fontes de interrupção do WRP1.
O funcionamento da interrupção ocorre da seguinte forma: caso houver uma instrução

ite (interrupt enable), todas as interrupções estarão habilitadas. Se ocorrer uma borda de subida
(transição de low para high) no pino int0, o programa é desviado para o endereço 02h, se ocorrer
no int1, para o 05h e assim por diante de acordo com a tabela 3. É importante destacar que cada
interrupção tem 3 bytes disponíveis, logo, se for necessário o uso de mais instruções, o usuário
deverá optar pela chamada de uma sub-rotina, conforme Box 34.
gta (princ) ;desvia do vetor de interrupção

isr0:
csr (trata0) ;chama sub-rotina para tratar interrupção 0
isr1:
;aqui virá o código para a interrupção 1 por exemplo
princ:
ldi H’76’ ;carrega 76h no ACC
loop:
oti ;mostra informação na saída
trata0:
add D’015’ ;soma 15
sub D’008’ ;subtrai 8
xor H’80’ ;complementa bit mais significativo
ret ;retorna
Box 34 - Exemplo de tratamento de interrupção com sub-rotina.
A sub-rotina “trata0” presente no Box 34 tem um total de 6 bytes, que iriam

sobrescrever o endereço do vetor da interrupção 1 (int1) – que no caso está em uso sinalizado
pela label isr1 – por este motivo, estamos utilizando a chamada da sub-rotina no vetor da
interrupção 0. Observe que preenchemos o vetor isr0 com exatos 3 bytes (csr mais argumento
e a instrução rip). Obviamente este procedimento não é necessário caso utilizemos apenas uma
fonte de interrupção ou optemos por utilizar vetores mais distantes entre si, como int0 e int4.
53
Conclusão
Desenvolvemos o processador WRP1 para ser bastante completo e permitir as mais

diversas operações por parte do usuário, ao mesmo tempo que apresenta um set de instruções
reduzido, facilitando o seu aprendizado.
Nesta primeira versão, optamos pelo minimalismo e todas as instruções foram

implementadas de modo a não precisar de argumentos ou conter no máximo um argumento. O
fato de termos apenas um argumento por instrução traz como desvantagem a necessidade de
algoritmos um pouco mais extensos, que em alguns casos seriam resolvidos com menos linhas
através de instruções de dois ou mais argumentos.
Não há dúvidas de que o processador servirá para o desenvolvimento de muitos projetos

envolvendo eletrônica, processamento, sistemas de automação, lógica, entre outros. De
qualquer forma, futuras atualizações poderão surgir e até mesmo uma versão do WRP2.

WRP1 User Manual

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

WRP1 User Manual

Enviado por

Direitos autorais:

Formatos disponíveis

WRP1 MANUAL DO USUÁRIO

Arquitetura, Operação e Instruções do Processador

ifc – Desvia se C estiver setada ............................................................................................... 30

Figura 35 - Ciclos da instrução ite. .............................................................................................. 40

O processador WRP1 é um dispositivo de 8 bits desenvolvido para trabalhar na

Vamos entender toda a arquitetura do WRP1 em detalhes agora.

A arquitetura do WRP1 pode ser conferida na Figura 1.

Figura 1 - Arquitetura do processador WRP1.

Vamos agora conhecer cada bloco do processador WRP1.

Memory Address Register (MAR: registrador de endereços de memória): armazena o valor do

normalmente só é necessária a utilização de uma ROM, já que o processador dispõe de alguns

Estão presentes no processador os registradores especiais conforme a Figura 2 e aqui

Figura 2 - Registradores especiais do WRP1.

Os registradores especiais disponíveis são os utilizados para interfaces de entrada e

Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

Na Figura 4 apresentamos o Registrador B. Poderá conter valores de 00h a FFh, pois é

Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

Confira na Figura 5 o Registrador de Instruções. É nele que o opcode de 8 bits referente

Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

Figura 5 - Registrador de Instruções.

O Registrador de Argumentos tem o mesmo aspecto e está explícito na Figura 6. Quando

Bit 7 Bit 6 Bit 5 Bit 4 Bit 3 Bit 2 Bit 1 Bit 0

Figura 6 - Registrador de Argumentos.

Out 7 Out 6 Out 5 Out 4 Out 3 Out 2 Out 1 Out 0

Figura 7 - Registrador de Saída.

- - - In/Int 4 In/Int 3 In/Int 2 In/Int 1 In/Int 0

Figura 8 - Registrador de Entrada.

O registrador de FLAGS apresenta 8 bits, porém apenas os três menos significativos

Figura 9 - Registrador de FLAGS.

Descrição dos Pinos

O processador WRP1 consiste em um circuito integrado de 40 pinos em encapsulamento

Figura 10 - Pinos do processador WRP1.

O processador efetua a busca e a execução das instruções a partir do endereço 00h de

A Tabela 1 apresenta a descrição de todos os pinos do processador WRP1, por ordem

Nome do Pino Nº Descrição

A6 40 Bit 6 do barramento de endereços.

*OBS.1: Interrupção externa por borda de subida.

**OBS.2: Fornece uma corrente máxima de 20mA (sink e source).

O circuito mínimo para utilização do processador WRP1 é apresentado na Figura 11.

Figura 11 - Circuito mínimo para o processador WRP1.

Ciclo de Busca e Execução

Na Figura 12 apresentamos o ciclo de busca por instrução e também o de execução, que

Figura 12 - Ciclo de Busca e Execução.

O sinal de CLOCK principal que aplicamos no pino 33 é o responsável por controlar os

Na Tabela 2 apresentamos o set completo de instruções do WRP1.

Set completo de instruções do Processador WRP1

Figura 13 - Ciclos da instrução nop.

nop ;sem operação, gasta 3 ciclos de clock

Box 1 - Exemplo de código Assembly para nop.

No Box 1 inserimos a instrução nop quatro vezes no código, totalizando 12 ciclos de

A instrução nop não afeta nenhuma flag.

lda – Load Accumulator

lda é uma instrução de endereçamento estendido, onde o seu argumento consiste em

Figura 14 - Ciclos da instrução lda.

lda H’50’ ;carrega ACC com conteúdo de UR0

Box 2 - Exemplo de código Assembly para lda.

Na terceira linha, sta armazena o conteúdo de ACC em UR1.

Instrução de endereçamento imediato que soma a ACC com o conteúdo do próprio

Figura 15 - Ciclos da instrução add.

ldi D’011’ ;carrega ACC com 11d

Box 3 - Exemplo de código Assembly para add.

Na primeira instrução do Box 3, carregamos ACC de forma imediata com 11 decimal e

add poderá afetar as flags C e Z. Se o resultado da soma ultrapassar o limite de 8 bits