Delay switching to LPG with Arduino NANO

String Versione = "avviobenzina-17";
/*

Note: 
avvio con bulbo freddo, inferiore a 65 gradi, 
	si accende led giallo
	sirena francese lenta, 
	attira i relè 
	fa un bip circa 8 secondi in attesa che salga la temperatura.
quando raggiunge la temperatura 	
	sirena francese veloce
	si spegne il giallo 
	si accende il verde, 
	rilascia i relè



avvio con bulbo già caldo, 
	sirena francese lenta e poi sirena francese veloce , 
	led verde, 
	i relè non sono mai attivati
	
	
Per entrare nel menu scrivere "Menu" a 115200 baud





Step 1) si collega il dispositivo di sicurezza WatchDog32 ai pin:
Step 2) si attiva il watchdog im modalità "sorvegliante"
Step 3) si scollega dalla centralina il bubo principale (pin Rele_bulbo attivo) e si collega al suo postp il bulbo simulato che fa "vedere" 
 alla centralina 13 gradi, in questo modo l'auto si avvierà a benzina
Stap 4) si collega il bulbo ad arduino (pin Rele_lettura_bulbo attivo), pin ADC A1, per leggerne il valore.
Step 5) si avvia il ciclo seguente (con durata massima 1 minuto (?), poi esce dal ciclo.) 
  Ciclo 5.1) - legge il valore del trimmer connesso al pin ADC A0.
  Ciclo 5.2) - legge 10.000 volte il bulbo e fa la media per eliminare il rumore di fondo
  Ciclo 6.3) - se la tempertura del bulbo supera quella del timmer termina il ciclo ed esce
 Step 6) ricollega il bulbo alla centralina
 Step 7) mando la cpu a dormire (basso consumo) e non faccio più nulla fino al ptossimo reset. 
*/






/*
WATCHDOG32 BREAKOUT - NOTE HARDWARE
Attenzione, ci sono tre versione di scheda WATCHDOG32 funzionalmente identiche
- 1) monta un transistor NPN Q2 con il lato piatto verso JP2, MARCATO BC317 (TO92 EBC)
- 2) monta un mosfet Q1 con il lato piatto veso R1/R2 , marcato BSS98 
- 3) monta un transistor PNP Q2 con il lato piatto verso JP2, MARCATO BC212 (TO92 CEB)

Le versioni 1 e 2 sono identiche
La versione 3 necessita di una inversione di segnale dichiarando la linea seguente
#define TransistorPNP 1

Il led di Arduino si accende quando ENABLE è attivo, ovvero, quando il reset di WATCHDOG32 è connesso al RESET di ARDUINO

Il tempo di sorveglianza del WATCHDOG è impostabile con un ponticello a goccia
https://www.analog.com/media/en/technical-documentation/data-sheets/ADM1232.pdf

- pin2 TD at GND = 150ms
- pin2 TD floating = 600msec
- pin2 TD at VCC = 1200ms
*/
//********************************************************************************************
//Pinout di Arduino
#define Buzzer 2 // cicalino
#define Led_giallo 3
#define Led_verde 4 //led D1 r1
#define Rele_lettura_bulbo 5
#define Rele_bulbo 6
#define Trigger_Wdog 7  //TRIGGER CONNETTERE AL PIN 3 TRG della scheda WATCHDOG32
#define Free8 8 //non usato
#define Enable_Wdog 9   //ENABLE  CONNETTERE AL PIN 2 TRG della scheda WATCHDOG32
#define Tracepin3 10
#define Tracepin4 11
#define Tracepin5 12
#define Tracepin6 13
//
#define AdcTrimmer A0
#define AFree1 A1
#define AFree2 A2
#define AdcTeCentralina A3
#define AdcTeBulbo A4

// Definizione delle frequenze per le note (in Hz)
#define NOTE_DO 523  // Do - 523 Hz
#define NOTE_RE 587  // Re - 587 Hz
#define NOTE_MI 659  // Mi - 659 Hz
#define NOTE_FA 698  // Fa - 698 Hz
#define NOTE_SOL 784 // Sol - 784 Hz
#define NOTE_LA 880 // Sol - 784 Hz
#define NOTE_WAIT 1200 //

