Módulo 1

Laboratório de Sistemas Microprocessados Digitais
02/2020 – Ensino Remoto
Módulo 1: Programação Assembly

ORIENTAÇÃO:
Este módulo é composto por 16 exercícios e pelo Problema 1. Os exercícios não precisam ser
apresentados, ou seja, eles não recebem visto. Servem apenas para que o aluno desenvolva
sua habilidade de programação. De acordo com sua conveniência, trabalhe com os diversos
exercícios e use o horário do laboratório para esclarecer suas dúvidas. Apenas o Problema 1
deve receber o visto (nota), que só será validado após o upload de seu programa solução. Serão
especificadas as datas limite para o visto e o upload.
OBJETIVO DESTE MÓDULO:

Usar a solução de pequenos programas para desenvolver o entendimento e o uso do assembly
do MSP430.
Introdução: declarando vetores na memória

Para este módulo usaremos vetores de números ou letras. Para facilitar, vamos adotar a
formatação ilustrada abaixo. Note que para indicar o vetor, a única referência necessária é a do
endereço de início, pois a primeira posição já indica seu tamanho. Os elementos podem ser
bytes, palavras de 16 bits (W16) ou palavras de 32 bits (W32). Para o caso de letras, usaremos
a Tabela ASCII, disponível no final deste documento.
O exemplo abaixo indica como inicializar a memória de dados com o vetor do exemplo acima.
Note que este vetor é composto apenas por bytes.
;----------------------------------------------------------------------------
; Segmento de dados inicializados (0x2400)
;----------------------------------------------------------------------------
.data
; Declarar vetor com 5 elementos [4, 7, 3, 9, 2]
vetor: .byte 0x05, 0x04, 0x07, 0x03, 0x09, 0x02
1
IMPORTANTE: A solução sempre será uma sub-rotina, por isso, o programa deve ter a
seguinte organização:
;----------------------------------------------------------------------------
; Main loop here
;----------------------------------------------------------------------------
mov #vetor,R5 ;inicializar R5 com o endereço do vetor
call #subrot ;chamar sub-rotina
jmp $ ;travar execução ao retornar da sub-rotina
subrot: ...
...
ret
Exercícios:
Exercício 1:
Escreva a sub-rotina MENOR que recebe em R5 o endereço de início de um vetor de bytes (sem
sinal) e retorna:
• R6  menor elemento do vetor e
• R7  qual sua frequência (quantas vezes apareceu)
Para este programa, declare um vetor de bytes formado pela concatenação do código ASCII
(veja tabela no final deste documento) dos nomes completos de cada membro da equipe. Note
que o montador já converte as letras para o código ASCII correspondente, como mostrado
abaixo. Use letras maiúsculas, omita os espaços e não use acentos. Preste atenção ao tipo das
aspas.
.data
; Declarar vetor com 11 elementos [JOAQUIMJOSE]
vetor: .byte 11,”JOAQUIMJOSE”
Dica 1: Você pode declarar o vetor em várias linhas, caracter a caracter
Rótulo (col 1) Instrução (col 13) Operandos (col 21) Comentários (col 45-80)
.data ; Início da seção de dados
vetor: .byte 11,'J','O','A' ; Declara o vetor de 11
.byte 'Q','U','I','M' ; elementos em várias
.byte 'J','O', 'S','E' ; linhas
Ou colocar tudo junto: vetor: .byte 11,”JOAQUIMJOSE”
Dica 2: Você pode visualizar a memória do MSP430 a qualquer momento no Code Composer
Studio. Basta abrir a janela do navegador de memória : “Windows”  “Show View”  “Memory
Browser”. Use a visualização “8-Bit Hex TI-Style” e navegue para o endereço 0x2400 para ver o
seu vetor.
2
Exercício 2:
Escreva a sub-rotina MAIOR16 que recebe em R5 o endereço de início de um vetor de palavras
de 16 bits (words ou W16) sem sinal e retorna:
• R6  maior elemento do vetor e
• R7  qual sua frequência (quantas vezes apareceu)
Use o mesmo vetor do Exercício 1, mas agora seu programa irá interpretar cada elemento como
sendo composto por 2 bytes (2 letras). Assim, o tamanho do vetor deve cair para a metade. No
caso de uma quantidade ímpar de letras, como acontece com o exemplo acima, é preciso um
cuidado extra. Eram 11 letras, então reduzimos o tamanho para 6 (não tem sentido usar 5,5) e
acrescentamos um zero no final do vetor, para completar a quantidade. Cuidado: o tamanho
precisa ser declarado em 2 bytes (16 bits). No exemplo abaixo, o primeiro elemento será 0x4F4A,
já que ASCII(O) = 0x4F e ASCII(J) = 0x4A. Note a inversão, pois é “little endian”!
.data
; Declarar vetor com 11 elementos [JOAQUIMJOSE]
vetor: .byte 6,0, ”JOAQUIMJOSE”,0
Observação: apenas para ampliar o conhecimento, também seria possível fazer a declaração da
forma mostrada abaixo. Para escrever o programa, não use este tipo de declaração!
.data
; Declarar vetor com 6 elementos de 16 bits [JOAQUIMJOSE]
vetor: .word 6,‘JO’,’AQ’,’UI’,’MJ’,’OS’,’E’
Dica 3: Se você estiver utilizando o visualizador de memória, é recomendável alterar a
visualização para “16-Bit Hex - TI Style”
Exercício 3:
Escreva a sub-rotina M2M4 que recebe em R5 o endereço de início de um vetor de bytes e
retorna:
• R6  quantidade de múltiplos de 2, R7  quantidade de múltiplos de 4
De forma semelhante ao Exercício 1, declare um vetor de bytes formado pela concatenação do

