4 x 4 x 4 cubo del LED con Charlieplexing (5 / 6 paso)

Paso 5: Código II

Este paso es sólo el código de C escrito para aquellos que no quieren descargar el archivo zip en el último paso o este paso (mismo código).

#include < avr/io.h >
#include < util/delay.h >
#include < stdlib.h >

int rn;
r64 int;
int r48;
int r32;
int r16;

es corto (-) cátodo (c), ánodo (a) es más largo (+) llevar
cátodo <------> capa 1 <------> capa 2 <------> capa 3 <------> capa 4
int c [] = {2,3,4,5 1,3,4,5, 1,2,4,5, 1,2,3,5, 6,7,8,9, 6,7,8,9, 6,7,8,9, 6,7,8,9, 1,2,3,4, 1,2,3,4, 1,2,3,4, 1,2,3,4, 6,7,8,9, 5,7,8,9, 5,6,8,9, 5,6,7,9};

ánodo de <------> capa 1 <------> capa 2 <------> capa 3 <------> capa 4
int a [] = {1,1,1,1 2,2,2,2, 3,3,3,3, 4,4,4,4, 1,1,1,1, 2,2,2,2, 3,3,3,3, 4,4,4,4, 5,5,5,5, 6,6,6,6, 7,7,7,7, 8,8,8,8, 5,5,5,5, 6,6,6,6, 7,7,7,7, 8,8,8,8};

anular el retardo (ms int) / / hay que escribir nuestra propia función de retraso puesto que _delay_ms(int) sólo acepta constantes (no podemos pasar una variable a él)
{
para (int i = 0; i < = ms; i ++)
{
_delay_ms(1);   en milisegundos
}
}

int principal (vacío)
{
RN = 642563;  la semilla aleatoria
DDRD = 0X00000000;
DDRB = 0X00000000;
PORTD = 0X00000000;
PORTB = 0X00000000;
while(1)
{
LineSpin(20,1,1);
LineSpin(16,1,1);
LineSpin(12,1,1);
LineSpin(8,1,1);
LineSpin(6,1,2);
LineSpin(5,1,2);
LineSpin(4,1,3);
LineSpin(3,1,3);
LineSpin(2,1,4);
LineSpin(1,1,8);

Scroll(75);
Scroll(50);
Scroll(25);
Scroll(10);
Scroll(3);

drawBox(100,40); multiplicar los inputs para obtener el tiempo en ms

Spin(1,60);
Spin(1,40);
Spin(1,30);
Spin(1,20);
Spin(1,15);
Spin(1,10);
Spin(1,8);
Spin(1,6);
Spin(1,5);
Spin(1,4);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);
Spin(1,3);

lluvia (100, 100, 16);

Snake_x(2,1,100);
Snake_x(2,14,60);
Snake_x(2,16,40);
Snake_x(2,18,20);
Snake_x(2,10,10);

layerPattern(50);
layerPattern(100);

FlashOn(0,0,16);
FlashOn(1,1,10);
FlashOn(10,1,6);

randomGen();
randomGen();
randomGen();
randomGen();
randomGen();
randomGen();
}
return 0;
}

OP pide las coordenadas de lo LED de las matrices indexadas arriba
void op (int n) {}
DDRD = 0X00000000;
DDRB = 0X00000000;
PORTD = 0X00000000;
PORTB = 0X00000000;
int cn = ((c[n-1])-1);
int un = ((a[n-1])-1);
---cátodos
if(CN==8)
{DDRB = _BV(DDB0);
PORTB = _BV(PORTB0);
}
otra cosa
{DDRD = _BV(cn);
PORTD = _BV(cn);
}
---los ánodos
if(an==8) {DDRB | = _BV(an);}
Else {DDRD | = _BV(an);}
}

void allOff()
{/ / se ilumina pins 1-9 off (esto significa que todos los pines utilizados son off)
PORTB & = 0;
PORTD y = 0;
DDRB = 0X00000000; ENTRADA pinMode para todo Puerto
DDRD = 0X00000000; ENTRADA pinMode para todo Puerto
}

FlashOn (int refresh_rate, int dark_time, int ciclos)
{
allOff();
Delay(dark_time);
para (int c = 0; c < ciclos; c ++)
{
para (int i = 1; i < 65; i ++)
{
OP(i);
Delay(refresh_rate);
}
}
}

---algoritmos de dibujos---
void boxFrame(v) {//rasters un marco del alambre de la caja
int lista [40] = {1,2,3,4, 5, 8, 9,12, 13,14,15,16,
17.20, 29,32,
33,36, 45,48,
49,50,51,52 53,56, 57,60, 61,62,63,64};
para (int i = 0; i < 41; i ++) {}
OP(list[i]);
para (int t = 0; t < v; t ++)
_delay_us(10);
}
}

