Ard-1 E06 ControlDeVisualizadoresDe7Segmentos v3.0

ARQUITECTURA DE COMPUTADORAS
Prácticas de Laboratorio
Experiencia Nº 06
6 CONTROL DE VISUALIZADORES DE 7
SEGMENTOS
FIGURA 6-1: Arduino MEGA 2560, Display de 7 segmentos y LCD.
6.1 OBJETIVOS
• Conocer las características y el funcionamiento del visualizador de 7 segmentos (o Display).
• Conocer los tipos de display; ánodo común y cátodo común.
• Visualización de números en el visualizador de 7 segmentos.
• Diseñar y montar en un protoboard un circuito para controlar 4 displays y visualizar mensajes.
6.2 LISTA DE HERRAMIENTAS Y MATERIALES
Herramientas y Materiales para el desarrollo de la experiencia
Herramientas Descripción
(1) Multímetro FLUKE 28 II
(1) Arduino Mega 2560
(2) Protoboard
76Experiencia Nº 06
Materiales Descripción
Cables con terminales Macho – Macho en sus extremos (Jumpers)
(2) Resistencia de 10 KΩ.

(8) Resistencia de 1 KΩ.
(8) Resistencia de 150 Ω (si el Display es de iluminación ROJO) o,
(8) Resistencia de 100 Ω (si el Display es de iluminación VERDE o AZUL).
(4) Display de 7 segmentos CÁTODO COMÚN.
(4) Transistor NPN 2N3904.
(2) Pulsador normalmente abierto.
TABLA 6-1: Lista de Herramientas y Materiales.
6.3 EL VISUALIZADOR DE 7 SEGMENTOS

El visualizador de siete segmentos (llamado también display) es una forma de representar números
en equipos electrónicos. Está compuesto de siete segmentos que se pueden encender o apagar
individualmente. Cada segmento tiene la forma de una pequeña línea.
Aunque externamente su forma difiere considerablemente de un LED típico, internamente están
constituidos por una serie de LEDs con determinadas conexiones internas, estratégicamente ubicados de tal
forma que se puede formar números del 0 al 9.
f b
e c
d P. d.
(a) Display de 7 segmentos. (b) Distribución de los segmentos.
FIGURA 6-2: Visualizador luminoso de 7 segmentos.

Control de visualizadores de 7 segmentos77
A cada uno de los segmentos que forman el display se les etiqueta como a, b, c, d, e, f y g y están
ensamblados de forma que se permita activar cada segmento por separado consiguiendo formar cualquier
dígito numérico. En la mayoría de los display aparece un octavo segmento denominado P.d. (punto
decimal).
Ánodo
Común
D1
a
D1
D2 a
b
D2
D3 b
c
D3
D4 c
d
D4
D5 d
e
D5
D6 e
f
D6
D7 f
g
D7
D8 g
Pd
D8
Pd
Cátodo
Común
a) Arreglo de 8 LEDs en Cátodo Común. b) Arreglo de 8 LEDs en Ánodo Común.
FIGURA 6-3: Diferencia entre cátodo común y ánodo común.
El display de siete segmentos tiene un encapsulado tipo DIP y cuenta con diez pines, repartidos en
grupos de cinco. Además, independientemente del tipo de display, cada entrada o segmento del display
deberá ser alimentada por intermedio de una resistencia, para limitar el paso de la corriente por cada uno de
los LEDs del display, y de esa manera no correr el riesgo de quemarlos.
Existen dos tipos de display:
• Ánodo común.
• Cátodo común.
6.3.1 Ánodo Común

En los de tipo de ánodo común, todos los ánodos de los LEDs o segmentos están unidos
internamente a un pin común que debe ser conectada a voltaje positivo (+5V). El encendido de cada
segmento individual se realiza aplicando 0 voltios (GND) por el pin correspondiente a través de una
resistencia que límite el paso de la corriente.
Ánodo
Común
g f a b
+5V
10 9 8 7 6
150 
a
3/8
150 
b
7
150 
6
c
4
150 
2
d
1
150 
9
e
10
150 
5
f
150  Display de
g Ánodo Común
1 2 3 4 5 150  (ROJO)
e d c Pto. Pd
Ánodo
Común
FIGURA 6-4: Diagrama de pines y conexionado del Display de 7 segmentos de ánodo común
6.3.2 Cátodo Común