int noteDuration = 500; //durata delle note
//********************************************************************************************
// Dichiarazione della variabile per tenere traccia dello stato del pin


String inputString = "";      // a String to hold incoming data
bool stringComplete = false;  // whether the string is complete
bool ExitFromMenu = false;    // Used for exit from loop 
char Cestino;                 // 
const long interval = 1000;           // interval at which to blink (milliseconds)

bool debug = false;
String inputBuffer = "";       // Buffer per memorizzare i caratteri ricevuti

// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;  // will store last time LED was updated

// Costanti del circuito e del NTC
const float VREF = 5.0; // Tensione di riferimento
const int ADC_MAX = 1023; // Valore massimo dell'ADC
const float R_FIXED = 22000.0; // Resistenza fissa in ohm

// Caratteristiche del sensore NTC
const float T1 = 65.0; // Temperatura a cui il NTC misura R1
const float R1 = 7600.0; // Resistenza del NTC a T1
const float T2 = 13.0; // Temperatura a cui il NTC misura R2
const float R2 = 45200.0; // Resistenza del NTC a T2

// Costante beta del sensore
const float BETA = log(R1 / R2) / ((1.0 / (T1 + 273.15)) - (1.0 / (T2 + 273.15)));

const int CicliPrimoFiltro = 2; // Numero di campioni per ogni lettura
const int CicliGranMedia = 2; // Numero totale di cicli
unsigned long adcGrandTotal = 0; // Somma totale ADC
float voltageGrandTotal = 0.0; // Somma totale delle tensioni
float temperatureGrandTotal = 0.0; // Somma totale delle temperature


// Calcolo delle grandi medie
float adcGrandAverage = (float)adcGrandTotal / CicliGranMedia;
float voltageGrandAverage = voltageGrandTotal / CicliGranMedia;
float temperatureGrandAverage = temperatureGrandTotal / CicliGranMedia;

//------------------------------------

//PROTOTIPI
void Azione1(void);
void Azione2(void);
void Azione3(void);
void Azione4(void);
void Azione5(void);
void Azione6(void);
void Azione7(void);
void Azione8(void);
void Azione9(void);
void Azione10(void);
void Azione11(void);
void Azione12(void);
void Azione13(void);
void Azione14(void);
void Azione15(void);
void Azione16(void);
void Azione17(void);
void Azione18(void);
void Azione19(void);
void Azione99(void);

//------------------------------------


// Funzione per suonare una nota
void playTone(int frequency, int duration) {
  tone(Buzzer, frequency, duration); // Genera il suono sul pin
  delay(duration);                      // Attendi la durata della nota
  noTone(Buzzer);                    // Ferma il suono
}
//********************************
//verifica se devo entrare nel menu
void CheckIfMenu(){
  // Controlla i dati ricevuti sulla seriale
  if (Serial.available() > 0) {
    char receivedChar = Serial.read(); // Legge un carattere
    inputBuffer += receivedChar;       // Aggiunge il carattere al buffer

    // Verifica se il buffer contiene la parola "Menu"
    if (inputBuffer.endsWith("Menu")) {
      Serial.println("Comando 'Menu' rilevato! Entrando nella funzione Menu().");
      Menu(); // Chiama la funzione Menu()
      inputBuffer = ""; // Resetta il buffer
    }

    // Evita che il buffer diventi troppo lungo
    if (inputBuffer.length() > 20) {
      inputBuffer = ""; // Resetta il buffer in caso di overflow
    }
  }

}


