Capítulo 2

[Link]ón en Lenguaje Ensamblador

En el capítulo anterior vimos el funcionamiento básico de CCS y la

generación de un proyecto utilizando el lenguaje C. Si seguimos los mismos
pasos, la generación de un proyecto en lenguaje ensamblador es
exactamente igual.
Aunque no exista ninguna diferencia, lógicamente, los archivos que
añadamos estarán escritos en ensamblador. CCS asigna a estos archivos la
extensión *.asm.
A pesar de que no vamos a escribir una aplicación completa en lenguaje
ensamblador, pueden existir situaciones donde nos veamos en la necesidad
de escribir partes del código en ensamblador, como puede ser, por ejemplo,
cuando utilicemos elementos que requieran una temporización precisa o
cuando requiramos una secuencia de instrucciones especiales. Para escribir
código de forma eficiente es imprescindible estar familiarizado con la
arquitectura y el juego de instrucciones del microcontrolador.
Si bien los mnemónicos de las instrucciones y su estructura son invariables,
dependiendo del programa ensamblador que utilicemos, las directivas
disponibles, sus sintaxis y los operadores pueden variar. Esta información
está disponible dentro de la que nos ofrece Texas Instruments y viene
referida como “MSP430 Assembly Language Tools”. Está disponible a través
del link: [Link]

1. Estructura de un programa en lenguaje ensamblador

La tabla 2.1 muestra un programa sencillo escrito en lenguaje ensamblador
del MSP430.
Cada línea de código escrita en lenguaje ensamblador puede contener
hasta cuatro campos. El formato genérico de una línea es el siguiente:
[etiqueta [:]] [operación] [operandos] [; comentario]

Sistemas Electrónicos Digitales Capítulo 2-1

 Capítulo 2: Programación en Lenguaje Ensamblador

;************************************************************************
; MSP430F5529 - Práctica 2:
; Programación en lenguaje Ensamblador. Entradas y salidas de propósito general.
;************************************************************************
.cdecls C,LIST, "msp430.h" ; Archivo de cabecera del µC
;----------------------------------------------------------------------------------------------------
.def RESET ; Indicación para el linker de la dirección
; de inicio del programa.
;----------------------------------------------------------------------------------------------------
.text ; Inicio del programa.

RESET mov.w #__STACK_END,SP ; Inicalizamos el puntero de pila

mov.w #WDTPW|WDTHOLD,&WDTCTL ; Detenemos el Watchdog Timer

bis.b #001h,&P1DIR ; Colocamos P1.0 como salida

Loop xor.b #001h,&P1OUT ; Cambia el valor existente en P1.0
mov.w #0A000h,R15 ; Definimos retardo en R15
L1 dec.w R15 ; Decrementamos R15
jnz L1 ; Retardo finalizado?
jmp Loop ; Cambio del led
;-------------------------------------------------------------------------------
; Definición del Stack Pointer
;-------------------------------------------------------------------------------
.sect .stack ; Inicializa la pila con el valor de defecto
.global __STACK_END ; Variable global definida en inicio de RAM
;-------------------------------------------------------------------------------
; Vectores de interrupción
;-------------------------------------------------------------------------------
.sect ".reset" ; Vector de RESET del MSP430
.word RESET

Tabla 2-1. Programa [Link]

A la hora de escribir deberemos seguir los siguientes criterios:

 Todas las líneas de código deben empezar por una etiqueta, un
espacio en blanco, un asterisco o un punto y coma.
 Las etiquetas son opcionales, pero en el caso de que se utilicen
deben empezar obligatoriamente en la primera columna.
 Cada campo debe estar separado del siguiente por una tabulación o
por uno o varios espacios.
 Los comentarios son opcionales. Todos los comentarios que
empiecen en la primera columna deben estar precedidos de un
asterisco o un punto y coma. En el caso de que no empiecen en esta
primera columna siempre deben ir precedidos de punto y coma
(exclusivamente).
Veamos el significado de cada uno de los campos.

Sistemas Electrónicos Digitales Capítulo 2- 2

 Capítulo 2: Programación en Lenguaje Ensamblador

