HardwareDesign/8By8/8By8.ino

#include "TimerOne.h"

#define TIME_PER_LAYER_IN_US 700
#define BUS_START_PIN 22
#define CLOCK_START_PIN 30
#define SW_START_PIN 38

class Cube {
private:
  static int layer_count;
  static int brightness_count;
  static bool blinking_LED_status;

public:
  // Every int represents a row of 8 LED status.
  static uint16_t LED_status[8][8];
  static uint16_t LED_brightness[8][8];
  static uint8_t LED_blinking_status[8][8];

  static void set_blinking(int x, int y, int z) {
    // 1 = enable blinking
    if (x >= 8 || x < 0 || y >= 8 || y < 0 || z >= 8 || z < 0) {
      return;
    }
    LED_blinking_status[z][x] = LED_blinking_status[z][x] | (1 << y);
  }

  static void unset_blinking(int x, int y, int z) {
    if (x >= 8 || x < 0 || y >= 8 || y < 0 || z >= 8 || z < 0) {
      return;
    }
    LED_blinking_status[z][x] = LED_blinking_status[z][x] & (~1 << y);

    LED_status[z][x] = (LED_status[z][x] & (~(3 << (y * 2)))) |
                       (LED_brightness[z][x] & (3 << (y * 2)));
  }

  static void do_blinking() {
    blinking_LED_status ^= 1;
    for (int i = 0; i < 8; i++) {
      for (int j = 0; j < 8; j++) {
        for (int k = 0; k < 8; k++) {
          if (LED_blinking_status[i][j] >> k & 1) {
            if (blinking_LED_status) {
              LED_status[i][j] = LED_brightness[i][j];
            } else {
              LED_status[i][j] = LED_status[i][j] & (~(3 << (k * 2)));
            }
          }
        }
      }
    }
  }

  static void display() {
    // Serial.println("Here");
    if (brightness_count >= 2) {
      digitalWrite(SW_START_PIN + layer_count, LOW);
      layer_count = (layer_count + 1) % 8;
    }

    brightness_count = (brightness_count + 1) % 3;

    for (int i = 0; i < 8; i++) {
      for (int j = 0; j < 8; j++) {
        // In LED_status:
        // 0 = off
        // 4 = brightest
        digitalWrite(BUS_START_PIN + j,
                     ((LED_status[layer_count][i] >> (j * 2)) & 3) >=
                         (3 - brightness_count));
      }
      digitalWrite(CLOCK_START_PIN + i, HIGH);
      digitalWrite(CLOCK_START_PIN + i, LOW);
    }

    digitalWrite(SW_START_PIN + layer_count, HIGH);
  }

  static void set_status(int x, int y, int z, int brightness) {
    if (x >= 8 || x < 0 || y >= 8 || y < 0 || z >= 8 || z < 0) {
      return;
    }
    brightness %= 4;
    LED_status[z][x] =
        (LED_status[z][x] & (~(3 << (y * 2)))) | (brightness << (y * 2));
    LED_brightness[z][x] =
        (LED_brightness[z][x] & (~(3 << (y * 2)))) | (brightness << (y * 2));
  }

  static int get_status(int x, int y, int z) {
    return LED_brightness[z][x] >> (y * 2) & 3;
  }

  static void clear() {
    for (int i = 0; i < 8; i++) {
      for (int j = 0; j < 8; j++) {
        LED_brightness[i][j] = 0;
        LED_status[i][j] = 0;
      }
    }
  }

  static void draw_line(int x, int y, int z, int length, int direction,
                        int brightness) {
    if (x >= 8 || x < 0 || y >= 8 || y < 0 || z >= 8 || z < 0) {
      return;
    }
    if (direction >= 3 || direction < 0 || length <= 0 || brightness >= 4 ||
        brightness < 0) {
      return;
    }
    // 0: x
    // 1: y
    // 2: z
    switch (direction) {
    case 0:
      for (int i = 0; i < length; i++) {
        set_status(x + i, y, z, brightness);
      }
      break;
    case 1:
      for (int i = 0; i < length; i++) {
        set_status(x, y + i, z, brightness);
      }
      break;
    case 2:
      for (int i = 0; i < length; i++) {
        set_status(x, y, z + i, brightness);
      }
      break;
    }
  }
};

int Cube::layer_count = 0;
int Cube::brightness_count = 0;
uint16_t Cube::LED_status[8][8] = {0};
uint16_t Cube::LED_brightness[8][8] = {0};
uint8_t Cube::LED_blinking_status[8][8] = {0};
bool Cube::blinking_LED_status = false;
int bright = 3;

void setup() {
  for (int i = 22; i < 46; i++) {
    pinMode(i, OUTPUT);
  }

  Timer1.initialize();
  Timer1.setPeriod(TIME_PER_LAYER_IN_US);
  Timer1.attachInterrupt(Cube::display);

  cli();
  TCCR4A = 0; // set entire TCCR1A register to 0
  TCCR4B = 0; // same for TCCR1B
  TCNT4 = 0;  // initialize counter value to 0
  // set compare match register for 1hz increments
  OCR4A = 7500 / 1; // = (16*10^6) / (1*1024) - 1 (must be <65536)
  // turn on CTC mode
  TCCR4B |= (1 << WGM12);
  // Set CS12 and CS10 bits for 1024 prescaler
  TCCR4B |= (1 << CS12) | (1 << CS10);
  // enable timer compare interrupt
  TIMSK4 |= (1 << OCIE4A);
  sei();

  Cube::set_blinking(1, 1, 1);
  Serial.begin(115200);
}

void loop() {
  for (int i = 7; i >= 0; i--) {
    for (int j = 0; j < 8; j++) {
      for (int k = 0; k < 8; k++) {
        Cube::set_status(i, j, k, 3);
        delay(5);
      }
    }
  }
}

ISR(TIMER4_COMPA_vect) { Cube::do_blinking(); }