UNIVERSIDAD DE MÁLAGA ETSI TELECOMUNICACIÓN

DPTO. DE TECNOLOGÍA ELECTRÓNICA 20 DE DICIEMBRE DE 2012

EXAMEN DE MICROCONTROLADORES TIEMPO: 3 HORAS

APELLIDOS, NOMBRE: ______________________________________________ D.N.I.: _____________

TITULACIÓN: __________________________________________________________________________

INSTRUCCIONES:
a) LEA ATENTAMENTE EL ENUNCIADO Y LAS PREGUNTAS DEL EXAMEN
b) ES NECESARIO OBTENER UN MÍNIMO DE 3 PUNTOS (SOBRE 10) PARA SUPERAR EL EXAMEN
c) LA CALIFICACIÓN DEL EXAMEN CONSITITUYE EL 60% DE LA CALIFICACIÓN FINAL DE LA
ASIGNATURA

DATOS:
a) CONSTANTES DEL FICHERO DE CABECERA “io430g2533.h”:
− #define TASSEL_1 (1*0x100u) /* Timer A clock source select: 1 - ACLK */
− #define TASSEL_2 (2*0x100u) /* Timer A clock source select: 2 - SMCLK */
− #define ID_1 (1*0x40u) /* Timer A input divider: 1 - /2 */
− #define ID_3 (3*0x40u) /* Timer A input divider: 3 - /8 */
− #define MC_2 (2*0x10u) /* Timer A mode control: 2 - Continous up */
− #define MC_3 (3*0x10u) /* Timer A mode control: 3 - Up/Down */
− #define PORT1_VECTOR (2 * 2u) /* 0xFFE4 Port 1 */
− #define USCIAB0TX_VECTOR (6 * 2u) /* 0xFFEC USCI A0/B0 Transmit */
− #define TIMER1_A1_VECTOR (12 * 2u) /* 0xFFF8 Timer1_A CC1, CC2, TA1 */

Se desea diseñar un juego de ingenio basado en el microcontrolador MSP430G2533. Dicho juego pretende
acertar un código de longitud variable generado aleatoriamente, compuesto por dígitos comprendidos entre 0
y 3. Para ello se dispone de un teclado numérico y un LCD que se conectan al microcontrolador a través del
bus I2C (los detalles y el funcionamiento de esta conexión I2C no son relevantes para resolver este examen).
Adicionalmente, se dispone de dos pulsadores, Inicio y Reset. La Figura 1 muestra el esquema del sistema.

Figura 1. Esquema del sistema.

-1/7-
En el esquema de la Figura 1 se puede apreciar que el teclado y el LCD están conectados directamente con
el microcontrolador mediante el bus I2C. El funcionamiento de estos elementos es el siguiente:
– Cuando se pulsa una tecla en el teclado se transmite al microcontrolador a través del bus I2C,
activando la rutina de interrupción RTI_I2C. Esta rutina de interrupción analiza las teclas pulsadas,
y si se corresponden con dígitos comprendidos entre 0 y 3 se almacenan en el array sec2. Cuando el
número de dígitos almacenados coincide con la longitud del código generado se activa la tarea
tareas.f1 del sistema.
– La función Write_LCD(char *string) se encarga de enviar a través del bus I2C una cadena de
caracteres para que el LCD la muestre por pantalla.
El funcionamiento del juego se describe a continuación:
1. Inicialmente el microcontrolador genera un código aleatorio formado por una secuencia de dígitos
entre 0 y 3.
2. Después de generar el código el usuario utilizará el teclado para introducir una secuencia de dígitos
entre 0 y 3, con el objetivo de intentar acertar el código generado.
3. Una vez introducida la secuencia del usuario el microcontrolador la compara con el código generado
e indica en el LCD cuántos dígitos iguales (y que además coincidan con la misma posición del
código generado) tiene la secuencia introducida, aunque no indica qué dígitos son los que coinciden.
4. Si ambas secuencias coinciden totalmente, se habrá acertado el código generado.
En la Figura 2 se muestra un ejemplo en la que el usuario necesita de siete intentos para adivinar el código
generado “2 – 0 – 1”:

0 , 0 ,0 Aciertos: 1

1 , 1 ,1 Aciertos: 1

2 , 2 ,2 Aciertos: 1

3 , 3 ,3 Aciertos: 0

Aciertos: 1
2 , 3 ,3
2 , 1 ,0 Aciertos: 1

2 , 0 ,1 Aciertos: 3 Código acertado!

Figura 2. Ejemplo.