código ASCII dos nomes completos de cada membro da equipe.
Exercício 4:
Escreva sub-rotina EXTREMOS que recebe em R5 o endereço de início de um vetor com
palavras de 16 bits (W16) com sinal e retorna:
• R6  menor elemento, R7  maior elemento
Para este exercício, vamos formar o vetor usando o número de matrícula e o ano de nascimento
de cada membro da equipe. Veja o exemplo para uma equipe com 2 alunos:
Aluno 1: matrícula = 12/1234567 e nasceu em 1990  121, 234, 567, -1990.
Aluno 2: matrícula = 11/786745 e nasceu em 1980 (está velho)  117, 867, 45, -1980
.data
; Declarar vetor com 8 elementos [121, 234, 567, -1990, 117, 867, 45, -1980]
vetor: .word 8, 121, 234, 567, -1990, 117, 867, 45, -1980
3
Exercício 5:
Escreva a sub-rotina SUM16 que armazena a soma (elemento a elemento) de dois vetores de
16 bits de mesmo tamanho.
R5 = 0x2400  endereço do vetor 1;
R6 = 0x2410  endereço do vetor 2;
R7 = 0x2420  endereço do vetor soma.
.data
; Declarar os vetores com 7 elementos
Vetor1: .word 7, 65000, 50054, 26472, 53000, 60606, 814, 41121
Vetor2: .word 7, 226, 3400, 26472, 470, 1020, 44444, 12345
Exercício 6:
Escreva a sub-rotina SUM_TOT que armazena o somatório de todos os elementos dos vetores
1 e 2 do exercício anterior. O resultado desta soma precisa de 32 bits e para tanto use a
concatenação dos registradores R8 (MSW) e R7 (LSW).
MSW = Most Significant Word e LSW = Least Significant Word
Exercício 7:
Escreva a sub-rotina FIB, que armazena na memória do MSP a partir da posição 0x2400 os
primeiros 20 números da sequência de Fibonacci. Use representação de 16 bits sem sinal.
Exercício 8:
Escreva a sub-rotina FIB16, que armazena em R10 o maior número da sequência de Fibonacci
a “caber” dentro da representação de 16 bits.
Exercício 9:
Escreva a sub-rotina FIB32, que armazena em R11 (MSW) e R10 (LSW) o maior número da
sequência de Fibonacci a “caber” dentro da representação de 32 bits.
Exercício 10:
Escreva a sub-rotina W16_ASC que recebe em R6 um número (sem sinal) de 16 bits e escreve
a partir do endereço 0x2400 o código ASCII correspondente ao valor hexadecimal de cada nibble
(4 bits). A sugestão é para criar a sub-rotina NIB_ASC, que converte um nibble em ASCII e
depois usar essa sub-rotina 4 vezes. Use R5 como ponteiro para escrita na memória. Veja o
exemplo abaixo:
Recebe: R6 = 35243 (0x89AB em hexadecimal)

Retorna em 0x2400: 0x38, 0x39, 0x41, 0x42
Inicialize R6 com os 5 primeiros dígitos de seu número de matrícula. Uma forma elegante de
se declarar uma constante num programa é usando a diretiva “.set”, como mostrado abaixo.
MATR .set 35243

…
mov #MATR,R6
4
Exercício 11:
Escreva sub-rotina ASC_W16 que faz a operação inversa do Exercício 5. Recebe R5 apontando
para um endereço (0x2400) com quatro códigos ASCII e monta em R6 a palavra de 16 bits
correspondente. Inicializar a memória com seus dados do programa anterior.
Note que é necessário testar se os códigos são válidos de acordo com a Tabela ASCII (de 0x30
 0x39 e de 0x41  0x46). Caso tenha sucesso, deve retornar o Carry em 1. Em caso de erro,
retornar Carry em zero.
Caso de sucesso.
Recebe em 0x2400: 0x38, 0x39, 0x41, 0x42
Retorna: R6 = 0x89AB e Carry = 1.
Caso de falha.
Recebe em 0x2400: 0x38, 0x3B, 0x41, 0x42
Retorna: R6 = “don’t care” e Carry = 0.
;----------------------------------------------------------------------------
; Main loop here
;----------------------------------------------------------------------------
;
mov #MEMO,R5
call #ASC_W16 ;chamar sub-rotina
OK jc OK ;travar execução com sucesso
NOK jnc NOK ; travar execução com falha
;
ASC_W16:
...
ret
;----------------------------------------------------------------------------
;----------------------------------------------------------------------------
.data
; Declarar 4 caracteres ASCII (0x38, 0x39, 0x41, 0x42)
MEMO: .byte '8','9','A','B'
SUGESTÕES:
• Esboçar um fluxograma para o problema.
• Escreva os programas de forma fracionada. Faça uso de sub-rotinas. Coloque as sub-
rotinas logo depois do programa principal.
• Documente as sub-rotinas, é provável que você as use em experimentos futuros.
Exercício 12:
Escrever sub-rotina que ordena, de forma crescente, um vetor. Um método muito conhecido para
ordenar os elementos de um vetor é o método da BOLHA. Este método pede uma sub-rotina
auxiliar que vamos chamar de ORD.
5
A sub-rotina ORD ordena de forma crescente duas posições de memória: a apontada pelo
ponteiro e a seguinte. Veja os exemplos abaixo. No Caso 1, as duas posições foram trocadas.
No Caso 2, a ordem já estava correta e nada foi feito. Note que em ambos os casos, o ponteiro
terminou apontando para a segunda posição.
Caso 1 Caso 1
Caso 2 Caso 2
Vamos agora considerar um vetor com n elementos, como mostrado abaixo. Note que o vetor
está na vertical. Se varrermos todo este vetor com a sub-rotina ORD, no topo do vetor deverá
estar o maior elemento (Maior 1). Se varrermos novamente o vetor, exceto a última posição,
selecionaremos o segundo maior elemento (MAIOR 2). Repetimos esse procedimento n-1 vezes
e o vetor será ordenado.
n y Maior 1 Maior 1 Maior 1 ... Maior 1

