TALLER DE MICROPROCESADORES II

Dispositivos simples

1- Manejo de Switches o Botones

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

configuracin bsica 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 seal 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 lgicos ms precisos.

Tambin podemos usar el siguiente circuito con una compuerta Smitt trigger.
Para la lectura de mltiples switches podemos usar un circuito similar al mostrado mas
abajo, mediante las seales de seleccin 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 Botn:

- Si queremos leer un solo botn 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 estn conectados con una lectura de 8 bits del valor del
puerto. Podemos leer con esta tcnica 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 estn definidos en la librera 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 funcin.
 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 operacin 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 parmetro a la funcion. El resultado es 1 si el switch esta en la posicin de
encendidoon, 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 botn 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 solucin por software de eliminacin de rebotes:

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

Estos tipos de conexin y lectura de switches y botones es aplicable a otros

dispositivos o seales 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 funcin 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 cmo 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 conexin y escritura de LEDs es aplicable a otros dispositivos o

seales que requieran ser incorporados a los proyectos con microcontroladores.
Ej.
Actuadores de todo tipo(relays, lamparas,BUZZER DC, ect. ) la mayora 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 informacin numrica. Existen dos tipos bsicos de 7 segmentos :
a).- nodo comn: Es aquel que tiene unido todos los nodos y cada segmento debe
activarse con
un cero.
b).- Ctodo comn: Es aquel que tiene unido todos los ctodos y cada segmento debe
activarse con un uno.

Tipos de visualizadores a 7 segmentos.

La ubicacin de los leds en un visualizador a 7 segmentos se muestra en la
figura c, donde cada led posee un identificador. Ntese como los nmeros 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 nmero de elementos separadamente controlados que pueden brindar
una representacin reconocible de todos los nmeros decimales. Se pueden obtener
tambin algunas letras y otros caracteres.

Conexin 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 conexin es
que permite la visualizacin 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 funcin de decodificacin BCD-7 segmentos puede implementarse por
software, el principio bsico radica en tomar un nmero (entre 0 y 9) y convertirlo, a
travs de una bsqueda en tabla, al cdigo en 7 segmentos equivalente.

Este mtodo facilita la representacin de nmeros cuando vienen acompaados

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

Lmparas atendidas con decodificador BCD - 7 segmentos.

En la siguiente figura se muestra la conexin de lmparas 7 segmentos a un puerto a
travs 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 comn 74LS47, en caso que
fuese ctodo comn se usara el 74LS48). Las resistencias de 150ohm limitan la
corriente a 20mA en cada led.

Atencin multiplexada a siete segmentos.

Una fuente de luz que parpadee a 20 mseg. (o menor ) no podra ser apreciado
por el ser humano, el cual ver esta luz esttica (siempre iluminada), este principio es
utilizado para el multiplexado de lmparas a 7 segmentos. En la figurase muestra una
conexin para la atencin a lmparas a travs de este mtodo.
La corriente promedio en cada led puede calcularse de la siguiente forma:
Iseg=N(Iprom) donde: Iseg= Corriente en el segmento.
N= Nmero de lmparas.
Ipro= Corriente promedio.
Debe considerarse que un led que admita una corriente mxima 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 comn de la lmpara, se debe controlar una corriente igual a
7(20mA)=140mA, capaz de encender los 7 segmentos del visualizador (correspondiente
al nmero 8).
Software para manejo de 7 segmentos
Mtodo de conexin directa
- Para manejar una conexin 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 creacin de la
tabla mostrada despus de la figura declarando un arreglo para los cdigos(nodo
comn) y otro arreglo de caracteres ascii que podran 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 librera string.h podemos buscar
cada carcter dentro del arreglo con la funcin strpos()que devuelve la posicin
del carcter buscado. Para ello debemos incluir la librera #include<string.h>
y cambiar el siguiente cdigo 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 seleccin debe ser dinamica, este metodo se explica mas
abajo.

Mtodo por decodificador BCD 7Segmentos

-Este mtodo 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 atencin 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 atencin 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
}