[SOLUCIONADO]Dudas con variables, constantes y PROGMEM

Hola a todos. Soy bastante novato en esto de la programación y más en el mundo de la electrónica. Aunque llevo muy
poco tiempo dado de alta en el foro, el mismo me ha ayudado mucho en las dudas que me van surgiendo. Así, que
ante todo, muchísimas gracias.

Estoy ensayado el manejo de puertos con un Arduino Mega y una matriz de leds 8x8:

/* Programa para Arduino Mega 2560.
 * Muestra carácteres y síbolos en una matriz 8x8 de leds con ánodo común.
 * Los pines utilizados son:
 * Ánodos:  Pins  placa -> 37 36 35 34 33 32 31 30
 *          Pins  PORTC ->  0  1  2  3  4  5  6  7
 * -----------------------------------------------
 * Cátodos: Pins  placa -> 22 23 24 25 26 27 28 29
 *          Pins  PORTA ->  0  1  2  3  4  5  6  7*/
            
const uint16_t INTERVALO = 500;

/*------------Símbolos------------------*/
uint8_t signoPor[8] = {
    0b00111100,
    0b10011001,
    0b11000011,
    0b11100111,
    0b11100111,
    0b11000011,
    0b10011001,
    0b00111100,
};

uint8_t signoMenos[8] = {
    0b11111111,
    0b11111111,
    0b11111111,
    0b00000000,
    0b00000000,
    0b11111111,
    0b11111111,
    0b11111111,
};


uint8_t signoMas[8] = {
    0b11100111,
    0b11100111,
    0b11100111,
    0b00000000,
    0b00000000,
    0b11100111,
    0b11100111,
    0b11100111,
};

uint8_t signoEntre[8] = {
    0b11100111,
    0b11100111,
    0b11111111,
    0b00000000,
    0b00000000,
    0b11111111,
    0b11100111,
    0b11100111,
};

//~ uint8_t cero[8] = {
    //~ 0b11000011,
    //~ 0b10000001,
    //~ 0b00111100,
    //~ 0b00111100,
    //~ 0b00111100,
    //~ 0b00111100,
    //~ 0b10000001,
    //~ 0b11000011,
//~ };

void setup() {
    DDRA = 0b11111111; //Todos los pins de PORTA como salidas.
    DDRC = 0b11111111; //Todos los pins de PORTC como salidas.(Filas).
}

void loop() {
    uint32_t t = millis() + INTERVALO;
    while(millis() <  t) {
        muestra(signoMas);
    }
    t = millis() + INTERVALO;
    while(millis() < t) {
        muestra(signoMenos);
    }
    t = millis() + INTERVALO;
    while(millis() < t) {
        muestra(signoPor);
    }
    t = millis() + INTERVALO;
    while(millis() < t) {
        muestra(signoEntre);
    }
}

void muestra (uint8_t matriz[8]){
    /* Toma como parámetro un array de 8 bytes y lo muestra barriendo por filas.*/
    uint8_t maskC = 0b00000001;// Máscara para poner los ánodos de la primera fila en HiGH:
    for(uint8_t i = 0; i < 8; i++) {
        PORTC = maskC;
        PORTA = matriz[i];//Máscara para poner los cátodos de la primera fila en LOW;
        maskC <<= 1;//Ponemos en HIG los ánodos de la siguiente fila;
        delayMicroseconds(3);
    }
}

Tal como esta el sketch hace lo que yo pretendo. Pero si declaro los símbolos como constantes, por ejemplo:
const uint8_t signoMas[8], compila pero lanza el siguiente aviso:

/home/cascovida/Desarrollo/Arduino/Matrix/Matrix.ino: In function 'void loop()':
/home/cascovida/Desarrollo/Arduino/Matrix/Matrix.ino:77:25: warning: invalid conversion from 'const uint8_t* {aka const unsigned char*}' to 'uint8_t* {aka unsigned char*}' [-fpermissive]
         muestra(signoMas);
                         ^
