ESP32 con la matriz de 16x16. Mensaje HOLA.

//salidas que se van a utilizar
//pongo las 5 seguidas para que sea más sencillo conectarlas
//VCC
//GND
#define dataPin 13
#define clockPin 12
#define latchPin 14

/*
 * poniendo el array en uint16_t y colocando la información en columnas en vez de en filas sería más facil crear mensajes largos
 */
//array en el que se va a contener toda la informacin de filas
uint32_t dato[] = {
  0xCC7183F0,
  0xCCF983F0,
  0xCDDD8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xFD8D83F0,
  0xFD8D83F0,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCD8D8330,
  0xCDDD8330,
  0xCCF9FB36,
  0xCC71FB36
};//informacion de las columnas

byte i, j;
byte fi_L, fi_H;

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  for (i = 0; i < 16; i++) dato[i] ^= 0xFFFFFFFF; //invierto todos los bits porque las columnas van a los cátodos.
  //si se cambia por uint16_t habría que cambiar esto de la inversión
}

void loop() {
  muestra (dato,32,1000);//(matriz, ancho de la matriz, numero de repeticiones) cuanto mayor sea el numero de repeticiones más tardará en pasar a la siguiente columna.
  uint32_t limpia[16];
  for (int i=0;i<16;i++){
    limpia[i]=0xFFFFFFFF;
  }
  muestra(limpia,32,10);
  delay(1000);
}

void muestra (uint32_t *matriz, int ancho, unsigned int numero_rep) {//puesto que es una variable global podría usar dato[]
  double t_inicio;
  uint32_t aux;
  byte enviar;
  uint16_t n_fila;
  //unsigned int n;
  for (j = 0; j < ancho - 16; j++) {//empiezo en 32 porque es la anchura total (para empezar por el extremo izquierdo termino en 32-16 porque la anchura de la matriz de puntos es 16
    for (int n = 0; n < numero_rep; n++) {//es una espera (va a repetir la información hasta saltar a la siguiente columna. Por eso no se hace nada con n.

      //se posiciona la variable que indica el numero de fila en la primera fila (como es de 16 bits, se carga en una variable uint16_n)
      n_fila = 1;

      //como tiene 16 filas se van a enviar de una en una
      for (i = 0; i < 16; i++, n_fila <<= 1) {//lo de rotar 1 bit a la izquierda es para que pase a la siguiente columna

        //se extraen los bytes de menor y menor peso

        //el de menor peso mediante una AND con 0000 0000 1111 1111
        fi_L = n_fila & 0xFF;

        //el de mayor peso mediante la misma AND pero con la variable n_fila desplazada 1 byte hacia la derecha
        fi_H = (n_fila >> 8) & 0xFF;

        //se prepara para recibir datos
        digitalWrite(latchPin, 0);

        //se envía la información de la fila (lógica positiva, una fila de cada vez)
        shiftOut(dataPin, clockPin, LSBFIRST, fi_L);
        shiftOut(dataPin, clockPin, LSBFIRST, fi_H);

        //se envía la información de la columna (lógica negativa, por eso se invierte la matriz en setup()

        //se posiciona en el primer bit desplazando el ancho total - 16 - i (que va a variar) y se carga en una variable de tipo uint32_n (como la matriz)
        aux = matriz[i] >> (ancho - 16 - j);
        //se cogen el byte de menor peso (operación AND con 0000 0000 1111 1111)
        enviar = aux & 0x00ff;
        //se envía el byte de menor peso que se había extraido
        shiftOut(dataPin, clockPin, LSBFIRST, enviar);
        //se extrae el segundo byte porque el dato se va a desplazar 1 byte a la derecha (el resto es como el anterior)
        enviar = (aux >> 8) & 0x00ff;
        shiftOut(dataPin, clockPin, LSBFIRST, enviar);

        //se desactiva la recepción de datos y por lo tanto los va a mostrar
        digitalWrite(latchPin, 1);
      }
    }//cuando ha repetido el numero de veces seleccionado, se pasa a la siguiente columna.
  }
}