En los de tipo de cátodo común, todos los cátodos de los LEDs o segmentos están unidos
internamente a un pin común que debe ser conectada a 0 voltios (GND). El encendido de cada segmento
individual se realiza aplicando voltaje positivo (+5V) por el pin correspondiente a través de una resistencia
que límite el paso de la corriente.
Cátodo
Común
g f a b
10 9 8 7 6
150 
a
150 
b
7
150 
c 6
4
150 
2
d
1
150 
9
e
10
150 
5
f
150 
3/8
g
1 2 3 4 5 150  Display de
Pd Cátodo Común
e d c Pto.
(ROJO)
Cátodo
Común
FIGURA 6-5: Diagrama de pines y conexionado del Display de 7 segmentos de cátodo común.
Los displays pueden ser de diversos colores (rojo, verde, naranja o azul), aunque el display más
comúnmente utilizado es el de color rojo, por su facilidad de visualización.
6.4 EL TRANSISTOR DE UNIÓN BIPOLAR

El transistor de unión bipolar (del inglés Bipolar Junction Transistor, o sus siglas BJT) es un
dispositivo electrónico de estado sólido consistente en dos uniones PN muy cercanas entre sí, que permite
controlar el paso de la corriente a través de sus terminales. La denominación de bipolar se debe a que la
conducción tiene lugar gracias al desplazamiento de portadores de dos polaridades (huecos positivos y
electrones negativos), y son de gran utilidad en gran número de aplicaciones; pero tienen ciertos
inconvenientes, entre ellos su impedancia de entrada bastante baja.
FIGURA 6-6: El transistor de unión bipolar.
Los transistores bipolares son los transistores más conocidos y se usan generalmente en electrónica
analógica aunque también en algunas aplicaciones de electrónica digital, como la tecnología TTL o
BICMOS.
Un transistor de unión bipolar está formado por dos Uniones PN en un solo cristal semiconductor,
separados por una región muy estrecha. De esta manera quedan formadas tres regiones:
• Emisor, que se diferencia de las otras dos por estar fuertemente dopada, comportándose
como un metal. Su nombre se debe a que esta terminal funciona como emisor de portadores
de carga.
• Base, la intermedia, muy estrecha, que separa el emisor del colector.
• Colector, de extensión mucho mayor.
En su funcionamiento normal, la unión base-emisor está polarizada en directa, mientras que la base-
colector en inversa. Los portadores de carga emitidos por el emisor atraviesan la base, porque es muy
angosta, hay poca recombinación de portadores, y la mayoría pasa al colector.
El transistor posee los siguientes estados de operación:
• Corte.
• Saturación.
• Activa.
• Inverso
Existen dos tipos de transistor de unión bipolar:

• NPN.
• PNP.
6.4.1 Transistor de Unión Bipolar NPN

NPN es uno de los dos tipos de transistores bipolares, en los cuales las letras "N" y "P" se refieren a
los portadores de carga mayoritarios dentro de las diferentes regiones del transistor. La mayoría de los
transistores bipolares usados hoy en día son NPN, debido a que la movilidad del electrón es mayor que la
movilidad de los "huecos" en los semiconductores, permitiendo mayores corrientes y velocidades de
operación.
FIGURA 6-7: Símbolo para el transistor NPN.
Los transistores NPN consisten en una capa de material semiconductor dopado P (la "base") entre
dos capas de material dopado N. Una pequeña corriente ingresando a la base en configuración emisor-
común es amplificada en la salida del colector.
La flecha en el símbolo del transistor NPN está en la terminal del emisor y apunta en la dirección en la
que la corriente convencional circula cuando el dispositivo está en funcionamiento activo.
6.4.2 Transistor de Unión Bipolar PNP