n-1 x y Maior 2 Maior 2 ... Maior 2
... ... ... ... Maior 3 ... Maior 3
3 c c c ... ... ...
2 b b b b ... Menor 2
1 a a a a ... Menor 1
Seq. Original Varrida 1 Varrida 2 Varrida 3 ... Varrida n-1
Exemplo: vetor [4, 7, 3, 5, 1] com 5 elementos, na horizontal.
Tamanho Elementos do vetor

Original 5 4 7 3 5 1
Varrida 1 (4 comparações) 5 4 3 5 1 7
Varrida 4 (1 comparação) 5 1 3 4 5 7
6
Escreva sub-rotina ORDENA que recebe em R5 o endereço de início de um vetor de bytes (sem
sinal) e o ordena. Organize os registradores da forma abaixo:
Para este programa, declare um vetor de bytes formado pela concatenação do código ASCII
dos nomes completos de cada membro da equipe. Note que o montador já converte as letras
para o código ASCII correspondente, como mostrado abaixo. Use letras maiúsculas, omita os
espaços e não use acentos. Preste atenção ao tipo das aspas. Note que usamos a mesma
formatação de vetor do Exercício 1.
Atenção: Não use a instrução swpb (swap bytes) pois ela opera em palavras de 16-bits e está
sempre alinhada em endereços pares, ou seja, não vai funcionar em endereços ímpares.
O programa deve ter a seguinte organização:
;----------------------------------------------------------------------------
; Main loop here
;----------------------------------------------------------------------------
mov #vetor,R5 ;incializar R5 com o endereço do vetor
call #ORDENA ;chamar sub-rotina
jmp $ ;travar execução
nop ;exigido pelo montador
;
ORDENA: ...
...
Ret
.data
; Declarar vetor com a concatenação dos nomes completos da equipe
vetor: .byte 11, "JOAQUIMJOSE"
Exercício 13:
Neste exercício vamos operar com algarismos romanos. Para relembrar, indicamos o link abaixo:
https://www.somatematica.com.br/fundam/romanos.php
Escreva a sub-rotina ROM_ARAB, que recebe R6 apontando para um número representado com
algarismos romanos (será uma a sequência de letras) e retorna em R5 o número correspondente.
Note que o número representado com algarismos romanos é, na verdade, um vetor composto
por bytes. Neste exercício, ao invés de usarmos a primeira posição para indicar o tamanho do
vetor, vamos apenas marcar seu final com o byte zero (0x00).
Siga a estruturação indicada abaixo.
7
;----------------------------------------------------------------------------
; Main loop here
;----------------------------------------------------------------------------
;
mov #NUM_ROM,R6 ;R6 aponta para o início do número
call #ROM_ARAB ;chamar sub-rotina
;
ROM_ARAB:
...
ret
;----------------------------------------------------------------------------
;----------------------------------------------------------------------------
.data
; Especificar o número romano, terminando com ZERO.
NUM_ROM: .byte “MMXIX”,0 ;2019
Exercício 13.a:
Apresente sub-rotina ALG_ROM que recebe em R5 um número entre 1 e 3999 e o escreve com
algarismos romanos a partir da posição de memória apontada por R6. O fim desse número deve
ser indicado como o byte igual a zero (0x00). O programa deve ter a seguinte organização:
;----------------------------------------------------------------------------
; Main loop here
;----------------------------------------------------------------------------
NUM .equ 2019 ;Indicar número a ser convertido
;
mov #NUM,R5 ;R5 = número a ser convertido
mov #RESP,R6 ;R6 = ponteiro para escrever a resposta
call #ALG_ROM ;chamar sub-rotina
nop ;exigido pelo montador
;
ALG_ROM: ...
ret
.data
; Local para armazenar a resposta (RESP = 0x2400)
RESP: .byte "RRRRRRRRRRRRRRRRRR",0
8
Utilizando Leds e Chaves:

A placa (Launch Pad) em uso tem duas chaves e dois leds. Veja a localização na figura abaixo.
De acordo com o esquemático abaixo, os leds acendem quando o pino correspondente (P1.0 ou
P4.7) é colocado em nível alto. As chaves, quando acionadas são lidas como ZERO. Enquanto
estiverem abertas, são lidas como UM.
A execução de uma ação ao acionar uma chave, merece um estudo mais detalhado. A chave
está normalmente aberta, ou seja, o pino de I/O correspondente está em nível alto. Ao ser
acionada, a chave faz um curto para a terra e com isso esse pino vai para nível baixo. A ação
comandada pela chave deve acontecer quando ela passar de aberta para fechada. Uma nova
ação só será executada quando a chave, novamente, passar pela transição de aberta para
fechada. Para tanto, a chave precisa deixar o estado de fechada. O fluxograma da Figura 1.a
ilustra essa ideia.
(a) Sem debounce. (b) Com debounce
Figura 1. Fluxograma para execução de uma ação mediante o acionamento de uma chave.
9
As chaves mecânicas possuem contatos metálicos que são ruidosos quando fechados e quando
abertos. Isto significa que ao se acionar a chave, o pino correspondente não vai imediatamente
para zero (ou para um), mas sim passa por uma situação transitória ruidosa, alternando entre
zero e um várias vezes. O resultado disso é que o programa é “enganado” e percebe múltiplos
acionamentos. A estes múltiplos acionamentos de uma chave damos o nome de rebote ou
bounce. É preciso de uma lógica (debounce) que elimine os bounces. O mais simples é, ao
perceber uma transição da chave, esperar um certo tempo para que os bounces decaiam e só
então prosseguir com o programa. O fluxograma da Figura 1.b, abaixo ilustra esse conceito. A
caixa denominada debounce apenas consome tempo.
É uma boa prática de programação, colocar no início do programa as constantes que serão
usadas. Por exemplo, na listagem abaixo, foi declarada a constante DELAY que é usada para
especificar a duração do debounce. Toda vez que a palavra DELAY for encontrada, o montador
a substitui pelo seu valor (1234). A declaração “.equ” é uma abreviação da palavra “equate”.
;----------------------------------------------------------------------------
; Main loop here
;----------------------------------------------------------------------------
DELAY .equ 1234
É de se notar que os fluxogramas apresentados são pouco eficientes, pois “prendem” o

