Informática Industrial - Examen ... - PoliformaT - UPV

Informática Industrial - Examen microcontroladores junio 2011
Nombre y apellidos:
• En la mesa sólo puede tenerse:
• Identificación Personal (Tarjeta Identidad UPV/DNI/Carnet de Conducir)
• Lápiz/Bolígrafo
• Este enunciado
• Tablas resumen publicadas en PoliformaT
• Hojas de respuesta
• Antes de nada, poner el nombre en: el enunciado, en cada hoja de respuesta y en las
• tablas resumen.
• Resolver cada problema en una hoja aparte.
Problema 1 (3,0 puntos).
Se desea implementar un dado electrónico con un microcontrolador de la familia
8051.
Para realizar el dado, se emplea una placa donde se montan 7 LEDs que representan
los posibles valores del dado. Para encender cada LED, el pin correspondiente del
microcontrolador al que se conecta el LED debe ponerse a “0”.
Un pulsador conectado al pin P0.7 se emplea para realizar la tirada, de manera que,
cada vez que se pulsa, debe aparecer un nuevo valor aleatorio en el dado.
+Vcc
P0.7
P0.6
P0.5
P0.4
P0.3
P0.2
P0.1
P0.0
Se pide: Desarrollar el código en C que implementa la funcionalidad del dado con las
siguientes restricciones:
• Emplear máscaras para actualizar la salida del puerto P0 de manera que el bit
P0.7 no se vea afectado. No usar operaciones bit a bit en esta parte.
• Emplear operaciones bit a bit para la lectura del pulsador.
• Definir los sfr y sbit necesarios.
Sugerencia: una manera sencilla de generar un valor aparentemente aleatorio consiste
en ir incrementando un contador mientras el pulsador de tirada se mantiene pulsado.

Problema 2 (3,0 puntos).
Se desea utilizar un microcontrolador de la familia 8051 para realizar un convertidor
de códigos de tres bits.
La tabla de conversión es la siguiente:
Código de
entrada
Código de
salida
000 010
001 011
010 100
011 000
100 101
101 111
110 001
111 110
Los códigos de entrada se reciben por los bits P0.2, P0.1 y P0.0 del microcontrolador
(siendo P0.0 el bit menos significativo del código de entrada)
Los códigos de salida se envían por los bits P1.2, P1.1 y P1.0 (siendo P1.0 el bit
menos significativo del código de salida)
La conversión debe realizarse cada vez que se recibe un flanco de bajada a través del
pin de interrupción externa INT1.
Se pide: Escribir un programa en lenguaje C que atienda la petición de interrupción
externa, leyendo el código de entrada y enviando el código de salida. Definir los sfr y
sbit necesarios.

Problema 3 (4,0 puntos).
Se desea diseñar un sistema basado en un microcontrolador de la familia 8051 para
controlar la alarma un vehículo.
El funcionamiento de la alarma es el siguiente. La alarma se activa o desactiva
mediante un flanco de bajada en el pin P3.2. Cuando la alarma se activa, debe hacerse
un retardo de 10s y, seguidamente, a través del pin P0.1 debe generarse una onda
cuadrada de 2 segundos de periodo como indica la figura. En cualquier momento, un
nuevo flanco en P3.2 (desactivar alarma) detendrá el ciclo, dejando P0.1 a nivel bajo
y el sistema listo para una nueva activación.
Se pide: Diseñar un programa en C que cumpla el requisito de funcionamiento de la
alarma.
MCS-51
P3.2
P0.1
retardo= 10s
T= 2 s
Para ello, declarar todos registros involucrados (“sfr”), los bits necesarios, así como
la utilización de las variables más adecuadas (0,5 ptos).
También, se deberá implementar usar el temporizador C/T0, en ambos casos en el
modo de 16 bits, tanto el retardo, como la salida periódica suponiendo un reloj de 6
MHz. Para ello, se habrá de tener en cuenta que el desborde de C/T0 se deberá
encuestar en ambos casos. (3,5 ptos)

