▷ Cubo de Leds 5x5x5 con PIC

Hola controleros y controleras les doy la bienvenida a otra entrada de nuestro curso de microcontroladores PIC, y hoy aprenderemos a Como hacer un Cubo de Leds 5x5x5 con el microcontolador PIC de Microchipa usando el PIC C Compiler CCS C.

Antes que nada, si todavia no has tenido la posibilidad de ver nuestro curso completo de PIC, pues miralo!! 👉Curso de Microcontroladores PIC

Contenidos mostrar

Cubo de Leds 5x5x5 con PIC

El proyecto consiste en el diseño de un secuenciador de luces con efectos 3D, todo controlado a través de un microcontrolador, el cual es el encargado de albergar cada secuencia y de ejecutarla por determinados lapsos de tiempo.

Aprendiendo a construir este proyecto, estarás en la capacidad de construir otros cubos de leds como por ejemplo un cubo led 8x8x8, un cubo de leds 4x4x4, un cubo led 3x3x3 y puedes emplear cualquier microcontrolador como Arduino, PIC, Raspberry PI Pico, etc.

MATERIALES DEL CUBO DE LED

125 LEDs de Chorro (alta luminosidad)
25 resistencias de 270 Ohms
Cristal de Cuarzo de 4MHz
Microcontrolador PIC 16F887
Cautín y Soldadura
Acrilico para hacer la caja.
Caja de plastico para colocar el circuito
5 transistores 2n3904
Regulador de Voltaje 5v LM7805
Cargador de celular viejo (fuente de alimentación)

FABRICACIÓN

Para la fabricación del Led Cube comenzaremos elaborando las cinco caras del cubo, cada cara contiene veinticinco leds (25) para un total de 5x5x5= 125 leds, se aprovechan las patas de los diodos para la realización de dicho cubo, uniendo en cada cara todos los cátodos de cada uno de los leds.

5x5x5 led cube

Una vez tenemos cátodos comunes en cada cara, se procede a ensamblar una cara sobre la otra por medio de los ánodos del led, asi se obtiene un total de veinticinco hileras de leds en la cual cada hilera tiene cinco leds con el anodo común.

Para el control de secuencias, se hace uso de un PIC 16f887, el cual es un microcontrolador perteneciente a la familia de la Microchip cuenta con 256 bytes de datos EEPROM la memoria más que suficientes para albergar 12 secuencias diferentes, y posee un encapsulado de 40 pines ideal para la cantidad de salidas requeridas en este proyecto.

Para poder activar los 125 leds del cubo, se requieren entonces 125 salidas del pic, para lograr el control de secuencias, esto es totalmente irrisorio y además el pic no cuenta con dicha cantidad de salidas, para solucionar dicho problema, se hace uso del método de multiplexacion, el cual consiste en engañar el ojo humano prendiendo y apagando los leds a alta velocidad dando una sensación de que todos los leds se encuentran encendidos, esto se logra de la siguiente manera:

Se utilizan únicamente 25 salidas del pic, para encender los 25 leds de cada cara y adicionalmente se usan otras 5 salidas que son las encargadas de realizar la multiplexación de las 5 caras del cubo, para un total de 30 salidas empleadas en el PIC.

A continuación se presenta el diagrama de cubo de leds para ser implementado con el microcontrolador.

Circuito del cubo de leds 5x5x5

Como se observa en el plano anterior, se utiliza todos los puertos del pic, de la siguiente manera, El puerto A, son los 5 controles encargados de la multiplexación dichos controles van hacia un transistor NPN el cual se conmuta y permite el flujo de electrones en la cara respectiva, habilitando los 25 leds de dicha cara. Y para cada ánodo se utilizan los puertos B,C,D y un bit del puerto E, estos energizan los 25 leds de las caras del cubo.

Display 7 Segmentos

Multiplexación Display de 7 Segmentos con PIC

Teclado Matricial

MULTIPLEXACIÓN.

Esta es una de las etapas mas importantes del proyecto, ya que gracias a ella se puede hacer uso del PIC 16f887 y ahorra el uso de 125 salidas, el truco es sencillo, consiste en habilitar una cara del cubo, por ejemplo al activar la salida A0, se habilita la cara superior del cubo, al habilitar esta cara se puede encender cualquier led de la cara superior, basta con energizar cualquiera de las 25 salidas de los puertos B,C,D o E para lograr el encendido del led, veamos el ejemplo de la secuencia del corazón:

En la cara superior se deben activar dos leds, para ello se habilita dicha cara con la salida “A0” y se energizan los leds respectivos en este caso “D1” y “D3”, se deja energizado por solo 2 milisegundos, luego se deshabilita esta cara y se habilita la segunda cara “A1” y se energizan los leds respectivos, en este caso “D0”, “D1”, “D2”, “D3” y “C3”, se deja energizado por solo 2 milisegundos y luego se deshabilita y se habilita la tercera cara, y asi sucesivamente una vez se llega a la cara 5, vuelve y comienza desde la cara 1 y se queda en el mismo ciclo una y otra vez por un tiempo determinado por el programador, pueden ser 30 segundos, la habilitación y des habilitación de cada cara, se conoce como multiplexación y este se realiza de una manera tan rápida (2 milisegundos) que el ojo humano lo percibe como si todo el cubo estuviera encendido y así es que se observa la figura del corazón.

La siguiente figura muestra la implementación del circuito electrónico elaborado para este proyecto

Por último, solo queda el proyecto en su forma final

Alimentación

Para energizar el circuito, basta con suministrarle 5v. Para esto, al circuito se le adicionó un regulador de voltaje (LM7805) y se utilizó un cargador de celular viejo de 1 amperio.

Normalmente estos cargadores entregan 5v de alimentación, sin embargo, en este circuito opté por colocar el regulador de voltaje, para garantizar en todo momento que el voltaje sea el adecuado. Esto aquí es a criterio de cada uno, perfectamente pueden colocar el cargador directo, si están seguros de que entrega 5v.

Codigo para cubo de leds 5x5x5 con PIC

Para descargar el código debes compartir el contenido de este post, para ayudar a este sitio web a continuar aportando contenido gratuito y de calidad.

[sociallocker id=948]

Descargar el código click aqui