/home/gustavo/Desarrollo/Arduino/Matrix/Matrix.ino:93:6: note:   initializing argument 1 of 'void muestra(uint8_t*)'
 void muestra (uint8_t matriz[8]){

Y si intento utilizar const uint8_t signoMas[8] PROGMEM, compila lanzado el mismo aviso y el resultado mostrado en la matriz es totalmente inesperado.

Me gustaría almacenar los símbolos en la memoria flash ya que pienso aumentar su número, estos solo eran de prueba.
¿Debería usar punteros? Todavía no he llegado a ellos aunque más pronto que tarde tendré que aprender a usarlos.
Si fueseis tan amables de indicarme donde estoy fallando os estaría muy agradecido.

He conseguido evitar los avisos de copilación definiendo el parámatre de la función como const uint8_t matriz.
El programa queda asi:

/* Programa para Arduino Mega 2560.
 * Muestra carácteres y síbolos en una matriz 8x8 de leds con ánodo común.
 * Los pines utilizados son:
 * Ánodos:  Pins  placa -> 37 36 35 34 33 32 31 30
 *          Pins  PORTC ->  0  1  2  3  4  5  6  7
 * -----------------------------------------------
 * Cátodos: Pins  placa -> 22 23 24 25 26 27 28 29
 *          Pins  PORTA ->  0  1  2  3  4  5  6  7*/
           
const uint16_t INTERVALO = 500;

/*------------Símbolos------------------*/
const uint8_t signoPor[8] = {
    0b00111100,
    0b10011001,
    0b11000011,
    0b11100111,
    0b11100111,
    0b11000011,
    0b10011001,
    0b00111100,
};

const uint8_t signoMenos[8] = {
    0b11111111,
    0b11111111,
    0b11111111,
    0b00000000,
    0b00000000,
    0b11111111,
    0b11111111,
    0b11111111,
};


const uint8_t signoMas[8] = {
    0b11100111,
    0b11100111,
    0b11100111,
    0b00000000,
    0b00000000,
    0b11100111,
    0b11100111,
    0b11100111,
};

const uint8_t signoEntre[8] = {
    0b11100111,
    0b11100111,
    0b11111111,
    0b00000000,
    0b00000000,
    0b11111111,
    0b11100111,
    0b11100111,
};


void setup() {
    DDRA = 0b11111111; //Todos los pins de PORTA como salidas.
    DDRC = 0b11111111; //Todos los pins de PORTC como salidas.(Filas).
}

void loop() {
    uint32_t t = millis() + INTERVALO;
    while(millis() <  t) {
        muestra(signoMas);
    }
    t = millis() + INTERVALO;
    while(millis() < t) {
        muestra(signoMenos);
    }
    t = millis() + INTERVALO;
    while(millis() < t) {
        muestra(signoPor);
    }
    t = millis() + INTERVALO;
    while(millis() < t) {
        muestra(signoEntre);
    }
}

void muestra (const uint8_t matriz[8]){
    /* Toma como parámetro un array de 8 bytes y lo muestra barriendo por filas.*/
    uint8_t maskC = 0b00000001;// Máscara para poner los ánodos de la primera fila en HiGH:
    for(uint8_t i = 0; i < 8; i++) {
        PORTC = maskC;
        PORTA = matriz[i];//Máscara para poner los cátodos necesarios de la primera fila en LOW;
        maskC <<= 1;//Ponemos en HIG los ánodos de la siguiente fila;
        delayMicroseconds(3);
    }
}

Pero si intento utilizar PROGMEM la matriz enciende con secuencias inesperadas.

Bueno. Di con la solución.

El problema viene de que solo había utilizado PROGMEM con nodemecu en este contexto:

Informadome mejor he visto que su uso es un poco más eleborado. Al final he definido los símbolos como
const uint8_t vector [8] PROGMEM = {} y la función así:

void muestra (uint8_t const matriz[]){
    /* Toma como parámetro un array de 8 bytes y lo muestra barriendo por filas.*/
    uint8_t maskC = 0b00000001;// Máscara para poner los ánodos de la primera fila en HiGH:
    for(uint8_t i = 0; i < 8; i++) {
        PORTC = maskC;
        //~ PORTA = matriz[i];//Máscara para poner los cátodos necesarios de la primera fila en LOW;
        PORTA = pgm_read_byte(&matriz[i]);//Se recuperan los datos PROGMEM y se pasan como máscara a los cátodos.
        maskC <<= 1;//Ponemos en HIG los ánodos de la siguiente fila;
        delayMicroseconds(3);
    }
}

Fuentes:
https://www.arduino.cc/reference/tr/language/variables/utilities/progmem/
https://esp8266-arduino-spanish.readthedocs.io/es/latest/PROGMEM.htm
url=https://www.todopic.com.ar/foros/index.php?topic=32257.0