#define interval 250UL
#define r0Pin 7
#define r1Pin 8
#define r2Pin 9
#define r3Pin 10
#define r4Pin 11
#define r5Pin 12
#define r6Pin 13

#define c0Pin 6
#define c1Pin 5
#define c2Pin 4
#define c3Pin 3
#define c4Pin 2

uint8_t rowPins[] = {r0Pin, r1Pin, r2Pin, r3Pin, r4Pin, r5Pin, r6Pin};
const uint8_t numberOfRows = sizeof(rowPins); // size of uint8_t = 1 byte;

uint8_t colPins[] = {c0Pin, c1Pin, c2Pin, c3Pin, c4Pin};
const uint8_t numberOfCols = sizeof(colPins); // size of uint8_t = 1 byte;


typedef struct {
  uint8_t x[5];
} font_t;

const font_t aFont = {0x7E, 0x11, 0x11, 0x11, 0x7E};
const font_t bFont = {0x7F, 0x49, 0x49, 0x49, 0x36};
const font_t cFont = {0x3E, 0x41, 0x41, 0x41, 0x22};
const font_t dFont = {0x7F, 0x41, 0x41, 0x41, 0x3E};

const font_t myFont[] = {aFont, bFont, cFont, dFont};

const uint8_t size = sizeof(myFont);
const uint8_t numberOfFonts = size / sizeof(font_t);
uint8_t fontIndex;

uint8_t xIndex;
uint8_t yIndex;

font_t buffer;
bool blank;

void setup() {
  for (uint8_t y = 0; y < numberOfRows; y++) {
    pinMode(rowPins[y], OUTPUT);
  }

  for (uint8_t x = 0; x < numberOfCols; x++) {
    pinMode(colPins[x], OUTPUT);
  }
  fontIndex = size - 1;
  blank = false;
}

void loop() {
  Matrix();
  if (!Trigger()) return;
  if (!blank) fontIndex = (fontIndex + 1) % size;
  if (blank) {
    LeftShift(0x00);
    blank = false;
    return;
  } else {
    LeftShift(myFont[fontIndex / 5].x[fontIndex % 5]);
  }
  if ((fontIndex + 1) % 5 == 0) blank = true;
}

void Matrix() {
  for (uint8_t x = 0; x < numberOfCols; x++) {
    uint8_t value = buffer.x[x];
    for (uint8_t y = 0; y < numberOfRows; y++) {
      ClearMatrix();
      if (bitRead(value, y)) {
        digitalWrite(rowPins[y], HIGH);
        digitalWrite(colPins[x], LOW);
      }
      delay(1);
    }
  }
}

void ClearMatrix() {
  for (uint8_t y = 0; y < numberOfRows; y++) {
    digitalWrite(rowPins[y], LOW);
  }
  for (uint8_t x = 0; x < numberOfCols; x++) {
    digitalWrite(colPins[x], HIGH);
  }
}

void LeftShift(uint8_t value) {
  uint8_t len = numberOfCols - 1;
  for (uint8_t x = 0; x < len; x++) {
    buffer.x[x] = buffer.x[x + 1];
  }
  buffer.x[len] = value;
}

bool Trigger() {
  static unsigned long startTime;
  unsigned long currTime = millis();
  unsigned long elapsedTime = currTime - startTime;
  if (elapsedTime < interval) return false;
  startTime = currTime;
  return true;
}