-2/7-
A continuación se muestra el código correspondiente al sistema:
#include "io430g2533.h" Write_LCD("Juego superado!");
#include "stdio.h" __disable_interrupt();
__low_power_mode_4();
/* ====== CONSTANTES ============================= */ } // if (tam > COD)
tareas.f0 = 1;
#define COD 8 } // if (suc == tam)
} // if (tareas.f1)
/* ====== TIPOS DATOS ============================ */ if (tareas.f2) {
tareas.f2 = 0;
typedef union { Write_LCD("--- GAMEOVER ---");
unsigned volatile char total; __disable_interrupt();
struct { __low_power_mode_4();
unsigned char f0 :1; } // if (tareas.f2)
unsigned char f1 :1; } // while (tareas.total)
unsigned char f2 :1; } // for (;;)
}; } // int main(void)
} flags;
/* ====== FUNCIONES ============================= */
/* ====== VARIABLES GLOBALES ===================== */
void Config_uC(void) {
flags tareas; WDTCTL = WDTPW + WDTHOLD;
unsigned char tam, niv, time, sec1[COD], sec2[COD]; DCOCTL = 0;
char text[16+1]; BCSCTL1 = CALBC1_1MHZ;
DCOCTL = CALDCO_1MHZ;
/* ====== PROTOTIPOS ============================= */ P2DIR = BIT7;
P2SEL = BIT7 + BIT6;
void Config_uC(void); } // void Config_uC(void)
void Config_Timers(void);
void Config_Ports(void); void Config_Timers(void) {
void Config_I2C(void); TA0CTL = TASSEL_2 + ID_1 + MC_2 + TACLR;
void Write_LCD(char *string); TA1CCR0 = 0xF000;
TA1CTL = TASSEL_1 + ID_3 + TACLR + TAIE;
/* ====== PROGRAMA PRINCIPAL ===================== */ } // void Config_Timers(void)