processador esperando a chave fechar ou abrir. Nenhuma outra tarefa pode ser executada pela
CPU. Uma situação mais realista é a de quando se precisa monitorar uma chave e executar uma
tarefa de tempos em tempos. Isto significa que o processador não pode “ficar preso” esperando
pela alteração na chave. A solução para este caso está apresentada na Figura 2. Note que são
levados em conta dois parâmetros: o estado atual da chave (S1) e o estado anterior (o passado)
da chave (PS1). É preciso explicar a notação:
S1  chave do launch pad PS1  estado anterior (passado) da chave S1

S1 = A  chave S1 está aberta PS1 = A  chave S1 estava aberta
S1 = F  chave S1 está fechada PS1 = F  chave S1 estava fechada
As possibilidades são:
S1 = A e PS1 = A  (AA) chave estava aberta e continua aberta;
S1 = A e PS1 = F  (FA) chave estava fechada e foi liberada;
S1 = F e PS1 = A  (AF) chave estava aberta e foi acionada e
S1 = F e PS1 = F  (FF) chave estava fechada e continua fechada;
O fluxograma permite executar uma tarefa repetitiva e monitorar a chave simultaneamente. O

programador decide onde ele vai realizar suas ações em função dos estados da chave S1.
10
Figura 2. Fluxograma para monitorar uma chave sem “prender a execução”.
Exercícios:
Exercício 14:
Faça os leds LED1 e LED2 acenderem alternadamente. Cada Led deve ficar aceso por um
intervalo aproximado de 1 segundo. Como ainda não estudamos os temporizadores do MSP,
vamos fazer uso da rotina ROT_ATZ que gera um atraso perto de 1 segundo. Uma sugestão é
apresentada abaixo. Use ensaio e erro para determinar os valores de DELAY 1 e 2.
;---------------------
; Main loop here
;---------------------
DELAY1 .equ 12
DELAY2 .equ 34
;;;; seu programa
; Rotina para gerar atraso

ROT_ATZ: MOV #DELAY1,R6
RT1: MOV #DELAY2,R5
RT2: DEC R5
JNZ RT2
DEC R6
JNZ RT1
RET
11
Note que a sub-rotina ROT_ATZ faz uso de dois contadores aninhados. O atraso será
proporcional aos valores DELAY1 e DELAY2. De forma hipotética, vamos supor que cada
instrução de desvio consuma 2 µs e as demais 1 µs. Sob estas condições, qual o tempo
consumido pela rotina exemplificada (DELAY1 = 12 e DELAY2 = 34)?
Exercício 15:
Neste exercício, LED1 deve permanecer aceso enquanto a chave S1 estiver pressionada. O
mesmo deve acontecer com o LED2 e S2.
Exercício 16:
Escreva a Rotina CONTA que constrói um contador binário de 2 bits (0, 1, 2, 3, 0, 1, ...) com os
LEDS 1 e 2. Os leds iniciam apagados e apresentam uma contagem a cada acionamento da
chave S2. A contagem deve acontecer toda vez em que a chave passar do estado de aberta
para fechada (transição: AF). Um novo acionamento só pode ser aceito depois da chave passar
de fechada para aberta (transição: FA). Será preciso eliminar os rebotes desta chave (SW2),
por isso use a rotina ROT_ATZ. É claro, determine os novos valores para DELAY1 e 2.
Exercício 17:
Escreva a Rotina LEDS que apresenta o seguinte controle para os leds.
• Chave S1: a cada acionamento (AF), inverte o estado do LED 1;
• Chave S2: a cada acionamento (AF), inverte o estado do LED 2;
• Enquanto ambas chaves estiverem acionadas (ambas fechadas), os leds piscam de
forma complementar, na frequência de 1 Hz. Por complementar se entende um led aceso
e o outro apagado. Quando ambas as chaves forem liberadas, é restaurado o estado dos
leds, que voltam a obedecer aos controles das chaves S1 e S2.
O diagrama de estados abaixo deixa claro o funcionamento esperado.
12
PROBLEMA 1: Cifrador Enigma

(Visto 1)
A solução deste problema é individual, de forma a que o aluno comprove seu domínio sobre o
assunto. Após resolvê-lo, o aluno deve fazer um pequeno vídeo (máximo de 2 minutos) de forma
a comprovar sua solução. Cada aluno deverá enviar sua listagem e seu vídeo. Serão aceitos
apenas dois arquivos por aluno. A listagem de sua solução deve ser auto contida, ou seja, ela
simplesmente será copiada para o CCS para comprovar seu correto funcionamento. Será
verificado o correto funcionamento de todo programa. Caso o programa solução entregue não
funcione, a nota será zerada.
Importante: Serão aceitas apenas uma listagem e apenas um arquivo de vídeo por aluno.
Regra para o nome dos arquivos:

Erros na nomeação serão penalizados em 20%
Siga o formato: TPN-xxxxxxxx.ext
T = sua turma (A, B, C, ... )
PN = Número do problema (P1, P2, ...)
xxxxx = seu número de matrícula, usando apenas números
ext = extensão que indica o tipo do arquivo (asm, c, avi, ...)
Na primeira linha de seu código deverão estar sua matrícula e seu nome completo.
ÉTICA E HONESTIDADE ESTUDANTIL:

Será verificada a similaridade entre os programas entregues e os demais programas, incluindo
os dos semestres anteriores. Caso a similaridade entre dois programas seja grande o suficiente
para caracterizar a “cola”, as equipes estão automaticamente reprovadas.
Este problema trabalha com a ideia do cifrador Enigma, usado pelos alemães durante a segunda
guerra mundial. Para facilitar o entendimento deste visto, faremos abaixo uma rápida
apresentação deste cifrador, seguida por 5 experimentos simples (não devem ser entregues) que
auxiliam na compreensão dos conceitos e ao final apresentamos o pedido de forma completa.
Vamos usar um modelo simplificado do Enigma. Uma explicação mais completa está disponível
no Apêndice E da fonte de consulta.
O Enigma trabalha apenas com 26 letras

maiúsculas: A, B, C, ..., Z. Não tem caractere
de espaço, números ou qualquer outro
símbolo. A cifragem do Enigma faz a troca
entre essas 26 letras. O segredo está na
grande possibilidade de trocas.
13
Foto do Enigma e detalhes do rotor.
Como pode ser visto na figura acima, o rotor é um cilindro com 26 contatos (26 letras) em cada
extremidade e um padrão de permutação (conexão por fios) entre os contatos nessas
extremidades. Diferentes padrões de contatos geram diferentes cilindros. Então, o que ele faz é
uma permutação entre as letras (entre os contatos). A figura abaixo apresenta uma ilustração
onde o cilindro é apresentado de forma linear. Nesta figura temos as trocas A  G, B  E, C 
T, ..., Z  J.
Ilustração de um rotor e a permuta entre as 26 letras realizada por uma série de condutores
(linhas amarelas).
(Fonte: hackaday.com/2017/08/22/the-enigma-enigma-how-the-enigma-machine-worked)
14
A partir deste ponto iniciamos os conceitos do Enigma simplificado, com o uso de pequemos
experimentos que trabalham com um modelo hipotético de apenas 6 letras (A, B, ..., F). Usamos
apenas 6 letras para que as explicações fiquem simples.
Experimento 1: Entendendo um Rotor
Como ilustrado ao lado, propomos um rotor de 6

posições, numeradas de 0 até 5. É fácil de ver que
estão programadas (pelos condutores internos) as
trocas: A(0)  C(2), B(1)  E(4), ..., F (5)  A (0).
Este rotor será denominado por RT1. Podemos
representá-lo pelo vetor, que indica o final de cada
“caminho”.
RT1 = { 2, 4, 1, 5, 3, 0 }
É importante que fique clara a ideia de que o rotor é
caracterizado pelo seu padrão de contatos. Um Rotor RT1
padrão diferente origina um novo rotor.
Problema: Escreve a sub-rotina “ENIGMA1” que recebe a mensagem “msg” em claro e a

armazena cifrada no vetor “gsm”, usando o rotor RT1.
EXP1: MOV #MSG,R5

MOV #GSM,R6
CALL #ENIGMA1
JMP $
NOP
;
; Sua rotina ENIGMA (Exp 1)
ENIGMA1: ...
;
; Dados para o enigma
.data
MSG: .byte "CABECAFEFACAFAD",0 ;Mensagem em claro
GSM: .byte "XXXXXXXXXXXXXXX",0 ;Mensagem cifrada
RT1: .byte 2, 4, 1, 5, 3, 0 ;Trama do Rotor 1
Resposta: BCEDBCADACBCACF
15
Experimento 2: Entendendo um Refletor
O Enigma é um cifrador simétrico, ou seja, a

mensagem em claro gera a cifrada e a
mensagem cifrada gera a mensagem em claro.
Para isso, se faz necessário um recurso
denominado Refletor, que está ilustrado ao lado.
Como o nome diz, ele retorna o sinal. O refletor
proposto, denominado de RF1 é representado
pelo vetor:
RF1 = { 3, 5, 4, 0, 2, 1 }
O conjunto RT1 e RF1 faz as permutações:
A ↔ B, C ↔ D, E ↔ F.
Problema: Escreve a sub-rotina “ENIGMA2” que recebe a mensagem “msg” em claro e a

armazena cifrada no vetor “gsm”, usando o rotor RT1 e o refletor RF1. Alerta, sua solução terá
dois acessos ao rotor RT1, o primeiro é direto e o segundo é na forma inversa. Pense nisso!
Após a cifragem, comprove sua solução apresentando a mensagem cifrada para ver se ela
retorna a mensagem em claro.
EXP2: MOV #MSG,R5

MOV #GSM,R6
CALL #ENIGMA2 ;Cifrar
;
MOV #GSM,R5
MOV #DCF,R6
CALL #ENIGMA2 ;Decifrar
JMP $
NOP
;
; Sua rotina ENIGMA (Exp 2)
ENIGMA2: ...
;
.data
DCF: .byte "XXXXXXXXXXXXXXX",0 ;Mensagem decifrada
RT1: .byte 2, 4, 1, 5, 3, 0 ;Trama do Rotor
RF1: .byte 3, 5, 4, 0, 2, 1 ;Tabela do Refletor
Resposta: DBAFDBEFEBDBEBC
16
Experimento 3: Entendendo a Configuração de um Rotor
Para aumentar a quantidade de possibilidades do rotor, o anel com as letras pode ser girado
sobre o padrão de contatos, resultando no que vamos chamar de Configuração. Na figura
abaixo, temos a representação simplificada do rotor RT1 com suas 6 possíveis configurações.
Note que estamos convencionando que a Configuração é dada pelo número que corresponde à
letra A (número à direita da letra A).
Config = 0 Config = 1 Config = 2 Config = 3 Config = 4 Config = 5
As 6 possíveis configurações do rotor RT1.

Para que a figura não ficasse grande, a trama interna do rotor foi omitida. Apresentam-se
apenas a entrada e a saída. São os contatos 0-2, 1-4, ..., 5-0.
Problema: Escreva a sub-rotina “ENIGMA3” que

recebe a mensagem “msg” em claro e a armazena
cifrada no vetor “gsm”, usando o rotor RT1 na
Configuração indicada pela constante CONF1 e o
refletor RF1.
Na solução será necessário conhecer o tamanho

