// Lista sketch example usati:
// - XCA9554_simpletest
// - HelloWorld LiquidCrystal_I2C
// - Video 650 Paolo Aliverti youtube per menu con encoder
// - 650.menu-encoder da Paolo Aliverti youtube
// - Video 262 Paolo Aliverti youtube per menu con sottolivelli
// - 262.menu-p2 da Paolo Aliverti youtube
// - Video 361 Paolo Aliverti youtube per interrupt interne
// - Video 202 Paolo Aliverti youtube per DAC MCP4725

// Libreria per expander LCD
#include <Adafruit_XCA9554.h>
// Libreria per I2C
#include <Wire.h>
// Libreria per comunicazione SPI con DAC e ADC
#include <SPI.h>
// Librerie per comunicare con display tramite expander LCD
#include <LiquidCrystal_I2C.h>
// Libreria per usare come interrupt qualsiasi pin digitale
//#include <PinChangeInt.h>
// Libreria per usare DAC in uscita
#include <Adafruit_MCP4725.h>

//------------ zona riservata ai parametri per le prove ------------
long nc1 = 500;       // numero cicli prova 1 e 2 parte 1
long nc2 = 500;       // numero cicli prova 1 e 2 parte 2
int dT1P1 = 500; // delay tra pedalate test 1 parte 1
int dT1P2 = 500; // delay tra pedalate test 1 parte 2
int fp1 = 1000;       // force parameter prova 1 e 3 parte 1 [N]
int fp2 = 1100;       // force parameter prova 1 e 3 parte 2 [N]
int fp3 = 450;        // force parameter prova 2 parte 1 [N]
int fp4 = 500;        // force parameter prova 2 parte 2 [N]
long nc31 = 60000;    // numero cicli prova 3 fase 1
long nc32 = 50000;    // numero cicli prova 3 fase 2
long udcp1 = 120000;  // user defined cicle parameter prova 5
int udfp1 = 1000;     // user defined force parameter prova 5 [N]
long udcp2 = 100000;  // user defined cicle parameter prova 6
int udfp2 = 1100;     // user defined force parameter prova 6 [N]
long i = 1;           // puntatore numero prova
int t = 0;            // puntatore countdown inizio prova
bool fl = false;      // flag per prova interrotta
bool flc = false;     // flag per counter interrotto
int w = 5;            // timer countdown per inzio prova
int t0, diff;         // parametri timer non bloccante
long tdb = 0; // debouncing timer pointer
long debD = 200; // debouncing setted delay
int pc = 1;  // puntatore prova (1 o 2)
int T;       // puntatore test (1, 2, 3 o 4)

//------------ zona riservata alle inizializzazioni dei DAC ------------
Adafruit_MCP4725 dac1;  // creo elemento DAC1
Adafruit_MCP4725 dac2;  // creo elemento DAC2
// controllo il dac con un segnale triangolare (da pensare ai parametri)

//------------ zona riservata alle inizializzazioni del DAC ------------
const int chipSelectPin = 53;

//------------ zona riservata alle inizializzazioni per display expander ------------
Adafruit_XCA9554 expander;  // creo elemento expander

//------------ zona riservata alle inizializzazioni per comunicazione display ------------
LiquidCrystal_I2C lcd(0x27, 20, 4);  // set the LCD address (0x20) for a 20 chars and 4 line display
// LCD custom characters
byte Check[] = { 0x00, 0x00, 0x01, 0x03, 0x16, 0x1c, 0x08, 0x00 };
byte DNarrow[] = { 0x00, 0x04, 0x02, 0x0f, 0x12, 0x14, 0x10, 0x0f };
byte UParrow[] = { 0x00, 0x04, 0x08, 0x1e, 0x09, 0x05, 0x01, 0x1e };

//------------ zona riservata alle inizializzazioni dell'encoder ------------
#define encoderPinA 19
#define encoderPinB 18
#define encoderPinS 3
volatile long pos = 0;
//volatile long but = 1;
unsigned long t1 = 0;
int stato = 0;
bool FIRST = true;
int UP, DN, CLIC;
int bt, pvbt;

