arduino B

#include <SoftwareSerial.h>
#include <FastCRC.h>

SoftwareSerial mySerial(10, 11);  // RX, TX

const int blueLedPin = 8; // Pin del LED blu
const int redLedPin = 13; // Pin del LED red
const int greenLedPin = 12; // Pin del LED green
const int writeLedPin = 9; // Pin del LED write

struct Ricezione {
  char startChar;
  float value_A;
  float value_B;
  int value_C;
  int value_D;
  int value_E;
  int value_F;
  bool value_G;
  bool value_H;
  bool value_I;
  uint32_t crc;
  char endChar;
};

struct Scrittura {
  char startChar;
  //int value;
  float valore_A;
  float valore_B;
  int valore_C;
  int valore_D;
  int valore_E;
  int valore_F;
  bool valore_G;
  bool valore_H;
  bool valore_I;
  char checksum;
  char endChar;
};

Ricezione ricezione;
Scrittura scrittura;

bool validatedCRC = false;
unsigned long tp;
unsigned long tx;
bool In_tx = false;
byte stato = 0;
unsigned long lastCommunicationTime;
const unsigned long ledDuration = 100;  // Durata in millisecondi per cui i LED rimangono accesi

FastCRC32 crc32;
unsigned long lastCRC; // Tempo dell'ultima conferma del CRC
int timeout = 5000; // Intervallo di timeout in millisecondi

void setup() {
  Serial.begin(9600);
  mySerial.begin(1200);
  pinMode(writeLedPin, OUTPUT);
  pinMode(greenLedPin, OUTPUT);
  pinMode(redLedPin, OUTPUT);
  pinMode(blueLedPin, OUTPUT); // Imposta il pin del LED blu come OUTPUT

  lastCommunicationTime = millis();
}
void led() {

  unsigned long currentTime = millis();

  if (mySerial.available() > 0) {
    tp = currentTime;
    digitalWrite(blueLedPin, HIGH);
    stato = 1;
    // In_tx = true;
  }

  if (stato == 1 && currentTime - tp > ledDuration) {
    digitalWrite(blueLedPin, LOW);
    tp = currentTime;
    stato = 2;
  }

  if (stato == 2) {
    if (validatedCRC) {
      digitalWrite(greenLedPin, HIGH);
    } else {
      digitalWrite(redLedPin, HIGH);
    }

    if (currentTime - tp > ledDuration) {
      digitalWrite(greenLedPin, LOW);
      digitalWrite(redLedPin, LOW);
      stato = 0;
    }
  }

  if (In_tx) {
    // if (!mySerial.available() ) {
    tx = currentTime;
    digitalWrite(writeLedPin, HIGH);
    In_tx = false;
    //}
  }
  if (currentTime - tx > ledDuration) {
    digitalWrite(writeLedPin, LOW);
  }
}
unsigned int scritturaSize = sizeof(scrittura);
void loop() {
   resetSerialTimeout(); // Chiamata a resetSerialTimeout per controllare il timeout tra conferme CRC

  led();
  if (mySerial.available() >= scritturaSize) {
    ricevo();
  }
}
void ricevo() {
  //unsigned int scritturaSize = sizeof(scrittura);
unsigned int ricezioneSize = sizeof(ricezione);
  if (mySerial.available() >= scritturaSize) {
   byte* scritturaBytes = (byte*)&scrittura;
    for (size_t i = 0; i < sizeof(scrittura); i++) {
      scritturaBytes[i] = mySerial.read();
    }
    if (scrittura.startChar == 0x02 && scrittura.endChar == 0x03) { // Verifica che i caratteri di inizio e fine trasmissione siano corretti
      char calculatedChecksum = calculateChecksum(&scrittura, sizeof(scrittura) - 2); // Calcola il checksum escludendo startChar e endChar
      if (calculatedChecksum == scrittura.checksum) {
        lastCRC = millis(); // Aggiorna il tempo dell'ultima conferma del CRC
        validatedCRC = true;//imposto variabile conferma led verde
        Serial.print("Valore ricevuto da Arduino A:\n");
        Serial.print("Valore A: ");
        Serial.println(scrittura.valore_A);
        Serial.print("Valore B: ");
        Serial.println(scrittura.valore_B);
        Serial.print("Valore C: ");
        Serial.println(scrittura.valore_C);
        Serial.print("Valore D: ");
        Serial.println(scrittura.valore_D);
        Serial.print("Valore E: ");
        Serial.println(scrittura.valore_E);
        Serial.print("Valore F: ");
        Serial.println(scrittura.valore_F);
        Serial.print("Valore G: ");
        Serial.println(scrittura.valore_G);
        Serial.print("Valore H: ");
        Serial.println(scrittura.valore_H);
        Serial.print("Valore I: ");
        Serial.println(scrittura.valore_I);
        lastCommunicationTime = millis();
        trasmetto();
      } else {
        Serial.println("Errore CRC nei dati ricevuti da Arduino B");
        validatedCRC = false;
      }
    } else {
      Serial.println("Errore nei caratteri di inizio o fine o dati corrotti.");
      validatedCRC = false;
    }
  }
}

void trasmetto() {
  //Serial.flush();
  Serial.println(" e' ora di trasmettere ");
  ricezione.startChar = 0x02; // Carattere di inizio trasmissione (STX)
  ricezione.value_A = 1.23;
  ricezione.value_B = 4.56;
  ricezione.value_C = random(7000, 22000);
  ricezione.value_D = millis() / 2 / 10;
  ricezione.value_E = random(0, 30000);
  ricezione.value_F = random(50, 180);
  ricezione.value_G = false;
  ricezione.value_H = true;
  ricezione.value_I = false;
  ricezione.crc = crc32.crc32((byte*)&ricezione, sizeof(ricezione) - sizeof(ricezione.crc) - 2);
  ricezione.endChar = 0x03; // Carattere di fine trasmissione (ETX)
  In_tx = true;
  byte* ricezioneBytes = (byte*)&ricezione;
  for (size_t i = 0; i < sizeof(ricezione); i++) {
    mySerial.write(ricezioneBytes[i]);
  }
  //Serial.flush();
  lastCommunicationTime = millis();
}



char calculateChecksum(void* data, size_t size) {
  char checksum = 0;
  char* bytes = (char*)data;

  for (size_t i = 0; i < size; i++) {
    checksum ^= bytes[i];
  }

  return checksum;
}

void resetSerialTimeout() {
  if (millis() - lastCRC > timeout) {
    mySerial.end(); // Termina la comunicazione seriale
    delay(150); // Assicurati di attendere un breve periodo prima di riavviare
    validatedCRC = false;
    mySerial.begin(1200);
    lastCRC = millis();
  }
}