Matrix.h

Go to the documentation of this file.

#pragma once
 
#pragma region INCLUSIONS
// Libreria per la gestione della matrice utilizzata: Matrice di LED RGB 16x32 Adafruit
/*
Libreria di autore "Adafruit" per la gestione LowLevel della matrice --> Matrice di LED RGB 16x32 Adafruit
Sorgenti necessarie:
--- RGB Matrix Panel by Adafruit
*/
#include <RGBmatrixPanel.h>
#pragma endregion INCLUSIONS
 
// Namespace di protezione dalle inclusioni multiple con nominazione uguale
/*
I valori constexpr, come spiegato appena sopra, equivalgono alla direttiva '#define'. Questo pu� creare problemi nel momento in cui un singolo file viene incluso
in una gerarchia di molti pi� file, dove si potrebbe riscontrare la presenza di constexpr appartenenti a file diversi ma con gli stessi nomi! Questa ripetitivit� dei nomi deriva
dagli standard di nominazione. Per evitare, quindi, conflitti di multipla definizione, andremo ad utilizzare un 'namespace', che, come dice il nome, fornisce uno SPAZIO per i NOMI del nostro
file in cui il 'namespace' � stato dichiarato ed implementato.
Mantieniamo comunque la specificazione 'static', per evitare errori di linker in caso di inclusioni multiple di questa unit� di traslazione [file].
*/
namespace Matrix__file
{
    // Espressione costante (equivalente della direttiva '#define') per la definizione dei valori 'CLK', 'OE', 'LAT', 'A', 'B', 'C'.
    // Questi valori sono delle costanti immutabili che rappresentano VALORI DI DEFAULT scelti dal creatore ed implementatore della classe.
    // L'utilizzo di un metodo di inizializzazione di default 'Init (1)' provocher� l'uso di tali valori.
    // L'utilizzo, se disponibile, di un metodo di inizializzazione parametrico 'Init (2)' NON provocher� l'utilizzo di tali valori.
    /*Questi valori risiederanno nel Data Segment*/
 
    // Rappresentano i PIN e le IMPOSTAZIONI di comunicazione seriale utilizzati per lo scambio di informazioni tra Arduino e la Matrice
    static constexpr auto _CLK = 8;
    static constexpr auto _OE = 9;
    static constexpr auto _LAT = 10;
    static constexpr auto _A = A0;
    static constexpr auto _B = A1;
    static constexpr auto _C = A2;
 
    // Rappresenta lo stato di utilizzo della modalit� "Double Buffering"
    /*
    // scrivere subito !!!!!!!!!!!!!!!!!!
    */
    static constexpr bool _DOUBLE_BUFFERING = true;
 
    // Espressione costante per la definizione del valore 'w' [widht -- larghezza] di una immagine bitmap
    static constexpr auto _w = 32;
    // Espressione costante per la definizione del valore 'h' [height -- altezza] di una immagine bitmap
    static constexpr auto _h = 16;
}
 
class Matrix
{
    /*Blocco trivial*/
    /*
    Stiamo trattando una classe interamente statica. Per la definizione di staticit�, descritta successivamente, questa classe funger� solamente
    da "contenitore astratto" per organizzare pi� logicamente i dati. In verit�, tutto risieder� principalmente nel Data Segment, quindi sar�
    globale, ma statico (anche questo descritto successivamente).
    Questa staticit� implica la NON necessit� di creare istanze di questa classe, che risulterebbero totalmente inutili dato che tutti gli attributi
    e i metodi esistono nell'ambito globale.
    Per evitare, quindi, inutili istanziamenti, verranno bloccati il costruttore trivial (di default generato dal compilatore) e il distruttore, reso
    inutile dalla non-istanziabilit� della classe stessa.
    */
private:
    // Blocco attraverso privatizzazione del costruttore trivial
    Matrix() = default;
    // Blocco attraverso privatizzazione del distruttore trivial
    ~Matrix() = default;
 
