Documente Academic
Documente Profesional
Documente Cultură
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.
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.
1
2
3
4
5
6
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;
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.
1 . EJEMPLO.
ER
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
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
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
//
//
//
//
//
//
//
//
//
//
//
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);
pinMode(BTN2, INPUT);
digitalWrite(BTN1, HIGH); // activa RPA
digitalWrite(BTN2, HIGH); // activa RPA
pinMode(CA1, OUTPUT);
pinMode(CA2, 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
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.
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
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
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
//
//
//
//
//
//
//
//
//
//
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
const byte numbers[10] = { 0b0111111, 0b0000110, 0b1011011, 0b1001111,
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(BTN1, INPUT);
pinMode(BTN2, INPUT);
digitalWrite(BTN1, HIGH); // activa RPA
digitalWrite(BTN2, HIGH); // activa RPA
pinMode(CC1, OUTPUT);
pinMode(CC2, OUTPUT);
pinMode(led, OUTPUT);
// digit1 = 9; digit2 = 9; // para depurar
}
void loop()
{
// chequea boton1. Incrementa
int val1 = digitalRead(BTN1);
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
int val2 = digitalRead(BTN2);
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) {
lightDigit1(numbers[digit1]);
delay(5);
lightDigit2(numbers[digit2]);
delay(5);
}
}
void lightDigit1(byte number) {
digitalWrite(CC1, LOW);
digitalWrite(CC2, HIGH);
lightSegments(number);
}
void lightDigit2(byte number) {
digitalWrite(CC1, HIGH);
digitalWrite(CC2, LOW);
lightSegments(number);
}
void lightSegments(byte number) {
for (int i = 0; i < 7; i++) {
int bit = bitRead(number, i);
digitalWrite(segs[i], bit);
}
}
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
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.
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
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
0
11
1
11
2
11
3
11
4
11
5
11
6
11
7
11
8
11
9
pinMode(G, OUTPUT);
pinMode(BTN1, INPUT);
pinMode(BTN2, INPUT);
pinMode(CA1, OUTPUT);
pinMode(CA2, OUTPUT);
pinMode(CA3, OUTPUT);
digitalWrite(BTN1, HIGH); // activa RPA
digitalWrite(BTN2, HIGH); // activa RPA
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 (val != estadobtn2) // el estado de botn ha cambiado!
{
if (val == LOW) // compruebe si el botn es presionado
{
if (count == 0)
{
count=999;
} else
{
count--;
}
}
}
estadobtn2=val;
// display number
digit1=count / 100;
digit2=(count - (digit1*100)) / 10;
digit3=count % 10;
//
lightDigit1(numbers[digit1]);
delay(2);
lightDigit2(numbers[digit2]);
delay(2);
lightDigit3(numbers[digit3]);
delay(2);
}
void lightDigit1(byte number) {
digitalWrite(CA1, LOW);
digitalWrite(CA2, HIGH);
digitalWrite(CA3, HIGH);
lightSegments(number);
}
void lightDigit2(byte number) {
digitalWrite(CA1, HIGH);
digitalWrite(CA2, LOW);
digitalWrite(CA3, HIGH);
lightSegments(number);
}
void lightDigit3(byte number) {
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
digitalWrite(CA1, HIGH);
13 digitalWrite(CA2, HIGH);
3
digitalWrite(CA3, LOW);
13 lightSegments(number);
4 }
13
5 void lightSegments(byte number) {
13 for (int i = 0; i < 7; i++) {
6
int bit = bitRead(number, i);
13
digitalWrite(segs[i], bit);
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
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
if (val != estadobtn2) // el estado de botn ha cambiado!
1
{
8
if (val == LOW) // compruebe si el botn es presionado
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
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.
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
//
//
//
//
//
//
//
//
//
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);
pinMode(BTN1, INPUT);
pinMode(BTN2, INPUT);
digitalWrite(BTN1, HIGH); // activa RPA
digitalWrite(BTN2, HIGH); // activa RPA
pinMode(CC1, OUTPUT);
pinMode(CC2, OUTPUT);
pinMode(CC3, OUTPUT);
pinMode(CC4, OUTPUT);
count = 0;
}
void loop() {
val = digitalRead(BTN1); // lee el valor de entrada y almacnlo en val
if (val != estadobtn1) // el estado de botn ha cambiado!
{
if (val == LOW) // compruebe si el botn es presionado
{
count++;
count %= 10000;
}
}
estadobtn1=val;
val = digitalRead(BTN2); // lee el valor de entrada y almacnlo en val
if (val != estadobtn2) // el estado de botn ha cambiado!
{
if (val == LOW) // compruebe si el botn es presionado
{
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;
lightDigit1(numbers[digit1]);
delay(2);
lightDigit2(numbers[digit2]);
delay(2);
lightDigit3(numbers[digit3]);
delay(2);
lightDigit4(numbers[digit4]);
delay(2);
}
void lightDigit1(byte number) {
digitalWrite(CC1, LOW);
digitalWrite(CC2, HIGH);
digitalWrite(CC3, HIGH);
digitalWrite(CC4, HIGH);
lightSegments(number);
}
void lightDigit2(byte number) {
digitalWrite(CC1, HIGH);
digitalWrite(CC2, LOW);
digitalWrite(CC3, HIGH);
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
digitalWrite(CC4, HIGH);
lightSegments(number);
}
void lightDigit3(byte number) {
digitalWrite(CA1, HIGH);
digitalWrite(CC2, HIGH);
digitalWrite(CC3, LOW);
digitalWrite(CC4, HIGH);
lightSegments(number);
}
void lightDigit4(byte number) {
digitalWrite(CC1, HIGH);
digitalWrite(CC2, HIGH);
digitalWrite(CC3, HIGH);
digitalWrite(CC4, LOW);
lightSegments(number);
}
void lightSegments(byte number) {
for (int i = 0; i < 7; i++) {
int bit = bitRead(number, i);
digitalWrite(segs[i], bit);
}
}
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
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;
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
Amperaje: 10 mA
Nmero de segmentos: 7
Modelo: GM2-5621CURG