Examen de Enero de Informática Industrial.
Julio 2018
Teoría 2.5 puntos.
Explicar las características generales de un microcontrolador de 8 bits (0.75 punto).
Explicar brevemente los siguientes conceptos (1 punto).
• Modulación
• Multiplexación en frecuencia
• Enlace half-duplex
• Redes de banda base
• Polling (o sondeo) y selección como técnicas de control de acceso al medio.
Compara brevemente las características de los enlaces RS-232 RS-485 y RS-422 (0.75 puntos)
Programa 3 de microcontroladores. Velocidad. 2 puntos
La parte óptica de un encoder incremental proporciona un nivel alto cuando alguna de las NVent
ventanas del disco se encuentra entre el diodo emisor y el transistor receptor. El receptor se halla
conectado a la patilla P3.3.
Realizar un programa que obtenga el tiempo transcurrido entre cada paso
de ventana y calcule la velocidad en revoluciones por minuto. Las
Emisor Receptor
unidades de millar y centenas de la velocidad se mostrarán en el puerto
P1, y las decenas y unidades en el puerto P2.
Por ejemplo, si la velocidad son 1485 rpm, se mostrará 14 en P1 y 85 en
P2.
El número de ventanas NVent y el reloj del oscilador se proporcionan como defines.
Responder a las siguientes preguntas:
- ¿Es necesario utilizar interrupciones externas? En caso de respuesta afirmativa, indicar cuál
o cuáles y la configuración más apropiada.
- ¿Es necesario utilizar temporizadores? En caso de respuesta afirmativa, indicar:
o El temporizador o temporizadores utilizados y la configuración más apropiada.
o ¿Es necesario asociar interrupciones a los temporizadores utilizados?
// Encoder
#include <reg51.h>
#define NVent 256
#define fosc 12000000L
int calcula_rpm(unsigned int ncm)
{
int rpm = (int) (fosc /12. / NVent * 60 / ncm);
return rpm;
}
void main(void)
{
IE = 0x84;
TCON = 0x04;
TMOD = 0x01;
TR0 = 1;
while(1);
}
void pulso(void) interrupt 2
{
int cm, rpm;
TR0 = 0;
cm = TH0 * 256 + TL0;
TR0 = 1;
TH0 = TL= = 0;
rpm = calcula_rpm(cm);
P1 = rpm/100;
P2 = rpm%100;
}
Programa 1A de microcontroladores. 2.5 puntos
El objetivo es crear una función que obtenga la trayectoria óptima para, partiendo desde el punto
inicial (0,0), pase por una serie de puntos de manera que la distancia total sea mínima. Para ello:
1. Crear una estructura tPunto que tenga como campos los valores enteros x e y
2. Crear una función llamada Distancia que calcule la distancia entre dos puntos como la mayor
de las distancias en x e y; esto es, si por ejemplo los puntos a considerar son (2,10) y (5,1), la
distancia será 9 (el mayor entre |5 - 2| y |1 - 10| ). Para ello, la función aceptará dos parámetros
de entrada de tipo TPunto llamados punto1 y punto2 y devolverá un entero con la distancia.
Puede utilizarse la macro abs(a) que se encuentra en la librería math.h.
3. Programar una función llamada Trayectoria_Optima con los siguientes parámetros enteros:
o Entrada: Dimension N de la serie de puntos
o Entrada: Vector de variables tPunto indicando los lugares por los que pasar. Suponemos
que con índice 0, siempre tendremos el punto (0,0)
o Salida: Distancia total recorrida dist_total.
La función realizará las siguientes tareas:
A. Partimos de un contador cont igual a 0. Apunta por tanto al punto (0,0). También se parte de
una variable dist_total igual a 0.
B. Obtener la distancia desde el punto con índice cont hasta cada uno de los restantes puntos y
deducir cuál es el punto más cercano (el que está a menor distancia). Supongamos que es el
punto con índice q.
C. Intercambiar los contenidos de las posiciones q y (cont +1).
D. La variable dist_total se incrementa con la menor distancia obtenida.
E. Incrementamos cont.
F. Comprobar si se han analizado todos los puntos, y si no es así, volver al punto B
Realizar un pequeño programa de ejemplo que llame a la función
(0,0) (5, 20) (12, 13) (8, 9) (4, 2) (11, 17) (5, 2) (2, 4) (7, 3)
ind = 0 ind = 1 ind = 2 ind = 3 ind = 4 ind = 5 ind = 6 ind = 7 ind = 8
Partiendo del punto (0,0), el elemento más cercano es el que tiene índice 4
(0,0) (5, 20) (12, 13) (8, 9) (4, 2) (11, 17) (5, 2) (2, 4) (7, 3)
ind = 0 ind = 1 ind = 2 ind = 3 ind = 4 ind = 5 ind = 6 ind = 7 ind = 8
Se intercambian los contenidos en la posición 4 y 1
(0,0) (4, 2) (12, 13) (8, 9) (5, 20) (11, 17) (5, 2) (2, 4) (7, 3)
ind = 0 ind = 1 ind = 2 ind = 3 ind = 4 ind = 5 ind = 6 ind = 7 ind = 8
El elemento más cercano a (4, 2) es el que tiene índice 6. Se intercambia su contenido con el elemento
con índice 2
(0,0) (4, 2) (12, 13) (8, 9) (5, 20) (11, 17) (5, 2) (2, 4) (7, 3)
ind = 0 ind = 1 ind = 2 ind = 3 ind = 4 ind = 5 ind = 6 ind = 7 ind = 8
(0,0) (4, 2) (5, 2) (8, 9) (5, 20) (11, 17) (12, 13) (2, 4) (7, 3)
ind = 0 ind = 1 ind = 2 ind = 3 ind = 4 ind = 5 ind = 6 ind = 7 ind = 8
Se continúa para cont = 2, siendo el siguiente valor (7, 3)
(0,0) (4, 2) (5, 2) (7, 3) (5, 20) (11, 17) (12, 13) (2, 4) (8, 9)
ind = 0 ind = 1 ind = 2 ind = 3 ind = 4 ind = 5 ind = 6 ind = 7 ind = 8
Y así sucesivamene hasta completar la serie.
#include <reg51.h>
#include <math.h>
// #define abs(a) ((a) > 0? (a): (-(a)))
typedef struct
{
int x;
int y;
} tPunto;
int Distancia(tPunto P1, tPunto P2)
{
int resx, resy;
resx = abs(P1.x - P2.x);
resy = abs(P1.y - P2.y);
if (resx > resy)
return resx;
return resy;
}
int Trayectoria_Optima(int N, tPunto serie[])
{
int dist_total = 0;
int menor_dist, ind_menor_distancia ;
int esta_dist;
tPunto swap;
int cont, cont_r;
for (cont = 0; cont < N-1; cont ++)
{
menor_dist = Distancia(serie[cont], serie[cont+1]);
ind_menor_distancia = -1;
for (cont_r = cont + 2; cont_r < N; cont_r++)
{
esta_dist = Distancia(serie[cont], serie[cont_r]);
if (esta_dist < menor_dist)
{
menor_dist = esta_dist;
ind_menor_distancia = cont_r;
}
}
if (ind_menor_distancia != -1)
{
swap.x = serie[ind_menor_distancia].x;
swap.y = serie[ind_menor_distancia].y;
serie[ind_menor_distancia].x = serie[cont+1].x;
serie[ind_menor_distancia].y = serie[cont+1].y;
serie[cont+1].x = swap.x; serie[cont+1].y = swap.y;
}
dist_total += menor_dist;
}
return dist_total;
}
void main(void)
{
tPunto serieP[] = {{0,0}, {5,20}, {12,13}, {8,9}, {4,2}, {11,17}, {5,2},
{2,4}, {7,3}};
int dist;
dist = Trayectoria_Optima(9, serieP);
}
Programa 1B de microcontroladores. 2.2 puntos
El objetivo es crear una función que obtenga la trayectoria óptima para, partiendo desde el punto
inicial (0,0), pase por una serie de puntos de manera que la distancia total sea mínima. Para ello:
1. Crear una función llamada Distancia que calcule la distancia entre dos puntos como la mayor
de las distancias en x e y; esto es, si por ejemplo los puntos a considerar son (2,10) y (5,1), la
distancia será 9 (el mayor entre | 5 – 2 | y | 1 – 10 | ). Para ello, la función aceptará dos vectores
de enteros (de dimensión 2) llamados punto1 y punto2 y devolverá un entero con la distancia.
Cada vector tendrá en su elemento 0 el valor de la x, y en su elemento 1, el valor de la y. Puede
utilizarse la macro abs(a) que se encuentra en la librería math.h.
2. Programar una función llamada Trayectoria_Optima con los siguientes parámetros enteros:
o Entrada: Dimension N de la serie de puntos
o Entrada: Matriz de N filas y dos columnas indicando los lugares por los que pasar. Cada
fila será un punto de los que componen la serie. Suponemos que la fila con índice 0
corresponderá siempre al punto (0,0)
o Salida: Distancia total recorrida dist_total.
La función realizará las siguientes tareas:
A. Partimos de un contador cont igual a 0. Apunta por tanto al punto (0,0). También se parte
de una variable dist_total igual a 0.
B. Obtener la distancia desde el punto con índice cont hasta cada uno de los restantes puntos
y deducir cuál es el punto a menor distancia. Supongamos que es el punto con índice q.
C. Intercambiar los contenidos de las posiciones q y (cont +1).
D. La variable dist_total se incrementa con la menor distancia obtenida.
E. Incrementamos cont.
F. Comprobar si se han analizado todos los puntos, y si no es así, volver al punto B
Realizar un pequeño programa de ejemplo que llame a la función
Programa 1C de microcontroladores. 2 puntos
El objetivo es crear una función que obtenga la trayectoria óptima para, partiendo desde el punto
inicial (0,0), pase por una serie de puntos de manera que la distancia total sea mínima. Para ello:
a) Crear una función llamada Distancia que calcule la distancia entre dos puntos como la mayor
de las distancias en x e y; esto es, si por ejemplo los puntos a considerar son (2,10) y (5,1), la
distancia será 9 (el mayor entre | 5 – 2 | y | 1 – 10 | ). Para ello, la función aceptará dos vectores
de enteros (de dimensión 2) llamados punto1 y punto2 y devolverá un entero con la distancia.
Cada vector tendrá en su elemento 0 el valor de la x, y en su elemento 1, el valor de la y. Puede
utilizarse la macro abs(a) que se encuentra en la librería math.h.
b) Programar una función llamada Trayectoria_Optima con los siguientes parámetros enteros:
o Entrada: Dimension N de la serie de puntos
o Entrada: Vector de N elementos vcoordx indicando la componente x de los lugares por
los que pasar. Suponemos que el primer elemento siempre será 0.
o Entrada: Vector de N elementos vcoordy indicando la componente y de los lugares por
los que pasar. Suponemos que el primer elemento siempre será 0.
o Salida: Distancia total recorrida dist_total.
La función realizará las siguientes tareas:
A. Partimos de un contador cont igual a 0. Apunta por tanto al punto (0,0). También se parte
de una variable dist_total igual a 0.
B. Obtener la distancia desde el punto con índice cont hasta cada uno de los restantes puntos
y deducir cuál es el punto a menor distancia. Supongamos que es el punto con índice q.
C. Intercambiar los contenidos de las posiciones q y (cont +1).
D. La variable dist_total se incrementa con la menor distancia obtenida.
E. Incrementamos cont.
F. Comprobar si se han analizado todos los puntos, y si no es así, volver al punto B
Realizar un pequeño programa de ejemplo que llame a la función
#include <reg51.h>
#include <math.h>
#define ConMatrices
int Distancia(int P1[], int P2[])
{
int resx, resy;
resx = abs(P1[0] - P2[0]);
resy = abs(P1[1] - P2[1]);
if (resx > resy)
return resx;
return resy;
}
#ifdef ConMatrices
int Trayectoria_Optima(int N, int serie[][2])
{
int dist_total = 0;
int menor_dist, ind_menor_distancia ;
int esta_dist;
int swap[2];
int cont, cont_r;
for (cont = 0; cont < N-1; cont ++)
{
menor_dist = Distancia(serie[cont], serie[cont+1]);
ind_menor_distancia = -1;
for (cont_r = cont + 2; cont_r < N; cont_r++)
{
esta_dist = Distancia(serie[cont], serie[cont_r]);
if (esta_dist < menor_dist)
{
menor_dist = esta_dist;
ind_menor_distancia = cont_r;
}
}
if (ind_menor_distancia != -1)
{
swap[0] = serie[ind_menor_distancia][0];
swap[1] = serie[ind_menor_distancia][1];
serie[ind_menor_distancia][0] = serie[cont+1][0];
serie[ind_menor_distancia][1] = serie[cont+1][1];
serie[cont+1][0] = swap[0]; serie[cont+1][1] = swap[1];
}
dist_total += menor_dist;
}
return dist_total;
}
void main(void)
{
int serieP[][2] = {{0,0}, {5,20}, {12,13}, {8,9}, {4,2}, {11,17}, {5,2},
{2,4}, {7,3}};
int dist;
dist = Trayectoria_Optima(9, serieP);
}
#else
int Trayectoria_Optima(int N, int seriex[], int seriey[])
{
int dist_total = 0;
int menor_dist, ind_menor_distancia ;
int esta_dist;
int swapx, swapy;
int P1[2], P2[2];
int cont, cont_r;
for (cont = 0; cont < N-1; cont ++)
{
P1[0] = seriex[cont]; P2[0] = seriex[cont+1];
P1[1] = seriey[cont]; P2[1] = seriey[cont+1];
menor_dist = Distancia(P1, P2);
ind_menor_distancia = -1;
for (cont_r = cont + 2; cont_r < N; cont_r++)
{
P2[0] = seriex[cont_r]; P2[1] = seriey[cont_r];
esta_dist = Distancia(P1, P2);
if (esta_dist < menor_dist)
{
menor_dist = esta_dist;
ind_menor_distancia = cont_r;
}
}
if (ind_menor_distancia != -1)
{
swapx = seriex[ind_menor_distancia];
swapy = seriey[ind_menor_distancia];
seriex[ind_menor_distancia] = seriex[cont+1];
seriey[ind_menor_distancia] = seriey[cont+1];
seriex[cont+1] = swapx;
seriey[cont+1] = swapy;
}
dist_total += menor_dist;
}
return dist_total;
}
void main(void)
{
int seriex[] = {0, 5, 12, 8, 4, 11, 5, 2, 7};
int seriey[] = {0, 20, 13, 9, 2, 17, 2, 4, 3};
int dist;
dist = Trayectoria_Optima(9, seriex, seriey);
}
#endif
Programa 2 de microcontroladores. PWM. 3 puntos
Realizar un programa que proporcione salidas PWM en NumCh canales (proporcionado mediante
define). La frecuencia de la señal PWM será de 250 Hz (este valor no es necesario) y el reloj es de
12 MHz. Existe un vector de caracteres, de ámbito global, llamado duty_cycles, de dimensión
NumCh, que recoge los ciclos de trabajo de cada uno de los canales. Los ciclos de trabajo son valores
entre 1 y 99, y están ordenados dentro del vector. Para simplificar, se supondrá que no existen dos
ciclos de trabajo iguales, y no se considerarán salidas continuas a 0 o a 1. Los canales se encuentran
todos en el puerto P1 y NumCh es menor o igual a 8.
a) Programar una función que desactive un determinado bit de un byte. Como parámetros de
entrada se pasará el carácter a modificar, y la posición del bit a desactivar. Devolverá el byte
modificado.
b) Programar la subrutina que cada 40 microsegundos realice la siguiente tarea:
1. En la primera entrada en la subrutina, un contador de ticks cticks y un contador de canales
cch, deben partir de 0.
2. Comparar el contador de ticks con el duty cycle del canal cch.
3. Si son iguales, desactivará el canal situado en la posición cch¸ e incrementará el valor del
contador cch. Si el contador ha llegado a NumCh, se reseteará dicho contador.
4. Incrementará el contador de ticks. Si el contador de ticks ha llegado a 100, se realizarán las
acciones indicadas en el paso 1, y se pondrán todos los pines del puerto P1 a 1.
c) Programar el resto del código. Tras las configuraciones necesarias, el programa principal
entrará en un bucle en el que cada 0.5 segundos (llamar al procedimiento existente void
delay(int ms)) conmute el led conectado a P2.2.
Se valorará no emplear variables globales salvo las estrictamente necesarias. No utilizar bucles
while o for fuera del bucle principal.
Responder a las siguientes preguntas:
- ¿Es necesario utilizar interrupciones externas? En caso de respuesta afirmativa, indicar cuál
o cuáles y la configuración más apropiada.
- ¿Es necesario utilizar temporizadores? En caso de respuesta afirmativa, indicar:
o El temporizador o temporizadores utilizados y la configuración más apropiada.
o ¿Es necesario asociar interrupciones a los temporizadores utilizados?
// PWM
#include <reg51.h>
#define NumCh 7
#define NumTicks 100
sbit led = P2^2;
sbit P1_1 = P1^1; // se definen para verlas en el analizador lógico
sbit P1_2 = P1^2;
bit led0, led1;
char duty_cycles[NumCh] = {3, 15, 47, 56, 66, 72, 88};
char desactiva(char byte, char posic)
{
char result;
result = byte &(~(1<<posic));
return result;
}
void tick40us(void) interrupt 1
{
static int cch =0;
static int cticks = 0;
if (cticks == duty_cycles[cch])
{
P1 = desactiva(P1, cch);
cch ++;
if (cch == NumCh)
cch = 0;
}
led0 = P1_1;
led1 = P1_2;
cticks++;
if (cticks < NumTicks)
return;
cticks = 0;
P1 = 0xFF;
cch = 0; // No hará falta
}
void delay(int ms)
{
int cms;
char cc;
for (cms = 0; cms < ms; cms ++)
for (cc = 0; cc < 10; cc++);
}
void main(void)
{
IE = 0x82;
TMOD = 0x02;
TH0 = TL0 = -40;
TR0 = 1;
while(1)
{
delay(500);
led = !led;
}
}
