8 x 8 x 8 LED cubo con Arduino Mega (+ sonido + PS controlador + juego) (8 / 11 paso)

Paso 8: Programm (effekte Arduino Mega)

Este es un ejemplo del código (efectos)
encontrar el código completo (y actual) en el último paso

void loop()
{
int i, x, y, z;

mientras que (gamechoice == 0)
{

effect_count_up(); AZ
effect_count_thru(); AZ

effect_text(1000,0,13);
effect_text_up(5000,0,6);

effect_rain(50);

effect_random_filler(75,1);
effect_random_filler(75,0);

effect_planboing (AXIS_Z, 400);
effect_planboing (AXIS_Y, 400);
effect_planboing (AXIS_X, 400);

effect_boxside_randsend_parallel (AXIS_X, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_X, 1, 150, 1);
effect_boxside_randsend_parallel (AXIS_Y, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_Y, 1, 150, 1);
effect_boxside_randsend_parallel (AXIS_Z, 0, 150, 1);
effect_boxside_randsend_parallel (AXIS_Z, 1, 150, 1);
effect_fireworks(10,30,500);
effect_intro();
sinelines(4000,10);
linespin(1500,10);
mirror_ripples(600,400);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,1);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_Z, 550,5000,1);
effect_axis_updown_randsuspend (AXIS_X, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_X, 550,5000,1);
effect_axis_updown_randsuspend (AXIS_Y, 550,5000,0);
effect_axis_updown_randsuspend (AXIS_Y, 550,5000,1);
side_ripples (300, 500);
effect_random_sparkle();
quad_ripples (600.300);

box_filled(2,2,2,5,5,5);
box_walls(2,2,2,5,5,5);
box_wireframe(2,2,2,5,5,5);

}
}

// ==========================================================================================
Funciones de los efectos
// ==========================================================================================

void draw_positions_axis (eje de char, unsigned char posiciones [64], int invertido)
{
int x, y, p;

Fill(0x00);

para (x = 0; x < 8; x ++)
{
para (y = 0; y < 8; y ++)
{
Si (invertir)
{
p = (7-positions[(x*8)+y]);
} else
{
p = posición [(x*8) + y];
}

Si (eje == AXIS_Z)
setvoxel(x,y,p);

Si (eje == AXIS_Y)
setvoxel(x,p,y);

Si (eje == AXIS_X)
setvoxel(p,y,x);
}
}

}

effect_count_up (AZ).
void effect_count_up)
{
int i, ii, iii;
int x;
int y;
int z;

Fill(0x00);
para (i = 0; i < 8; i ++)
{
Si (i < = 0)
{
x = 0;
y = 0;
z = 0;
}
para (ii = 0; ii < 8; ii ++)
{

para (iii = 0; iii < 7; iii ++)
{
setvoxel(x,y,z);
delay_ms(500);
z = z ++;
}
setvoxel(x,y,z);
delay_ms(500);
y = y ++;
z = 0;
}

setvoxel(x,y,z);
delay_ms(500);
x = x ++;
y = 0;
}
}

effect_count_thru (AZ).
void effect_count_thru)
{
int i, ii, iii;
int x;
int y;
int z;

Fill(0x00);
para (i = 0; i < 8; i ++)
{
Si (i < = 0)
{
x = 0;
y = 0;
z = 0;
}
para (ii = 0; ii < 8; ii ++)
{

para (iii = 0; iii < 7; iii ++)
{
setvoxel(x,y,z);
delay_ms(1000);
clrvoxel(x,y,z);
z = z ++;
}
setvoxel(x,y,z);
delay_ms(1000);
clrvoxel(x,y,z);
y = y ++;
z = 0;
}

setvoxel(x,y,z);
delay_ms(1000);
clrvoxel(x,y,z);
x = x ++;
y = 0;
}
}

void effect_text_up (int delayt, int primero, int ultimo) {}

const int charNum = 6;
char cadena [charNum] = {'S', 'U', 'P', 'E', 'R'};

Fill(0x00);
para (int litros = primero; ltr < último; ltr ++) {/ / para cada letra en la matriz de cadenas
para (dist int = 0; dist < 8; dist ++) {Carta de //bring adelante
relleno (0 x 00), cubo de //blank
rev int = 0;
para (int rw = 7; rw > = 0; rw--) {//copy filas
poner esto en para mal alambrado hacia atrás cubo: cubo [rev] [dist] = bitswap(font_data[string[ltr]][rw]);
Cube [rev] [dist] = font_data [string [litros]] [rw];
Cube [dist] [rev] = fuente [cadena [litros]] [rw];
utilizar por encima de la línea de cubos adecuados
Rev ++;
}
delay_ms(delayt);
}
}
}

void effect_text (int delayt, int primero, int ultimo) {}

const int charNum = 13;
char cadena [charNum] = {'P', 'r', 'e', de ', de ',' ', de ', ' t ', 'a', 'r', ' t ','! ',' '};

Fill(0x00);
para (int litros = primero; ltr < último; ltr ++) {/ / para cada letra en la matriz de cadenas
para (dist int = 0; dist < 8; dist ++) {Carta de //bring adelante
Fill(0x00); cubo en blanco
rev int = 0;
para (int rw = 7; rw > = 0; rw--) {//copy filas
poner esto en cubo normal:
Cube [rev] [dist] = bitswap(font[string[ltr]][rw]);
Cube [rev] [dist] = fuente [cadena [litros]] [rw];
Cube [dist] [rev] = fuente [cadena [litros]] [rw];
utilizar por encima de la línea de cubos de culo hacia atrás
Rev ++;
}
delay_ms(delayt);
}
}
}