//-------------------------------------------------------------------
void loop(){
/*
1 Suona beep accensione
2 Leggi Bulbo connesso alla centralina
3 Leggi soglia impostata sul trimmer e stampala
4 Leggi bulbo connesso Se il bulbo è inferiore al trimmer
  4.1 Scollega il bulbo e collega il bulbo falso (si avvierà a benzina)
  4.2 Inizia a leggere il trimmer ed il bulbo scollegato e ripeti fino a che il bulbo non supera la soglia del trimmer
  4.3 emetti il bip
5 emetti il bip di fine ciclo
6 vai a basso consumo spegni la cpu
*/
  Retrigger_Wdog();
  delay(100);
  Retrigger_Wdog();
  Abilita_Wdog();   //da ora è "sicuro"
  float SaveTempBulbo;
  float SaveSogliaTrimmer;
  // 1 Suona beep accensione
  SirenaFrancese(); //de re mi fa sol

  // 2 Leggi Bulbo connesso alla centralina
  void ConnettiBulbo(); //
  LeggeADCGranMedia(AdcTeCentralina);
  Retrigger_Wdog();
  SaveTempBulbo = temperatureGrandAverage;
  Serial.print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx TEMPERATURA BULBO GRADI ");Serial.print(SaveTempBulbo);Serial.println(" C");


  // 3 Leggi soglia impostata sul trimmer e stampala
  LeggeADCGranMedia(AdcTrimmer);
  SaveSogliaTrimmer = temperatureGrandAverage;
  Retrigger_Wdog();
  Serial.print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx SOGLIA TRIMMER GRADI ");Serial.print(SaveSogliaTrimmer);Serial.println(" C");

// 4 Se il bulbo è inferiore al trimmer
  if (SaveTempBulbo < SaveSogliaTrimmer){
    // 4.1 Scollega il bulbo e collega il bulbo falso (si avvierà a benzina)
    SconnettiBulbo();
    Led_verde_off();
    Led_giallo_on();

    while (true) {
      Retrigger_Wdog();
      delay(200);//attesa
      CheckIfMenu();
      Retrigger_Wdog();
      delay(200);//attesa
      CheckIfMenu();
      Retrigger_Wdog();
      delay(200);//attesa
      CheckIfMenu();
      Retrigger_Wdog();
      delay(200);//attesa
      CheckIfMenu();
      Retrigger_Wdog();
      delay(200);//attesa
      CheckIfMenu();
      Retrigger_Wdog();
      //ciclo di attesa
      playTone(NOTE_WAIT, 100);
      CheckIfMenu();
      Retrigger_Wdog();

      // 4.2 Inizia a leggere il trimmer ed il bulbo scollegato e ripeti fino a che il bulbo non supera la soglia del trimmer
      LeggeADCGranMedia(AdcTeBulbo);
      SaveTempBulbo = temperatureGrandAverage;
      Serial.print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx TEMPERATURA BULBO GRADI ");Serial.print(SaveTempBulbo);Serial.println(" C");
      Retrigger_Wdog();

      LeggeADCGranMedia(AdcTrimmer);
      SaveSogliaTrimmer = temperatureGrandAverage;
      Serial.print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx SOGLIA TRIMMER GRADI ");Serial.print(SaveSogliaTrimmer);Serial.println(" C");
      Retrigger_Wdog();

      if (SaveTempBulbo > SaveSogliaTrimmer){
        // 4.1 Ricollega il bulbo e scollega il bulbo falso (si avvierà a benzina)
        ConnettiBulbo();
        Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx TEMPERATURA RAGGIUNTA ");
        Retrigger_Wdog();
        
        // 4.3 emetti il bip
        Retrigger_Wdog();

        break; // Esce dal ciclo e dalla funzione
      }
    CheckIfMenu();
    }
  }
  Serial.println("rele' rilasciati, bulbo connesso alla centralina");
  Led_verde_on();
  Led_giallo_off();
  //SirenaFranceseVeloce; //de re mi fa sol
  Azione9();
   
  //ciclo infinito, non fa più nulla
  while (true) {
    delay(200);//attesa
    CheckIfMenu();
    Retrigger_Wdog();
    delay(200);//attesa
    Retrigger_Wdog();
    delay(200);//attesa
    CheckIfMenu();
    Retrigger_Wdog();
    delay(200);//attesa
    CheckIfMenu();
    Retrigger_Wdog();
    delay(200);//attesa
    CheckIfMenu();
    Retrigger_Wdog();
    Serial.print(". ");
    CheckIfMenu();
  }


  
  
// 5 emetti il bip di fine ciclo
// 6 vai a basso consumo spegni la cpu




}

