++ Displays

PROLOGO.
Quien no dispone en su cajn desastre, de un conjunto de display a LED

con dos, tres o cuatro dgitos. Este es el momento de reutilizar dicho
display (multiplexado) en un contador cuya aplicacin puede mejorar una
presentacin que tena pendiente. En este artculo, veremos como aplicar
cdigo a un display multiplexado y como debe funcionar.
INICIANDO.
Actualmente es fcil encontrar en Internet cdigos sobre pantallas LCD y
cmo adaptarlas a distintas aplicaciones. En cambio, son muy pocos los
sitios donde se describe cmo utilizar un display de siete segmentos y no
digamos, cuando se trata de conjuntos de displays de 2, 3 o 4 dgitos
multiplexados. Sin embargo, este dispositivo es bastante comn en un
gran nmero de electrodomsticos que podemos desguazar y reutilizar su
display. Aqu, con este artculo, voy a intentar rellenar esta laguna.
Este artculo, no se puede considerar como una extensin a uno anterior
que puede verse aqu. En aquella ocasin se contemplaba el caso de
aplicar el contador de dos dgitos, como contador en una aplicacin del
propio Arduino que, como ejercicio es esclarecedor y consigue ayudar el
interesado en realizar un contador de esas caractersticas. En esta
ocasin, si bien, puede utilizarse con unos pequeos ajustes, del mismo
modo, la diferencia radica en que se visualizar la cuenta obtenida
reflejada en un pantalla o display de dos, tres o cuatro dgitos de siete
segmentos a LED, mediante la multiplexacin de los dgitos utilizados.
Esta es la estructura del display mltiple.
Estructur
a
Sin ms, vamos a entrar en harina, como dira un panadero. La teora, se
puede ver en el mencionado artculo, as que slo nos preocuparemos de
los tipos de pantalla a utilizar, para este caso usaremos un display mltiple
(multiplexado). El display que vamos a utilizar aqu, tiene la particularidad
en su encapsulado, es decir, que en una pieza ( o encapsulado) nos
presenta varios dgitos. Tenemos que tener en cuenta que en algunos
casos, las patillas que vienen en el encapsulado, parece que no estn
bien, ya que hay menos de las que se supone debera tener, esto es
debido a que se han dispuesto de forma especial, lo que se llama
multiplexado.
EL PROGRAMA.
La cuestin importante radica en el propio programa. El programa consta
de 3 partes bien diferenciadas:
1.
Los displays, definicin propia de los segmentos, de como se
constituyen los dgitos (estructura interna).
2.
La asignacin y correspondencia de los pines del display, del Arduino y
pulsadores, para su aplicacin sin posteriores consultas por ese motivo.
3.
Rutinas, adems de la configuracin (Set up), dentro del lazo (loop) se
encuentran las subrutinas pertenecientes a los pulsadores.
LOS DISPLAYS.
No voy a describir con detalle cmo se construye un display, ms arriba

se puede ver su estructura. El display que voy a utilizar en este artculo, es
el de un display multiplexado, es decir, que sus segmentos estn
conectados internamente de tal manera que al exterior slo aparecen
(normalmente) los correspondientes a los siete segmentos, ms el comn
de cada uno de los dgitos que lo componen, en el caso de cuatro dgitos,
muestra los siete pines de los siete segmentos, ms cuatro
correspondientes a cada uno de los cuatro dgitos. Estos son, unos
ejemplos de encapsulados.
Hay que tener en cuenta que podemos encontrar estos displays en ctodo
comn y en nodo comn. Si usted, no dispone de un encapsulado de
este tipo y est interesado en poner en prctica un contador de los
descritos aqu y en cambio, si dispone de los display individuales,
tranquilo, usted puede auto construir uno fcilmente, con los dgitos que
necesite, vea cmo est construido el de 2 dgitos, de abajo y pngase a
su construccin.
Se pueden apreciar con todo detalle, los dos cablecillos blancos que son
los comunes de cada dgito, por otra parte los siete hilos rojos,
corresponden a los 7 segmentos, los cuales unen entre s, los pares de
segmentos (porque son dos) de cada dgito en paralelo. Recuerde utilizar
todos en nodo o ctodo comn.
CIRCUITO DE 1 DGITO.
El circuito de montaje de encendido de un dgito, es muy simple, se
muestra a continuacin y debajo el cdigo.
El cdigo es igual de sencillo, se ha incluido el Dp (pin digital point), por