El otro tipo de transistor de unión bipolar es el PNP con las letras "P" y "N" refiriéndose a las cargas
mayoritarias dentro de las diferentes regiones del transistor. Pocos transistores usados hoy en día son PNP,
debido a que el NPN brinda mucho mejor desempeño en la mayoría de las circunstancias.
FIGURA 6-8: Símbolo para el transistor PNP.
Los transistores PNP consisten en una capa de material semiconductor dopado N entre dos capas de
material dopado P. Los transistores PNP son comúnmente operados con el colector a masa y el emisor
conectado al terminal positivo de la fuente de alimentación a través de una carga eléctrica externa. Una
pequeña corriente circulando desde la base permite que una corriente mucho mayor circule desde el emisor
hacia el colector.
La flecha en el transistor PNP está en el terminal del emisor y apunta en la dirección en la que la
corriente convencional circula cuando el dispositivo está en funcionamiento activo.
6.4.3 Los transistores 2N3904 Y 2N3906
FIGURA 6-9: El transistor 2N3904.
El transistor 2N3904 es uno de los más comunes transistores NPN generalmente usado para
amplificación. Este tipo de transistor fue patentado por Motorola Semiconductor en los años 60, junto con el
Transistor PNP 2N3906, y representó un gran incremento de eficiencia, con un encapsulado TO-92 en vez
del antiguo encapsulado metálico. Está diseñado para funcionar a bajas intensidades, bajas potencias,
tensiones medias, y puede operar a velocidades razonablemente altas. Se trata de un transistor de bajo
costo, muy común, y suficientemente robusto como para ser usado en experimentos electrónicos.
Es un transistor de 200 miliamperios (mA), 40 voltios (V), 625 milivatios (mW), con una Frecuencia de
transición de 300 MHz, con una beta de 100. Es usado primordialmente para la amplificación analógica.
El Transistor PNP complementario del 2N3904 es el 2N3906. El Transistor NPN 2N2222A es otro
transistor muy popular, con características similares al 2N3904, pero que permite intensidades mucho más
elevadas. No obstante, en todas las aplicaciones que requieren baja intensidad, es preferible el uso del
2N3904.
2N3904 2N3906
C C
E B E B
a) Diagrama de pines del transistor 2N3904. b) Diagrama de pines del transistor 2N3906.
FIGURA 6-10: Diagrama de pines de los transistores 2N3904 y 2N3906.
Los transistores de pequeña potencia vienen fabricados en diferentes formatos, los más comunes son
los TO-18, TO-92, SOT-23, y SOT-223.
a) TO-18 b) TO-92 c) SOT-23 d) SOT-223
FIGURA 6-11: Tipos de encapsulados de transistores de pequeña potencia.
Uno de los diversos parámetros del transistor 2N3904 es conocer la ganancia de corriente, el cual es
la relación entre la corriente del colector y la corriente de la base. Para una ganancia de corriente con valor
de 100, un cambio de 0.001 A en la corriente base resulta en un cambio de 0.1 A en el colector. Esto
sugiere la manera en la cual el transistor 2N3904 puede convertirse en un amplificador. Un pequeño cambio
en la corriente base conduce a cientos de cambios en la corriente del colector, lo cual se puede traducir en
un cambio de voltaje o energía. Designando al transistor en etapas en cascada, es posible construir
amplificadores, switches y osciladores para diversas aplicaciones.
+5V
R2 = 10 KΩ
Salida
R1 = 10 KΩ
Entrada Q1 = 2N3904
FIGURA 6-12: Configuración del transistor 2N3904 como interruptor.
6.5 PRÁCTICA DE LABORATORIO

Para desarrollar esta cuarta práctica de laboratorio, realizaremos los siguientes pasos:
• ¿Qué se va a hacer?
• Diseñando el circuito para nuestro laboratorio.
• Programando.
6.5.1 ¿Qué se va a hacer?

En este sexto laboratorio, se realizará las siguientes aplicaciones:
• Mostraremos los números (0 al 9) en un visualizador de 7 segmentos (Display) cátodo común.
• Ingresaremos un número por teclado mediante el monitor serie y lo visualizaremos en un
visualizador de 7 segmentos.
• Usaremos dos pulsadores para controlar un visualizador de 7 segmentos (Display), cátodo
común, realizando un contador ascendente/descendente del 0 al 9.
• Aprenderemos a controlar un panel implementado con cuatro visualizadores de 7 segmentos,
mediante la multiplexación.
• Mostraremos palabras de un máximo de cuatro letras en el panel de cuatro visualizadores de 7
segmentos.
• Desplazaremos de derecha a izquierda una PALABRA en el panel de cuatro visualizadores de
7 segmentos.
• Finalmente, desplazaremos de derecha a izquierda un MENSAJE en el panel de cuatro
visualizadores de 7 segmentos.
6.5.2 Diseñando el circuito para nuestro laboratorio.

