String Versione = "Test_board_watchdog32_ITA_v04";
/*
WATCHDOG32 BREAKOUT - NOTE HARDWARE
Attenzione, ci sono tre versioni 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
data sheet sito analog devices ADM1232 . pdf

- pin2 TD at GND = 150ms
- pin2 TD floating = 600msec
- pin2 TD at VCC = 1200ms
*/
//********************************************************************************************
//Pinout di Arduino
#define Trigger_Wdog 8  //TRIGGER CONNETTERE AL PIN 3 TRG della scheda WATCHDOG32
#define Enable_Wdog 9   //ENABLE  CONNETTERE AL PIN 2 TRG della scheda WATCHDOG32

//pin di servizio, si possono omettere
#define Tracepin3 3
#define Tracepin4 4
#define Tracepin5 5
#define Tracepin6 6

//********************************************************************************************
// 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)



// 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



// xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void setup() {

  pinMode(Tracepin3, OUTPUT);
  pinMode(Tracepin4, OUTPUT);
  pinMode(Tracepin5, OUTPUT);
  pinMode(Tracepin6, OUTPUT);

  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(9600); // terminale
  Serial.println();
  Serial.println( F ("|******   SISTEMA RESETTATO  ******|"));
  Serial.println( F (" Sketch build 19092024 "));
  Serial.print( F ("Versione "));Serial.println(Versione);
  Serial.println();


}

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

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

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


void loop() {
  //--------------------------------------
  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 (" 99 Torna al loop senza reset"));
  
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

void Menu() {

  //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:

      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"));
  delay(2000);
  Serial.println( F (" se non si è resettato invia Q"));
  BlinkWaitQ();
  Serial.println( F (" qualcosa non ha funzionato, invia Q per tornare al menu"));
  BlinkWaitQ();
  Disabilita_Wdog();
 
  
}
//--------------------------------------------------------------------------
void Azione3(){
  pinMode(Trigger_Wdog, OUTPUT);
  Serial.println( F (" il led rosso della scheda Watchdog32 si deve spegnere"));
  Serial.println( F (" inserisci il jumper W1 e poi invia Q per continuare"));
  pinMode(Enable_Wdog, OUTPUT);
  digitalWrite(Tracepin3, HIGH);

  Abilita_Wdog();
  BlinkRetriggerWaitQ();
  digitalWrite(Tracepin5, LOW);

  Serial.println( F (" tra 5 secondi il trigger verrà tolto"));
  digitalWrite(Tracepin6, HIGH);
  for(int i = 1; i<6; i++){
    for(int j = 1; j<10; j++){
      Retrigger_Wdog();
      delay(100);
      Serial.print(".");  
    }
    Serial.print(i);
    
    if(i==5){
      digitalWrite(Tracepin4, HIGH);

      Serial.println();
      Serial.println( F ("Tra un secondo si deve resettare"));
      Serial.println( F ("Se non resetta invia Q per continuare"));
      digitalWrite(Tracepin6, LOW);

    }
  }


  BlinkWaitQ();
  Serial.println( F (" qualcosa non ha funzionato, invia Q per tornare al menu"));
  BlinkWaitQ();
  Disabilita_Wdog();
  digitalWrite(Tracepin3, LOW);
  digitalWrite(Tracepin4, LOW);
  digitalWrite(Tracepin5, LOW);
  digitalWrite(Tracepin6, LOW);  
  
}
//--------------------------------------------------------------------------
void Azione4(){
  pinMode(Trigger_Wdog, OUTPUT);
  Serial.println( F (" il led rosso della scheda Watchdog32 si deve spegnere"));
  Serial.println( F (" inserisci il jumper W1 e poi invia Q per continuare"));
  
  pinMode(Enable_Wdog, OUTPUT);
  for(int i = 1; i<10; i++){
    Retrigger_Wdog();
    delay(100);
  }

  
  Abilita_Wdog();
  BlinkRetriggerWaitQ();
  Serial.println( F (" inizio a triggerare a tempi cresenti,deve resettare"));


  for (int t=250;t<3000;t=t+10){
    Serial.println(t);
    Retrigger_Wdog();
    Abilita_Wdog();

    //accelera
    if (t>750){
      t=t+15;
    }

    //accelera
    if (t>1000){
      t=t+50;
    }
     
    delay(t);
      
    // Utilizza digitalWrite() per impostare lo stato del pin
    if (t>1500){
      Serial.println();
      Serial.println("  XXXXXXXXXXXXXXX errore XXXXXXXXXXXXXXX  ");
      Serial.println(" (◡_◡) il tempo ha superato i 1500msec, e non si è generato un Reset");
      Serial.println(" - verifica se è stato inserito il jumper W1");
      Serial.println(" - la scheda non sta funzionando bene");
      Serial.println(" - verifica saldature e montaggio");
      while(1){
              //attesa infinita di un reset
      }
    }
  }
                    // wait for a second
  BlinkWaitQ();
  Serial.println( F (" qualcosa non ha funzionato, invia Q per tornare al menu"));
  BlinkWaitQ();
  Disabilita_Wdog();
}
//--------------------------------------------------------------------------

//--------------------------------------------------------------------------
void Azione99(){
  Serial.println( F ("E' stata scelta l'azione n. 99"));
  delay(2000);
  Serial.println( F ("torno al loop'"));
  delay(2000);
  ExitFromMenu = true;

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



//---------------------------------------------------------
//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
}
//---------------------------------------------------------