ese motivo se ha aadido la octava resistencia. La secuencia enciende y
apaga cada segmento y luego una secuencia de los 7 al tiempo. Por
cierto, el display es un nodo comn FND507 que tena a mano.
Encendido de 7 segmentos.
1
2
3
4
5
6
// Creado por V. Garca 26.02.2014

//
// definimos los 7 segmentos y los asignamos a los pines
int A = 2;
int B = 3;
int C = 4;
7
8
9
1
0
1
1
1
2
1
3
1
4
1
5
1
6
1
7
1
8
1
9
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
int
int
int
int
int
D = 5;
E = 6;
F = 7;
G = 8;
Dp = 9;
// Configuramos los pines.

void setup() {
pinMode (A, OUTPUT);
pinMode (B, OUTPUT);
pinMode (C, OUTPUT);
pinMode (D, OUTPUT);
pinMode (E, OUTPUT);
pinMode (G, OUTPUT);
pinMode (F, OUTPUT);
pinMode (Dp, OUTPUT);
}
// Y encendemos los segmentos.
void loop() {
digitalWrite(A, HIGH);
delay(300);
digitalWrite(A, LOW);
delay(300);
digitalWrite(B, HIGH);
delay(300);
digitalWrite(B, LOW);
delay(300);
digitalWrite(C, HIGH);
delay(300);
digitalWrite(C, LOW);
delay(300);
digitalWrite(D, HIGH);
delay(300);
digitalWrite(D, LOW);
delay(300);
digitalWrite(E, HIGH);
delay(300);
digitalWrite(E, LOW);
delay(300);
digitalWrite(F, HIGH);
delay(300);
digitalWrite(F, LOW);
delay(300);
digitalWrite(G, HIGH);
delay(300);
digitalWrite(G, LOW);
delay(300);
digitalWrite(Dp, HIGH);
delay(300);
digitalWrite(Dp, LOW);
delay(600);
digitalWrite(A, HIGH);
digitalWrite(B, HIGH);
digitalWrite(C, HIGH);
digitalWrite(D, HIGH);
digitalWrite(E, HIGH);
digitalWrite(F, HIGH);
digitalWrite(G, HIGH);
delay(600);
digitalWrite(A, LOW);
digitalWrite(B, LOW);
digitalWrite(C, LOW);
digitalWrite(D, LOW);
digitalWrite(E, LOW);
1
4
2
4
3
4
4
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
6
1
6
2
6
3
6
4
6
5
6
6
6
7
6
8
6
9
7
0
7
1
7
2
7
3
7
digitalWrite(F, LOW);
digitalWrite(G, LOW);
delay(600);
}
4
7
5
7
6
Por supuesto que este cdigo se puede reducir, sin embargo, he querido
mostrarlo de esta forma para que los que se inician puedan seguirlo con
mayor facilidad.
CIRCUITO DE 2 DGITOS.
El circuito se muestra a continuacin. Es muy sencillo y no creo necesario
entrar a describir cada componente. Dos apuntes importantes:
Este mismo circuito, con slo aadir unas resistencias, nos sirve, para el
resto de ejemplos que se describen.
Los pines analgicos del Arduino (A0A6), pueden tomarse como

digitales, siguiendo el orden, A0 = A14; A1 = A15; A6 = A19.
1 . EJEMPLO.
ER
Esta es una primera versin y su correspondiente cdigo realizado con

Arduino v.013 y v.023. El display utilizado para este caso es de ctodo
comn (CC). Como de costumbre, puede seleccionar el cdigo y pegarlo
en su editor dndole un nombre para guardarlo y su posterior ejecucin.
CONTADOR CON DOS DISPLAY DE 7

SEGMENTOS.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//
//
//
//
//
//
//
//
//
//
//
//
//
Doble Didplay siete-segmentos LED con botones