void effect_boxside_randsend_parallel (char eje, int origen, int retardo, int modo)
{
int i;
int hecha;
unsigned char cubepos [64];
unsigned char pos [64];
notdone int = 1;
int notdone2 = 1;
Enviado int = 0;

para (i = 0; i < 64; i ++)
{
pos [i] = 0;
}

mientras (notdone)
{
Si (modo == 1)
{
notdone2 = 1;
mientras que (notdone2 & & enviado < 64)
{
i = rand () % 64;
Si (pos [i] == 0)
{
Enviado ++;
pos [i] += 1;
notdone2 = 0;
}
}
} else if (modo == 2)
{
Si (enviado < 64)
{
pos [enviados] += 1;
Enviado ++;
}
}

= 0;
para (i = 0; i < 64; i ++)
{
Si (pos [i] > 0 & & pos [i] < 7)
{
pos [i] += 1;
}

Si (pos [i] == 7)
hecho ++;
}

Si (== 64)
notdone = 0;

para (i = 0; i < 64; i ++)
{
Si (origen == 0)
{
cubepos [i] = pos [i];
} else
{
cubepos [i] = (7-pos[i]);
}
}

delay_ms(Delay);
draw_positions_axis(Axis,cubepos,0);

}

}

void effect_rain (int iteraciones)
{
int i, ii;
int rnd_x;
int rnd_y;
int rnd_num;

para (ii = 0; ii {}
rnd_num = rand () %4;

para (i = 0; i < rnd_num; i ++)
{
rnd_x = rand () %8;
rnd_y = rand () %8;
setvoxel(rnd_x,rnd_y,7);
}

delay_ms(1500);
Shift(AXIS_Z,-1);
}
}

Establecer o borrar exactamente 512 voxels en un orden aleatorio.
void effect_random_filler (int retardo, int estado)
{
int x, y, z;
int bucle = 0;

Si (estado == 1)
{
Fill(0x00);
} else
{
Fill(0xFF);
}

mientras que (lazo < 511)
{
x = rand () %8;
y = rand () %8;
z = rand () %8;

Si ((estado == 0 & & getvoxel(x,y,z) == 0 x 01) || (estado == 1 & & getvoxel(x,y,z) == 0 x 00))
{
altervoxel(x,y,z,State);
delay_ms(Delay);
bucle ++;
}
}
}

Dibujar un plano en un eje y enviarlo hacia atrás y adelante una vez.
void effect_planboing (int plano, int velocidad)
{
int i;
para (i = 0; i < 8; i ++)
{
Fill(0x00);
setplane(Plane, i);
delay_ms(5000);
}

para (i = 7; i > = 0; i--)
{
Fill(0x00);
setplane(Plane,i);
delay_ms(5000);
}
}

void effect_fireworks (int iteraciones, int n, int delay)
{
Fill(0x00);

int i, f, e;

Float origin_x = 3;
Float origin_y = 3;
Float origin_z = 3;

int rand_y, rand_x, rand_z;

slowrate flotador, gravedad;

Las partículas y su posición x, y, z y su movimiento, dx, dy, dz
flotador de partículas [n] [6];

para (i = 0; i {}

origin_x = rand () %4;
origin_y = rand () %4;
origin_z = rand () %2;
origin_z += 5;
origin_x += 2;
origin_y += 2;

disparar una partícula en el aire
para (e = 0; e {}
setvoxel(origin_x,origin_y,e);
delay_ms(600+500*e);
Fill(0x00);
}

Llenar matriz de partículas
para (f = 0; f {}
Posición
partículas [f] [0] = origin_x;
partículas [f] [1] = origin_y;
partículas [f] [2] = origin_z;

rand_x = rand () % 200;
rand_y = rand () % 200;
rand_z = rand () % 200;

Movimiento
partículas [f] [3] = 1-(float) rand_x/100; DX
partículas [f] [4] = 1-(float) rand_y/100; DY
partículas [f] [5] = 1-(float) rand_z/100; DZ
}

explotar
para (e = 0; e < 25; e ++)
{
slowrate = 1 + tan ((e+0.1)/20) * 10;

gravedad = tan ((e+0.1)/20) / 2;

para (f = 0; f {}
las partículas partículas [f] [0] += [f] [3] / slowrate;
las partículas partículas [f] += [1] [f] [4] / slowrate;
las partículas partículas [f] [2] += [f] [5] / slowrate;
partículas [f] [2]-= gravedad;

setvoxel(particles[f][0],particles[f][1],particles[f][2]);

}

delay_ms(Delay);
Fill(0x00);
}

}

}

void effect_intro() {}
int cnt, cnt_2, tiempo;

Abajo hacia arriba

para (cnt = 0; cnt < = 7; cnt ++) {}
box_wireframe (0, 0, 0, 7, 7, cnt);
delay_ms(2000);
}
para (cnt = 0; cnt < 7; cnt ++) {}
clrplane_z(CNT);
delay_ms(2000);
}

Cambio cosas bien
1
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,6);
}
delay_ms(2000);
2
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,5);
}
setvoxel(0,0,6);
setvoxel(7,0,6);
delay_ms(2000);
3
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,4);
}
setvoxel(0,0,5);
setvoxel(7,0,5);
setvoxel(0,0,6);
setvoxel(7,0,6);
delay_ms(2000);

4
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,3);
}
setvoxel(0,0,4);
setvoxel(7,0,4);
setvoxel(0,0,5);
setvoxel(7,0,5);
setvoxel(0,0,6);
setvoxel(7,0,6);
delay_ms(2000);

