Hacia tiempo que había visto los cubos de leds en Youtube y algunos son realmente

impresionantes, asi que me decidí a hacer uno, pero de los sencillos, de 3x3x3 leds.
(En Youtube los hay de hasta 16x16x16 leds)

Este ha sido el resultado de mi cubo 3x3x3 de leds:

Cubo de Leds 3x3x3

Pero… ¿Cómo se hace?
Sigue leyendo para verlo

Primero que nada, hay que construir una especie de plantilla, para poder posicionar
bien los leds y efectuar el doblado de las patillas, sin que se deforme, o que por lo
menos parezca un cubo al estar terminado.
Para esto, una madera fina, y un taladro con broca del 5 (justo el tamaño de los leds
5mm), y realizamos la plantilla con los 9 agujeros en forma de cubo y uno en el centro,
tal que asi:

Plantilla para cubo de leds 3x3x3

Una vez tengamos la plantilla terminada, colocamos los leds dentro de forma que
queden los cátodos (patilla más corta) hacia adentro del cubo. Deben quedar los
cátodos hacia adentro ya que son éstos los que conectaremos para formar el primer
“nivel” del cubo, así que doblamos y conectamos los cátodos de los leds para que
quede un “cátodo común” para todos los leds. Yo heché mano de unas pinzas de
cocodrilo y procedemos a soldarlos.

Doblamos los cátodos y nos ayudamos de pinzas

Una vez soldados los cátodos retiramos la estructura que queda, y realizamos el
mismo paso 3 veces, para obtener 3 estructuras de 9 leds conectados por sus cátodos,
que serán los 3 niveles o filas del cubo.

Estructuras de leds
Una vez que tengamos las estructuras de los leds, procedemos a conectarlas entre sí,
y para ello utilizando la misma plantilla colocamos una de las estructuras dentro, con
ayuda de unas pinzas de cocodrilo colocamos otra estructura encima y soldamos los
ánodos de los leds esta vez, repitiendo el paso para la última estructura y finalizando el
cubo.
 Estructuras montadas para soldar los ánodos
Y así, finalizamos el cubo, de modo que tenemos un cubo con 9 patillas donde cada
una de ellas corresponde al ánodo de los 3 leds de esa misma columna,  y 3 niveles o
filas de leds conectados por sus cátodos.

Si lo vieramos de un modo informático, es un array bidimensional de leds,

tenemos “columnas” y “filas”, y así es como accederemos a cada uno de los leds con
Arduino.

Cubo de Leds 3x3x3

Terminado el cubo procedemos a la conexión con Arduino. Dado que son leds,
necesitan de una pequeña resistencia así que conectamos cada uno de los pines del
cubo con una resistencia de 220 Ω, a 9 pines digitales del Arduino.
Para conectar los cátodos ó los 3 niveles del cubo, debemos utilizar 3 transistores
NPN, en mi caso usé 2N3904.

Así que conectamos cada uno de los 3 niveles al colector de 3 transistores NPN, la base
de los transistores se conectaría a los pines digitales del Arduino, y el emisor a masa o
GND.
Así utilizamos el transistor en conmutación, de modo que al enviar con Arduino un
valor lógico HIGH a uno de los transistores, éste entrará en saturación, “conectando”
el colector con el emisor, de forma que el cátodo del diodo led se “conectaría” a masa
y encendería.

La forma de conectarlo todo es la siguiente:

Y una vez conectado, declaramos los pines como un array de filas y columnas, y que

decir, es simplemente encender unos leds 

Debido a las altas peticiones de código para encender el cubo, dejo aquí el código
correspondiente al momento en que se encienden los leds aleatoriamente:

