#include <LedControl.h>

// DIN, CLK, CS, кількість матриць
LedControl lc = LedControl(12, 11, 10, 2);
#define MATRIX 1

byte digits45[10][8] = {
  { // 0
    B00011000,
    B00100100,
    B01000010,
    B01000010,
    B01000010,
    B00100100,
    B00011000,
    B00000000
  },
  { // 1
    B00001000,
    B00011000,
    B00101000,
    B00001000,
    B00001000,
    B00001000,
    B00111100,
    B00000000
  },
  { // 2
    B00111100,
    B00000100,
    B00001000,
    B00010000,
    B00100000,
    B01000000,
    B01111100,
    B00000000
  },
  { // 3
    B00111100,
    B00000100,
    B00011000,
    B00000100,
    B00000100,
    B00000100,
    B00111100,
    B00000000
  },
  { // 4
    B00000100,
    B00001100,
    B00010100,
    B00100100,
    B01111110,
    B00000100,
    B00000100,
    B00000000
  },
  { // 5
    B01111100,
    B01000000,
    B01111100,
    B00000100,
    B00000100,
    B01000100,
    B00111000,
    B00000000
  },
  { // 6
    B00111000,
    B01000000,
    B01111100,
    B01000100,
    B01000100,
    B01000100,
    B00111000,
    B00000000
  },
  { // 7
    B01111110,
    B00000100,
    B00001000,
    B00010000,
    B00100000,
    B00100000,
    B00100000,
    B00000000
  },
  { // 8
    B00111000,
    B01000100,
    B01000100,
    B00111000,
    B01000100,
    B01000100,
    B00111000,
    B00000000
  },
  { // 9
    B00111000,
    B01000100,
    B01000100,
    B00111100,
    B00000100,
    B00001000,
    B00110000,
    B00000000
  }
};


// Цифри 0–9 (8x8)
byte digits[10][8] = {
  { // 0
    B00111100,
    B01100110,
    B01101110,
    B01110110,
    B01100110,
    B01100110,
    B00111100,
    B00000000
  },
  { // 1
    B00011000,
    B00111000,
    B00011000,
    B00011000,
    B00011000,
    B00011000,
    B00111100,
    B00000000
  },
  { // 2
    B00111100,
    B01100110,
    B00000110,
    B00001100,
    B00110000,
    B01100000,
    B01111110,
    B00000000
  },
  { // 3
    B00111100,
    B01100110,
    B00000110,
    B00011100,
    B00000110,
    B01100110,
    B00111100,
    B00000000
  },
  { // 4
    B00001100,
    B00011100,
    B00101100,
    B01001100,
    B01111110,
    B00001100,
    B00001100,
    B00000000
  },
  { // 5
    B01111110,
    B01100000,
    B01111100,
    B00000110,
    B00000110,
    B01100110,
    B00111100,
    B00000000
  },
  { // 6
    B00111100,
    B01100110,
    B01100000,
    B01111100,
    B01100110,
    B01100110,
    B00111100,
    B00000000
  },
  { // 7
    B01111110,
    B00000110,
    B00001100,
    B00011000,
    B00110000,
    B00110000,
    B00110000,
    B00000000
  },
  { // 8
    B00111100,
    B01100110,
    B01100110,
    B00111100,
    B01100110,
    B01100110,
    B00111100,
    B00000000
  },
  { // 9
    B00111100,
    B01100110,
    B01100110,
    B00111110,
    B00000110,
    B01100110,
    B00111100,
    B00000000
  }
};


const int8_t rot45[8][8][2] = {
  {{3,0},{4,1},{5,2},{6,3},{7,4},{-1,-1},{-1,-1},{-1,-1}},
  {{2,1},{3,2},{4,3},{5,4},{6,5},{7,6},{-1,-1},{-1,-1}},
  {{1,2},{2,3},{3,4},{4,5},{5,6},{6,7},{-1,-1},{-1,-1}},
  {{0,3},{1,4},{2,5},{3,6},{4,7},{-1,-1},{-1,-1},{-1,-1}},
  {{-1,-1},{0,4},{1,5},{2,6},{3,7},{-1,-1},{-1,-1},{-1,-1}},
  {{-1,-1},{-1,-1},{0,5},{1,6},{2,7},{-1,-1},{-1,-1},{-1,-1}},
  {{-1,-1},{-1,-1},{-1,-1},{0,6},{1,7},{-1,-1},{-1,-1},{-1,-1}},
  {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{0,7},{-1,-1},{-1,-1},{-1,-1}}
};


void showDigitCompensated(int matrix, int d) {
  lc.clearDisplay(matrix);

  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 8; x++) {

      if (!bitRead(digits[d][y], 7 - x)) continue;

      int nx = rot45[y][x][0];
      int ny = rot45[y][x][1];

      if (nx >= 0 && ny >= 0)
        lc.setLed(matrix, ny, nx, true);
    }
  }
}


byte reverseByte(byte b) {
  b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;
  b = (b & 0xCC) >> 2 | (b & 0x33) << 2;
  b = (b & 0xAA) >> 1 | (b & 0x55) << 1;
  return b;
}

void setup() {
  lc.shutdown(MATRIX, false);     // увімкнути матрицю
  lc.setIntensity(MATRIX, 8);    // яскравість 0–15
  lc.clearDisplay(MATRIX);
}

void showDigit(int d) {
  for (int row = 0; row < 8; row++) {
    lc.setRow(MATRIX, row, reverseByte(digits45[d][row]));
  }
}

void loop() {
  for (int i = 0; i <= 9; i++) {
    showDigit(i);
    showDigitCompensated(0, i);
    delay(1000);
  }
}