A continuación, se muestra el circuito para la primera y segunda aplicación, la cual controlara un
visualizador de 7 segmentos del tipo cátodo común.
R1 = 150 
R2 = 150 
a 7
TX3  14 R3 = 150 
b 6
RX3  15
c 4
TX2  16 R4 = 150 
d 2
RX2  17
e 1
TX1  18 R5 = 150 
f 9
RX1  19
g 10
SDA 20 R6 = 150 
Pd 5
SCL 21
Arduino R7 = 150 
3/8
MEGA
R8 = 150  Display de
Cátodo Común
(ROJO)
FIGURA 6-13: Circuito para la primera y segunda experiencia.
Para la tercera experiencia, se ha diseñado el siguiente circuito, el cual cuenta con dos pulsadores
para realizar un contador ascendente y descendente, respectivamente, del 0 al 9.
R1 = 150  +5V
R2 = 150 
7 a B1
R3 = 150  14  TX3 RX0  0 Decremento
6 b
15  RX3 TX0  1
4 c
R4 = 150  16  TX2 2
2 d 17  RX2 3 +5V
1 e 18  TX1
R5 = 150  4
9 f 19  RX1 5 R9 = 10 KΩ
10 g
R6 = 150  20 SDA 6
5 Pd Incremento
21 SCL 7 B2
R7 = 150  Arduino
3/8
MEGA
Display de R8 = 150 
Cátodo Común
(ROJO) R10 = 10 KΩ
FIGURA 6-14: Circuito para la tercera experiencia.

Finalmente, pasando a un nivel de mayor complejidad con respecto a los visualizadores de 7

segmentos, ahora vamos a controlar 4 visualizadores de 7 segmentos, para esto, se presenta el circuito a
montar en el protoboard.
Display de Display de Display de Display de
Cátodo Común Cátodo Común Cátodo Común Cátodo Común
(ROJO 1) (ROJO 2) (ROJO 3) (ROJO 4)
7
6
4
2
1
9
10
5
3/8 3/8 3/8 3/8
Q1 = 2N3904 Q2 = 2N3904 Q3 = 2N3904 Q4 = 2N3904
R11 = 10 KΩ R12 = 10 KΩ R13 = 10 KΩ R14 = 10 KΩ
R1 = 150  +5V
a
R2 = 150 
b B1
R3 = 150  14  TX3 RX0  0 Decremento
15  RX3 TX0  1
c
R4 = 150  16  TX2 2
17  RX2 3 +5V
d
R5 = 150  18  TX1 4
19  RX1 5 R9 = 10 KΩ
e
R6 = 150  20 SDA 6
21 SCL 7 Incremento B2
f
R7 = 150  Arduino
MEGA
g
R8 = 150 
Pd R10 = 10 KΩ
FIGURA 6-15: Circuito para las demás experiencias.
6.5.3 Programando
Primera experiencia:
Mostraremos los números en un visualizador de 7 segmentos (Display) cátodo común.
a
f b
g
e c
d
P.d.
FIGURA 6-16: Designación de segmentos para mostrar en el display.

Código de SIETE SEGMENTOS

(Display de Cátodo Común) Valor
Decimal
a b c d e f g Pd
Nº
(1) (2) (4) (8) (16) (32) (64) (128)
0 1 1 1 1 1 1 0 0 63
TABLA 6-2: Segmentos activados (con UNO) para cada número a mostrar en el display.
El montaje para esta experiencia, es el siguiente:

10
15
20
25
30
35
40
45
50
55
60
1
f b
F G H I J
F G H I J
R2 R4 R6 R8 g a
R1 R3 R5 R7
A B C D E
A B C D E
a g
b f
10
15
20
25
30
35
40
45
50
55
60
1
Pd
e
d
c
FIGURA 6-17: Montaje para la primera experiencia.

