Temporizzatore ad impulso.

      /*  TEMPORIZZATORE
          Alla pressione di BUTTON1
          LED1 si accende per 
          spegnersi dopo TempoON
      */
     # define BUTTON1 2
     # define LED1    8
     
       int buttonState1 = 0;
     
      unsigned long iMillis1 = 0;
      byte acceso1 = LOW;
      int TempoON           =  3000;
      
      void setup() 
          { pinMode(LED1, OUTPUT);      
            pinMode(BUTTON1, INPUT);  }
      
      void loop() {
       
        int buttonState1 = digitalRead(BUTTON1);
        if ( buttonState1 == HIGH && acceso1 == LOW) 
           { digitalWrite(LED1, HIGH);
             acceso1 = HIGH;
             iMillis1 = millis(); }
        if ( acceso1 == HIGH && (millis()-iMillis1)> TempoON)
           { digitalWrite(LED1, LOW);
             acceso1 = LOW; }
      
      }//-------------Fine LOOP-------------

Temporizzatore ritardato all'inserzione (pulsante).

      /* Il LED si accende dopo 5 sec. dalla pressione
         del pulsante e si spegne dopo 8 secondi dalla
         stessa pressione.  */
         
       # define TASTOSET       2
       # define LED            7
      
       int  ValueLED          =  0;
       int  tempoON           =  5000;
       byte acceso = LOW;
       int  tempoOFF          =  8000;
       byte acceso1 = LOW;

     
       unsigned long iMillis = 0;

       
       void setup() 
       
           { pinMode(TASTOSET, INPUT );
             pinMode(LED,      OUTPUT); }
      
       void loop() {

      int valoreTastoSET = digitalRead(TASTOSET);
          if ( valoreTastoSET == HIGH)
             { acceso = HIGH;
               acceso1 = HIGH;
               iMillis = millis(); 
               digitalWrite(LED, LOW);}
         
          if ( acceso == HIGH && (millis()-iMillis)> tempoON)
             { digitalWrite(LED, HIGH);
               acceso = LOW;  }
      
          if ( acceso1 == HIGH && (millis()-iMillis)> tempoOFF)
             { digitalWrite(LED, LOW);
               acceso1 = LOW;  }            
               
          }

Temporizzatore con ritardo all'inserzione.

       # define LED1 8
       # define SWITCH1 2
  
      int switch1State = LOW;         
  

      byte          pState1 = 0;
      unsigned long pMillis1 = 0; 
      unsigned long pausa1 =3000;

      void setup() 
           { pinMode(LED1, OUTPUT);      
             pinMode(SWITCH1, INPUT);  }
      
      void loop(){
   
        switch1State = digitalRead(SWITCH1);

        if  (switch1State == HIGH) 
            {    if ( millis() - pMillis1 > pausa1)
                { pMillis1 = millis(); 
                  pState1 = HIGH;
                  digitalWrite(LED1, pState1);}}
        }
     

Delay 2

I due led lampeggiano alla stessa frequenza con tempi di ON ed OFF uguali.
Vedi anche i post  " delay 1" e " Blink senza delay".

      /* La pausa inserita nel ciclo di BUTTON1
         non influisce sull'azione di BUTTON2 
             */
      
      const int BUTTON1 = 2;     
      const int LED1 =  12;     
      int buttonState1 = 0;       
      
      const int BUTTON2 = 3;     
      const int LED2 =  13;     
      int buttonState2 = 0;  
      
      long pMillis = 0;  
      long interval = 10000;  
      void setup()
      
           { pinMode(BUTTON1, INPUT);
             pinMode(BUTTON2, INPUT); 
             pinMode(LED1,   OUTPUT);      
             pinMode(LED2,   OUTPUT); }
      
      void loop(){
      
      buttonState1 = digitalRead(BUTTON1);
            if ( buttonState1 == HIGH)
               { unsigned long cMillis = millis();
                 if ( cMillis - pMillis > interval)
                    { pMillis = cMillis;   
                      digitalWrite( LED1, HIGH); }
               else { LED1, LOW;}}
                       
     buttonState2 = digitalRead(BUTTON2);
            if ( buttonState2 == HIGH)
               { digitalWrite(LED2, HIGH); } 
          else { digitalWrite(LED2, LOW);  }
          
       
      }

