matrix max7219 v10

//http://xantorohara.github.io/led-matrix-editor/#ff00000000000000
//http://robojax.com/learn/arduino/8x8LED/
//We always have to include the library
#include "LedControl.h"
#include <TimerOne.h>

/*
  Now we need a LedControl to work with.
 ***** These pin numbers will probably not work with your hardware *****
  pin 12 is connected to the DataIn
  pin 11 is connected to the CLK
  pin 10 is connected to LOAD
  We have only a single MAX72XX.
*/

const byte interruptPinA = 2;
const byte interruptPinB = 3;
const byte interruptPinC = 18;
const int LEDRIGHT = 7;  // the pin with a LED
const int LEDLEFT = 6;  // the pin with a LED
int ledState = LOW;


volatile byte state = 0;

LedControl lc = LedControl(12, 11, 10, 1);
byte LEFT[] = { B00011000, B00110000, B01100000, B11011111, B11011111, B01100000, B00110000, B00011000};
byte RIGHT[] = { B00011000, B00001100, B00000110, B11111011, B11111011, B00000110, B00001100, B00011000};
byte UP[] = { B00011000, B00111100, B01100110, B11011011, B10011001, B00011000, B00011000, B00011000};
byte DN[] = { B00011000, B00011000, B00011000, B10011001, B11011011, B01100110, B00111100, B00011000};
byte DIAMOND[] = { B00011000, B00111100, B01111110, B11111111, B11111111, B01111110, B00111100, B00011000};
byte SQUARE0[] = { B00000000, B00000000, B00000000, B00011000, B00011000, B00000000, B00000000, B00000000};
byte SQUARE1[] = { B00000000, B00000000, B00111100, B00100100, B00100100, B00111100, B00000000, B00000000};
byte SQUARE2[] = { B00000000, B01111110, B01000010, B01000010, B01000010, B01000010, B01111110, B00000000};
byte SQUARE3[] = { B11111111, B10000001, B10000001, B10000001, B10000001, B10000001, B10000001, B11111111};

byte CIRCLE0[] = { B00000000, B00000000, B00000000, B00011000, B00011000, B00000000, B00000000, B00000000};
byte CIRCLE1[] = { B00000000, B00000000, B00011000, B00100100, B00100100, B00011000, B00000000, B00000000};
byte CIRCLE2[] = { B00000000, B00111100, B01000010, B01000010, B01000010, B01000010, B00111100, B00000000};
byte CIRCLE3[] = { B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10000001, B01111110};


const byte ROTATE[][8] = {
  { B10001111,    B11001110,    B11101100,    B11111000,    B00011111,    B00110111,    B01110011,    B11110001  },
  { B11110001,    B01110011,    B00110111,    B00011111,    B11111000,    B11101100,    B11001110,    B10001111  },
  { B00011100,    B00011100,    B11001000,    B11111011,     B11011111,   B00010011,    B00111000,    B00111000  }
};

const int ROTATE_LEN = sizeof(ROTATE) / 8;

byte BANK[8][8];

byte VAR1[] = { B10000000,
                B10000000,
                B10000000,
                B10000000,
                B10000000,
                B10000000,
                B10000000,
                B10000000
              };
byte TEST[] = { B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B11111111};

byte TEMP[8] ;

/* we always wait a bit between updates of the display */
unsigned long delaytime = 50;

void setup() {
  /*
    The MAX72XX is in power-saving mode on startup,
    we have to do a wakeup call
  */
  lc.shutdown(0, false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0, 8);
  /* and clear the display */
  lc.clearDisplay(0);

  attachInterrupt(digitalPinToInterrupt(interruptPinA), MovetoLEFT, CHANGE);
  attachInterrupt(digitalPinToInterrupt(interruptPinB), MovetoRIGHT, CHANGE);
  attachInterrupt(digitalPinToInterrupt(interruptPinC), OFFMATRIX, CHANGE);

  Timer1.initialize(500000);
  Timer1.attachInterrupt(blinkLED); // blinkLED to run every 500ms
  pinMode(LEDRIGHT, OUTPUT);
  pinMode(LEDLEFT, OUTPUT);

}

void blinkLED(void)
{
  if (ledState == LOW) {
    ledState = HIGH;
  } else {
    ledState = LOW;
  }

  if (state == 1)
    digitalWrite(LEDRIGHT, ledState);
  else
    digitalWrite(LEDRIGHT, HIGH);

  if (state == 2)
    digitalWrite(LEDLEFT, ledState);
  else
    digitalWrite(LEDLEFT, HIGH);

}

void matrix(byte PARAM[]) {
  for (int i = 0; i < 8; i++) {
    lc.setRow(0, i, PARAM[i]);
  }
}

void matrixShiftRIGHT(void) {
  //SHift to left
  memcpy(TEMP, RIGHT, 8); // or strcpy( TEMP, RIGHT);
  for (int j = 8; j > 0; j--) {
    for (int i = 0; i < 8; i++) {
      TEMP[i] = TEMP[i] << j;
    }
    matrix(TEMP);
    delay(delaytime);
    memcpy(TEMP, RIGHT, 8);
  }

  for (int j = 1; j < 8; j++) {
    for (int i = 0; i < 8; i++) {
      TEMP[i] = TEMP[i] >> j;
    }
    matrix(TEMP);
    delay(delaytime);
    memcpy(TEMP, RIGHT, 8);
  }
}