//------------------------------------
/*
Nei sistemi che utilizzano numeri a virgola mobile, confrontare due numeri float direttamente usando l'operatore di uguaglianza == può 
 essere problematico a causa delle imprecisioni legate alla rappresentazione in virgola mobile.
Per confrontare due numeri float, è meglio verificare se la differenza assoluta tra i due numeri è inferiore a una soglia (detta epsilon). 
Questo metodo consente di considerare due numeri "uguali" se sono sufficientemente vicini tra loro.
*/
bool compareFloats(float a, float b, float epsilon = 0.0001) {
  return fabs(a - b) < epsilon;
}
//------------------------------------

void LeggeAdcGrezzo(int QualeAdc){
  Serial.print("Lettura ADC ");Serial.println(QualeAdc);
  ClearSerialBuffer();
  while (true) {
    // Controlla se c'è un dato disponibile sulla seriale
    if (Serial.available() > 0) {
      char receivedChar = Serial.read(); // Legge il carattere inviato via seriale
      if (receivedChar == 'Q' || receivedChar == 'q') {
        Serial.println("Interruzione della lettura.");
        break; // Esce dal ciclo e dalla funzione
      }
    }
    Serial.println(analogRead(QualeAdc));
  }
}
//---------------
void LeggeAdcFiltrato(int QualeAdc){
  ClearSerialBuffer();
  while (true) {
    // Controlla se c'è un dato disponibile sulla seriale
    if (Serial.available() > 0) {
      char receivedChar = Serial.read(); // Legge il carattere inviato via seriale
      if (receivedChar == 'Q' || receivedChar == 'q') {
        Serial.println("Interruzione della lettura");
        break; // Esce dal ciclo e dalla funzione
      }
    }
    LeggeADCGranMedia(QualeAdc);
  /*
  for(int i=1;i<1000;i++){
    Serial.println(analogRead(A1));
  */
  }
}














//-------------------------------------------------------------------

// Funzione per calcolare tensione e temperatura dalla media ADC
void CalculateValues(int adcValue, float &voltage, float &temperature) {
  voltage = (adcValue * VREF) / ADC_MAX; // Calcolo della tensione
  float rNtc = R_FIXED * ((VREF / voltage) - 1.0); // Resistenza del NTC
  float tempK = 1.0 / ((1.0 / (T1 + 273.15)) + (log(rNtc / R1) / BETA)); // Temperatura in Kelvin
  temperature = tempK - 273.15; // Conversione in Celsius
}
//-------------------------------------------------------------------

// Funzione per leggere e calcolare media dei valori ADC
int ReadNtcAvg(int inputPin, int CicliPrimoFiltro) {
  unsigned long adcSum = 0;

  for (int i = 0; i < CicliPrimoFiltro; i++) {
    adcSum += analogRead(inputPin);
  }

  return adcSum / CicliPrimoFiltro; // Restituisce il valore medio
}

//-------------------------------------------------------------------

//---------------
void LeggeADCGranMedia(int QualeAdc){
  //int pin = A0 + channel; // Calcola il pin corrispondente
  adcGrandTotal = 0; // Somma totale ADC
  voltageGrandTotal = 0.0; // Somma totale delle tensioni
  temperatureGrandTotal = 0.0; // Somma totale delle temperature


  for (int i = 0; i < CicliGranMedia; i++) {
    Retrigger_Wdog();
    // Media dei valori ADC
    //int avgAdcValue = ReadNtcAvg(pin, CicliPrimoFiltro);
    int avgAdcValue = ReadNtcAvg(QualeAdc, CicliPrimoFiltro);

    // Calcolo della tensione e temperatura
    float avgVoltage, avgTemperature;
    CalculateValues(avgAdcValue, avgVoltage, avgTemperature);

    // Accumula i valori medi
    adcGrandTotal += avgAdcValue;
    voltageGrandTotal += avgVoltage;
    temperatureGrandTotal += avgTemperature;

    if (debug){
      // Stampa i valori per questa iterazione
      Serial.print("Lettura ");
      Serial.print(i + 1);
      Serial.print(": ADC = ");
      Serial.print(avgAdcValue);
      Serial.print(", Tensione = ");
      Serial.print(avgVoltage, 2); // Due cifre decimali
      Serial.print(" V, Temperatura = ");
      Serial.print(avgTemperature, 1); // Una cifra decimale
      Serial.println(" C");
    }
  
  }

  // Calcolo delle grandi medie
   adcGrandAverage = (float)adcGrandTotal / CicliGranMedia;
   voltageGrandAverage = voltageGrandTotal / CicliGranMedia;
   temperatureGrandAverage = temperatureGrandTotal / CicliGranMedia;

  // Stampa delle grandi medie
  Retrigger_Wdog();
  Serial.println("==================================================");
  Serial.print("Media ADC = ");
  Serial.println(adcGrandAverage, 2);
  Serial.print("Media Tensione = ");
  Serial.print(voltageGrandAverage, 2);
  Serial.println(" V");
  Serial.print("Media Temperatura = ");
  Serial.print(temperatureGrandAverage, 1);
  Serial.println(" C");
  Serial.println("==================================================");
  Retrigger_Wdog();

}