5
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,2);
}
setvoxel(0,0,3);
setvoxel(7,0,3);
setvoxel(0,0,4);
setvoxel(7,0,4);
setvoxel(0,0,5);
setvoxel(7,0,5);
setvoxel(0,0,6);
setvoxel(7,0,6);
delay_ms(2000);

6
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,1);
}
setvoxel(0,0,2);
setvoxel(7,0,2);
setvoxel(0,0,3);
setvoxel(7,0,3);
setvoxel(0,0,4);
setvoxel(7,0,4);
setvoxel(0,0,5);
setvoxel(7,0,5);
delay_ms(2000);

7
Shift(AXIS_Y,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,0,0);
}
setvoxel(0,0,1);
setvoxel(7,0,1);
setvoxel(0,0,2);
setvoxel(7,0,2);
setvoxel(0,0,3);
setvoxel(7,0,3);
setvoxel(0,0,4);
setvoxel(7,0,4);
setvoxel(0,0,5);
setvoxel(7,0,5);
delay_ms(2000);

De derecha a izquierda
para (cnt = 0; cnt < = 7; cnt ++) {}
box_wireframe (0, 0, 0, 7, cnt, 7);
delay_ms(2000);
}
para (cnt = 0; cnt < 7; cnt ++) {}
clrplane_y(CNT);
delay_ms(2000);
}

Pasar a la parte inferior
para (cnt_2 = 6; cnt_2 > = 0; cnt_2--) {}
Shift(AXIS_Z,-1);
para (cnt = 0; cnt < = 7; cnt ++) {}
setvoxel(CNT,cnt_2,0);
}
para (cnt = 6; cnt > cnt_2; cnt--) {}
setvoxel(0,CNT,0);
setvoxel(7,CNT,0);
}

delay_ms(2000);
}

Hacer caja de pared todos

para (cnt = 0; cnt < = 6; cnt ++) {}
Fill(0x00);
box_walls(0,0,0,7,7,CNT);
delay_ms(2000);
}

tiempo = 2000;
para (cnt_2 = 0; cnt_2 < 5; cnt_2 ++) {}
tiempo = tiempo - 300;
Hacer la caja más pequeña
para (cnt = 0; cnt < = 3; cnt ++) {}
Fill(0x00);
box_walls(CNT,CNT,CNT,7-CNT,7-CNT,7-CNT);
delay_ms(Time);
}

Hacer la caja más grande
para (cnt = 0; cnt < = 3; cnt ++) {}
Fill(0x00);
box_walls(3-CNT,3-CNT,3-CNT,4+CNT,4+CNT,4+CNT);
delay_ms(Time);
}
}
para (cnt_2 = 0; cnt_2 < 5; cnt_2 ++) {}
tiempo = tiempo + 300;
Hacer la caja más pequeña
para (cnt = 0; cnt < = 3; cnt ++) {}
Fill(0x00);
box_walls(CNT,CNT,CNT,7-CNT,7-CNT,7-CNT);
delay_ms(Time);
}

Hacer la caja más grande
para (cnt = 0; cnt < = 3; cnt ++) {}
Fill(0x00);
box_walls(3-CNT,3-CNT,3-CNT,4+CNT,4+CNT,4+CNT);
delay_ms(Time);
}
}
delay_ms(2000);
}

void sinelines (int iteraciones, int delay)
{
int i, x;

flotador, izquierda, derecha, sine_base, x_dividor, ripple_height;

para (i = 0; i {}
para (x = 0; x < 8; x ++)
{
x_dividor = 2 + pecado ((float) i / 100) + 1;
ripple_height = 3 + (pecado ((float) i / 200) + 1) * 6;

sine_base = (float) i / 40 + (float) x / x_dividor;

izquierda = 4 + pecado (sine_base) * ripple_height;
derecha = 4 + cos (sine_base) * ripple_height;
derecha = izquierda 7;

printf ("%i %i \n", (int) izquierda, derecha (int));

line_3d (0-3, x, (int) izquierda, 7 + 3, x, (int) derecha);
derecho de line_3d((int), 7, x);
}

delay_ms(Delay);
Fill(0x00);
}
}

void linespin (int iteraciones, int delay)
{
flotador top_x, top_y, top_z, bot_x, bot_y, bot_z, sin_base;
flotador center_x, center_y;

center_x = 4;
center_y = 4;

int i, z;
para (i = 0; i {}

printf ("pecado base %f \n",sin_base);

para (z = 0; z < 8; z ++)
{

sin_base = (float) i / 50 + (float)z/(10+(7*sin((float)i/200)));

top_x = center_x + pecado (sin_base) * 5;
top_y = center_x + cos (sin_base) * 5;
top_z = center_x + cos (sin_base/100) * 2.5;

bot_x = center_x + pecado (sin_base + 3.14) * 10;
bot_y = center_x + cos (sin_base + 3.14) * 10;
bot_z = 7-top_z;

bot_z = z;
top_z = z;

setvoxel((int) top_x, (int) top_y, 7);
setvoxel((int) bot_x, (int) bot_y, 0);

printf ("P1: %i %i %i P2: %i %i %i \n", (int) top_x, (int) top_y, 7, (int) bot_x, (int) bot_y, 0);

line_3d((int) top_x (int) top_y, (int) top_z, (int) bot_x, (int) bot_y, (int) bot_z);
line_3d((int) top_z (int) top_x, (int) top_y, (int) bot_z, (int) bot_x, (int) bot_y);
}

delay_ms(Delay);
Fill(0x00);
}

}