do rotor, que é dado pela constante RT_TAM.
Para facilitar seu raciocínio, a figura ao lado

apresenta com detalhes o rotor RT1 na Rotor RT1, Configuração 1
Configuração = 1.
Comprove sua solução apresentando a mensagem cifrada para ver se ela retorna a mensagem
em claro. Faça ensaios com diferentes configurações.
RT_TAM .equ 6 ;Tamanho dos rotores

CONF1 .equ 1 ;Configuração do Rotor 1
EXP3: MOV #MSG,R5

MOV #GSM,R6
CALL #ENIGMA3
;
; Dependendo da solução, pode ser necessária uma
; sub-rot para restaurar posição original do rotor
;
17
MOV #GSM,R5
MOV #DCF,R6
CALL #ENIGMA3
JMP $
NOP
;
; Sua rotina ENIGMA (Experimento 3)
ENIGMA3: ...
;
.data
RT1: .byte 2, 4, 1, 5, 3, 0 ;Trama do Rotor
RF1: .byte 3, 5, 4, 0, 2, 1 ;Tabela do Refletor
Resposta: BFCDBFADAFBFAFE.
Experimento 4: Entendendo a Justaposição dos Rotores

Em sua forma mais típica, o Enigma tinha 5 rotores diferentes. Para sua operação, a cada dia, 3
rotores eram selecionados dentre esses 5. A figura abaixo apresenta mais 4 rotores, para
perfazermos um total de 5 rotores. Veja também os vetores que caracterizam esses rotores.
Lembramos que cada rotor ainda possui 6 possibilidades de configuração.
RT2 RT3 RT4 RT5
RT2 = { 1, 5, 3, 2, 0, 4 } RT3 = { 4, 0, 5, 2, 3, 1 }
RT4 = { 3, 4, 1, 5, 2, 0 } RT5 = { 5, 2, 3, 4, 1, 0 }
Para este experimento vamos usar os rotores RT2 e RT3, nas configurações 4 e 1
respectivamente como mostrado abaixo.
18
A figura abaixo apresenta o esquema deste experimento. Note que os rotores foram girados de
forma que a letra “A” de cada um deles ocupasse o topo (Posição Inicial A para todos os rotores).
Agora temos as seguintes permutações: A ↔ E, B ↔ C, D ↔ F. É importante que se vá
percebendo a quantidade de permutações possíveis.
Problema: Escreva a sub-rotina “ENIGMA4” que recebe a mensagem “msg” em claro e a

armazena cifrada no vetor “gsm”, usando os rotores RT2 e RT3 nas configurações 4 e 1
respectivamente, junto com o refletor RF1. Comprove também a decifragem. Veja a listagem
abaixo

EXP4: MOV #MSG,R5

MOV #GSM,R6
;
; Dependendo da solução, pode ser necessária uma
; Sub-rot para restaurar posição original dos rotores
;
MOV #GSM,R5
MOV #DCF,R6
JMP $
19
NOP
;
;
ENIGMA4: ...
;
; Área de dados
.data
;
; Rotores disponíveis
ROTORES:
;
; Refletores disponíveis
REFLETORES:
RF1: .byte 3, 5, 4, 0, 2, 1 ;Tabela do Refletor 1
Resposta: BECABEDADEBEDEF
Experimento 5: Entendendo a rotação dos Rotores

Se analisarmos com cuidado o resultado do experimento 4, vamos concluir que ele apenas trocou
as letras A ↔ E, B ↔ C, D ↔ F. Isto é muito fácil de decifrar. Para aumentar a complexidade, os
rotores giram. O rotor mais à esquerda gira um passo após a cifragem de cada letra e o rotor à
direita gira um passo a cada volta completa do rotor da esquerda. No nosso caso, como temos
apenas 6 letras, a cada 6 letras o rotor da esquerda dá uma volta completa e o rotor da direita
um passo.
Cuidado, para não se confundir, pois o corpo do Enigma permanece fixo. A figura abaixo ilustra
a posição dos rotores para cifrar as 4 primeiras letras. O padrão de contatos dos rotores foi
redesenhado para facilitar a elaboração do programa.
1a Letra (A↔E, B↔C, D↔F) 2a Letra (A↔E, B↔F, C↔D)
20
3a Letra (A↔C, B↔F, D↔E) 4a Letra (A↔C, B↔D, E↔F)
Problema: Escreva a sub-rotina “ENIGMA5” que recebe a mensagem “msg” em claro e a

armazena cifrada no vetor “gsm”, usando os rotores RT2 e RT3 nas configurações 4 e 1
respectivamente, junto com o refletor RF1. Inclua agora a rotação dos rotores.
Cuidado, antes de decifrar a mensagem, é preciso voltar os rotores para a posição inicial.

EXP5: MOV #MSG,R5

MOV #GSM,R6
;
; Agora é necessário uma
; Sub-rot para restaurar posição original dos rotores
;
MOV #GSM,R5
MOV #DCF,R6
JMP $
NOP
;
;
ENIGMA5: ...

.data
; Rotores disponíveis
ROTORES:
21
; Refletores disponíveis
REFLETORES:
Resposta: BEFFEBDABCEBDEE
Observação: O Enigma, além de girar os rotores a cada letra, oferece ainda flexibilidade para
especificar a Posição Inicial dos Rotores e um Painel de Plugs para fazer até 10 trocas entre
duas letras. A isso tudo foram adicionados um teclado e um painel de letras para permitir seu
uso. Eram usados 3 rotores escolhidos entre um total de 5 e 1 refletor escolhido entre 3
disponíveis. O total de possibilidades é astronômico, pois chega a 158.962.555.217.826.360.000
ou, aproximadamente, 1,5 x 1020. Imaginando que você consiga testar 1 Giga possibilidades por
segundo, quanto tempo você demoraria, na pior das hipóteses, para decifrar uma mensagem? A
chave era trocada todo dia, à meia-noite. Como será que em apenas 24 horas os ingleses, várias
vezes, conseguiram decifrar mensagens cifradas pelo Enigma?
Proposta para o problema a ser resolvido