capa patrones (AKA rebanada (z))
void sz1() {/ / se enciende para arriba la capa inferior
para (int i = 1; i < 17; i ++) {}
OP(i);
}
}
void sz2() {/ / se enciende para arriba la capa 2
para (int i = 17; i < 33; i ++) {}
OP(i);
}
}
void sz3() {/ / se enciende para arriba la capa 3
para (int i = 33; i < 49; i ++) {}
OP(i);
}
}
void sz4() {/ / se enciende para arriba la 4ta capa
para (int i = 49; i < 65; i ++) {}
OP(i);
}
}

patrones de corte (x)
void sx1() {/ / enciende el x 1 rebanada (nuevo)
int lista [16] = {1,2,3,4, 17,18,19,20, 33,34,35,36 49,50,51,52};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}
void sx2() {/ / se enciende para arriba la 2ª x rebanada
int lista [16] = {5,6,7,8, 21,22,23,24, 37,38,39,40, 53,54,55,56};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}
void sx3() {/ / se enciende para arriba la 3ra x rebanada
int lista [16] = {9,10,11,12 25,26,27,28, 41,42,43,44, 57,58,59,60};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}
void sx4() {/ / se enciende para arriba el x 4 rebanada (delantero)
int lista [16] = {13,14,15,16 29,30,31,32, 45,46,47,48, 61,62,63,64};
para (int i = 0; i < 16; i ++) {}
OP(list[i]);
}
}

patrones de corte (y)
void sy1() {/ / se enciende el segmento y 1 (izquierda)
para (int i = 0; i < 64; i = i + 4) {}
OP(i);
}
}
void sy2() {/ / se enciende el segmento y 2 º
para (int i = 1; i < 64; i = i + 4) {}
OP(i);
}
}
void sy3() {/ / se enciende el 3er segmento y
para (int i = 2; i < 64; i = i + 4) {}
OP(i);
}
}
void sy4() {/ / se enciende el segmento y 4 º (derecha)
para (int i = 3; i < 64; i = i + 4) {}
OP(i);
}
}

lluvia
{} void lluvia (int dur, int inidur, int ciclos)

srand(RN);
RN = ((rn*13) %7) + 1;
para (int i = 0; i < ciclos; i ++)
{
R64 = (rand () % 16) 49;
R48 = r64-16;
R32 = r48-16;
R16 = r32-16;
OP(R64);
Delay(inidur); Usted puede tener pausa extra larga en la primera luz si quieres con inidur.
OP(R48);
Delay(Dur);
OP(R32);
Delay(Dur);
OP(R16);
Delay(Dur);
}
}

al azar (genera un campo oscilante al azar nebuloso de la luz)
void randomGen() {}
srand(RN);
para (int i = 0; i < 10; i ++) {}
int r = (rand () % 64) + 1;
OP(r);
Delay(100);
}
RN ++;
}

girar alrededor del eje z
void spin11 (int v) {}
int base [8] = {6,11 22.27, 38,43, 54,59}; parte superior izquierda e inferior derecha de cada rebanada
int externa [8] = {oído-pedacito de 1.16, 17.32, 33,48, 49,64};    esquina superior izquierda e inferior derecha
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin12 (int v) {}
int base [8] = {6,11 22.27, 38,43, 54,59};
int externa [8] = {2.15 18,31, 34,47, 50,63};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin21 (int v) {}
int base [8] = {7,10, 23,26, 39,42, 55,58};
int externa [8] = {3,14, 19,30, 35,46, 51,62};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin22(int v) {/ / la parte superior derecha e inferior izquierda esquinas
int base [8] = {7,10, 23,26, 39,42, 55,58};
int externa [8] = {4,13 20,29, 36,45, 52,61};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin23 (int v) {}
int base [8] = {7,10, 23,26, 39,42, 55,58};
int externa [8] = {8,9, 24,25, 40,41, 56,57};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}
void spin13 (int v) {}
int base [8] = {6,11 22.27, 38,43, 54,59};
int externa [8] = {5,12 21,28, 37,44, 53,60};
para (int t = 0; t < v; t ++) {}
para (int i = 0; i < 8; i ++) {}
OP(Core[i]);
_delay_us(500);
OP(outer[i]);
_delay_us(500);
}
}
}

// ------------------ programs ---------------------------------------------
void girar (giros int, int v) {}
para (int i = 0; i < giros; i ++) {}
spin11(v);
spin12(v);
spin21(v);
spin22(v);
spin23(v);
spin13(v);
}
}

