Você está na página 1de 6

Tas Laurindo Pereira

12/0042223

Relatrio 1 Programao em Assembly

Questo 1
Obs: foi colocado a estrutura completa do programa apenas no programa 1, com os demais apresentando
apenas o main loop.

Programa 1
;-------------------------------------------------------------------------------
;-------------------------------------------------------------------------------
; MSP430 Assembler Code Template for use with TI Code Composer Studio
;
;
;-------------------------------------------------------------------------------
.cdecls C,LIST,"msp430.h" ; Include device header file

;-------------------------------------------------------------------------------
.def RESET ; Export program entry-point to
; make it known to linker.
;-------------------------------------------------------------------------------
.text ; Assemble into program memory.
.retain ; Override ELF conditional linking
; and retain current section.
.retainrefs ; And retain any sections that have
; references to current section.
;-------------------------------------------------------------------------------
RESET mov.w #__STACK_END,SP ; Initialize stackpointer
StopWDT mov.w #WDTPW|WDTHOLD,&WDTCTL ; Stop watchdog timer

;-------------------------------------------------------------------------------
; Main loop here
;-------------------------------------------------------------------------------
;R5 = ponteiro
;R6 = registor que ter o menor elemento do vetor
;R7 = frequncia do menor elemento
;R8 = contador com o tamanho do vetor

mov #vetor,R5 ;inicializa o ponteiro


mov.b @R5, R8 ;R8 = tamanho do vetor
mov #0,R6 ;zera R6
mov #1,R7 ;define a frequncia mnima
inc R5 ;avana uma posio no vetor
;inc equivale a add #1,R5
mov.b @R5, R6 ;a primeira letra registrada em R6
call #MENOR ;chama a subrotina
jmp $
nop ;nop equivale a mov #0h,#0h

MENOR: inc R5 ;avana mais uma posio no vetor


;inc equivale a add #1,R5
mov.b @R5, R9 ;coloca-se a letra dessa outra posio em R9
cmp.b R6, R9 ;= R9 - R6
jn novoMenor ;se N=1, temos R9<R6 e R6 deve ser atualizado
cont1: jz atR7 ;se Z=1, R9 = R6, aumenta-se a frequncia em R7
cont2: dec R8 ;Decrementa R8. Se R8 = 0, temos o fim do vetor
;dec equivale a sub #1,R8
jnz MENOR ;enquanto R8 no for zero, avana-se no vetor
ret
;ret equivale a mov @SP+,PC

novoMenor: mov.b @R5, R6 ;a nova menor letra vai para R6


mov.b #1, R7 ;o contador de frequncia reiniciado
jmp cont1 ;chama a atualizao de R7

atR7: inc R7 ;incrementa em 1 a frequncia da menor letra


;inc equivale a add #1,R7
jmp cont2 ;retorna para a subrotina MENOR

.data
;Declarar vetor com 50 elementos [JOAOANTONIODESANTARITTAERONDINATAISLAURINDOPEREIRA]

vetor: .byte 50,'J','O','A','O','A','N','T','O','N','I','O','D','E'


.byte 'S','A','N','T','A','R','I','T','T','A','E','R','O','N','D','I','N','A'
.byte 'T','A','I','S','L','A','U','R','I','N','D','O'
.byte 'P','E','R','E','I','R','A'

;-------------------------------------------------------------------------------
; Stack Pointer definition
;-------------------------------------------------------------------------------
.global __STACK_END
.sect .stack

;-------------------------------------------------------------------------------
; Interrupt Vectors
;-------------------------------------------------------------------------------
.sect ".reset" ; MSP430 RESET Vector
.short RESET

Programa 2

;-------------------------------------------------------------------------------
; Main loop here
;-------------------------------------------------------------------------------

mov.w #vetor,R5 ;R5 = ponteiro


mov.b @R5, R8 ;R8=tamanho do vetor (contador)
mov.w #0,R6 ;zera R6 e R9, onde R6 mostrar o
maior elemento
mov.w #0,R9
mov.b #1,R7 ;R7 = frequncia do maior elemento
incd R5 ;incrementa de 2 (d) R5
;equivale a add #2,R5
mov.w @R5,R6 ;move o contedo da posio para R6
call #MAIOR16
jmp $
nop
;equivale a mov #0h,#0h