Delay 1

  /* Mentre BUTTON1
         è a livello HIGH per 10 sec. tutto il 
         LOOP è bloccato, infatti BUTTON2
         non riesce ad accendere LED2
      
      */
      
      const int BUTTON1 = 2;     
      const int LED1 =  12;     
      int buttonState1 = 0;       
      
      const int BUTTON2 = 3;     
      const int LED2 =  13;     
      int buttonState2 = 0;  
      
      long pMillis = 0;  
      long interval = 10000;  
      void setup()
      
           { pinMode(BUTTON1, INPUT);
             pinMode(BUTTON2, INPUT); 
             pinMode(LED1,   OUTPUT);      
             pinMode(LED2,   OUTPUT); }
      
      void loop(){
      
  buttonState1 = digitalRead(BUTTON1);
           if ( buttonState1 == HIGH)
               { digitalWrite(LED1, HIGH); 
                  delay (10000);           } 
          else { digitalWrite(LED1, LOW);  }
                       
  buttonState2 = digitalRead(BUTTON2);
            if ( buttonState2 == HIGH)
               { digitalWrite(LED2, HIGH); } 
          else { digitalWrite(LED2, LOW);  }
      }

Blink with delay asimmetrico.

Alla chiusura di un interruttore due led lampeggiano ciascuno con tempi propri di ON ed OFF senza l'uso dell'istruzione delay()

   
      # define BUTTON1 2
      # define BUTTON2 3
      # define LED1 6
      # define LED2 7
      
      int buttonState1 = 0;
      byte Pulse1 = 0;
      unsigned long pMillis1A = 0; 
      unsigned long Wart1A = 100;  
      unsigned long pMillis1B = 0; 
      unsigned long Wart1B = 1200; 
   
      int buttonState2 = 0;
      byte Pulse2 = 0;
      unsigned long pMillis2A = 0; 
      unsigned long Wart2A = 330;  
      unsigned long pMillis2B = 0; 
      unsigned long Wart2B = 660;      
    
    
      void setup() 
          { pinMode(BUTTON1,INPUT);
            pinMode(BUTTON2,INPUT);
            pinMode(LED1, OUTPUT);
            pinMode(LED2, OUTPUT); }
      

      void loop() {
    
      buttonState1 = digitalRead(BUTTON1);
           if ( buttonState1 == HIGH)
              { if ( millis() - pMillis1A > Wart1A)
                   { pMillis1A = millis(); 
                     Pulse1 = LOW;
                     digitalWrite(LED1, Pulse1); 
                if ( millis() - pMillis1B > Wart1B)
                    { pMillis1B = millis(); 
                      Pulse1 = HIGH;
                      digitalWrite(LED1, Pulse1);   }}}
     
      buttonState2 = digitalRead(BUTTON2);
           if ( buttonState2 == HIGH)
              { if ( millis() - pMillis2A > Wart2A)
                   { pMillis2A = millis(); 
                     Pulse2 = LOW;
                     digitalWrite(LED2, Pulse2); 
                if ( millis() - pMillis2B > Wart2B)
                    { pMillis2B = millis(); 
                      Pulse2 = HIGH;
                      digitalWrite(LED2, Pulse2);   }}}     
}

Encoder

