Proyecto cubo de led 8x8x8 * DitecnoMakers

Introducción:

Un cubo LED es como una pantalla LED,pero es especial, ya que tiene una tercera
dimensión, por lo que es en 3D. Piense en ello como muchas de las pantallas de baja
resolución transparentes.

Este cubo del LED tiene 512 LEDs.Obviamente, que tiene un puerto IO
dedicado para cada LED sería muy poco práctico. Lo que necesitas un
microcontrolador con 512 puertos IO, y correr 512 cables a través del cubo.
En cambio, cubos LED se basan en un fenómeno óptico llamado persistencia de
la visión (POV).

Pasos: Cada capa está formada por 8 columnas de LEDs se mantienen unidas por las patas de cada LED. En la parte superior de cada capa de cada LED se gira 90 grados en sentido horario, de modo que la pata se conecta con el LED superior de la columna siguiente. En la columna a la derecha esta pata se pegará fuera del lado de la capa. Dejamos esto en su lugar y lo utilizan para conectar tierra al probar todos los LED en un paso posterior. 1) Preparar 64 LEDs , doble las piernas cátodo de cada LED de 90 grados. Asegúrese de que las piernas se doblan en la misma dirección en todos los indicadores LED. En cuanto a la sesión de LED en un agujero en la plantilla con la muesca a la derecha, nos inclinamos hacia arriba de las piernas. 2) Comience con la fila en la parte superior de inicio mediante la colocación de la parte superior derecha de LED en la plantilla. A continuación, coloque la una a la izquierda, colocándolo de manera que la pierna de cátodo está en contacto con la pierna cátodo del LED anterior. Aclarar y repetir hasta que llegue la luz LED izquierda. Soldar todas las articulaciones. 3) Suelde todas las 8 columnas Si usted es diestro, le recomendamos que comience con la columna a la izquierda. De esa manera la mano puede descansar en la plantilla de madera, cuando la soldadura. Usted necesitará una mano firme al soldar a mano alzada como este. Comience por colocar el segundo LED de la parte superior, la alineación que por lo que toca la pierna de la unión de soldadura de la etapa anterior. A continuación, coloque el LED. Por debajo de ese modo que la pierna toque el cátodo LED por encima de Repita el proceso hasta llegar a la parte inferior. Suelde todas las articulaciones. 4) Añadir refuerzos Ahora tiene una capa que se parece a un peine. En este punto, todo el asunto es muy endeble, y usted tendrá que agregar un poco de apoyo. Se utilizó un refuerzo en la parte inferior y uno cerca de la mitad. Tome una paz de alambre recto, más o menos se alinean en la que desea que uno de los extremos y la soldadura de la capa. Afinar la alineación y la soldadura del otro extremo en su lugar. Ahora, hacer juntas de soldadura a las columnas restantes 6. Haga esto para ambas llaves. 5) prueba que todos los LEDs Esto se explica en el siguiente paso. Sólo mencionar aquí lo que no es eliminar la capa por el momento. 6)Retire la capa es todo La primera capa del cubo de LED hecho, ahora todo lo que tienes que hacer es sacarlo de la plantilla. Dependiendo del tamaño de los agujeros, algunos LED pueden tener más resistencia al intentar sacarlo. Basta con coger los dos extremos de la capa y tirando probablemente se rompería toda la cosa, si un par de los LEDs están atrapados. Comience levantando cada LED de un par de milímetros. Sólo lo suficiente para sentir que no hay ninguna resistencia.

Elementos a Utilizar:

1- Arduino Uno R3 512

– LEDs azules difusos 5mm

1- Fuente de alimentación de conmutación regulada 5V 10A

1- cinta aisladora para cables

16- Transistores PN2222

64- Resistencias de 220 ohm

9- Registro de desplazamiento 74HC595

– Alambre de cobre estañado 20 AWG

– Alambres

– Botones

1-LED rojo

1-LED verde

Tablas de madera Pegamento de madera

Abrazaderas

Pintura en aerosol

Espuma para hacer paneles

Diagrama se pueden encontrar en GitHub

Código:

#include <SPI.h>

#define XAXIS 0
#define YAXIS 1
#define ZAXIS 2

#define POS_X 0
#define NEG_X 1
#define POS_Z 2
#define NEG_Z 3
#define POS_Y 4
#define NEG_Y 5

#define BUTTON_PIN 8
#define RED_LED 5
#define GREEN_LED 7

#define TOTAL_EFFECTS 8
#define RAIN 0
#define PLANE_BOING 1
#define SEND_VOXELS 2
#define WOOP_WOOP 3
#define CUBE_JUMP 4
#define GLOW 5
#define TEXT 6
#define LIT 7

