UNIVERSIDAD NACIONAL EXPERIMENTAL DEL TÁCHIRA
VICERRECTORADO ACADÉMICO
DECANATO DE DOCENCIA
DEPARTAMENTO DE INGENIERIA ELECTRÓNICA
UNIDAD 2
Técnicas de Enmascaramiento y
Multiplexación
Profesor:M. Sc. Ing. Rynaldo Salas Franco
Asignatura: Sistemas Digitales II
Contenido
Técnicas de enmascaramiento ............................................................................................ 3
Técnicas de multiplexación ................................................................................................ 5
Multiplexación y Tiempo ................................................................................................... 8
Problemas Propuestos ....................................................................................................... 11
ANEXO 1 ......................................................................................................................... 14
Técnicas de enmascaramiento
Recordemos que los bytes (8 bits) se dividen en dos nibles (4 bits): un nible más
significativo y otro nible menos significativo, como se observa en la figura 1.
Figura 1: Byte y Nibles
Para separar estos nibles, normalmente se recurre a utilizar técnicas de
enmascaramiento, que consiste en ocultar con una “mascara” el otro nible para quedarnos
solo con el nible de nuestro interés.
Enmascarar un byte es simplemente aplicarle una operación AND con una constante
a la que llamamos máscara. La máscara para ocultar el nible menos significativo es
11110000b, mientras que para ocultar el nible mas significativo se utiliza 00001111b.
Cuando se utiliza la máscara 00001111b., se obtiene un número de 4 bits, que es el
nible menos significativo.
Cuando se emplea la máscara 11110000b, se obtiene un número de 8 bits con todos
sus bits menos significativos en bajo, si quisiéramos obtener un número de 4 bits sería
necesario rotar 4 veces a la derecha los bits del número resultante.
Para ilustrar este procedimiento, supongamos que debemos capturar el número de 4
bits que se coloca en DSW1 y mostrarlo en el display de 7 segmentos que se muestra en la
figura 2.
Figura 2: Ejemplo de Enmascaramiento ([Link])
Como se observa en la figura 2, DSW1 está conectado al microcontrolador, a través,
de las líneas RB7, RB6, RB5 y RB4, es decir, la entrada de datos ocurre, a través, del
Puerto_B. Debemos entonces leer el estado de dicho puerto y separar los datos de 4 bits. La
función que permite leer dicho puerto es input_B(). Para separar los dos datos debemos
recurrir a enmascarar la lectura. El enmascaramiento consiste en ocultar los bits que no nos
interesan mediante una operación “and” con un número constante de 8 bits. En el caso de
DSW1, esté numero constante será 11110000b de manera que se ocultan los bits 3 al 0 y
capturamos los 4 bits mas significativos: input_B()&0b11110000, pero además de
enmascarar, se hace necesario rotar los bits, cuatro veces hacia la derecha, es decir,
(input_A()&0b00111000)>>4. Considerando que la función que permite escribir un valor
en un puerto es output_X(valor); podemos decir que para pasar el nible al puerto D se
usa output_D(nible). Entonces podemos definir la función leer_y_mostrar():
void leer_y_mostrar()
{ int nible;
nible=(input_B()&0b11110000)>>4; //lee nible mas significativo
output_D(nible); //visualiza en el diplay el dato
return;
}
Técnicas de multiplexación
Para explicar esta técnica, estudiaremos la matriz de LEDs. Normalmente estos
periféricos requieren de una circuitería como la que se muestra en la figura 3.
Figura 3: Matriz de LEDs ([Link])
Para borrar la matriz de puntos (mantener todos sus leds apagados), es necesario,
enviar ceros por los puertos D y B. Podemos entonces contar con una función borrar():
void borrar() // Función para apagar la matriz
{
output_B(0); // Coloca 0 en el Puerto B (RB0 a RB7)
output_D(0); // Coloca 0 en el Puerto D (RD0 a RD7)
Return;
}
Para mostrar un carácter en la matriz de puntos, debemos considerar cuales leds se
activarán y cuales permanecerán apagados, para ello podemos recurrir a realizar un “mapa”
de la forma que tendrá cada carácter. En la figura 13, puede observarse que las filas de la
matriz están conectados al puerto D y las columnas al puerto E, a través, de una circuitería
que permite deducir que, para encender un led de dicha matriz, es necesario colocar la fila y
la columna correspondiente en alto. Pero debido a la complejidad que pueden tener los
caracteres, es necesario hacer un barrido en las columnas que consiste en rotar un bit alto
secuencialmente en intervalos de tiempo muy pequeños, mientras se colocan en las filas los
bits correspondientes a la forma que tendrá el carácter. Esto puede lograrse mediante la
función siguiente:
void mostrar()
{ for(i=0; i<9; i++) //Para i=0 hasta 9:
{
borrar(); //apagar todos los leds
output_B(columnas[i]); //envía a PORTB el dato columna i
output_D(filas[i]); //envía a PORTD el dato fila i
delay_ms(2); //retardo de 2 ms
};
return;
}
Surge la necesidad de crear un par de arreglos globales de 8 datos cada uno, con el
fin de almacenar en ellos las filas y las columnas:
int columnas[8]= {1,2,4,8,16,32,64,128};
int filas[8];
Para el arreglo filas, consideremos que vamos a mostrar en la matriz el número de
tres bits que se selecciona en DSW2, que tendrán valores desde 0H hasta 7H, con lo cual se
construye una función que permite llenar las “filas” según el dato que se emplee como
argumento. Para lograr esto, se hicieron los mapas de bits que se muestran en el Anexo 1, en
el que se incluye dicha función, cuyo prototipo es el siguiente:
void tabla (int n); // retorna el mapa de bits para visualizar n
La función que permite leer y mostrar DSW2 se estructura de la siguiente forma:
void leer_y_mostrar_DSW2()
{
dato=input_A()&0b00000111; //captura dato desde DSW2
tabla(dato);//obtiene mapa de bits de dato
mostrar(); //visualiza en la matriz a dato
return;
}
Finalmente se puede codificar la función principal de la siguiente forma:
void main()
{
setup_adc_ports(NO_ANALOGS);//todos los puertos digitales
while(1)
{
borrar(); //apaga todos los leds
leer_y_mostrar_DSW2();
} // Este lazo se repite continuamente
}
Multiplexación y Tiempo
Supongamos que se requiere diseñar una máquina de estados como la que se muestra
en la figura 4, con la matriz de puntos y el microcontrolador PIC18F4550 interconectados
como en la figura 3.
Figura 4: Máquina de estados
Considerando las funciones mostrar(), borrar() y tabla(n), que se
aplicaron en la sección anterior, podemos vernos tentados a escribir una función main() como
la siguiente:
void main()
{
setup_adc_ports(NO_ANALOGS);//todos los puertos digitales
borrar(); //apaga todos los leds
while(1)
{
tabla(0);
mostrar(); //muestra el número 0 en la matriz
delay_ms(1000); // espera 1000 ms = 1s
tabla(1);
mostrar(); //muestra el número 1 en la matriz
delay_ms(1000); //espera 1s
} // Este lazo se repite continuamente
}
Esta función main() aparenta tener una lógica acertada, sin embargo, si la simulamos
notaremos que la matriz en vez de permanecer mostrando cada número por 1 segundo, los
muestra en un parpadeo (E3muxT.c)
¿A que se debe este parpadeo? A que cada fila de la matriz se enciende por solo
2_ms y el número completo se visualiza por 16 ms, que es el tiempo de ejecución de la
función mostrar(); recuerde que con dicha función la matriz no se mantiene fija, es un
engaño que le hacemos a nuestra vista y el retardo de 1 segundo “delay_ms(1000)” lo
que hace es permitir que nuestra vista detecte la intermitencia no deseada de los LEDs y por
eso no se aprecian fijos los números en la matriz por un segundo.
¿Cómo lo solucionamos? Considerando que si el barrido completo de cada número
demora 16 ms, debemos repetir dicho barrido 62 o 63 veces:
62 × 16𝑚𝑠 = 992 𝑚𝑠 = 0.99 𝑠
63 × 16𝑚𝑠 = 1008 𝑚𝑠 = 1.01 𝑠
Para lograr los intervalos de tiempo indicados en la maquina de estado, debemos
escribir una función mostrar_por_1segundo(), que lo que hace es repetir 62 veces a
la función mostrar():
void mostrar_por_1segundo()
{
for (j=0; j<63 ;j++)
{
mostrar(); //repite mostrar 62 veces
};
return;
}
Y luego reescribimos la función main():
void main()
{ setup_adc_ports(NO_ANALOGS);//todos los puertos digitales
borrar(); //apaga todos los leds
while(1)
{ tabla(0);
mostrar_por_1segundo();
tabla(1);
mostrar_por_1segundo();
} // Este lazo se repite continuamente
}
Modifique el programa E3muxT.c según la explicación previa y simúlelo.
Problemas Propuestos
1. Se dispone de un pulsador, una matriz de puntos y dos encapsulados de 3 interruptores
cada uno (DSW1 y DSW2), interconectados como se muestra en la figura 5. Se desea
realizar la suma de los números de 3 bits establecidos por el estado de los interruptores
de DSW1 y DSW2. Cada vez que se presione el pulsador, se ejecutará una tarea según se
muestra en la tabla 1. Esta secuencia debe repetirse indefinidamente, es decir, al presionar
por sexta vez el pulsador, se comportará como si nunca lo hubieran presionado.
Figura 5: Problema Propuesto 1 ([Link])
Tabla 1: Secuencia de actividades para el problema propuesto n° 1.
Número de veces que
Actividades que realizará el microcontrolador
se presiona el pulsador
0 La matriz permanecerá apagada.
Almacenará el número de 3 bits de DSW2.
1 Mostrará en la matriz de puntos: dicho número en formato
hexadecimal.
2 Mostrará en la matriz de puntos: el signo “+”.
Almacenará el número de 3 bits de DSW1.
3 Mostrará en la matriz de puntos: dicho número en formato
hexadecimal.
4 Mostrará en la matriz de puntos: el signo “=”.
Realizará la suma de los números de 3 bits almacenados
5 Mostrará el resultado de dicha suma (hexadecimal) en la
matriz de puntos.
2. Con el mismo circuito mostrado en la figura 5 escriba un programa que permita mostrar
en la matriz los números colocados en DSW1 y DSW2 por intervalos de 2 segundos,
como se muestra en la máquina de estados de la figura 6.
Figura 6: Máquina de estados del problema 2
3. Se tienen dos displays conectados a un PIC18f4550 como se muestra en la figura 7.
Escribir un programa que permita realizar un conteo entre dos números de 8 bits (mínimo
00H y máximo FFH) El valor inicial se introduce al microcontrolador mediante 8
interruptores conectados al puerto B. El valor final se introduce mediante 8 interruptores
conectados al puerto D. El valor inicial y final indicarán, dependiendo de su comparación,
si el conteo es ascendente o descendente. El intervalo de tiempo entre números
consecutivos es de 500 ms.
Figura 7: Problema Propuesto 3
ANEXO 1
Mapas y función empleados para llenar el arreglo filas con el fin de visualizar caracteres en
la matriz de leds.
Forma del carácter Mapa de bits Función
void tabla(int n)
{switch(n)
{
case 0: filas[0]= 0b00000000;
00000000
filas[1]= 0b00111100;
00111100
filas[2]= 0b01100110;
01100110
filas[3]= 0b01101110;
01101110
filas[4]= 0b01110110;
01110110
filas[5]= 0b01100110;
01100110
filas[6]= 0b00111100;
00111100
filas[7]= 0b00000000;
00000000
break;
case 1: filas[0]= 0b00000000;
00000000
filas[1]= 0b00001000;
00001000
filas[2]= 0b00011000;
00011000
filas[3]= 0b00111000;
00111000
filas[4]= 0b00011000;
00011000
filas[5]= 0b00011000;
00011000
filas[6]= 0b00111100;
00111100
filas[7]= 0b00000000;
00000000
break;
case 2: filas[0]= 0b00000000;
00000000
filas[1]= 0b00111100;
00111100
filas[2]= 0b01100110;
01100110
filas[3]= 0b00001100;
00001100
filas[4]= 0b00011000;
00011000
filas[5]= 0b00110000;
00110000
filas[6]= 0b01111110;
01111110
filas[7]= 0b00000000;
00000000
break;
case 3: filas[0]= 0b00000000;
00000000
filas[1]= 0b00111100;
00111100
filas[2]= 0b01100110;
01100110
filas[3]= 0b00001100;
00001100
filas[4]= 0b00000110;
00000110
filas[5]= 0b01000110;
01000110
filas[6]= 0b00111100;
00111100
filas[7]= 0b00000000;
00000000
break;
00000000 case 4: filas[0]= 0b00000000;
00100000 filas[1]= 0b00100000;
01101100 filas[2]= 0b01101100;
01101100 filas[3]= 0b01101100;
filas[4]= 0b01111110;
01111110
filas[5]= 0b00001100;
00001100
filas[6]= 0b00001100;
00001100
filas[7]= 0b00000000;
00000000 break;
Forma del carácter Mapa de bits Función (Continuación)
case 5: filas[0]= 0b00000000;
00000000
filas[1]= 0b01111110;
01111110
filas[2]= 0b01100000;
01100000
filas[3]= 0b01111100;
01111100
filas[4]= 0b00000110;
00000110
filas[5]= 0b01100110;
01100110
filas[6]= 0b00111100;
00111100
filas[7]= 0b00000000;
00000000
break;
case 6: filas[0]= 0b00000000;
00000000
filas[1]= 0b00111100;
00111100
filas[2]= 0b01100110;
01100110
filas[3]= 0b01100000;
01100000
filas[4]= 0b01111100;
01111100
filas[5]= 0b01100110;
01100110
filas[6]= 0b00111100;
00111100
filas[7]= 0b00000000;
00000000
break;
case 7: filas[0]= 0b00000000;
00000000
filas[1]= 0b01111110;
01111110
filas[2]= 0b00000110;
00000110
filas[3]= 0b00001100;
00001100
filas[4]= 0b00011000;
00011000
filas[5]= 0b00011000;
00011000
filas[6]= 0b00011000;
00011000
filas[7]= 0b00000000;
00000000
break;
00000000 case 8: filas[0]= 0b00000000;
00111100 filas[1]= 0b00111100;
01100110 filas[2]= 0b01100110;
00111100 filas[3]= 0b00111100;
01100110 filas[4]= 0b01100110;
01100110 filas[5]= 0b01100110;
00111100 filas[6]= 0b00111100;
00000000 filas[7]= 0b00000000;
break;
case 9: filas[0]= 0b00000000;
00000000
filas[1]= 0b00111100;
00111100
filas[2]= 0b01100110;
01100110
filas[3]= 0b00111110;
00111110
filas[4]= 0b00000110;
00000110
filas[5]= 0b01100110;
01100110
filas[6]= 0b00111100;
00111100
filas[7]= 0b00000000;
00000000
break;
}
return;
}