void matrixShiftLEFT(void) {

  //SHift to left
  memcpy(TEMP, LEFT, 8);
  for (int j = 8; j > 0; j--) {
    for (int i = 0; i < 8; i++) {
      TEMP[i] = TEMP[i] >> j;
    }
    matrix(TEMP);
    delay(delaytime);
    memcpy(TEMP, LEFT, 8);
  }

  for (int j = 0; j < 8; j++) {
    for (int i = 0; i < 8; i++) {
      TEMP[i] = TEMP[i] << j;
    }
    matrix(TEMP);
    delay(delaytime);
    memcpy(TEMP, LEFT, 8);
  }
}

void matrixShiftUP(void) {
  int k = 0;
  memcpy(TEMP, UP, 8);
  memcpy(BANK[k++], TEMP, 8);
  //  matrix(TEMP);
  //  delay(delaytime);
  for (int j = 0; j < 8; j++) {
    for (int i = 7; i > 0; i--) {
      TEMP[i] = TEMP[i - 1];
    }
    TEMP[0] = 0;
    //    matrix(TEMP);
    memcpy(BANK[k++], TEMP, 8);
    //    delay(delaytime);
  }

  for (int j = 7; j >= 0; j--) {
    matrix(BANK[j]);
    delay(delaytime);
  }


  memcpy(TEMP, UP, 8);
  for (int i = 0; i < 7; i++) {
    for (int i = 0; i < 7; i++) {
      TEMP[i] = TEMP[i + 1];
    }
    TEMP[7] = 0;
    matrix(TEMP);
    delay(delaytime);
  }
}

void matrixShiftDN(void) {
  memcpy(TEMP, DN, 8);
  matrix(TEMP);
  delay(delaytime);
  for (int i = 0; i <= 8; i++) {
    for (int i = 6; i >= 0; i--) {
      TEMP[i + 1] = TEMP[i];
    }
    TEMP[0] = 0;
    matrix(TEMP);
    delay(delaytime);
  }
}

void matrixShiftSquare(void) {
  int delayTime = 150;
  matrix(SQUARE0);
  delay(delayTime);
  matrix(SQUARE1);
  delay(delayTime);
  matrix(SQUARE2);
  delay(delayTime);
  matrix(SQUARE3);
  delay(delayTime);
  lc.clearDisplay(0);
  delay(delayTime);
  matrix(SQUARE2);
  delay(delayTime);
  matrix(SQUARE1);
  delay(delayTime);
  matrix(SQUARE0);
  delay(delayTime);
  lc.clearDisplay(0);
  delay(delayTime);
}

void matrixRotateLED(void) {
  int delayTime = 150;
    matrix(ROTATE[0]);
    delay(delayTime);
    matrix(ROTATE[1]);
    delay(delayTime);
    matrix(ROTATE[2]);
    delay(delayTime);
}

void loop() {
  //  switch (state) {
  //    case 0:
  //      break;
  //    case 1:
  //      break;
  //  }
  if (state == 1) {
    matrixShiftRIGHT();
  } if (state == 2) {
    matrixShiftLEFT();
  }
  if (state == 3) {
    //    lc.clearDisplay(0);
    matrixRotateLED();
  }

  //  matrixShiftUP();
  //  matrixShiftUP();
  //  matrixShiftUP();
  //  matrixShiftLEFT();
  //  matrixShiftLEFT();
  //  matrixShiftLEFT();
  //  matrixShiftRIGHT();
  //  matrixShiftRIGHT();
  //  matrixShiftRIGHT();

  //  matrix(LEFT);
  //  delay(delaytime);
  //  matrix(RIGHT);
  //  delay(delaytime);
  //  matrix(UP);
  //  delay(delaytime);
  //  matrix(DIAMOND);
  //  delay(delaytime);
  //  matrix(SQUARE);
  //  delay(delaytime);
  //  matrix(SQUARE1);
  //  delay(delaytime);
  //  matrix(SQUARE2);
  //  delay(delaytime);
  //  matrix(SQUARE3);
  //  delay(delaytime);

  //    matrix(CIRCLE0);
  //    delay(delaytime);
  //    matrix(CIRCLE1);
  //    delay(delaytime);
  //    matrix(CIRCLE2);
  //    delay(delaytime);
  //    matrix(CIRCLE3);
  //    delay(delaytime);

  //  for (int i = 0; i < 4; i++) {
  //    matrix(CIRCLE3);
  //    delay(delaytime);
  //    matrix(CIRCLE2);
  //    delay(delaytime);
  //    matrix(CIRCLE1);
  //    delay(delaytime);
  //  }
  //  lc.clearDisplay(0);
  //  delay(100);
}

void MovetoLEFT() {
  state = 1;
}

void MovetoRIGHT() {
  state = 2;
}

void OFFMATRIX() {
  state = 3;
}