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 ad Impulso ritardato.

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

     
       unsigned long iMillis = 0;

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

      int valoreTastoSET = digitalRead(SET);
          if ( valoreTastoSET == HIGH)
             { acceso = HIGH;
               acceso1 = HIGH;
               iMillis = millis(); 
               digitalWrite(LED, LOW);}
         
          if ( acceso == HIGH && (millis()-iMillis)> RitardoON)
             { digitalWrite(LED, HIGH);
               acceso = LOW;  }
      
          if ( acceso1 == HIGH && (millis()-iMillis)> RitardoOFF)
             { 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);}}
        }
     

Pausa

Non ho capito bene il perchè ma questo è lo sketch corretto che sostituisce la funzione delay.

      unsigned long iMillis1 = 0;
      byte acceso1 = LOW;
      int TempoON           =  3000;
      
      void setup() 
          { pinMode(13, OUTPUT);      
            pinMode(2, INPUT);  }
      
      void loop() {
       
        if ( digitalRead(2) == HIGH && acceso1 == LOW) 
           { digitalWrite(13, HIGH);
             acceso1 = HIGH;
             iMillis1 = millis(); }
      
        if (acceso1 == HIGH && (millis()-iMillis1)> TempoON)
        { digitalWrite(13, LOW);
          acceso1 = LOW; }
      
      }

ARDUINO ridotto all'essenziale.

Programmate un chip ATMEGA328 fornito di bootlader con una scheda Arduino.
Rimuovete dallo zoccolo di Arduino ed inseritolo nello zoccolo saldato su una piastra millefori.
Aggiunete i due condensatori ed il quarzo.

Sulla stessa base millefori costruite uno o più stadi di uscita a relè.

Ed uno o più stadi di ingresso.Attenzione che lo stato è invertito: quando il diodo led riceve corrente il pin di ingresso di Arduino è LOW.
Un'ingresso analogico sul fotoaccoppiatore non va bene perchè 1,5V servono al diodo per cui la tensione in ingresso su Arduino andrebbe da circa 2V.

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

Maffucci.

La maggiore fonte dei miei sketch.Da visitare.

http://www.maffucci.it/2011/06/29/personalizzazione-dellide-arduino/

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

Scrivere su questo BLOG.

IMPORTANTE.

Nota: Non sono un programmatore il che implica l'eventuale presenza di errori nello sketch ed una certa ed inutile pesantezza dei programmi.

Le parentesi graffe sono posizionate secondo un mio personalissimo criterio.

In alcuni sketch ho fatto un uso improprio dell' istruzione delay()

Questo è un blog, metto qui i miei appunti perchè sul pc me li perdo, prendete a piene mani ma con cautela.

Non tutti gli sketch sono stati provati e quelli che lo sono stati non è detto che siano stati provati bene!

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


 }