    /*Enumerazioni*/
    /*
    Una enumerazione permette una gestione pi� intelligente degli "switcher" forniti all'utente finale.
    Tramite nomi significativi, si gestiscono gli "switcher" appunto con dei nomi, utilizzati per mascherare i valori di enumerazione meno significativi per l'utente.
    Anche qua si applica la staticit� descritta successivamente. Una classe di enumarazione � automaticamente statica.
    */
public:
    enum class IncrementalModifyBuffer
    {
        LOCK_INCREMENTAL_MODIFY,
        ALLOW_INCREMENTAL_MODIFY,
        INVALID_REFERENCE
    };
    
    enum class Color
    {
        AQUA,           /*0, 255, 255*/
        BLACK,          /*0, 0, 0*/
        BLUE,           /*0, 0, 255*/
        FUCHSIA,        /*255, 0, 255*/
        GREEN,          /*0, 128, 0*/
        LIME,           /*0, 255, 0*/
        NAVY,           /*0, 0, 128*/
        PURPLE,         /*128, 0, 128*/
        RED,            /*255, 0, 0*/
        TEAL,           /*0, 128, 128*/
        WHITE,          /*255, 255, 255*/
        YELLOW,         /*255, 255, 0*/
    };
 
    /*Attributi*/
private:
    // Puntatore alla matrice stessa, rappresentata da un oggetto di classe "RGBmatrixPanel"
    /*
    Questa variabile conterr� l'istanza dell'oggetto matrice creata durante l'operazione di inizializzazione.
    L'oggetto sar� sottoposto ad allocazione dinamica [heap]. Questo per evitare problemi con la deallocazione mirata all'ambito
    caratteristica della memoria statica [stack]. Una allocazione statica [stack] provocherebbe l'allocazione e successiva deallocazione
    immediata dell'oggetto esistendo solamente nell'ambito di inizializzazione.
    Essendo statica, la variabile (puntatore) verr� allocata nel 'Data Segment' (segmento dei dati) ed "esister�" fino a termine
    del programma stesso. Quindi si tratta di una variabile globale, ma statica. Questo la rende esistente solamente in questa unit�
    di traslazione (file).
    */
    static RGBmatrixPanel* m_Matrix;
 
    /*Seguiranno tutti gli attributi che si riferiscono ai PIN e alle IMPOSTAZIONI di comunicazione tra Arduino e Matrice*/
    // Valore --> CLK
    static unsigned int m_CLK;
 
    // Valore --> OE
    static unsigned int m_OE;
 
    // valore --> LAT
    static unsigned int m_LAT;
 
    // Valore --> A
    static unsigned int m_A;
 
    // Valore --> B
    static unsigned int m_B;
 
    // Valore --> C
    static unsigned int m_C;
 
    // Valore --> DOUBLE_BUFFERING
    static bool m_DOUBLE_BUFFERING;
 
    // Indica se la matrice � stata gi� avviata (con il metodo 'Begin') oppure no
    static bool m_isStarted;
 
    /*Attributi per la definizione del logo originale GBE*/
    // 'G', 32x16px
    static const unsigned char G_bitmap[64] PROGMEM = 
    {
        0x00, 0x00, 0x00, 0x00, 0x7f, 0x80, 0x00, 0x00, 0x7f, 0x80, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00,
        0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x67, 0x80, 0x00, 0x00,
        0x67, 0x80, 0x00, 0x00, 0x61, 0x80, 0x00, 0x00, 0x61, 0x80, 0x00, 0x00, 0x61, 0x80, 0x00, 0x00,
        0x61, 0x80, 0x00, 0x00, 0x7f, 0x80, 0x00, 0x00, 0x7f, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };
 
    // 'B', 32x16px
    static const unsigned char B_bitmap[64] PROGMEM = 
    {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xe0, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x0c, 0x30, 0x00,
        0x00, 0x0c, 0x30, 0x00, 0x00, 0x0c, 0x30, 0x00, 0x00, 0x0c, 0x30, 0x00, 0x00, 0x0f, 0xe0, 0x00,
        0x00, 0x0f, 0xe0, 0x00, 0x00, 0x0c, 0x30, 0x00, 0x00, 0x0c, 0x30, 0x00, 0x00, 0x0c, 0x30, 0x00,
        0x00, 0x0c, 0x30, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x0f, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00
    };
 