void mirror_ripples (int iteraciones, int delay)
{
16 valores de raíz cuadrada de a ^ 2 + b ^ 2. Índice de un * 4 + b = 10 * sqrt
Esto da la distancia a 3.5,3.5 desde el punto de
unsigned char sqrt_LUT [] = {49,43,38,35,43,35,29,26,38,29,21,16,35,25,16,7};
LUT_START / / Macro de nueva tottymath. Comentado y reemplazado con el código completo
unsigned char LUT [65];
init_LUT(LUT);
int i;
unsigned char x, y, altura, distancia;
para (i = 0; i {}
Fill(0x00);
para (x = 0; x < 4; x ++)
para (y = 0; y < 4; y ++)
{
x + y * 4 da no. de 0-15 para sqrt_LUT
distancia = sqrt_LUT [x + y * 4] ;// la distancia es aproximadamente 0-50
la altura es pecado de iteración + distancia * 4
altura = 4 + totty_sin(LUT,distance+i)/52;
Height=(196+totty_sin(LUT,Distance+i)) / 49;
Utiliza 4-way mirroring para ahorrar en cálculos
setvoxel(x,y,height);
setvoxel(7-x,y,height);
setvoxel(x,7-y,height);
setvoxel(7-x,7-y,height);
setvoxel(x,y,7-height);
setvoxel(7-x,y,7-height);
setvoxel(x,7-y,7-height);
setvoxel(7-x,7-y,7-height);

}
delay_ms(Delay);
}
}

void effect_axis_updown_randsuspend (char eje, int retardo, sueño de int, int invertido)
{
posiciones de unsigned char [64];
destinos de unsigned char [64];

int i, px;

Set de 64 posiciones al azar
para (i = 0; i < 64; i ++)
{
posiciones [i] = 0; Todas las posiciones de partida se establece en 0
destinos [i] = rand () %8;
}

Lazo 8 veces para permitir que el destino 7 llegar a la
para (i = 0; i < 8; i ++)
{
Para cada iteración, mueva que toda la posición un paso más cerca a su destino
para (px = 0; px < 64; px ++)
{
Si (posiciones {} [px]
posiciones [px] ++;
}
}
Dibujar las posiciones y tomar una siesta
draw_positions_axis (eje, posiciones, invertir);
delay_ms(Delay);
}

Establece todos los destinos en 7 (enfrente del lado comenzaron hacia fuera)
para (i = 0; i < 64; i ++)
{
destinos [i] = 7;
}

Suspender las posiciones en el aire por un tiempo
delay_ms(SLEEP);

Luego hacer lo mismo una vez más
para (i = 0; i < 8; i ++)
{
para (px = 0; px < 64; px ++)
{
Si (posiciones {} [px]
posiciones [px] ++;
}
Si (posiciones [px] > destinations[px])
{
posiciones [px]--;
}
}
draw_positions_axis (eje, posiciones, invertir);
delay_ms(Delay);
}
}

void side_ripples (int iteraciones, int delay)
{
16 valores de raíz cuadrada de a ^ 2 + b ^ 2. Índice de un * 4 + b = 10 * sqrt
Esto da la distancia a 3.5,3.5 desde el punto de
unsigned char sqrt_LUT [] = {49,43,38,35,43,35,29,26,38,29,21,16,35,25,16,7};
LUT_START / / Macro de nueva tottymath. Comentado y reemplazado con el código completo
unsigned char LUT [65];
init_LUT(LUT);
int i;
unsigned char x, y, altura, distancia;
para (i = 0; i {}
Fill(0x00);
para (x = 0; x < 4; x ++)
para (y = 0; y < 4; y ++)
{
x + y * 4 da no. de 0-15 para sqrt_LUT
distancia = sqrt_LUT [x + y * 4] ;// la distancia es aproximadamente 0-50
la altura es pecado de iteración + distancia * 4
altura = 4 + totty_sin(LUT,distance+i)/52;
Height=(196+totty_sin(LUT,Distance+i)) / 49;
Utiliza 4-way mirroring para ahorrar en cálculos
setvoxel(x,height,y);
setvoxel(7-x,height,y);
setvoxel(x,height,7-y);
setvoxel(7-x,height,7-y);
setvoxel(x,7-height,y);
setvoxel(7-x,7-height,y);
setvoxel(x,7-height,7-y);
setvoxel(7-x,7-height,7-y);

}
delay_ms(Delay);
}
}

1 voxel al azar a parpadear, parpadear 2 vóxeles al azar... parpadear vóxeles al azar 20
y de vuelta a 1.
void effect_random_sparkle (void)
{
int i;

para (i = 1; i < 20; i ++)
{
effect_random_sparkle_flash(5,i,200);
}

para (i = 20; i > = 1; i--)
{
effect_random_sparkle_flash(5,i,200);
}

}