Etiquetas
Una etiqueta debe ser un identificador 1 válido colocado en la columna 1.
Cada instrucción puede tener, opcionalmente, una etiqueta. Muchas
directivas también las admiten y en otras su uso será obligatorio.
Las etiquetas pueden ir seguidas de dos puntos (:). Su uso es opcional y
no formarán parte de la misma.
Cuando utilizamos una etiqueta ante una instrucción en ensamblador (o
una directiva), automáticamente esta etiqueta pasa a tener la dirección de
memoria en que se encuentra dicha instrucción.

Operación
El campo correspondiente a la operación se encuentra inmediatamente a la
derecha de la etiqueta. Este campo no puede empezar en la columna 1 o
será interpretado como una etiqueta. Podrá contener:
 Mnemónicos correspondientes al lenguaje ensamblador (como ADD,
MOV, JMP, etc.)
 Directivas del ensamblador (como .data, .equ, etc.)

Operandos
Son los elementos sobre los que se realiza la operación y pueden estar
constituidos por ninguno, uno o más elementos separados por comas.
Pueden estar constituidos por:
 Una constante representativa de un valor numérico o una dirección.
 Un nombre simbólico que represente un valor numérico o una
dirección.
 Un registro
 Un símbolo predefinido
 El Contador de Programa

Comentarios
Los comentarios están constituidos por cualquier expresión o aclaración
que queramos incluir. Pueden contener cualquier carácter ASCII,
incluidos espacios en blanco y no afectan al proceso de ensamblado.
Una línea puede estar constituida únicamente por un comentario. Si
empieza en la columna 1 puede empezar con un punto y coma (;) o con
un asterisco (*). Si no empieza en la primera columna, entonces solo
podrá empezar con punto y coma.

1
Un identificador puede estar constituido por una cadena de caracteres alfanuméricos (A-Z, a-z, 0-9), el símbolo dolar
($) y el subguión (_). El primer carácter de un identificador no puede ser un número y no pueden contener espacios en
blanco. Se diferencian mayúsculas y minúsculas, por lo que ABC, Abc y abc serán tres identificadores distintos.
Sistemas Electrónicos Digitales Capítulo 2- 3
 Capítulo 2: Programación en Lenguaje Ensamblador

2. Constantes
Una constante literal (que también podemos encontrar referidas como
literales o valores inmediatos en la literatura) es un valor que viene
expresado en el mismo formato convencional que utilizamos
habitualmente, como puede ser, por ejemplo, 12, 3.14, u “hola”.
El ensamblador soporta diferentes tipos de constantes:
 Enteros binarios
 Enteros octales
 Enteros decimales
 Enteros hexadecimales
 Caracteres
 Cadenas de caracteres
 Números en coma flotante

2.1 Constantes enteras

El ensamblador mantiene cada literal entero internamente como un entero
de 32 bits sin signo. En ningún caso se realiza una extensión del signo. Por
ejemplo, la constante 0xFF será 00FF en base 16 (o 255 en decimal). Si lo
que necesitábamos era almacenar el -1 debemos guardar 0xFFFFFFFF (en
base 16).

2.1.1 Enteros binarios

Un entero binario es una cadena de 32 bits seguidos por el sufijo B (o b).
Alternativamente se puede utilizar el formato que emplea el prefijo 0B (0b).
Si se indica una cantidad menor a los 32 bits, el ensamblador completará
los dígitos que falten con ceros. Ejemplos:
 00000000B Representación del 010
 0100000b Representación del 3210
 01b Representación del 110
 11111000 Representación del 24810
 0b00101010 Representación del 4210
 0B101010 Representación del 4210

2.1.2 Enteros octales

Un entero octal es una cadena de 11 dígitos octales seguidos por el sufijo
Q (o q). Si no le colocamos este sufijo, un entero octal debe empezar
siempre con 0 y no deberá contener los dígitos 8 o 9. Por ejemplo:
 10Q Representa el 810
 054321 Representa el 2273710
 100000Q Representa el 3276810
 226q Representa el 15010

Sistemas Electrónicos Digitales Capítulo 2- 4

 Capítulo 2: Programación en Lenguaje Ensamblador

2.1.3 Enteros decimales

Un entero decimal es una cadena de dígitos decimales situados en el
rango -2147 483 648 a 4294 967 295. Cualquier cadena decimal
quedará expresada por el valor indicado y no utiliza prefijo ni sufijo
alguno.

