Hello every one I just built a 8x8x8 single color led cube and I'm having some troubles with the code. The cube is controller by 8 TPIC shit register for the 64 vertical columns and 1 74HC595 to control the 8 mosfets for the 8 horizontal layers. I'm supplying the cube with 12V 5A with a step-down voltage regulator to 5V. I have actually issues in writing the pattern to the cube. As you can see only the first layer (layer 0) should be fully light up, but actually al the cube is light up. In addition the brightness of the leds is very low, like all the leds are on at the same time. This indicates that maybe all the layers are actually on. Does it possibly depend on the timing of the interrupt and the time to write to the 74HC595?
Thank you guys
This is the code
#include <SPI.h>
#include <TimerOne.h>
byte currentLayer;
const int cube_size = 8;
//----------------- PINS --------------------
//columns control pins. Use PORTB
//latch for colums shift registers
int RCLK_COL = 10;
int RCLK_COL_BIT = 2;
//clock for columns shift registers
int SRCLK_COL = 13;
int SRCLK_COL_BIT = 1;
//data for columns shift registers
int SER_COL = 11;
//layer control pins. Use PORTD
//latch for layers shift register
int RCLK_LAYERS = 7;
int RCLK_LAYERS_BIT = 7;
//clk for layers shift register
int SRCLK_LAYERS = 6;
int SRCLK_LAYERS_BIT = 6;
//data for layers shift register
int SER_LAYERS = 5;
int SER_LAYERS_BIT = 5;
//-------------LAYERS PATTERNS---------------
byte noLayers = B11111111;
//byte layers[cube_size] = {
// B01111111,
// B10111111,
// B11011111,
// B11101111,
// B11110111,
// B11111011,
// B11111101,
// B11111110};
int layers[][8] = {
{0,1,1,1,1,1,1,1},
{1,0,1,1,1,1,1,1},
{1,1,0,1,1,1,1,1},
{1,1,1,0,1,1,1,1},
{1,1,1,1,0,1,1,1},
{1,1,1,1,1,0,1,1},
{1,1,1,1,1,1,0,1},
{1,1,1,1,1,1,1,0}
};
//----------------- CUBE --------------------
// [8,8,0] +-------------+ [8,8,8]
// /| /|
// / | / |
// / | [8,0,8] / |
//[8,0,0]+---|---------+ |
// | | | |
// | +---------|---+ [0,8,8] ^
// | / [0,8,0] | / |
// | / | / y
// |/ |/ |
// +-------------+ --x-->
// [0,0,0] [0,0,8]
// --x-->
//1: LAYERS
//2: x
//3: y
//
//cube_pattern[i] : layer i
//cube_pattern[i][j] : the 8-bit word to write to shift register j
byte cube_pattern[8][8];
void setup() {
pinMode(RCLK_COL, OUTPUT);
pinMode(SRCLK_COL, OUTPUT);
pinMode(SER_COL, OUTPUT);
pinMode(RCLK_LAYERS, OUTPUT);
pinMode(SRCLK_LAYERS, OUTPUT);
pinMode(SER_LAYERS, OUTPUT);
Timer1.initialize(2000);
Timer1.attachInterrupt(renderCube);
SPI.begin();
for(int i=0;i<8;i++){ //inicializes the byte array with 0
for(int j=0;j<8;j++){
cube_pattern[i][j]=0;
}
}
Serial.begin(9600);
cube_pattern[0][0]=B11111111;
cube_pattern[0][1]=B11111111;
cube_pattern[0][2]=B11111111;
cube_pattern[0][3]=B11111111;
cube_pattern[0][4]=B11111111;
cube_pattern[0][5]=B11111111;
cube_pattern[0][6]=B11111111;
cube_pattern[0][7]=B11111111;
cube_pattern[1][0]=B00000000;
cube_pattern[1][1]=B00000000;
cube_pattern[1][2]=B00000000;
cube_pattern[1][3]=B00000000;
cube_pattern[1][4]=B00000000;
cube_pattern[1][5]=B00000000;
cube_pattern[1][6]=B00000000;
cube_pattern[1][7]=B00000000;
cube_pattern[2][0]=B00000000;
cube_pattern[2][1]=B00000000;
cube_pattern[2][2]=B00000000;
cube_pattern[2][3]=B00000000;
cube_pattern[2][4]=B00000000;
cube_pattern[2][5]=B00000000;
cube_pattern[2][6]=B00000000;
cube_pattern[2][7]=B00000000;
cube_pattern[3][0]=B00000000;
cube_pattern[3][1]=B00000000;
cube_pattern[3][2]=B00000000;
cube_pattern[3][3]=B00000000;
cube_pattern[3][4]=B00000000;
cube_pattern[3][5]=B00000000;
cube_pattern[3][6]=B00000000;
cube_pattern[3][7]=B00000000;
cube_pattern[4][0]=B00000000;
cube_pattern[4][1]=B00000000;
cube_pattern[4][2]=B00000000;
cube_pattern[4][3]=B00000000;
cube_pattern[4][4]=B00000000;
cube_pattern[4][5]=B00000000;
cube_pattern[4][6]=B00000000;
cube_pattern[4][7]=B00000000;
cube_pattern[5][0]=B00000000;
cube_pattern[5][1]=B00000000;
cube_pattern[5][2]=B00000000;
cube_pattern[5][3]=B00000000;
cube_pattern[5][4]=B00000000;
cube_pattern[5][5]=B00000000;
cube_pattern[5][6]=B00000000;
cube_pattern[5][7]=B00000000;
cube_pattern[6][0]=B00000000;
cube_pattern[6][1]=B00000000;
cube_pattern[6][2]=B00000000;
cube_pattern[6][3]=B00000000;
cube_pattern[6][4]=B00000000;
cube_pattern[6][5]=B00000000;
cube_pattern[6][6]=B00000000;
cube_pattern[6][7]=B00000000;
cube_pattern[7][0]=B00000000;
cube_pattern[7][1]=B00000000;
cube_pattern[7][2]=B00000000;
cube_pattern[7][3]=B00000000;
cube_pattern[7][4]=B00000000;
cube_pattern[7][5]=B00000000;
cube_pattern[7][6]=B00000000;
cube_pattern[7][7]=B00000000;
currentLayer = 0;
}
void loop() {
}
void renderCube() {
byte layer = (currentLayer++)&0x7;
transferLayer(layer);
ONLayer(layer);
}
void transferLayer(byte layer) {
bitClear(PORTB, RCLK_COL_BIT);
//digitalWrite(RCLK_COL, LOW);
for(int i = 0; i < cube_size; i++) {
SPI.transfer(cube_pattern[layer][i]);
}
//digitalWrite(RCLK_COL, HIGH);
bitSet(PORTB, RCLK_COL_BIT);
}
void ONLayer(int layer) {
PORTD = B00000000;
bitClear(PORTD, RCLK_LAYERS_BIT);
for(int i = 0; i < cube_size; i++) {
bitClear(PORTD, SRCLK_LAYERS_BIT);
bitSet(PORTD, layers[layer][i]);
bitSet(PORTD, RCLK_LAYERS_BIT);
}
bitSet(PORTD, RCLK_LAYERS_BIT);
}
//void OFFLayer(int layer) {
// digitalWrite(RCLK_LAYERS, LOW);
// for(int i = 0; i < cube_size; i++) {
// digitalWrite(SRCLK_LAYERS, LOW);
// digitalWrite(SER_LAYERS, 1);
// digitalWrite(SRCLK_LAYERS, HIGH);
// }
// digitalWrite(RCLK_LAYERS, HIGH);
//}
void layersRCLKOFF() {
bitClear(PORTD, RCLK_LAYERS_BIT);
}
void layersRCLKON() {
bitSet(PORTD, RCLK_LAYERS_BIT);
}
void layersSRCLKOFF() {
bitClear(PORTD, SRCLK_LAYERS_BIT);
}
void layersSRCLKON() {
bitClear(PORTD, SRCLK_LAYERS_BIT);
}
void columnsRCLKOFF() {
bitClear(PORTB, RCLK_COL_BIT);
}
void columnsRCLKON() {
bitSet(PORTB, RCLK_COL_BIT);
}
void columnsSRCLKOFF() {
bitClear(PORTB, SRCLK_COL_BIT);
}
void columnsSRCLKON() {
bitSet(PORTB, SRCLK_COL_BIT);
}