Senso di rotazione.

     /* Due fotointerruttori a forcella affiancati.
        Il fascio di luce viene interrotto da un disco rotante.
        Il senso di rotazione viene stabilito in
        funzione di quale fotodiodo viene illuminato
        per primo.
     */     
      int canaleA=6;
      int canaleB=9;
      int contatore=0;
      boolean avanti;
      boolean indietro;
      boolean memoriaA;
      boolean memoriaB;
      boolean direzione;
       
      void setup()
          { Serial.begin(9600);
            pinMode(6,INPUT);
            pinMode(9,INPUT); }
      
      void loop() {
      
      canaleA=digitalRead(6);
      canaleB=digitalRead(9);
      Serial.print(contatore);
      Serial.print("  Avanti ");
      Serial.print(avanti);
      Serial.print("  indietro ");
      Serial.println(indietro);
                
      if ( canaleB==1 && canaleA==1)
         { direzione=1;
           memoriaA=0;
           memoriaB=0;             }
  
      if ( canaleA==0 && direzione==1)
         { indietro=1;
           avanti=0;
           direzione=0;              }
    
      if ( canaleB==0 && direzione==1)
         { avanti=1;
           indietro=0;
           direzione=0;              }
              
     if ( canaleB==0 && avanti==1 && memoriaA==0)
        { contatore=contatore+1;
          memoriaA=1;                           }
   
     if ( canaleA==0 && indietro==1 && memoriaB==0)
        { contatore=contatore-1;
          memoriaB=1;                             }
       
     
    }//---------FINE LOOP--------------
       

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

Contatore UP/DOWN

Contatore generico con ingressi di UP; DOWN, AZZERA ed IMPOSTA.

      #include <LiquidCrystal.h>
      LiquidCrystal lcd( 8, 9, 10, 11, 12, 13);
      
       # define IMPOSTA       A0
       # define CONTA          2
       # define SCONTA         3
       # define AZZERA         4
       # define RELE           6
       # define RELE1          7 
       
       long ValueImposta     = 0;
       long ValueImposta1    = 0;
       long ValueAzzera      = 0;
       int  ValueConta       = 0;
       int  ValueSconta      = 0;
       int  lastValueConta   = 0;
       int  lastValueSconta  = 0;
       byte contaImpulsi     = 0;
       byte Merker           = 0; 
       
       void setup() 
           { pinMode(IMPOSTA,   INPUT ); 
             pinMode(CONTA,     INPUT );
             pinMode(SCONTA,     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");
      
        //-- Azzera il contatore pin 4----------
            ValueAzzera  = digitalRead(AZZERA); 
            if ( ValueAzzera == HIGH) 
               { contaImpulsi = 0; 
                      lcd.setCursor(13, 1);
                      lcd.print(contaImpulsi); 
                      Serial.println(contaImpulsi);
                      delay(20);    }
      
      //-Imposta con Pot.su A0 il n. max di pezzi ---
             ValueImposta=analogRead(IMPOSTA);
             ValueImposta1 = (ValueImposta / 10);
             lcd.setCursor(13,0);
             lcd.print(ValueImposta1);
      
      //---------- Incrementa con input 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;
             
      //---------- Decrementa con input su Pin3 ----     
            ValueSconta  = digitalRead(SCONTA); 
            if ( ValueSconta != lastValueSconta) 
               { if ( ValueSconta == HIGH)
                    { contaImpulsi = contaImpulsi - 1; 
                      lcd.setCursor(13, 1);
                      lcd.print(contaImpulsi); 
                      Serial.println(contaImpulsi);
                      delay(20);    }}// DebounceTime
            lastValueSconta = ValueSconta;
 
      /*---- -----CONFRONTO FRA I DUE DATI -------- 
       Se valore comntatore è uguale a valore
      impostato eccita i relè.at */
        
            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 è usata per eseguire
       altre azioni.  */    
       
            if ( Merker == HIGH)
               { digitalWrite(RELE1, HIGH); }
      
      
       }

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); }


 }

Counter due + tre