// funzioni
//---------------------------------------------------------
void SirenaFrancese(){
  noteDuration=400;
  Retrigger_Wdog();
  playTone(NOTE_MI, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_LA, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_MI, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_LA, noteDuration);
  Retrigger_Wdog();
  noTone(8); //fermo il tono

}
//---------------------------------------------------------
void SirenaFranceseVeloce(){
  noteDuration=250;
  Retrigger_Wdog();
  playTone(NOTE_MI, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_LA, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_MI, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_LA, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_MI, noteDuration);
  Retrigger_Wdog();
  playTone(NOTE_LA, noteDuration);
  Retrigger_Wdog();
  noTone(8); //fermo il tono
}

//---------------------------------------------------------
//lampeggia ed attendein loop il tasto Q per continuare
void BlinkWaitQ(void){
  while (1) {
    char inChar = (char)Serial.read();

    if (inChar == 'q'){
      break;
    }

    delay(500);                       // wait for a second

    if (inChar == 'Q'){
      break;
    }
    
    delay(500); 
  
  }
}
//---------------------------------------------------------
void BlinkRetriggerWaitQ(){
  while (1) {
    digitalWrite(Tracepin5, HIGH);

    Retrigger_Wdog();
    char inChar = (char)Serial.read();
    if (inChar == 'q'){
      break;
    }

    delay(200);                       // wait for a second

    Retrigger_Wdog();    
    if (inChar == 'Q'){
      break;
    }
    delay(200); 
  }
  

  
  
}




//*******************************************************


void Retrigger_Wdog(void) {
  digitalWrite(Trigger_Wdog, HIGH);
  delay(40);
  digitalWrite(Trigger_Wdog, LOW);
  delay(5);
}
//---------------------------------------------------------

void Abilita_Wdog(void) {

  Serial.println("WDOG abilitato");
    digitalWrite(LED_BUILTIN, HIGH);    // turn the ARDUINO LED ON by making the PIN voltage HIGH
  #ifdef TransistorPNP
    digitalWrite(Enable_Wdog, LOW);
  #else
    digitalWrite(Enable_Wdog, HIGH);
  #endif    

}
//---------------------------------------------------------

void Disabilita_Wdog(void) {

  Serial.println("WDOG disabilitato");
  digitalWrite(LED_BUILTIN, LOW);    // turn the ARDUINO LED off by making the pin voltage LOW
  #ifdef TransistorPNP
    digitalWrite(Enable_Wdog, HIGH);
  #else
    digitalWrite(Enable_Wdog, LOW);  
  #endif
}
//---------------------------------------------------------

//---------------------------------------------------------

//---------------------------------------------------------



void ConnettiBulbo(){
  digitalWrite(Rele_lettura_bulbo, LOW); // 
  digitalWrite(Rele_bulbo, LOW); 
}

void SconnettiBulbo(){
  digitalWrite(Rele_lettura_bulbo, HIGH); // 
  digitalWrite(Rele_bulbo, HIGH); 
}




//----------------------
void ClearSerialBuffer() {
  while (Serial.available() > 0) {
    Serial.read(); // Legge e scarta i dati nel buffer
  }
}
//----------------------
void Buzzer_on(){
  digitalWrite(Buzzer, HIGH); // 4
}  

