[code]
/*
 * timbratrice: vers. 4.0
 * movimenti carrello avanti e indietro
 * movimenti timbro alto e basso
 * comandati da elettrovalvole collegate a modulo relé
 * data: 18/05/2018
 *
 *---------------------------------------------------------------------
 * NOTA:
 * =====
 * i moduli relè (reperibili su amazon o altrisiti)
 * normalmente attivano l'uscita quando il pin di controllo va a massa
 *---------------------------------------------------------------------
 * finecorsa avanti, indietro
 *
 * NOTA:
 * =====
 * finecorsa di tipo microswitch con contatto che chiude a massa
 *----------------------------------------------------------------------
 * selettore a due posizioni timbro singolo/ripetuto
 *
 * NOTA:
 * =====
 * selettore posizione 1 scollegato! (=+5V)         = timbro singolo
 * selettore posizione 2 chiude il contatto a massa = timbro ripetuto
 *---------------------------------------------------------------------
 * pulsanti avvio e stop
 *
 * NOTA:
 * =====
 * pulsanti chiudono a massa
 *---------------------------------------------------------------------
 * 4 potenziometri da 10K collegati tra +5V e gnd di arduino
 * con centrale su A0, A1, A2 e A3 per variare tempi nelle varie fasi
 *---------------------------------------------------------------------
 * Aggiunta 18/5/2018
 * selettore a due posizioni partenza timbratrice
 *
 * NOTA:
 * =====
 * selettore posizione 1 scollegato!  (=+5V)        = partenza avanti
 * selettore posizione 2 chiude il contatto a massa = partenza indietro
 * aggiunte funzioni:
 * qualeStart()      seleziona il ciclo da eseguire per la timbratura
 *                   e predispone la macchina nel modo corretto
 * eseguiTimbroDue() esegue la timbratura con partenza indietro alto
 * ---------------------------------------------------------------------
 * NOTA2:
 * ======
 * se il modulo relè attiva l'uscita con ingresso alto bisogna
 * cambiare releAttivato da LOW ad HIGH e
 * cambiare releDisattivato da HIGH a LOW
 *
 */

//___________________________________________________________//
// *************  logica funzionamento relé  ****************//
//-----------------------------------------------------------//
// a seconda dell'uscita relé bassa o alta
// commentare le righe appropriate

//tipo1 standard pin basso (0V)= uscita attivata
const byte releAttivato = LOW;
const byte releDisattivato = HIGH;

//tipo2 pin Alto (5V) = uscita attivata
//const byte releAttivato = HIGH;
//const byte releDisattivato = LOW;
//___________________________________________________________//
// ***********  fine logica funzionamento relé  *************//
//-----------------------------------------------------------//

//___________________________________________________________//
// **********  collegamenti fisici con Arduino  *************//
//-----------------------------------------------------------//
// collegamenti pin arduino con contatti relé
const byte releIndietro = 3;
const byte releBasso = 4;

// collegamenti pin arduino con contatti finecorsa
const byte fcAvanti = 6;
const byte fcIndietro = 7;

const byte potBassoIndietro = A0;
const byte potBassoAvanti = A1;
const byte potAltoAvanti = A2;
const byte potAltoIndietro = A3;


//collegamento pin arduino con selettore a due posizioni timbro singolo/multiplo
const byte timbroSingolo = 10;

//collegamento pin Arduino con selettore a due posizioni partenza avanti/indietro
const byte StartAvantiIndietro = 9;

// collegamento pin arduino pulsanti marcia e arresto
const byte pulMarcia = 11;
const byte pulStop = 2;
//_________________________________________________________//
// ******** fine collegamenti fisici con Arduino **********//
//---------------------------------------------------------//

//_________________________________________________________//
// ************ variabili usate dal programma *************//
//---------------------------------------------------------//
int pausa = 1000;                   // pausa per commutazioni relè alto/basso 1 secondo
byte numTimbri = 0;                 // se = 1 timbro singolo se = 2 multipla
byte startAvanti = 0;               // se 1 posizione start avanti se 2 posizione start indietro
bool startPremuto = false;          // flag pressione pulsante marcia
bool startCiclo = false;            // flag partenza timbratura
volatile bool fermaCiclo = false;   // flag di controllo stop premuto