2.1.4 Enteros hexadecimales

Un entero hexadecimal es una cadena de hasta 8 dígitos hexadecimales
seguidas por el sufijo H (o h) o precedida por 0x. En el caso de utilizar
el formato que emplea el sufijo, cualquier entero hexadecimal debe
empezar por un digito decimal (0 a 9). Si representamos menos de 8
dígitos hexadecimales, el ensamblador completa los faltantes con 0 por
la izquierda. Ejemplos:
 78h Representa el 12010
 0x78 Representa el 12010
 0Fh Representa el 1510
 37ACh Representa el 1425210

2.1.5 Caracteres
Un carácter literal es un carácter único que se encuentra entre comillas
simples. Los caracteres se representan internamente mediante su
código ASCII con 8 bits. Se requieren dos comillas simples para
considerar cada comilla simple como parte de un carácter. Un carácter
consistente únicamente en dos comillas simples es válido y se le asigna
el valor 0. Por ejemplo:
 ‘a’ Define el carácter a y se representa internamente como 6116
 ‘C’ Define el carácter C y se representa internamente como 4316
 ‘’’’ Define el carácter ‘ y se representa internamente como 2716
 ‘’ Define el carácter nulo y se representa internamente como 0

2.2 Cadena de Caracteres

Una cadena de caracteres es una secuencia de caracteres encerrados
entre dobles comillas. Si las dobles comillas deben formar parte de la
cadena se deben representar como dos consecutivas. La longitud
máxima dependerá de la directiva con que se utilice. Cada caracter se
representa internamente con su código ASCII con 8 bits. Ejemplos:
 “programa ejemplo” Define la cadena de 16 caracteres
programa ejemplo
 “PLAN “”B””” Define la cadena de 8 caracteres PLAN
“B”

2.3 Constantes en Coma Flotante

Una constante en coma flotante es una cadena de digitos decimales
seguida por un punto, una parte fraccionaria opcional y por una también
opcional parte representativa del exponente. Su sintaxis sería:
[+|-] nnn.[nnn] [e|E [+|-] nnn]

Sistemas Electrónicos Digitales Capítulo 2- 5

 Capítulo 2: Programación en Lenguaje Ensamblador

Reemplazaremos nnn con una cadena de dígitos decimales. Podemos

predecer nnn con un + o un – y debemos colocar específicamente un
punto decimal. Por ejemplo 3.e5 es válido, pero 3e5 no lo es. Ejemplos:
 3.0 Representa el 3.00
 3.14 Representa el 3.14
 3. Representa el 3.00
 -0.314e13 Representa -0.31*1013
 +314.59e-2 Representa el 314.59*10-2

3 Directivas
Las directivas se utilizan para proporcionar información al programa y
controlar el proceso de ensamblado. Nos permitirán entre otras acciones:
 Ensamblar código y datos en secciones específicas.
 Reservar espacio en memoria para variables.
 Inicializar la memoria.
 Ensamblar bloques condicionales.
 Definir variables globales.

Para definir variables globales se hace uso de .global, que hace referencia
a símbolos definidos en un archivo que pueden ser vistos desde otro.
Para utilizar en ensamblador de archivos de cabecera y prototipos definidos
en C haremos uso de .cdecls
Para finalizar un programa haremos uso de .end

3.1 Directivas para el control de secciones

Una sección es un bloque de código o datos que ocupan posiciones
contiguas en memoria. Habitualmente encontraremos tres tipos de
secciones:
 .text, que contendrá el código ejecutable.
 .data, que normalmente contiene los datos que han sido inicializados.
 .bss, que se emplea para reservar espacio en memoria para las
variables no inicializadas.

.bss

RAM
.data

.text
FLASH

Figura 2-1. Distribución de las secciones en memoria.

Sistemas Electrónicos Digitales Capítulo 2- 6

 Capítulo 2: Programación en Lenguaje Ensamblador

El CCS construye estas secciones durante el proceso de ensamblado

haciendo la asignación que nos muestra la figura 2.1.
Las directivas .text y .data no admiten parámetros y se sitúan siempre al
inicio del espacio de memoria en el que se integran (o tras la primera
dirección libre si ya han sido utilizadas previamente).
La directiva .bss tiene el formato:
.bss nombre_variable, tamaño en bytes
Ejemplo:
.bss temp, 2 ; reserva 2 bytes para la variable temp