void Buzzer_off(){
  digitalWrite(Buzzer, LOW); // 4
}  
//---------------
void Led_giallo_on(){
  digitalWrite(Led_giallo, HIGH); // 4
}  

void Led_giallo_off(){
  digitalWrite(Led_giallo, LOW); // 4
}  
//---------------
void Led_verde_on(){
  digitalWrite(Led_verde, HIGH); // 
}  

void Led_verde_off(){
  digitalWrite(Led_verde, LOW); // 
}  
//---------------
void Rele_lettura_bulbo_on(){
  digitalWrite(Rele_lettura_bulbo, HIGH); // 
}  

void Rele_lettura_bulbo_off(){
  digitalWrite(Rele_lettura_bulbo, LOW); // 
}  
//---------------
void Rele_bulbo_on(){
  digitalWrite(Rele_bulbo, HIGH); // 
}  

void Rele_bulbo_off(){
  digitalWrite(Rele_bulbo, LOW); // 
}  
//---------------
/*
void LeggeTrimmerGrezzo1000volte(){
  for(int i=1;i<1000;i++){
    Serial.println(analogRead(A0));

  }
}
*/
//---------------
/*
void LeggeTrimmerGranMedia(){
  LeggeADCGranMedia(0);
}
*/
//---------------
/*
void LeggeBulboGrezzo1000volte(){
  ClearSerialBuffer();
  while (true) {
    // Controlla se c'è un dato disponibile sulla seriale
    if (Serial.available() > 0) {
      char receivedChar = Serial.read(); // Legge il carattere inviato via seriale
      if (receivedChar == 'Q' || receivedChar == 'q') {
        Serial.println("Interruzione della lettura da A0.");
        break; // Esce dal ciclo e dalla funzione
      }
    }
    Serial.println(analogRead(A1));
  }
}
*/
//---------------
/*
void LeggeBulboGranMedia(){
  ClearSerialBuffer();
  while (true) {
    // Controlla se c'è un dato disponibile sulla seriale
    if (Serial.available() > 0) {
      char receivedChar = Serial.read(); // Legge il carattere inviato via seriale
      if (receivedChar == 'Q' || receivedChar == 'q') {
        Serial.println("Interruzione della lettura da A0.");
        break; // Esce dal ciclo e dalla funzione
      }
    }
    LeggeADCGranMedia(1);
  }
}
*/
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void setup() {

  pinMode(Buzzer, OUTPUT); // 3 // cicalino
  pinMode(Led_giallo, OUTPUT); // 4
  pinMode(Led_verde, OUTPUT); // 5
  pinMode(Rele_lettura_bulbo, OUTPUT); // 6
  pinMode(Rele_bulbo, OUTPUT); // 7
  pinMode(Trigger_Wdog, OUTPUT); // 8  //TRIGGER CONNETTERE AL PIN 3 TRG della scheda WATCHDOG32
  pinMode(Enable_Wdog, OUTPUT); // 9   //ENABLE  CONNETTERE AL PIN 2 TRG della scheda WATCHDOG32
  pinMode(Tracepin3, OUTPUT);
  pinMode(Tracepin4, OUTPUT);
  pinMode(Tracepin5, OUTPUT);
  pinMode(Tracepin6, OUTPUT);

  digitalWrite(Buzzer, LOW); // 3 // cicalino
  digitalWrite(Led_giallo, LOW); // 4
  digitalWrite(Led_verde, LOW); // 5
  digitalWrite(Rele_lettura_bulbo, LOW); // 6
  digitalWrite(Rele_bulbo, LOW); // 7
  digitalWrite(Trigger_Wdog, LOW); // 8  //TRIGGER CONNETTERE AL PIN 3 TRG della scheda WATCHDOG32
  digitalWrite(Enable_Wdog, LOW); // 9   //ENABLE  CONNETTERE AL PIN 2 TRG della scheda WATCHDOG32
  digitalWrite(Tracepin3, LOW); //
  digitalWrite(Tracepin4, LOW);
  digitalWrite(Tracepin5, LOW);
  digitalWrite(Tracepin6, LOW);


   // set the digital pin as output:
   Disabilita_Wdog();
   pinMode(LED_BUILTIN, OUTPUT);

//erial.println( F ("Attivato"));    
   //start serial connection
  Serial.begin(115200); // terminale
  Serial.println();
  Serial.println( F ("|******   SISTEMA RESETTATO  ******|"));
  Serial.println( F (" Sketch build xxxxx "));
  Serial.print( F ("Versione "));Serial.println(Versione);
  Serial.println();


}