La programación es la siguiente:
/*
* EXPERIENCIA 6.1:
* Mostraremos un número decimal en el visualizador de 7 segmentos.
*/
int pausa = 1000; // Tiempo que se visualizara el número.
void display(int sa, int sb, int sc, int sd, int se, int sf, int sg, int Pd)
{
digitalWrite (14,sa); // Se asigna el pin 14 al segmento a.
digitalWrite (15,sb); // Se asigna el pin 15 al segmento b.
digitalWrite (16,sc); // Se asigna el pin 16 al segmento c.
digitalWrite (17,sd); // Se asigna el pin 17 al segmento d.
digitalWrite (18,se); // Se asigna el pin 18 al segmento e.
digitalWrite (19,sf); // Se asigna el pin 19 al segmento f.
digitalWrite (20,sg); // Se asigna el pin 20 al segmento g.
digitalWrite (21,Pd); // Se asigna el pin 21 al segmento Pd.
}
void setup()
{
pinMode(14, OUTPUT);
}
void loop()
{
display (1,1,1,1,1,1,0,0); // Se visualiza el número 0.
delay(pausa);
}
Segunda experiencia:
Ingresaremos un número por teclado mediante el monitor serie y lo mostramos en un visualizador de
7 segmentos.
Por ejemplo:
Se ingresa el número
0 por teclado y luego
se presiona la tecla
ENTER, .
FIGURA 6-18: Monitor serie.