int tempoPotBI, tempoPotBA, tempoPotAI, tempoPotAA;

void setup() {
   Serial.begin(9600);


   //   pinMode(fcBasso, INPUT_PULLUP);
   //   pinMode(fcAlto, INPUT_PULLUP);
   pinMode(fcAvanti, INPUT_PULLUP);
   pinMode(fcIndietro, INPUT_PULLUP);
   pinMode(pulMarcia, INPUT_PULLUP);
   pinMode(pulStop, INPUT_PULLUP);
   pinMode(timbroSingolo, INPUT_PULLUP);
   pinMode(StartAvantiIndietro, INPUT_PULLUP);

   pinMode(releIndietro, OUTPUT);
   pinMode(releBasso, OUTPUT);
   // predispongo le condizioni iniziali
   // timbratrice indieto e timbro in alto
   digitalWrite(releBasso, releDisattivato);
   digitalWrite(releIndietro, releDisattivato);
   attachInterrupt(digitalPinToInterrupt(pulStop), stopCiclo, FALLING);
   // assegno il valore corrente dei potenziometri alle variabili
   tempoPotBI = map(analogRead(potBassoIndietro),0,1023,0,2000);
   tempoPotBA = map(analogRead(potBassoAvanti),0,1023,0,2000);
   tempoPotAI = map(analogRead(potAltoIndietro),0,1023,0,2000);
   tempoPotAA = map(analogRead(potAltoAvanti),0,1023,0,2000);
}

void loop() {
   //legge posizione iniziale per start
   qualeStart();
   //quanti timbri?
   leggiNumTimbri();
   //premuto marcia?
   leggiMarcia();
   //avvio timbratura

   //per debug
   Serial.print("numero timbrature: (1=singola 2=multipla) -> ");
   Serial.println(numTimbri);
   Serial.print("start premuto? 0=No 1=Si -> ");
   Serial.println(startPremuto);

   startTimbro();
}

void leggiNumTimbri() {
   if (digitalRead(timbroSingolo)) { // se sono in posizione 1 ho 5V
      numTimbri = 1;
   } else {                         // se sono in posizione 2 ho 0V
      numTimbri = 2;
   }
}
void leggiMarcia() {
   if (!digitalRead(pulMarcia) && !startPremuto) {
      startCiclo = true;
      startPremuto = true;
      delay(10);
   }
}
void startTimbro() {
   // predispongo le condizioni iniziali
   // timbratrice indieto e timbro in alto

   if (startPremuto) {                 // se ho premuto lo start
      Serial.println("start premuto");
      if (numTimbri == 1) {            // se selettore è su 1 timbro
         Serial.println("timbratura singola");
         if (startAvanti = 1) {
            eseguiTimbro();               // esegue una timbratura con partenza da avanti
         } else if (startAvanti = 2) {
            eseguiTimbroDue();            // esegue timbratura con partenza da indietro
         }
         startPremuto = false;            // azzera tutto
         startCiclo = false;
         fermaCiclo = false;
         numTimbri = 0;
      } else {
         Serial.println("ciclo multiplo"); //fino a che non premo stop
         while (numTimbri == 2) {
            if (startAvanti = 1) {
               eseguiTimbro();               // esegue timbratura con partenza da avanti
            } else if (startAvanti = 2) {
               eseguiTimbroDue();            // esegue timbratura con partenza da indietro
            }
            if (fermaCiclo) {          //se è stato premuto lo stop
               Serial.println("Uscita-- stop premuto");
               startPremuto = false;
               startCiclo = false;
               fermaCiclo = false;
               numTimbri = 0;
               break;                  // azzera tutto ed esce
            }
         }
      }
   }
}

