#define CLK 13
#define DIN 11
#define CS 10
#define X_SEGMENTS 4 // Número de segmentos horizontalmente
#define Y_SEGMENTS 4 // Número de segmentos verticalmente
#define NUM_SEGMENTS (X_SEGMENTS * Y_SEGMENTS)

const byte font[26][5] = {
  {0x7E, 0x09, 0x09, 0x09, 0x7E}, // A
  {0x7F, 0x49, 0x49, 0x49, 0x36}, // B
  {0x3E, 0x41, 0x41, 0x41, 0x22}, // C
  {0x7F, 0x41, 0x41, 0x41, 0x3E}, // D
  {0x7F, 0x49, 0x49, 0x49, 0x41}, // E
  {0x7F, 0x09, 0x09, 0x09, 0x01}, // F
  {0x3E, 0x41, 0x49, 0x49, 0x2E}, // G
  {0x7F, 0x08, 0x08, 0x08, 0x7F}, // H
  {0x41, 0x41, 0x7F, 0x41, 0x41}, // I
  {0x20, 0x40, 0x40, 0x40, 0x3F}, // J
  {0x7F, 0x08, 0x14, 0x22, 0x41}, // K
  {0x7F, 0x40, 0x40, 0x40, 0x40}, // L
  {0x7F, 0x02, 0x04, 0x02, 0x7F}, // M
  {0x7F, 0x02, 0x04, 0x08, 0x7F}, // N
  {0x3E, 0x41, 0x41, 0x41, 0x3E}, // O
  {0x7F, 0x09, 0x09, 0x09, 0x06}, // P
  {0x3E, 0x41, 0x49, 0x49, 0x3E}, // Q
  {0x7F, 0x09, 0x19, 0x29, 0x46}, // R
  {0x46, 0x49, 0x49, 0x49, 0x31}, // S
  {0x01, 0x01, 0x7F, 0x01, 0x01}, // T
  {0x3F, 0x40, 0x40, 0x40, 0x3F}, // U
  {0x1F, 0x20, 0x40, 0x20, 0x1F}, // V
  {0x3F, 0x40, 0x30, 0x40, 0x3F}, // W
  {0x63, 0x14, 0x08, 0x14, 0x63}, // X
  {0x11, 0x14, 0x7C, 0x14, 0x11}, // Y
  {0x71, 0x49, 0x45, 0x43, 0x00}, // Z
};

byte fb[8 * NUM_SEGMENTS];

void shiftAll(byte send_to_address, byte send_this_data) {
  digitalWrite(CS, LOW);
  for (int i = 0; i < NUM_SEGMENTS; i++) {
    shiftOut(DIN, CLK, MSBFIRST, send_to_address);
    shiftOut(DIN, CLK, MSBFIRST, send_this_data);
  }
  digitalWrite(CS, HIGH);
}

void setup() {
  Serial.begin(115200);
  pinMode(CLK, OUTPUT);
  pinMode(DIN, OUTPUT);
  pinMode(CS, OUTPUT);
  
  shiftAll(0x0f, 0x00); // Teste de display - desligado
  shiftAll(0x0b, 0x07); // Limite de exibição - 8 dígitos
  shiftAll(0x0c, 0x01); // Operação normal
  shiftAll(0x0a, 0x0f); // Intensidade máxima
  shiftAll(0x09, 0x00); // Modo de decodificação - Nenhum
}

void clear() {
  byte *addr = fb;
  for (byte i = 0; i < 8 * NUM_SEGMENTS; i++)
    *addr++ = 0;
}

void drawChar(char c, byte x_offset, byte y_offset) {
  byte letter = 0;
  if (c >= 'A' && c <= 'Z') {
    letter = c - 'A';
  } else if (c == ' ') {
    clear();
    return;
  }
  
  for (byte x = 0; x < 5; x++) {
    byte col = font[letter][x];
    for (byte y = 0; y < 7; y++) {
      if (col & (1 << y)) {
        set_pixel(x + x_offset, y + y_offset, 1);
      }
    }
  }
}

void set_pixel(uint8_t x, uint8_t y, uint8_t mode) {
  byte *addr = &fb[x / 8 + y * X_SEGMENTS];
  byte mask = 128 >> (x % 8);
  switch (mode) {
    case 0: *addr &= ~mask; break;
    case 1: *addr |= mask; break;
    case 2: *addr ^= mask; break;
  }
}

void show() {
  for (byte row = 0; row < 8; row++) {
    digitalWrite(CS, LOW);
    byte segment = NUM_SEGMENTS;
    while (segment--) {
      byte x = segment % X_SEGMENTS;
      byte y = segment / X_SEGMENTS * 8;
      byte addr = (row + y) * X_SEGMENTS;
      if (segment & X_SEGMENTS) {
        shiftOut(DIN, CLK, MSBFIRST, 8 - row);
        shiftOut(DIN, CLK, LSBFIRST, fb[addr + x]);
      } else {
        shiftOut(DIN, CLK, MSBFIRST, 1 + row);
        shiftOut(DIN, CLK, MSBFIRST, fb[addr - x + X_SEGMENTS - 1]);
      }
    }
    digitalWrite(CS, HIGH);
  }
}

void loop() {
  const char* name = "LUIS"; // Nome a ser exibido
  clear();
  
  byte x_offset = (X_SEGMENTS * 8 - strlen(name) * 5) / 2; // Deslocamento horizontal
  byte y_offset = (Y_SEGMENTS * 8 - 7) / 2; // Deslocamento vertical
  byte spacing = 1;
  
  for (int i = 0; i < strlen(name); i++) {
    drawChar(name[i], x_offset, y_offset);
    show();
    delay(500);
    x_offset += 5 + spacing;
  }
}