1 int Columnas[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

2  
3
4
5 int Filas[] = {12, 11, 10};
6 int RandFila;     //Variable para fila aleatoria
7 int RandColumna;  //Variable para columna aleatoria
8  
void setup()
9 {
10   int contador;
11  
12   for (int contador = 1; contador < 10; contador++){
13     pinMode(Columnas[contador], OUTPUT); }
14  
15   for (int contador = 1; contador < 4; contador++){
    pinMode(Filas[contador], OUTPUT); }
16 }
17  
18 void loop()
19 {
20   RandLed();
}
21
22  
void RandLed()
23 {
24   RandFila = random(0,3);
25   RandColumna = random(0,9);
26  
27   digitalWrite(Filas[RandFila], HIGH);
  digitalWrite(Columnas[RandColumna], HIGH);
28
29  
  delay(75);
30  
31   digitalWrite(Filas[RandFila], LOW);
32   digitalWrite(Columnas[RandColumna], LOW);
33  
34   delay(50);
35 }
36
37
En funcionamiento:
Hemos realizado un cubo de led 3x3x3 con una placa Arduino Uno, nos ha hecho falta los siguientes
materiales:

- 27 led de color blanco

- Cables para realizar las conexiones entre placa y led.
- 11 resistencias en la union de la placa con los led.
- Estaño para soldar todas las conexiones.
- 3 Transistores de referencia BD 135
- 1 Placa de ArduinoUno 
- 1 placa de conexiones

Pasos realizados para hacer el montaje:

1) Realizamos el cubo con los led, soldando los leds entre ellos.

 
2) Insertamos las resistencias, transistores y el cubo de led a la placa de conexiones.
3) Unimos con los cables la placa arduino a la placa de conexiones.
4) Soldamos las conexiones.
5) Conectamos la placa arduino al ordenador y transferimos el codigo.

Este seria el esquema a seguir para realizar las conexiones:

  

 Uno de los muchos codigos que se pueden utilizar:

int Columnas[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

int Filas[] = {12, 11, 10};
int RandFila;     //Variable para fila aleatoria
int RandColumna;  //Variable para columna aleatoria
void setup()
{
  int contador;
  for (int contador = 1; contador < 10; contador++){
    pinMode(Columnas[contador], OUTPUT); }
  for (int contador = 1; contador < 4; contador++){
    pinMode(Filas[contador], OUTPUT); }
}
void loop()
{
  RandLed();
}
void RandLed()
{
  RandFila = random(0,3);
  RandColumna = random(0,9);
  digitalWrite(Filas[RandFila], HIGH);
  digitalWrite(Columnas[RandColumna], HIGH);
  delay(75);
  digitalWrite(Filas[RandFila], LOW);
  digitalWrite(Columnas[RandColumna], LOW);
  delay(50);
}
Imágenes de nuestro proyecto ya terminado:
Aquí un vídeo de demostración del proyecto:

http://www.youtube.com/watch?v=jxIFTKsBAT0

 
Para conectar los
cátodos ó los 3
niveles del cubo,
debemos utilizar
3 transistores
NPN (2N3904),
para que al
conectarlos
cátodos a 3 pines
digitales del
Arduino podemos
encender el cubo
enviando valores
lógicos 0 ó LOW,
pero
cuandoqueramos
apagar el cubo no
podemos enviar
un valor lógico
HIGH, ya que
quemaríamos los
leds,
estaríamosaplica
ndo positivo en
ambas patillas
del led, por lo
que
no
es posible.Así
que se conecta
cada uno de
los 3 niveles
al colector de
3 transistores
NPN, el
transistor
2N3904, la
base de
lostransistores
se conectaría
a los pines
digitales del
Arduino,
utilizando para
cada base una
resistencia de
10
KΩ
y elemisor a
masa o GND.
 Así utilizamos el
transistor en
conmutación, de
modo que al
enviar con
Arduino un valor
lógico HIGH a
uno de los
transistores, éste
entrará en
saturación,
“conectando” el
colector con el
emisor, de forma
que el cátodo se
conectaría
a masa.La forma
de conectarlo es
la siguiente:Y
una vez
conectado,
declaramos los
pines como un
array de filas
y columnas
, y que decir, es
simplemente
encenderunos
leds.
 

 El código para

encender el
cubo, dejo aquí
el código
correspondiente
al momento
en que se
encienden los
ledsaleatoriamen
te:
01
 
int Columnas[]
= {1, 2, 3, 4,
5, 6, 7, 8, 9};
 
02
 
03
 
int Filas[] =
{12, 11, 10};
 
04
 
int RandFila; /
/Variable para 
fila aleatoria
 
05
 
int RandColumna
; //Variable pa
ra columna alea
toria
 
06
 
07
 
void setup()
 
08
 
{
 
09
 
int contador;
 
10
 
11
 
for (int
contador = 0;
contador < 10;
contador++){
 
12
 
pinMode(Columna
s[contador],
OUTPUT); }
 
13
 
14
 
for (int
contador = 0;
contador < 4;
contador++){
 
15
 
pinMode(Filas[c
ontador],
OUTPUT); }
 
16
 
}
 
17
 
18
 
void loop()
 
19
 
{
 
20
 
RandLed();
 
21
 
}
 
22
 
23
 
void RandLed()
 
24
 
{
 
25
 
RandFila =
random(0,3);
 
26
 
RandColumna =
random(0,9);
 
27
 
28
 
digitalWrite(Fi
las[RandFila],
HIGH);
 
29
 
digitalWrite(Co
lumnas[RandColu
mna], HIGH);
 
30
 
31
 
delay(75);
 
32
 
33
 
digitalWrite(Fi
las[RandFila],
LOW);
 
34
 
digitalWrite(Co
lumnas[RandColu
mna], LOW);
 
35
 
36
 
delay(50);
 
37
 
}
 
 

NOTA:
También puedes
bajar la
siguiente librería
de ejemplo de
cubo de leds
para Arduino, en
el siguiente
link:Librería
Cubo de Leds 
¿Cómo utilizar
las librerías
Arduino?
 Para utilizar las
librerías de
arduino, deberás
primero
descomprimir el
archivo de
librería que
quieras
utilizar,moviéndo
la a la
carpeta /skecth
book/librareis
de ArduinoSi no
ves la carpeta
skeetchbook,
puedes ingresar
al IDE de
arduino y en la
solapa
File>Preferences
podrás encontrar
ladirección del
directorio
sketchbook. Si
no tienes la
carpeta libraries
creada dentro de
sketchbook,
creála.Reinicia el
IDE de arduino
(si lo
tuviste abierto)
y busca en
File>Sketchbook>
libraries>LedCub
e>ledcubeCompila
y chan chan!!!!!!!!!!
Agradecemos la
información
brindada
(imágenes e
información) desde
los siguientes
blogs
:http://electronica
vm.wordpress.com/
2011/07/27/cubo-
de-leds-3x3x3-
con-arduino/ http:
//es.scribd.com/
doc/82405114/
Cubo-de-Leds-
3x3x3 
¿Cómo crear un cubo de leds 3x3x3 con
Arduino?
febrero 4, 2012Kiara Navarro
Hoy se muestra el proceso de confección de un cubo de Leds de 3x3x3 con Arduino, destacando la parte electrónica y la programación.
Clase911 ha querido dar inicio a sus proyectos, es por este que decidimos crear un cubo de leds 3x3x3.

En lo personal, he observado algunos videos donde se tiene cubos de 8x8x8. En este caso para dejarlo
accesible a las personas que deseen también hacerlo, se ha hecho solamente con 9 leds en tres niveles.
En este proyecto se verán algunos conceptos de electrónica básica, y de arduino.
¡Manos a la obra!
Nivel: Básico
Costo: dinero > 20 USD.
Materiales:
 27 Leds
 3 Transistores NPN (2N3904 ó también 2N2222)
 3 Resistencias de 10 kΩ
 9 Resistencias de 220 Ω
 1 Breadboard
 1 Arduino UNO
 Cables de conexión (4 ft bastarán) ó Arduino Jumper Wires
Paso 1: Creando el circuito
En la compra de materiales, fíjense cuando vayan a la electrónica de comprar leds que tengan las patillas
suficientemente largas. Por todo lo demás, no hay que tener problema.
La primera etapa consiste en la construcción del cubo. Para esto, se recomienda tener una tabla de
madera y hacer una plantilla donde irán los leds cuando se vayan a soldar.
El área de esta plantilla dependerá de la longitud que tenga la patilla más larga de su led. Para abrir los
huecos se recomienda el uso de un taladro con broca de 5 mm que es más o menos el diámetro de los
leds.
Ya que se tiene la plantilla se prodece a doblar los cátodos de los leds. En este proyecto trabajaremos
cada nivel como cátodo común. Esto quiere decir que todos los cátodos de cada leds deberán estar
unidos, y mirando hacia adentro.
Existen tres manera de identificar cuál es el cátodo:
1. Es la patilla más corta de led
2. El lado que es plano sobre el led
3. Se encuentra conectado a la pieza más grande en el interior de led

Utilice unos lagartos para mantener unidos el punto común entre los dos leds que va a soldar. Cuando
haya terminado de soldar todos los leds, entonces repita este procedimiento tres veces.
Lo siguiente es conectar los niveles, uno encima de otro. Para esto, doblaremos un poco hacia afuera los
ánodos de los leds, para cuando se vayan a soldar, no haya problema.
Nos quedaría algo como ésto.

A continuación se presenta el esquemático del circuito:

Ahora, para conectar el cubo al arduino, necesitaremos varios componentes. Uno de ellos son las
resistencias. Como el arduino brinda a cada una de sus salidas digitales una tensión de 5 V, no podemos
someter semejante voltaje a los leds, para eso se utiliza una resistencia que disminuirá el voltaje aplicado
permitiendo que nuestros leds no se quemen. En este caso usamos un valor de 220 Ω .
Ahora, para lograr que los leds se enciendan necesitamos el uso del transistor en modo de conmutación
es decir que los transistores cambian su región de operación: de corte a saturación. Así cuando el arduino
manda una pequeña corriente (no más de 40 mA) el transistor se activa en saturación ocasionando que el
colector “se conecte” con el emisor dirigiendo los cátodos a tierra.
En este caso, para operar el transistor en conmutación se necesita conectar la base del transistor a través
de una resistencia de 10 kΩ con los pin digital de arduino, mientras que el colector irá conectado a los
cátodos del cubo, y finalmente el emisor a tierra.
Paso 2: Creando el programa
Lo único que falta hacer es bajar el programa creado en processing/wiring para nuestro Arduino UNO
que nos permitirá encender los leds. También si quiere, puede crear su propio programa para el
encendido de leds.
Existe una gran cantidad de ejemplos que nos permitirá hacer de nuestro cubo, una belleza en acción =)
Gracias a Electrónica de Segundo pudimos probar el cubo con el siguiente código:

1 int Columnas[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

2   
3 int Filas[] = {12, 11, 10};
4 int RandFila; //Variable para fila aleatoria
5 int RandColumna; //Variable para columna aleatoria
6
7 void setup() {
8 int contador;
9
10 for (int contador = 0; contador < 10; contador++) {
11 pinMode(Columnas[contador], OUTPUT);
12 }
13
14 for (int contador = 0; contador < 4; contador++) {
15 pinMode(Filas[contador], OUTPUT);
16 }
17 }
18
19 void loop() {
20 RandLed();
21 }
22
23 void RandLed() {
24 RandFila = random(0,3);
25 RandColumna = random(0,9);
26
27 digitalWrite(Filas[RandFila], HIGH);
28 digitalWrite(Columnas[RandColumna], HIGH);
29 delay(75);
30
31 digitalWrite(Filas[RandFila], LOW);
32 digitalWrite(Columnas[RandColumna], LOW);
33 delay(50);
34 }
También puedes bajar la siguiente librería de ejemplo de cubo de leds para arduino.
Librería Cubo de Leds
¿Cómo utilizar las librerías arduino en fedora?
Para utilizar las librerías de arduino, deberás primero descomprimir el archivo de librería que quieras
utilizar, moviéndola a la carpeta /skecthbook/librareis de arduino. Si estas trabajando en fedora, puedes
encontrar esta carpeta en el directorio:
/home/tuusario
Si no ves la carpeta skeetchbook, puedes ingresar al IDE de arduino y en la solapa
File>Preferencespodrás encontrar la dirección del directorio sketchbook. Si no tienes la carpeta libraries
creada dentro de sketchbook, creála.
Reinicia el IDE de arduino (si lo tuviste abierto) y busca en
File>Sketchbook>libraries>LedCube>ledcube
Compila y chan chan!!!!!!!!!!
Queremos agradecer a CIDETYS por habernos patrocinado los materiales electrónicos para
la creación de este proyecto.
Espero que les haya gustado, y por favor si tienen alguna pregunta, consulta, sugerencia… coméntenla
Display 7 segmentos
Hoje vou falar de outro display bastante comum utilizado nos projetos do Arduino : o display de 7
segmentos, como esse abaixo :

O display de 7 segmentos, como o próprio nome diz, tem 7 partes, ou segmentos, que podem ser
agrupados de modo a formar números e letras.

Os segmentos são organizados de A a F :

Imagem : Wikipedia
Assim, se você quiser mostrar o número 1, basta ativar os segmentos B e C. Para mostrar o
número 3, os segmentos A, B, C, D e G, e assim por diante.

A ligação ao Arduino usa os pinos de 2 a 9, mais o GND,  na seguinte sequencia :

Pino 2 do Arduino ====> Pino segmento A

Pino 3 do Arduino ====> Pino segmento B
Pino 4 do Arduino ====> Pino segmento C
Pino 5 do Arduino ====> Pino segmento D
Pino 6 do Arduino ====> Pino segmento E
Pino 7 do Arduino ====> Pino segmento F
Pino 8 do Arduino ====> Pino segmento G
Pino 9 do Arduino ====> Pino segmento PONTO
Pino GND do Arduino => Pino 3 do display

Um ponto importante é a utilização dos resistores de 220 ohms para cada pino. Como o display
trabalha com 2V, é necessário limitar a corrente, evitando queimar o componente :

Para o modelo de display que estou utilizando (FJ5101AH, catodo comum), a disposição dos pinos
é mostrada na próxima imagem. Se o seu display for de outro modelo, basta descobrir qual pino
corresponde a cada segmento. Isso pode ser feito utilizando-se um multimetro ou até mesmo uma
pilha, tomando o cuidado de respeitar a voltagem máxima que comentei acima : 2 volts.
 Imagem : Parallax

Finalmente o programa, baseado no código desenvolvido pelo site hacktronics. Fiz algumas
alterações no mesmo, para que o display mostre não só os números de 0 a 9, mas também as
letras de A a F, em ordem crescente :

1 // Programa : Contador crescente 0 a F

2 // Modificacoes e comentarios : Arduino e Cia
3 // Baseado no programa:
4 // Arduino 7 segment display example software
5 // http://www.hacktronics.com/Tutorials/arduino-and-7-segment-
6 led.html
7 // License: http://www.opensource.org/licenses/mit-license.php (Go
8 crazy)
9 // Define a ordem de ligação dos segmentos, dos digitos 0 a F
10 // Este padrão é para display de catodo comum
11 // Para display de anodo comum, modifique os valores de 0 para 1 e
12 // de 1 para 0
13 // 1 = LED ligado, 0 = LED desligado, nessa ordem :
14 // Arduino pinos: 2,3,4,5,6,7,8
15
16 byte seven_seg_digits[16][7] = { { 1,1,1,1,1,1,0 }, // = Digito 0
17 { 0,1,1,0,0,0,0 }, // = Digito 1
18 { 1,1,0,1,1,0,1 }, // = Digito 2
19 { 1,1,1,1,0,0,1 }, // = Digito 3
20 { 0,1,1,0,0,1,1 }, // = Digito 4
21 { 1,0,1,1,0,1,1 }, // = Digito 5
22 { 1,0,1,1,1,1,1 }, // = Digito 6
23 { 1,1,1,0,0,0,0 }, // = Digito 7
24 { 1,1,1,1,1,1,1 }, // = Digito 8
25 { 1,1,1,0,0,1,1 }, // = Digito 9
26 { 1,1,1,0,1,1,1 }, // = Digito A
 { 0,0,1,1,1,1,1 }, // = Digito B
27
{ 1,0,0,1,1,1,0 }, // = Digito C
28
{ 0,1,1,1,1,0,1 }, // = Digito D
29
{ 1,0,0,1,1,1,1 }, // = Digito E
30
{ 1,0,0,0,1,1,1 } // = Digito F
31
};
32
33
34
void setup()
35
{
36
pinMode(2, OUTPUT); //Pino 2 do Arduino ligado ao segmento A
37
pinMode(3, OUTPUT); //Pino 3 do Arduino ligado ao segmento B
38
pinMode(4, OUTPUT); //Pino 4 do Arduino ligado ao segmento C
39
pinMode(5, OUTPUT); //Pino 5 do Arduino ligado ao segmento D
40
pinMode(6, OUTPUT); //Pino 6 do Arduino ligado ao segmento E
41
pinMode(7, OUTPUT); //Pino 7 do Arduino ligado ao segmento F
42
pinMode(8, OUTPUT); //Pino 8 do Arduino ligado ao segmento G
43
pinMode(9, OUTPUT); //Pino 9 do Arduino ligado ao segmento PONTO
44
writePonto(0); // Inicia com o ponto desligado
45
}
46
47
void writePonto(byte dot) //Funcao que aciona o ponto no display
48
{
49
digitalWrite(9, dot);
50
}
51
52
void sevenSegWrite(byte digit) //Funcao que aciona o display
53
{
54
byte pin = 2;
55
56
//Percorre o array ligando os segmentos correspondentes ao digito
57
for (byte segCount = 0; segCount < 7; ++segCount)
58
{
59
digitalWrite(pin, seven_seg_digits[digit][segCount]);
60
++pin;
61
}
62
writePonto(1); //Liga o ponto
63
delay(100); //Aguarda 100 milisegundos
64
writePonto(0); //Desliga o ponto
65
}
66
67
void loop()
68
{
69
//Contador de 0 a 15, ligando os segmentos correspondentes
70
//0 a 9 = liga os segmentos correspondentes aos numeros
71
//10 a 15 = Forma as letras A,B,C,D,E,F
72
for (byte count = 0; count < 16; count++)
73
{
74
delay(500);
75
sevenSegWrite(count);
76
}
77
delay(4000);
 }

