/*

  ============================================
  code is placed under the MIT license
  Copyright (c) 2023 J-M-L
  For the Arduino Forum : https://forum.arduino.cc/u/j-m-l
  https://forum.arduino.cc/t/chainer-trois-matrices-led-avec-un-max-7219/1306034$0

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ===============================================
*/

#include <SPI.h>
#include "Symboles.h"

// Définition des constantes pour les broches et le nombre de segments
constexpr byte clkPin = 13;
constexpr byte dataPin = 11;
constexpr byte csPin = 3;
constexpr byte nbModulesX = 4;  // 32 pixels de large (4 segments de 8 pixels)
constexpr byte nbModulesY = 3;  // 24 pixels de haut (3 segments de 8 pixels)

// Un framebuffer pour stocker l'état de toute la matrice de LED
// Chaque octet représente une colonne de 8 pixels (dans un module)
uint8_t frameBuffer[nbModulesX][nbModulesY * 8];  // Taille 32x24

// Fonction pour envoyer des données à un MAX7219 spécifique
void envoiSPI(byte segment, byte adresse, byte donnees) {
  digitalWrite(csPin, LOW);
  for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
    if (i == segment) {
      SPI.transfer(adresse);  // Envoyer l'adresse et les données pour le bon segment
      SPI.transfer(donnees);
    } else {
      SPI.transfer(0);  // Ne rien envoyer aux autres segments
      SPI.transfer(0);
    }
  }
  digitalWrite(csPin, HIGH);
}

// Fonction pour allumer ou éteindre un pixel aux coordonnées (x, y)
void definirPixel(int x, int y, bool alllume) {
  if (x < 0 || x >= nbModulesX * 8 || y < 0 || y >= nbModulesY * 8) return;  // Vérifie les limites

  // Calcul du segment (bloc 8x8) et de la position dans le segment
  int moduleX = x / 8;            // module horizontal (bloc de 8x8 pixels)
  int colonneDansModule = x % 8;  // Colonne dans le module
  int ligneSegment = y;           // Ligne dans la grille

  // Allume ou éteint le bit correspondant dans le framebuffer
  if (alllume) {
    frameBuffer[moduleX][ligneSegment] |= (1 << (7 - colonneDansModule)); // on met le bit à 1
  } else {
    frameBuffer[moduleX][ligneSegment] &= ~(1 << (7 - colonneDansModule)); // on met le bit à 0
  }
}

// Fonction pour envoyer le framebuffer aux MAX7219
void afficher() {
  for (byte ligne = 0; ligne < 8; ligne++) {  // Pour chaque ligne dans un module
    for (byte moduleX = 0; moduleX < nbModulesX; moduleX++) {  // Parcourt chaque segment horizontal
      for (byte segmentY = 0; segmentY < nbModulesY; segmentY++) {  // Parcourt chaque segment vertical
        byte colonne = frameBuffer[moduleX][ligne + (segmentY * 8)];
        envoiSPI(moduleX + segmentY * nbModulesX, 8 - ligne, colonne);
      }
    }
  }
}

void effacer() {
  memset(frameBuffer, 0, sizeof frameBuffer);
  afficher();  // met à jour l'affichage
}

void chargerBitmap8x8(const byte bitmap[], int positionX, int positionY) {
  for (int ligne = 0; ligne < 8; ligne++) {
    byte octet = pgm_read_byte_near(bitmap + (7 - ligne));  // Inverser les lignes (pour corriger la tête en bas)
    for (int colonne = 0; colonne < 8; colonne++) {
      bool alllume = (octet & (1 << (7 - colonne))) != 0;  // Lire les bits de droite à gauche pour corriger le flip horizontal
      definirPixel(positionX + colonne, positionY + ligne, alllume);  // Définir le pixel dans le framebuffer
    }
  }
  afficher();  // Mettre à jour l'affichage
}

void afficherBitmap8x8(const byte bitmap[], int positionX, int positionY) {
  chargerBitmap8x8(bitmap, positionX, positionY);
  afficher();  // Mettre à jour l'affichage
}


void setup() {
  Serial.begin(115200);
  pinMode(clkPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(csPin, OUTPUT);
  SPI.beginTransaction(SPISettings(16000000, MSBFIRST, SPI_MODE0));

  // Configuration initiale pour chaque MAX7219
  for (byte i = 0; i < nbModulesX * nbModulesY; i++) {
    envoiSPI(i, 0x0f, 0x00);  // registre de test - mode test désactivé
    envoiSPI(i, 0x0b, 0x07);  // registre de limite de scan - affiche les chiffres 0 à 7
    envoiSPI(i, 0x0c, 0x01);  // registre de mise en marche - fonctionnement normal
    envoiSPI(i, 0x0a, 0x0f);  // registre d'intensité - luminosité maximale
    envoiSPI(i, 0x09, 0x00);  // registre de mode de décodeur - pas de décodeur
  }

  // exemple d'affichage

  // on parcourt chaque pixel de la matrice
  for (int y = 0; y < nbModulesY * 8; y++) {
    for (int x = 0; x < nbModulesX * 8; x++) {
      definirPixel(x, y, true);  // Allume le pixel
    }
    afficher();  // Met à jour l'affichage
  }

  delay(1000);
  effacer();

  // affichage les bitmaps des 10 chiffres de 0 à 9
  int positionX = 0;
  int positionY = 0;
  for (byte i = 0; i < 10; i++) {
    afficherBitmap8x8(chiffres[i], positionX, positionY);
    if (((i + 1) % nbModulesX == 0)) {
      positionX = 0;
      positionY += 8;
    } else {
      positionX += 8;
    }
  }
  delay(3000);
  effacer();


  afficherBitmap8x8(symboleAddition, 0, 0);
  afficherBitmap8x8(symboleSoustraction, 8, 0);
  afficherBitmap8x8(symboleDivision, 16, 0);
  afficherBitmap8x8(symboleMultiplication, 24, 0);

  afficherBitmap8x8(symbolePourcentage, 0, 8);
  afficherBitmap8x8(symboleCroix, 8, 8);
  afficherBitmap8x8(symbolePlein, 16, 8);
  afficherBitmap8x8(symboleFlash, 24, 8);

  afficherBitmap8x8(symboleExclamation, 0, 16);
  afficherBitmap8x8(symboleCible, 8, 16);
  afficherBitmap8x8(symboleR, 16, 16);

  delay(3000);
  effacer();

  for (int x = 0; x < nbModulesX * 8; x++) {
    effacer();
    chargerBitmap8x8(symboleCible, x, 0);
    chargerBitmap8x8(symboleCroix, x, 8);
    chargerBitmap8x8(symboleFlash, x, 16);
    afficher();
    delay(50);  // Délai entre chaque déplacement
  }
  effacer();

}

void loop() {}