void quad_ripples (int iteraciones, int delay)
{
16 valores de raíz cuadrada de a ^ 2 + b ^ 2. Índice de un * 4 + b = 10 * sqrt
Esto da la distancia a 3.5,3.5 desde el punto de
unsigned char sqrt_LUT [] = {49,43,38,35,43,35,29,26,38,29,21,16,35,25,16,7};
LUT_START / / Macro de nueva tottymath. Comentado y reemplazado con el código completo
unsigned char LUT [65];
init_LUT(LUT);
int i;
unsigned char x, y, altura, distancia;
para (i = 0; i {}
Fill(0x00);
para (x = 0; x < 4; x ++)
para (y = 0; y < 4; y ++)
{
x + y * 4 da no. de 0-15 para sqrt_LUT
distancia = sqrt_LUT [x + y * 4] ;// la distancia es aproximadamente 0-50
la altura es pecado de iteración + distancia * 4
altura = 4 + totty_sin(LUT,distance+i)/52;
Height=(196+totty_sin(LUT,Distance+i)) / 49;
Utiliza 4-way mirroring para ahorrar en cálculos
setvoxel(x,y,height);
setvoxel(7-x,y,height);
setvoxel(x,7-y,height);
setvoxel(7-x,7-y,height);
setvoxel(x,y,7-height);
setvoxel(7-x,y,7-height);
setvoxel(x,7-y,7-height);
setvoxel(7-x,7-y,7-height);
setvoxel(x,height,y);
setvoxel(7-x,height,y);
setvoxel(x,height,7-y);
setvoxel(7-x,height,7-y);
setvoxel(x,7-height,y);
setvoxel(7-x,7-height,y);
setvoxel(x,7-height,7-y);
setvoxel(7-x,7-height,7-y);

}
delay_ms(Delay);
}
}

// ==========================================================================================
Dibujar funciones
// ==========================================================================================

Activado un único voxel (o)
void setvoxel (int x, int y, int z)
{
Si (inrange(x,y,z))
Cube [z] [y] | = (1 << x);
}

Activado un único voxel (y)
void clrvoxel (int x, int y, int z)
{
Si (inrange(x,y,z))
cubo de [z] [y] & = ~ (1 << x);
}

Esta función valida que estamos dibujando dentro del cubo.
unsigned char inrange (int x, int y, int z)
{
Si (x > = 0 & & x < 8 & & y > = 0 & & y < 8 & & z > = 0 & & z < 8)
{
devolver 0 x 01;
} else
{
Una de las coordenadas estaba fuera del cubo.
retorno 0 x 00;
}
}

Conseguir el estado actual de un voxel
unsigned char getvoxel (int x, int y, int z)
{
Si (inrange(x,y,z))
{
Si (cubo [z] [y] & (1 << x))
{
devolver 0 x 01;
} else
{
retorno 0 x 00;
}
} else
{
retorno 0 x 00;
}
}

En un cierto efecto queremos toma bool y escribirlo en un voxel
Esta función llama a la función de manipulación adecuada voxel.
void altervoxel (int x, int y, int z, int estado)
{
Si (estado == 1)
{
setvoxel(x,y,z);
} else
{
clrvoxel(x,y,z);
}
}

El estado de un voxel del tirón.
Si el voxel es 1, su vuelta a un 0 y viceversa.
void flpvoxel (int x, int y, int z)
{
Si (inrange (x, y, z))
Cube [z] [y] ^ = (1 << x);
}

X1 es alwas menor que x2
Esto es útil para funciones que utiliza para los bucles,
para evitar bucles infinitos
void argorder (int ix1, ix2 int, int * ox1, int * ox2)
{
Si (ix1 > ix2)
{
int tmp;
tmp = ix1;
ix1 = ix2;
ix2 = tmp;
}
* ox1 = ix1;
* ox2 = ix2;
}

Establece todos los vóxeles en un X / Y plano en un punto dado
en eje Z
void setplane_z (int z)
{
int i;
Si (z > = 0 & & z < 8)
{
para (i = 0; i < 8; i ++)
Cube [z] [i] = 0xff;
}
}

Vóxeles se borra de la misma manera que el anterior
void clrplane_z (int z)
{
int i;
Si (z > = 0 & & z < 8)
{
para (i = 0; i < 8; i ++)
Cube [z] [i] = 0 x 00;
}
}

void setplane_x (int x)
{
int z;
int y;
Si (x > = 0 & & x < 8)
{
para (z = 0; z < 8; z ++)
{
para (y = 0; y < 8; y ++)
{
Cube [z] [y] | = (1 << x);
}
}
}
}

void clrplane_x (int x)
{
int z;
int y;
Si (x > = 0 & & x < 8)
{
para (z = 0; z < 8; z ++)
{
para (y = 0; y < 8; y ++)
{
cubo de [z] [y] & = ~ (1 << x);
}
}
}
}

void setplane_y (int y)
{
int z;
Si (y > = 0 & & y < 8)
{
para (z = 0; z < 8; z ++)
Cube [z] [y] = 0xff;
}
}

void clrplane_y (int y)
{
int z;
Si (y > = 0 & & y < 8)
{
para (z = 0; z < 8; z ++)
Cube [z] [y] = 0 x 00;
}
}

void setplane (eje de char, unsigned char i)
{
interruptor (eje)
{
caso AXIS_X:
setplane_x(i);
rotura;

caso AXIS_Y:
setplane_y(i);
rotura;

caso AXIS_Z:
setplane_z(i);
rotura;
}
}

void clrplane (eje de char, unsigned char i)
{
interruptor (eje)
{
caso AXIS_X:
clrplane_x(i);
rotura;

caso AXIS_Y:
clrplane_y(i);
rotura;

caso AXIS_Z:
clrplane_z(i);
rotura;
}
}

Introduzca un valor en todos 64 byts del búfer cubo
Se utiliza sobre todo para claro. Fill(0x00)
o todos en. Fill(0xFF)
relleno (patrón de char sin signo)
{
int z;
int y;
para (z = 0; z < 8; z ++)
{
para (y = 0; y < 8; y ++)
{
Cube [z] [y] = patrón;
}
}
}

Dibujar un cuadro con todas las paredes dibujadas y todos los vóxeles en conjunto
void box_filled (int x1, int y1, int z1, int x2, int y2, int z2)
{
int iy;
int iz;

argorder (x1, x2, x1 & x2);
argorder (y1, y2 y y1 y y2);
argorder (z1, z2 y z1 y z2);

para (iz = z1; iz < = z2; iz ++)
{
para (iy = y1; iy < = y2; iy ++)
{
Cube [iz] [iy] | = byteline(x1,x2);
}
}

}

