KeyInput

#include <Keypad.h>
  const byte ROWS = 4; 
  const byte COLS = 4; 
  char keys[ROWS][COLS] =
  {{'1','2','3','C'},
   {'4','5','6','D'},
   {'7','8','9','E'},
   {'A','0','B','F'}};
  byte rowPins[ROWS] = { 4, 3, 2, 1}; 
  byte colPins[COLS] = { 8, 7, 6, 5}; 
  Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

int ValoreF = 0;
int Valore1 = 123;

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

void loop() {

   char  key = keypad.getKey();

   else 
     {int number = key - 48;
      ValoreF = ValoreF * 10 + number;
      if (Valore1 < ValoreF)
         { Serial.print("OK"); }} 
  }  

Inserire un valore con Keypad, metodo teorico perchè conviene di gran lunga un encoder rotativo o un comune potenziometro.

CALCOLATRICE

dal sito di GianLuca Ciocia.

//GIANLU8CA CIOCIAhttp://ciocia.altervista.org/
#include <Keypad.h>
#include <LiquidCrystal.h>

LiquidCrystal lcd(8, 9, 10, 11, 12, 13);
const byte ROWS = 4; 
const byte COLS = 4; 
char keys[ROWS][COLS] = {
  {'1','2','3','C'},
  {'4','5','6','D'},
  {'7','8','9','E'},
  {'A','0','B','F'}
};

byte rowPins[ROWS] = { 3, 2, 1, 0}; 
byte colPins[COLS] = { 7, 6, 5, 4}; 

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
static float lvalue;
static float rvalue;
static char oper;
static byte errcode;

void setup() 
{ lcd.begin(16,2);
  lcd.print("Calcolatrice 3.0");
  lcd.setCursor(0,1);
  lcd.print("PaulettGiankard");
  errcode = 0; }

float do_calc (float num1, float num2, char a_oper) 
    {if (errcode > 0)
        {return num1; }
      
     else switch (a_oper)
          { case 0:
              return num2;
              break;
            case 'C': 
              return (num1 + num2);
              break;
            case 'D': 
              return (num1 - num2);
              break;
            case 'E': 
              return (num1 * num2);
              break;
            case 'F':
              if (num2 != 0) 
                return (num1 / num2);   
              else 
                {errcode = 1;
                return 0;}
            break;}}

void print_result(float valore)
{ lcd.clear();
  if (errcode > 0)
      lcd.print("ERRORE");
  else
      lcd.print(valore); }

void loop() {
  lvalue = 0;
  rvalue = 0;
  oper = 'C';
  for (;;) 
  {
    char  key = keypad.getKey();
    if (key == 0) {
    } 
    else
      if ((key >= 'C') && (key <= 'F')) {
        lvalue = do_calc(lvalue, rvalue, oper);
        print_result(lvalue);
        rvalue = 0;
        oper = key;
      } 
      else
        if (key == 'B') {
          lvalue = do_calc(lvalue, rvalue, oper);
          print_result(lvalue);
          rvalue = 0;
          oper = 'C';
        }
        else
          if (key == 'A') { 
            lcd.clear();
            lvalue = 0;
            rvalue = 0;
            errcode = 0;
            oper = 'C';
            print_result(rvalue);
          }
          else {
            int number = key - 48;
            //qui andrebbe un controllo per evitare che l'utente
            //inserisca un numero eccessivo di cifre...
            rvalue = rvalue * 10 + number; 
            print_result(rvalue);
          }
  }
}

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.

Serratura a combinazione

La serratura è composta da 12 pulsanti (non tastiera a matrice) normalmente aperti, un led che seganal l'avvenuta pressione del tasto ed un relè di uscita.
Si scelgono a caso tre pulsanti, ad esempio il n. 2, il n,5 ed il n.6 e si collegano rispettivamente al pin 2, 3 e 4 di Arduino.
Nello sketch che segue è previsto che per pilotare il relè si prema:
5 volte il pulsante n.2; 7 volte il pulsante n.5 e 3 volte il pulsante n.6 per concludere l'operazione premendo una volta il pulsante OK.Se si ritiene di aver sbagliato si premeil tasto CANC e si ricomincia.
I rimante pulsanti sono tutti in parallelo fra loro e l'incremento della variabile ad essi associato impedisce il pilotaggio dei relè.
Non è previsto che premendo per tre o quattro volte il tasto CANC scatti l'allarme ma è possibie inserire delle istruzioni ad hoc.

  # define TASTO1 2
  # define TASTO2  3
  # define TASTO3  4
  # define TASTOW  5
 # define TASTOK  6
 # define TASTOZ  7
 # define LED1   13
 # define RELE   8
 
 int  Value100   = 0;
 int  Value200   = 0;
 int  Value300   =0;
 int  ValueK     = 0;
 int  ValueW     = 0;
 int  ValueZ     = 0;
 long Tempo1     = 0;
 long Tempo2     = 50; 
 int  ValueComb1 = 5;
 int  ValueComb2 = 7;
 int  ValueComb3 = 3;
 int  ValueCombW = 1;
 int  ValueCombZ = 0;

 void setup() 
     { pinMode(TASTO1,INPUT );
       pinMode(TASTO2,INPUT );
       pinMode(TASTO3,INPUT );
       pinMode(TASTOW,INPUT );
       pinMode(TASTOK,INPUT );
       pinMode(TASTOZ,INPUT );
       
       pinMode(LED1,  OUTPUT);
       pinMode(RELE,  OUTPUT);  
       Serial.begin(9600);    }

 void loop() {
       
//********** TASTO K (Cancella) ***************** 
  int StatoTastoK;             
  int StatoTastoKa = LOW;  
  int valoreTastoK = digitalRead(TASTOK);
//-------- ANTIRIMBALZO-----------
  if (valoreTastoK != StatoTastoKa)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo2)
      {StatoTastoK = valoreTastoK;}