void setup() {
  Serial.begin(9600);  // scommentare all'occorrenza

  //------------ zona riservata all'encoder ------------
  pinMode(encoderPinA, INPUT_PULLUP);  // PIN 12 su custom PCB - togliere PULLUP
  pinMode(encoderPinB, INPUT_PULLUP);  // PIN 11 su custom PCB - togliere PULLUP
  pinMode(encoderPinS, INPUT_PULLUP);  // PIN 13 su custom PCB - togliere PULLUP
  //pinMode(13, OUTPUT); // inserito solo per debug con led su pin 13 arduino
  //pinMode(20, INPUT);  // disabilito pullup su SDA
  //pinMode(21, INPUT);  // disabilito pullup su SCL

  // definisco operazioni di interrupt con libreria anziche usare interrupt esterne
  //PCintPort::attachInterrupt(encoderPinA, doEncoderA, RISING);
  //PCintPort::attachInterrupt(encoderPinB, doEncoderB, RISING);

  ////------------ da usare solo con PIN riconosciuti dagli interrupt esterni previsti da Arduino ------------
  // encoder pin on interrupt
  attachInterrupt(digitalPinToInterrupt(19), doEncoderA, CHANGE);  //
  // encoder pin on interrupt
  attachInterrupt(digitalPinToInterrupt(18), doEncoderB, CHANGE);  //

  //------------ zona riservata all'expander ------------ // evitabile in quanto se metti indirizzo giusto va anche con libreria liquid i2c
  // Begin communication with the expander
  if (!expander.begin(0x27)) {  // Set I2C expander address (0x20 con A0/A1/A2 a GND)
    //Serial.println("Failed to find XCA9554 chip");
    while (1) {
      // far lampeggiare led rosso per far capire che non ha trovato chip expander per display
      digitalWrite(13, HIGH);  // su custom PCB mettere PIN 3
      delay(1000);
      digitalWrite(13, LOW);
      delay(1000);
    }
  }

  //------------ zona riservata all'ADC ------------
  pinMode(chipSelectPin, OUTPUT);     // set the pin 53 (SS) as an output
  digitalWrite(chipSelectPin, HIGH);  // set SS pin high
  SPI.begin();                        // initialize the SPI library

  //------------ zona riservata al display ------------
  lcd.init();       // initialize the lcd
  lcd.backlight();  // accendi backlight (evitare doppi comandi con altra libreria)

  // Send The Custom Characters To LCD's CGRAM
  lcd.createChar(0, Check);
  lcd.createChar(1, DNarrow);
  lcd.createChar(2, UParrow);


  // LOGO, VERSIONE FW ECC
  lcd.clear();
  lcd.setCursor(7, 0);
  lcd.print("MBike");
  lcd.setCursor(4, 1);
  lcd.print("Hercules mk1");
  lcd.setCursor(6, 2);
  lcd.print("Fw v1.0");
  lcd.setCursor(1, 3);
  lcd.print("By L.B.engineering");
  delay(3000);
  lcd.clear();

  //------------ zona riservata al DAC ------------
  dac1.begin(0x60);              // indirizzo DAC 1
  dac2.begin(0x61);              // indirizzo DAC 2 - da mettere pin A0 a VCC
  dac1.setVoltage(2048, false);  // valvole in zona di riposo
  dac2.setVoltage(2048, false);  // valvole in zona di riposo
}