Construir o programa Enigma que opera com rotores de 26 letras. Para facilitar o trabalho,
somente as letras A, B, ..., Z serão cifradas. Todo resto, ou seja, espaços, pontuação, números
etc., deve ser preservado.
Temos a disponibilidade de 5 rotores e 3 refletores. Nosso Enigma vai usar 3 rotores justapostos,
denominados: rotor da esquerda, rotor central e rotor da direita, e um refletor. Os rotores giram
a cada letra cifrada. O vetor CHAVE especifica a configuração do cifrador, da forma descrita
abaixo:
CHAVE: .byte A, B, C, D, E, F, G
A = número do rotor à esquerda e B = sua configuração;
C = número do rotor central e D = sua configuração;
E = número do rotor à direita e F = sua configuração;
G = número do refletor.
;---------------------------------------------------------------------
; Main loop here
;---------------------------------------------------------------------
RT_TAM .equ 26 ;Tamanho dos rotores (26 letras)
VISTO1: MOV #MSG,R5

MOV #GSM,R6
CALL #ENIGMA ;Cifrar
;
CALL #RESETE ;Restaurar posição original
;
MOV #GSM,R5
MOV #DCF,R6
22
CALL #ENIGMA ;Cifrar

JMP $
NOP
;
; Definição da chave do Enigma
CHAVE: .byte 2, 6, 3, 8, 5, 12, 2
;
; Coloque aqui sua sub-rotina ENIGMA
ENIGMA: ...
;
;
; Área de dados
.data
MSG: .byte "UMA NOITE DESTAS, VINDO DA CIDADE PARA O ENGENHO NOVO,"
.byte " ENCONTREI NO TREM DA CENTRAL UM RAPAZ AQUI DO BAIRRO,"
.byte " QUE EU CONHECO DE VISTA E DE CHAPEU.",0 ;Don Casmurro
GSM: .byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

.byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
.byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",0
DCF: .byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

.byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
.byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",0
;Rotores com 26 posições

ROTORES:
RT1: .byte 10, 18, 0, 7, 3, 2, 4, 8, 14, 17, 5, 22, 20
.byte 25, 23, 1, 24, 13, 21, 19, 11, 6, 12, 15, 9, 16
RT2: .byte 19, 9, 7, 23, 11, 25, 17, 16, 2, 24, 15, 10, 6
.byte 14, 0, 8, 13, 4, 3, 18, 1, 22, 21, 20, 5, 12
RT3: .byte 16, 21, 4, 0, 1, 12, 15, 14, 8, 25, 9, 19, 17
.byte 6, 5, 20, 13, 24, 23, 10, 3, 22, 11, 7, 18, 2
RT4: .byte 25, 4, 21, 22, 17, 14, 12, 8, 5, 15, 23, 6, 2
.byte 18, 10, 16, 13, 3, 19, 20, 0, 24, 11, 7, 9, 1
RT5: .byte 13, 5, 20, 7, 0, 15, 21, 9, 19, 14, 24, 18, 12
.byte 6, 2, 11, 16, 8, 3, 1, 10, 23, 4, 25, 22, 17
;Refletores com 26 posições

REFLETORES:
RF1: .byte 7, 17, 5, 19, 15, 2, 9, 0, 14, 6, 18, 16, 25
.byte 23, 8, 4, 11, 1, 10, 3, 22, 24, 20, 13, 21, 12
RF2: .byte 2, 13, 0, 8, 10, 19, 23, 14, 3, 22, 4, 20, 25
.byte 1, 7, 17, 21, 15, 24, 5, 11, 16, 9, 6, 18, 12
RF3: .byte 22, 5, 9, 12, 14, 1, 13, 10, 23, 2, 7, 21, 3
.byte 6, 4, 24, 17, 16, 19, 18, 25, 11, 0, 8, 15, 20
Resposta:
UMA NOITE DESTAS, VINDO DA CIDADE PARA O ENGENHO NOVO,

XGK GHPZB WXIJHY, ECKAJ WM LFPNYP UUWK V YDAUBRR ABLI,
ENCONTREI NO TREM DA CENTRAL UM RAPAZ AQUI DO BAIRRO,

RDJETIHUP UV JDSW HN VYVPEHP HZ FWCND EDHV AD UIUMZT,
23
QUE EU CONHECO DE VISTA E DE CHAPEU.

XCB WB VRVKTOC PQ OQPQC Z RS HFSNBN.
Tabela a ser usada na correção

Pontos Configuração Rotação Experimentos
50% Não Não 1, 2, 3
80% Sim Não 1, 2, 3, 4
100% Sim Sim 1, 2, 3 , 4, 5
   Sensacional desafio   
O primeiro aluno que descobrir a chave usada na cifragem da mensagem abaixo recebe 200%
de pontuação.
UMA NOITE DESTAS, VINDO DA CIDADE PARA O ENGENHO NOVO,

AJP CDUEC FGVWFZ, UDLWI SB BBEPIV ZQBP N UUWNMWP EFCE,
ENCONTREI NO TREM DA CENTRAL UM RAPAZ AQUI DO BAIRRO,

XWBKWGNLH OP JQQW MB BNTHEBU HY DOBRQ RRGC II DMXBUU,
QUE EU CONHECO DE VISTA E DE CHAPEU.

LXK PP LIELYXK RS XLYZT Q EF AGPSGR.
GSM: .byte "AJP CDUEC FGVWFZ, UDLWI SB BBEPIV ZQBP N UUWNMWP EFCE,"
.byte " XWBKWGNLH OP JQQW MB BNTHEBU.HY.DOBRQ.RRGC.II.DMXBUU,"
.byte " LXK PP LIELYXK RS XLYZT Q EF AGPSGR.",0
Quanto tempo você demorou?
24
TABELA ASCII PADRÃO

