Trasferire variabili a 4 cifre tramite software serial

Salve a tutti, ho bisogno di trasferire un numero a 4 cifre tramite software serial. Attualmente so che il comando mySerial.write() mi da il valore raw ma mi da problemi dalla terza cifra in poi, mentre mySerial.print() mi da le 4 cifre in formato Ascii, ma non so convertirle in un intero sulla scheda arduino ricevente.
Per mandare variabili uso un esp8266 con libreria apposita, mentre per riceverle, uso un arduino con libreria nativa.
Grazie mille a chi mi aiuterà :kissing_heart:

Un modo potrebbe essere ricevere i valori ascii e metterli nell'ordine corretto dentro un array di char, aggiungere in fondo il terminatore di stringa e poi con la funzione atoi() convertire in intero.

Avrei una domanda riguardo l'array. Dopo un certo numero di variabili inviate, avrò problemi di riempimento del buffer? Oppure ho informazioni sbagliate?

Di che buffer parli?
L'array di ricezione o il buffer della seriale?

Non è una questione di cifre...
Serial.write() trasmette un byte per volta.
Un byte è formato da 8 bit, quindi con questo tipo di dati puoi rappresentare fino a 2^8 numeri.

Se parliamo di interi positivi significa da 0 fino a 255.
Per rappresentare un numero superiore (e quindi anche quelli con 4 cifre come dici tu) hai bisogno di due byte.

In questo forum se cerchi ci sono minimo 3/4 post che trattano questo argomento (solo nella sezione italiana, in quella internazionale forse ancora di più).

Ho letto in giro che il buffer di ricezione ha una capacità massima che se riempita non posso più eseguire il comando serial.write(). So anche che la scheda ricevente deve salvare un array di caratteri da convertire in intero, ma poi, salvando sempre gli array uno dopo l'altro, avrò bisogno di svuotare il buffer di ricezione prima o poi?

O hai letto male oppure hai letto delle stupidaggini.

Il buffer la seriale se lo gestisce da se, non devi svuotare nulla.

Quanto al passaggio numero - stringa - numero per funzionare funziona, ma io lo trovo un'inutile spreco di risorse e cicli di clock.

Purtroppo sul forum ho trovato solo questo, consigli qualcosa?

Se ne era discusso in passato qui. Nello specifico si usava una struct per trasmettere in un colpo solo tutta una serie di valori.

Poi ho trovato anche questa discussione simile, dopo mi sono fermato.

Se hai esigenze più "semplici" puoi usare direttamente i metodi inclusi con la classe Serial (derivati da Stream) ed usare il Serial.print() invece di write().
Ad esempio nel tuo caso ti basterebbe questo
Serial.parseInt() - Arduino Reference

......
if(Serial.available()) {
  // in value viene memorizzato il primo intero valido ricevuto dalla seriale.
  int value = Serial.parseInt();
  if (value  != 0) {
    Serial.print("Ricevuto valore intero ");
    Serial.println(value);
  }
}
.....

Eventualmente potresti "irrobustire" un po' il protocollo aggiungendo una intestazione che ti consente di discriminare quale valore stai ricevendo.
Se sulla seriale del TX scrivi una cosa del genere:

Serial.print("Value1: ");
Serial.prinln(val1);
Serial.print("Value2: ");
Serial.prinln(val2);

Lato RX potresti fare cosi:

int value1, value2;
......
if(Serial.available()) {
  // Scorre tutto lo stream seriale fino a trovare "Value1"
  if(Serial.find("Value1") {
    // in value1 viene memorizzato il primo intero valido ricevuto dalla seriale subito dopo la substring "Value1"
    int value1 = Serial.parseInt();  
    if (value1  != 0) {
      Serial.print("Ricevuto valore intero ");
      Serial.println(value1);
    }
  }

  if(Serial.find("Value2:") {
    int value2 = Serial.parseInt(); 
     // in value2 viene memorizzato il primo intero valido ricevuto dalla seriale subito dopo la substring "Value2"
    if (value2  != 0) {
      Serial.print("Ricevuto valore intero ");
      Serial.println(value2);
   }
  }

}
.....

Io non amo molto questo metodo perché non è il massimo dell'efficienza, però funziona ed è abbastanza semplice da implementare.

Concordo con @cotestatnt che il metodo della print con i valori ascii è più macchinoso di altre soluzioni, forse però è più semplice da capire se l'OP non ha ben chiaro tutto il meccanismo.
Poi concordo anche che un minimo di protocollo non guasta.

Ho letto la documentazione di parseInt, sembra interessante, proverò e vi faccio sapere.