Basado en un trabajo de Natalia Fargasch Norman
Common Catode digit 1 pin 10
Modificado y mejorado 11.08.11
V. Garca
Utiliza 2202 bytes con Arduino v0013
//
//
//
//
//
//
//
//
//
//
//
CA1 G F A B
| | | | | | -> pines y segmentos de control
--------- --------|A||A|
F| |B F| |B
|---G---| |---G---|
E| |C E| |C
|D||D|
--------- --------| | | | | | -> pines y segmentos de control
D DP E C CA2
//
//
//
//
//
//
//
//
//
//
//
Composicin de los digitos en Segmentos

0 => -FEDCBA
1 => ----BC2 => G-ED-BA
3 => G--DCBA
4 => GF--CB5 => GF-DC-A
6 => GFEDC-A
7 => ----CBA
8 => GFEDCBA
9 => GF-DCBA
// Pines digitales usados Arduino para encender

// los correspondientes segmentos LED del display
#define A 2
#define B 3
#define C 4
#define D 5
#define E 6
#define F 7
#define G 8
// Pulsadoes boton conectados a pines 9 y 10
#define BTN1 14
#define BTN2 15
#define led 13
// Pines comunes de cada display de anodo comun
#define CA1 9
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
10
0
10
1
10
2
10
3
10
4
10
5
10
6
10
7
10
8
10
9
11
#define CA2 10
// Pines para A B C D E F G, en secuencia
// se pueden usar los que ms interesen
const int segs[7] = { 2, 3, 4, 5, 6, 7, 8 };
// Segmentos que componen cada nmero
// Para CC.
const byte numbers[10] = { 0b0111111, 0b0000110, 0b1011011, 0b1001111,
0b1100110,
0b1101101, 0b1111101, 0b0000111, 0b1111111, 0b1101111};
// Para CA. descomentar las 2 lneas que siguen.
// const byte numbers[10] = { 0b1000000, 0b1111001, 0b0100100, 0b0110000,
0b0011001, 0b0010010,
// 0b0000010, 0b1111000, 0b0000000, 0b0010000};
int digit1 = 0;
int digit2 = 0;
void setup()
{
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);
pinMode(BTN1, INPUT);
digitalWrite(BTN1, HIGH); // activa RPA
pinMode(CA1, OUTPUT);
pinMode(led, OUTPUT);
// digit1 = 9; digit2 = 9;
}
void loop()
{
// chequea boton1. Incrementa
int val1 = digitalRead(BTN1);
if (val1 == LOW)
{
if (digit2 >= 9 && digit1 >= 9)
{
digit2 = 0;
digit1++;
digit1 %= 10;
if (digit1 >=9)
{
digit2++;
}
} else if (digit1 >= 9)
{
digit2++;
digit2 %= 10;
}
digit1++;
digit1 %= 10;
delay(10);
}
// cheque boton2. Decrementa
0
11
1
11
2
11
3
11
4
11
5
11
6
11
7
11
8
11
9
12
0
12
1
12
2
12
3
12
4
12
5
12
6
12
7
12
8
12
9
13
0
13
1
13
2
13
3
13
4
13
5
13
6
13
7
13
8
13
9
14
0
14
1
14
2
14

if (val2 == LOW)
{
if (digit1 >= 0)
{
if (digit1 < 0)
{
digit1 = 0;
}
digit1--;
}
if(digit1 < 0)
{
digit1 = 9;
if (digit2 < 0)
{
digit2 = 0;
}
digit2--;
}
if (digit2 < 0)
{
digit2 = 9;
}
}
// display numero
unsigned long startTime = millis();
for (unsigned long elapsed=0; elapsed < 300; elapsed = millis() - startTime)
{
lightDigit1(numbers[digit1]);
delay(5);
delay(5);
}
}
void lightDigit1(byte number)
{
digitalWrite(CA1, LOW);
digitalWrite(CA2, HIGH);
lightSegments(number);
}
void lightDigit2(byte number)
{
}
void lightSegments(byte number)
{
for (int i = 0; i < 7; i++)
{
int bit = bitRead(number, i);
digitalWrite(segs[i], bit);
}
}
3
14
4
14
5
14
6
14
7
14
8
14
9
15
0
15
1
15
2
15
3
15
4
15
5
15
6
15
7
15
8
15
9
16
0
16
1
16
2
16
3
16
4
16
5
16
6
16
7
16
8
16
9
17
0
17
1
17
2
17
3
17
4
17
5
17
6
17
7
2 EJEMPLO.
En este segundo ejemplo, voy a utilizar otra forma de resolver el
programa y adems aprovechando que dispongo de un display mltiple de
4 dgitos, har un contador de dos dgitos.
El circuito electrnico es similar al del ejemplo anterior, con unos pocos
cambios, por lo que no lo mostrar aqu. El cdigo se muestra a
continuacin.
CONTADOR 2 X 7 SEGMENTOS Y 2 BOTONES.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//
//
//
//
//
//
//
//
//
//
//
//
//
Doble Didplay siete-segmentos LED con botones

