TALLER DE MICROPROCESADORES II

Dispositivos simples

1- Manejo de Switches o Botones

Estos son dispositivos de entrada usados como sensores de contacto. La

configuración básica del circuito es mostrada en la figura.

La figura muestra como un switch es alambrado a un puerto de entrada. Cuando el

switch esta abierto,(como muestra el diagrama), la entrada esta puesta a 5 volt por la
resistencia de pull-up. Cuando el switch esta cerrado, la entrada esta puesta a tierra,
generando una señal de cero volt.

Sin embargo este tipo de circuito produce muchos rebotes en o distorsiones del nivel de
voltaje, que para lecturas de valores digitales no son deseadas. Los siguientes circuitos
pueden ayudar a reducir los rebotes y con ellos se obtienen valores lógicos más precisos.

También podemos usar el siguiente circuito con una compuerta Smitt trigger.
Para la lectura de múltiples switches podemos usar un circuito similar al mostrado mas
abajo, mediante las señales de selección se toma el valor de uno y solo un switch el cual
se coloca en el pin de salida(output).

En software existen muchas formas de leer el valor de un Switch o Botón:

- Si queremos leer un solo botón podemos leer el valor del pin donde esta
conectado directamente pues el micro permite lectura bit a bit de los pines
del puerto. Como hago esto? Ej.
1- Declare el nombre del Switch y el pin en donde esta conectado.
sbit switch_1 = P1^0; // Asigna el nombre switch_1 al pin 0 del puerto 1
2- Para poder usar switch_1 como entrada se coloca la siguiente
sentencia en las inicializaciones de hardware en main() o en
cualquier funcion que lo requiera.
Switch_1=1; //inicializacion del pin 0 puerto 1 como entrada.
3- Ahora ya podemos leer el valor del switch con cualquier
sentencia valida en c51. Ejemplos while(switch_1); if(switch_1==0);

- Si queremos leer un grupo de botones podemos leer el valor del puerto