Si imposta il valore di riferimento (Valore1) con un potenziometro.
Quando Valore2 è uguale a Valore1 un relè si innesca o disinnesca.

/* Impostare il valore con il potenziometro.
Quando il numero di impulsi di TASTO2 è
uguale al valore impostato il relè si innesca. */
   
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

 # define POT1      A0
 # define TASTO2   3
 # define RELE     6
 
 long Value1     = 0;
 long Value1a    = 0;
 int  Value2     =0;
 long Tempo1     = 0;
 long Tempo11    = 50; 

 void setup() 
     { pinMode(POT1,   INPUT); 
       pinMode(TASTO2,INPUT );
       pinMode(RELE,  OUTPUT);  
       lcd.begin(16, 2);
       lcd.setCursor(0,0);
       lcd.print ("Valore1");
       lcd.setCursor(0,1);
       lcd.print ("Valore2");
       Serial.begin(9600);    }

 void loop() {
  Value1a=analogRead(POT1);
  Value1 = (Value1a / 2);
  lcd.setCursor(10,0);
  lcd.print(Value1);
  delay(50);
  lcd.print("        ");
delay(10);

  
 //********** TASTO 2  ***************** 
  int StatoTasto2;             
  int StatoTasto2a = LOW;  
  int valoreTasto2 = digitalRead(TASTO2);
//-------- antirimbalzo2-----------
  if (valoreTasto2 != StatoTasto2a)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo11)
      {StatoTasto2 = valoreTasto2;}
             StatoTasto2a = valoreTasto2;
//-------- esecuzione2 ------------  
  if (valoreTasto2 == HIGH)
       { Value2 = (Value2 + 1);
         Serial.println(Value2);
         lcd.setCursor(10,1);
         lcd.print(Value2);
         delay(50);         }
 
//---- CONFRONTO FRA I DUE DATI -------- 
  if (Value1 == Value2)
          { digitalWrite(RELE, HIGH);
            Serial.println("RELE ON");
            delay(30);          }
}

Di seguito è possibile variare il valore di rifimento da un minimo di 1023 a 1534. Per ciò basta collegare un resistore da 10K fra A1 e + Vcc.

/* Impostare il valore con il potenziometro.
Quando il numero di impulsi di TASTO2 è
uguale al valore impostato il relè si innesca.
L'impostazione di rifirmento minima è di 1023.
*/
   
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

 # define POT1    A0
 # define POT2    A1
 # define TASTO2   3
 # define RELE     6
 
 long Value1     =0;
 long Value1a    =0;
 int  Value2     =0;
 int Value2a     = 0;
 long Tempo1     =0;
 long Tempo11    =50; 

 void setup() 
     { pinMode(POT1,   INPUT); 
       pinMode(TASTO2,INPUT );
       pinMode(RELE,  OUTPUT);  
       lcd.begin(16, 2);
       lcd.setCursor(0,0);
       lcd.print ("Valore1");
       lcd.setCursor(0,1);
       lcd.print ("Valore2");
       Serial.begin(9600);    }

 void loop() {
  
  Value2a=analogRead(POT2);
  
  Value1a=analogRead(POT1);
  Value1 = ((Value1a / 2)+ Value2a);
  lcd.setCursor(10,0);
  lcd.print(Value1);
  delay(50);
  lcd.print("        ");
delay(10);

  
 //********** TASTO 2  ***************** 
  int StatoTasto2;             
  int StatoTasto2a = LOW;  
  int valoreTasto2 = digitalRead(TASTO2);
//-------- antirimbalzo2-----------
  if (valoreTasto2 != StatoTasto2a)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo11)
      {StatoTasto2 = valoreTasto2;}
             StatoTasto2a = valoreTasto2;
//-------- esecuzione2 ------------  
  if (valoreTasto2 == HIGH)
       { Value2 = (Value2 + 1);
         Serial.println(Value2);
         lcd.setCursor(10,1);
         lcd.print(Value2);
         delay(50);         }
 
//---- CONFRONTO FRA I DUE DATI -------- 
  if (Value1 == Value2)
          { digitalWrite(RELE, HIGH);
            Serial.println("RELE ON");
            delay(30);          }
}