Basado en un trabajo de Natalia Fargasch Norman
Modificado y mejorado 11.08.11
V. Garca
Utiliza 2138 bytes con Arduino v0013
//
//
//
//
//
//
//
//
//
//
//
//
CA1 G F A B
| | | | | -> pins and segments they control
--------- --------|A||A|
F| |B F| |B
|---G---| |---G---|
E| |C E| |C
|D||D|
--------- --------| | | | | -> pins and segments they control
D DP E C CA2
//
//
//
//
//
//
//
//
//
//
Composicin de los digitos en Segmentos

0 => -FEDCBA
1 => ----BC2 => G-ED-BA
3 => G--DCBA
4 => GF--CB5 => GF-DC-A
6 => GFEDC-A
7 => ----CBA
8 => GFEDCBA
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
10
0
10
1
// 9 => GF-DCBA
// Pines digitales usados Arduino para encender
// los correspondientes segmentos LED del display
#define A 2
#define B 3
#define C 4
#define D 5
#define E 6
#define F 7
#define G 8
// Pulsadoes boton conectados a pines 9 y 10
#define BTN1 14
#define BTN2 15
#define led 13
// Pines comunes de cada display de anodo comun
#define CC1 12
#define CC2 11
int estadobtn1 = 0;
int estadobtn2 = 0;
int count = 0;
// Pines para A B C D E F G, en secuencia
// se pueden usar los que ms interesen
const int segs[7] = { 2, 3, 4, 5, 6, 7, 8 };
// Segmentos que componen cada nmero
0b1100110,
0b1101101, 0b1111101, 0b0000111, 0b1111111, 0b1101111};
int digit1 = 0;
int digit2 = 0;
void setup() {
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
pinMode(G, OUTPUT);
pinMode(CC1, OUTPUT);
pinMode(led, OUTPUT);
// digit1 = 9; digit2 = 9; // para depurar
}
void loop()
{
// chequea boton1. Incrementa
if (val1 == LOW)
{
if (digit1 >= 9 )
{
digit1 ++;
{
digit1 = 0;
digit2++;
if (digit2 > 9)
{
if (digit1 > 9)
10
2
10
3
10
4
10
5
10
6
10
7
10
8
10
9
11
0
11
1
11
2
11
3
11
4
11
5
11
6
11
7
11
8
11
9
12
0
12
1
12
2
12
3
12
4
12
5
12
6
12
7
12
8
12
9
13
0
13
1
13
2
13
3
13
4
digit2 = 0;
}
}
}
// cheque boton2. Decrementa
if (val2 == LOW)
{
if (digit1 >= 0)
{
if (digit1 < 0)
{
digit1 = 0;
}
digit1--;
}
if(digit1 < 0)
{
digit1 = 9;
if (digit2 < 0)
{
digit2 = 0;
}
digit2--;
}
if (digit2 < 0)
{
digit2 = 9;
}
}
// display numero
unsigned long startTime = millis();
for (unsigned long elapsed=0; elapsed < 200; elapsed = millis() - startTime) {
delay(5);
delay(5);
}
}
void lightDigit1(byte number) {
digitalWrite(CC1, LOW);
digitalWrite(CC2, HIGH);
}
}
void lightSegments(byte number) {
for (int i = 0; i < 7; i++) {
}
}
13
5
13
6
13
7
13
8
13
9
14
0
14
1
14
2
14
3
14
4
14
5
14
6
14
7
14
8
14
9
15
0
15
1
15
2
15
3
15
4
15
5
15
6
15
7
15
8
15
9
16
0
16
1
16
2
Este ejemplo, muestra un cdigo mejorado al representado en el primer