void loop() {
  //Serial.println(bt);
  if (millis() - tdb > debD) {
    bt = !digitalRead(encoderPinS);  // leggo valore di button per rilevare click con encoder
    tdb = millis();
  }

  if ((millis() - t1) > 300) {  // ritardo per evitare scorrimenti troppo veloci
    if (pos > 0) DN = 1;        // CW
    else if (pos < 0) UP = 1;   // CCW
    pos = 0;
    t1 = millis();
  }
  if (bt && !pvbt) {
    CLIC = 1;
  }
  switch (stato) {
    case 0:  // pagina iniziale
      home();
      break;
    case 1:  // prova 1 con dati prova
      prova1();
      break;
    case 2:
      prova2();
      break;
    case 3:
      prova3();
      break;
    case 4:
      prova4();
      break;
    case 5:
      prova5();
      break;
    case 6:
      prova6();
      break;
    case 7:  // back to pagina iniziale
      back2home();
      break;
    case 9:  // pagina informativa di fine prova
      provaterminata();
      break;
    case 10:  // timer inizio prova ed esecuzione prova
      espr1();
      break;
    case 20:
      espr2();
      break;
    case 30:
      espr3();
      break;
    case 40:
      espr4();
      break;
    case 50:
      par15();
      break;
    case 51:
      par25();
      break;
    case 60:
      par16();
      break;
    case 61:
      par26();
      break;
    case 500:
      avvio5();
      break;
    case 501:
      back5();
      break;
    case 600:
      avvio6();
      break;
    case 601:
      back6();
      break;
    case 5000:
      espr5();
      break;
    case 6000:
      espr6();
      break;
    case 123:  // STOP prova interrotta
      pause();
      break;
  }
  pvbt = bt;
  CLIC = 0;
  UP = 0;
  DN = 0;
}

void go(int st) {  // funzione che mi permette il cambio di stato
  Serial.print("go - bt, pvbt, CLIC ");
  Serial.print(bt);
  Serial.print(pvbt);
  Serial.println(CLIC);
  FIRST = true;
  fl = false;
  flc = false;
  tdb = millis();
  stato = st;
  lcd.clear();
  delay(100);
}

void home() {  // case 0
  if (FIRST) {
    // pensare alla homepage
    lcd.setCursor(4, 0);
    lcd.print("Hercules mk1");
    lcd.setCursor(7, 1);
    lcd.print("Ready");
    //lcd.setCursor(0, 2);
    //lcd.print("");
    lcd.setCursor(3, 3);
    lcd.write(0);
    lcd.print("for test list");
    FIRST = false;
  }
  if (CLIC) go(1);  // passa alla lista delle prove solo con il click e non con movimento encoder
  //if (DN) go(2);
  //if (UP) go(1);
}

void prova1() {  // case 1
  if (FIRST) {
    // pensare alle indicazioni prova 1
    lcd.setCursor(0, 0);
    lcd.print("1.Test fatica pedali");
    lcd.setCursor(0, 1);
    lcd.print("Fase1: 120k-1000N");
    lcd.setCursor(0, 2);
    lcd.print("Fase2: 100k-1100N");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Start");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("Next");
    lcd.setCursor(15, 3);
    lcd.write(2);
    lcd.print("Home");
    FIRST = false;
  }
  if (CLIC) go(10);
  if (DN) go(2);
  if (UP) go(7);
}