Não encontrei o datasheet específico desse display FJ5101AH.Procurando modelos similares,

encontrei as informações abaixo, que podem ser utilizadas como base :
No próximo artigo vou usar esse mesmo display de 7 segmentos com o Ardu

En la lección de hoy vamos a abordar la utilización de un display de 7

segmentos desde nuestro ARDUINO .
El display de 7 segmentos es un dispositivo de salida que se utiliza para la
representacion de valores numéricos. Su nombre proviene de su construcción
basada en la utilización de siete leds con unas determinadas formas y conexiones
internas, estratégicamente ubicados de tal forma que forman el número '8' y,
opcionalmente, con un octavo led para el punto decimal.
Cada uno de los segmentos que forman la pantalla están marcados con las ocho
primeras letras del alfabeto ( de la 'a' a la 'g'), y se montan de forma que permiten
activar cada segmento por separado, consiguiendo formar cualquier dígito
numérico. En el caso de que incluyan el punto decimal, éste diodo se nombra
como DP.

Estos dispositivos de pueden encontar en dos configuraciones posibles, según los

pines de los leds que tengan unidos: ánodo común o cátodo común. 
Para comprender el funcionamiento de un display de siete segmentos de cátodo
común, vamos a utilizar el siguiente montaje:
Puesto que se trata de un dispositivo con el cátodo común, hemos puesto a tierra
el pin común. A cada uno de los otros pines les hemos conectado una resistencia
de 220 ohms en serie con un interruptor y conectado al potencial de +5V.
Actuando sobre cada uno de los pulsadores podemos ver cómo se enciende el
segmento correspondiente. En la imagen siguiente vemos como se ilumina el
segmento 'e' al cerrar el interruptor correspondiente.
Cómo es lógico, si cerramos los interruptores correspondientes a los segmentos
a,b,c,d y g tendremos representado el número 3.