Perchè mai debbo complicarmi la vita usando un encoder rotativo?
Se devo impostare un valore posso usare un comune potenziometro o due pulsanti UP e DOWN.
Di seguito un listato. Necessita di due resistense da 10Kohm fra + Vcc ed i pin dell'encoder.
Nello sketch non c'è, ma ci vuole perchè è pur sempre un dispositivo meccanico, l'antirimbalzo.

      #include <LiquidCrystal.h>
     
      LiquidCrystal lcd(8, 9, 10, 11, 12, 13);
      int encoderPin1 = 2;
      int encoderPin2 = 3;
      int ledPin1     = 5; 
       
      volatile int lastEncoded = 0;
      volatile long encoderValue = 0;
       
      long lastencoderValue = 0;
       
      int lastMSB = 0;
      int lastLSB = 0;
       
      void setup() 
      
           { pinMode(encoderPin1, INPUT);
             pinMode(encoderPin2, INPUT);
             pinMode(ledPin1, OUTPUT);
             digitalWrite(encoderPin1, HIGH); 
             digitalWrite(encoderPin2, HIGH); 
             analogWrite (ledPin1,LOW);
             attachInterrupt(0, updateEncoder, CHANGE);
             attachInterrupt(1, updateEncoder, CHANGE);
             lcd.begin(16, 2);
             Serial.begin (9600);                     }
       
      void loop(){
         
         //  delay(200); 
        Serial.println(encoderValue);
        lcd.setCursor(0, 0);
        lcd.print(encoderValue);

        
        if ( encoderValue > 255 ) 
           { encoderValue = 255; 
             lcd.clear();
           delay (20);       }
       
        if ( encoderValue < 0 )  
           { encoderValue = 0; 
         lcd.clear();
       delay(20);}
       
        analogWrite(ledPin1,encoderValue);
        Serial.println(encoderValue);
       
 
  }  //--------------- Fine LOOP-------------------      
        
       
       
       
       
       
       
       
       
       
       
       
      void updateEncoder(){
        int MSB = digitalRead(encoderPin1); 
        int LSB = digitalRead(encoderPin2); 
       
        int encoded = (MSB << 1) |LSB; 
        int sum  = (lastEncoded << 2) | encoded; 
       
        if(sum == 0b1101 || sum == 0b0100 || sum == 0b0010 || sum == 0b1011) encoderValue ++;
        if(sum == 0b1110 || sum == 0b0111 || sum == 0b0001 || sum == 0b1000) encoderValue --;
       
        lastEncoded = encoded; 
      }

Contapezzi

/* Impostare il valore con il potenziometro.
Quando il numero di impulsi su Pin2 è
uguale al valore impostato il relè si eccita. 
Fornito di antirimalzo. Il conteggio avanza
sulo sul fronte di salita,ovvero non avanza
se su pin2 permane in HIGH.Il valore impostato
viene diviso per 10 per avere un fondoscala
di 123.
*/
   
#include <LiquidCrystal.h>
LiquidCrystal lcd( 8, 9, 10, 11, 12, 13);

 # define IMPOSTA       A0
 # define CONTA          3
 # define RELE           5
 # define RELE1          6
 # define AZZERA         4 
 
 long ValueImposta     = 0;
 long ValueImposta1    = 0;
 
 int  ValueConta       = 0;
 int  lastValueConta   = 0;
 byte contaImpulsi     = 0;
 byte Merker           = 0; 
 
 void setup() 
     { pinMode(IMPOSTA,   INPUT ); 
       pinMode(CONTA,     INPUT );
       pinMode(RELE,     OUTPUT ); 
       pinMode(RELE1,   OUTPUT ); 
       lcd.begin(16, 2);
       Serial.begin(9600);    }

 void loop() {
       
       lcd.setCursor(0,0);
       lcd.print ("V.Impostato");
       lcd.setCursor(0,1);
       lcd.print ("V.Contato");

//-------- Imposta il n. max di pezzi ------------
       ValueImposta=analogRead(IMPOSTA);
       ValueImposta1 = (ValueImposta / 10);
       lcd.setCursor(13,0);
       lcd.print(ValueImposta1);

//---------- Leggi pezzi su Pin2 -------------------     
      ValueConta  = digitalRead(CONTA); 
      if ( ValueConta != lastValueConta) 
         { if ( ValueConta == HIGH)
              { contaImpulsi = contaImpulsi + 1; 
                lcd.setCursor(13, 1);
                lcd.print(contaImpulsi); 
                Serial.println(contaImpulsi);
                delay(20);    }}// DebounceTime
      lastValueConta = ValueConta;
 
/*---- -----CONFRONTO FRA I DUE DATI -------- 
  arrivato al valore impostato il relè si eccita
  per mezzo secondo, il conteggio si azzera per 
  poi reiniziare*/
  
      if ( ValueImposta1 == contaImpulsi)
         { digitalWrite(RELE, HIGH);
           Serial.println("RELE ON");
           Merker = HIGH;
           delay(500); 
            
           contaImpulsi = 0;
           digitalWrite(RELE, LOW);
           Merker = LOW; 
           lcd.clear();
           delay(30);          }

/*------------ Esegui un'altra azione-----------
 La variabile Merker può essere usata per eseguire
 altre azioni.  */    
 
      if ( Merker == HIGH)
         { digitalWrite(RELE1, HIGH); }


 }