Darw una caja hueca con paredes laterales.
void box_walls (int x1, int y1, int z1, int x2, int y2, int z2)
{
int iy;
int iz;

argorder (x1, x2, x1 & x2);
argorder (y1, y2 y y1 y y2);
argorder (z1, z2 y z1 y z2);

para (iz = z1; iz < = z2; iz ++)
{
para (iy = y1; iy < = y2; iy ++)
{
Si (iy == y1 || iy == y2 || iz == z1 || iz == z2)
{
Cube [iz] [iy] = byteline(x1,x2);
} else
{
Cube [iz] [iy] | = ((0 x 01 << x1) | (0 x 01 << x2));
}
}
}

}

Trazar un rectángulo de alambre. Esto sólo dibuja las esquinas y bordes,
no hay paredes.
void box_wireframe (int x1, int y1, int z1, int x2, int y2, int z2)
{
int iy;
int iz;

argorder (x1, x2, x1 & x2);
argorder (y1, y2 y y1 y y2);
argorder (z1, z2 y z1 y z2);

Líneas a lo largo de eje X
Cube [z1] [y1] = byteline(x1,x2);
Cube [z1] [y2] = byteline(x1,x2);
Cube [z2] [y1] = byteline(x1,x2);
Cube [z2] [y2] = byteline(x1,x2);

Líneas a lo largo del eje Y
para (iy = y1; iy < = y2; iy ++)
{
setvoxel(x1,IY,Z1);
setvoxel(x1,IY,Z2);
setvoxel(x2,IY,Z1);
setvoxel(x2,IY,Z2);
}

Líneas a lo largo del eje Z
para (iz = z1; iz < = z2; iz ++)
{
setvoxel(x1,Y1,iz);
setvoxel(x1,Y2,iz);
setvoxel(x2,Y1,iz);
setvoxel(x2,Y2,iz);
}

}

bitswap char sin signo (unsigned char x) //Reverses un byte (por lo que cartas no al revés);
{resultado byte;

ASM ("mov __tmp_reg__, % [en] \n\t"
«lsl __tmp_reg__ \n\t» / * cambio de un poco alta para llevar a * /
«ror % [out] \n\t» / * llevar gire __tmp_reg__to baja poco (eventualmente) * /
«lsl __tmp_reg__ \n\t» / * 2 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 3 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 4 * /
«ror % [out] \n\t»

«lsl __tmp_reg__ \n\t» / * 5 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 6 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 7 * /
«ror % [out] \n\t»
«lsl __tmp_reg__ \n\t» / * 8 * /
«ror % [out] \n\t»

: [a] "r =" (resultado): [en] "r" (x));
Return(Result);
}

Devuelve un byte con una fila de 1 dibujado en ella.
byteline(2,5) da 0b00111100
char byteline (int Inicio, int final)
{
regresar ((0xff <}

Un byte se girará 180 grados.
MSB se convierte en LSB, LSB se convierte en MSB.
char flipbyte (byte char)
{
flop char = 0 x 00;

= flop (flop & 0b11111110) | (0b00000001 & (byte >> 7));
= flop (flop & 0b11111101) | (0b00000010 & (byte >> 5));
= flop (flop & 0b11111011) | (0b00000100 & (byte >> 3));
= flop (flop & 0b11110111) | (0b00001000 & (bytes >> 1));
= flop (flop & 0b11101111) | (0b00010000 & (bytes << 1));
= flop (flop & 0b11011111) | (0b00100000 & (byte << 3));
= flop (flop & 0b10111111) | (0b01000000 & (byte << 5));
= flop (flop & 0b01111111) | (0b10000000 & (byte << 7));
volver flop;
}

Trace una línea entre cualquier coordenadas en el espacio 3d.
Utiliza valores enteros de entrada, así que no esperes animaciones suaves.
línea de vacía (int x1, int y1, int z1, int x2, int y2, int z2)
{
flotador de xy; voxels cuantos nos movemos en el eje y para cada paso en el eje x
xz del flotador; voxels cuantos nos movemos en el eje y para cada paso en el eje x
unsigned char x, y, z;
unsigned char lasty, lastz;

Siempre queremos llamar a la línea de x = 0 a x = 7.
Si x1 es bigget que x2, tenemos que voltear todos los valores.
Si (x1 > x2)
{
int tmp;
tmp = x2; x2 = x1; x1 = tmp;
tmp = y2; Y2 = y1; Y1 = tmp;
tmp = z2; z2 = z1; Z1 = tmp;
}

Si (y1 > y2)
{
XY = (float)(y1-y2)/(float)(x2-x1);
lasty = y2;
} else
{
XY = (float)(y2-y1)/(float)(x2-x1);
lasty = y1;
}

Si (z1 > z2)
{
XZ = (float)(z1-z2)/(float)(x2-x1);
lastz = z2;
} else
{
XZ = (float)(z2-z1)/(float)(x2-x1);
lastz = z1;
}

Para cada paso de x, incrementos y por:
para (x = x1; x < = x2; x ++)
{
y = (xy*(x-x1)) + y1;
z = (xz*(x-x1)) + z1;
setvoxel(x,y,z);
}

}

Bucle de retardo.
Esto no está calibrado en milisegundos,
pero teníamos ya a muchos efectos que el uso de este
calibración cuando lo pensamos puede ser una buena idea
para calibrarlo.
void delay_ms(uint16_t x)
{
uint8_t y, z;
para (x > 0; x--) {}
para (y = 0 y < 90; y ++) {}
para (z = 0; z < 6; z ++) {}
ASM volátil ("nop");
}
}
}
}

