Reporte Del Cubo de Les 5X5X5

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 16

INSTITUTO TECNOLOGICO DE

OAXACA

MATERIA:
CIRCUITOS ELECTRICOS I

NOMBRE DEL TRABAJO:


CUBO DE LEDS 5X5X5

INTEGRANTES:
MARTINEZ HERNANDEZ FLAVIO CESAR
PEREZ CABRERA CRISTIAN

CARRERA:
ING. ELECTRONICA

LUGAR Y FECHA:
OAXACA DE JUAREZ OAXACA, A 12 DE
DICIEMBRE 2017
Descripción General del Proyecto

Como proyecto se presenta un cubo de luces led’s de tamaño 5X5X5. Con esta
descripción nos referimos que su composición está basada en 5 filas multiplicado
por 5 columnas y 5 pisos de luces led’s, formando un total de 125 luces led’s.

Su figura de luces o secuencia será programada desde I.D.E. Arduino y se


pretende generar diversos juegos de luces por medio de una extensa
programación basada principalmente en las columnas y pisos del cubo led.
Tomando como base fundamental anteriores proyectos de este tipo realizados con
éxito.

Este será montado sobre una breadboard y usando diversos componentes


indispensables para su funcionamiento, cómo lo son resistencias, transistores,
led’s, cables y el corazón del proyecto, un Arduino UNO.

Objetivos del Proyecto

Objetivo General:

 Obtener las bases de programación en Arduino puara ser implementadas


en un circuito que controle el flujo de energía para el buen funcionamiento
de los leds programados, creando un programa con una secuencia lógica
que será demostrada por un sistema digital diseñado para ejecutar el
programa desarrollado.

Objetivos específicos:

 Reforzar el conocimiento en el armado de circuitos.

 Comprender el funcionamiento de cada implemento utilizado en el proyecto.

Marco Teórico

Diodo led

Un diodo emisor de luz (LED), es una fuente de luz constituida por un


material semiconductor dotado de dos terminales. Se trata de un diodo de unión p-
n, que emite luz cuando está activado.6 Si se aplica una tensión adecuada a los
terminales, los electrones se recombinan con los huecos en la región de la unión
p-n del dispositivo, liberando energía en forma de fotones. Este efecto se
denomina electroluminiscencia, y el color de la luz generada (que depende de la
energía de los fotones emitidos) viene determinado por la anchura de la
banda prohibida del semiconductor. Los leds son normalmente pequeños (menos
de 1 mm2) y se les asocian algunas componentes ópticas para configurar
un patrón de radiación.

Resistencia

Se denomina resistencia, al componente electrónico diseñado para introducir


una resistencia eléctrica determinada entre dos puntos de un circuito eléctrico. En
otros casos, como en las planchas, calentadores, etc., se emplean resistencias
para producir calor aprovechando el efecto Joule. Es un material formado por
carbón y otros elementos resistivos para disminuir la corriente que pasa. Se opone
al paso de la corriente.

La corriente máxima y diferencia de potencial máxima en una resistencia viene


condicionada por la máxima potencia que pueda disipar su cuerpo. Esta potencia
se puede identificar visualmente a partir del diámetro sin que sea necesaria otra
indicación. Los valores más comunes son 0.25 W, 0.5 W y 1 W .
Cable puente (Jumper)

Un cable puente para prototipos (o simplemente puente para prototipos), es un


cable con un conector en cada punta (o a veces sin ellos), que se usa
normalmente para interconectar entre sí los componentes en una placa de
pruebas. P.E.: se utilizan de forma general para transferir señales eléctricas de
cualquier parte de la placa de prototipos a los pines de entrada/salida de
un microcontrolador.
Los cables puente se fijan mediante la inserción de sus extremos en los agujeros
previstos a tal efecto en las ranuras de la placa de pruebas, la cual debajo de su
superficie tiene unas planchas interiores paralelas que conectan las ranuras en
grupos de filas o columnas según la zona. Los conectores se insertan en la placa
de prototipos, sin necesidad de soldar, en los agujeros que convengan para el
conexionado del diseño.

Baterías Recargables

Una pila o batería recargable (también llamada acumulador recargable) es un


grupo de una o más celdas electroquímicas secundarias.

Las baterías recargables usan reacciones electroquímicas que son


eléctricamente reversibles, es decir:

 Cuando la reacción transcurre en un sentido, se agotan los materiales de la