    // 'E', 32x16px
    static const unsigned char E_bitmap[64] PROGMEM = 
    {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x01, 0x80,
        0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x01, 0xfe,
        0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x01, 0x80,
        0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x01, 0xfe, 0x00, 0x00, 0x00, 0x00
    };
 
    // 'wifi', 32x16px
    static const unsigned char wifi_bitmap[64] PROGMEM = 
    {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x10, 0x08, 0x00,
        0x00, 0x20, 0x04, 0x00, 0x00, 0x40, 0x02, 0x00, 0x00, 0x07, 0xe0, 0x00, 0x00, 0x08, 0x10, 0x00,
        0x00, 0x10, 0x08, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x04, 0x20, 0x00, 0x00, 0x01, 0x80, 0x00,
        0x00, 0x03, 0xc0, 0x00, 0x00, 0x03, 0xc0, 0x00, 0x00, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00
    };
 
    // 'cross', 32x16px
    static const unsigned char cross_bitmap[64] PROGMEM = 
    {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x20,
        0x00, 0x00, 0x00, 0x50, 0x00, 0x00, 0x00, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
    };
 
    /*Init*/
public:
    // Inizializza la matrice tramite il costruttore della classe "RGBmatrixPanel"
    /*
    Questo metodo, fondamentale, "d� vita" alla matrice. Effettua una allocazione (dinamica [heap]) attraverso un costruttore
    parametrico della classe "RGBmatrixPanel". Questo costruttore richiede 7 parametri. Il loro significato � riportato
    nel namespace ad inizio file.
    I parametri, per evitare inutili copie, vengono passati per riferimento [reference --> '&'] (ove possibile).
    Il metodo ritorna un valore booleano, utilizzato per comunicare eventuali errori durante l'allocazione.
    Inoltre, prima dell'effettiva allocazione, esegue una deallocazione [delete] se necessaria.
    Anche qua ritroviamo la specificazione di staticit�. Nel caso di applicazione ad un metodo, dissocia il metodo stesso da qualsiasi possibile istanza
    della classe. Quindi, il metodo sar� richiamabile come se fosse globale (e statico). Sar� solamente necessario anteporre il nome della classe di
    appartenenza. Ricordiamo anche che i metodi statici possono operare solo su variabili statiche, che anch'esse, essendo globali (e statiche) sono
    totalmente dissociate da possibili istanze della classe stessa (da oggetti).
    */
 
    // Init (1) --> default
    // Utilizzer� i valori forniti dalle espressioni costanti [constexpr] dichiarate all'inizio dell'intestazione
    static bool Init();
 
    // Init (2) --> parametrico
    // Utilizzer� i valori forniti dalle espressioni costanti [constexpr] dichiarate all'inizio dell'intestazione
    // Utilizzer� il valore fornito come parametro dall'utente richiamante questo metodo solamente per l'assegnazione del valore all'attributo 'm_DOUBLE_BUFFERING'
    static bool Init(const bool& t_DOUBLE_BUFFERING);
 
    // Init (3) --> parametrico
    // Utilizzer� i valori forniti dai parametri forniti dall'utente richiamante questo metodo
    static bool Init(const unsigned int& t_A, const unsigned int& t_B, const unsigned int& t_C,
        const unsigned int& t_CLK, const unsigned int& t_LAT, const unsigned int& t_OE,
        const bool& t_DOUBLE_BUFFERING);
        
    /*Service Management*/
public:
    // Avvia la matrice
    /*
    Il seguente metodo permette di avviare la matrice dopo la sua inizializzazione.
    Da specificare che l'inizializzazione effttuata nel metodo 'Init' non corrisponde all'avvio della matrice stessa effettuato nel metodo seguente 'Begin'.
    */
    static bool Begin();
 