Y de la misma forma, se pueden representar el resto de números.

Cuando utilicemos un dispositivo de ánodo común, el funcionamiento será similar,
con la única excepción de que tendremos que alimentar el pin común con los +5V
y realizar el montaje de resistencias e interruptores unidos a tierra.
El principal inconveniente de la utilización de los displays de 7 segmentos es que
necesitan un gran número de líneas para su gobierno. Un control directo de un
display de siete segmentos desde nuestro ARDUINO supondría utilizar siete pines
(ocho si contamos el punto decimal) para gobernar un solo dispositivo.
Con una sencilla operación de multiplicación podemos comprobar que es
imposible utilizar cuatro dísplays de 7 segmentos desde nuestro ARDUINO porque
necesitaríamos 28 pines.
Por eso, la solución habitual es utilizar integrados que nos ayudan a reducir el
número de pines utilizados de nuestro ARDUINO para gobernar los displays de 7
segmentos. En el siguiente montaje podemos ver la utilización de un integrado
4511 para gobernar un display del tipo cátodo común utilizando sólo cuatro pines.
El 4511 es un decodificador BCD a 7-Segmentos de bajo coste (existen versiones
que cuestan unos pocos céntimos de euro). Recibe la información del dígito a
mostrar en codificación octal (4 bits) a través de los cuatros pines denominados
A,B,C y D. Gobierna los siete segmentos del display por medio de los siete pines
de salida marcados como QA a QG.
El pin rotulado LT (lamp test) sirve para hacer una prueba de lámpara, es decir,
que si conectamos este pin a tierra se iluminan los 7 segmentos y podemos
comprobar que todos funcionan correctamente. Para un funcionamiento normal lo
debemos conectar a +5V.
El pin rotulado BL (blank) sirve para inhabilitar el display y que se queden todos
los segmentos apagados. Para inhabilitar el display debemos conectarlo a tierra y
para que funcione normalmente conectarlo a +5V.
Por último, el pin rotulado LE (latch enable) permite congelar el display mostrando
un determinado valor escrito en los pines de entrada del integrado. Su uso se
realiza con la siguiente secuencia de trabajo. Ponemos el pin LE a tierra,
utilizamos los pines A, B, C y D para indicar el número a mostrar en código octal y
ponemos el pin LE a +5V. Mientras el pin LE esté conectado a +5V se ignorarán
todos los cambios que se produzcan en los pines A, B, C y D manteniendo el
mismo valor mostrado en el display. 
Más tarde veremos un ejemplo de uso de este pin para gobernar más de un
display desde nuestro ARDUINO utilizando el menor número de pines posible. 
Por ahora, vamos a conectar nuestro integrado 4511 como se mostraba en la
última figura.
El código que ejecutaremos en nuestro ARDUINO para mostrar un contador
incremental de 0 a 9 con un nuevo incremento cada segundo se muestra a
continuación.
El programa utiliza las funciones iniTemp() y chkTmp() que ya vimos en lecciones
anteriores y que sirven para controlar la ejecución de las líneas de código
convenientes cada segundo.
Utilizamos una matriz llamada digitos, de 10 x 4 posiciones, para codificar las diez
cifras en octal y facilitar la activación y desactivación de las cuatro salidas que
utilizamos para controlar el integrado 4511. Usamos la variable Contador para
almacenar el número a mostrar en cada nuevo ciclo.
Al combinar el uso de la matriz digitos con la variable contador, resulta sencillo
escribir el código necesario para mostrar la cifra indicada en cada bucle activando
las salidas correspondientes para cada nuevo número a mostrar con unas
sencillas instrucciones if..else por cada una de los cuatro pines de entrada del
integrado 4511.
El resultado es un contador incremental en el display de siete segmentos.

