Serial Read per Pivelli

salve a tutti, con questo sketch ed un adattatore rs422 ----> TTL

#include <M5Stack.h>


void setup() {

  M5.begin();

  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, 21, 22);

  pinMode(5, OUTPUT);
  digitalWrite(5, 1);
}


void loop() {

  if (Serial2.available()) {
    int ch = Serial2.read();
    Serial.write(ch);
  }
}

riesco ad avere nel monitor seriale un bel output…

  |0  60
  |1  100
  |0  60
  |1  120
  |0  60
  |1  93
  |0  60
  |1  95
  |0  70
  |1 211
  |0  70
  |1 208
  |0  70
  |1 207
  |0  70
  |1 205

ora vorrei scindere il dato ricevuto e, se ho capito bene, dirgli:

se il primo byte è “60” fai qualche cosa con il secondo byte…
oppure se il primo byte è “70” fai qualche cos’altro con il secondo byte…

quindi la butto li:

#include <M5Stack.h>


void setup() {

  M5.begin();

  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, 21, 22);

  pinMode(5, OUTPUT);
  digitalWrite(5, 1);
}

void loop() {

  if (Serial2.available()) {
    int ch = Serial2.read();
    if (lowByte(ch) == 60) {
      Serial.println("sessanta");
      Serial.write(highByte(ch));
    } else {
      Serial.println("settanta");
      Serial.write(highByte(ch));
    }
  }
}

ha senso tutto questo?

purtroppo per il momento non ho piu sotto mano l’aggeggio che sputa in rs422, quindi non posso testare il tutto…

grz

.... o forse devo andare a cercare quel carattere "|" che è all'inizio di ogni riga?

Ciao! Se stampi sul monitor seriale devi usare i metodi Serial.print() o Serial.println(), write() stampa i valori in byte e il monitor seriale deve invece ricevere caratteri.

Penso che se vuoi fare qualcosa sulla base di quello che ricevi, dovresti mettere appunto un sistema più elaborato.

1) Leggo i byte ricevuti uno per uno 2)Se il byte ricevuto è uno particolare, leggo il successivo come comando.