#include <16f887.h>
#device adc=10
#FUSES NOWDT, XT, NOPUT, NOPROTECT, NOBROWNOUT, NOLVP, NOCPD, NOWRT, NODEBUG , PROTECT
#use delay(clock=4000000)
#byte porta=5
#byte portb=6
#byte portc=7
#byte portd=8
#byte porte=9
#include <stdlib.h>
#byte ANSEL = 0x188  //Dirección de memoria del byte ANSEL
#byte ANSELH = 0x189 //Dirección de memoria del byte ANSELH
float sound,volt;
long int ret=3;
int8 mul[6]={0x01,0x02,0x04,0x08,0x10,0x00};
int i,a,b,c,d,e,sec;
void repXYZ(void)
{
porta=mul[0];
delay_ms(ret);
porta=mul[1];
delay_ms(ret);
porta=mul[2];
delay_ms(ret);
porta=mul[3];
delay_ms(ret);
porta=mul[4];
delay_ms(ret);
}
void rotation(int veces)
{ 
int8 ca1[4][5]={0x11,0x22,0x44,0x88,0x00,0x11,0x22,0x44,0x88,0x00,0x10,0x20,0x40,0x80,0x0f,0x00,0x00,0x00,0x00,0x01};
int8 ca2[2]={0x0f,0xf0};
int8 ca4[5]={0x01,0x02,0x04,0x08,0xf0};
int8 ca5[2]={0x00,0x01};
int8 ca3=0xff;
for(b=0;b<=veces;b++)
{
//Rotacion en X
for(i=0;i<5;i++)
{
for(a=0;a<10;a++)
{
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porte=ca1[3][i];
repXYZ();
portb=0;
portd=0;
portc=0;
porte=0;
}
}
for(i=0;i<5;i++)
{
for(a=0;a<10;a++)
{
portb=ca1[0][4-i];
portd=ca1[1][4-i];
portc=ca1[2][4-i];
porte=ca1[3][4-i];
repXYZ();
portb=0;
portd=0;
portc=0;
porte=0;
}
}
//Rotacion en Y
for(i=0;i<2;i++)
{
for(a=0;a<10;a++)
{
portb=ca2[i];
portc=ca4[i];
repXYZ();
portb=0;
portc=0;
}
}
for(i=0;i<2;i++)
{
for(a=0;a<10;a++)
{
portd=ca2[i];
portc=ca4[i+2];
repXYZ();
portd=0;
portc=0;
}
}
for(a=0;a<10;a++)
{
portc=ca4[4];
porte=ca5[1];
repXYZ();
porte=0;
portc=0;
}
//dev   
for(i=0;i<2;i++)
{
for(a=0;a<10;a++)
{
portd=ca2[1-i];
portc=ca4[3-i];
repXYZ();
portd=0;
portc=0;
}
}
for(i=0;i<2;i++)
{
for(a=0;a<10;a++)
{
portb=ca2[1-i];
portc=ca4[1-i];
repXYZ();
portd=0;
portc=0;
}
}
//Rotacion en Z
portb=ca3;
portd=ca3;
portc=ca3;
porte=0x01;
for(i=0;i<5;i++)
{
for(a=0;a<40;a++)
{
porta=mul[i];
delay_ms(ret);
}
}
for(i=0;i<5;i++)
{
for(a=0;a<40;a++)
{
porta=mul[4-i];
delay_ms(ret);
}
}
}
}
void giro(int veces)
{
int8 ca1[3][4]={0x44,0x21,0x00,0x80,0x44,0x84,0x0f,0x24,0x40,0x00,0x04,0x11};
//b                 //d                  //c
for(d=0;d<=veces;d++)
{
for(i=0;i<4;i++)
{
for(b=0;b<10;b++)
{
for(a=0;a<5;a++)
{
porta=mul[5];
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porta=mul[a];
if(i==1)
{bit_set(porte,0);}
else
{bit_clear(porte,0);}
delay_ms(ret);
}
}
}
}
}
void subir(int veces)
{
int8 ca5[4][3]={0x01,0x1b,0x1f,0x00,0x10,0x11,0x11,0xbb,0xff,0x01,0x01,0x01};
//b           //d            //c            //e
int8 ca234[4][2]={0x01,0xff,0x00,0xff,0x11,0xff,0x01,0x01};
//b      //d       //c       //e
int8 ca1[4][6]={0x01,0x1b,0x1f,0xbf,0xff,0xff,0x00,0x10,0x11,0xb1,0xfb,0xff,0x11,0xbb,0xff,0xff,0xff,0xff,0x01,0x01,0x01,0x01,0x01,0x01};
//b                           //d                            //c                          //e
for(d=0;d<=veces;d++)
{
porta=0;      //Los inicializo en 0
portb=0;
portc=0;
portd=0;
porte=0;
for(i=0;i<3;i++)
{
for(a=0;a<160;a++)
{
porta=mul[5];
portb=ca5[0][i];
portd=ca5[1][i];
portc=ca5[2][i];
porte=ca5[3][i];
porta=mul[4];
delay_ms(ret);
}
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[3];
delay_ms(ret);
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[2];
delay_ms(ret);
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[1];
delay_ms(ret);
}
for(i=0;i<6;i++)
{
for(a=0;a<20;a++)
{
porta=mul[5];
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porte=ca1[3][i];
porta=mul[0];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[1];
delay_ms(ret);
}
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=ca234[0][1];
portd=ca234[1][1];
portc=ca234[2][1];
porte=ca234[3][1];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[2];
delay_ms(ret);
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=ca234[0][1];
portd=ca234[1][1];
portc=ca234[2][1];
porte=ca234[3][1];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca234[0][0];
portd=ca234[1][0];
portc=ca234[2][0];
porte=ca234[3][0];
porta=mul[3];
delay_ms(ret);
}
for(a=0;a<60;a++)
{
porta=mul[5];
portb=ca234[0][1];
portd=ca234[1][1];
portc=ca234[2][1];
porte=ca234[3][1];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[4];
delay_ms(ret);
}
for(a=0;a<60;a++)
{
porta=mul[5];
portb=ca234[0][1];
portd=ca234[1][1];
portc=ca234[2][1];
porte=ca234[3][1];
porta=mul[4];
delay_ms(ret);
}
delay_ms(500);
porta=mul[5];
delay_ms(100);
// }
} 
}
void adn(int veces)
{
int8 ca5[4][4]={0x07,0x11,0x00,0x0c,0x00,0x01,0x11,0x00,0xc0,0x0c,0x17,0x71,0x01,0x01,0x00,0x00};
//b                //d                  //c                //e
int8 ca4[4][4]={0x10,0x00,0x08,0x02,0x00,0x10,0x00,0x00,0x08,0x02,0x20,0x80,0x00,0x00,0x00,0x00};
//b                //d                  //c                //e        
int8 ca3[4][4]={0x00,0x00,0x04,0x01,0x01,0x00,0x00,0x00,0x04,0x11,0x40,0x00,0x00,0x00,0x00,0x01};
//b                //d                  //c                //e        
int8 ca2[4][4]={0x00,0x08,0x02,0x10,0x10,0x00,0x00,0x00,0x02,0x20,0x80,0x08,0x00,0x00,0x00,0x00};
//b                //d                  //c                //e        
int8 ca1[4][4]={0x00,0x04,0x01,0x00,0x00,0x00,0x00,0x01,0x11,0x40,0x00,0x04,0x00,0x00,0x01,0x00};
//b                //d                  //c                //e        
for(d=0;d<=veces;d++)
{
for(i=0;i<4;i++)
{
for(b=0;b<12;b++)
{  
porta=mul[5];
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porte=ca1[3][i];
porta=mul[0];
delay_ms(ret);
porta=mul[5];
portb=ca2[0][i];
portd=ca2[1][i];
portc=ca2[2][i];
porte=ca2[3][i];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca3[0][i];
portd=ca3[1][i];
portc=ca3[2][i];
porte=ca3[3][i];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][i];
portd=ca5[1][i];
portc=ca5[2][i];
porte=ca5[3][i];
porta=mul[4];
delay_ms(ret);
}
}
}
}
void heart(int veces)
{
int8 ca5[4][4]={0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
//b                //d                  //c                 //e
int8 ca5i[4][2]={0x00,0x00,0x00,0x40,0x40,0x00,0x00,0x00};
int8 ca4[4][4]={0x00,0x20,0x40,0x80,0x0e,0x84,0x44,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
//b                 //d                 //c                 //e        
int8 ca4i[4][2]={0x00,0x00,0x00,0xe0,0xe0,0x00,0x00,0x00};
int8 ca3[4][4]={0x00,0x21,0x44,0x80,0x0f,0x84,0x44,0x24,0x04,0x00,0x40,0x11,0x00,0x01,0x00,0x00};
//b                 //d                 //c                 //e        
int8 ca3i[4][2]={0x00,0x00,0x00,0xf0,0xf0,0x08,0x01,0x00};
int8 ca2[4][4]={0x00,0x21,0x44,0x80,0x0f,0x84,0x44,0x24,0x04,0x00,0x40,0x11,0x00,0x01,0x00,0x00};
//b                 //d                 //c                 //e        
int8 ca2i[4][2]={0x00,0x00,0x00,0xf0,0xf0,0x08,0x01,0x00,};
int8 ca1[4][4]={0x00,0x20,0x40,0x80,0x0a,0x80,0x40,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
//b                 //d                 //c                //e
int8 ca1i[4][2]={0x00,0x00,0x00,0xa0,0xa0,0x00,0x00,0x00};
int8 ca5h[4][2]={0x00,0x00,0x04,0x04,0x00,0x00,0x00,0x00};
int8 ca4h[4][2]={0x00,0x40,0x0e,0x4e,0x00,0x00,0x00,0x00};
int8 ca3h[4][2]={0x00,0xe0,0x0f,0xef,0x04,0x04,0x00,0x00};
int8 ca2h[4][2]={0x00,0xe0,0x0f,0xef,0x04,0x04,0x00,0x00};
int8 ca1h[4][2]={0x00,0x00,0x0a,0x0a,0x00,0x00,0x00,0x00};
int t;
for(i=0;i<2;i++)
{
for(b=0;b<30;b++)
{  
porta=mul[5];
portb=ca1i[0][i];
portd=ca1i[1][i];
portc=ca1i[2][i];
porte=ca1i[3][i];
porta=mul[0];
delay_ms(ret);
porta=mul[5];
portb=ca2i[0][i];
portd=ca2i[1][i];
portc=ca2i[2][i];
porte=ca2i[3][i];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca3i[0][i];
portd=ca3i[1][i];
portc=ca3i[2][i];
porte=ca3i[3][i];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca4i[0][i];
portd=ca4i[1][i];
portc=ca4i[2][i];
porte=ca4i[3][i];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca5i[0][i];
portd=ca5i[1][i];
portc=ca5i[2][i];
porte=ca5i[3][i];
porta=mul[4];
delay_ms(ret);
}
}
for(t=0;t<=veces;t++)
{
for(a=0;a<12;a++)
{
for(i=0;i<4;i++)
{
for(b=0;b<10;b++)
{ 
porta=mul[5];
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porte=ca1[3][i];
porta=mul[0];
delay_ms(ret);
porta=mul[5];
portb=ca2[0][i];
portd=ca2[1][i];
portc=ca2[2][i];
porte=ca2[3][i];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca3[0][i];
portd=ca3[1][i];
portc=ca3[2][i];
porte=ca3[3][i];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][i];
portd=ca5[1][i];
portc=ca5[2][i];
porte=ca5[3][i];
porta=mul[4];
delay_ms(ret);
if(a==5 && b==0 && i==0)
{
for(e=0;e<3;e++)
{
for(c=0;c<2;c++)
{
for(d=0;d<15;d++)
{
porta=mul[5];
portb=ca1h[0][c];
portd=ca1h[1][c];
portc=ca1h[2][c];
porte=ca1h[3][c];
porta=mul[0];
delay_ms(ret);
porta=mul[5];
portb=ca2h[0][c];
portd=ca2h[1][c];
portc=ca2h[2][c];
porte=ca2h[3][c];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca3h[0][c];
portd=ca3h[1][c];
portc=ca3h[2][c];
porte=ca3h[3][c];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca4h[0][c];
portd=ca4h[1][c];
portc=ca4h[2][c];
porte=ca4h[3][c];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca5h[0][c];
portd=ca5h[1][c];
portc=ca5h[2][c];
porte=ca5h[3][c];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
}
}
}
}
}
}
} 
}
}
void ziza(int veces)
{
int8 ca4[4][5]={0x11,0x22,0x44,0x88,0x00,0x11,0x22,0x44,0x88,0x00,0x10,0x20,0x40,0x80,0x0f,0x00,0x00,0x00,0x00,0x01};
int8 mux[20]={0x08,0x10,0x10,0x10,0x10,0x04,0x08,0x10,0x10,0x10,0x02,0x04,0x08,0x10,0x10,0x01,0x02,0x04,0x08,0x10};
int8 mux1[35]={0x02,0x01,0x02,0x04,0x08,0x04,0x02,0x01,0x02,0x04,0x08,0x04,0x02,0x01,0x02,0x10,0x08,0x04,0x02,0x01,0x10,0x10,0x08,0x04,0x02,0x10,0x10,0x10,0x08,0x04,0x10,0x10,0x10,0x10,0x08};
for(d=0;d<=veces;d++)
{
int g=0;
//derecho
for(a=0;a<20;a++)
{
for(i=0;i<5;i++)
{
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mul[4];
delay_ms(ret);
}
}
for(a=0;a<4;a++)
{ 
for(b=0;b<10;b++)
{
for(i=0;i<5;i++)
{
c=i;
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mux[g+c];
delay_ms(ret);
}
if(b==9)
g=g+c+1;
}
}
g=0;c=0;
for(a=0;a<7;a++)
{ 
for(b=0;b<10;b++)
{
for(i=0;i<5;i++)
{
c=i;
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mux1[g+c];
delay_ms(ret);
}
if(b==9)
g=g+c+1;
}
}
g=0;c=0;
//inverso
for(a=0;a<20;a++)
{
for(i=0;i<5;i++)
{
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mul[4];
delay_ms(ret);
}
}
g=0;c=0;
for(a=0;a<7;a++)
{ 
for(b=0;b<10;b++)
{
for(i=0;i<5;i++)
{
c=i;
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mux1[30-g+c];
delay_ms(ret);
}
if(b==9)
g=g+c+1;
}
}
g=0;c=0;
for(a=0;a<4;a++)
{ 
for(b=0;b<10;b++)
{
for(i=0;i<5;i++)
{
c=i;
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mux[15-g+c];
delay_ms(ret);
}
if(b==9)
g=g+c+1;
}
}
}    
}
void piramide(int veces)
{
int8 ca5[4][3]={0x1f,0xe0,0x00,0x11,0xea,0x04,0xff,0x00,0x00,0x01,0x00,0x00};
//b           //d            //c             //e
for(b=0;b<veces;b++)
{
signed int x,y,z;
x=4;y=4;z=4;
for(d=0;d<18;d++)
{
for(a=0;a<9;a++)
{
porta=mul[5];
portb=ca5[0][0];
portd=ca5[1][0];
portc=ca5[2][0];
porte=ca5[3][0];
porta=mul[z];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][1];
portd=ca5[1][1];
portc=ca5[2][1];
porte=ca5[3][1];
porta=mul[y];
delay_ms(ret);
porta=mul[5];
portb=ca5[0][2];
portd=ca5[1][2];
portc=ca5[2][2];
porte=ca5[3][2];
porta=mul[x];
delay_ms(ret);
}
if(d==0)
{x=4;y=4;z=3;}
if(d==1)
{x=4;y=3;z=2;}
if(d>1 && d<=8)
{
z=z-1;
y=y-1;
x=x-1;
if(x<0)
{x=0;}
if(y<0)
{y=0;}
if(z<0)
{ z=0;}
}
if(d==9)
{z=1;y=0;x=0;}
if(d==10)
{z=2;y=1;x=0;}
if(d>10)
{
x++;y++;z++;
if(x>4)
{x=4;}
if(y>4)
{y=4;}
if(z>4)
{ z=4;}
}
}  
}
}
void heli(int veces)
{
int8 ca5[4][3]={0x00,0x00,0x00,0x00,0x40,0x04,0x40,0x00,0x00,0x00,0x00,0x00};
//b            //d            //c            //e
int8 ca4[4][3]={0x00,0x00,0x00,0x00,0x40,0x04,0x40,0x00,0x00,0x00,0x00,0x00};
//b            //d            //c            //e
int8 ca3[4][3]={0x00,0x00,0x00,0x00,0xf0,0x0f,0xf0,0x08,0x04,0x01,0x00,0x00};
//b            //d            //c            //e 
int8 ca2[4][3]={0x00,0x00,0x00,0x00,0x40,0x04,0x40,0x00,0x00,0x00,0x00,0x00};
//b            //d            //c            //e                
int8 ca1[4][3]={0x00,0x00,0x00,0x00,0x40,0x04,0x40,0x00,0x00,0x00,0x00,0x00};
//b            //d           //c             //e               
porta=0;      //Los inicializo en 0
portb=0;
portc=0;
portd=0;
porte=0;
for(i=0;i<2;i++)
{
for(a=0;a<30;a++)
{
porta=mul[5];
portb=ca5[0][i];
portd=ca5[1][i];
portc=ca5[2][i];
porte=ca5[3][i];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porte=ca4[3][i];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca3[0][i];
portd=ca3[1][i];
portc=ca3[2][i];
porte=ca3[3][i];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca2[0][i];
portd=ca2[1][i];
portc=ca2[2][i];
porte=ca2[3][i];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porte=ca1[3][i];
porta=mul[0];
delay_ms(ret);
}
}
for(d=0;d<=veces;d++)
{
for(c=0;c<12;c++)
{ 
int8 ca5421[4][4]={0x00,  0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};//elgiro
//b                       //d                     //c                      //e
int8 ca3[4][4]={0x80,  0x44, 0x21, 0x00, 0x24, 0x44, 0x84, 0x0f, 0x11, 0x40, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00};
//b                      //d                     //c                     //e
for(i=0;i<4;i++)
{
for(b=0;b<7;b++)
{
for(a=0;a<5;a++)
{ 
if (a!=2){
porta=mul[5];
portb=ca5421[0][i];
portd=ca5421[1][i];
portc=ca5421[2][i];
porte=ca5421[3][i];
porta=mul[a];
delay_ms(ret);}
else{
porta=mul[5];
portb=ca3[0][i];
portd=ca3[1][i];
portc=ca3[2][i];
porte=ca3[3][i];
porta=mul[a];
delay_ms(ret);}
}
}
}
}     
}
}       
void vuelta(int veces)
{
int8 fig1[2][1]={0x0f,0x01};
int8 fig2[2][1]={0x17,0x01}; 
int8 fig3[3][1]={0x11,0x11,0x10};
int8 fig4[2][1]={0x11,0x70};
int8 fig5[2][1]={0xf0,0x01};
int8 fig6[2][1]={0xcc,0x01};
int8 fig7[2][1]={0x0f,0x01};
int8 fig8[2][1]={0x0c,0x07};
for(d=0;d<=veces;d++)
{
for(i=0;i<1;i++)
{
for (b=0;b<8;b++)
{ 
for(c=0;c<7;c++)
{
for (a=0;a<5;a++)
{
if (b==0){
porta=mul[5];
portb=fig1[0][i];
portc=fig1[1][i];
porta=mul[a];
delay_ms(ret);}
if (b==1){  
porta=mul[5];
portb=fig2[0][i];
portd=fig2[1][i];
portc=0;
porta=mul[a];
delay_ms(ret);}
if (b==2){  
porta=mul[5];
portb=fig3[0][i];
portd=fig3[1][i];
portc=fig3[2][i];
porta=mul[a];
delay_ms(ret);}
if (b==3){  
porta=mul[5];
portb=0;
portd=fig4[0][i];
portc=fig4[1][i];
porta=mul[a];
delay_ms(ret);}
if (b==4){  
porta=mul[5];
portd=0;
portc=fig5[0][i];
porte=fig5[1][i];
porta=mul[a];
delay_ms(ret);}
if (b==5){  
porta=mul[5];
portc=fig6[0][i];
porte=fig6[1][i];
porta=mul[a];
delay_ms(ret);}
if (b==6){  
porta=mul[5];
portc=fig7[0][i];
porte=fig7[1][i];
porta=mul[a];
delay_ms(ret);}
if (b==7){  
porta=mul[5];
portb=fig8[0][i];
portc=fig8[1][i];
porte=0;
porta=mul[a];
delay_ms(ret);} 
}
}
}
}
}
}
void vortix()
{
int8 ca1[4]={0xa4,0xa5,0x44, 0x00};
//b  //d  //c   //e
int8 ca2[2]={0x12,0x88};
//b //c 
int8 ca3[2]={0x01,0x01};
int x,y,z;
for(a=0;a<6;a++)
{
//9
porta=mul[5];
portb=ca1[0];
portd=ca1[1];
portc=ca1[2];
porte=ca1[3];
porta=mul[0];
delay_ms(ret);
//4
porta=mul[5];
if(a==0 || a==1)
portb=ca2[0];
if(a==0)
portc=ca2[1];
porta=mul[1];
delay_ms(ret);
//2
porta=mul[5];
portb=ca2[0];
porte=ca2[1];
porta=mul[2];
delay_ms(ret);
}
}
void moneda()
{
int8 ca5[3][4]={0,0,0x10,0x0e,   0,0,0x11,0,    0x0e,0xe0,0,0};
int8 ca4[3][4]={0x08,0,0x02,0x10,   0,0x10,0,0, 0x80,0x08,0x20,0x02};
int8 ca3[3][4]={0x04,0,0x04,0,   0,0x01,0,0x01, 0x40,0x04,0x40,0x04};
int8 ca2[3][4]={0x02,0x10,0x08,0,   0,0,0,0x10, 0x20,0x02,0x80,0x08}; 
int8 ca1[3][4]={0x10,0x0e,0,0,   0x11,0,0,0,  0,0,0x0e,0xe0};
int8 ca6[3]={0x1e,0x11,0xee};
for(a=0;a<10;a++)
{
porta=0;      //Los inicializo en 0
portb=0;
portc=0;
portd=0;
porte=0;
for(i=0;i<4;i++)
{
for(c=0;c<10;c++)
{
porta=mul[5];
portb=ca5[0][i];
portd=ca5[1][i];
portc=ca5[2][i];
porta=mul[4];
delay_ms(ret);
porta=mul[5];
portb=ca4[0][i];
portd=ca4[1][i];
portc=ca4[2][i];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca3[0][i];
portd=ca3[1][i];
portc=ca3[2][i];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca2[0][i];
portd=ca2[1][i];
portc=ca2[2][i];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porta=mul[0];
delay_ms(ret);
}
}
}
//caida
for(d=0;d<4;d++)
{
for(c=0;c<200;c++)
{
porta=mul[5];
portb=ca6[0];
portd=ca6[1];
portc=ca6[2];
porta=mul[4];
delay_ms(ret);
}
}
}
void cubito()
{
int8 pbd[4]={0x33,0x66,0xcc,0x88};
int8 pbdc[4]={0x30,0x60,0xc0,0x80};
int8 pc[8]={0x03,0x06,0x0c,0x08};
for(i=0;i<3;i++)
{
for(a=0;a<30;a++)
{
porta=mul[5];
portb=pbd[i];
porta=mul[4];
delay_ms(ret);
porta=mul[3];
delay_ms(ret);
}
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=pbd[3];
portc=pc[0];
porta=mul[4];
delay_ms(ret);
porta=mul[3];
delay_ms(ret);
} 
for(a=0;a<30;a++)
{
porta=mul[5];
portb=pbdc[3];
portc=pc[1];
portd=pc[3];
porta=mul[4];
delay_ms(ret);
porta=mul[3];
delay_ms(ret);
}
portb=0;
for(a=0;a<30;a++)
{
porta=mul[5];
portc=pc[2];
portd=pbd[3];
porta=mul[4];
delay_ms(ret);
porta=mul[3];
delay_ms(ret);
}
for(a=0;a<30;a++)
{
porta=mul[5];
portc=pbd[3];
portd=pbdc[3];
porte=0x01;
porta=mul[4];
delay_ms(ret);
porta=mul[3];
delay_ms(ret);
}
porte=0;
for(i=0;i<3;i++)
{
for(a=0;a<30;a++)
{
porta=mul[5];
portd=pbdc[2-i];
portc=pbdc[2-i];
porta=mul[4];
delay_ms(ret);
porta=mul[3];
delay_ms(ret);
}
}   
for(i=0;i<3;i++)
{
for(a=0;a<30;a++)
{
porta=mul[5];
portd=pbdc[0];
portc=pbdc[0];
porta=mul[3-i];
delay_ms(ret);
porta=mul[2-i];
delay_ms(ret);
}
}   
portc=0;
for(a=0;a<30;a++)
{
porta=mul[5];
portd=pbd[0];
porta=mul[0];
delay_ms(ret);
porta=mul[1];
delay_ms(ret);
}
for(i=0;i<3;i++)
{ 
for(a=0;a<30;a++)
{
porta=mul[5];
portb=pbdc[i];
portd=pc[i];
porta=mul[0];
delay_ms(ret);
porta=mul[1];
delay_ms(ret);
}
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=pbdc[3];
portc=pc[1];
portd=pc[3];
porta=mul[0];
delay_ms(ret);
porta=mul[1];
delay_ms(ret);
}
for(a=0;a<30;a++)
{
porta=mul[5];
portb=pbd[3];
portc=pc[0];
porta=mul[0];
delay_ms(ret);
porta=mul[1];
delay_ms(ret);
} 
portd=0;portc=0;
}
void girox(int veces)
{
int8 ca1[3][4]={0x0f,0x00,0x00,0x00,0x00,0x0f,0x00,0x00,0x01,0x04,0xf0,0x00};
//b                 //d                 //c
int8 ca2[3][4]={0xf0,0x00,0x00,0x00,0x00,0x0f,0xf0,0x00,0x02,0x04,0x08,0x00};
//b                 //d                 //c
int8 ca3[3][4]={0x00,0x00,0x00,0xff,0x0f,0x0f,0x0f,0xff,0x00,0x00,0x00,0xff};
//b                 //d                 //c
int8 pe[4]={0x01,0x00,0x00,0x00};
for(d=0;d<=veces;d++)
{
for(i=0;i<4;i++)
{
for(b=0;b<8;b++)
{
porta=mul[5];
portb=ca1[0][i];
portd=ca1[1][i];
portc=ca1[2][i];
porta=mul[0];
delay_ms(ret);
porta=mul[5];
portb=ca2[0][i];
portd=ca2[1][i];
portc=ca2[2][i];
porta=mul[1];
delay_ms(ret);
porta=mul[5];
portb=ca3[0][i];
portd=ca3[1][i];
portc=ca3[2][i];
porta=mul[2];
delay_ms(ret);
porta=mul[5];
portb=ca2[0][2-i];
portd=ca2[1][2-i];
portc=ca2[2][2-i];
porta=mul[3];
delay_ms(ret);
porta=mul[5];
portb=ca1[0][2-i];
portd=ca1[1][2-i];
portc=ca1[2][2-i];
porte=pe[i];
porta=mul[4];
delay_ms(ret);
}
}
}
}
void intermitente(int veces)
{
for(b=0;b<=veces;b++)
{
portb=0xff;
portd=0xff;
portc=0xff;
porte=0x01;
for(a=0;a<100;a++)
{
for(i=0;i<5;i++)
{
porta=mul[i];
delay_ms(15);        
}
}
}
}
void flamitas(int veces)
{
int8 flab[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
int8 flad[8]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
for(e=0;e<=veces;e++)
{
c = rand() % 8;
d = rand() % 8;
b = rand() % 8;
portb=flab[c];
portd=flad[d];
portc=flad[b];
for(a=0;a<20;a++)
{
for(i=0;i<5;i++)
{
porta=mul[i];
delay_ms(ret);
}
}
}
}
void main()
{//Inicio del principal
set_tris_a(0);// pongo puertos como salidas
set_tris_b(0);
set_tris_c(0);
set_tris_d(0);
set_tris_e(0);
set_tris_e(0x06);
// 1 = Para ponerlo como analogico
// 0 = Para ponerlo como digital
//                           bit ->   7     6     5     4     3     2     1     0
//Registro ANSEL -> AN7 AN6 AN5 AN4 AN3   --    --    --
ANSEL = 0x80; //10000000 Ponemos únicamente el AN7 a analógico, ver datasheet 
ANSELH = 0;
//setup_adc_ports(ALL_ANALOG); //Entradas analogas
setup_adc(adc_clock_internal);//Habilito el reloj interno de la conversion
porta=0;      //Los inicializo en 0
portb=0;
portc=0;
portd=0;
porte=0;
while(true)
{//Inicio while
//vuelta(1);
if(bit_test(porte,1))
{
set_adc_channel(7); //especifico q usare el puerto RA5
delay_ms(2);
sound=read_adc();
if(sound>710)
{
sec = rand() % 14;
switch(sec)
{
case 0:
moneda();
break; 
case 1:
rotation(0);
break;
case 2:
heli(0);
break;
case 3:
giro(5);
break;
case 4:
girox(5);
break;
case 5:
subir(0);
break;
case 6:
adn(5);
break;
case 7:
heart(0);
break;
case 8:
ziza(1);
break;          
case 9:
piramide(1);
break;  
case 10:
vuelta(1);
break;  
case 11:
cubito();
break;            
case 12:
intermitente(0);
break; 
case 13:  flamitas(10);
break;
}
porta=0;      //Los inicializo en 0
portb=0;
portc=0;
portd=0;
porte=0;
}
}
if(!bit_test(porte,1))
{
sec = rand() % 14;
switch(sec)
{
case 0:
moneda();
break; 
case 1:
rotation(1);
break;
case 2:
heli(1);
break;
case 3:
giro(5);
break;
case 4:
girox(5);
break;
case 5:
subir(0);
break;
case 6:
adn(5);
break;
case 7:
heart(0);
break;
case 8:
ziza(1);
break;          
case 9:
piramide(3);
break;  
case 10:
vuelta(5);
break;  
case 11:
cubito();
break;            
case 12:
intermitente(1);
break; 
case 13:  flamitas(10);
break;
}
}
}// Fin while
}//Fin del principal

[/sociallocker]

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.

Volver al Curso de Microcontroladores PIC

Sergio A. Castaño Giraldo

Mi nombre es Sergio Andres Castaño Giraldo, y en este sitio web voy a compartir una de las cosas que mas me gusta en la vida y es sobre la Ingeniería de Control y Automatización. El sitio web estará en constante crecimiento, voy a ir publicando material sobre el asunto desde temas básicos hasta temas un poco más complejos. Suscríbete al sitio web, dale me gusta a la página en Facebook y únete al canal de youtube. Espero de corazón que la información que comparto en este sitio, te pueda ser de utilidad. Y nuevamente te doy las gracias y la bienvenida a control automático educación.