completo donde están conectados con una lectura de 8 bits del valor del
puerto. Podemos leer con esta técnica cuantos botones queramos de un
grupo de 8.Como hago esto? Ej.
1- Si vamos a leer 8 switches. Se lee el valor del puerto por su
nombre(P0,P1,P2,P3) ya que están definidos en la librería reg51.h o con
el nombre con que lo hayamos definido Ej.(#define switches_8 P1) .
var1=P1; //Lee los switches de P1 y asigna el valor a la variable var1
var1=switches_8 ;//Igual que la anterior
funcion1(switches_8);// Se puede pasar como argumento a una función.
 2- Si vamos leer uno o mas switches leemos el puerto completo y
enmascaramos los pines que corresponden a los switches que
queremos leer realizando una operación AND del puerto con el
valor en uno del switch correspondiente. Ej. 4 switches desde el
pin 0 hasta el pin 1 en el puerto 1.
P1 = 0x0F; //Inicializar el nible bajo como entrada
if (var1== (P1 & 0x01) accion1();//Lee primer switch
if (var1== (P1 & 0x02) accion2();//Lee segundo switch
if (var1== (P1 & 0x04) accion3();//Lee tercer switch
if (var1== (P1 & 0x08) accion4();//Lee cuarto switch

En cuanto a funciones, algunos ejemplos prototipos en c51 para el manejo de

switches o botones son:
int dip_switch(int sw) que podria retornar indicarnos si un switch esta
activado(encendido) o no, el valor del DIP switch sw que queremos leer en el circuito se
pasa como parámetro a la funcion. El resultado es 1 si el switch esta en la posición de
encendido”on”, y 0 si no.
int dip switches() que retorna el valor de los DIP switches como un numero
binario de cuatro bit.
int choose_button() que retorna el valor del botón con etiqueta Choose: 1 si esta
presionado y 0 si esta libre.
Ejemplo:
/* espera hasta que el boton choose en este caso “left” sea presionado */
while (!left_button()) {}

Como reducir los rebotes mediante software

Este ejemplo brinda una solución por software de eliminación de rebotes:

/* espera hasta que el botón sea presionado; entonces espera hasta que el botón sea
liberado */
while (!escape_button()) {}
while (escape_button()) {}

Estos tipos de conexión y lectura de switches y botones es aplicable a otros

dispositivos o señales que requieran ser incorporados a los proyectos con
microcontroladores. Ej.
Censores de todo tipo de magnitud(fin de carrera, temperatura on-off,
proximidad, infrarrojos, de luz, ect. ) Investigue como se hace esto para su futuro
proyecto.
2- Manejo de LEDs y/o cualquier otro dispositivo de salida activo con 1 o 0.
- Si queremos encender o apagar un LED, podemos escribir el valor 1 o 0
respectivamente en el pin donde esta conectado, pues el micro permite
escritura bit a bit de los pines del puerto. Como hago esto? Ej.
1- Declare el nombre del pin en donde esta conectado el dispositivo o
LED.
sbit solenoide = P1^0; // Asigna el nombre solenoide al pin 0 del puerto 1
sbit LED4 = P1^7; // Asigna el nombre LED4 al pin 7 del puerto 1

2- Para poder usar LED4 o solenoide como salida

se coloca la siguiente sentencia en las 330R

inicializaciones de hardware en main() o en

cualquier función que lo requiera. Enciende con un 0 en el pin
solenoide = 0; //inicializacion del pin 0 puerto 1 como salida. DIODE-LED
BUFFER
LED4 = 0; //inicializacion del pin 7 puerto 1 como salida.
3 2
Px.x

3- Ahora ya podemos escribir un valor al 4050

dispositivo con cualquier sentencia valida en

c51. Ejemplos
330R
solenoide = 0; //coloca un 0 en el pin 0 puerto 1. BUFFER
solenoide = 1; //coloca un 1 en el pin 0 puerto 1. Px.x
3 2

Para un LED la activacion dependera de cómo esta 4050

conectado, observe la figura de al lado. El LED de la figura
superior se activara o desactivara con las siguientes sentencias: Enciende con un 1 en el pin
DIODE-LED
LED4 = 0; // enciende el LED.
LED4 = 1; // apaga el LED.
El LED de la figura inferior se activara o desactivara
con las siguientes sentencias:
LED4 = 1; // enciende el LED.
LED4 = 0; // apaga el LED.

Otras sentencias que pueden leer y modificar el estado de estas salidas son:

LED4 = ~LED4; // complementa el valor del pin, por tanto si esta encendido se apaga
LED4 = LED4 & 1; // lo mismo que la anterior pero con logica AND
LED4 = LED4 | 1; // setea a uno el valor del pin o sea enciende el LED de forma obligada
LED4 = LED4 & 0; // pone a cero el valor del pin o sea apaga el LED de forma obligada

Este tipo de conexión y escritura de LEDs es aplicable a otros dispositivos o

señales que requieran ser incorporados a los proyectos con microcontroladores.
Ej.
Actuadores de todo tipo(relays, lamparas,BUZZER DC, ect. ) la mayoría de
dispositivos de salida necesitan de un buffer o driver de corriente para el
correcto funcionamiento debido a la demanda de corriente que exigen.
Investigue como poner a funcionar estos dispositivos para su futuro proyecto.
 Manejo de 7 segmentos.
Los visualizadores a 7 segmentos son dispositivos que permiten lograr el control
de la información numérica. Existen dos tipos básicos de 7 segmentos :
a).- Ánodo común: Es aquel que tiene unido todos los ánodos y cada segmento debe
activarse con
un cero.
b).- Cátodo común: Es aquel que tiene unido todos los cátodos y cada segmento debe
activarse con un uno.

Tipos de visualizadores a 7 segmentos.

La ubicación de los leds en un visualizador a 7 segmentos se muestra en la
figura c, donde cada led posee un identificador. Nótese como los números se forman de
acuerdo a los leds que se iluminen (por ejemplo, para visualizar un tres deben activarse
los segmentos a,b,g,c y d).
Los visualizadores a 7 segmentos son ampliamente utilizados debido a que
tienen el menor número de elementos separadamente controlados que pueden brindar
una representación reconocible de todos los números decimales. Se pueden obtener
también algunas letras y otros caracteres.

Conexión directa de visualizadores a puertos buffer.

En la siguiente figura se muestra como conectar de manera directa
visualizadores 7 segmentos a puertos buffers, la ventaja de este tipo de conexión es
que permite la visualización de caracteres especiales.
U1
19 39
XTAL1 P0.0/AD0
38
P0.1/AD1
37
P0.2/AD2
18 36
XTAL2 P0.3/AD3
35
P0.4/AD4
34
P0.5/AD5
33
P0.6/AD6
9 32
R1R2R3R4
R5 R8
RST P0.7/AD7
130R
130R
130R
130R
130R

U1 21
P2.0/A8
19
XT AL1 P0.0/AD0
39
22
P0.1/AD1
38 Q1 P2.1/A9
37 2N3906 23
18
XT AL2
P0.2/AD2
P0.3/AD3
36 P2.2/A10
35 29 24
P0.4/AD4
P0.5/AD5
34 PSEN P2.3/A11
33 30 25
9
P0.6/AD6
32 ALE P2.4/A12
RST P0.7/AD7
Q2
31 26
21
EA P2.5/A13
P2.0/A8 2N3906 27
P2.1/A9
22
1k P2.6/A14
P2.2/A10
23 28
29
PSEN P2.3/A11
24 P2.7/A15
30
ALE P2.4/A12
25 Q3
31 26 2N3906
EA P2.5/A13
27 1 10
P2.6/A14
28 P1.0 P3.0/RXD
P2.7/A15
Q4 2 11
1 10 P1.1 P3.1/T XD
P1.0 P3.0/RXD 2N3906
3 12
2
P1.1 P3.1/T XD
11
1k P1.2 P3.2/INT0
3
P1.2 P3.2/INT0
12
4 13
4
P1.3 P3.3/INT1
13 Q5 P1.3 P3.3/INT1
5
P1.4 P3.4/T0
14 2N3906 5 14
6
P1.5 P3.5/T1
15 P1.4 P3.4/T0
7
P1.6 P3.6/WR
16 6 15
8
P1.7 P3.7/RD
17 Q6 P1.5 P3.5/T1
7 16
80C51
2N3906
P1.6 P3.6/WR
8 17
P1.7 P3.7/RD
Q7
2N3906 80C31

Q8
2N3906
 La función de decodificación BCD-7 segmentos puede implementarse por
software, el principio básico radica en tomar un número (entre 0 y 9) y convertirlo, a
través de una búsqueda en tabla, al código en 7 segmentos equivalente.

Este método facilita la representación de números cuando vienen acompañados

de caracteres especiales, cuando los visualizadores se conectan de forma directa.

Lámparas atendidas con decodificador BCD - 7 segmentos.

En la siguiente figura se muestra la conexión de lámparas 7 segmentos a un puerto a
través de decodificadores BCD-7segmentos.

1k R1R2R3R4R5
130R
130R
130R
130R
130R

U2
7 13
A QA
1 12
B QB
2 11
C QC
6 10
D QD
U1 4
BI/RBO QE
9
19 39 5 15
XT AL1 P0.0/AD0 RBI QF
38 3 14
P0.1/AD1 LT QG
37
18
P0.2/AD2
36 7447
U3:A
XT AL2 P0.3/AD3
35 3 2
P0.4/AD4
34
P0.5/AD5 U3:B
33
P0.6/AD6 4050
9 32 5 4
RST P0.7/AD7
U3:C
21
P2.0/A8 4050
22 7 6
P2.1/A9
23
P2.2/A10 U3:D
29 24
PSEN P2.3/A11 4050
30 25 9 10
ALE P2.4/A12
31 26
EA P2.5/A13
27
P2.6/A14 4050
28
P2.7/A15

1 10
P1.0 P3.0/RXD
2 11 1k
P1.1 P3.1/T XD
3 12
P1.2 P3.2/INT0
4 13
P1.3 P3.3/INT1
5 14
P1.4 P3.4/T0
6 15
P1.5 P3.5/T1
7 16
P1.6 P3.6/WR
8 17
P1.7 P3.7/RD

80C51
En el ejemplo anterior se utiliza decodificador para ánodo común 74LS47, en caso que
fuese cátodo común se usaría el 74LS48). Las resistencias de 150ohm limitan la
corriente a 20mA en cada led.

Atención multiplexada a siete segmentos.

Una fuente de luz que parpadee a 20 mseg. (o menor ) no podría ser apreciado
por el ser humano, el cual verá esta luz estática (siempre iluminada), este principio es
utilizado para el multiplexado de lámparas a 7 segmentos. En la figurase muestra una
conexión para la atención a lámparas a través de este método.
La corriente promedio en cada led puede calcularse de la siguiente forma:
Iseg=N(Iprom) donde: Iseg= Corriente en el segmento.
N= Número de lámparas.
Ipro= Corriente promedio.
Debe considerarse que un led que admita una corriente máxima de 50mA (en un
arreglo de 8 visualizadores) tendrá una corriente promedio de 50mA/8=6.25mA. Lo
anterior significa que el visualizador tendrá mucho menos brillo que aquellos en que
circula 20mA. Por otra parte, un led que esté polarizado con una corriente constante
tendrá menos brillo que un led polarizado (en un sistema multiplexado) con el mismo
valor de corriente promedio. Por ejemplo son necesarios 8 o 9mA de corriente constante
para obtener el mismo brillo que produce una corriente promedio de 6.25mA. Con
respecto al terminal común de la lámpara, se debe controlar una corriente igual a
7(20mA)=140mA, capaz de encender los 7 segmentos del visualizador (correspondiente
al número 8).
Software para manejo de 7 segmentos
Método de conexión directa
- Para manejar una conexión como la mostrada anteriormente y que contiene un
solo un display de 7segmentos conectado directamente al puerto uno del
microcontrolador el paso mas importante que debemos dar es la creación de la
tabla mostrada después de la figura declarando un arreglo para los códigos(ánodo
común) y otro arreglo de caracteres ascii que podrían estar en memoria externa
de datos o en la de codigo. Ej.
unsigned char code tabla_code_7segm[32]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,
0x78,0x80,0x18,0x08,0x46,0x06,0x0E,0x09,
0x79,0x61,0x47,0x40,0x0C,0x41,0x11,0x03,
0x27,0x21,0x0B,0x2B,0x23,0x2F,0x63,
0x3F,0x2C};
unsigned char code tabla_ascii[32] ="0123456789ACEFHJLOPUYbcdhnofu-?";

El siguiente programa muestra cada uno de los caracteres en el display 7segm

/*segm7.c*/
#include<reg51.h>
void main(void)
{ //declaracion de las tablas de codigo y ascii en memoria de codigo
unsigned char code tabla_code_7segm[32]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,
0x78,0x80,0x18,0x08,0x46,0x06,0x0E,0x09,
0x79,0x61,0x47,0x40,0x0C,0x41,0x11,0x03,
0x27,0x21,0x0B,0x2B,0x23,0x2F,0x63,
0x3F,0x2C};
unsigned char tabla_ascii[32]="0123456789ACEFHJLOPUYbcdhnofu-?";
unsigned char var1;
unsigned int i;
while(1){
for(var1=0;var1<32;var1++)
{
P1= tabla_code_7segm[var1]; //Escritura del valor en el puerto
for(i=0;i<65000;i++); // delay para visualizar a tiempo el ascii
}
}
Si creamos otro programa y hacemos uso de la librería string.h podemos buscar
cada carácter dentro del arreglo con la función strpos()que devuelve la posición
del carácter buscado. Para ello debemos incluir la librería #include<string.h>
y cambiar el siguiente código en el bucle infinito.
while(1){
for(var1=0;var1<32;var1++){
i=strpos(tabla_ascii,'J');
P1= tabla_code_7segm[i];
}
}
Para utilizar mas displays como lo muestra la figura de 8 displays usamos los
mismos programas anteriores cambiando el puerto 1 (P1) por el puerto 0 (P0) y
el puerto dos para seleccionar cada display. Para mostrar los diferentes valores
en cada display la selección debe ser dinamica, este metodo se explica mas
abajo.

Método por decodificador BCD – 7Segmentos

-Este método usa cuatro bits para representar un U13 Catodo comun
numero del 0 al 15 en hexadecimal(del 0 al 9 y P10
7
A QA
13

de A a F ) en el display por lo que solamente P11

P12
1
2
B
C
QB
QC
12
11
tenemos que escribir en el decodificador el valor P13
6
4
D QD
10
9
BI/RBO QE
que queremos visualizar en el display. Ej. 5
RBI QF
15
3 14
Si tenemos un display conectado al nible LT QG
330R
bajo del puerto 1 escribimos los valores usando 74LS48

la siguiente sentencia para 3 P1=0x03; para 10

P1=0x0A; para 13 P1=0x0D;

Metodo de atención multiplexada

Si tenemos 4 displays conectados al puerto 0 como en una de las figuras
anteriores podemos manejarlo seleccionando cada display con el nible alto del mismo
puerto. Ej.
La siguiente programa contiene una funcion que recibe un numero entero desde 0000
hasta 9999 y lo muestra en los displays. La funcion devuelve un cero si no esta en el
rango y diferente de cero si esta en el rango.

//Manejo de displays con atención multiplexada

#include<reg51.h>
//Declaracion de la funcion prototipo
int disp_num(int num);
//Declaracion de pines para seleccionar cada display
sbit disp1=P0^4;
sbit disp2=P0^5;
sbit disp3=P0^6;
sbit disp4=P0^7;
//Programa principal
void main()
{
unsigned int xnum,i,j;
P0=0x00; //Inicializaciom del puerto como salida y los displays apagado
while(1){
for(i=0;i<5000;i++)
{
xnum=i;
for(j=0;j<1000;j++)disp_num(xnum); // Uso de la funcion de display
}
}
}
//Funcion display que recibe un numero entero y despliega en cuatro 7segmentos
int disp_num(int num)
{ unsigned int unidad,decena,centena,mil;// Variables para valor de cada display
if((num > 0000 )&& (num < 9999))
{
unidad=num%10;
num=num/10;
P0=unidad & 0x0F;
disp1=1; //Enciende el display 1
decena=num%10;
num=num/10;
P0=decena & 0x0F;
disp2=1; //Enciende el display 2
centena=num%10;
P0=centena & 0x0F;
disp3=1; //Enciende el display 3
mil=num/10;
P0=mil & 0x0F;
disp4=1; //Enciende el display 4
return 0x01; //Retorna un valor indicando numero en rango
}
else
return 0; //Retorna indicando numero fuera de rango
}