desplazamiento vacío (int v) {/ / uno por uno, {encender, esperar, off} cada LED en orden
para (int n = 1; n < 65; n ++) {}
OP(n);
Delay(v);      esperar milisegundos v antes rastering siguiente LED
}
}

{} void allOn (ciclos de int, int delaytime)
para (int i = 0; i < ciclos; i ++) {}
para (int n = 1; n < 65; n ++) {}
OP(n);
para (int t = 0; t < delaytime; t ++)
_delay_us(1);
}
}
}

void drawBox (ciclos de int, int v) {/ / v es retraso en 10 micro segundos
para (int i = 0; i < ciclos; i ++) {}
boxFrame(v);
}
}

void layerZup (int v) {/ / más alto v = más lento
para (int t = 0; t < v; t ++) {sz1();}
para (int t = 0; t < v; t ++) {sz2();}
para (int t = 0; t < v; t ++) {sz3();}
para (int t = 0; t < v; t ++) {sz4();}
}
void layerZdown (int v) {}
para (int t = 0; t < v; t ++) {sz4();}
para (int t = 0; t < v; t ++) {sz3();}
para (int t = 0; t < v; t ++) {sz2();}
para (int t = 0; t < v; t ++) {sz1();}
}
void layerYup (int v) {}
para (int t = 0; t < v; t ++) {sy1();}
para (int t = 0; t < v; t ++) {sy2();}
para (int t = 0; t < v; t ++) {sy3();}
para (int t = 0; t < v; t ++) {sy4();}
}
void layerYdown (int v) {}
para (int t = 0; t < v; t ++) {sy4();}
para (int t = 0; t < v; t ++) {sy3();}
para (int t = 0; t < v; t ++) {sy2();}
para (int t = 0; t < v; t ++) {sy1();}
}
void layerXup (int v) {}
para (int t = 0; t < v; t ++) {sx1();}
para (int t = 0; t < v; t ++) {sx2();}
para (int t = 0; t < v; t ++) {sx3();}
para (int t = 0; t < v; t ++) {sx4();}
}
void layerXdown (int v) {}
para (int t = 0; t < v; t ++) {sx4();}
para (int t = 0; t < v; t ++) {sx3();}
para (int t = 0; t < v; t ++) {sx2();}
para (int t = 0; t < v; t ++) {sx1();}
}

void layerPattern (int v) {/ / más alto v = velocidad más lenta de capa de cambio
layerZdown(v);
layerZup(v);
layerYdown(v);
layerYup(v);
layerXdown(v);
layerXup(v);
}

LineSpin (int dur, int dt, int ciclos)
{
para (int c = 0; c < ciclos; c ++)
{
int spin_x [] = {1,5,9,13,14,15,16,12,8,4,3,2};
para (int a = 1; a < 13; a ++)
{
para (int t = 0; t < dur; t ++)
{
OP(spin_x[a]);
Delay(DT);
OP(spin_x[a]+16);
Delay(DT);
OP(spin_x[a]+32);
Delay(DT);
OP(spin_x[a]+48);
Delay(DT);
}
}
}
}

Snake_x (capa int, int ciclos, velocidad de int) / / válido capa 1,2,3,4
{
int start_led = (16 * capa) - 15;
int x[] = {1,5,9,13,14,15,16,12,8,4,3,2};
srand(RN);
int r = rand () % 100;
int current_layer = capa;
para (int c = 0; c < ciclos; c ++)
{
para (int i = 1; i < 13; i ++)
{
Si ((r < 20) & & (current_layer! = 1))
{
current_layer--;
}
else if ((r > 80) & & (current_layer! = 4))
{
current_layer ++;
}

OP(x[i]+(16*(current_layer-1)));

Delay(Speed);
r = rand () % 100;
}
}
}

Artículos Relacionados

4 x 4 x 4 interactivo-cubo del LED con Arduino

4 x 4 x 4 interactivo-cubo del LED con Arduino

para explicar mi 4 x 4 x 4 cubo del LED interactivo publicado antes, un poco más claro, voy a intentar hacer mi primer paso por paso instructable.Este 4 x 4 x 4 cube es interactivo usando la esquina de cuatro LEDs LEDs y sensores que reaccionan a la
Cubo del LED con Arduino y PCB personalizado

Cubo del LED con Arduino y PCB personalizado

este instructivo detalla el diseño y construcción de proceso para un 5 x 5 x 5 cubo del LED, controladas con un Arduino, que reside en un tablero de circuito impreso personalizado.Videos, fotos e información adicional pueden encontrarse en mi sitio w
3 x 3 x 3 cubo del LED con Arduino Lib

3 x 3 x 3 cubo del LED con Arduino Lib