void line_3d (int x1, int y1, int z1, int x2, int y2, int z2)
{
int i, dx, dy, dz, l, m, n, x_inc, y_inc, z_inc,
err_1, err_2, dx2, dy2, dz2;
int pixel [3];
Pixel [0] = x1;
Pixel [1] = y1;
Pixel [2] = z1;
DX = x2-x 1;
DY = y2 - y1;
DZ = z2 - z1;
¿x_inc = (dx < 0)? -1: 1;
l = abs(dx);
¿y_inc = (dy < 0)? -1: 1;
m = abs(dy);
¿z_inc = (dz < 0)? -1: 1;
n = abs(dz);
DX2 = l << 1;
Dy2 = m << 1;
dz2 = n << 1;
Si ((l > = m) & & (l > = n)) {}
err_1 = dy2 - l;
err_2 = dz2 - l;
para (i = 0; i < l; i ++) {}
PUT_PIXEL(pixel);
setvoxel(Pixel[0],pixel[1],pixel[2]);
printf ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
Si (err_1 > 0) {}
Pixel [1] += y_inc;
err_1 = dx2;
}
Si (err_2 > 0) {}
Pixel [2] += z_inc;
err_2 = dx2;
}
err_1 += dy2;
err_2 += dz2;
Pixel [0] += x_inc;
}
} else if ((m > = l) & & (m > = n)) {}
err_1 = dx2 - m;
err_2 = dz2 - m;
para (i = 0; i < m; i ++) {}
PUT_PIXEL(pixel);
setvoxel(Pixel[0],pixel[1],pixel[2]);
printf ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
Si (err_1 > 0) {}
Pixel [0] += x_inc;
err_1 = dy2;
}
Si (err_2 > 0) {}
Pixel [2] += z_inc;
err_2 = dy2;
}
err_1 += dx2;
err_2 += dz2;
Pixel [1] += y_inc;
}
} else {}
err_1 = dy2 - n;
err_2 = dx2 - n;
para (i = 0; i < n; i ++) {}
setvoxel(Pixel[0],pixel[1],pixel[2]);
printf ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
PUT_PIXEL(pixel);
Si (err_1 > 0) {}
Pixel [1] += y_inc;
err_1 = dz2;
}
Si (err_2 > 0) {}
Pixel [0] += x_inc;
err_2 = dz2;
}
err_1 += dy2;
err_2 += dx2;
Pixel [2] += z_inc;
}
}
setvoxel(Pixel[0],pixel[1],pixel[2]);
printf ("%i %i valor %i \n", pixel[0],pixel[1],pixel[2]);
PUT_PIXEL(pixel);
}

void init_LUT (unsigned char LUT[65])
{
unsigned char i;
flotador sin_of, seno;
para (i = 0; i < 65; i ++)
{
sin_of = i * PI/64; Sólo tiene una media onda de pecado
sine=sin(sin_of);
181.0 como este cuadrado es < 32767, por lo que podemos multiplicar dos pecado o cos sin desbordar un int.
LUT [i] = seno * 181.0;
}
}

int totty_sin (unsigned char LUT [65], int sin_of)
{
unsigned char inv = 0;
Si (sin_of < 0)
{
sin_of =-sin_of;
INV = 1;
}
sin_of & = 0x7f; 127
Si (sin_of > 64)
{
sin_of-= 64;
INV = 1-inv;
}
Si (inv)
volver - LUT [sin_of];
otra cosa
volver LUT [sin_of];
}

int totty_cos (unsigned char LUT [65], int cos_of)
{
unsigned char inv = 0;
cos_of += 32; / / simplemente gira 90 grados para COS
cos_of & = 0x7f; //127
Si (cos_of > 64)
{
cos_of-= 64;
INV = 1;
}
Si (inv)
volver - LUT [cos_of];
otra cosa
volver LUT [cos_of];
}

void effect_random_sparkle_flash (int iteraciones, vóxeles de int y int retardo)
{
int i;
int v;
para (i = 0; i < iteraciones; i ++)
{
para (v = 0; v < = vóxeles; v ++)
setvoxel(Rand()%8,Rand()%8,Rand()%8);

delay_ms(Delay);
Fill(0x00);
}
}

Cambiar todo el contenido del cubo a lo largo de un eje
Esto es excelente para efectos donde quieres dibujar algo
en un lado del cubo y con flujo hacia el otro
lado. Como la lluvia que fluye hacia abajo el axiz Z.
desplazamiento vacío (eje de char, int dirección)
{
int i, x, y;
int ii, iii;
int estado;

para (i = 0; i < 8; i ++)
{
Si (Dirección == -1)
{
II = i;
} else
{
II = (7-i);
}

para (x = 0; x < 8; x ++)
{
para (y = 0 y < 8; y ++)
{
Si (Dirección == -1)
{
III = ii + 1;
} else
{
III = ii-1;
}

Si (eje == AXIS_Z)
{
Estado = getvoxel(x,y,iii);
altervoxel(x,y,II,State);
}

Si (eje == AXIS_Y)
{
Estado = getvoxel(x,iii,y);
altervoxel(x,II,y,State);
}

Si (eje == AXIS_X)
{
Estado = getvoxel(iii,y,x);
altervoxel(II,y,x,State);
}
}
}
}

Si (Dirección == -1)
{
i = 7;
} else
{
i = 0;
}

para (x = 0; x < 8; x ++)
{
para (y = 0 y < 8; y ++)
{
Si (eje == AXIS_Z)
clrvoxel(x,y,i);

Si (eje == AXIS_Y)
clrvoxel(x,i,y);

Si (eje == AXIS_X)
clrvoxel(i,y,x);
}
}
}