CRONOMETRO HIGH/LOW

Lo sketch permette di cronometrare il tempo di ON e di OFF di un onda quadra.

   /* Cronómetro modificato, creado por 
      Javier Sirgo Blanco http://zygzax.com/webpcronometro/
      
      Ingresso al pin 2.
      Misura il tempo di ON e di OFF di un segnale ad onda quadra.
      I due tempi si azzerano al reinizio del ciclo.
  */
    
    #include <LiquidCrystal.h>                
   
    # define SET   2
   
    LiquidCrystal lcd(8, 9, 10, 11, 12, 13); 
    int m, mu=0,md=0;                          
    int s, su=0,sd=0;
    int l, lu=0,ld=0,lc=0;
    int  pin2;
    long int tempo,inizio;
         
    void setup()
        
         { pinMode(SET, INPUT);                      
           pin2=LOW;
           lcd.begin(16, 2);                      
           lcd.setCursor(0, 0); 
           lcd.print("ON");         
           lcd.setCursor(5, 0);                  
           lcd.print("00:00:000");                
           lcd.setCursor(0, 1); 
           lcd.print("OFF");         
           lcd.setCursor(5, 1);                  
           lcd.print("00:00:000");
                                }
     
    
    void loop() {
//**************** Tempo in cui il pin 2 è HIGH ********************
      pin2=digitalRead(2);                 
      if ( pin2==HIGH)
         { inizio=millis();                      
         //Cronometra e trasforma in sessagesimali il tempo di ON
           while (pin2==HIGH)
                { tempo=millis()-inizio;            
                  m=(tempo/1000)/60;                 
                  mu=m%10;                           
                  md=(m-mu)/10;                       
                  s=(tempo/1000)%60;                 
                  su=s%10;                          
                  sd=(s-su)/10;                       
                  l=(tempo%1000);                    
                  lu=l%10;                            
                  ld=((l-lu)/10)%10;                  
                  lc=(l-(ld*10)-lu)/100;              
               // Stampa sulla prima riga il tempo di ON
                  lcd.setCursor(5, 0);                
                  lcd.print(md);                      
                  lcd.print(mu);              
                  lcd.print(":");
                  lcd.print(sd);
                  lcd.print(su);
                  lcd.print(":");
                  lcd.print(lc);
                  lcd.print(ld);
                  lcd.print(lu);
                  pin2=digitalRead(SET); } } // Fine sottoprogramma tempo di HIGH
                  
 //**************** Tempo in cui il pin 2 è LOW ********************                 
      pin2=digitalRead(2);                 
      if ( pin2==LOW)
         { inizio=millis();                      
         //Cronometra e trasforma in sessagesimali il tempo di OFF
           while( pin2==LOW)
                { tempo=millis()-inizio;            
                  m=(tempo/1000)/60;                 
                  mu=m%10;                           
                  md=(m-mu)/10;                       
                  s=(tempo/1000)%60;                 
                  su=s%10;                          
                  sd=(s-su)/10;                       
                  l=(tempo%1000);                    
                  lu=l%10;                            
                  ld=((l-lu)/10)%10;                  
                  lc=(l-(ld*10)-lu)/100;              
               // Stampa sulla seconda riga il tempo di OFF
                  lcd.setCursor(5, 1);                
                  lcd.print(md);                      
                  lcd.print(mu);              
                  lcd.print(":");
                  lcd.print(sd);
                  lcd.print(su);
                  lcd.print(":");
                  lcd.print(lc);
                  lcd.print(ld);
                  lcd.print(lu);
                  pin2=digitalRead(SET); }}  // Fine sottoprogramma tempo di LOW                   
                                            
           }//----------Fine Programma