Veamos ahora como podemos controlar cuatro displays con sólo ocho pines de
nuestro ARDUINO utilizando el pin LE de cada integrado 4511. El esquema de
conexionado de los cuatro displays se muestra en la siguiente imagen.
El código de nuestro nuevo programa se muestra a continuación.
El funcionamiento es muy similar al código que ya vimos para controlar un único
display.
La diferencia principal radica en que utilizamos cuatro pines para controlar el pin
LE de cada uno de los integrados 4511 y que nuestra variable contador ahora se
ha convertido en una matriz de cuatro posiciones para contener ahora los cuatro
dígitos de nuestro contador.
Con la utilizanción de los pines LE podemos compartir los mismos cuatro pines de
salida de nuestro ARDUINO para enviar la información del dígito que queremos
mostrar en cada uno de los cuatro displays.
Como se puede observar la técnica consiste en activar el pin LE del integrado
4511 que gobierna el display que nos interesa excitar, escribir el código octal de la
cifra a mostrar en ese display y volver a desactivar el pin LE. Y repetir esta
operación para cada uno de los otros tres conjuntos de integrado y display que
utilizamos para cada uno de los tres dígitos restantes.
De esta manera cada integrado 4511 se encarga de mantener el display que
controla con el digíto que deseamos mostrar mientras utilizamos los mismos pines
de salida para ir enviando la información al resto de los integrados.
Gracias a esta técnica, con sólo ocho pines podemos gobernar cuatro displays de
siete segmentos. Además este código nos otorga una ventaja adicional. El tiempo
de carga de trabajo de nuestro ARDUINO es muy limitado, puesto que con ayuda
del uso de las funciones temporales, sólamente tenemos ocupado al
microcontralador unos pocos milisegundos cada ciclo de escritura. De esta
manera podemos utilizar displays de siete segmentos para mostrar información del
proceso controlado por nuestro ARDUINO dejando a éste libre para realizar otras
tareas de control.
El programa es un contador incremental con una frecuencia de un segundo
empezando en el número 987 (el número desde el que comienza la cuenta se
configura en las líneas del código 42 a 45).

Como siempre, esperamos que esta lección os haya resultado interesante y que
encontréis aplicaciones para el uso de displays de 7 segmentos dentro de
vuestros proyectos.