    /*LowLevel getters*/
    /*
    I seguenti metodi LowLevel sono supposti soprattutto per uso a scopo di debug e management manuale.
    Forniscono un punto di accesso costante a VALORE MODIFICABILE (quindi dereferenziabile ma non reindirizzabile).
    In release mode, potrebbe risultare efficace cambiare il contrassegno da 'public' a 'private'.
    Anche qua, per via della staticit�, viene applicata la gestione analizzata prima.
    */
public:
    // Ritorna un puntatore a 'm_Matrix'
    static RGBmatrixPanel* const get_Matrix();
 
    // Ritorna un puntatore a 'm_CLK'
    static unsigned int* const get_CLK();
 
    // Ritorna un puntatore a 'm_OE'
    static unsigned int* const get_OE();
 
    // Ritorna un puntatore a 'm_LAT'
    static unsigned int* const get_LAT();
 
    // Ritorna un puntatore a 'm_A'
    static unsigned int* const get_A();
 
    // Ritorna un puntatore a 'm_B'
    static unsigned int* const get_B();
 
    // Ritorna un puntatore a 'm_C'
    static unsigned int* const get_C();
 
    // Ritorna un puntatore a 'm_DOUBLE_BUFFERING'
    static bool* const get_DOUBLE_BUFFERING();
 
    /*LowLevel reallocator*/
    /*
    Il seguente metodo � supposto soprattutto per uso a scopo di debug e management manuale.
    Esegue una riallocazione dell'oggetto sensore costruito con il rispettivo costruttore parametrico (della libreria "DHT") con i valori degli attributi interessati
    della classe.
    Inoltre, prima dell'effettiva riallocazione, esegue una deallocazione [delete] se necessaria.
    Il metodo ritorna un valore booleano, utilizzato per comunicare eventuali errori durante l'allocazione.
    Anche qua, per via della staticit�, viene applicata la gestione analizzata prima.
    */
public:
    // Riesegue una operazione di inizializzazione con i valori degli attributi 'm_CLK', 'm_OE', 'm_LAT', 'm_A', 'm_B', 'm_C'.
    static bool ReInit();
 
    /*Risorse Interne*/
private:
    // Determina il colore in base al campo enumerativo indicato
    static void DefineShades(const Color& t_COLOR, unsigned int& t_RED, unsigned int& t_GREEN, unsigned int& t_BLUE);
 
    // Converte da 'String' a 'char*'
    static char* from_String_to_Char(String& t_toConvert);
    // Gestisce l'allocazione per il contenitore per la conversione
    static char* allocate_forConversion(const unsigned int& t_Length);
    // Gestisce la deallocazione per il contenitore per la conversione
    static bool deallocate_forConversion(char* t_toDeallocate);
    // Contenitore
    static char* m_Container;
    // Imposta il contenitore
    static void set_Container(char* t_toSet);
    // Resetta il contenitore
    static void reset_Container();
 
    /*Metodi*/
public:
    // "Pulisce" lo schermo, eliminando tutto il contenuto in visualizzazione
    /*
    Il seguente metodo permette di "pulire" lo schermo da precedenti informazioni scritte.
    Esso non presenta alcuna specializzazione del comportamento. Sia in 'single-buffer' che in 'double-buffer' il comportamento sarà lo stesso.
    In 'single-buffer' la "pulizia" avverrà sull'unico buffer disponibile. In 'double-buffer' la "pulizia" avverrà sul 'back-buffer'.
    Anche qua, per via della staticità, viene applicata la gestione analizzata prima.
    */
    static bool Clear(); /*OK*/
 
    // Imposta manualemente la posizione del cursore
    /*
    Il seguente metodo permette di impostare la posizione del cursore sulla matrice. Questo grazie alla specificazione di due parametri, 't_x' e 't_y', che 
    corrispondono alle coordinate cartesiane del "piano cartesiano della matrice". L'origine è nel punto (0, 0), che si trova "in alto a sinistra" (guardando la matrice di fronte).
    Esso non presenta alcuna specializzazione del comportamento. Sia in 'single-buffer' che in 'double-buffer' il comportamento sarà lo stesso.
    In 'single_buffer' il riposizionamento del cursore affligerà l'unico buffer disponibile. In 'double-buffer' affligerà il 'back-buffer'.
    Anche qua, per via della staticità, viene applicata la gestione analizzata prima.
    */
    static bool set_Cursor(const int& t_x, const int& t_y); /*OK*/
 