// timbratura con finecorsa
// partenza posizione alto e avanti
// ciclo indietro (tenuta), basso, alto, avanti(rilascio), basso, alto.
void eseguiTimbro() {
   //leggo ogni volta i potenziometri così ad ogni timbratura i tempi sono aggiornati
   tempoPotBI = map(analogRead(potBassoIndietro),0,1023,0,2000);
   tempoPotBA = map(analogRead(potBassoAvanti),0,1023,0,2000);
   tempoPotAI = map(analogRead(potAltoIndietro),0,1023,0,2000);
   tempoPotAA = map(analogRead(potAltoAvanti),0,1023,0,2000);

   //vado indietro
   Serial.println("Attendo fcIndietro");
   digitalWrite(releIndietro, releAttivato);    // vado indietro
   while (digitalRead(fcIndietro)) {}           // attendo finecorsa indietro e tengo indietro
   delay(pausa);

   //inchiostraggio tampone
   Serial.println("Attendo Basso");
   digitalWrite(releBasso, releAttivato);    //vado in basso
   delay(tempoPotBI);

   digitalWrite(releBasso, releDisattivato);    // risalgo
   Serial.println("Attendo Alto");
   delay(tempoPotAI);

   //posizionamento per timbratura
   Serial.println("Attendo fcAvanti");
   digitalWrite(releIndietro, releDisattivato);   //torno avanti
   while (digitalRead(fcAvanti)) {}
   delay(pausa);

   // timbratura
   Serial.println("Attendo Basso");
   digitalWrite(releBasso, releAttivato);    //vado giù
   delay(tempoPotBA);

   digitalWrite(releBasso, releDisattivato);    //risalgo
   Serial.println("Attendo Alto");
   // attendo finecorsa alto
   delay(tempoPotAA);
}

// timbratura con finecorsa
// partenza posizione alto e indietro
// ciclo basso, alto, avanti (rilascio), basso, alto, indietro.
void eseguiTimbroDue() {
   //leggo ogni volta i potenziometri così ad ogni timbratura i tempi sono aggiornati
   tempoPotBI = map(analogRead(potBassoIndietro),0,1023,0,2000);
   tempoPotBA = map(analogRead(potBassoAvanti),0,1023,0,2000);
   tempoPotAI = map(analogRead(potAltoIndietro),0,1023,0,2000);
   tempoPotAA = map(analogRead(potAltoAvanti),0,1023,0,2000);

   //inchiostraggio tampone
   Serial.println("Attendo Basso");
   digitalWrite(releBasso, releAttivato);    //vado in basso
   delay(tempoPotBI);

   digitalWrite(releBasso, releDisattivato);    // risalgo
   Serial.println("Attendo Alto");
   delay(tempoPotAI);

   //posizionamento per timbratura
   Serial.println("Attendo fcAvanti");
   digitalWrite(releIndietro, releDisattivato);   //torno avanti
   while (digitalRead(fcAvanti)) {}
   delay(pausa);

   // timbratura
   Serial.println("Attendo Basso");
   digitalWrite(releBasso, releAttivato);    //vado giù
   delay(tempoPotBA);

   digitalWrite(releBasso, releDisattivato);    //risalgo
   Serial.println("Attendo Alto");
   // attendo finecorsa alto
   delay(tempoPotAA);

   //vado indietro
   Serial.println("Attendo fcIndietro");
   digitalWrite(releIndietro, releAttivato);    // vado indietro
   while (digitalRead(fcIndietro)) {}           // attendo finecorsa indietro e tengo indietro
   delay(pausa);
}

void qualeStart() {
   if (digitalRead(StartAvantiIndietro)) { // se sono in posizione 1 ho 5V
      startAvanti = 1;
      Serial.println("Attendo fcAvanti");
      digitalWrite(releIndietro, releDisattivato);   //torno avanti
      while (digitalRead(fcAvanti)) {}
      delay(pausa);
   } else {                                // se sono in posizione 2 ho 0V
      startAvanti = 2;
      //vado indietro
      Serial.println("Attendo fcIndietro");
      digitalWrite(releIndietro, releAttivato);    // vado indietro
      while (digitalRead(fcIndietro)) {}           // attendo finecorsa indietro e tengo indietro
      delay(pausa);
   }
}

//funzione di interrupt
void stopCiclo () {
   fermaCiclo = true;
}
[/code]