3.2 Directivas para la reserva de espacio

Para reservar espacio de memoria utilizaremos las directivas:
 .space tamaño, que reserva el número de bytes indicado por tamaño.
La etiqueta que la acompañe hará referencia a la posición de memoria
en la que se inicia la reserva.
 .bes tamaño, que reserva el número de bytes indicado por tamaño. La
etiqueta que la acompañe hará referencia a la posición de memoria en
la que finaliza la reserva.
Ejemplo:
.data ; la dirección inicial de la RAM es 2400h
Dat1 .bes 4 ; la directiva .bes reserva 4 posiciones y Dat1
; tendrá el valor 2403h
Dat2 .space 4 ; .space también reserva 4 posiciones pero
; Dat2 valdrá 2404h

3.3 Directivas para inicializar valores

Para inicializar datos en memoria utilizaremos las directivas:
 .bits coloca uno o más bits de forma consecutiva
 .byte o .char colocan uno o más valores de 8 bits en posiciones de
memoria consecutivas.
 .ubyte o .uchar colocan uno o más valores de 8 bits sin signo en
posiciones de memoria consecutivas.
 .word, .int, .half, .short. colocan uno o más valores de 16 bits en
posiciones de memoria consecutivas.
 .uword, .uint, .uhalf, .ushort colocan uno o más valores de 16 bits sin
signo en posiciones de memoria consecutivas.
 .float coloca una o más valores en coma flotante expresados en IEEE754
en simple precisión en posiciones de memoria consecutivas.
 .double coloca una o más valores en coma flotante expresados en
IEEE754 en doble precisión en posiciones de memoria consecutivas.
 .set y .equ asignan un valor a un símbolo
 .string coloca los caracteres (8 bits) de la cadena indicada en posiciones
de memoria consecutivas.
Ejemplos:
Dato1 .bits 1,0,1,0,0,1,1
.byte 23, 51, 0x1A
Datow .word 2432, 0x1234, 0xa234
RES .equ R10
IND .set 100
Sistemas Electrónicos Digitales Capítulo 2- 7
 Capítulo 2: Programación en Lenguaje Ensamblador

CAD1 .string “hola”

Num4 .float -2.4e25
Num2 .double 6

4 Programa ejemplo [Link]

El programa de la Tabla 2.1 es similar al que realizamos en la práctica 1 en
lenguaje C. Su comportamiento es el mismo y los resultados que se
obtienen son idénticos.
Hagamos una breve descripción de los elementos que encontramos ahora
y su significado. Para ello, vamos a crearnos un nuevo proyecto:
 Siguiendo los pasos de la práctica anterior, creamos un proyecto vacío
para ensamblador (Empty Assembly-only Project) de nombre practica2.
 Code Composser Studio nos generará una plantilla para trabajar en
ensamblador que incluirá varias directivas cuyo objetivo es ahorrarnos
trabajo.
Observemos el archivo [Link] de la Tabla 2.1. En primer lugar
encontramos .cdecls C,LIST,"msp430.h", que hace referencia al archivo
genérico msp430h escrito en C. Este archivo enlaza directamente con el del
microcontrolador que hayamos seleccionado en el proyecto y nos permitirá
utilizar las definiciones que contiene. Sería el equivalente a utilizar un
“include” en C.
A continuación encontramos la directiva .def, que es la que utiliza Code
Composer para indicarle al linker la dirección de inicio del programa y que
salvo que indiquemos lo contrario coincidirá con el inicio de la memoria
flash.

Figura 2-2. Desensamblado y codificación de las instrucciones

Sistemas Electrónicos Digitales Capítulo 2- 8

 Capítulo 2: Programación en Lenguaje Ensamblador

En la figura 2-2 podemos ver la correspondencia entre el código que hemos