    // Effettua lo swap manuale dei due buffer, solo se è attiva l'opzione 'DOUBLE_BUFFERING'
    /*
    Il seguente metodo permette uno swap manuale dei due buffer --> 'front-buffer' e 'back-buffer'.
    Ovviamente, esso presenta una specializzazione del comportamento. In 'single-buffer' non produrrà alcun risultato. 'In double-buffer' effettuerà lo swap.
    Esso permette la specificazione della modalità di swap: con 'copia' per permettere la 'modifica incrementale' oppure no.
    Questo è reso possibile grazie al parametro di tipo enumerativo 't_Switch'.
    - In caso la 'modifica incrementale' venga permessa, durante lo swap il contenuto del nuovo 'front-buffer' verrà copiato anche nel nuovo 'back-buffer'.
    - In caso la 'modifica incrementale' non venga permessa, durante lo swap il contenuto del nuovo 'back-buffer' sarà lo stesso del vecchio 'front-buffer' (ormai sovrascritto).
    Anche qua, per via della staticità, viene applicata la gestione analizzata prima.
    */
    static bool SwapBuffers(const IncrementalModifyBuffer& t_Switch); /*OK*/
    
    // set_Color (1)
    // Imposta manualmente il colore delle informazioni che verranno stampate
    /*
    Il seguente metodo permette la scelta del colore per la visualizzazione delle informazioni.
    Esso non presenta alcuna specializzazione del comportamento. Sia in 'single-buffer' che in 'double-buffer' il comportamento sarà lo stesso.
    In 'single_buffer' la scelta del colore affligerà l'unico buffer disponibile. In 'double-buffer' affligerà il 'back-buffer'.
    */
    static bool set_Color(const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE);
 
    // set_Color (2)
    // Imposta manualemente il colore delle informazioni che verranno stampate
    /*
    Il seguente metodo permette la scelta del colore per la visualizzazione delle informazioni.
    Esso non presenta alcuna specializzazione del comportamento. Sia in 'single-buffer' che in 'double-buffer' il comportamento sarà lo stesso.
    In 'single_buffer' la scelta del colore affligerà l'unico buffer disponibile. In 'double-buffer' affligerà il 'back-buffer'.
    */
    static bool set_Color(const Color& t_COLOR);
 
    // Imposta la dimensione del testo da visualizzare
    /*
    Il seguente metodo permette la scelta della dimensione del testo per la visualizzazione delle infomazioni.
    Esso non presenta alcuna specializzazione del comportamento. Sia in 'single-buffer' che in 'double-buffer' il comportamento sarà lo stesso.
    In 'single_buffer' la scelta della dimensione affligerà l'unico buffer disponibile. In 'double-buffer' affligerà il 'back-buffer'.
    */
    static bool set_TextSize(const unsigned int& t_Size);
 
    // Visualizza manualmente le informazioni sulla matrice
    // Show (1)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Esso non presenta alcuna specializzazione del comportamento. Sia in 'single-buffer' che in 'double-buffer' il comportamento sarà lo stesso.
    In 'single_buffer' la visualizzazione affligerà l'unico buffer disponibile. In 'double-buffer' affligerà il 'back-buffer'.
    In 'single_buffer' la visualizzazione sarà automatica.
    In 'double-buffer' sarà necessaria una chiamata ad uno degli overload del metodo 'SwapBuffers'.
    */
    static bool Show(const char* t_toShow);
 
