MSP430 - Experimento em assembly

Taís Laurindo Pereira 12/0042223

Relatório 1 – Programação em Assembly

Questão 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 = frequência do menor elemento ;R8 = contador com o tamanho do vetor mov mov.b mov mov inc

#vetor,R5 @R5, R8 #0,R6 #1,R7 R5

mov.b @R5, R6 call #MENOR jmp $ nop MENOR:

inc

R5

mov.b @R5, R9

;inicializa o ponteiro ;R8 = tamanho do vetor ;zera R6 ;define a frequência mínima ;avança uma posição no vetor ;inc equivale a add #1,R5 ;a primeira letra é registrada em R6 ;chama a subrotina ;nop equivale a mov #0h,#0h ;avança mais uma posição no vetor ;inc equivale a add #1,R5 ;coloca-se a letra dessa outra posição em R9

cont1: cont2:

cmp.b jn jz dec

R6, R9 novoMenor atR7 R8

jnz ret

MENOR

;= R9 - R6 ;se N=1, temos R9R6, atualiza o R6

cont1: cont2:

jz dec

atR7 R8

jnz

MAIOR16

;decrementa R8 ;equivale a sub #2,R8 ;enquanto R8 não for 0, refaz-se a

operação ret ;equivale a mov @SP+,PC atR6:

mov.w mov.w jmp

@R5,R6 #1, R7 cont1

atR7:

inc

R7

jmp nop

cont2

; atualização de R6 ; R7 é reiniciado ; chama a atualização de R7 ; incrementa R7 ;add #1,R7 ;chama a atualização de R8 ;mov #0h,#0h

vetor:

.byte .byte .byte .byte

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

Programa 3 ;------------------------------------------------------------------------------; Main loop here ;------------------------------------------------------------------------------;R5 ;R6 ;R7 ;R8 mov call jmp nop

#vetor,R5 #M2M4 $

= = = =

ponteiro multiplos de 2 multiplos de 4 contador

;ponteiro é inicializado

;nop=mov #0h,#0h

M2M4:

mov.b @R5+,R8 dec R8 mov mov call ret

#0,R6 #0,R7 #loop

;atribui-se o tamanho do vetor para R8 e avança ;decrementa R8 ;dec equivale a sub #1,R8 ;zera R6 ;zera R7 ;chama o loop ;ret equivale a mov @SP+,PC

loop:

@R5+,R9 R9 mult2 cont2

cont1:

mov.b rra jnc jc nop

R9 mult4

cont2:

rra jnc nop dec

R8

jnz

loop

;guarda a letra em R9 e avança no vetor ;guarda o LSB no carry ;LSB=0, é múltiplo de 2 ;se não é múltiplo de 2, também não é de 4 ;nop=mov #0h,#0h ;guarda o novo LSB em R9 ;se LSB=0, é múltiplo de 4 ;nop=mov #0h,#0h ;Decrementamos o contador ;dec equivale a sub #1,R8 ;roda enquanto não temos 0

ret ;ret equivale a mov @SP+,PC mult2:

mult4:

inc

R6

Jmp

cont1

inc

R7

;Se for multiplo de 2, aumenta a frequência em 1 ; inc equivale a add #1,R6

;Se for multiplo de 4, aumenta a frequência em 1 ;inc equivale a add #1,R7

jmp cont2 ;------------------------------------------------------------------------------; Segmento de dados inicializados (0x2400) ;------------------------------------------------------------------------------.data ;Declarar vetor com 50 elementos [JOAOANTONIODESANTARITTAERONDINATAISLAURINDOPEREIRA] vetor:

.byte .byte .byte .byte

50,'J','O','A','O','A','N','T','O','N','I','O','D','E' 'S','A','N','T','A','R','I','T','T','A','E','R','O','N','D','I','N','A' 'T','A','I','S','L','A','U','R','I','N','D','O' 'P','E','R','E','I','R','A'

Programa 4 ;------------------------------------------------------------------------------; Main loop here ;------------------------------------------------------------------------------;R4 = contador ;R5 = ponteiro ;R6 = Número da matrícula ;R7 = registro utilizado

mov mov mov call jmp nop

#MATR, R6 #0x2403, R5 #4, R4 #W16ASC $

;carrega o valor de matrícula em R6 ;e o endereço 2403 em R5 ;inicializa o contador ;chama a subrotina

;nop=mov #0h,#0h W16ASC:

mov R6, R7 rra R6 rra R6 rra R6 rra R6 and #0xF, R7 call #nibble em um byte de código ASCII mov.b R7,0(R5) dec R5

;cópia em R7 para extrair os nibbles ;desloca 4 vezes o bit para a direita

;extrai os 4 LSBs ;chama a subrotina nibble, que transforma o nibble

dec

R4

jnz

W16ASC

;escreve o byte ASCII na memória ;avança memória ;dec equivale a sub #1,R5 ;decrementa o contador ;dec equivale a sub #1,R4 ;repete o processo até que os nibbles acabem

nibble:

cmp jn add ret

#10,R7 numero #55,R7

;compara o nibble com 10 ;N=1, R7 é menor que 10, então é um número ;caso contrário, é uma letra (adiciona 55)

numero:

add ret

#48,R7

;ret equivale a mov @SP+,PC ;Se R7 for um número, adiciona 48

;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 memória mov #0, R6 ;zera R6 call #ASC_W16 ;chama a subrotina OK: jc OK ;resultado ok NOK: jnc NOK ASC_W16: memória

mov.b @R5+, R7 rla

R6

rla rla rla

R6 R6 R6

;guarda o elemento em R7 e avança na ;move o resultado um nibble para a esquerda ;equivale a add R6,R6

;verificação: pois código ASCII vai de 0x30 a 0x46

ok:

cont:

cmp jn mov cmp jn

#0x30, R7 erro #0x46, R8 R7, R8 erro

;verifica se é menor que 0x30

cmp jn cmp jn

#0x39, R7 ok #0x41, R7 erro

;verifica se está entre 0x39 e 0x41

cmp jn cmp jn

#0x39, R7 numero #0x46, R7 letra

;menor que 0x39, número

;verifica se é maior que 0x46

;menor que 0x46, letra

nop Add

R7,R6

cmp #0x2404,R5 alcançada é a desejada jnz ASC_W16 subrotina setc ret

;mov #0h,#0h ;adiciona os nibbles ao resultado ;confere se a posição de memória ;se não é igual a zero, volta para a ;se não houveram erros, C=1 ;bis #1,SR ;volta para a rotina principal ;mov @SP+,PC

numero:

sub jmp

#48, R7 cont

;número, subtrai 48

letra:

sub jmp

#55, R7 cont

;letra, subtrai 55

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'

Questão 2 Ver códigos acima.

Questão 3 Os vetores são alocados neste endereço pois este é o início do endereço disponível ao usuário na memória RAM, que vai de 0x2400 a 0x4400, em passos de 2kB. De 0X1C00 a 0x2400 tem-se o espaço reservado para comunicação serial.

Questão 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, obtém-se o resultado desejado: nibble:

mov.b tab(R7),R7 mov.b R7,0(R5) ret

Questão 5 O programa 4 pode ser considerado mais eficiente pois o número de testes necessários é menor, economizando em tempo e espaço de processamento.