//--******************************************************************************************

void(* resetFunc) (void) = 0; //declare reset function @ address 0

//-------------------------------------------


void loopDebug() {
  //--------------------------------------
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;
  }
  //--------------------------------------
  
  Menu();
}

//*******************************************************
/*
  SerialEvent occurs whenever a new data comes in the hardware serial RX. This
  routine is run between each time loop() runs, so using delay inside loop can
  delay response. Multiple bytes of data may be available.
*/
void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline, set a flag so the main loop can
    // do something about it:
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}

//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
void TypeMenuList(void){
    Serial.println();
    Serial.println( F ("|*******************************************"));
    Serial.println( F ("|             ʘ‿ʘ   Menù   (◡_◡)          "));
      Serial.print( F ("|  Ver. "));Serial.println(Versione);
    Serial.println( F ("|  nessuno sta retriggerando il Watchdog32, "));
    Serial.println( F ("|  il led rosso WDOG32 continua a blinkare  "));
    Serial.println( F ("|*******************************************"));
    Serial.println( F ("  0 Reset"));
    Serial.println( F ("  1 Retriggera Watchdog32 ogni 100msec"));
    Serial.println( F ("  2 Abilita Watchdog32 senza retriggerare"));
    Serial.println( F ("  3 Abilita, triggera 5 secondi e poi ferma il trigger, deve resettare"));
    Serial.println( F ("  4 Abilita, triggera con tempi crescenti, deve resettare"));
    Serial.println( F ("  5 Aziona relè bulbo per 3 secondi"));
    Serial.println( F ("  6 Aziona relè lettura bulbo per 3 secondi"));
    Serial.println( F ("  7 Accende led giallo per 3 secondi"));
    Serial.println( F ("  8 Accende led verde per 3 secondi"));
    Serial.println( F ("  9 Suona il cicalino"));
    Serial.println( F ("  10 Temperatura trimmer gradi (Q)"));
    Serial.println( F ("  11 Legge bit ADC trimmer (Q)"));
    Serial.println( F ("  12 Temperatura bulbo sconnesso (Q)"));
    Serial.println( F ("  13 Legge bit ADC bulbo sconnesso (Q)"));
    Serial.println( F ("  14 Temperatura bulbo connesso (Q)"));
    Serial.println( F ("  15 Legge bit ADC bulbo connesso (Q)"));
    Serial.println( F ("  16 Loop principale"));
      Serial.print( F ("  17 Debug is "));
      if(debug){
        Serial.println(" ON");
      }else{
        Serial.println(" OFF");
      }
        
   Serial.println( F ("  18 Legge tutti gli ADC"));
   Serial.println( F ("  19 Collaudo funzione NTC"));
   Serial.println( F (" 99 Torna al loop senza reset"));
  
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void Menu() {
  Disabilita_Wdog(); //ALTRIMENTI RESETA
  //resta nel menu fino a che premi 0
  while (!ExitFromMenu) {
    Disabilita_Wdog();
    TypeMenuList();

    //svuoto il buffer
    while (Serial.available()) {
      Cestino = Serial.read();
    }

    Serial.println();
    // qui ciclo attesa e Flash fino a che non c'è un carattere sulla seriale
    while (!Serial.available()) {
      
      //--------------------------------------
      unsigned long currentMillis = millis();
      if (currentMillis - previousMillis >= interval/4) {
        previousMillis = currentMillis;   
      }     
    }

    // arrivato un carattere
    int CmdMenu = Serial.parseInt();
    Serial.print( F ("ricevuto CmdMenu "));Serial.println(CmdMenu);

    switch (CmdMenu){
      //-------------------------------------------------
      case 0:

        Serial.println( F ("reset tra 1 sec"));
        delay(1000);               // wait for a second
        resetFunc();  //call reset

        delay(100);
        Serial.println( F ("Il reset non ha funzionato"));
      break;
      //-------------------------------------------------
      case 1:
        //    Serial.println("  1 Retriggera Watchdog32 ogni 200msec");
        Azione1();
      break;
      //-------------------------------------------------
      case 2:
        //    Serial.println("  2 Abilita Watchdog32 senza retriggerare");
        Azione2();
      break;
      //-------------------------------------------------
      case 3:
        //Serial.println( F ("  3 Abilita, triggera 5 secondi e poi ferma il trigger, deve resettare"));
        Azione3();
      break;
      //-------------------------------------------------
      case 4:
        //    Serial.println( F ("  4 Abilita, triggera con tempi crescenti, deve resettare"));      
        Azione4();
      break;
      //-------------------------------------------------
      case 5:
        //    5 Aziona relè bulbo per 3 secondi      
        Azione5();
      break;
      //-------------------------------------------------
      case 6:
        //    6 Aziona relè lettura bulbo per 3 secondi"     
        Azione6();
      break;
      //-------------------------------------------------
      case 7:
        //     7 Accende led giallo per 3 secondi"));  
        Azione7();
      break;
      //-------------------------------------------------
      case 8:
        //    8 Accende led verde per 3 secondi"));      
        Azione8();
      break;
      //-------------------------------------------------
      case 9:
        //    9 Suona il cicalino"));      
        Azione9();
      break;
      //-------------------------------------------------
      case 10:
        //     10 Legge il trimmer"));     
        Azione10();
      break;
      //-------------------------------------------------
      case 11:
        //     11 Legge il bulbo"));
        Azione11();
      break;
      //-------------------------------------------------
      case 12:
        //     11 Legge il bulbo"));
        Azione12();
      break;
      //-------------------------------------------------
      case 13:
        //     11 Legge il bulbo"));
        Azione13();
      break;
      //-------------------------------------------------
      case 14:
        //     11 Legge il bulbo"));
        Azione14();
      break;
      //-------------------------------------------------
      case 15:
        //     11 Legge il bulbo"));
        Azione15();
      break;
      //-------------------------------------------------
      case 16:
        //     11 Legge il bulbo"));
        Azione16();
      break;
      //-------------------------------------------------
      case 17:
        //     swap debug;
        Azione17();
      break;
      //-------------------------------------------------
      case 18:
        //     swap debug;
        Azione18();
      break;
      //-------------------------------------------------
      case 19:
        //     swap debug;
        Azione19();
      break;
      //-------------------------------------------------


      case 99:
        Azione99();
      break;
      //-------------------------------------------------

      default:
        //Serial.println( F ("Unrecognized command, try again!"));
        Serial.println( F ("Comando errato! Riprova"));
    } //Serial.available
  } // ExitFromMenu
} // Menu


//*******************************************************

//--------------------------------------------------------------------------
void Azione1(){
  pinMode(Trigger_Wdog, OUTPUT);
  Serial.println( F ("  il led rosso della scheda Watchdog32 si deve spegnere"));
  Serial.println( F ("  Arduino non si deve resettare"));
  Serial.println( F ("invia Q quando vuoi per uscire"));
  BlinkRetriggerWaitQ(); 
}
//--------------------------------------------------------------------------
void Azione2(){
  Serial.println( F (" il Watchdog32 viene connesso al reset"));
  Serial.println( F (" nessuno triggera il Watchdog32"));
  Serial.println( F (" il led rosso della scheda Watchdog32 continua a blinkare"));
  //Serial.println( F (" tra un secondo dovrebbe resettarsi Arduino"));
  Serial.println( F (" togli il jumper W1 e invia Q"));
  BlinkWaitQ();

  
  delay(1000);
  pinMode(Enable_Wdog, OUTPUT);
  Abilita_Wdog();
  Serial.println( F (" inserisci jumper W1, e in un secondo dovrebbe resettarsi Arduino"));
...

This file has been truncated, please download it to see its full contents.