arduino A

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

SoftwareSerial mySerial(3, 4);  // RX, TX
const int blueLedPin = 8; // Pin del LED blu
const int redLedPin = 13; // Pin del LED rosso
const int greenLedPin = 12; // Pin del LED verde
const int writeLedPin = 9; // Pin del LED di scrittura

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;
  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 lastByteReceivedTime = 0;

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


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);
  }
}

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 loop() {
  resetSerialTimeout(); // Chiamata a resetSerialTimeout per controllare il timeout tra conferme CRC
  led();
  ricevo();
  if (millis() - lastCommunicationTime >= 1200) {
    In_tx = true;
    Serial.println(" e' ora di trasmettere ");
    scrittura.startChar = 0x02; // Carattere di inizio trasmissione (STX)
    scrittura.valore_A = 1.234;
    scrittura.valore_B = 5.67;
    scrittura.valore_C = millis() / 100;
    scrittura.valore_D = millis() / 2 / 100;
    scrittura.valore_E = random(0, 250);
    scrittura.valore_F = random(50, 180);
    scrittura.valore_G = true;
    scrittura.valore_H = false;
    scrittura.valore_I = true;
    scrittura.checksum = calculateChecksum(&scrittura, sizeof(scrittura) - 2); // Calcola il checksum escludendo startChar e endChar
    scrittura.endChar = 0x03; // Carattere di fine trasmissione (ETX)
    byte* scritturaBytes = (byte*)&scrittura;
    for (size_t i = 0; i < sizeof(scrittura); i++) {
      mySerial.write(scritturaBytes[i]);

    }
    lastCommunicationTime = millis();
  }
}
void ricevo() {
  unsigned int ricezioneSize = sizeof(ricezione);
  unsigned int availableBytes = mySerial.available();
  //resetSerialTimeout(); // Chiamata a resetSerialTimeout per controllare il timeout tra conferme CRC
  if (availableBytes >= ricezioneSize) {
    byte* ricezioneBytes = (byte*)&ricezione;
    for (size_t i = 0; i < sizeof(ricezione); i++) {
      ricezioneBytes[i] = mySerial.read();
    }
    if (ricezione.startChar == 0x02 && ricezione.endChar == 0x03) { // Verifica che i caratteri di inizio e fine trasmissione siano corretti
      uint32_t calculatedCRC = crc32.crc32((byte*)&ricezione, sizeof(ricezione) - sizeof(ricezione.crc) - 2);
      if (calculatedCRC == ricezione.crc) {
        lastCRC = millis(); // Aggiorna il tempo dell'ultima conferma del CRC
        validatedCRC = true; // Imposta variabile conferma LED verde
        Serial.println(" ");
        Serial.print("Valori ricevuti da Arduino B:\n");
        Serial.print("Valore A: ");
        Serial.println(ricezione.value_A);
        Serial.print("Valore B: ");
        Serial.println(ricezione.value_B);
        Serial.print("Valore C: ");
        Serial.println(ricezione.value_C);
        Serial.print("Valore D: ");
        Serial.println(ricezione.value_D);
        Serial.print("Valore E: ");
        Serial.println(ricezione.value_E);
        Serial.print("Valore F: ");
        Serial.println(ricezione.value_F);
        Serial.print("Valore G: ");
        Serial.println(ricezione.value_G);
        Serial.print("Valore H: ");
        Serial.println(ricezione.value_H);
        Serial.print("Valore I: ");
        Serial.println(ricezione.value_I);
        lastCommunicationTime = millis();
      } 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;
    }
  }
}

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
    Serial.print("Resetto la seriale \n");
    delay(150); // Assicurati di attendere un breve periodo prima di riavviare
    validatedCRC = false;
    mySerial.begin(1200);
    lastCRC = millis();
  }
}