#define RAIN_TIME 260
#define PLANE_BOING_TIME 220
#define SEND_VOXELS_TIME 140
#define WOOP_WOOP_TIME 350
#define CUBE_JUMP_TIME 200
#define GLOW_TIME 8
#define TEXT_TIME 300
#define CLOCK_TIME 500

uint8_t characters[10][8] = {
{0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C}, //0
{0x10, 0x18, 0x14, 0x10, 0x10, 0x10, 0x10, 0x3C}, //1
{0x3C, 0x42, 0x40, 0x40, 0x3C, 0x02, 0x02, 0x7E}, //2
{0x3C, 0x40, 0x40, 0x3C, 0x40, 0x40, 0x42, 0x3C}, //3
{0x22, 0x22, 0x22, 0x22, 0x7E, 0x20, 0x20, 0x20}, //4
{0x7E, 0x02, 0x02, 0x3E, 0x40, 0x40, 0x42, 0x3C}, //5
{0x3C, 0x02, 0x02, 0x3E, 0x42, 0x42, 0x42, 0x3C}, //6
{0x3C, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40}, //7
{0x3C, 0x42, 0x42, 0x3C, 0x42, 0x42, 0x42, 0x3C}, //8
{0x3C, 0x42, 0x42, 0x42, 0x3C, 0x40, 0x40, 0x3C}, //9
};

uint8_t cube[8][8];
uint8_t currentEffect;

uint16_t timer;

uint64_t randomTimer;

bool loading;

void setup() {

loading = true;
randomTimer = 0;
currentEffect = RAIN;

SPI.begin();
SPI.beginTransaction(SPISettings(8000000, MSBFIRST, SPI_MODE0));

pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(RED_LED, OUTPUT);
pinMode(GREEN_LED, OUTPUT);

randomSeed(analogRead(0));
digitalWrite(GREEN_LED, HIGH);

}

void loop() {

randomTimer++;

if (digitalRead(BUTTON_PIN) == LOW) {
clearCube();
loading = true;
timer = 0;
currentEffect++;
if (currentEffect == TOTAL_EFFECTS) {
currentEffect = 0;
}
randomSeed(randomTimer);
randomTimer = 0;
digitalWrite(RED_LED, HIGH);
digitalWrite(GREEN_LED, LOW);
delay(500);
digitalWrite(RED_LED, LOW);
digitalWrite(GREEN_LED, HIGH);
}

switch (currentEffect) {
case RAIN: rain(); break;
case PLANE_BOING: planeBoing(); break;
case SEND_VOXELS: sendVoxels(); break;
case WOOP_WOOP: woopWoop(); break;
case CUBE_JUMP: cubeJump(); break;
case GLOW: glow(); break;
case TEXT: text("0123456789", 10); break;
case LIT: lit(); break;

default: rain();
}

renderCube();

}

void renderCube() {
for (uint8_t i = 0; i < 8; i++) {
digitalWrite(SS, LOW);
SPI.transfer(0x01 << i);
for (uint8_t j = 0; j < 8; j++) {
SPI.transfer(cube[i][j]);
}
digitalWrite(SS, HIGH);
}
}

void rain() {
if (loading) {
clearCube();
loading = false;
}
timer++;
if (timer > RAIN_TIME) {
timer = 0;
shift(NEG_Y);
uint8_t numDrops = random(0, 5);
for (uint8_t i = 0; i < numDrops; i++) {
setVoxel(random(0, 8), 7, random(0, 8));
}
}
}

uint8_t planePosition = 0;
uint8_t planeDirection = 0;
bool looped = false;

void planeBoing() {
if (loading) {
clearCube();
uint8_t axis = random(0, 3);
planePosition = random(0, 2) * 7;
setPlane(axis, planePosition);
if (axis == XAXIS) {
if (planePosition == 0) {
planeDirection = POS_X;
} else {
planeDirection = NEG_X;
}
} else if (axis == YAXIS) {
if (planePosition == 0) {
planeDirection = POS_Y;
} else {
planeDirection = NEG_Y;
}
} else if (axis == ZAXIS) {
if (planePosition == 0) {
planeDirection = POS_Z;
} else {
planeDirection = NEG_Z;
}
}
timer = 0;
looped = false;
loading = false;
}

timer++;
if (timer > PLANE_BOING_TIME) {
timer = 0;
shift(planeDirection);
if (planeDirection % 2 == 0) {
planePosition++;
if (planePosition == 7) {
if (looped) {
loading = true;
} else {
planeDirection++;
looped = true;
}
}
} else {
planePosition--;
if (planePosition == 0) {
if (looped) {
loading = true;
} else {
planeDirection--;
looped = true;
}
}
}
}
}