MAIOR16: incd R5 ;avana-se novamente no vetor


;equivale a add #2,R5
mov.w @R5, R9 ;move o conetdo da posio para R9
cmp.w R6, R9 ; R9-R6
jhs atR6 ; R9>R6, atualiza o R6
cont1: jz atR7
cont2: dec R8 ;decrementa R8
;equivale a sub #2,R8
jnz MAIOR16 ;enquanto R8 no for 0, refaz-se a
operao
ret
;equivale a mov @SP+,PC

atR6: mov.w @R5,R6 ; atualizao de R6


mov.w #1, R7 ; R7 reiniciado
jmp cont1 ; chama a atualizao de R7

atR7: inc R7 ; incrementa R7


;add #1,R7
jmp cont2 ;chama a atualizao de R8
nop
;mov #0h,#0h

.data
vetor: .byte 25,0,'J','O','A','O','A','N','T','O','N','I','O','D','E'
.byte 'S','A','N','T','A','R','I','T','T','A','E','R','O','N','D','I','N','A'
.byte 'T','A','I','S','L','A','U','R','I','N','D','O'
.byte 'P','E','R','E','I','R','A'

Programa 3
;-------------------------------------------------------------------------------
; Main loop here
;-------------------------------------------------------------------------------

;R5 = ponteiro
;R6 = multiplos de 2
;R7 = multiplos de 4
;R8 = contador

mov #vetor,R5 ;ponteiro inicializado


call #M2M4
jmp $
nop
;nop=mov #0h,#0h

M2M4: mov.b @R5+,R8 ;atribui-se o tamanho do vetor para R8 e avana


dec R8 ;decrementa R8
;dec equivale a sub #1,R8
mov #0,R6 ;zera R6
mov #0,R7 ;zera R7
call #loop ;chama o loop
ret
;ret equivale a mov @SP+,PC

loop: mov.b @R5+,R9 ;guarda a letra em R9 e avana no vetor


rra R9 ;guarda o LSB no carry
jnc mult2 ;LSB=0, mltiplo de 2
jc cont2 ;se no mltiplo de 2, tambm no de 4
cont1: nop
;nop=mov #0h,#0h
rra R9 ;guarda o novo LSB em R9
jnc mult4 ;se LSB=0, mltiplo de 4
cont2: nop
;nop=mov #0h,#0h
dec R8 ;Decrementamos o contador
;dec equivale a sub #1,R8
jnz loop ;roda enquanto no temos 0
ret
;ret equivale a mov @SP+,PC

mult2: inc R6 ;Se for multiplo de 2, aumenta a frequncia em 1


; inc equivale a add #1,R6
Jmp cont1

mult4: inc R7 ;Se for multiplo de 4, aumenta a frequncia em 1


;inc equivale a add #1,R7
jmp cont2
;-------------------------------------------------------------------------------
; Segmento de dados inicializados (0x2400)
;-------------------------------------------------------------------------------
.data
;Declarar vetor com 50 elementos [JOAOANTONIODESANTARITTAERONDINATAISLAURINDOPEREIRA]

vetor: .byte 50,'J','O','A','O','A','N','T','O','N','I','O','D','E'


.byte 'S','A','N','T','A','R','I','T','T','A','E','R','O','N','D','I','N','A'
.byte 'T','A','I','S','L','A','U','R','I','N','D','O'
.byte 'P','E','R','E','I','R','A'

Programa 4
;-------------------------------------------------------------------------------
; Main loop here
;-------------------------------------------------------------------------------
;R4 = contador
;R5 = ponteiro
;R6 = Nmero da matrcula
;R7 = registro utilizado

mov #MATR, R6 ;carrega o valor de matrcula em R6


mov #0x2403, R5 ;e o endereo 2403 em R5
mov #4, R4 ;inicializa o contador
call #W16ASC ;chama a subrotina
jmp $
nop
;nop=mov #0h,#0h