Recordar que el circuito para realizar esta experiencia es el mismo, utilizado en la primera
experiencia.
10
15
20
25
30
35
40
45
50
55
60
1
f b
F G H I J
F G H I J
R2 R4 R6 R8 g a
R1 R3 R5 R7
A B C D E
A B C D E
a g
b f
10
15
20
25
30
35
40
45
50
55
60
1
Pd
e
d
c
FIGURA 6-19: Montaje para la segunda experiencia (el mismo de la primera experiencia).
/*
* EXPERIENCIA 6.2:
* Ingresaremos un número decimal por teclado y lo visualizaremos.
*/
int mensaje = 0;
{
}
void setup()
{
Serial.begin(9600);
}
void loop()
{
if(Serial.available()>0)
{
mensaje = Serial.read();
if(mensaje == '0') display(1,1,1,1,1,1,0,0); // Se visualiza el número 0.
if(mensaje == '1') display(…
}
}
Tercera experiencia:
Realizaremos la programación de un contador ascendente/descendente y que la cuenta se muestre
en un visualizador de 7 segmentos. La cuanta ascendente se realizara por intermedio de un pulsador (B1),
de la misma manera, la cuenta descendente se realizara por un segundo pulsador (B2).
El circuito para esta experiencia, es el siguiente:
Incremento
Decremento
10
15
20
25
30
35
40
45
50
55
60
1
f b
F G H I J
F G H I J
R9 R10 R2 R4 R6 R8 g a
R1 R3 R5 R7
A B C D E
A B C D E
B1 B2 a g
b f
10
15
20
25
30
35
40
45
50
55
60
1
Pd
e
d
c
FIGURA 6-20: Montaje para la tercera experiencia.
El programa es el siguiente:
/*
* EXPERIENCIA 6.3:
* Contador ascendente/descendente con visualizador de 7 segmentos.
*/
int BotonDecre = 2; // Al PIN 2 se le asigna el nombre “BotonDecre”.

int BotonIncre = 3; // Al PIN 3 se le asigna el nombre “BotonIncre”.
int tiempoAntiRebote = 15; // Se declara la variable “tiempoAntiRebote” con valor 15.
int cuenta = 0; // Variable para guardar las cuentas del contador, inicia en 0.
int estadoBotonDecre; // Guardar el estado actual del pulsador Decremento.
int estadoBotonIncre; // Guardar el estado actual del pulsador incremento.
int estadoBotonAnteriorDecre; // Guardar el estado anterior del pulsador Decremento.
int estadoBotonAnteriorIncre; // Guardar el estado anterior del pulsador Incremento.
// Función Anti-Rebote: Filtra los armónicos generados al presionar el pulsador.

boolean antiRebote(int pin) // Esta función nos retorna el estado del pulsador.
{
int contador = 0;
boolean estado; // Guarda el estado actual del pulsador.
boolean estadoAnterior; // Guarda el estado anterior del pulsador.
do
{
estado = digitalRead(pin);
if (estado != estadoAnterior)
{
contador = 0;
estadoAnterior = estado;
}
else
{
contador = contador + 1;
}
delay(1);
} while (contador < tiempoAntiRebote);
return estado;
}
// Función Display: Se utiliza para escribir en el visualizador de 7 segmentos.

{
}
void actualizarNumero() // Función para visualizar el número.

{
switch(cuenta) // Consulta el valor de la variable “cuenta” y lo ejecuta.
{
case 0: // Configuración para prender el “0” en el visualizador de 7 segmentos.
display(1,1,1,1,1,1,0,0); // Se llama a la función “display”.
break; // Se utiliza para cerrar el case.
case 1: // Configuración para prender el “1” en el visualizador de 7 segmentos.

display(… // Se llama a la función “display” (Completar los datos).
break; // Se utiliza para cerrar el case.
void setup()
{
pinMode(BotonDecre, INPUT);
pinMode(BotonIncre, INPUT);
}
void loop()
{
estadoBotonIncre = digitalRead(BotonIncre);
if((estadoBotonIncre != estadoBotonAnteriorIncre) && (antiRebote(BotonIncre)))
{
cuenta++;
if(cuenta > 9)
{
cuenta = 9;
}
}
estadoBotonAnteriorIncre = estadoBotonIncre;
estadoBotonDecre = digitalRead(BotonDecre);
if((estadoBotonDecre != estadoBotonAnteriorDecre) && (antiRebote(BotonDecre)))
{
cuenta--;
if(cuenta < 0)
{
cuenta = 0;
}
}
estadoBotonAnteriorDecre = estadoBotonDecre;
actualizarNumero();
}
Cuarta experiencia:
Aprenderemos a controlar un panel implementado con cuatro visualizadores de 7 segmentos,
mediante la multiplexación.
10
15
20
25
30
35
40
45
50
55
60
1
1 2 3 4 f a g 2 b f a g 4 b b d f p
F G H I J
F G H I J
g 1 b f a g 3 b f a a c e g R9 R10
Q1 Q2 Q3 Q4
R1 R8
A B C D E
A B C D E
R11 R12 R13 R14 e p d c e p d c B1 B2
d c e p d c e p
10
15
20
25
30
35
40
45
50
55
60
1
10
15
20
25
30
35
40
45
50
55
60
1
5
F G H I J
F G H I J
A B C D E
A B C D E
10
15
20
25
30
35
40
45
50
55
60
1
FIGURA 6-21: Montaje para las demás experiencias.
Se presenta el código a continuación:

/*
* EXPERIENCIA 6.4:
* Control de un panel de 4 Visualizadores de 7 segmentos.
*/
int colums [4] = {4,5,6,7};

const int pausa = 200;
void setup()
{
for(int i=0; i<=3; i++) pinMode(colums[i], OUTPUT);
}
void loop()
{
digitalWrite(colums[0], HIGH);
for(int i=14; i<=21; i++)
{
digitalWrite(i,HIGH);
delay(pausa);
digitalWrite(i,LOW);
}
}
Quinta experiencia:
Mostraremos palabras de un máximo de cuatro letras para lograr ser mostradas en el panel de cuatro
visualizadores de 7 segmentos.
Para esto, primero se tiene que sacar los códigos binarios (o mapas de bit, BitMap) para las letras;
sólo algunas letras se pueden mostrar en un visualizadores de 7 segmentos.
Código de SIETE SEGMENTOS

(Display de Cátodo Común) Valor
Decimal
a b c d e f g Pd
Letra
(1) (2) (4) (8) (16) (32) (64) (128)
A 1 1 1 0 1 1 1 0 119
S
Esp
TABLA 6-3: Segmentos activados (con UNO) para cada letra a mostrar en el display.
Para nuestra aplicación vamos a mostrar la palabra “HOLA”
0 1 2 3  Matriz
 Palabra
 BitMap
FIGURA 6-22: Palabra “HOLA” codificada.
/*
* EXPERIENCIA 6.5:
* Visualización de palabras.
*/
int seg[8] = {14,15,16,17,18,19,20,21};

int colums[4] = {4,5,6,7};
byte caracter[] = {118,63,56,119}; // Mapa de Bits para la palabra "HOLA".
void muestraPantalla()
{
for(int columna=0; columna<=3; columna++)
{
for(int i=0; i<=7; i++) digitalWrite(seg[i], LOW);
for(int j=0; j<=3; j++)
{
if(j==(columna)) digitalWrite(colums[j], HIGH);
else digitalWrite(colums[j], LOW);
}
for(int fila=0; fila<=7; fila++)
{
int Bit=(caracter[columna] >> fila) & 1;
if(Bit==1) digitalWrite(seg[fila], HIGH);
}
delayMicroseconds(500);
}
}
void setup()
{
for(int i=0; i<=7; i++)
{
pinMode(seg[i], OUTPUT);
digitalWrite(seg[i], LOW);
}
for(int j=0; j<=3; j++)
{
pinMode(colums[j], OUTPUT);
digitalWrite(colums[j], HIGH);
}
}
void loop()
{
muestraPantalla();
}
Sexta experiencia:
Desplazaremos de derecha a izquierda una palabra en el panel de cuatro visualizadores de 7
segmentos.
Para nuestra aplicación vamos a desplazar la palabra “HOLA”
0 1 2 3 4 5 6 7 8 9 10 11  Matriz
 Palabra
 BitMap
FIGURA 6-23: Palabra “HOLA” codificada para el desplazamiento.
/*
* EXPERIENCIA 6.6:
* Desplazamiento de la palabra HOLA.
*/
int seg [8]={14,15,16,17,18,19,20,21};

int colums [4]={4,5,6,7};
byte caracter[] = {0,0,0,0,118,63,56,119,0,0,0,0}; // Mapa de Bits para la palabra "HOLA".
void desplazaPantalla()
{
for(int d=0; d<=8; d++)
{
for(int r=0; r<=150; r++)
{
for(int columna=(0+d); columna<=(3+d); columna++)
{
for(int j=0; j<=3; j++)
{
if(j==(columna-d)) digitalWrite(colums[j], HIGH);
}
{
}
}
}
}
}
void setup()
{
for(int i=0; i<=7; i++)
{
}
for(int j=0; j<=3; j++)
{
}
}
void loop()
{
desplazaPantalla();
}
Sétima experiencia:
Desplazaremos de derecha a izquierda un MENSAJE en el panel de cuatro visualizadores de 7
segmentos.
Para nuestra aplicación desplazaremos el mensaje “HOLA BCD UNIVERSITY 2017”. El código es el
siguiente:
/*
* EXPERIENCIA 6.7:
* Desplazamiento de un mensaje.
*/
int seg [8] = {14,15,16,17,18,19,20,21};

int colums [4] = {4,5,6,7};
String mensaje = "HOLA BCD UNIVERSITY 2017";

byte caracter[1000];
int desp;
int cant=0;
int cero[]={1,63}; // BitMap para el número 0.

int uno[]={1,… // BitMap para el número 1 (Completar hasta el número 9).
int esp[]={1,0}; // BitMap para el espacio.
int A[]={1,119}; // BitMap para la letra A.

int B[]={1,… // BitMap para la letra B (Completar hasta la letra Z).
void construyeMatriz()
{
for(int col=0; col<=3; col++)
{
caracter[cant]=0;
cant++;
}
for(int in=0; in<mensaje.length(); in++)

{
switch(mensaje[in])
{
case '0': {for(int col=1; col<=cero[0]; col++){caracter[cant]=cero[col]; cant++;}
break;}
case '1': {… // Completar hasta el número 9.
case 'A': {for(int col=1; col<=A[0]; col++){caracter[cant]=A[col]; cant++;} break;}

case 'B': {… // Completar hasta la letra Z.
}
}
desp=cant;
for(int col=0; col<=3; col++)
{
caracter[cant]=0;
cant++;
}
}
void desplazaPantalla()
{
for(int d=0; d<=desp; d++)
{
for(int r=0; r<=150; r++)
{
for(int columna=(0+d); columna<=(3+d); columna++)
{
for(int j=0; j<=3; j++)
{
if(j==(columna-d)) digitalWrite(colums[j], HIGH);
}
{
}
}
}
}
}
void setup()
{
for(int i=0; i<=7; i++)
{
}
for(int j=0; j<=3; j++)
{
}
construyeMatriz();
}
void loop()
{
desplazaPantalla();
}
6.6 ANOTACIONES IMPORTANTES
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
Experiencia N ° 06
CONTROL DE VISUALIZADORES DE 7 SEGMENTOS

Ard-1 E06 ControlDeVisualizadoresDe7Segmentos v3.0

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ard-1 E06 ControlDeVisualizadoresDe7Segmentos v3.0

Cargado por

Copyright:

Formatos disponibles

ARQUITECTURA DE COMPUTADORAS

FIGURA 6-1: Arduino MEGA 2560, Display de 7 segmentos y LCD.

6.2 LISTA DE HERRAMIENTAS Y MATERIALES

Herramientas y Materiales para el desarrollo de la experiencia

(1) Multímetro FLUKE 28 II

(1) Arduino Mega 2560

Cables con terminales Macho – Macho en sus extremos (Jumpers)

(2) Resistencia de 10 KΩ.

(4) Display de 7 segmentos CÁTODO COMÚN.

(4) Transistor NPN 2N3904.

(2) Pulsador normalmente abierto.

TABLA 6-1: Lista de Herramientas y Materiales.

6.3 EL VISUALIZADOR DE 7 SEGMENTOS

(a) Display de 7 segmentos. (b) Distribución de los segmentos.

FIGURA 6-2: Visualizador luminoso de 7 segmentos.

FIGURA 6-3: Diferencia entre cátodo común y ánodo común.

6.3.1 Ánodo Común

6.3.2 Cátodo Común

6.4 EL TRANSISTOR DE UNIÓN BIPOLAR

FIGURA 6-6: El transistor de unión bipolar.

Existen dos tipos de transistor de unión bipolar:

6.4.1 Transistor de Unión Bipolar NPN

FIGURA 6-7: Símbolo para el transistor NPN.

6.4.2 Transistor de Unión Bipolar PNP

FIGURA 6-8: Símbolo para el transistor PNP.

6.4.3 Los transistores 2N3904 Y 2N3906

FIGURA 6-9: El transistor 2N3904.

a) TO-18 b) TO-92 c) SOT-23 d) SOT-223

FIGURA 6-11: Tipos de encapsulados de transistores de pequeña potencia.

FIGURA 6-12: Configuración del transistor 2N3904 como interruptor.

6.5 PRÁCTICA DE LABORATORIO

6.5.1 ¿Qué se va a hacer?

6.5.2 Diseñando el circuito para nuestro laboratorio.

FIGURA 6-13: Circuito para la primera y segunda experiencia.

FIGURA 6-14: Circuito para la tercera experiencia.

Finalmente, pasando a un nivel de mayor complejidad con respecto a los visualizadores de 7

3/8 3/8 3/8 3/8

Q1 = 2N3904 Q2 = 2N3904 Q3 = 2N3904 Q4 = 2N3904

R11 = 10 KΩ R12 = 10 KΩ R13 = 10 KΩ R14 = 10 KΩ

FIGURA 6-15: Circuito para las demás experiencias.

FIGURA 6-16: Designación de segmentos para mostrar en el display.

Código de SIETE SEGMENTOS

El montaje para esta experiencia, es el siguiente:

FIGURA 6-17: Montaje para la primera experiencia.

int pausa = 1000; // Tiempo que se visualizara el número.

FIGURA 6-18: Monitor serie.

FIGURA 6-20: Montaje para la tercera experiencia.

int BotonDecre = 2; // Al PIN 2 se le asigna el nombre “BotonDecre”.

// Función Anti-Rebote: Filtra los armónicos generados al presionar el pulsador.

// Función Display: Se utiliza para escribir en el visualizador de 7 segmentos.

void actualizarNumero() // Función para visualizar el número.

case 1: // Configuración para prender el “1” en el visualizador de 7 segmentos.

FIGURA 6-21: Montaje para las demás experiencias.

Se presenta el código a continuación:

int colums [4] = {4,5,6,7};

Código de SIETE SEGMENTOS

Para nuestra aplicación vamos a mostrar la palabra “HOLA”

FIGURA 6-22: Palabra “HOLA” codificada.

int seg[8] = {14,15,16,17,18,19,20,21};

byte caracter[] = {118,63,56,119}; // Mapa de Bits para la palabra "HOLA".

FIGURA 6-23: Palabra “HOLA” codificada para el desplazamiento.

int seg [8]={14,15,16,17,18,19,20,21};

byte caracter[] = {0,0,0,0,118,63,56,119,0,0,0,0}; // Mapa de Bits para la palabra "HOLA".