//--------INIZIO ESECUZIONE ------------      
   if (valoreTastoK == HIGH)
       {digitalWrite(LED1, HIGH);
        delay (75);
        digitalWrite(LED1, LOW);
         ValueK = (ValueK + 1);
         Value100  = 0;
         Value200  = 0;
         Value300  = 0;
         ValueW    = 0;
         ValueZ = 0;
         Serial.print("CANCELLATO");  
         Serial.println(ValueK);
         delay (350);              }
      //----------FINE ESECUZIONE--------       
         StatoTastoKa = valoreTastoK;
//********* FINE SOTTOPROGRAMMA TASTO k (CANCELLA) **************   
    
//********** TASTOZ (Civetta) ***************** 
  int StatoTastoZ;             
  int StatoTastoZa = LOW;  
  int valoreTastoZ = digitalRead(TASTOZ);
//-------- ANTIRIMBALZO-----------
  if (valoreTastoZ != StatoTastoZa)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo2)
      {StatoTastoZ = valoreTastoZ;}
//--------INIZIO ESECUZIONE ------------      
   if (valoreTastoZ == HIGH)
       {digitalWrite(LED1, HIGH);
        delay (75);
        digitalWrite(LED1, LOW);
        ValueZ = (ValueZ + 1);
        Serial.print("CIVETTA");  
        Serial.println(ValueZ);
        delay (350);              }
//--------------------FINE ESECUZIONE--------       
         StatoTastoZa = valoreTastoZ;
   
 //********** TASTO 1 ***************** 
  int StatoTasto1;             
  int StatoTasto1a = LOW;  
  int valoreTasto1 = digitalRead(TASTO1);
//-------- ANTIRIMBALZO-----------
  if (valoreTasto1 != StatoTasto1a)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo2)
      {StatoTasto1 = valoreTasto1;}
//--------INIZIO ESECUZIONE ------------      
   if (valoreTasto1 == HIGH)
       { digitalWrite(LED1, HIGH);
         delay (75);
         digitalWrite(LED1, LOW);
         Value100 = (Value100 + 1);
         Serial.print("1a cifra ");  
         Serial.println(Value100);
         delay (350);              }
//--------------------FINE ESECUZIONE--------       
         StatoTasto1a = valoreTasto1;
//********* FINE SOTTOPROGRAMMA TASTO 1 **************
  
//********** TASTO 2 ***************** 
  int StatoTasto2;             
  int StatoTasto2a = LOW;  
  int valoreTasto2 = digitalRead(TASTO2);
//-------- ANTIRIMBALZO-----------
  if (valoreTasto2 != StatoTasto2a)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo2)
      {StatoTasto2 = valoreTasto2;}
//--------INIZIO ESECUZIONE ------------      
   if (valoreTasto2 == HIGH)
       { digitalWrite(LED1, HIGH);
         delay (75);
         digitalWrite(LED1, LOW);
         Value200 = (Value200 + 1);
         Serial.print("2a cifra ");  
         Serial.println(Value200);
         delay (350);              }
      //----------FINE ESECUZIONE--------       
         StatoTasto2a = valoreTasto2;
  //********* FINE SOTTOPROGRAMMA TASTO 2 **************
   
    
//********** TASTO 3 ***************** 
  int StatoTasto3;             
  int StatoTasto3a = LOW;  
  int valoreTasto3 = digitalRead(TASTO3);
//-------- ANTIRIMBALZO-----------
  if (valoreTasto3 != StatoTasto3a)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo2)
      {StatoTasto3 = valoreTasto3;}
//--------INIZIO ESECUZIONE ------------      
   if (valoreTasto3 == HIGH)
       {digitalWrite(LED1, HIGH);
        delay (75);
        digitalWrite(LED1, LOW);
        Value300 = (Value300 + 1);
        Serial.print("3a cifra ");  
        Serial.println(Value300);
        delay (350);              }
      //----------FINE ESECUZIONE--------       
         StatoTasto3a = valoreTasto3;
  //********* FINE SOTTOPROGRAMMA TASTO 3 **************
   
     
//********** TASTO W (Apri) ***************** 
  int StatoTastoW;             
  int StatoTastoWa = LOW;  
  int valoreTastoW = digitalRead(TASTOW);
//-------- ANTIRIMBALZO-----------
  if (valoreTastoW != StatoTastoWa)
     {Tempo1 = millis();} 
  if ((millis() - Tempo1) > Tempo2)
      {StatoTastoW = valoreTastoW;}
//--------INIZIO ESECUZIONE ------------      
   if (valoreTastoW == HIGH)
       {digitalWrite(LED1, HIGH);
        delay (75);
        digitalWrite(LED1, LOW);
        ValueW = (ValueW + 1);
        Serial.print("APRI ");  
        Serial.println(ValueW);
        delay (350);              }
      //----------FINE ESECUZIONE--------       
         StatoTastoWa = valoreTastoW;
//********* FINE SOTTOPROGRAMMA TASTO W (Apri) **************   
  
//*************** SOTTOPROGRAMMA COMBINAZIONE*************
 
  if (Value100 == ValueComb1 &&  Value200 == ValueComb2 && Value300 ==
  ValueComb3 && ValueZ == ValueCombZ && ValueW == ValueCombW)
         { digitalWrite(RELE, HIGH);
          //delay (350);
          //digitalWrite(RELE, LOW);
          Serial.print("PORTA APERTA ");  
          Serial.println(ValueW);
          delay (350); }
      else  {delay (350);  } 

}