Artículos Relacionados

Simple 3 x 3 x 3 LED cubo con Arduino

Simple 3 x 3 x 3 LED cubo con Arduino

Este es mi primer instructivo para votar en los comentarios por favor.Al ver un montón de tutoriales de cubo del LED, parecía eran demasiado complejas y como no dan suficientes detalles acerca de cómo construirlos. También la selección controlada uno
4 x 4 X 4 LED cubo con Arduino Uno

4 x 4 X 4 LED cubo con Arduino Uno

Como alguien que es muy nuevo con electrónica digital este cubo LED fue divertido de hacer, un reto y una gran lección en soldadura. Si tienes algo de paciencia (64 LED de soldar!) y manos constantes, este proyecto merece la pena al final!Paso 1: Mat
Guía de un newbie para configurar ESP8266 con Arduino Mega 2560 o Uno

Guía de un newbie para configurar ESP8266 con Arduino Mega 2560 o Uno

Por productos de código abierto para tener éxito o adopción en masa por los "fabricantes" / "DIY-ers" / "dev" / "etc"; una documentación actualizada y exacta o guía de inicio rápido tiene que ser proporcionado. Mens
Servidor Web DIY con Arduino Mega 2560

Servidor Web DIY con Arduino Mega 2560

en este proyecto de bricolaje, vamos a hacer nosotros mismos un servidor web pequeño con W5100 escudo y arduino mega 2560,Vamos a conseguir nosotros mismos iniciado,Preparar todas las piezas...Paso 1: Las piezas necesarias para este DIY 1. Arduino Me
Cómo utilizar 2.4" TFT LCD protector con Arduino Mega

Cómo utilizar 2.4" TFT LCD protector con Arduino Mega

Hoy, voy a demostrar que queremos utilizar 2.4" shield TFT LCD (hay mcufriend.com escribe sobre este escudo) trabaja con Arduino Mega, porque no es tan fácil de ejecutar unos a otros. Pero con estas instrucciones, puede ejecutar y modificar los códig
$9 construir una 4 x 4 x 4 RGB LED cubo con creador de animación

$9 construir una 4 x 4 x 4 RGB LED cubo con creador de animación

Cubo del LED RGB es impresionante, pero tiene muchos led pierna a construir y el precio es alta, así que aquí es el componente más barato podemos hacer con 64 LEDs RGB, que tenga todas las piezas de bricolaje por su auto, al compartir el esquema y el
Cubo de LED Rubik con Arduino

Cubo de LED Rubik con Arduino

En este instructable te voy a mostrar cómo pueden construir cubos de su propia LED Rubik. Este proyecto fue realizado para un curso introductorio de electrónica en el Pomona College. Grupos recibieron aproximadamente dos meses para completar un proye
Android controla LEDs RGB con Arduino

Android controla LEDs RGB con Arduino

Hai a todos en el post iam va a mostrar cómo controlar el LED RGB utilizando android con arduino y el módulo Bluetooth HC-05.He buscado en la web hay muchas técnicas para controlar el LED RGB. Pero este es el método que es muy simple y fácil.En este
48 x 8 desplazamiento matriz LED DISPLAY con ARDUINO controlador

48 x 8 desplazamiento matriz LED DISPLAY con ARDUINO controlador

un monocromo pantalla de matriz de puntos LED (solo color) se utiliza para mostrar los caracteres y símbolos que es interfaz con un microcontrolador. Este proyecto será deliberar sobre mostrando un mensaje de texto desplazable en una pantalla de matr
LED Star con Arduino y WS2811 Neopixels

LED Star con Arduino y WS2811 Neopixels

DescripciónEste pequeño proyecto hace un gran adorno para colgar en tu ventana en tiempo de Navidad. Es una estrella amplia de 20" con 50 leds de"neopixel"alrededor del perímetro. Cada led es individualmente direccionable y es controlado po
Control de un Led RGB con Arduino y procesamiento

Control de un Led RGB con Arduino y procesamiento

este instructable (mi primer no menos) se muestra cómo controlar un RGB led usando procesamiento y arduino.La característica fundamental que el color se selecciona haciendo clic en una imagen, el valor RGB del pixel que usted haga clic en es procesad
Control LED RGB con arduino y procesamiento.

Control LED RGB con arduino y procesamiento.

Hoy te diré cómo controlar un LED RGB con ayuda del lenguaje Arduino y procesamiento. Este es mi primer instructable, déjeme por favor saber si pudiera mejorar algo y si tienes cualquier tipo de preguntas les dejan en la caja de comentario, me encant
Un reloj de 15 LED RGB con Arduino base

Un reloj de 15 LED RGB con Arduino base

El reloj RGB utiliza el modelo de composición de color RGB usado en todas las pantallas color. Este modelo utiliza tres colores 'básicos', es decir, rojos, verdes y azules, para construir cualquier otro 'compuesto' color del espectro. Con reloj RGB,
Fin de semana proyecto reloj fecha termómetro y humedad con Arduino mega

Fin de semana proyecto reloj fecha termómetro y humedad con Arduino mega

chicos, quiero compartir mi proyecto de fin de semana en la creación de un reloj con sensor de temperatura y humedadEstá usando el sensor DHT11, RTC DS1307, LCD 16 x 2 y Arduino Mega 2560,Mantener lectura y buena suertePaso 1: Preparar todas las piez