void prova2() {  // case 2
  if (FIRST) {
    // pensare alle indicazioni prova 2
    lcd.setCursor(0, 0);
    lcd.print("2.Test fatica orizz.");
    lcd.setCursor(0, 1);
    lcd.print("Fase1: 120k-450N");
    lcd.setCursor(0, 2);
    lcd.print("Fase2: 100k-500N");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Start");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("Next");
    lcd.setCursor(15, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(20);
  if (DN) go(3);
  if (UP) go(1);
}

void prova3() {  // case 3
  if (FIRST) {
    // pensare alle indicazioni prova 3
    lcd.setCursor(0, 0);
    lcd.print("3.Test fatica vert.");
    lcd.setCursor(0, 1);
    lcd.print("Fase1: 60k-1000N");
    lcd.setCursor(0, 2);
    lcd.print("Fase2: 50k-1100N");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Start");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("Next");
    lcd.setCursor(15, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(30);
  if (DN) go(4);
  if (UP) go(2);
}

void prova4() {  // case 4
  if (FIRST) {
    // pensare alle indicazioni prova 4
    lcd.setCursor(0, 0);
    lcd.print("4.Test impatto");
    lcd.setCursor(0, 1);
    lcd.print("Vel: 15mm/min");
    lcd.setCursor(0, 2);
    lcd.print("Forza: 1000N");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Start");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("Next");
    lcd.setCursor(15, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(40);
  if (DN) go(5);
  if (UP) go(3);
}

void prova5() {  // case 5
  if (FIRST) {
    // pensare alle indicazioni prova 5
    lcd.setCursor(0, 0);
    lcd.print("5.Test custom 1");
    lcd.setCursor(0, 1);
    lcd.print("");
    lcd.setCursor(0, 2);
    lcd.print("");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Enter");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("Next");
    lcd.setCursor(15, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(50);
  if (DN) go(6);
  if (UP) go(4);
}

void prova6() {  // case 6
  if (FIRST) {
    // pensare alle indicazioni prova 6
    lcd.setCursor(0, 0);
    lcd.print("6.Test custom 2");
    lcd.setCursor(0, 1);
    lcd.print("");
    lcd.setCursor(0, 2);
    lcd.print("");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Enter");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("Next");
    lcd.setCursor(15, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(60);
  if (DN) go(7);
  if (UP) go(5);
}

void back2home() {  // case 7
  if (FIRST) {
    // pensare a cosa scrivere per tornare alla home
    lcd.setCursor(5, 1);
    lcd.print("Back home?");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Yes");
    lcd.setCursor(7, 3);
    lcd.write(1);
    lcd.print("Next");
    lcd.setCursor(15, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(0);
  if (DN) go(1);
  if (UP) go(6);
}

void espr1() {  // case 10 - TEST FATICA PEDALI - segnale onda quadra
  T = 1;
  lcd.setCursor(0, 0);
  lcd.print("Test fatica pedali");
  lcd.setCursor(0, 1);
  lcd.print("Inizio parte1 tra:");
  lcd.setCursor(8, 2);
  lcd.print("secondi");
  lcd.setCursor(0, 3);
  lcd.write(0);
  lcd.print("STOP");
  for (t = w; t >= 0; t--) {  // timer della durata di "w" secondi con indicazione a schermo
    lcd.setCursor(5, 2);
    lcd.print("  ");
    lcd.setCursor(5, 2);
    lcd.print(t);
    t0 = millis();  //Delay non bloccante
    diff = millis() - t0;
    while (diff < 1000) {
      if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {
        flc = true;
        tdb = millis();
        break;
      }
      diff = millis() - t0;
    }
    if (flc) break;
  }
  if (!flc) {
    lcd.setCursor(0, 1);
    lcd.print("                    ");  // cancellazione 2 riga
    lcd.setCursor(0, 1);
    lcd.print("Parte1");
    lcd.setCursor(0, 2);
    lcd.print("                    ");  // cancellazione 3 riga
    lcd.setCursor(0, 2);
    lcd.print("Ciclo: ");
    lcd.setCursor(13, 2);
    lcd.print("/");
    lcd.print(nc1);
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("STOP");
    pc = 1;
    // PUNTO DI PARTENZA PISTONI IMPOSTATO DAL MONTATORE DEL TELAIO SULLA CELLA - leggo posizione con sensore di posizione
    // LETTURA SENSORE DI POSIZIONE (DA IMPLEMENTARE)
    for (i = 1; i <= nc1; i++) {                                     // ciclo principale prova
      if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {  // verifica sulla pressione del tasto centrale per interruzione prova -- DA SOSTITUIRE UN DOMANI CON FUNGHETTO ROSSO
        fl = true;
        tdb = millis();
        break;
      }
      lcd.setCursor(6, 2);  // cancellazione parziale per riscrivere valore ciclo
      lcd.print("       ");
      lcd.setCursor(7, 2);
      lcd.print(i);
      // segnale da 0 a 4095 ma noi abbiamo opamp con guadagno 2 in uscita quindi 2.5V (2048) sono 5V su valvole
      dac1.setVoltage(4095, false);  // pistone 1 estrae
      dac2.setVoltage(0, false);     // pistone 2 ritrae
      //delay(100); // sostituire delay con feedback su delta spazio di uscita/ingresso pistoni e forza - PROBABILMENTE USARE CILO WHILE
      dac1.setVoltage(2048, false);  // pistoni fermi
      dac2.setVoltage(2048, false);
      t0 = millis();  //Delay non bloccante
      diff = millis() - t0;
      while (diff < dT1P1) {  // pistoni fermi per 500ms
        if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {
          fl = true;
          tdb = millis();
          break;
        }
        diff = millis() - t0;
      }
      if (fl) break;
      // inversione di marcia
      dac1.setVoltage(0, false);     // pistone 1 ritrae
      dac2.setVoltage(4095, false);  // pistone 2 estrae
      //delay(100); // sostituire delay con feedback su delta spazio di uscita/ingresso pistoni e forza - PROBABILMENTE USARE CILO WHILE
      dac1.setVoltage(2048, false);  // pistoni fermi
      dac2.setVoltage(2048, false);
      t0 = millis();  //Delay non bloccante
      diff = millis() - t0;
      while (diff < dT1P1) {  // pistoni fermi per simulare pedalata
        if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {
          fl = true;
          tdb = millis();
          break;
        }
        diff = millis() - t0;
      }
      if (fl) break;
    }
    // RIPORTA I PISTONI IN MODO DA AVERE PEDALI IN POSIZIONE SCARICA/DI RIPOSO - impostare movimento in base al valore letto prima dell'inizio della parte 1
    if (!fl) {  // se non e' stata interrotta la parte 1, prosegui con la 2, altrimenti salta
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print("T1 P1 terminata!");
      lcd.setCursor(3, 1);
      lcd.print("Cicli: ");
      lcd.print(i - 1);
      lcd.setCursor(2, 2);
      lcd.print("Avviare parte2?");
      lcd.setCursor(0, 3);
      lcd.write(0);
      lcd.print("Start");
      while ((digitalRead(encoderPinS)) || ((millis() - tdb) < debD)) {
        ;
      }
      tdb = millis();
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Test fatica pedali");
      lcd.setCursor(0, 1);
      lcd.print("Inizio parte2 tra:");
      lcd.setCursor(8, 2);
      lcd.print("secondi");
      lcd.setCursor(0, 3);
      lcd.write(0);
      lcd.print("STOP");
      pc = 2;
      for (t = w; t >= 0; t--) {  // timer della durata di "w" secondi con indicazione a schermo
        lcd.setCursor(5, 2);
        lcd.print("  ");
        lcd.setCursor(5, 2);
        lcd.print(t);
        t0 = millis();  //Delay non bloccante
        diff = millis() - t0;
        while (diff < 1000) {
          if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {
            flc = 1;
            tdb = millis();
            break;
          }
          diff = millis() - t0;
        }
        if (flc) break;
      }
      if (!flc) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Test fatica pedali");
        lcd.setCursor(0, 1);
        lcd.print("Parte2");
        lcd.setCursor(0, 2);
        lcd.print("Ciclo: ");
        lcd.setCursor(13, 2);
        lcd.print("/");
        lcd.print(nc2);
        lcd.setCursor(0, 3);
        lcd.write(0);
        lcd.print("STOP");
        for (i = 1; i <= nc2; i++) {
          if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {  // verifica sulla pressione del tasto centrale per interruzione prova -- DA SOSTITUIRE UN DOMANI CON FUNGHETTO ROSSO
            fl = true;
            tdb = millis();
            break;
          }
          lcd.setCursor(6, 2);  // cancellazione parziale per riscrivere valore ciclo
          lcd.print("       ");
          lcd.setCursor(7, 2);
          lcd.print(i);
          // segnale da 0 a 4095 ma noi abbiamo opamp con guadagno 2 in uscita quindi 2.5V (2048) sono 5V su valvole
          dac1.setVoltage(4095, false);  // pistone 1 estrae
          dac2.setVoltage(0, false);     // pistone 2 ritrae
          //delay(100); // feedback su delta spazio di uscita/ingresso pistoni da fare non con delay ma con sensore forza
          dac1.setVoltage(2048, false);  // pistoni fermi
          dac2.setVoltage(2048, false);
          t0 = millis();  //Delay non bloccante
          diff = millis() - t0;
          while (diff < dT1P2) {  // pistoni fermi per 500ms
            if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {
              fl = true;
              tdb = millis();
              break;
            }
            diff = millis() - t0;
          }
          if (fl) break;
          // inversione di marcia
          dac1.setVoltage(0, false);     // pistone 1 ritrae
          dac2.setVoltage(4095, false);  // pistone 2 estrae
          //delay(100); // feedback su delta spazio di uscita/ingresso pistoni da fare non con delay ma con sensore forza
          dac1.setVoltage(2048, false);  // pistoni fermi
          dac2.setVoltage(2048, false);
          t0 = millis();  //Delay non bloccante
          diff = millis() - t0;
          while (diff < dT1P2) {  // pistoni fermi per 500ms
            if (!digitalRead(encoderPinS) && ((millis() - tdb) > debD)) {
              fl = true;
              tdb = millis();
              break;
            }
            diff = millis() - t0;
          }
          if (fl) break;
        }
        // RIPORTA I PISTONI IN MODO DA AVERE PEDALI IN POSIZIONE SCARICA/DI RIPOSO - impostare movimento in base al valore letto prima dell'inizio della parte 1 o 2
        if (fl) go(123);  // se prova interrotta allora vai a pagina interruzione
        else go(9);       // altrimenti vai a pagina fine prova
      } else if (flc) go(1);
    } else if (fl) go(123);
    else go(9);
  } else if (flc) go(1);
}

void espr2() {  // case 20 - TEST FATICA ORIZZONTALE - segnale triangolare con ampiezza incrementale nei primi cicli
  if (FIRST) {
    // timer 10s con indicazione a schermo
    FIRST = false;
  }
  while (i < nc1) {
    // esecuzione ciclo prova2 parte 1
    i++;
  }
  i = 0;
  while (i < nc2) {
    // esecuzione ciclo prova2 parte 2
    i++;
  }
  i = 0;
  go(9);
}

void espr3() {  // case 30 - TEST FATICA VERTICALE - segnale triangolare con ampiezza incrementale nei primi cicli
  if (FIRST) {
    // timer 10s con indicazione a schermo
    FIRST = false;
  }
  while (i < nc31) {
    // esecuzione ciclo prova3 parte 1
    i++;
  }
  i = 0;
  while (i < nc32) {
    // esecuzione ciclo prova3 parte 2
    i++;
  }
  i = 0;
  go(9);
}

void espr4() {  // case 40 - TEST IMPATTO - analizzare dati per capire come implementarlo
  if (FIRST) {
    // timer 10s con indicazione a schermo
    FIRST = false;
  }
  while (i < nc1) {
    // esecuzione ciclo prova4 parte 1
    i++;
  }
  i = 0;
  while (i < nc2) {
    // esecuzione ciclo prova4 parte 2
    i++;
  }
  i = 0;
  go(9);
}

void par15() {  // case 50
  if (FIRST) {
    // impostazione numero cicli prova 5
    lcd.setCursor(5, 0);
    lcd.print("Parametri");
    lcd.setCursor(4, 1);
    lcd.print("Numero cicli");
    lcd.setCursor(7, 2);
    lcd.print(udcp1);  // modificabile
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Set");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("+10");
    lcd.setCursor(16, 3);
    lcd.write(2);
    lcd.print("-10");
    FIRST = false;
  }
  if (CLIC) go(51);  // click per parametro successivo
  if (UP) {          // diminuzione parametro
    udcp1 = udcp1 - 10;
    lcd.setCursor(6, 2);
    lcd.print("        ");
    lcd.setCursor(7, 2);
    lcd.print(udcp1);
    delay(100);
  }
  if (DN) {  // aumento parametro
    udcp1 = udcp1 + 10;
    lcd.setCursor(6, 2);
    lcd.print("        ");
    lcd.setCursor(7, 2);
    lcd.print(udcp1);
    delay(100);
  }
}

void par25() {  // case 51
  if (FIRST) {
    // impostazione forza prova 5
    lcd.setCursor(5, 0);
    lcd.print("Parametri");
    lcd.setCursor(5, 1);
    lcd.print("Forza (N)");
    lcd.setCursor(8, 2);
    lcd.print(udfp1);  // modificabile
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Set");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("+10");
    lcd.setCursor(16, 3);
    lcd.write(2);
    lcd.print("-10");
    FIRST = false;
  }
  if (CLIC) go(500);  // click per parametro successivo
  if (UP) {           // diminuzione parametro
    udfp1 = udfp1 - 10;
    lcd.setCursor(7, 2);
    lcd.print("       ");
    lcd.setCursor(8, 2);
    lcd.print(udfp1);
    delay(100);
  }
  if (DN) {  // aumento parametro
    udfp1 = udfp1 + 10;
    lcd.setCursor(7, 2);
    lcd.print("       ");
    lcd.setCursor(8, 2);
    lcd.print(udfp1);
    delay(100);
  }
}

void par16() {  // case 60
  if (FIRST) {
    // impostazione parametri
    lcd.setCursor(5, 0);
    lcd.print("Parametri");
    lcd.setCursor(4, 1);
    lcd.print("Numero cicli");
    lcd.setCursor(7, 2);
    lcd.print(udcp2);  // modificabile
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Set");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("+10");
    lcd.setCursor(16, 3);
    lcd.write(2);
    lcd.print("-10");
    FIRST = false;
  }
  if (CLIC) go(61);  // click per parametro successivo
  if (UP) {
    udcp2 = udcp2 - 10;
    lcd.setCursor(6, 2);
    lcd.print("        ");
    lcd.setCursor(7, 2);
    lcd.print(udcp2);
    delay(100);
  }
  if (DN) {
    udcp2 = udcp2 + 10;
    lcd.setCursor(6, 2);
    lcd.print("        ");
    lcd.setCursor(7, 2);
    lcd.print(udcp2);
    delay(100);
  }
}

void par26() {  // case 61
  if (FIRST) {
    // impostazione parametri
    lcd.setCursor(5, 0);
    lcd.print("Parametri");
    lcd.setCursor(5, 1);
    lcd.print("Forza (N)");
    lcd.setCursor(8, 2);
    lcd.print(udfp2);  // modificabile
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Set");
    lcd.setCursor(8, 3);
    lcd.write(1);
    lcd.print("+10");
    lcd.setCursor(16, 3);
    lcd.write(2);
    lcd.print("-10");
    FIRST = false;
  }
  if (CLIC) go(600);  // click per parametro successivo
  if (UP) {
    udfp2 = udfp2 - 10;
    lcd.setCursor(7, 2);
    lcd.print("       ");
    lcd.setCursor(8, 2);
    lcd.print(udfp2);
    delay(100);
  }
  if (DN) {
    udfp2 = udfp2 + 10;
    lcd.setCursor(7, 2);
    lcd.print("       ");
    lcd.setCursor(8, 2);
    lcd.print(udfp2);
    delay(100);
  }
}

void avvio5() {  // case 500
  if (FIRST) {
    // pagina avvio prova 5
    lcd.setCursor(3, 1);
    lcd.print("Avviare prova?");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Yes");
    lcd.setCursor(7, 3);
    lcd.write(1);
    lcd.print("Next");
    //lcd.setCursor(15, 3);
    //lcd.write(2);
    //lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(5000);
  if (DN) go(501);
  //if (UP) go(6);
}

void back5() {  // case 501
  if (FIRST) {
    // pagina di ritorno alla lista prove
    lcd.setCursor(3, 1);
    lcd.print("Back to list?");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Yes");
    //lcd.setCursor(7, 3);
    //lcd.write(1);
    //lcd.print("Start");
    lcd.setCursor(14, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(5);
  //if (DN) go(600);
  if (UP) go(500);
}

void avvio6() {  // case 600
  if (FIRST) {
    // pagina avvio prova 6
    lcd.setCursor(3, 1);
    lcd.print("Avviare prova?");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Yes");
    lcd.setCursor(7, 3);
    lcd.write(1);
    lcd.print("Next");
    //lcd.setCursor(15, 3);
    //lcd.write(2);
    //lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(6000);
  if (DN) go(601);
  //if (UP) go(6);
}

void back6() {  // case 601
  if (FIRST) {
    // pagina di ritorno alla lista prove
    lcd.setCursor(3, 1);
    lcd.print("Back to list?");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Yes");
    //lcd.setCursor(7, 3);
    //lcd.write(1);
    //lcd.print("Start");
    lcd.setCursor(14, 3);
    lcd.write(2);
    lcd.print("Prev");
    FIRST = false;
  }
  if (CLIC) go(6);
  //if (DN) go(600);
  if (UP) go(600);
}

void espr5() {  // case 5000
  if (FIRST) {
    // timer 10s con indicazione a schermo
    FIRST = false;
  }
  while (i < nc1) {
    // esecuzione ciclo prova2 parte 1
    i++;
  }
  i = 0;
  while (i < nc2) {
    // esecuzione ciclo prova2 parte 2
    i++;
  }
  i = 0;
  go(9);
}

void espr6() {  // case 6000
  if (FIRST) {
    // timer 10s con indicazione a schermo
    FIRST = false;
  }
  while (i < nc1) {
    // esecuzione ciclo prova2 parte 1
    i++;
  }
  i = 0;
  while (i < nc2) {
    // esecuzione ciclo prova2 parte 2
    i++;
  }
  i = 0;
  go(9);
}

void provaterminata() {  // case 9
  if (FIRST) {
    // pagina di fine prova terminata con successo
    lcd.setCursor(2, 0);
    lcd.print("T");
    lcd.print(T);
    lcd.print(" P");
    lcd.print(pc);
    lcd.print(" terminata!");
    lcd.setCursor(3, 1);
    lcd.print("Cicli: ");
    lcd.print(i - 1);
    //lcd.setCursor(0, 2);
    //lcd.print("");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Home");
    FIRST = false;
  }
  if (CLIC) go(0);  // con il click si torna alla home
}

void pause() {  // case 123
  if (FIRST) {
    // pagina di fine prova terminata per interruzione con indicazione cicli eseguiti -- AGGIUNGERE SPEGNIMENTO DISPOSITIVI CELLA TEST
    lcd.setCursor(1, 0);
    lcd.print("PROVA ");
    lcd.print(pc);
    lcd.print(" INTERROTTA");
    lcd.setCursor(3, 1);
    lcd.print("Cicli: ");
    lcd.print(i - 1);
    //lcd.setCursor(0, 2);
    //lcd.print("");
    lcd.setCursor(0, 3);
    lcd.write(0);
    lcd.print("Home");
    //lcd.setCursor(7, 3);
    //lcd.write(1);
    //lcd.print("No");
    //lcd.setCursor(14, 3);
    //lcd.write(2);
    //lcd.print("No");
    fl = false;
    FIRST = false;
  }
  if (CLIC) go(0);  // click per tornare alla home
}

void doEncoderA() {  // funzione per rilevare movimento encoder
  // look for a low-to-high on channel A
  if (digitalRead(encoderPinA) == HIGH) {
    // check channel B to see which way encoder is turning
    if (digitalRead(encoderPinB) == LOW) {
      pos = 1;  // CW
    } else {
      pos = -1;  // CCW
    }
  } else {                                   // look for a high-to-low on channel A
    if (digitalRead(encoderPinB) == HIGH) {  // check channel B to see which way encoder is turning
      pos = 1;                               // CW
    } else {
      pos = -1;  // CCW
    }
  }
}

void doEncoderB() {  // funzione per rilevare movimento encoder
  // look for a low-to-high on channel B
  if (digitalRead(encoderPinB) == HIGH) {
    // check channel A to see which way encoder is turning
    if (digitalRead(encoderPinA) == HIGH) {
      pos = 1;  // CW
    } else {
      pos = -1;  // CCW
    }
  } else {  // Look for a high-to-low on channel B
    // check channel B to see which way encoder is turning
    if (digitalRead(encoderPinA) == LOW) {
      pos = 1;  // CW
    } else {
      pos = -1;  // CCW
    }
  }
}

void ADCWrite(int address, int value) {

  // take the SS pin low to select the chip:
  digitalWrite(chipSelectPin, LOW);
  delay(20);

  //  send in the address and value via SPI:
  SPI.transfer(address);
  SPI.transfer(value);
  delay(20);

  // take the SS pin high to de-select the chip:
  digitalWrite(chipSelectPin, HIGH);
}