uint8_t selX = 0;
uint8_t selY = 0;
uint8_t selZ = 0;
uint8_t sendDirection = 0;
bool sending = false;

void sendVoxels() {
if (loading) {
clearCube();
for (uint8_t x = 0; x < 8; x++) {
for (uint8_t z = 0; z < 8; z++) {
setVoxel(x, random(0, 2) * 7, z);
}
}
loading = false;
}

timer++;
if (timer > SEND_VOXELS_TIME) {
timer = 0;
if (!sending) {
selX = random(0, 8);
selZ = random(0, 8);
if (getVoxel(selX, 0, selZ)) {
selY = 0;
sendDirection = POS_Y;
} else if (getVoxel(selX, 7, selZ)) {
selY = 7;
sendDirection = NEG_Y;
}
sending = true;
} else {
if (sendDirection == POS_Y) {
selY++;
setVoxel(selX, selY, selZ);
clearVoxel(selX, selY - 1, selZ);
if (selY == 7) {
sending = false;
}
} else {
selY--;
setVoxel(selX, selY, selZ);
clearVoxel(selX, selY + 1, selZ);
if (selY == 0) {
sending = false;
}
}
}
}
}

uint8_t cubeSize = 0;
bool cubeExpanding = true;

void woopWoop() {
if (loading) {
clearCube();
cubeSize = 2;
cubeExpanding = true;
loading = false;
}

timer++;
if (timer > WOOP_WOOP_TIME) {
timer = 0;
if (cubeExpanding) {
cubeSize += 2;
if (cubeSize == 8) {
cubeExpanding = false;
}
} else {
cubeSize -= 2;
if (cubeSize == 2) {
cubeExpanding = true;
}
}
clearCube();
drawCube(4 - cubeSize / 2, 4 - cubeSize / 2, 4 - cubeSize / 2, cubeSize);
}
}

uint8_t xPos;
uint8_t yPos;
uint8_t zPos;

void cubeJump() {
if (loading) {
clearCube();
xPos = random(0, 2) * 7;
yPos = random(0, 2) * 7;
zPos = random(0, 2) * 7;
cubeSize = 8;
cubeExpanding = false;
loading = false;
}

timer++;
if (timer > CUBE_JUMP_TIME) {
timer = 0;
clearCube();
if (xPos == 0 && yPos == 0 && zPos == 0) {
drawCube(xPos, yPos, zPos, cubeSize);
} else if (xPos == 7 && yPos == 7 && zPos == 7) {
drawCube(xPos + 1 - cubeSize, yPos + 1 - cubeSize, zPos + 1 - cubeSize, cubeSize);
} else if (xPos == 7 && yPos == 0 && zPos == 0) {
drawCube(xPos + 1 - cubeSize, yPos, zPos, cubeSize);
} else if (xPos == 0 && yPos == 7 && zPos == 0) {
drawCube(xPos, yPos + 1 - cubeSize, zPos, cubeSize);
} else if (xPos == 0 && yPos == 0 && zPos == 7) {
drawCube(xPos, yPos, zPos + 1 - cubeSize, cubeSize);
} else if (xPos == 7 && yPos == 7 && zPos == 0) {
drawCube(xPos + 1 - cubeSize, yPos + 1 - cubeSize, zPos, cubeSize);
} else if (xPos == 0 && yPos == 7 && zPos == 7) {
drawCube(xPos, yPos + 1 - cubeSize, zPos + 1 - cubeSize, cubeSize);
} else if (xPos == 7 && yPos == 0 && zPos == 7) {
drawCube(xPos + 1 - cubeSize, yPos, zPos + 1 - cubeSize, cubeSize);
}
if (cubeExpanding) {
cubeSize++;
if (cubeSize == 8) {
cubeExpanding = false;
xPos = random(0, 2) * 7;
yPos = random(0, 2) * 7;
zPos = random(0, 2) * 7;
}
} else {
cubeSize--;
if (cubeSize == 1) {
cubeExpanding = true;
}
}
}
}

bool glowing;
uint16_t glowCount = 0;

void glow() {
if (loading) {
clearCube();
glowCount = 0;
glowing = true;
loading = false;
}

timer++;
if (timer > GLOW_TIME) {
timer = 0;
if (glowing) {
if (glowCount < 448) {
do {
selX = random(0, 8);
selY = random(0, 8);
selZ = random(0, 8);
} while (getVoxel(selX, selY, selZ));
setVoxel(selX, selY, selZ);
glowCount++;
} else if (glowCount < 512) {
lightCube();
glowCount++;
} else {
glowing = false;
glowCount = 0;
}
} else {
if (glowCount < 448) {
do {
selX = random(0, 8);
selY = random(0, 8);
selZ = random(0, 8);
} while (!getVoxel(selX, selY, selZ));
clearVoxel(selX, selY, selZ);
glowCount++;
} else {
clearCube();
glowing = true;
glowCount = 0;
}
}
}
}