pila mientras se genera una corriente eléctrica.
 Para que la reacción transcurra en sentido inverso, es necesaria una corriente
eléctrica para regenerar los materiales consumidos.
Las baterías recargables vienen en diferentes tamaños y emplean diferentes
combinaciones de productos químicos. Las celdas secundarias ("batería
recargable") utilizadas con más frecuencia son las de plomo-ácido, la de níquel-
cadmio (NiCd), la de níquel-metal hidruro (NiMH), la de iones de litio (Li-ion), y la
de polímero de iones de litio (polímero de Li-ion).

Diodo
El diodo Zener es un diodo de silicio fuertemente dopado que se ha construido
para que funcione en las zonas de rupturas, recibe ese nombre por su inventor, el
Dr. Clarence Melvin Zener. El diodo Zener es la parte esencial de los reguladores
de tensióncasi constantes con independencia de que se presenten grandes
variaciones de la tensión de red, de la resistencia de carga y temperatura.
Son mal llamados a veces diodos de avalancha, pues presentan comportamientos
similares a estos, pero los mecanismos involucrados son diferentes. Además si el
voltaje de la fuente es inferior a la del diodo este no puede hacer su regulación
característica.

Tarjeta arduino

Arduino se enfoca en acercar y facilitar el uso de la electrónica y programación de


sistemas embebidos en proyectos multidisciplinarios. Toda la plataforma,
incluyendo sus componentes de hardware (esquemáticos) y Software, son
liberados con licencia de código abierto que permite libertad de acceso a ellos.3
El hardware consiste en una placa de circuito impreso con un microcontrolador,
usualmente Atmel AVR, puertos digitales y analógicos de entrada/salida,4 los
cuales pueden conectarse a placas de expansión (shields), que amplían los
funcionamientos de la placa Arduino. Asimismo, posee un puerto de conexión USB
desde donde se puede alimentar la placa y establecer comunicación con el
computador.
Por otro lado, el software consiste en un entorno de desarrollo (IDE) basado en el
entorno de processing y lenguaje de programación basado en Wiring, así como en
el cargador de arranque (bootloader) que es ejecutado en la placa.4 El
microcontrolador de la placa se programa mediante un computador, usando una
comunicación serie mediante un convertidor de niveles RS-232 a TTL.

Materiales

 125 Leds
 Placa Arduino (uno, nano, mega)
 Cautín
 Estaño
 Cable de Calibre 24
 Pinzas
 Multímetro
 Placa fenólica de 15x15
 Baterías recargables
 Interruptor
 4 resistencias de 220 ohm

Desarrollo

1.-Ensamblado del circuito de leds

Antes de comenzar la construcción, es importante tener una visión completa de cómo va a


funcionar, para que pueda improvisar e identificar los errores a medida que avanzas.
Necesitamos controlar los 125 leds del cubo con tan solo 20 in de la placa de arduino,
vamos a estar utilizando una técnica denominada multiplexación. Rompemos el cubo en
cuatro capas separadas por lo que sólo necesitamos pines de control para 16 LEDs – de
modo para encender un LED específico, debemos activar tanto la capa , y el pin de
control , que nos da una necesidad total de 16 +4 pines. Cada capa tiene un cátodo
común – la parte negativa del circuito – así que todas las patas negativas se unen entre
sí, y se conecta a un solo pin para esa capa.

En el lado (positivo) de ánodo, cada LED se puede conectar a la correspondiente LED en


la capa por encima y por debajo de ella. En esencia, tenemos 25 columnas de las patas
positivas y 4 capas de la negativa. El siguiente diagrama en 3D muestra perfectamente la
idea:

Lo primero es tomar el trozo de porexpan y pegar en él la plantilla para poder


armar el cubo. A continuación ya podemos ir doblando los cátodos (piernas cortas)
de los LED 90 grados y luego soldar a todos juntos para formar un cátodo común.
Cada una de las cuatro capas contará con un cátodo común y 16 ánodos
individuales (piernas largas). Deb es doblar todos los cátodos de los Leds de
manera uniforme, yo me ha ayudado de unos alicates de precisión pequeños,
como los de la imagen. Con un poco de paciencia voy soldando de cuatro en
cuatro los catodos de los diodos.

El siguiente paso es utilizar un cable para conectar las cuatro filas juntos en una
capa, se podría utilizar cuatro tiras de alambre por capa, pero en realidad sólo se
necesitan dos iguales – una tras la primera tira de LEDs y un segundo antes de la
última tira de LEDs. Yo he usado tres tiras por capa para dar una mayor sensación
de cubo unido, en la imagen de abajo podrás observar como quedaría cada capa
con un cátodo común y 16 ánodos individuales. Asegúrese de recortar cualquier
exceso de cable colgando sobre el borde de su cubo , también puedes recortar los
cuatro cátodos que sobresalen del borde de la capa.Recuerda que en las
soldaduras debes usar el menor contacto y tan poco de soldadura como sea
posible. Recuerde, más estaño en cada soldadura no es sinónimo de mayor fuerza
en la unión, al contrario podría dar problemas más adelante.

Soldando las cuatro capas.

Ahora que tenemos las cuatro capas individuales, vamos a soldarlas entre si para
formar el cubo. Vamos a hacer esto al unir los 25 ánodos de cada capa juntos
para que nos quedamos con 25 ánodos comunes y 5 cátodos comunes.Lo primero
que debe hacer es doblar el último mm de cada ánodo hacia el centro del LED,
esto le ayudará a unir las capas entre sí. Sólo tiene que hacer esto con tres de sus
capas superiores.
A partir de aquí tendremos que darnos maña para completar la tarea, podeis usar:

 Separdores de cartón entre capas para facilitar la tarea de soldar los 16


ánodos.
 Usar pinzas de cocodrilo para sujetar las capas mientras las sueldo.
Mi consejo es que soldar los ánodos de las esquinas juntos primero. Repita esto
para las dos capas restantes y su cubo estará completo.

Conexionado y Programa en Arduino

Bueno vamos ahora al conexionado del cubo a la placa arduino y posterior


programación, Usamoa las placas board para pinchar el cubo, y conectamos a
cada uno de los 25 ánodos cómunes una resistencia de 220 Oh, que a su vez se
conectarán a los puertos de Arduino, como se muestran en el gráfico siguiente. A
su vez cada capa que forman los cátodos comunes se conectarán a los puertos
A2. A3, A4 y A5.
Una vez realizadas las conexiones me puedo descargar cualquiera de los dos
programas adjuntos, cada uno de ellos muestran animaciones diferentes.

Si usted desea hacer sus propias animaciones, sigue leyendo y voy a explicar
cómo funciona. Así , cuando se abrió el código en el software de Arduino, te
habrás dado cuenta de la gran bloque de código en el medio que parecía un poco
a esto.
Este gran bloque de código en el medio es donde se desarrollan los patrones de
encendio de los leds del cubo. La manera más fácil de pensar en ella es como una
animación . Cada cambio en el cubo representa un fotograma de la animación, y
cada línea de código representa un fotograma.

En cada línea hay 64 bits de 1 y 0 , se dividió en 25 bloques de 4 bits cada uno,


los cuatro primeros nibbles (cuartetos de bits) corresponden a la capa 1, los
siguientes a la capa 2 y asi hasta la cuatro. Si hay un 1, entonces eso significa que
un LED se encendió, si hay un 0, entonces no va a lucir.

Por ejemplo si tenemos esta línea:

B1000,B1000,B1000,B1000, B0000,B0000,B0000,B0000, B0000,B0000,B0000,B0


000, B0000,B0000,B0000,B0000, 10,

He separado por colores cada capa, de forma que el color negro corresponde a la
capa 1(la inferior), la rojo a la dos, verde tres y azul la cuarta capa. Bien en las
capas 2, 3 y 4 todo está a cero significa que todos los leds de esas capas están
apagados, sin embargo si observamos la capa 1 (la inferior) vemos que está
encendido el primer led de cada nibble (cuarteto), lo que quiere decir que lucirán
los leds de la fila inferior del fondo. El último valor de la fila indica el tiempo que
permanece la secuencia.

Trata de probar con sus propias animaciones, mi consejo es utilizar los


comentarios para darse un recordatorio de lo que hace cada animación. Usted
puede escribir un comentario en el programa escribiendo “/ /” y luego el
comentario.

Códigos de arduino
int layer[4]={A3,A2,A1,A0}; //initializing pinMode(layer[i], OUTPUT); //setting
and declaring led layers layers to output
int }
column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,
A5,A4}; //initializing and declaring led randomSeed(analogRead(10)); //seeding
rows random for random pattern
int time = 250; }