ejemplo. Como puede apreciarse, he utilizado los mismos pines del
Arduino, en cada ejemplo. Con esto, trato de minorar los errores de
asignacin en los distintos listados de cdigo.
PROBLEMAS A CAUSA DEL MULTIPLEXADO.
El problema que se puede encontrar el programador, frente a una

representacin por multiplexado, radica en los tiempos de muestreo de
cada dgito, por este motivo, recomiendo que se tenga en cuenta, dira,
muy en cuenta, no utilizar o minimizar los delay(), ya que stos, tienden a
producir el efecto de parpadeo que se aprecia en los dgitos.
En un multiplexado, siempre se producir un parpadeo, aunque ste sea
poco apreciable, cuantos ms dgitos se muestren, ms evidente se har.
Por ese motivo hay que reducir en lo posible los tiempos de muestreo.
3ER. EJEMPLO.
Voy a presentar el cdigo de un contador de 3 dgitos en un display de 7
segmentos LED. El lector, puede apreciar las pocas diferencias que se
presentan en este cdigo. Un punto a tener en en cuenta, se encuentra
precisamente en la rutina de asignacin de encendido de cada dgito,
representados por digit1, digit2 y digit3, con sus frmulas.
CONTADOR 3 DISPLAYS DE 7 SEGMENTOS.
1
2
3
4
5
6
7
//
//
//
//
//
//
//
Basado en un trabajo de: Natalia Fargasch Norman

Modificado y actualizado por Vins el 12.08.11
Three seven-segment LED Display with buttons
Common Catode digit 1
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
// Common Catode digit 2

// CA1 G F A B
// | | | | | -> pins and segments they control
// --------- --------// | A | | A |
// F| |B F| |B
// |---G---| |---G---|
// E| |C E| |C
// | D | | D |
// --------- --------// | | | | | -> pins and segments they control
// D DP E C CA2
// Segments that make each number when lit:
// 0 => -FEDCBA
// 1 => ----BC// 2 => G-ED-BA
// 3 => G--DCBA
// 4 => GF--CB// 5 => GF-DC-A
// 6 => GFEDC-A
// 7 => ----CBA
// 8 => GFEDCBA
// 9 => GF-DCBA
// Arduino digital pins used to light up
// corresponding segments on the LED display
#define A 2
#define B 3
#define C 4
#define D 5
#define E 6
#define F 7
#define G 8
// Pushbuttons connected to pins 9 and 10
#define BTN1 14
#define BTN2 15
#define led 13
// Pins driving common anodes
#define CA1 9
#define CA2 10
#define CA3 11
// Pins for A B C D E F G, in sequence
const int segs[7] = { 2, 3, 4, 5, 6, 7, 8 };
// Segments that make each number
0b1100110,
0b1101101, 0b1111101, 0b0000111, 0b1111111, 0b1101111};
int estadobtn1 = 0;
int estadobtn2 = 0;
int digit1 = 0;
int digit2 = 0;
int digit3 = 0;
int count = 0;
int val;
int val2;
void setup() {
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
10
0
10
1
10
2
10
3
10
4
10
5
10
6
10
7
10
8
10
9
11
0
11
1
11
2
11
3
11
4
11
5
11
6
11
7
11
8
11
9
pinMode(G, OUTPUT);
count = 0;
}
void loop() {
// incrementa
val = digitalRead(BTN1); // lee el valor de entrada y almacnelo en val
if (val != estadobtn1) // el estado de botn ha cambiado!
{
if (val == LOW) // compruebe si el botn es presionado
{
count++;
count %= 1000;
}
}
estadobtn1=val;
// decrementa
val = digitalRead(BTN2); // lee el valor de entrada y almacnelo en val
{
{
if (count == 0)
{
count=999;
} else
{
count--;
}
}
}
estadobtn2=val;
// display number
digit1=count / 100;
digit2=(count - (digit1*100)) / 10;
digit3=count % 10;
//
delay(2);
delay(2);
delay(2);
}
}
}
12
0
12
1
12
2
12
3
12
4
12
5
12
6
12
7
12
8
12
9
13
0
13
1
13
2
13 digitalWrite(CA2, HIGH);
3
13 lightSegments(number);
4 }
13
5 void lightSegments(byte number) {
13 for (int i = 0; i < 7; i++) {
6
13
7
}
13 }
8
13
9
14
0
14
1
14
2
14
3
14
4
14
5
14
6
14
7
14
8
14
9
15
0
Veamos la importancia que tiene la reduccin de lo que yo llamo tiempos