    // Show (2)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Esso non presenta alcuna specializzazione del comportamento. Sia in 'single-buffer' che in 'double-buffer' il comportamento sarà lo stesso.
    In 'single_buffer' la visualizzazione affligerà l'unico buffer disponibile. In 'double-buffer' affligerà il 'back-buffer'.
    In 'single_buffer' la visualizzazione sarà automatica.
    In 'double-buffer' sarà necessaria una chiamata ad uno degli overload del metodo 'SwapBuffers'.
    */
    static bool Show(String& t_toShow);
 
 
    /*Metodi di Automazione*/
public:
    // Effettua lo swap manuale dei due buffer, solo se è attiva l'opzione 'DOUBLE_BUFFERING'
    // Non permette la modifica incrementale, ma effettua una "pulizia" automatica sul nuovo 'back_buffer'
    /*
    Il seguente metodo permette uno swap manuale dei due buffer --> 'front-buffer' e 'back-buffer'.
    Ovviamente, esso presenta una specializzazione del comportamento. In 'single-buffer' non produrrà alcun risultato. 'In double-buffer' effettuerà lo swap.
    La tipologia dello swap effettuato da questo è di tipo 'LOCK_INCREMENTAL_MODIFY'. Questo è causato dall'inutilità di una 'modifica incrementale' data dal fatto che verrà effettuata
    anche una "pulizia" automatica del buffer.
    Anche qua, per via della staticità, viene applicata la gestione analizzata prima.
    */
    static bool SwapBuffersAutomated();
 
    // Visualizza le informazioni sulla matrice
    // ShowAutomated (1.1)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [const char*]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare 
    --- t_Size --> dimensione del testo da visualizzare
    --- t_RED, t_GREEN, t_BLUE, --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
        const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // ShowAutomated (1.2)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [const char*]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_Size --> dimensione del testo da visualizzare
    --- t_COLOR --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // ShowAutomated (2.1)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [String]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_Size --> dimensione del testo da visualizzare
    --- t_RED, t_GREEN, t_BLUE, --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
        const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // ShowAutomated (2.2)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [String]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_Size --> dimensione del testo da visualizzare
    --- t_COLOR --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // "Pulisce" lo schermo e visualizza le informazioni sulla matrice
    // ClearShowAutomated (1.1)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Come prima operazione, "pulisce" lo schermo. Poi, visualizza.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [const char*]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_Size --> dimensione del testo da visualizzare
    --- t_RED, t_GREEN, t_BLUE, --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ClearShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
        const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // ClearShowAutomated (1.2)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Come prima operazione, "pulisce" lo schermo. Poi, visualizza.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [const char*]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_Size --> dimensione del testo da visualizzare
    --- t_COLOR --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ClearShowAutomated(const char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // ClearShowAutomated (2.1)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Come prima operazione, "pulisce" lo schermo. Poi, visualizza.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [String]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_Size --> dimensione del testo da visualizzare
    --- t_RED, t_GREEN, t_BLUE, --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ClearShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size,
        const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // ClearShowAutomated (2.2)
    /*
    Il seguente metodo permette di visualizzare le infomazioni desiderate sulla matrice.
    Come prima operazione, "pulisce" lo schermo. Poi, visualizza.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesto sono x:
    --- t_toShow --> informazioni da visualizzare [String]
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_Size --> dimensione del testo da visualizzare
    --- t_COLOR --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    */
    static bool ClearShowAutomated(String& t_toShow, const int& t_x, const int& t_y, const unsigned int& t_Size, const Color& t_COLOR,
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE);
 
    // Visualizza sulla matrice una immagine formato 'bitmap'
    // ShowBitmap (1)
    /*
    Il seguente metodo permette di visualizzare una immagine in formato bitmap (rappresentata da un vettore di caratteri) sulla matrice.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesti sono 8:
    --- t_toShow --> informazioni da visualizzare [vettore di 'const char']
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_RED, t_GREEN, t_BLUE, --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    --- t_w, t_h --> rispettivamente larghezza e altezza dell'immagine bitmap (di default: 32 x 16)
    */
    static bool ShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE, 
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE, const unsigned int& t_w = Matrix__file::_w, const unsigned int& t_h = Matrix__file::_h);
 