hay otros Instructables sobre la construcción de cubos de LED, éste es diferente por varias razones:1. se construye con un bajo número de componentes estándares y ganchos directamente a Arduino.2. una clara, fácil de reproducir circuito diagrama está
4 x 4 x 4 cubo del LED, con MSP430, utilizando sólo 3 pines

4 x 4 x 4 cubo del LED, con MSP430, utilizando sólo 3 pines

este es mi 4 x 4 x 4 cubo led proyecto, realizado con MSP430, usando solo 3 pines del MSP, el diagrama del circuito se muestra en las fotos, el hardware consta de cambio de 3 registros, transistores NPN 74595 y 4...Usted puede aprender cómo hacer un
Cubo del LED con 3D impreso base

Cubo del LED con 3D impreso base

Se trata de un cubo de LED normal. Sólo su base es algo especial. Lo imprimí con mi impresora 3D.Paso 1: partesEste cubo Led está inspirado en el cubo de LED de GreatScottLab. Había diseñado una nueva base para este cubo. GreatScottLab puede explicar
3 x 3 x 3 cubo del LED Arduino-UNO

3 x 3 x 3 cubo del LED Arduino-UNO

¿Es interés para hacer tu propio 3 x 3 x 3 cubo del LED???Es usted principiante no importaQue sigues los pasos correctos. Es simple y fácil.Permítame mostrarle cómo!!!!!!Paso 1: Qué necesitas1 uno de x Arduino27 x LED (usar 3 colores, 9 de cada color
Cubo del LED 3 x 3 x 3 con la música beat detección - PIC16F84

Cubo del LED 3 x 3 x 3 con la música beat detección - PIC16F84

cubos LED son grandes por sí mismos sin embargo decidí condimentar con sincronización de beats de música. Se trata de un 3 x 3 x 3 cubo del LED con un PIC 16F84A funcionando a 4MHz.La detección de beat real se realiza en hardware por un amplificador
4 x 4 x 4-cubo del LED basado en Arduino y flor protoboard

4 x 4 x 4-cubo del LED basado en Arduino y flor protoboard

este instructable le mostrará cómo construir tu 4 x 4 x 4 cubo del LED con control de Arduino y ProtoBoard de flor . ¿Por qué es flor ProtoBoard? ¿no ProtoBoard?Debido a menudo usar protoboards para probar si una idea nueva funciona en la práctica. Y
UberCube X 4 - el cubo del LED sobremesa

UberCube X 4 - el cubo del LED sobremesa

siempre quise construir cubos de LED, pero me tomó un tiempo para entender cómo hacer uno que es bueno mirar y sirve como una pieza decorativa en mi banco de trabajo. Por lo tanto, hice un simple 4 x 4 x 4 cubo del LED con el microcontrolador MSP430
BRICOLAJE | 3 x 3 x 3 cubo del LED para Arduino Nano +

BRICOLAJE | 3 x 3 x 3 cubo del LED para Arduino Nano +

Hi todo el mundo!Mi nombre es RGBFreak y he creado un canal en YouTube hace poco.Me encanta el bricolaje y me gusta sobre todo LED, por lo que decidí hacer mi propia 3 x 3 x 3 cubo del LED!Usted necesitará los siguientes elementos para hacer este cub
TBLC (cubo del LED de la caja de la lata)

TBLC (cubo del LED de la caja de la lata)

Mientras limpiar en casa encontré una caja de Altoids, hey cool pensaba porque a menudo leer lo que otras personas han hecho con él. Kits de supervivencia, Radio's y así sucesivamente. Hay incluso lugares donde se pueden comprar "Cajas de lata"
5 x 5 x 5 cubo del LED funcionar con Arduino Uno

5 x 5 x 5 cubo del LED funcionar con Arduino Uno

Hola amigos, esta es mi opinión sobre un 5 x 5 x 5 cubo del LED, permite comenzar.Lo primero que debemos hacer es conseguir todos nuestros suministros.Vamos a necesitar...:125 LEDs (Asegúrese de que son rojo o amarillo o el arduino no será capaz de e
El 4 x 4 x 4 cubo del LED (Arduino)

El 4 x 4 x 4 cubo del LED (Arduino)

en este instructable le mostraré cómo hacer un 4 x 4 x 4 cubo del LED que será controlado por un Arduino Demulionove. ahora sí que podríamos decir"que Arduino tiene sólo 14 pines I/O bien también los pines analógicos 6 puede utilizarse como pernos de
Cubo del LED RGB infinito

Cubo del LED RGB infinito

El 8 x 8 x 8 LED cubo proyecto publicado en la Web de Instructables era muy detallada y todavía parecía lo suficientemente simple como para mí no sólo a completar pero añade sustanciales mejoras así.Siguiente es un tutorial sobre cómo construí mi 8 x