void loop() {

  if (Serial2.available()>=2) {
    int ch = Serial2.read(); //leggo uno per uno
    if (ch == 60) {
       comando=Serial2.read(); //leggo il successivo come comando
   }
}

grazie mille !!

torn24: ``` void loop() {

  if (Serial2.available()>=2) {     int ch = Serial2.read(); //leggo uno per uno     if (ch == 60) {       comando=Serial2.read(); //leggo il successivo come comando   } }

cosi facendo però ci potrebbero essere degli errori in quanto il 60 o il 70 sono come dei codici fissi che caratterizzano il dato che poi li segue... ma anche il dato potrebbe essere 60 o 70....

quello che potrebbe arrivare è:

|0 60 |1 60

e

|0 70 |1 70

il dato che a me serve estrapolare è quello che sta a fianco a "|1" ma poi lo devo trattare in modo diverso a seconda se a fianco allo "|0" c'era 60 o 70

c'è il modo di riconoscere questo carattere strano "|"?

gli dovrei poter dire: se dopo "|0" c'è 60, predi quello che c'è dopo "|1" e fai questo se dopo "|0" c'è 70, predi quello che c'è dopo "|1" e fai quest'altro

Serial Input Basics https://forum.arduino.cc/index.php?topic=396450

grazie!!! me la sto studiando ....

ma come ripeto non ho piu per il momento il marchingegno che sputa rs422..

pensavo di fare con un altro arduino un simulatore e quindi fargli uscire su seriale TTL un output che riproducesse quello del macchinario (bypassando logicamente l'adattatore rs422---->TTL)...

ho provato a trasmettere questo:

void loop() {

  Serial2.println("|0 60");
  Serial2.println("|1 110");
  Serial2.println();
  Serial2.println("|0 70");
  Serial2.println("|1 110");
  Serial2.println();

  delay(1000);
  Serial.println("|0 60");
  delay(1000);
  Serial.println("|1 110");
  delay(1000);
  Serial.println();
  Serial.println("|0 70");
  delay(1000);
  Serial.println("|1 110");
  delay(1000);
  Serial.println();

  Serial2.println("|");
  delay(1000);
  Serial2.println("1");
  delay(1000);
  Serial2.println("0");
  delay(1000);
  Serial2.println();
  delay(1000);
  Serial2.write(0xb3);
  delay(1000);
  Serial2.write(0x00);
  delay(1000);
  Serial2.write(0x3c);
  delay(1000);
  Serial2.write(0x01);

  delay(1000);
}

ma dall'altra parte con questo codice:

void loop() {

  if (Serial.available()) {
    int ch = Serial.read();
    Serial2.write(ch);
  }

  if (Serial2.available()) {
    int ch = Serial2.read();
    Serial.write(ch);
    Serial.println("spazio");
    Serial.println(ch, HEX);
    Serial.println("spazio");
    Serial.println(ch, DEC);
    Serial.println("spazio");
    Serial.println(ch, DEC);
    Serial.println("spazio");
    Serial.println(ch);
    Serial.println("spazio");
    Serial.println();
    Serial.println();
    Serial.println();
    Serial.println();
  }
}

ho un output di soli numeri al quale non trovo una logica..

80
spazio
128
spazio
128
spazio
⸮spazio




0
spazio
0
spazio
0
spazio
spazio




0
spazio
0
spazio
0
spazio
spazio




0
spazio
0
spazio
0
spazio
spazio




FF
spazio
255
spazio
255
spazio
⸮spazio




1
spazio
1
spazio
1
spazio
spazio




E4
spazio
228
spazio
228
spazio
⸮spazio




1
spazio
1
spazio
1
spazio
spazio




0
spazio
0
spazio
0
spazio
spazio




0
spazio
0
spazio
0
spazio
spazio




70
spazio
112
spazio
112
spazio
pspazio




0
spazio
0
spazio
0
spazio
spazio

mumble mumble.....

Quando usi una seriale devi conoscere esattamente i byte che transitano.
Se vengono inviate stringhe di caratteri, i valori dei byte sono i codici ASCII di quei caratteri.
Se le stringhe vengono inviate con fineriga ci sono due caratteri in più chiamati CR LF (rispettivamente ‘\r’ e ‘\n’)

Ad esempio se da un Arduino trasmetti sulla seriale con println("|0 60"), vengono inviati sette byte con il seguente valore (in decimale):

124 48 32 54 48 13 10

Il valore 124 è il carattere pipe '|'
Il valore 48 è il carattere '0'
Il 32 è il carattere spazio ' '

13 e 10 sono il fineriga “\r\n”

Se scrivi sulla seriale println() non trasmetti uno spazio, trasmetti i due byte di fineriga. Se vuoi trasmettere solo uno spazio (senza i fineriga) bisogna scrivere print(' ') oppure write(' ') oppure write(32).

Quindi per ricevere (e decodificare) le stringhe in arrivo, intanto bisogna sincronizzarsi con il loro inizio attendendo l’arrivo di un pipe, poi i vari valori rappresentati nella stringa vanno (eventualmante) ricomposti a partire dai diversi byte che li rappresentano sotto forma di caratteri:

un “60” sono due byte di valore 54 e 48

(54-'0')*10 + (48-'0') = 60

che alla fine è l’operazione effettuata dalla funzione atoi()

Naturalmente puoi anche evitare di convertire in valori interi e testare solo i singoli byte/caratteri ricevuti, ma appunto non puoi fare un confronto diretto con il valore 60 (carattere ‘<’), ma due confronti con i caratteri consecutivi ‘6’ e ‘0’.

grazie!!!

per ora sono arrivato a questo ancora non funziona come dovrebbe ma è gia un grande passo avanti:

TX: (simulatore)

#include <M5Stack.h>
HardwareSerial Serial2_(2);

//#include <M5StickC.h>
//#include <HardwareSerial.h>

void setup() {
  M5.begin();
  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, 16, 17);
  
  // Serial2.begin(baud, config, rxPin, txPin, bool invert)
  // Serial2.begin(9600, SERIAL_8N1, 21, 22); // RX TX STACK GROVE
  // Serial2.begin(115200); // RX TX STACK IO
  // Serial2.begin(9600, SERIAL_8N1, 32, 33); //STICKC GROVE
  // Serial2.begin(9600, SERIAL_8N1, 36, 0); //STICKC I/O
  // Serial2.begin(9600, SERIAL_8N1, 25, 13); //STICK GROVE

}

void loop() {

  Serial2.write(0xb3); // |
  Serial2.write(0x00); // 0
  Serial2.write(0x20); // spazio
  Serial2.write(0x3c); // 60 cm

  Serial2.write(0xb3); // |
  Serial2.write(0x01); // 1
  Serial2.write(0x20); // spazio
  Serial2.write(0x6E); // 110 misura


  Serial2.write(0xb3); // |
  Serial2.write(0x00); // 0
  Serial2.write(0x20); // spazio
  Serial2.write(0x46); // 70 ft

  Serial2.write(0xb3); // |
  Serial2.write(0x01); // 1
  Serial2.write(0x20); // spazio
  Serial2.write(0x6E); // 110 misura


  delay(500);

  // per vedere se il codice gira
  Serial.println("|0 60");
  Serial.println("|1 110");
  Serial.println();
  Serial.println("|0 70");
  Serial.println("|1 110");
  Serial.println();

}

RX:

// Example 6 - Receiving binary data
#include <M5Stack.h>
const byte numBytes = 32;
byte receivedBytes[numBytes];
byte numReceived = 0;

boolean newData = false;

void setup() {

  M5.begin();
  Serial.begin(115200);
  Serial.println("<Arduino is ready>");

  // Serial2.begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert)
  Serial2.begin(9600, SERIAL_8N1, 25, 13);
  pinMode(5, OUTPUT);
  digitalWrite(5, 1);
}

void loop() {
  recvBytesWithStartEndMarkers();
  showNewData();
}

void recvBytesWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  byte startMarker = 0xb3;
  byte endMarker = 0xb3;
  byte rb;


  while (Serial2.available() > 0 && newData == false) {
    rb = Serial2.read();

    if (recvInProgress == true) {
      if (rb != endMarker) {
        receivedBytes[ndx] = rb;
        ndx++;
        if (ndx >= numBytes) {
          ndx = numBytes - 1;
        }
      }
      else {
        receivedBytes[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        numReceived = ndx;  // save the number for use when printing
        ndx = 0;
        newData = true;
      }
    }

    else if (rb == startMarker) {
      recvInProgress = true;
    }
  }
}

void showNewData() {
  if (newData == true) {
    Serial.print("This just in (HEX values)... ");
    for (byte n = 0; n < numReceived; n++) {
      Serial.print(receivedBytes[n], HEX);
      Serial.print(' ');
    }
    Serial.println();
    newData = false;
  }
}

output monitor seriale RX:

This just in (HEX values)... 1 20 46 
This just in (HEX values)... 1 20 46 
This just in (HEX values)... 1 20 46 
This just in (HEX values)... 1 20 46 
This just in (HEX values)... 1 20 46 
This just in (HEX values)... 1 20 46 
This just in (HEX values)... 1 20 46 
This just in (HEX values)... 1 20 46

logicamente avendo start e stop byte non mi prende mai la prima parte… mummble mummmmble

Temevo di aggiungere confusione ed è avvenuto :confused:

Se fai Serial2.write(110) trasmetti UN byte di valore 110.

Se fai Serial2.print("110") trasmetti TRE byte/caratteri di valore 49 49 48.

Nell'ultimo codice stai mescolando stringhe (byte che rappresentano caratteri) con byte puri (che rappresentano direttamente un valore).

L'apparato trasmette stringhe di caratteri, non valori diretti sotto forma di singoli byte.

Claudio_FF:
Temevo di aggiungere confusione ed è avvenuto :confused:

Se fai Serial2.write(110) trasmetti UN byte di valore 110.

Se fai Serial2.print("110") trasmetti TRE byte/caratteri di valore 49 49 48.

Nell’ultimo codice stai mescolando stringhe (byte che rappresentano caratteri) con byte puri (che rappresentano direttamente un valore).

L’apparato trasmette stringhe di caratteri, non valori diretti sotto forma di singoli byte.

se ho capito bene questo allora dovrebbe essere il “simulatore” corretto:

#include <M5Stack.h>
HardwareSerial Serial2_(2);


void setup() {
  M5.begin();
  Serial.begin(115200);
  Serial2.begin(9600, SERIAL_8N1, 16, 17);

}

void loop() {
  delay(500);
  Serial2.write(0xb3); // |
  Serial2.write(0x00); // 0
  Serial2.write(0x20); // spazio
  Serial2.write(0x36); // "6"0 cm
  Serial2.write(0x30); // 6"0" cm
  Serial2.write(0x0A); //  CR ('\r')
  Serial2.write(0x0D); //  LF ('\n')
  delay(500);
  Serial2.write(0xb3); // |
  Serial2.write(0x01); // 1
  Serial2.write(0x20); // spazio
  Serial2.write(0x31); // "1"10 misura
  Serial2.write(0x31); // 1"1"0 misura
  Serial2.write(0x30); // 11"0" misura
  Serial2.write(0x0A); //  '\r'
  Serial2.write(0x0D); //  '\n'
  delay(500);
  Serial2.write(0xb3); // |
  Serial2.write(0x00); // 0
  Serial2.write(0x20); // spazio
  Serial2.write(0x37); // "7"0 ft
  Serial2.write(0x30); // 7"0" ft
  Serial2.write(0x0A); //  '\r'
  Serial2.write(0x0D); // '\n'
  delay(500);
  Serial2.write(0xb3); // |
  Serial2.write(0x01); // 1
  Serial2.write(0x20); // spazio
  Serial2.write(0x31); // "1"10 misura
  Serial2.write(0x31); // 1"1"0 misura
  Serial2.write(0x30); // 11"0" misura
  Serial2.write(0x0A); //  '\r'
  Serial2.write(0x0D); // '\n'


  delay(500);

  // per vedere se il codice gira
  Serial.println("|0 60");
  Serial.println("|1 110");
  Serial.println();
  Serial.println("|0 70");
  Serial.println("|1 110");
  Serial.println();

}

ma dal lato RX con questo codice:

// Example 6 - Receiving binary data
#include <M5Stack.h>
const byte numBytes = 32;
//const byte numBytes = 8;
byte receivedBytes[numBytes];
byte numReceived = 0;

boolean newData = false;

void setup() {

  M5.begin();

  // Serial2.begin(unsigned long baud, uint32_t config, int8_t rxPin, int8_t txPin, bool invert)
  Serial2.begin(9600, SERIAL_8N1, 25, 13);
  delay(2000);
  Serial.begin(115200);
  delay(2000);
  Serial.println("<Arduino is ready>");


  pinMode(5, OUTPUT);
  digitalWrite(5, 1);
}

void loop() {
  recvBytesWithStartEndMarkers();
  showNewData();
}

void recvBytesWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  byte startMarker = 0xb3; // "|"
//  byte endMarker = 0x0A; // "/r"
  //  byte startMarker = 0x0D; // "/n"
    byte endMarker = 0x0D; // "/n"

  byte rb;


  while (Serial2.available() > 0 && newData == false) {
    rb = Serial2.read();

    if (recvInProgress == true) {
      if (rb != endMarker) {
        receivedBytes[ndx] = rb;
        ndx++;
        if (ndx >= numBytes) {
          ndx = numBytes - 1;
        }
      }
      else {
        receivedBytes[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        numReceived = ndx;  // save the number for use when printing
        ndx = 0;
        newData = true;
      }
    }

    else if (rb == startMarker) {
      recvInProgress = true;
    }
  }
}

void showNewData() {
  if (newData == true) {
    Serial.print("in HEX values.. ");
    for (byte n = 0; n < numReceived; n++) {
      Serial.print(receivedBytes[n], HEX);
      Serial.print(' ');
    }
    Serial.println();
    newData = false;
  }
}

ho questo output che all’inizio è quasi perfetto ma poi svalvola e si ripiglia:

M5Stack initializing...OK
<Arduino is ready>
in HEX values.. F1 3E 39 31 3C CA 
in HEX values.. F1 3C 39 31 3C 8A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 11 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 11 31 30 A 
in HEX values.. 0 20 11 30 A 
in HEX values.. 1 20 31 31 10 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 11 31 30 A 
in HEX values.. 0 20 13 30 A 
in HEX values.. 1 20 11 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 33 30 A 
in HEX values.. 1 20 31 31 10 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 10 A 
in HEX values.. 0 20 33 10 A 
in HEX values.. 1 20 31 11 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 33 30 A 5 0 F4 0 88 0 F0 0 F8 0 C8 0 FC 0 E0 0 0 0 F3 0 D0 0 C0 0 F8 0 
in HEX values.. 1 20 31 31 10 A 
in HEX values.. 0 20 33 30 A 
in HEX values.. 1 20 31 31 30 A 5 0 C0 0 40 0 A0 0 C0 0 F8 0 D0 0 84 FF 0 0 0 F0 0 80 0 C0 0 
in HEX values.. 0 20 33 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 5 0 E0 0 F0 0 90 0 D6 0 80 0 FC 0 F8 0 F0 0 F0 0 F4 0 E0 0 E0 
in HEX values.. F9 20 31 31 30 A 
in HEX values.. FE 20 36 30 A 
in HEX values.. F9 38 31 31 30 A 
in HEX values.. FE 3E 37 30 A 
in HEX values.. F9 3E 31 31 30 A 
in HEX values.. FE 3E 36 30 A 
in HEX values.. F9 3E 31 31 30 A 
in HEX values.. FE 3E 37 30 A 
in HEX values.. F9 3E 31 31 30 A 
in HEX values.. FE BE 37 30 A 
in HEX values.. F9 3E 39 31 30 A 
in HEX values.. FE BE 37 3C A 
in HEX values.. F9 3E 39 39 30 A 
in HEX values.. FE 3E 36 3E A 
in HEX values.. F9 3F 39 39 3C A 
in HEX values.. FC 3E 37 3E A 
in HEX values.. F9 BF 39 39 3E A 
in HEX values.. FE 3E 36 3E CA 
in HEX values.. F9 BE 39 39 3E A 
in HEX values.. FE 3E 37 3E CA 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 33 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 33 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 0 20 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 20 20 37 30 A 
in HEX values.. 1 20 31 31 30 A

cepics: Serial2.write(0xb3); // | Serial2.write(0x00); // 0 Serial2.write(0x20); // spazio Serial2.write(0x36); // "6"0 cm Serial2.write(0x30); // 6"0" cm Serial2.write(0x0A); //  CR ('\r') Serial2.write(0x0D); //  LF ('\n')

O ecco, adesso si (quasi)... quello 0 doveva essere uno 0x30. Ma anche:

Serial2.write('|');
Serial2.write('0');
Serial2.write(' '); // spazio
Serial2.write('6');
Serial2.write('0');
Serial2.write('\r');
Serial2.write('\n');

O ancora:

Serial2.print("|0 60\r\n");

O ancora:

Serial2.println("|0 60");

Sono tutti equivalenti.

QUESTA QUARANTENA COMINCIA A PIACERMI!!! :slight_smile: :slight_smile: :slight_smile: :slight_smile:

simulatore:

#include <M5Stack.h>
HardwareSerial Serial2_(2);

int ft = 0;
int cm = 0;
void setup() {

  M5.begin();
  Serial.begin(115200);
  delay(1000);
  // Serial2.begin(baud, config, rxPin, txPin, invert)
  Serial2.begin(9600, SERIAL_8N1, 16, 17);
  delay(1000);


}

void loop() {

    Serial2.write(0xb3); // |
    Serial2.write(0x30); // 0
    Serial2.write(0x20); // spazio
    Serial2.write(0x36); // "6"0 cm
    Serial2.write(0x30); // 6"0" cm
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'
    Serial2.write(0xb3); // |
    Serial2.write(0x01); // 1
    Serial2.write(0x20); // spazio
   
    Serial2.write(0x31); // "1"10 misura
    Serial2.write(0x31); // 1"1"0 misura
    Serial2.write(0x30); // 11"0" misura
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'

    delay(100);

    Serial2.write(0xb3); // |
    Serial2.write(0x30); // 0
    Serial2.write(0x20); // spazio
    Serial2.write(0x37); // "7"0 ft
    Serial2.write(0x30); // 7"0" ft
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'

    Serial2.write(0xb3); // |
    Serial2.write(0x01); // 1
    Serial2.write(0x20); // spazio
    Serial2.write(0x31); // "1"10 misura
    Serial2.write(0x31); // 1"1"0 misura
    Serial2.write(0x30); // 11"0" misura
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'

    delay(100);


  // per vedere se il codice gira
  Serial.println("|0 60");
  Serial.println("|1 110");
  Serial.println();
  Serial.println("|0 70");
  Serial.println("|1 110");
  Serial.println();

}

RX:

// Example 6 - Receiving binary data
#include <M5Stack.h>
const byte numBytes = 32;
byte receivedBytes[numBytes];
byte numReceived = 0;

boolean newData = false;

void setup() {

  M5.begin();

  // Serial2.begin(baud, config, rxPin, txPin, invert)
  Serial2.begin(9600, SERIAL_8N1, 25, 13);
  delay(1000);
  Serial.begin(115200);
  delay(1000);
  Serial.println("<Arduino is ready>");

}

void loop() {
  recvBytesWithStartEndMarkers();
  showNewData();
}

void recvBytesWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  byte startMarker = 0xb3; // "|"
//  byte endMarker = 0x0A; // "/r"
  //  byte startMarker = 0x0D; // "/n"
    byte endMarker = 0x0D; // "/n"

  byte rb;


  while (Serial2.available() > 0 && newData == false) {
    rb = Serial2.read();

    if (recvInProgress == true) {
      if (rb != endMarker) {
        receivedBytes[ndx] = rb;
        ndx++;
        if (ndx >= numBytes) {
          ndx = numBytes - 1;
        }
      }
      else {
        receivedBytes[ndx] = '\0'; // terminate the string
        recvInProgress = false;
        numReceived = ndx;  // save the number for use when printing
        ndx = 0;
        newData = true;
      }
    }

    else if (rb == startMarker) {
      recvInProgress = true;
    }
  }
}

void showNewData() {
  if (newData == true) {
    Serial.print("in HEX values.. ");
    for (byte n = 0; n < numReceived; n++) {
      Serial.print(receivedBytes[n], HEX);
      Serial.print(' ');
    }
    Serial.println();
    newData = false;
  }
}

serial monitor output:

Arduino is ready>
in HEX values.. FB 5B ED BB C1 20 31 31 10 A 5 0 FF 0 FE 0 FF 0 FF 0 36 F2 BB FB 5B ED BB E1 20 31 31 
in HEX values.. FD BF BD 39 38 A 
in HEX values.. FD BF BD 3D 30 A 
in HEX values.. FD BF BD 3D 34 A 
...
in HEX values.. FD BF BD 3D 3E A 
in HEX values.. FD BF BD 3D 38 A 
in HEX values.. FD BF BD 3D 3C A 
...
in HEX values.. FD BF BD BD 3F A 
in HEX values.. F9 BF BD BD 3F A 
in HEX values.. FD BF BD BD 3F A 
in HEX values.. FD BF BD BD 3F A 
in HEX values.. FD BF BD BD 3F A 
...
in HEX values.. F9 BF BD BD BF B 
in HEX values.. F9 BF BD BD BF B 
in HEX values.. F9 BF BD BD BF A 
in HEX values.. F9 BF BD BD BF CB 
in HEX values.. F9 BF BD BD BF 8B 
in HEX values.. F9 BF BD BD BF CB 
...
in HEX values.. F9 BE BD BD BF EB 
in HEX values.. F9 BF BD BD BF EB 
in HEX values.. F9 BF BD BD BF EB 
in HEX values.. F9 BF BD BD BF CB 
in HEX values.. F9 BF BD BD BF EB 8D 0 FF 0 0 FF 0 FF 0 24 4 92 30 A 
in HEX values.. F1 BF BD BD BF EB 
in HEX values.. F1 BF BD BD BF EB CD 0 0 FF 0 FF 0 0 24 4 92 30 A 
in HEX values.. F1 BF BD BD BF EB CD 0 FF 0 FF 0 FF 0 FE 0 24 4 8A 10 A 
in HEX values.. F1 BF BD BD BF EB CD 0 FF 0 0 FF 0 FF 0 24 4 92 10 A 
...
in HEX values.. 1 BE BD BD BF EB ED 0 0 FF 0 0 FE 80 2 4 8A 10 A 
in HEX values.. 1 BE 39 BD BF EB ED 0 FF 0 FF 0 0 80 2 4 92 10 A 
in HEX values.. 1 BE B9 BD BF EB ED 0 0 FF 0 0 60 2 4 8A 10 A 
in HEX values.. 1 BC BD BD BF EB CD 0 FF 0 FF 0 FF 0 40 2 4 92 10 A 
in HEX values.. 1 3E B9 BD BF EB ED 0 FF 0 FE 0 0 FF 20 2 4 8A 10 A 
in HEX values.. 1 BC 3D BD BF EB ED 0 FF 0 0 FF 0 60 2 4 92 10 A 
in HEX values.. 1 3C B9 BD BF EB ED 0 0 FF 0 FF 0 FF 30 2 4 8A 10 A 
.....
in HEX values.. 1 30 B9 B9 BF EB ED 0 FF 0 FF 0 FF 0 FF 26 20 20 11 10 A 
in HEX values.. 1 20 B9 BD BF EB ED 0 FF 0 0 0 FE B3 20 20 12 10 A 
in HEX values.. 1 20 B9 BD BF EB ED 0 FF 0 FF 0 FF 0 B3 30 20 12 10 A 
in HEX values.. 1 20 39 BD BF EB ED 0 0 FF 0 0 FF B3 30 20 11 10 A 
in HEX values.. 1 20 39 BD BF EB ED 0 0 0 0 B3 30 20 12 10 A 
in HEX values.. 1 20 39 B9 BF EB ED 0 0 0 FF 0 FF B3 30 20 11 10 A 5 B3 1 20 39 B9 BF EB ED 0 FF 0 
in HEX values.. 1 20 31 B9 BF EB ED 0 FF 0 FE 0 FE 0 FF B3 30 20 11 10 A 5 B3 1 20 31 B9 BF EB ED 0 
in HEX values.. 30 20 36 10 A 5 B1 1 20 31 39 BE EB ED 0 FF 0 FF 0 FF 0 FF B3 30 20 33 10 A 5 91 2 
in HEX values.. 30 20 11 10 A 5 91 1 20 31 31 3E EB ED 0 FE 0 FF 0 FE 0 FF B3 30 20 16 10 A 5 91 1 
in HEX values.. 1 20 31 31 3E EA ED 0 FE 0 FF 0 FA 0 FC B3 30 20 13 30 A 5 93 1 20 31 31 3E EA ED 0 
in HEX values.. 30 20 33 10 A 5 93 1 20 31 31 BE EB ED 0 FE 0 FE 0 FD 0 FC B3 30 20 36 10 A 5 93 1 
in HEX values.. 30 20 33 10 A 
in HEX values.. 30 20 16 10 A 5 B1 1 20 31 31 3C EA ED 0 FE 0 FE 0 FF 0 FC B3 30 20 11 10 A 5 91 1 
in HEX values.. 30 20 33 10 A 5 91 1 20 31 31 3C CA ED 0 FF 0 FE 0 FF 0 FF B3 30 20 16 10 A 5 91 40 
in HEX values.. 3F 20 37 30 A 
in HEX values.. 40 8A 11 30 A 
in HEX values.. 40 8A 11 30 A 
in HEX values.. 1 20 11 11 30 A 
in HEX values.. 1 20 11 11 30 A 
in HEX values.. 40 8A 11 30 A 
in HEX values.. 1 20 11 11 30 A 
in HEX values.. 1 20 11 11 30 A 
in HEX values.. BF BF B7 3F A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF 37 3F A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF B7 3F A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF B7 3F A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF B7 3F A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF B7 3F A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF B7 BF A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF B7 BF A 
in HEX values.. 1 20 11 11 10 A 
in HEX values.. BF BF B7 3F A 
in HEX values.. 1 20 31 11 10 A 
in HEX values.. BF BF 37 BE A 
in HEX values.. 1 20 31 11 30 A 5 0 FF 0 FF 0 FE 0 FE 0 B3 BF BF B7 BF A 
in HEX values.. 1 20 11 11

se invece nel codice del RX cambio:

const byte numBytes = 32;

con

const byte numBytes = 8;

l'output, quando si stabilizza,diventa questo:

in HEX values.. 3E 3E 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 36 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 37 30 A 
in HEX values.. 1 20 31 31 30 A 
in HEX values.. 3E 3E 36 30 A 
in HEX values.. 1 20 31 31 30 A

cepics: Serial2.write(0x01); // 1

Qui stai ancora trasmettendo il byte 1, non il carattere '1'

me tapino!!!

il nuovo simulatore:

#include <M5Stack.h>
HardwareSerial Serial2_(2);


void setup() {
  M5.begin();
  Serial.begin(115200);
  delay(1000);
  // Serial2.begin(baud, config, rxPin, txPin, invert)
  Serial2.begin(9600, SERIAL_8N1, 16, 17);
  delay(1000);

}

void loop() {

    Serial2.write(0xb3); // |
    Serial2.write(0x30); // 0
    Serial2.write(0x20); // spazio
    Serial2.write(0x36); // "6"0 cm
    Serial2.write(0x30); // 6"0" cm
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'
    
    Serial2.write(0xb3); // |
    Serial2.write(0x31); // 1
    Serial2.write(0x20); // spazio
    Serial2.write(0x31); // "1"10 misura
    Serial2.write(0x31); // 1"1"0 misura
    Serial2.write(0x30); // 11"0" misura
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'

    delay(100);

    Serial2.write(0xb3); // |
    Serial2.write(0x30); // 0
    Serial2.write(0x20); // spazio
    Serial2.write(0x37); // "7"0 ft
    Serial2.write(0x30); // 7"0" ft
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'

    Serial2.write(0xb3); // |
    Serial2.write(0x31); // 1
    Serial2.write(0x20); // spazio
    Serial2.write(0x31); // "1"10 misura
    Serial2.write(0x31); // 1"1"0 misura
    Serial2.write(0x30); // 11"0" misura
    Serial2.write(0x0A); //  CR '\r'
    Serial2.write(0x0D); //  LF '\n'


  // per vedere se il codice gira
  Serial.println("|0 60");
  Serial.println("|1 110");
  Serial.println();
  Serial.println("|0 70");
  Serial.println("|1 110");
  Serial.println();

}

l’RX è sempre lo stesso

e questo è l’output:

in HEX values.. 11 20 11 11 10 A 5 0 FF 0 FF 0 FE 0 FF 0 FF BB BF BF B7 BF CB 
in HEX values.. 31 20 11 11 10 A 5 0 0 0 FF 0 FF 0 BB BF BF B7 BF 4A 
in HEX values.. 31 20 11 11 10 A 5 0 FF 0 FF 0 FF 0 FF 0 BB BF BF B7 BF 8B 
in HEX values.. 11 20 11 0 10 0 5 0 FF 0 0 0 FF 0 FE BB BF BF B7 BF 8B 
in HEX values.. 31 20 11 11 10 0 5 0 FF 0 FE 0 FF 0 FF 0 FF BB BF BF B7 BF B 
in HEX values.. 11 20 11 11 10 10 5 2 0 FF 0 FF 0 FF 0 FF BB BF BF B7 BF B 
in HEX values.. 31 20 11 11 20 0 5 2 FE 0 FF 0 FF 0 0 FF BB BF BF B7 BF 4B 
in HEX values.. 11 20 11 11 20 A 5 0 FC 0 FF 0 FE 0 0 FF BB BF BF B7 BF A 
in HEX values.. 31 20 11 11 10 10 5 1 FE 0 FF 0 FF 0 FF 0 FF BB BF BF B7 BF A 
in HEX values.. 11 20 11 11 10 A 5 0 FF 0 FF 0 FF 0 FE 0 FF BB BF BF B7 BF A 
in HEX values.. 11 20 11 0 10 A 5 0 FF 0 FE 0 FF 0 FF 0 FF BB BF BF B7 BF A 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 31 20 11 11 10 A A 2 FE 0 FF 0 FF 0 FE 0 FF BB BF BF B7 BF A 
in HEX values.. 11 20 11 11 0 0 A 1 FF 0 FF 0 FE 0 FE 0 FF BB BF BF B7 BF A 
in HEX values.. 31 20 11 0 0 A 5 1 FE 0 FF 0 FE 0 FE 0 FF BB BF BF B7 3F A 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 31 20 11 11 10 A 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 31 20 11 0 0 0 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 31 20 11 11 0 A 
in HEX values.. 31 20 11 11 10 0 
in HEX values.. 31 20 11 0 10 10 
in HEX values.. 11 20 11 11 10 0 
in HEX values.. 11 20 11 11 10 0 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 11 20 11 31 10 A 
in HEX values.. 11 20 11 0 10 A 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 31 20 11 0 10 A 
in HEX values.. 44 8A 11 10 A 
in HEX values.. 44 8A 11 20 10 
in HEX values.. 11 20 11 11 10 A 
in HEX values.. 44 8A 11 0 A 
in HEX values.. 44 0 14 4 A4

mumble mumble

In ricezione:

byte startMarker = 0xb3; // "|"
//  byte endMarker = 0x0A; // "/r"
//  byte startMarker = 0x0D; // "/n"
byte endMarker = 0x0D; // "/n"

Il crattere '|' è il 0x7c Il carattere '\r' (CR) è il 0x0D Il carattere '\n' (LF) è il 0x0A

Claudio_FF:
In ricezione:Il crattere ‘|’ è il 0x7c
Il carattere ‘\r’ (CR) è il 0x0D
Il carattere ‘\n’ (LF) è il 0x0A

solo in ricezione?

in effetti ho fatto confusione anche sul simulstore…

ma cmq ancora non ho nulla di stabile…

sim

#include <M5Stack.h>
HardwareSerial Serial2_(2);

void setup() {
  M5.begin();
  Serial.begin(115200);
  delay(1000);
  // Serial2.begin(baud, config, rxPin, txPin, invert)
  Serial2.begin(9600, SERIAL_8N1, 16, 17);
  delay(1000);
}

void loop() {
  //  for (cm = 0; cm <= 255; cm++) {
  //    Serial2.write(0x7C); // |
  //    Serial2.write(0x30); // 0
  //    Serial2.write(0x20); // spazio
  //    Serial2.write(0x36); // "6"0 cm
  //    Serial2.write(0x30); // 6"0" cm
  //    Serial2.write(0x0D); //  CR '\r'
  //    Serial2.write(0x0A); //  LF '\n'

  //DEC
  Serial2.write(124); // |
  Serial2.write(48); // 0
  Serial2.write(32); // spazio
  Serial2.write(54); // "6"0 cm
  Serial2.write(48); // 6"0" cm
  Serial2.write(13); //  CR '\r'
  Serial2.write(10); //  LF '\n'

  //    Serial2.write(0x7C); // |
  //    Serial2.write(0x31); // 1
  //    Serial2.write(0x20); // spazio
  //    Serial2.write(0x31); // "1"10 misura
  //    Serial2.write(0x31); // 1"1"0 misura
  //    Serial2.write(0x30); // 11"0" misura
  //    Serial2.write(0x0D); //  CR '\r'
  //    Serial2.write(0x0A); //  LF '\n'


  delay(500);

  


  // per vedere se il codice gira
  Serial.println("|0 60");
  Serial.println("|1 110");
  Serial.println();
  Serial.println("|0 70");
  Serial.println("|1 110");
  Serial.println();

}

RX:

// Example 6 - Receiving binary data
#include <M5Stack.h>
const byte numBytes = 32;
//const byte numBytes = 8;
//const byte numBytes = 16;
byte receivedBytes[numBytes];
byte numReceived = 0;
//bool unit;
//int suca;

boolean newData = false;

void setup() {

  M5.begin();
  Serial.begin(115200);
  delay(1000);

  Serial2.begin(9600, SERIAL_8N1, 25, 13);  //STICK GROVE
  delay(1000);

  Serial.println("<Arduino is ready>");

}

void loop() {
  recvBytesWithStartEndMarkers();
  showNewData();
}

void recvBytesWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  //  byte startMarker = 0x0A; // "/n"
  byte startMarker = 0x7C; // "|"
    byte endMarker = 0x0A; // (LF) "/n"
//  byte endMarker = 0x0D; // (CR) "/r"


  byte rb;


  while (Serial2.available() > 0 && newData == false) {
    rb = Serial2.read();

    if (recvInProgress == true) {
      if (rb != endMarker) {
        receivedBytes[ndx] = rb;
        ndx++;
        if (ndx >= numBytes) {
          ndx = numBytes - 1;
        }
      }
      else {
        receivedBytes[ndx] = '\0'; // terminate the string
        recvInProgress = false;

        numReceived = ndx;  // save the number for use when printing
        //        suca = receivedBytes[3];
        ndx = 0;
        newData = true;
      }
    }

    else if (rb == startMarker) {
      recvInProgress = true;
    }
  }
}

void showNewData() {
  if (newData == true) {

    //    Serial.print(" ... HEX Value.. ");
    for (byte n = 0; n < numReceived; n++) {
      Serial.print(receivedBytes[n], HEX);
      Serial.print(' ');

    }

    Serial.println();


    newData = false;
  }
}

monitor seriale RX:

10 20 0 0 0 
10 20 12 0 0 0 0 0 FF 0 0 FF 0 FF 0 FF 0 0 0 FF 0 FF 0 0 FF 0 FF 0 FF 0 0 
30 20 0 10 0 0 0 FF 0 FF 0 FF 0 FF 0 0 FF 0 0 FF 0 0 0 0 0 FF 0 FF 0 FF 0 
30 20 12 10 5 0 0 FF 0 0 FF 0 0 0 0 FF 0 0 0 FF 0 FF 0 FF 0 FF 0 FF 0 0 0 
30 20 12 10 0 0 0 FF 0 FF 0 FF 0 FF 0 0 0 FF 0 FF 0 FF 0 FF 0 FF 0 FF 0 FF 0 
30 20 12 10 0 0 0 FF 0 FF 0 FF 0 FF 0 0 FF 0 FF 0 FF 0 0 FF 0 0 FF 0 FF 0 0 
10 20 12 0 5 
10 20 12 0 0 0 0 0 0 0 FF 0 0 FF 0 0 FF 0 0 0 FF 0 0 0 0 0 FF 0 0 0 0 
30 20 12 10 0 0 0 FF 0 FF 0 0 0 0 FF 0 FF 0 FF 0 FF 0 0 0 0 FF 0 FF 0 0 0 
10 20 12 0 0 0 0 FF 0 FF 0 0 0 0 FF 0 0 FF 0 FF 0 0 0 0 0 FF 0 FF 0 0 FF 
30 20 12 10 0 0 0 FF 0 FF 0 FF 0 0 0 0 0 0 0 0 0 FF 0 FF 0 0 FF 0 0 0 FF 
10 20 12 10 5 
30 20 12 10 5 
30 20 12 10 5 
30 20 12 10 5 
30 20 12 10 5 
30 20 36 10 5 
BE BF B7 BF ED 
30 20 12 10 D 
30 20 12 10 D 
30 20 32 10 5 
30 20 36 10 5 
30 20 36 10 5 
BF BF B7 6B EB 0 FF 0 FF 0 0 0 FF 0 0 FF 0 0 0 0 0 0 0 0 FF 0 0 FF 0 0 0 
10 20 12 0 0 0 0 FF 0 0 0 0 0 0 0 0 FF 0 0 0 FE 0 0 0 FF 0 0 0 FF 0 0 
30 20 12 10 0 0 0 0 0 0 0 0 0 0 0 0 FF 0 0 0 0 FF 0 FF 0 0 0 0 0 0 0 
BF BF F7 BF ED EB 0 FF 0 0 0 FF 0 0 0 0 FF 0 0 0 FF 0 FF 0 0 FF 0 0 0 0 FF 
10 20 0 0 0 0 0 FF 0 FF 0 FF 0 FF 0 FF 0 FF 0 FF 0 FF 0 FF 0 FF 0 FE 0 FE 0 
10 20 0 10 5 0 0 0 0 FF 0 FF 0 0 0 FF 0 0 0 0 FF 0 0 FF 0 0 FF 0 FF 0 FF 
30 20 12 10 0 0 0 0 0 0 0 0 FF 0 0 0 FF 0 0 0 0 0 FF 0 FF 0 FF 0 0 FF 0 
30 20 12 10 0 0 0 0 FF 0 0 0 0 0 FF 0 FF 0 0 0 0 0 FF 0 FF 0 0 FF 0 FF 0 
30 20 12 10 0 0 0 0 0 0 0 0 0 0 FF 0 0 FF 0 FF 0 FF 0 0 FF 0 FF 0 0 0 0 
30 20 12 10 0 0 0 0 0 0 FF 0 0 0 0 0 FF 0 0 0 0 0 FF 0 0 0 0 0 FF 0 FF 
30 20 0 10 0 0 0 0 0 FF 0 0 0 0 FF 0 0 0 0 0 0 0 FF 0 0 FF 0 0 0 FF 0 
BF BF B7 BF ED EB 0 FF 0 FF 0 0 FF 0 0 FF 0 FF 0 FF 0 0 0 0 0 FF 0 0 0 FF 0 
10 20 12 0 5 
10 20 0 10 0 
10 20 12 10 0 
30 20 12 0 0 0 0 0 FF 0 0 FF 0 FF 0 FF 0 FF 0 FF 0 0 0 FF 0 FF 0 0 FF 0 FF 
BF BF BF EB EB 0 0 FF 0 0 0 0 0 FF 0 0 0 0 0 0 0 FF 0 FF 0 FF 0 0 0 0 0 
10 20 12 0 5 0 0 FF 0 FF 0 FF 0 0 FF 0 FF 0 FF 0 0 FF 0 FF 0 FF 0 0 0 FF 0 
30 20 12 10 5 0 0 0 0 0 FF 0 0 FF 0 0 FF 0 FF 0 0 0 0 0 0 0 0 FF 0 FF 0 
BF BF B7 BF ED EB 0 0 0 0 0 0 0 0 0 0 0 0 0 FF 0 0 0 0 0 0 0 0 0 0 FF 
30 20 12 10 5 
30 20 12 30 D 
10 20 12 10 5 
10 20 12 10 5 
10 20 16 10 5 
30 20 36 10 D

Sono un tacchino!!!

le connessioni da fare tra gli “arduino” sono:

TX------RX
RX------TX
GRD—GRD

sim:

#include <M5Stack.h>
HardwareSerial Serial2_(2);

void setup() {
  M5.begin();
  Serial.begin(115200);
  delay(1000);
  // Serial2.begin(baud, config, rxPin, txPin, invert)
  Serial2.begin(9600, SERIAL_8N1, 16, 17);
  delay(1000);
}

void loop() {
  //DEC
  Serial2.write(124); // |
  Serial2.write(48); // 0
  Serial2.write(32); // spazio
  Serial2.write(32); // spazio
  Serial2.write(54); // "6"0 cm
  Serial2.write(48); // 6"0" cm
  Serial2.write(13); //  CR '\r'
  Serial2.write(10); //  LF '\n'

  Serial2.write(124); // |
  Serial2.write(49); // 1
  Serial2.write(32); // spazio
  Serial2.write(49); // "1"10 misura
  Serial2.write(49); // 1"1"0 misura
  Serial2.write(48); // 11"0" misura
  Serial2.write(13); //  CR '\r'
  Serial2.write(10); //  LF '\n'

  Serial2.write(124); // |
  Serial2.write(48); // 0
  Serial2.write(32); // spazio
  Serial2.write(32); // spazio
  Serial2.write(55); // "7"0 ft
  Serial2.write(48); // 7"0" ft
  Serial2.write(13); //  CR '\r'
  Serial2.write(10); //  LF '\n'

  Serial2.write(124); // |
  Serial2.write(49); // 1
  Serial2.write(32); // spazio
  Serial2.write(49); // "1"10 misura
  Serial2.write(49); // 1"1"0 misura
  Serial2.write(48); // 11"0" misura
  Serial2.write(13); //  CR '\r'
  Serial2.write(10); //  LF '\n'

  //HEX
  Serial2.write(0x7C); // |
  Serial2.write(0x30); // 0
  Serial2.write(0x20); // spazio
  Serial2.write(0x20); // spazio
  Serial2.write(0x36); // "6"0 cm
  Serial2.write(0x30); // 6"0" cm
  Serial2.write(0x0D); //  CR '\r'
  Serial2.write(0x0A); //  LF '\n'
  //
  Serial2.write(0x7C); // |
  Serial2.write(0x31); // 1
  Serial2.write(0x20); // spazio
  Serial2.write(0x31); // "1"10 misura
  Serial2.write(0x31); // 1"1"0 misura
  Serial2.write(0x30); // 11"0" misura
  Serial2.write(0x0D); //  CR '\r'
  Serial2.write(0x0A); //  LF '\n'

  Serial2.write(0x7C); // |
  Serial2.write(0x30); // 0
  Serial2.write(0x20); // spazio
  Serial2.write(0x20); // spazio
  Serial2.write(0x37); // "7"0 cm
  Serial2.write(0x30); // 7"0" cm
  Serial2.write(0x0D); //  CR '\r'
  Serial2.write(0x0A); //  LF '\n'
  //
  Serial2.write(0x7C); // |
  Serial2.write(0x31); // 1
  Serial2.write(0x20); // spazio
  Serial2.write(0x31); // "1"10 misura
  Serial2.write(0x31); // 1"1"0 misura
  Serial2.write(0x30); // 11"0" misura
  Serial2.write(0x0D); //  CR '\r'
  Serial2.write(0x0A); //  LF '\n'


//locale

  Serial.write(124); // |
  Serial.write(48); // 0
  Serial.write(32); // spazio
  Serial.write(32); // spazio
  Serial.write(54); // "6"0 cm
  Serial.write(48); // 6"0" cm
  Serial.write(13); //  CR '\r'
  Serial.write(10); //  LF '\n'

  Serial.write(124); // |
  Serial.write(49); // 1
  Serial.write(32); // spazio
  Serial.write(49); // "1"10 misura
  Serial.write(49); // 1"1"0 misura
  Serial.write(48); // 11"0" misura
  Serial.write(13); //  CR '\r'
  Serial.write(10); //  LF '\n'


  Serial.write(124); // |
  Serial.write(48); // 0
  Serial.write(32); // spazio
  Serial.write(32); // spazio
  Serial.write(55); // "6"0 cm
  Serial.write(48); // 6"0" cm
  Serial.write(13); //  CR '\r'
  Serial.write(10); //  LF '\n'

  Serial.write(124); // |
  Serial.write(49); // 1
  Serial.write(32); // spazio
  Serial.write(49); // "1"10 misura
  Serial.write(49); // 1"1"0 misura
  Serial.write(48); // 11"0" misura
  Serial.write(13); //  CR '\r'
  Serial.write(10); //  LF '\n'

}

RX:

// Example 6 - Receiving binary data
#include <M5Stack.h>
//const byte numBytes = 32;
const byte numBytes = 8;
//const byte numBytes = 10;
//const byte numBytes = 16;
byte receivedBytes[numBytes];
byte numReceived = 0;


boolean newData = false;

void setup() {

  M5.begin();
  Serial.begin(115200);
  delay(1000);
  Serial2.begin(9600, SERIAL_8N1, 25, 13);  //STICK GROVE
  delay(1000);

  Serial.println("<Arduino is ready>");

}

void loop() {
  recvBytesWithStartEndMarkers();
  showNewData();
}

void recvBytesWithStartEndMarkers() {
  static boolean recvInProgress = false;
  static byte ndx = 0;
  //  byte startMarker = 0x0A; // "/n"
  byte startMarker = 0x7C; // "|"
    byte endMarker = 0x0A; // (LF) "/n"
//  byte endMarker = 0x0D; // (CR) "/r"


  byte rb;


  while (Serial2.available() > 0 && newData == false) {
    rb = Serial2.read();

    if (recvInProgress == true) {
      if (rb != endMarker) {
        receivedBytes[ndx] = rb;
        ndx++;
        if (ndx >= numBytes) {
          ndx = numBytes - 1;
        }
      }
      else {
        receivedBytes[ndx] = '\0'; // terminate the string
        recvInProgress = false;

        numReceived = ndx;  // save the number for use when printing
        //        suca = receivedBytes[3];
        ndx = 0;
        newData = true;
      }
    }

    else if (rb == startMarker) {
      recvInProgress = true;
    }
  }
}

void showNewData() {
  if (newData == true) {

    //    Serial.print(" ... HEX Value.. ");
    for (byte n = 0; n < numReceived; n++) {
      Serial.print(receivedBytes[n], HEX);
      Serial.print(' ');
    }
    Serial.println();

    newData = false;
  }
}

monitor RX:

30 20 20 36 30 D 
31 20 31 31 30 D 
30 20 20 37 30 D 
31 20 31 31 30 D 
30 20 20 36 30 D 
31 20 31 31 30 D 
30 20 20 37 30 D 
31 20 31 31 30 D 
30 20 20 36 30 D 
31 20 31 31 30 D 
30 20 20 37 30 D 
31 20 31 31 30 D 
30 20 20 36 30 D 
31 20 31 31 30 D 
30 20 20 37 30 D 
31 20 31 31 30 D 
30 20 20 36 30 D 
31 20 31 31 30 D 
30 20 20 37 30 D 
31 20 31 31 30 D 
30 20 20 36 30 D 
31 20 31 31 30 D 
30 20 20 37 30 D 
31 20 31 31 30 D 
30 20 20 36 30 D

cosa manda l'apparato tra 0x7C, 0x31 e le cifre?

degli spazi (0x20), dei nulli(0x00) o degli zeri(0x30)?

  |1  100
  |0  60
  |1  120
  |0  60
  |1  93
  |0  60
  |1  95
  |0  70
  |1 211
  |0  70
  |1 208