Solución problema 1:
/* dado examen infi juny 2011 */
sfr P0= 0x80;
sbit pulsador = P0^7;
unsigned char
tabla_combinaciones[]={0x3F,0x5B,0x1B,0x52,0x12,0x40};
void main(void) {
unsigned char puntuacion;
puntuacion = 3;
// un valor inicial a ojo
}
while(1) {
while(pulsador == 1) {}; // esperar pulsacion
// mientras está oprimido el pulsador ir contando
while(pulsador == 0) {
puntuacion = (puntuacion + 1) % 6;
}
// actualizar puntos
P0 &= 0x80;
P0 |= tabla_combinaciones[puntuacion];
}
Solución problema 2:
unsigned char tabla_conversion [8] = {2,3,4,0,5,7,1,6};
sfr P0 = 0x80;
sfr P1 = 0x90;
sfr TCON = 0x88;
sfr IE = 0xA8;
sbit IT1 = TCON^2;
sbit EX1 = IE^2;
sbit EA = IE^7;
void convertir (void) interrupt 2 {
P1 = tabla_conversion [ P0 & 0x07 ]; }
void main (void) {
IT1 = 1;

EX1 = 1;
EA = 1;
while (1) { } }
Solución problema 3:
sfr P0 = 0x80;
sfr P3 = 0xB0;
sfr TH0 = 0x8C;
sfr TL0 = 0x8A;
sfr TMOD = 0x89;
sfr TCON = 0x88;
sbit TR0 = TCON^4;
sbit TF0 = TCON^5;
sbit entrada = P3^2;
sbit salida = P0^1;
data bit alarma;
#define alarma_ON 1
#define alarma_OFF 0
#define desbordes_retardo_10_s 100 // 1 CM = 12/6MHz = 2us; 10s
= 5 000 000 CM, suponiendo temporización de 50000 CM
#define desbordes_semiperiodo_1_s 10 // 1s = 500 000 CM duración
de cada semiperiodo, suponiendo temporización de 50000 CM
void main(void){
unsigned char recarga_TH0;
unsigned char recarga_TL0;
bit entrada_activada; // para almacenar si se ha activado
la entrada
unsigned char desbordes;
// preparar timer
TR0 = 0;
TF0 = 0;
TMOD &= 0xF1;
TMOD |= 0x01; // modo 1, timer, gate=0
recarga_TH0 = (65536-50000)/256;
registro TH0 del C/T0
recarga_TL0 = (65536-50000)%256;
registro TL0 del C/T0
// Inicialización del
// Inicialización del
alarma = alarma_OFF;
// bucle infinito
while (1){

salida = 1;
// valor inicial de la salida
// esparar pulso
while(entrada) {} // espera mientras la entrada sea un
nivel alto (=1)
while(entrada==0) {} // espera termacion pulso
nuevo
entrada_activada = 0;
// supones que no ha llega pulso
// temporizar 10 s
salida = 0;
desbordes = desbordes_retardo_10_s;
while ((entrada_activada == 0) && (desbordes > 0)) {
TR0 = 0; TF0 = 0;
TH0 = recarga_TH0; // Inicialización del registro
TH0 del C/T0
TL0 = recarga_TL0; // Inicialización del registro
TL0 del C/T0
TR0 = 1;
while ((entrada_activada == 0) && (TF0 == 0)) {
if (entrada == 0) {
entrada_activada =1; // se ha
detectado pulso
};
}
desbordes--;
}
// temporizar 1 s a nivel alto
salida = 1;
desbordes = desbordes_semiperiodo_1_s;
while ((entrada_activada == 0) && (desbordes > 0)) {
TR0 = 0; TF0 = 0;
TH0 = recarga_TH0; // Inicialización del registro
TH0 del C/T0
TL0 = recarga_TL0; // Inicialización del registro
TL0 del C/T0
TR0 = 1;
while ((entrada_activada == 0) && (TF0 == 0)) {
if (entrada == 0) {
entrada_activada =1; // se ha
detectado pulso
};
}
desbordes--;
}
// temporizar 1 s a nivel alto

salida = 0;
desbordes = desbordes_semiperiodo_1_s;
while ((entrada_activada == 0) && (desbordes > 0)) {
TR0 = 0; TF0 = 0;
TH0 = recarga_TH0; // Inicialización del registro
TH0 del C/T0
TL0 = recarga_TL0; // Inicialización del registro
TL0 del C/T0
TR0 = 1;
while ((entrada_activada == 0) && (TF0 == 0)) {
if (entrada == 0) {
entrada_activada =1; // se ha
detectado pulso
};
}
desbordes--;
}
}
}