Counter uno

Premere il pulsante fino ad impostare un valore (Valore1).
Quando il numero di giri rilevato da valore2 è uguale a valore1 un relè si eccita.

/* Impostare il valore con TASTO2.
   Quando il numero di impulsi di TASTO1 è
   uguale a TASTO2 il relè si innesca. */
   
#include <LiquidCrystal.h>
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);

 # define TASTO1   2
 # define TASTO2   3
 # define RELE     6
 int  Value1     = 1;
 int  Value2      =0;
 long Tempo1     = 0;
 long Tempo11    = 50; 

 void setup() 
     { pinMode(TASTO1,INPUT );
       pinMode(TASTO2,INPUT );
       pinMode(RELE,  OUTPUT);  
       lcd.begin(16, 2);
       lcd.setCursor(0,0);
       lcd.print ("Valore1");
       lcd.setCursor(0,1);
       lcd.print ("Valore2");
       Serial.begin(9600);    }

 void loop() {
   
   //********** TASTO 1  ***************** 
  int StatoTasto1;             
  int StatoTasto1a = LOW;  
  int valoreTasto1 = digitalRead(TASTO1);
//-------- antirimbalzo1  --------------
  if (valoreTasto1 != StatoTasto1a)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo11)
      {StatoTasto1 = valoreTasto1;}
             StatoTasto1a = valoreTasto1;
//------------esecuzione1 ------------  
  if (valoreTasto1 == HIGH)
       { Value1 = (Value1 + 1);
         Serial.println(Value1);
         lcd.setCursor(10,0);
         lcd.print(Value1);
         delay(500);         }
  
 //********** TASTO 2  ***************** 
  int StatoTasto2;             
  int StatoTasto2a = LOW;  
  int valoreTasto2 = digitalRead(TASTO2);
//-------- antirimbalzo2-----------
  if (valoreTasto2 != StatoTasto2a)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo11)
      {StatoTasto2 = valoreTasto2;}
             StatoTasto2a = valoreTasto2;
//-------- esecuzione2 ------------  
  if (valoreTasto2 == HIGH)
       { Value2 = (Value2 + 1);
         Serial.println(Value2);
         lcd.setCursor(10,1);
         lcd.print(Value2);
         delay(500);         }
 
//---- CONFRONTO FRA I DUE DATI -------- 
  if (Value1 == Value2)
          { digitalWrite(RELE, HIGH);
            Serial.println("RELE ON");
            delay(350);          }
  //else    { delay (350);  } 
}

La soluzione è improponibile per numeri alti.

Incrementa

 # define TASTOQ   7
 # define LED1     8
 # define RELE     9
 int  ValueQ     = 0;
 long Tempo1     = 0;
 long Tempo2     = 50; 
 int  ValueCombQ =20;

 void setup() 
     { pinMode(TASTOQ,INPUT );
       pinMode(LED1,  OUTPUT);
       pinMode(RELE,  OUTPUT);  
       Serial.begin(9600);    }

 void loop() {
//********** TASTO Q  ***************** 
  int StatoTastoQ;             
  int StatoTastoQa = LOW;  
  int valoreTastoQ = digitalRead(TASTOQ);
//-------- ANTIRIMBALZO-----------
  if (valoreTastoQ != StatoTastoQa)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo2)
      {StatoTastoQ = valoreTastoQ;}
             StatoTastoQa = valoreTastoQ;
             
             
//--------INIZIO ESECUZIONE ------------  

  if (valoreTastoQ == HIGH)
       {digitalWrite(LED1, HIGH);
        delay (75);
        digitalWrite(LED1, LOW);
        ValueQ = (ValueQ + 1);
        Serial.print("APRI ");  
        Serial.println(ValueQ);
        delay (350);   }
  
  if (ValueQ == ValueCombQ)
          { digitalWrite(RELE, HIGH);
            Serial.println(ValueQ);
            delay (350); }
  else    { delay (350);  } 
}

Pigiando il tasto il led si accende per una frazione di secondo ad indicare l'avvenuta pressione, il relè si ecciterà dopo aver premuto 20 volte il pulsante.