W16ASC: mov R6, R7 ;cpia em R7 para extrair os nibbles


rra R6 ;desloca 4 vezes o bit para a direita
rra R6
rra R6
rra R6
and #0xF, R7 ;extrai os 4 LSBs
call #nibble ;chama a subrotina nibble, que transforma o nibble
em um byte de cdigo ASCII
mov.b R7,0(R5) ;escreve o byte ASCII na memria
dec R5 ;avana memria
;dec equivale a sub #1,R5
dec R4 ;decrementa o contador
;dec equivale a sub #1,R4
jnz W16ASC ;repete o processo at que os nibbles acabem

nibble: cmp #10,R7 ;compara o nibble com 10


jn numero ;N=1, R7 menor que 10, ento um nmero
add #55,R7 ;caso contrrio, uma letra (adiciona 55)
ret
;ret equivale a mov @SP+,PC
numero: add #48,R7 ;Se R7 for um nmero, adiciona 48
ret
;ret equivale a mov @SP+,PC

MATR .set 12003

Programa 5
;-------------------------------------------------------------------------------
; Main loop here
;-------------------------------------------------------------------------------
;R5 o ponteiro
;R6 = Resultado
mov #MEMO, R5 ;inicializa R5 para apontar memria
mov #0, R6 ;zera R6
call #ASC_W16 ;chama a subrotina
OK: jc OK ;resultado ok
NOK: jnc NOK

ASC_W16: mov.b @R5+, R7 ;guarda o elemento em R7 e avana na


memria
rla R6 ;move o resultado um nibble para a esquerda
;equivale a add R6,R6
rla R6
rla R6
rla R6

;verificao: pois cdigo ASCII vai de 0x30 a 0x46

cmp #0x30, R7 ;verifica se menor que 0x30


jn erro
mov #0x46, R8
cmp R7, R8 ;verifica se maior que 0x46
jn erro

cmp #0x39, R7 ;verifica se est entre 0x39 e 0x41


jn ok
cmp #0x41, R7
jn erro

ok: cmp #0x39, R7 ;menor que 0x39, nmero


jn numero
cmp #0x46, R7 ;menor que 0x46, letra
jn letra

cont: nop
;mov #0h,#0h
Add R7,R6 ;adiciona os nibbles ao resultado

cmp #0x2404,R5 ;confere se a posio de memria


alcanada a desejada
jnz ASC_W16 ;se no igual a zero, volta para a
subrotina
setc ;se no houveram erros, C=1
;bis #1,SR
ret ;volta para a rotina principal
;mov @SP+,PC

numero: sub #48, R7 ;nmero, subtrai 48


jmp cont

letra: sub #55, R7 ;letra, subtrai 55


jmp cont
erro: clrc ;em caso de erro, C=0
;equivale a bic #1,SR
mov #0xFFFF, R6 ;coloca um don't care em R6
ret ;volta para a rotina principal
; mov @SP+,PC
;------------------------------------------------------------------------------
; Segmento de dados inicializados (0x2400)
;-------------------------------------------------------------------------------
.data
; Declarar 4 caracteres ASCII (0x32, 0x45, 0x45, 0x33)
MEMO: .byte '2','E','E','3'

Questo 2
Ver cdigos acima.

Questo 3
Os vetores so alocados neste endereo pois este o incio do endereo disponvel ao usurio na memria
RAM, que vai de 0x2400 a 0x4400, em passos de 2kB. De 0X1C00 a 0x2400 tem-se o espao reservado para
comunicao serial.

Questo 4
Pode-se declarar um vetor que assumir os valores de 0 a F em ASCII, como se segue:
tab: .byte 0x30,0x31,0x32...0x38,0x39,0x40,...0x46

Logo, fazendo-se uma rotina nibble que retornar diretamente o valor ASCII correspondente, obtm-se o
resultado desejado:
nibble: mov.b tab(R7),R7
mov.b R7,0(R5)
ret

Questo 5
O programa 4 pode ser considerado mais eficiente pois o nmero de testes necessrios menor,
economizando em tempo e espao de processamento.