muertos, probemos a modificar estas lneas, simplemente, comentemos
las que aqu se muestran, compilemos y carguemos el programa en el

Arduino:
1 // incrementa + + + +
2 val = digitalRead(BTN1); // lee el valor de entrada y almacnalo en val
3 // delay(4);
// 10 milisegundos son una buena cantidad de tiempo
4 // val2 = digitalRead(BTN1); // lee la entrada otra vez para comprobar saltos
5 // if (val == val2)
// asegurar que conseguimos 2 lecturas constantes
6 // {
7
if (val != estadobtn1)
// el estado de botn ha cambiado!
8
{
9
if (val == LOW)
<span style="color: #009900;"> // compruebe si el botn es
1 presionado
0
{
1
count++;
1
count %= 1000;
1
}
2
}
1
estadobtn1=val;
3 // }
1
4
// decrementa - - - 1
val = digitalRead(BTN2); // lee el valor de entrada y almacenalo en val
5 // delay(4);
// 10 milisegundos son una buena cantidad de tiempo
1 // val2 = digitalRead(BTN2); // lee la entrada otra vez para comprobar saltos
6 // if (val == val2)
// asegurar que conseguimos 2 lecturas constantes
1 // {
7
1
{
8
1
{
9
if (count == 0)
2
{
0
count=999;
2
} else
1
{
2
count--;
2
}
2
}
3
}
2
estadobtn2=val;
4 // } </span>
2
5
2
6
2
7
2
8
2
9
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
Habr comprobado que ahora el parpadeo no parece afectar a la normal

visin del contador. A esto es, a lo que me refera, con llevar cuidado al
programar, evitando rutinas que tomen excesivo tiempo en tareas que
retengan el normal desarrollo del microprocesador.
Ahora, puede eliminar de su cdigo, las lneas que ha comentado, guarde
el archivo, compile y cargue el programa en el Arduino y finalmente
compruebe que la solucin es la esperada.
4 EJEMPLO.
En este ejemplo, vamos a utilizar los cuatro dgitos del encapsulado del
display (es uno que tena de una impresora). En este programa la tarea de
multiplexar se dedica a cuatro displays, lo que puede llevar algn
problema si no se vigilan los tiempos. Si no utilizamos bien las rutinas,
aparecern dos consecuencias, el parpadeo y una notable bajada de
luminosidad de los dgitos.
Veamos el listado del cdigo, estos listados estn probados y sin duda
funcionan como se espera de ellos.
CONTADOR CON 4 DISPLAYS DE 7 SEGMENTOS.
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
*
* Esta es la colaboracin que a
* modificado y mejorado por Vins el 12.08.11
*
* Four seven-segment LED Display with two buttons
* Un botn incrementa la cuenta. Otro botn decrementa la cuenta.
* Common Catode digit 1 pin 10
* Common Catode digit 2 pin 5
// CC1 A F CC3 CC2 B
// | | | | | | -> pins and segments they control
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
//
//
//
//
//
//
//
//
//
--------- --------- --------- --------|A||A||A||A|

F| |B F| |B F| |B F| |B
|---G---| |---G---| |---G---| |---G---|
E| |C E| |C E| |C E| |C
|D||D||D||D|
--------- --------- --------- --------| | | | | | -> pins and segments they control
E D C G CC4
// Segments that make each number when lit:

// 0 => -FEDCBA
// 1 => ----BC// 2 => G-ED-BA
// 3 => G--DCBA
// 4 => GF--CB// 5 => GF-DC-A
// 6 => GFEDC-A
// 7 => ----CBA
// 8 => GFEDCBA
// 9 => GF-DCBA
*/
// Arduino digital pins used to light up
// corresponding segments on the LED display
#define A 2
#define B 3
#define C 4
#define D 5
#define E 6
#define F 7
#define G 8
// Pushbuttons connected to pins 9 and 10
#define BTN1 14
#define BTN2 15
// Pins driving common anodes
#define CC1 9
#define CC2 10
#define CC3 11
#define CC4 12
// Pins for A B C D E F G, in sequence
const int segs[7] = { 2, 3, 4, 5, 6, 7, 8 };
// Segments that make each number
0b1100110, 0b1101101, 0b1111101, 0b0000111, 0b1111111, 0b1101111};
int
int
int
int
int
int
int
int
int
estadobtn1 = 0;
estadobtn2 = 0;
digit1 = 0;
digit2 = 0;
digit3 = 0;
digit4 = 0;
count = 0;
val;
val2;
void setup() {
pinMode(A, OUTPUT);
pinMode(B, OUTPUT);
pinMode(C, OUTPUT);
pinMode(D, OUTPUT);
pinMode(E, OUTPUT);
pinMode(F, OUTPUT);
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
10
0
10
1
10
2
10
3
10
4
10
5
10
6
10
7
10
8
10
9
11
0
11
1
11
2
11
3
11
4
11
5
11
6
11
7
11
8
11
9
12
0
12
1
12
2
pinMode(G, OUTPUT);
count = 0;
}
void loop() {
val = digitalRead(BTN1); // lee el valor de entrada y almacnlo en val
{
{
count++;
count %= 10000;
}
}
estadobtn1=val;
val = digitalRead(BTN2); // lee el valor de entrada y almacnlo en val
{
{
if (count == 0)
{
count=9999;
} else {
count--;
}
}
estadobtn2=val;
}
// display number
digit1=count / 1000;
digit2=(count - (digit1 * 1000)) / 100;
digit3=(count - (digit1*1000) - (digit2*100)) / 10;
digit4=count % 10;
delay(2);
delay(2);
delay(2);
delay(2);
}
}
12
3
12
4
12
5
12
6
12
7
12
8
12
9
13
0
13
1
13
2
13
3
13
4
13
5
13
6
13
7
13
8
13
9
14
0
14
1
14
2
14
3
14
4
14
5
14
6
14
7
14
8
14
9
15
0
15
1
15
2
15
3
15
4
15
5
}
}
}
void lightSegments(byte number) {
for (int i = 0; i < 7; i++) {
}
}
15
6
15
7
15
8
15
9
16
0
16
1
16
2
16
3
16
4
16
5
16
6
16
7
16
8
16
9
17
0
A dems de lo comentado, el punto delicado de este sistema de

multiplexado est en la eleccin correcta de la rutina de control de
presentacin de dgitos, cuanto menor tiempo se utilice en comparaciones,
retardos, etc. ms rpido se lograr la activacin del dgito a visualizar:
1
2
3
4
5
// display number
digit1=count / 1000;
digit2=(count - (digit1 * 1000)) / 100;
digit3=(count - (digit1*1000) - (digit2*100)) / 10;
digit4=count % 10;
Esto es un pequeo vdeo de baja calidad que muestra el contador de 4