escrito y el desensamblado que nos proporciona CCS. Para obtener la
ventana de desensamblado la seleccionaremos en la pestaña View.
Podemos ver el número de línea y código que hemos escrito y en la línea
siguiente la dirección de memoria donde se ubicará, su codificación y el
código equivalente que le asigna CCS.
Una vez definido el segmento de código con .text, encontramos las
instrucciones correspondientes a las operaciones que constituyen nuestro
programa. En este caso concreto, son las que harán que el diodo LED
conectado en el bit 0 del puerto P1 parpadee.
Posteriormente aparece un comentario “Vectores de interrupción”. Una
interrupción es una señal, normalmente generada por el hardware, que nos
advierte de que se ha producido un evento que debe atenderse de forma
inmediata. En el MSP430 las interrupciones tienen asignada una dirección
en la que se indicará dónde se encuentra su rutina de tratamiento. Este
mismo método es el utilizado para el RESET. Siempre que arrancamos
nuestro microcontrolador, se produce un RESET. Su dirección de
tratamiento se corresponde con las dos últimas palabras de memoria
(0xFFFE-0xFFFF) y el contador de programa se inicializará con la dirección
que introduzcamos en ellas.
Tras la directiva .sect “.reset” con la que señalamos que los datos
posteriores constituirán la dirección de tratamiento de esta interrupción,
encontramos .word con el valor RESET, que es la dirección correspondiente
a la primera instrucción de nuestro programa (0x4400h).
Podemos visualizar el valor de los registros internos (Core Registers) y
comprobar que el contenido del Contador de Programa ha pasado a ser
0x4400 (figura 2-2).

5 Repertorio de instrucciones del MSP430