0_ 1_ 2_ 3_ 4_ 5_ 6_ 7_
_0 NUL DLE SP 0 @ P ` p
_1 SOH DC1 ! 1 A Q a q
_2 STX DC2 " 2 B R b r
_3 ETX DC3 # 3 C S c s
_4 EOT DC4 $ 4 D T d t
_5 ENQ NAK % 5 E U e u
_6 ACK SYN & 6 F V f v
_7 BEL ETB ' 7 G W g w
_8 BS CAN ( 8 H X h x
_9 HT EM ) 9 I Y i y
_A LF SUB * : J Z j z
_B VT ESC + ; K [ k {
_C FF FS , < L \ l |
_D CR GS - = M ] m }
_E SO RS . > N ^ n ~
_F SI UP / ? O _ o DEL
Exemplos: símbolo 'A' = código ASCII 41h

símbolo 'B' = código ASCII 42h
símbolo 'a' = código ASCII 61h
símbolo 'z' = código ASCII 7Ah
Códigos especiais usados na Tabela ASCII
Hexa ASCII Significado Hexa ASCII Significado

00 NUL NULL 10 DLE Data Link Escape
01 SOH Start Of Heading 11 DC1 Device Control 1
02 STX Start of TeXt 12 DC2 Device Control 2
03 ETX End of TeXt 13 DC3 Device Control 3
04 EOT End Of Transmission 14 DC4 Device Control 4
05 ENQ ENQuire 15 NAK Negative AcKnowledge
06 ACK ACKnowledge 16 SYN SYNcronism idle
07 BEL BELL 17 ETB End of Transmission Block
08 BS Back Space 18 CAN CANcel
09 HT Horizontal Tab 19 EM End of Medium
0A LF Line Feed 1A SUB SUBstitute
0B VT Vertical Tab 1B ESC ESCape
0C FF Form Feed 1C FS File Separator
0D CR Carriage Return 1D GS Group Separator
0E SO Shift Out 1E RS Record Separator
0F SI Shift In 1F UP Unit Separator
7F DEL DELete" 20 SP SPace
25

Módulo 1

Enviado por

Dados do documento

Descrição 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

Módulo 1

Enviado por

Direitos autorais:

Formatos disponíveis

Laboratório de Sistemas Microprocessados Digitais

02/2020 – Ensino Remoto

Módulo 1: Programação Assembly

OBJETIVO DESTE MÓDULO:

Introdução: declarando vetores na memória

Dica 1: Você pode declarar o vetor em várias linhas, caracter a caracter

Ou colocar tudo junto: vetor: .byte 11,”JOAQUIMJOSE”

De forma semelhante ao Exercício 1, declare um vetor de bytes formado pela concatenação do

Recebe: R6 = 35243 (0x89AB em hexadecimal)

MATR .set 35243

n y Maior 1 Maior 1 Maior 1 ... Maior 1

Exemplo: vetor [4, 7, 3, 5, 1] com 5 elementos, na horizontal.

Tamanho Elementos do vetor

O programa deve ter a seguinte organização:

Siga a estruturação indicada abaixo.

Utilizando Leds e Chaves:

(a) Sem debounce. (b) Com debounce

É de se notar que os fluxogramas apresentados são pouco eficientes, pois “prendem” o

S1  chave do launch pad PS1  estado anterior (passado) da chave S1

O fluxograma permite executar uma tarefa repetitiva e monitorar a chave simultaneamente. O

Figura 2. Fluxograma para monitorar uma chave sem “prender a execução”.

;;;; seu programa

; Rotina para gerar atraso

PROBLEMA 1: Cifrador Enigma

Regra para o nome dos arquivos:

ÉTICA E HONESTIDADE ESTUDANTIL:

O Enigma trabalha apenas com 26 letras

Foto do Enigma e detalhes do rotor.

Experimento 1: Entendendo um Rotor

Como ilustrado ao lado, propomos um rotor de 6

Problema: Escreve a sub-rotina “ENIGMA1” que recebe a mensagem “msg” em claro e a

EXP1: MOV #MSG,R5

Experimento 2: Entendendo um Refletor

O Enigma é um cifrador simétrico, ou seja, a

Problema: Escreve a sub-rotina “ENIGMA2” que recebe a mensagem “msg” em claro e a

EXP2: MOV #MSG,R5

Experimento 3: Entendendo a Configuração de um Rotor

Config = 0 Config = 1 Config = 2 Config = 3 Config = 4 Config = 5

As 6 possíveis configurações do rotor RT1.

Problema: Escreva a sub-rotina “ENIGMA3” que

Na solução será necessário conhecer o tamanho

Para facilitar seu raciocínio, a figura ao lado

RT_TAM .equ 6 ;Tamanho dos rotores

EXP3: MOV #MSG,R5

Experimento 4: Entendendo a Justaposição dos Rotores

RT2 RT3 RT4 RT5

Problema: Escreva a sub-rotina “ENIGMA4” que recebe a mensagem “msg” em claro e a

RT_TAM .equ 6 ;Tamanho dos rotores

EXP4: MOV #MSG,R5

Experimento 5: Entendendo a rotação dos Rotores

1a Letra (A↔E, B↔C, D↔F) 2a Letra (A↔E, B↔F, C↔D)

3a Letra (A↔C, B↔F, D↔E) 4a Letra (A↔C, B↔D, E↔F)

Problema: Escreva a sub-rotina “ENIGMA5” que recebe a mensagem “msg” em claro e a

RT_TAM .equ 6 ;Tamanho dos rotores

EXP5: MOV #MSG,R5

; Dados para o enigma

Proposta para o problema a ser resolvido

VISTO1: MOV #MSG,R5

CALL #ENIGMA ;Cifrar

GSM: .byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

DCF: .byte "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"

;Rotores com 26 posições

;Refletores com 26 posições