dgitos y 7 segmentos a LED, ciertamente no se ve con la calidad que
hubiera deseado. Tambin puede descargar una versin, desde aqu.
Con estos ejemplos, he querido llenar un vaco que, haba entre tantos
ejemplos que se pueden encontrar en diferentes foros de Arduino.
Realmente, en los foros se puede encontrar mucha colaboracin y en la
web, muchos artculos que hablan de contadores, realizados con LCD. Sin
embargo, no son muchos los que se inclinan por los displays de siete
segmentos a LED. En la mayora de los que se encuentran teorizan y
hablan de como funcionan, pero que lo describan en espaol, hay pocos.
Por ese motivo, me he tomado la tarea de introducir al interesado en este
tema de la multiplexacin, en este caso, de unos dgitos. Tal vez le pueda
ayudar a alguien en su trabajo.
Como siempre, comentarios, criticas y sugerencias para mejorar este
artculo, son bienvenidos y apreciados.
Descripcin
El visualizador de siete segmentos (llamado tambin display) es una forma de representar
nmeros en equipos electrnicos. Est compuesto de siete segmentos que se pueden
encender o apagar individualmente. Cada segmento tiene la forma de una pequea lnea.
Aunque externamente su forma difiere considerablemente de un led tpico, internamente
estn constituidos por una serie de ledes con unas determinadas conexiones internas,
estratgicamente ubicados de tal forma que forme un nmero 8 de esta forma controlando
el encendido y apagado de cada led, podremos representar el numero o letra que
necesitamos.
Existen dos tipos de display de 7 segmentos, su principal diferencia es la
conexin que debemos implementar para encenderlos, estos dos tipos se
conocen como Anodo comn y Catodo comn.
En los 7 segmentos de Ctodo Comn, el punto circuital en comn para todos
los Led es el Ctodo (Gnd), cero volt, Mientras que el nodo comn el punto de
referencia es Vcc (5 volt). Teniendo en cuenta estas consideraciones la forma de
encender los led debe realizase de diferente manera en funcin de que
elemento tengamos (nodo o Ctodo comn). Cada Led trabaja con tensiones y
corrientes bajas por lo tanto se pueden conectar directamente a compuertas
lgicas o pines de salida de un micro controlador, igualmente siempre es
recomendable para aumentar la vida util de los mismos, conectarle una
resistencia en serie entre el pin de salida del micro controlador y el de entra del
7 segmentos, la intensidad lumnica en este caso depender del valor de la
resistencia agregada.
Especificaciones
Voltaje: 1.9 VCD
Amperaje: 10 mA
Nmero de segmentos: 7
Conexin comn: Ctodo comn
Color del LED: Rojo
Posicin de los pines con respecto al punto: horizontal
Dimensiones del display : 2.4 cm x 1.8 cm x 0.55 cm
Modelo: GM2-5621CURG

++ Displays

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

++ Displays

Uploaded by

Copyright:

Available Formats

PROLOGO.

Quien no dispone en su cajn desastre, de un conjunto de display a LED

No voy a describir con detalle cmo se construye un display, ms arriba

El cdigo es igual de sencillo, se ha incluido el Dp (pin digital point), por

// Creado por V. Garca 26.02.2014

// Configuramos los pines.

Los pines analgicos del Arduino (A0A6), pueden tomarse como

Esta es una primera versin y su correspondiente cdigo realizado con

CONTADOR CON DOS DISPLAY DE 7

Doble Didplay siete-segmentos LED con botones

Composicin de los digitos en Segmentos

// Pines digitales usados Arduino para encender

int val2 = digitalRead(BTN2);

CONTADOR 2 X 7 SEGMENTOS Y 2 BOTONES.

Doble Didplay siete-segmentos LED con botones

Composicin de los digitos en Segmentos

Este ejemplo, muestra un cdigo mejorado al representado en el primer

PROBLEMAS A CAUSA DEL MULTIPLEXADO.

El problema que se puede encontrar el programador, frente a una

CONTADOR 3 DISPLAYS DE 7 SEGMENTOS.

Basado en un trabajo de: Natalia Fargasch Norman

// Common Catode digit 2

Veamos la importancia que tiene la reduccin de lo que yo llamo tiempos

las que aqu se muestran, compilemos y carguemos el programa en el

Habr comprobado que ahora el parpadeo no parece afectar a la normal

CONTADOR CON 4 DISPLAYS DE 7 SEGMENTOS.

--------- --------- --------- --------|A||A||A||A|

// Segments that make each number when lit:

A dems de lo comentado, el punto delicado de este sistema de

Esto es un pequeo vdeo de baja calidad que muestra el contador de 4

Voltaje: 1.9 VCD

Conexin comn: Ctodo comn

Color del LED: Rojo

Posicin de los pines con respecto al punto: horizontal

Dimensiones del display : 2.4 cm x 1.8 cm x 0.55 cm

You might also like