int main(void) { void Config_Ports(void) {

unsigned char suc, cont; P1DIR = P1IFG = 0;
unsigned int aux; P1REN = P1OUT = P1IES = P1IE = BIT3;
Config_uC(); } // void Config_Ports(void)
Config_Timers();
Config_Ports(); void Config_I2C(void) {
Config_I2C(); // …
tareas.total = 0; } // void Config_I2C(void)
niv = 1;
tam = 3; void Write_LCD(char *string) {
time = 0; // …
Write_LCD("Pulse Inicio..."); } // void Write_LCD(char *string)
for (;;) {
__low_power_mode_0(); /* ====== RUTINAS TRATAMIENTO INTERRUPCION ====== */
while (tareas.total) {
if (tareas.f0) { #pragma vector = PORT1_VECTOR
tareas.f0 = 0; __interrupt void RTI_P1(void) {
aux = TA0R; tareas.f0 = 1;
for (cont = 0; cont < tam; cont++) { P1IE = P1IFG = 0;
sec1[cont] = (char) (aux >> (2*cont)); TA1CTL |= MC_3;
sec1[cont] &= 0x03; __low_power_mode_off_on_exit();
} // for (cont = 0; cont < tam; cont++) } // void RTI_P1(void)
TA1CTL_bit.TACLR = 1;
time = 0; #pragma vector = USCIAB0TX_VECTOR
sprintf(text, "Nivel: %d", niv); __interrupt void RTI_I2C(void) {
Write_LCD(text); static unsigned char num = 0;
} // if (tareas.f0) // …
if (tareas.f1) { if (num == tam) {
tareas.f1 = 0; tareas.f1 = 1;
suc = 0; __low_power_mode_off_on_exit();
for (cont = 0; cont < tam; cont++) { } // if (num == tam)
if (sec1[cont] == sec2[cont]) { } // void RTI_I2C(void)
suc++;
} // if (sec1[cont] == sec2[cont]) #pragma vector = TIMER1_A1_VECTOR
} // for (cont = 0; cont < tam; cont++) __interrupt void RTI_TA1IFG(void) {
sprintf(text, "Aciertos: %d", suc); TA1CTL_bit.TAIFG = 0;
Write_LCD(text); time++;
if (suc == tam) { if (time == tam) {
Write_LCD("Código acertado!"); tareas.f2 = 1;
niv++; __low_power_mode_off_on_exit();
tam += 2; } // if (time == tam)
if (tam > COD) { } // void RTI_TA1CCR1(void)

-3/7-
Puntuación:
– Respuesta correcta : +0.5 puntos
– Respuesta incorrecta : –0.17 puntos
– Respuesta en blanco : +0.0 puntos

1. Según el algoritmo utilizado para generar el código:

aux = TA0R;
for (cont = 0; cont < tam; cont++) {
sec1[cont] = (char) (aux >> (2*cont));
sec1[cont] &= 0x03;
} // for (cont = 0; cont < tam; cont++)

indicar el número máximo de dígitos que puede tener dicho código:

a. 3
b. 5
c. 7
d. Ninguna de las otras opciones es correcta
2. Si se presiona el pulsador Inicio antes de comenzar el juego cuando el valor del registro TA0R es
0x5C3A, indicar cuál es el código generado de longitud 7 dígitos:
a. 1130032
b. 2230031
c. 1300322
d. Ninguna de las otras opciones es correcta
3. Si se modifica el procedimiento de generación del código para que esté compuesto por dígitos
comprendidos entre 0 y 7:
aux = TA0R;
for (cont = 0; cont < tam; cont++) {
sec1[cont] = (char) (aux >> (3*cont));
sec1[cont] &= 0x07;
} // for (cont = 0; cont < tam; cont++)

indicar cuál sería la longitud máxima que se podría obtener para dicho código:
a. 5
b. 8
c. No se puede realizar dicha modificación
d. Ninguna de las otras opciones es correcta
4. Indicar el número de niveles que hay que pasar para superar el juego:
a. 2
b. 3
c. 4
d. Ninguna de las otras opciones es correcta
5. Indicar cuál es el grado de dificultad que se incrementa al aumentar el nivel del juego:
a. Se aumenta la longitud del código generado
b. Se reduce el tiempo permitido para acertar el código
c. Se reduce el número de intentos permitidos para acertar el código
d. Ninguna de las otras opciones es correcta

-4/7-
6. Indicar cuál es el número de intentos permitidos para intentar acertar el código en un nivel:
a. 8
b. 16
c. 20
d. Ninguna de las otras opciones es correcta
7. Indicar cuál es el tiempo permitido para intentar acertar el código en un nivel:
a. 15 segundos
b. 30 segundos
c. Depende del nivel
d. Ninguna de las otras opciones es correcta
8. Indicar qué ocurre si no se consigue acertar el código de un nivel en el tiempo permitido:
a. El juego comienza de nuevo desde el primer nivel
b. El juego comienza de nuevo desde el nivel actual
c. El juego finaliza y el sistema se bloquea
d. Ninguna de las otras opciones es correcta
9. Indicar la longitud del código en el nivel 3:
a. 3
b. 7
c. 8
d. Ninguna de las otras opciones es correcta
10. Indicar cuál es la utilidad del pulsador Inicio:
a. Generar el código y comenzar el juego
b. Comenzar otra partida una vez que se ha superado el juego
c. Reiniciar el juego durante una partida
d. Ninguna de las otras opciones es correcta
11. Indicar si es necesario incorporar un sistema antirrebote para el pulsador Inicio:
a. Sí, todos los pulsadores necesitan siempre un sistema antirrebote
b. No, pues al utilizar una resistencia de pullup interna en el pin P1.3 no se producen rebotes
c. Depende del código generado
d. Ninguna de las otras opciones es correcta
12. Indicar qué ocurre si se presiona el pulsador Inicio una vez ha comenzado el juego:
a. Nada
b. Se reinicia el juego
c. Depende del nivel en el que se encuentre la partida
d. Ninguna de las otras opciones es correcta
13. Indicar cómo se puede comenzar otra partida una vez que se ha superado el juego:
a. No se puede
b. Presionando el pulsador Inicio
c. Comienza automáticamente
d. Ninguna de las otras opciones es correcta

-5/7-
14. Indicar si es posible reiniciar el juego durante una partida:
a. No
b. Sí, siempre
c. Sí, pero únicamente tras superar el primer nivel
d. Ninguna de las otras opciones es correcta
15. Indicar qué utilidad tiene el pulsador Reset:
a. Ninguna, pues su funcionalidad es la misma que la del pulsador Inicio
b. Reinicia el juego si todavía no se ha llegado al final del mismo
c. Reinicia el juego en cualquier momento
d. Ninguna de las otras opciones es correcta
16. Indicar qué funcionalidad tiene la tarea tareas.f0 del sistema:
a. Generar un código de longitud máxima para todos los niveles al principio del juego
b. Generar un código de la longitud adecuada al principio de cada nivel
c. Generar un código cada vez que se presione el pulsador Inicio
d. Ninguna de las otras opciones es correcta
17. Indicar qué información almacena el array sec1 del sistema:
a. La secuencia introducida por el usuario
b. El valor decimal entre 0 y 9 de los dígitos menos significativos del temporizador TA0R
c. El valor decimal entre 0 y 9 de los dígitos más significativos del temporizador TA0R
d. Ninguna de las otras opciones es correcta
18. Indicar si es posible utilizar el modo de bajo consumo LPM3 en el sistema:
a. Sí
b. No, pues se deshabilitaría la interrupción correspondiente al pulsador Inicio
c. No, pues se deshabilitaría el funcionamiento del temporizador TA0
d. Ninguna de las otras opciones es correcta
19. Desde el punto de vista del usuario, indicar la diferencia que se percibe entre superar y no superar el
juego:
a. Ninguna
b. El texto que aparece en el LCD
c. Si no se supera el juego el sistema se bloquea, y si se supera comienza automáticamente de nuevo
d. Ninguna de las otras opciones es correcta
20. Indicar si existe alguna limitación de tiempo máximo para superar el juego:
a. No, se puede emplear todo el tiempo que se requiera
b. Sí, la suma de los tiempos permitidos para cada uno de los niveles, que es 7.5 minutos
c. Sí, el tiempo permitido para el nivel más complejo, que es 3.5 minutos
d. Ninguna de las otras opciones es correcta

-6/7-
Instrucciones:
– Para seleccionar una respuesta : marcarla


– Para borrar una respuesta marcada : rodearla con un círculo

Respuesta
Pregunta
a b c d

1   

2  

3
  
4 
 
5
  
6   

7  

8  

9 
 
10
  
11   

12
  
13   

14 
 
15  

16 
 
17   

18  

19 
 
20 
 

-7/7-