void loop()
{
void setup() turnEverythingOff();
{ flickerOn();
turnEverythingOn();
for(int i = 0; i<16; i++) delay(time);
{
pinMode(column[i], OUTPUT); //setting turnOnAndOffAllByLayerUpAndDownNotT
rows to ouput imed();
} layerstompUpAndDown();
spiralInAndOut();
for(int i = 0; i<4; i++) turnOnAndOffAllByColumnSideways();
{ delay(time);
aroundEdgeDown(); turnEverythingOff();
turnEverythingOff(); delay(i);
randomflicker(); i-= 5;
randomRain(); }
diagonalRectangle(); }
goThroughAllLedsOneAtATime(); //turn everything on and off by layer up
propeller(); and down NOT TIMED
spiralInAndOut(); void
flickerOff(); turnOnAndOffAllByLayerUpAndDownNotT
turnEverythingOff(); imed()
delay(2000); {
} int x = 75;
for(int i = 5; i != 0; i--)
{
//turn all off turnEverythingOn();
void turnEverythingOff() for(int i = 4; i!=0; i--)
{ {
for(int i = 0; i<16; i++) digitalWrite(layer[i-1], 0);
{ delay(x);
digitalWrite(column[i], 1); }
} for(int i = 0; i<4; i++)
for(int i = 0; i<4; i++) {
{ digitalWrite(layer[i], 1);
digitalWrite(layer[i], 0); delay(x);
} }
} for(int i = 0; i<4; i++)
{
//turn all on digitalWrite(layer[i], 0);
void turnEverythingOn() delay(x);
{ }
for(int i = 0; i<16; i++) for(int i = 4; i!=0; i--)
{ {
digitalWrite(column[i], 0); digitalWrite(layer[i-1], 1);
} delay(x);
//turning on layers }
for(int i = 0; i<4; i++) }
{ }
digitalWrite(layer[i], 1); //turn everything on and off by column
} sideways
} void
//turn columns off turnOnAndOffAllByColumnSideways()
void turnColumnsOff() {
{ int x = 75;
for(int i = 0; i<16; i++) turnEverythingOff();
{ //turn on layers
digitalWrite(column[i], 1); for(int i = 0; i<4; i++)
} {
} digitalWrite(layer[i], 1);
//flicker on }
void flickerOn() for(int y = 0; y<3; y++)
{ {
int i = 150; //turn on 0-3
while(i != 0) for(int i = 0; i<4; i++)
{ {
turnEverythingOn(); digitalWrite(column[i], 0);
delay(i); delay(x);
} for(int i = 4; i<8; i++)
//turn on 4-7 {
for(int i = 4; i<8; i++) digitalWrite(column[i], 0);
{ delay(x);
digitalWrite(column[i], 0); }
delay(x); //turn on 0-3
} for(int i = 0; i<4; i++)
//turn on 8-11 {
for(int i = 8; i<12; i++) digitalWrite(column[i], 0);
{ delay(x);
digitalWrite(column[i], 0); }
delay(x); //turn off 12-15
} for(int i = 12; i<16; i++)
//turn on 12-15 {
for(int i = 12; i<16; i++) digitalWrite(column[i], 1);
{ delay(x);
digitalWrite(column[i], 0); }
delay(x); //turn off 8-11
} for(int i = 8; i<12; i++)
//turn off 0-3 {
for(int i = 0; i<4; i++) digitalWrite(column[i], 1);
{ delay(x);
digitalWrite(column[i], 1); }
delay(x); //turn off 4-7
} for(int i = 4; i<8; i++)
//turn off 4-7 {
for(int i = 4; i<8; i++) digitalWrite(column[i], 1);
{ delay(x);
digitalWrite(column[i], 1); }
delay(x); //turn off 0-3
} for(int i = 0; i<4; i++)
//turn off 8-11 {
for(int i = 8; i<12; i++) digitalWrite(column[i], 1);
{ delay(x);
digitalWrite(column[i], 1); }
delay(x); }
} }
//turn off 12-15 //up and down single layer stomp
for(int i = 12; i<16; i++) void layerstompUpAndDown()
{ {
digitalWrite(column[i], 1); int x = 75;
delay(x); for(int i = 0; i<4; i++)
} {
//turn on 12-15 digitalWrite(layer[i], 0);
for(int i = 12; i<16; i++) }
{ for(int y = 0; y<5; y++)
digitalWrite(column[i], 0); {
delay(x); for(int count = 0; count<1; count++)
} {
//turn on 8-11 for(int i = 0; i<4; i++)
for(int i = 8; i<12; i++) {
{ digitalWrite(layer[i], 1);
digitalWrite(column[i], 0); delay(x);
delay(x); digitalWrite(layer[i], 0);
} }
//turn on 4-7 for(int i = 4; i !=0; i--)
{ }
digitalWrite(layer[i-1], 1); //random rain
delay(x); void randomRain()
digitalWrite(layer[i-1], 0); {
} turnEverythingOff();
} int x = 100;
for(int i = 0; i<4; i++) for(int i = 0; i!=60; i+=2)
{ {
digitalWrite(layer[i], 1); //d4
delay(x); turnColumnsOff();
} digitalWrite(column[0], 0);
for(int i = 4; i!=0; i--) digitalWrite(column[5], 0);
{ digitalWrite(column[10], 0);
digitalWrite(layer[i-1], 0); digitalWrite(column[15], 0);
delay(x); delay(x);
} }
} //go through all leds one at a time
} void goThroughAllLedsOneAtATime()
//flicker off {
void flickerOff() int x = 15;
{ turnEverythingOff();
turnEverythingOn(); for(int y = 0; y<5; y++)
for(int i = 0; i!= 150; i+=5) {
{ //0-3
turnEverythingOff(); for(int count = 4; count != 0; count--)
delay(i+50); {
turnEverythingOn(); digitalWrite(layer[count-1], 1);
delay(i); for(int i = 0; i<4; i++)
} {
} digitalWrite(column[i], 0);
//around edge of the cube down delay(x);
void aroundEdgeDown() digitalWrite(column[i], 1);
{ delay(x);
for(int x = 200; x != 0; x -=50) }
{ digitalWrite(layer[count-1], 0);
turnEverythingOff(); }
for(int i = 4; i != 0; i--) //4-7
for(int count = 0; count < 4; count++)
} {
//random flicker digitalWrite(layer[count], 1);
void randomflicker() for(int i = 4; i<8; i++)
{ {
turnEverythingOff(); digitalWrite(column[i], 0);
int x = 10; delay(x);
for(int i = 0; i !=750; i+=2) digitalWrite(column[i], 1);
{ delay(x);
int randomLayer = random(0,4); }
int randomColumn = random(0,16); digitalWrite(layer[count], 0);
}
digitalWrite(layer[randomLayer], 1); //8-11
digitalWrite(column[randomColumn], 0); for(int count = 4; count != 0; count--)
delay(x); {
digitalWrite(layer[randomLayer], 0); digitalWrite(layer[count-1], 1);
digitalWrite(column[randomColumn], 1); for(int i = 8; i<12; i++)
delay(x); {
} digitalWrite(column[i], 0);
delay(x); {
digitalWrite(column[i], 1); digitalWrite(column[i], 0);
delay(x); delay(x);
} digitalWrite(column[i], 1);
digitalWrite(layer[count-1], 0); delay(x);
} }
//12-15 digitalWrite(layer[count], 0);
for(int count = 0; count < 4; count++) }
{ }
digitalWrite(layer[count], 1); }
for(int i = 12; i<16; i++)

Conclusión

Este cubo LED utiliza un microcontrolador Arduino Uno para crear un espectáculo
de luces en movimiento muy espectacular. Para realizar este proyecto con éxito la
paciencia es una de las claves, si sigue el tutorial paso a paso no tendrá ningún
problema en desarrollarlo.

Por último, lo más importante en este proyecto es que te diviertas .

Bibliografías

https://www.scoop.it/t/tecno4/p/4014752341/2014/01/24/como-hacer-un-cubo-
de-leds-4x4x4-con-arduino

https://www.google.com.mx/search?q=como+hacer+un+cubo+de+leds+4x4x
4&source=lnms&tbm=isch&sa=X&ved=0ahUKEwjn9aGaxYbYAhXGxYMKHag
-AkwQ_AUICygC&biw=1024&bih=613#imgrc=ZDvGMFekEfTlWM:

https://www.scoop.it/t/tecno4/p/4014752341/2014/01/24/como-hacer-un-cubo-
de-leds-4x4x4-con-arduino

También podría gustarte