uint8_t charCounter = 0;
uint8_t charPosition = 0;

void text(char string[], uint8_t len) {
if (loading) {
clearCube();
charPosition = -1;
charCounter = 0;
loading = false;
}
timer++;
if (timer > TEXT_TIME) {
timer = 0;

shift(NEG_Z);
charPosition++;

if (charPosition == 7) {
charCounter++;
if (charCounter > len - 1) {
charCounter = 0;
}
charPosition = 0;
}

if (charPosition == 0) {
for (uint8_t i = 0; i < 8; i++) {
cube[i][0] = characters[string[charCounter] - '0'][i];
}
}
}
}

void lit() {
if (loading) {
clearCube();
for(uint8_t i=0; i<8; i++) {
for(uint8_t j=0; j<8; j++) {
cube[i][j] = 0xFF;
}
}
loading = false;
}
}

void setVoxel(uint8_t x, uint8_t y, uint8_t z) {
cube[7 - y][7 - z] |= (0x01 << x);
}

void clearVoxel(uint8_t x, uint8_t y, uint8_t z) {
cube[7 - y][7 - z] ^= (0x01 << x);
}

bool getVoxel(uint8_t x, uint8_t y, uint8_t z) {
return (cube[7 - y][7 - z] & (0x01 << x)) == (0x01 << x);
}

void setPlane(uint8_t axis, uint8_t i) {
for (uint8_t j = 0; j < 8; j++) {
for (uint8_t k = 0; k < 8; k++) {
if (axis == XAXIS) {
setVoxel(i, j, k);
} else if (axis == YAXIS) {
setVoxel(j, i, k);
} else if (axis == ZAXIS) {
setVoxel(j, k, i);
}
}
}
}

void shift(uint8_t dir) {

if (dir == POS_X) {
for (uint8_t y = 0; y < 8; y++) {
for (uint8_t z = 0; z < 8; z++) {
cube[y][z] = cube[y][z] << 1;
}
}
} else if (dir == NEG_X) {
for (uint8_t y = 0; y < 8; y++) {
for (uint8_t z = 0; z < 8; z++) {
cube[y][z] = cube[y][z] >> 1;
}
}
} else if (dir == POS_Y) {
for (uint8_t y = 1; y < 8; y++) {
for (uint8_t z = 0; z < 8; z++) {
cube[y - 1][z] = cube[y][z];
}
}
for (uint8_t i = 0; i < 8; i++) {
cube[7][i] = 0;
}
} else if (dir == NEG_Y) {
for (uint8_t y = 7; y > 0; y--) {
for (uint8_t z = 0; z < 8; z++) {
cube[y][z] = cube[y - 1][z];
}

}
for (uint8_t i = 0; i < 8; i++) {
cube[0][i] = 0;
}
} else if (dir == POS_Z) {
for (uint8_t y = 0; y < 8; y++) {
for (uint8_t z = 1; z < 8; z++) {
cube[y][z - 1] = cube[y][z];
}
}
for (uint8_t i = 0; i < 8; i++) {
cube[i][7] = 0;
}
} else if (dir == NEG_Z) {
for (uint8_t y = 0; y < 8; y++) {
for (uint8_t z = 7; z > 0; z--) {
cube[y][z] = cube[y][z - 1];
}
}
for (uint8_t i = 0; i < 8; i++) {
cube[i][0] = 0;
}
}
}

void drawCube(uint8_t x, uint8_t y, uint8_t z, uint8_t s) {
for (uint8_t i = 0; i < s; i++) {
setVoxel(x, y + i, z);
setVoxel(x + i, y, z);
setVoxel(x, y, z + i);
setVoxel(x + s - 1, y + i, z + s - 1);
setVoxel(x + i, y + s - 1, z + s - 1);
setVoxel(x + s - 1, y + s - 1, z + i);
setVoxel(x + s - 1, y + i, z);
setVoxel(x, y + i, z + s - 1);
setVoxel(x + i, y + s - 1, z);
setVoxel(x + i, y, z + s - 1);
setVoxel(x + s - 1, y, z + i);
setVoxel(x, y + s - 1, z + i);
}
}

void lightCube() {
for (uint8_t i = 0; i < 8; i++) {
for (uint8_t j = 0; j < 8; j++) {
cube[i][j] = 0xFF;
}
}
}

void clearCube() {
for (uint8_t i = 0; i < 8; i++) {
for (uint8_t j = 0; j < 8; j++) {
cube[i][j] = 0;
}
}
}

Autor: VECT Estudio

Saludos hasta la próxima.

2235

arduino | circuitos