El MSP430 está dotado de 27 instrucciones básicas y 27 emuladas cuya
descripción y sintaxis ya hemos visto en las clases de teoría de la asignatura
y cuya descripción detallada se encuentra en la Guía de Usuario del
microcontrolador ([Link] A
grandes rasgos, las podemos dividir en diferentes grupos:
 Transferencia
 Aritméticas y Lógicas
 De desplazamiento y rotación
 De control de flujo del programa
La forma de especificar los operandos en estas instrucciones constituyen
los modos de direccionamiento:
 Inmediato
 A Registro
 Indexado
 Simbólico
 Absoluto
 Indirecto a Registro
 Indirecto a Registro con autoincremento

Sistemas Electrónicos Digitales Capítulo 2- 9

 Capítulo 2: Programación en Lenguaje Ensamblador

6 Ejercicios
Escribe el programa de la Tabla 2.1 y compílalo comprobando que no tiene
errores. Inicia una sesión de Debug.
o Encuentra la ecuación que relaciona el contenido de R15 con el
número de ciclos que tarda en ejecutarse el bucle L1.

6.1 Cuestiones
Responde a las siguientes cuestiones:
 ¿Cuál es el valor de la frecuencia y periodo de parpadeo del diodo rojo?
Mide esta frecuencia haciendo uso del osciloscopio. El diodo rojo se
encuentra conectado en P1.0.
 ¿Durante cuántos ciclos de reloj está el diodo a uno y durante cuántos
a cero? Habilita el reloj en CCS para contabilizarlos.
 ¿Cuántos bytes de memoria ocupa el programa?

6.2 Escribiendo un programa

1. Tomando como base el ejemplo de la Tabla 2.1 escribe un programa en
lenguaje ensamblador que haga que el diodo led verde conectado en
P4.7 este encendido durante 100.000 ciclos de reloj y apagado durante
120.000.

2. Escribe un programa en lenguaje ensamblador que cumpla las

siguientes especificaciones:

o A partir del inicio de la memoria RAM (0x2400) deberemos

encontrar 10 bytes vacíos y a continuación los datos 0xA111,
0xB222, 0xC333, 0xD444, E555h, 0xF666, 0xFFFF. Utiliza
directivas para incorporarlos.
o Utilizando direccionamiento indirecto a registro/indexado,
copia el contenido de la dirección de memoria con los datos
introducidos a partir de la 0x02420h.

1. En las cuestiones anteriores hemos visto que si ejecutamos paso a paso el ejemplo de la
Tabla 2.1 obtenemos que el tiempo necesario para la ejecución de la instrucción dec.w
R15 es de 1 ciclo de reloj y jnz L1 de 2 ciclos. Por tanto, el retardo introducido es de 3
veces el contenido de R15. Si necesitamos que esté encendido 100.000 ciclos de reloj, el
valor que debemos colocar en R15 es, aproximadamente de 33.333. Para que esté
apagado 120.000 ciclos pondremos 40.000.
Aunque podemos asignar los valores directamente al escribir el programa, si lo hacemos
por ejemplo mediante etiquetas, los valores solo se sustituyen durante el ensamblado y
no se almacenan en memoria.

;-------------------------------------------------------------------------------
; 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.
Encendido .equ 33333 ; Número de ciclos encendido
Apagado .equ 40000 ; Número de ciclos apagado
RESET mov.w #__STACK_END,SP ; Initialize stackpointer
Sistemas Electrónicos Digitales Capítulo 2- 10
 Capítulo 2: Programación en Lenguaje Ensamblador

StopWDT mov.w #WDTPW|WDTHOLD,&WDTCTL ; Stop watchdog timer

;-------------------------------------------------------------------------------
; Main loop here
;-------------------------------------------------------------------------------
bis.b #001h,&P1DIR ; Colocamos P1.0 como salida
Loop xor.b #001h,&P1OUT ; Cambia el valor existente en P1.0
mov.w #Encendido,R15 ; Definimos retardo de encendido
L1 dec.w R15 ; Decrementamos el contador de tiempo
jnz L1 ; Retardo finalizado?
mov.w #Apagado,R15 ; Definimos retardo apagado
L2 dec.w R15 ; Decrementamos el contador de tiempo
jnz L2 ; Retardo finalizado?
jmp Loop
nop
;-------------------------------------------------------------------------------
; Stack Pointer definition
;-------------------------------------------------------------------------------
.global __STACK_END
.sect .stack
;-------------------------------------------------------------------------------
; Interrupt Vectors
;-------------------------------------------------------------------------------
.sect ".reset" ; MSP430 RESET Vector
.short RESET

2. Para definir datos en memoria lo haremos utilizando la sección .data. Esta directiva
ubicará los datos indicados a partir del inicio de la RAM (en el MSP430F5529 en la
dirección 0x2400). La reserva de espacio la podemos hacer con la directiva .space y la
introducción de datos, puesto que son datos de 16 bits, con .word

;-------------------------------------------------------------------------------
.cdecls C,LIST,"msp430.h" ; Include device header file
;-------------------------------------------------------------------------------
.def RESET ; Export program entry-point to
; make it known to linker.
;-------------------------------------------------------------------------------
*La sección .data nos permite introducir datos en memoria.
.data
.space 10 ; Reservamos 10 bytes
datos .word 0xA111,0xB222,0xC333,0xD444,0xE555,0xF666,0xFFFF
;-------------------------------------------------------------------------------
.text ; Assemble into program memory.
RESET mov.w #__STACK_END,SP ; Initialize stackpointer
StopWDT mov.w #WDTPW|WDTHOLD,&WDTCTL ; Stop watchdog timer
mov.w #datos,R10 ; Cargamos en R10 la dirección de
; inicio de los datos
mov.w #0x2420,R12 ; Cargamos en R12 la dirección para
; guardar los datos
mov.b #7,R5 ; Contador con la cantidad de datos
transf mov.w @R10,0(R12) ; Copiamos el dato
incd.w R10 ; Incrementamos dirección fuente
incd.w R12 ; Incrementamos dirección destino
dec.b R5 ; Decrementamos contador de datos
jnz transf ; hasta finalizar
jmp $ ; Salto sobre la misma dirección
nop ; (bucle infinito)
;-------------------------------------------------------------------------------

Sistemas Electrónicos Digitales Capítulo 2- 11

 Capítulo 2: Programación en Lenguaje Ensamblador

; Stack Pointer definition

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

7 Problemas

7.1 Instrucciones aritmético-lógicas

Escribe un programa en lenguaje ensamblador que realice la suma de una
serie de números con signo, según las siguientes especificaciones:
 Los números a sumar se encuentran en bytes sucesivos a partir de la
dirección de inicio de la RAM. Mediante directivas, coloca inicialmente
los datos -95, 17, -78, 77, 119, 51, -44, 122, -27 y 127.
 El resultado debe de almacenarse en el byte de memoria RESULTADO
 ¿El resultado es positivo o negativo?

;-------------------------------------------------------------------------------
; 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.
;-------------------------------------------------------------------------------
.data
datos .byte -95,17,-78,77,119,51,-44,122,-27,127
resultado .space 1
;-------------------------------------------------------------------------------
.text ; Assemble into program memory.
RESET mov.w #__STACK_END,SP ; Initialize stackpointer
StopWDT mov.w #WDTPW|WDTHOLD,&WDTCTL ; Stop watchdog timer
mov #datos,R10 ; Cargamos dirección de inicio de datos
mov #10,R8 ; Cargamos cantidad de datos
xor.b R5,R5 ; Inicialicamos Registro Suma
suma add.b @R10,R5 ; Sumamos el dato siguiente
inc R10 ; Incrementamos dirección del dato
dec R8 ; Decrementamos contador de datos
jnz suma ; Y regresamos hasta finalizar
mov.b R5,&resultado ; Almacenamos resultado
jmp $
nop
;-------------------------------------------------------------------------------
; Stack Pointer definition
;-------------------------------------------------------------------------------
.global __STACK_END
.sect .stack
;-------------------------------------------------------------------------------
; Interrupt Vectors

Sistemas Electrónicos Digitales Capítulo 2- 12

 Capítulo 2: Programación en Lenguaje Ensamblador

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

7.2 Instrucciones de desplazamiento y rotación

Escribe un programa en lenguaje en lenguaje ensamblador que cumpla las
siguientes especificaciones:
 Debe inicializar una serie de 5 números de 16 bits.
 Debe leer estos números de 16 bits y modificarlos de forma que los
datos de su byte bajo se desplacen tantos lugares como indiquen los
tres bits menos significativos de su byte alto (b10,b9,b8).
 El desplazamiento será a la derecha si el bit más significativo de este
byte alto (b15) está a 0 y a la izquierda si está a 1.
 Los desplazamientos siempre introducirán ceros.
 El resultado debe quedar en las posiciones de memoria RESULTADO y
siguientes y estará compuesto por el byte bajo desplazado y el alto a
cero excepto los bits implicados en el desplazamiento (b15,b10,b9,b8) que
permanecerán inalterados.

;-------------------------------------------------------------------------------
; 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.
.data
datos .word 0x1234,0xC234,0x6006,0x0345,0xAAAA
Resultado .space 10
;-------------------------------------------------------------------------------
.text ; Assemble into program memory.
RESET mov.w #__STACK_END,SP ; Initialize stackpointer
StopWDT mov.w #WDTPW|WDTHOLD,&WDTCTL ; Stop watchdog timer
mov.w #datos,R14 ; Registro puntero de datos
mov.w #Resultado,R13 ; Registro puntero resultados
mov.b #5,R15 ; Cantidad de datos
inicio mov @R14,R6 ; R6 Dato
mov.b R6,R7 ; R7 Byte bajo
mov R6,R8
swpb R8 ; Intercambio de bytes
tst R6 ; Comprobamos el bit 15 es 1 o 0
jn izquierda
and #7,R8 ; Cantidad de desplazamientos
jz hecho ; Si es 0 finalizamos
derecha clrc ; C=0, ya que se incluye en la rotación
rrc.b R7 ; Desplazamos R6 a la derecha las que
dec R8 ; las veces que indique R8
jnz derecha ;
jmp hecho
izquierda and #7,R8 ; O a la izquierda
jz hecho
izq2 clrc ; C=0, ya que se incluye en la rotación

Sistemas Electrónicos Digitales Capítulo 2- 13

 Capítulo 2: Programación en Lenguaje Ensamblador

rlc.b R7 ; Desplazamos a la izquierda

dec R8
jnz izq2
hecho and #0x8700,R6 ; Nos quedamos con los bits altos pedidos
or R7,R6 ; Y le añadimos el byte desplazado
mov R6,0(R13) ; Guardamos el resultado
incd R14 ; Actualizamos puntero de datos
incd R13 ; Actualizamos puntero de resultados
dec R15 ; Decrementamos contador de datos
jnz inicio ; y si no es 0, cargamos nuevo dato
jmp $
nop
;-------------------------------------------------------------------------------
; Stack Pointer definition
;-------------------------------------------------------------------------------
.global __STACK_END
.sect .stack

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

Sistemas Electrónicos Digitales Capítulo 2- 14