Medir distancia mediante ESP32 y enviar al puerto serie

int EchoPin = 13;
int TriggerPin = 12;

void setup() {
   Serial.begin(115200);
   pinMode(TriggerPin, OUTPUT);
   pinMode(EchoPin, INPUT);
}

void loop() {
   int cm = ping(TriggerPin, EchoPin);
   Serial.print("Distancia: ");
   Serial.println(cm);
   delay(1000);
}

int ping(int TriggerPin, int EchoPin) {
   long duration, distanceCm;
  
   digitalWrite(TriggerPin, LOW);  //para generar un pulso limpio ponemos a LOW 4us
   delayMicroseconds(4);
   digitalWrite(TriggerPin, HIGH);  //generamos Trigger (disparo) de 10us
   delayMicroseconds(10);
   digitalWrite(TriggerPin, LOW);
  
   duration = pulseIn(EchoPin, HIGH);  //medimos el tiempo entre pulsos, en microsegundos
  
   distanceCm = duration * 10 / 292/ 2;   //convertimos a distancia, en cm
   return distanceCm;
}

ESP32 con matriz 16x16 dos imagenes que cambian usando millis() con un retardo de 1000 ms

//salidas que se van a utilizar
#define dataPin 13
#define clockPin 12
#define latchPin 14

uint16_t dato1[] = {
  0xFFFF,
  0x8001,
  0xBFFD,
  0xA005,
  0xAFF5,
  0xA815,
  0xABD5,
  0xAA55,
  0xAA55,
  0xABD5,
  0xA815,
  0xAFF5,
  0xA005,
  0xBFFD,
  0x8001,
  0xFFFF
};

uint16_t dato2[] = {
  0x0000,
  0x7FFE,
  0x4002,
  0x5FFA,
  0x500A,
  0x57EA,
  0x542A,
  0x55AA,
  0x55AA,
  0x542A,
  0x57EA,
  0x500A,
  0x5FFA,
  0x4002,
  0x7FFE,
  0x0000
};

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++) dato1[i] ^= 0xFFFF;
  for (i = 0; i < 16; i++) dato2[i] ^= 0xFFFF;
}

void loop() {
  muestra (dato1);
  //delay(1000);
  muestra (dato2);
  //delay(1000);
}

void muestra (uint16_t *matriz) {
  double t_inicio;
  unsigned int retardo=1000;
  uint16_t aux;
  byte enviar;
  uint16_t n_fila;
  int n;
  t_inicio = millis();
  while (millis()<(t_inicio+retardo)) {
    n_fila = 1;
    for (i = 0; i < 16; i++, n_fila <<= 1) {
      fi_L = n_fila & 0xFF;
      fi_H = (n_fila >> 8) & 0xFF;
      digitalWrite(latchPin, 0);
      shiftOut(dataPin, clockPin, LSBFIRST, fi_L);
      shiftOut(dataPin, clockPin, LSBFIRST, fi_H);
      aux = matriz[i];
      enviar = aux & 0x00ff;
      shiftOut(dataPin, clockPin, LSBFIRST, enviar);
      enviar = (aux >> 8) & 0x00ff;
      shiftOut(dataPin, clockPin, LSBFIRST, enviar);
      digitalWrite(latchPin, 1);
    }
  }
}

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.
  }
}