    // ShowBitmap (2)
    /*
    Il seguente metodo permette di visualizzare una immagine in formato bitmap (rappresentata da un vettore di caratteri) sulla matrice.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesti sono 8:
    --- t_toShow --> informazioni da visualizzare [vettore di 'const char']
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_COLOR --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    --- t_w, t_h --> rispettivamente larghezza e altezza dell'immagine bitmap (di default: 32 x 16)
    */
    static bool ShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const Color& t_COLOR,
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE, const unsigned int& t_w = Matrix__file::_w, const unsigned int& t_h = Matrix__file::_h);
 
    // "Pulisce" lo schermo visualizze una immagine formato 'bitmap'
    // ClearShowBitmap (1)
    /*
    Il seguente metodo permette di visualizzare una immagine in formato bitmap (rappresentata da un vettore di caratteri) sulla matrice.
    Come prima operazione, "pulisce" lo schermo. Poi, visualizza.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesti sono 8:
    --- t_toShow --> informazioni da visualizzare [vettore di 'const char']
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_RED, t_GREEN, t_BLUE, --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    --- t_w, t_h --> rispettivamente larghezza e altezza dell'immagine bitmap (di default: 32 x 16)
    */
    static bool ClearShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const unsigned int& t_RED, const unsigned int& t_GREEN, const unsigned int& t_BLUE,
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE, const unsigned int& t_w = Matrix__file::_w, const unsigned int& t_h = Matrix__file::_h);
 
    // ClearShowBitmap (2)
    /*
    Il seguente metodo permette di visualizzare una immagine in formato bitmap (rappresentata da un vettore di caratteri) sulla matrice.
    Come prima operazione, "pulisce" lo schermo. Poi, visualizza.
    Esso presenta una specializzazione del comportamento. Infatti, per automatizzare la visualizzazione delle infomazioni, le procedure da adottare sono diverse
    in base al parametro 'm_DOUBLE_BUFFERING'.
 
    I parametri richiesti sono 8:
    --- t_toShow --> informazioni da visualizzare [vettore di 'const char']
    --- t_x, t_y --> posizione del cursore dal punto di inizio per la stesura delle informazioni da visualizzare
    --- t_COLOR --> colore del testo da visualizzare
    --- t_Switch --> indica la modalità del buffer: 'LOCK_INCREMENTAL_MODIFY', ALLOW_INCREMENTAL_MODIFY'
    --- t_w, t_h --> rispettivamente larghezza e altezza dell'immagine bitmap (di default: 32 x 16)
    */
    static bool ClearShowBitmap(const unsigned char* t_toShow, const int& t_x, const int& t_y, const Color& t_COLOR,
        const IncrementalModifyBuffer& t_Switch = IncrementalModifyBuffer::INVALID_REFERENCE, const unsigned int& t_w = Matrix__file::_w, const unsigned int& t_h = Matrix__file::_h);
 
    // Visualizza il logo originale GBE
    static bool ShowLogo_GBE();
 
    // Visualizza il lofo del WiFi
    static bool ShowLogo_WiFi();
 
    // Visualizza il logo del WiFi crossed
    static bool ShowLogo_CrossedWiFi();
};
 
// Dichiarazione delle variabili GLOBALI STATICHE 
// Risiederanno nel Data Segment
/*
Essendo statiche in classe, tutti gli attributi non sono altro che variabili GLOBALI STATICHE.
Per questo è richiesta la dichiarazione globale. Non è necessario specificare 'static' essendo già stato specificato nella dichiarazione degli
attributi nella classe stessa.
*/
RGBmatrixPanel* Matrix::m_Matrix;
unsigned int Matrix::m_CLK;
unsigned int Matrix::m_OE;
unsigned int Matrix::m_LAT;
unsigned int Matrix::m_A;
unsigned int Matrix::m_B;
unsigned int Matrix::m_C;
bool Matrix::m_DOUBLE_BUFFERING;
bool Matrix::m_isStarted = false;
char* Matrix::m_Container = nullptr;
const unsigned char Matrix::G_bitmap[64];
const unsigned char Matrix::B_bitmap[64];
const unsigned char Matrix::E_bitmap[64];
const unsigned char Matrix::wifi_bitmap[64];
const unsigned char Matrix::cross_bitmap[64];