Linea dati.

Un appartamento. Un fotodiodo ricevente IR ed un telecomando in ciascuna stanza, gli Attiny posizionati presso i dispositivi elettrici da pilotare. Da ciascuna stanza il fotodiodo rileverebbe il treno di impulsi proveniente dal telecomando, identico in ogni stanza, inviandolo sulla linea dati. Ciascun ATTTINY è programmato per accettare un solo treno di impulsi ed attivare un relè. Esempio: da qualunque stanza premendo il tasto 4 si può abbassare la tapparella della cucina.
Potrebbe funzionare.

  /* Si sottopone a condizione if la lettura
       esadecimale dei tasti anteponendo al valore
       HEX il valore 0x. Nello sketch:
       Relè = OFF
       Tasto 1 premuto FF30CF = Relè ON
       Tasto 2 premuto FF18E7= Relè OFF      */
     
       #include <IRremote.h> 
       
       # define RELE 6
       
       int receiver = 7; 
      
       IRrecv irrecv(receiver); 
      
      decode_results results;
    
      void setup()
          { Serial.begin(9600); 
            irrecv.enableIRIn(); 
            pinMode(RELE, OUTPUT);
            digitalWrite(RELE,LOW); }
          
          
      void loop(){
      
         if ( irrecv.decode(&results)) 
            { Serial.println(results.value, HEX); 
              irrecv.resume();                  } 
         
         if ( results.value == 0xFF30CF)
            { digitalWrite(RELE, HIGH);    } 
            
         if ( results.value == 0xFF18E7)
            { digitalWrite(RELE, LOW);    } 
               
    }

Inseguitore solare 3

    /* VEDI LO SKETCH RIGINALE SU
       * Inseguitore solare - prima parte
       *
       * Autore: Mauro Alfieri
       * web: www.mauroalfieri.it
       * Tw: @mauroalfieri.it
       *
       */
       
      #include <Servo.h>
      
      #define FOTO     A0 
      #define MOTORE    8
     
      int sensorPin   = 0;
      int servoPin    = 0;
       
      int sensorValue = 0;
      int servoGrad   = 90;
       
      Servo myservo;
       
      void setup()
          { pinMode( FOTO, INPUT);
            myservo.attach( MOTORE );
            myservo.write( servoGrad ); }
       
      void loop() {
        
        sensorValue = analogRead(FOTO);
        
        if ( sensorValue < (512) )
           { if ( servoGrad < 180) 
                { servoGrad++;    }}
       
        if ( sensorValue > (512) )
           { if ( servoGrad > 0) 
                { servoGrad--;    }}
       
        myservo.write( servoGrad );
       
        delay(100);
      }

Inseguitore solare 2

 
      # define MOTORE    8
      # define FOTOuno  A0
      # define FOTOdue  A1
     
      #include <Servo.h>

        
      Servo myservo;
      int Value        = 0;
      int Centrato     =90;
      int sensorValue1 = 0;
      int sensorValue2 = 0;  
    
      void setup() 
          { pinMode (MOTORE, OUTPUT);
            pinMode (FOTOuno, INPUT);
            pinMode (FOTOdue, INPUT);
            myservo.attach(MOTORE); 
            Serial.begin(9600); }
       
      void loop() {
     
        int sensorValue = analogRead(FOTOuno);   
        int sensorValue2 = analogRead(FOTOdue);  
         
        Value=(sensorValue-sensorValue2)/10; 
   
          if   (Value==0) myservo.detach();//scollega MOTORE
          else myservo.attach(MOTORE);
            
          if ( Value>10 )
             { Value=10;}
         
          if ( Value<-10 )
             { Value=-10;}
        Serial.println(Value);  
        myservo.write(Centrato+Value);
    
        delay(15);
      
      }

Inseguitore solare 1/bis

Si aggiunge un servo e la relativa libreria.

     
      #include <Servo.h>
      # define POT       A0
      # define MOTORE     9
     
      int sensorValue = 0;
      int Value = 0;
      
      Servo myservo; 
        
      void setup() 
         
          { myservo.attach(MOTORE);
            pinMode(POT, INPUT);   
            Serial.begin(9600);   }
       
      void loop() {
        
        int sensorValue = analogRead(POT); 
        Value=map (sensorValue, 0, 1023, 0, 179); 
        myservo.write(Value);   
        delay(15);
 
      }

Sostituire il potenziometro con due fotoresistenze uguali e montate in opposizione sul servo. Quando entrambe le fotoresistenze riceveranno la stessa luce il servo sarà allineato.

Inseguitore solare 1

Collegare il centrale di un potenziometro ad AO e seguire le istruzioni sull'IDE di Arduino

      # define POT       A0
    
      int sensorValue1 = 0;
      int Value = 0;
   
        
      void setup() 
         
          { pinMode(POT, INPUT);   
            Serial.begin(9600);   }
       
      void loop() {
        
        int sensorValue = analogRead(POT); 
        Value=map (sensorValue, 0, 1023, 0, 179);     
            if ( Value==90) 
               { Serial.println (" CENTRATO");}
         
            if ( Value>90)
               { Serial.println ("Ruota a Sx");}
               
            if ( Value<90) 
               { Serial.println ("Ruota a Dx");}
  
        Serial.println(Value); 

         
        delay(500);
 
      }

Candeliere votivo.

Annotazioni: vedi lo sketch Pausa.
Senza le variabili acceso1...acceso6 il LOOp so blocca dopo un certo numero di cicli.
NinoAL

 /* Candeliere votivo.
          Alla pressione del pulsante la
          relativa candela rimane accesa
          per n. minuti */
       # define CONTA          2
       # define LED1           8
       # define LED2           9
       # define LED3          10
       # define LED4          11     
       # define LED5          12
       # define LED6          13
     
       int ValueConta        = 0;
       int lastValueConta    = 0;
       int contaImpulsi      = 0;
       int ValueUno          = 1;
       int ValueDue          = 2;
       int ValueTre          = 3;
       int ValueQuattro      = 4;
       int ValueCinque       = 5;
       int ValueSei          = 6;
       
       byte acceso1 = LOW;
       byte acceso2 = LOW;
       byte acceso3 = LOW;
       byte acceso4 = LOW;
       byte acceso5 = LOW;
       byte acceso6 = LOW;
       
       unsigned long iMillis1 = 0;
       unsigned long iMillis2 = 0;
       unsigned long iMillis3 = 0;
       unsigned long iMillis4 = 0;
       unsigned long iMillis5 = 0;
       unsigned long iMillis6 = 0;
      
       int TempoON           =  3000;
       
       void setup() 
           { pinMode(CONTA,     INPUT );
             pinMode (LED1,     OUTPUT);
             pinMode (LED2,     OUTPUT);   
             pinMode (LED3,     OUTPUT);
             pinMode (LED4,     OUTPUT);             
             pinMode (LED5,     OUTPUT);
             pinMode (LED6,     OUTPUT); }
      
       void loop() {
      
      //---------- Leggi pezzi su Pin2 -------------------     
            ValueConta  = digitalRead(CONTA); 
            if ( ValueConta != lastValueConta) 
               { if ( ValueConta == HIGH)
                    { contaImpulsi++;
                    delay(20);    }}// DebounceTime
            lastValueConta = ValueConta;

           if ( ValueConta == HIGH && acceso1 == LOW && contaImpulsi==ValueUno) 
              { digitalWrite(LED1, HIGH);
                acceso1 = HIGH;
                iMillis1 = millis(); }
           if ( acceso1 == HIGH && (millis()-iMillis1) > TempoON)
              { digitalWrite(LED1, LOW);
                acceso1 = LOW; }
            
           if ( ValueConta == HIGH && acceso2 == LOW && contaImpulsi==ValueDue) 
              { digitalWrite(LED2, HIGH);
                acceso2 = HIGH;
                iMillis2 = millis(); }
           if ( acceso2 == HIGH && (millis()-iMillis2) > TempoON)
              { digitalWrite(LED2, LOW);
                acceso2 = LOW; }           
          
           if ( ValueConta == HIGH && acceso3 == LOW && contaImpulsi==ValueTre) 
              { digitalWrite(LED3, HIGH);
                acceso3 = HIGH;
                iMillis3 = millis(); }
           if ( acceso3 == HIGH && (millis()-iMillis3) > TempoON)
              { digitalWrite(LED3, LOW);
                acceso3 = LOW; }
            
           if ( ValueConta == HIGH && acceso4 == LOW && contaImpulsi==ValueQuattro) 
              { digitalWrite(LED4, HIGH);
                acceso4 = HIGH;
                iMillis4 = millis(); }
           if ( acceso4 == HIGH && (millis()-iMillis4) > TempoON)
              { digitalWrite(LED4, LOW);
                acceso4 = LOW; }             
         
           if ( ValueConta == HIGH && acceso5 == LOW && contaImpulsi==ValueCinque) 
              { digitalWrite(LED5, HIGH);
                acceso5 = HIGH;
                iMillis5 = millis(); }
           if ( acceso5 == HIGH && (millis()-iMillis5) > TempoON)
              { digitalWrite(LED5, LOW);
                acceso5 = LOW; }
            
           if ( ValueConta == HIGH && acceso6 == LOW && contaImpulsi==ValueSei) 
              { digitalWrite(LED6, HIGH);
                acceso6 = HIGH;
                iMillis6 = millis(); }
           if ( acceso6 == HIGH && (millis()-iMillis6) > TempoON)
              { digitalWrite(LED6, LOW);
                acceso6 = LOW; }   
      
          if ( contaImpulsi > 5)
             { contaImpulsi= 0; }     
       }

Parcheggio: Aggancio/Sgancio

Carroponte su casella x=F; y=6
Centralina MZ1= ON; pistoni Giù.
I pistoni ruotano su se stessi.
4 microswitch PZ2, normalmente aperti ed in serie segnalano la corretta rotazione dei quattro pistoni.
Centralina MZ1= OFF; pistoni su.

SICUREZZA:
1- se i quattro pulsanti normalmenti aperti PZ2 sono chiusi tutti i perni dei pistoni sono ruotati all'esterno.La macchina non è agganciata.
2- Se i quattro pulsanti normalmenti aperti PZ1 sono chiusi tutti i perni dei pistoni sono ruotati all'interno(sotto l'auto).La macchina è agganciata.
Quindi:

Parcheggio:Prelievo auto.

Il tagliando viene inserito in un lettore di codice a barra.

Parcheggio: Deposito auto

Un parcheggio sotterraneo con alcuni posti auto ancora liberi. Si accede dalla rampa a destra e si posiziona l'auto nella casella F6.
Il carroponte è fermo nella pozione M6.

La pedana, ruotando su se stessa, posizione l'auto pronta per essere imbragata.
L'operatore individua un parcheggio vuoto sul monitor touch screen.
I parcheggi vuoti hanno la fotoresistenza (a pavimento)illuminata dalla luce del garage. Quelle occupate sono oscurate dall'auto.
L'operatore preme il pulsante sul monitor touch screen di una casella vuota seguita dalla pressione del pulsante START

Il carroponte si posiziona in M6.
Dei pistoni abbassano delle leve a forma di T rovesciata.
I pistoni ruotano, le quattro T rovesciate si trovano ora sotto la carrozzeria.
Dei microswitch segnalano l'avvenuta rotazione.

.

I pistoni si abbassano, ruotano, si risollevano.
Il carroponte torna nella casella iniziale M6.
E'stata stampata

Sezione di blocco ferroviario.

http://it.wikipedia.org/wiki/Sezione_di_blocco

Lo sketch è uguale a "Passaggio a livello1".
Un pulsante conta gli assi del convolgio ferroviario all'ingresso di una tratta mentre un secondo pulsante li conta dopo 2 km. Se il conteggio è lo stesso il semaforo da via libera al convolgio che segue.

Passaggio a livello 2.

Se i binari sono due i pulsanti saranno 4, 2 per binario, uno prima ed uno dopo il passaggio a livello.
Lo sketch è quello del post "Passaggio a livello Uno" ma doppio.

Primo binario
P1 incrementa Value1
P2 incrementa Value2

Secondo binario
P3 incrementa Value3
P4 incrementa value4

Se (if) Value1 = Value2 AND Value3 = Value4 ---> la barra è alzata.
Altrimenti (else) ---> la barra si abbassa.

Passaggio a livello 1

Il pulsante P1 viene posizionato a debita distanza a nord del passaggio a livello.
Esso incrementerà la variabile value1.
Il pulsante P2 a sud del passaggio a livello ed incrementerà la variabile value2.
Se value1= value2 la barra è alzata.
Se value1 diverso da value2 la barra è abbassata.
Lo sketch visualizza, inultimente,il conteggio degli assi del treno prima e dopo il suo passaggio, serve solo come controllo dello sketch.

#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 10, 11, 12, 13);

 # define TASTO1   2
 # define TASTO2   3
 # define RELE     6
 int  Value1     = 0;
 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, LOW);
            Serial.println("RELE OFF");
            delay(350);          }
  else    {digitalWrite(RELE, HIGH);
            Serial.println("RELE OFF"); 
          delay (100);  } 
}

Sella di lancio parte 2

Misura la velocità del vagone ed aziona i frenatoi.
La velocità ottimale del vagone deve essere di 8 km/h se superiore vengono azionati dei frentaoi, ciascuno capace di ridurre la velocità del 2%.

/* Legge gli impulsi di un oscillatore
esterno qualunque sia la durata dell'onda quadra.
File
 - Esempi
  -Digital
   -StateChangeDetection

L'oscillatore deve avere una f=1Hz ma per una
prova va bene un diodo led lampeggiante.

Le istruzioni antirimbalzo di START sono state sostituite 
dalla funzione incrementa e dalla successiva istruzione
if START maggiore o uguale a di 1*/

   
    # define START  2
    # define STOP   3
    # define AZZERA 4   
    # define OSCEXT 5 
    
   int ValueStart1  = 0;
   int ValueStart1a = 0;
   
   int ValueStop    = 0;
   int ValueAzzera  =0;
   int Spazio       = 20;
   float Velocita   = 0;
   int ValueOSC1    = 0;  
   int ValueOSC1a   = 0;  
   int ValueOSC1b   = 0;     


   void setup() 
              { pinMode(OSCEXT, INPUT);
                pinMode(START, INPUT);
                pinMode(STOP, INPUT);
                pinMode(AZZERA, INPUT);
                Serial.begin(9600);   }

   void loop() {
  //---------- Lettura AZZERA --------      
      int ValueAzzera= digitalRead(AZZERA);

         if (ValueAzzera== HIGH) 
            {(ValueOSC1 = 0);}
     
/*--Lettura di START con incrementa */ 

     ValueStart1a= digitalRead(START);

            if (ValueStart1a == HIGH )
              { ValueStart1++;  }
     
//------------- Lettura impulsi oscillatore-------        
     ValueOSC1a= digitalRead(OSCEXT);

         if (ValueOSC1a!= ValueOSC1b) 
            { if (ValueOSC1a == HIGH && ValueStart1 >=1 && ValueStop==LOW )
              { ValueOSC1++;
               Serial.println(ValueOSC1);  }}
        ValueOSC1b = ValueOSC1a;

//--------- Fine lettura impulsi esterni-----       
 
//---------- Lettura STOP --------      
      int ValueSTOP= digitalRead(STOP);

         if ( ValueSTOP== HIGH ) 
            { ValueStart1 = 0;
              Velocita = ((Spazio / ValueOSC1) *3.6);  
              Serial.print("Velocita km/h : ");
              Serial.println(Velocita); 
              ValueOSC1 = ValueOSC1 ;
              if (ValueOSC1 == 3)
                 {Serial.println("6 Frenatoi in azione");}
              if (ValueOSC1 == 4)
                 {Serial.println("5 Frenatoi in azione");}
              if (ValueOSC1 == 5)
                 {Serial.println("4 Frenatoi in azione");}
              if (ValueOSC1 == 6)
                 {Serial.println("3 Frenatoi in azione");}
              if (ValueOSC1 == 7)
                 {Serial.println("2 Frenatoi in azione");}
              if (ValueOSC1 == 8)
                 {Serial.println("1 Frenatoi in azione");}
               delay (500);}
           
        
        
}

Sella di lancio parte 1

Smistamento automatico di un convoglio ferroviario merci.
Si propone qui un economico lavoro scolastico di automazione e programmazione.

1 .Convoglio merci.

I convogli si formano agganciando vagoni lungo la tratta ferroviaria, la sua destinazione è uno scalo merci dove i vagoni verranno smistati a seconda della destinazione.

2 .Smistamento.

I vagoni sono stati smistati su tronchi di binari a seconda la destinazione qui indicata con dei colori

3. Procedura di smistamento.

All’arrivo allo scalo il locomotore 2 si stacca dal convoglio. Il locomotore1, prima posto in A, si posiziona in coda e spinge i vagoni all’interno dello scalo con numerose manovre di entra ed esci in ciascun tronco.

4 .Procedura di smistamento con “Sella di lancio” http://it.wikipedia.org/wiki/Sella_di_lancio
Un locomotore di manovra si posiziona dietro il carro, ma non viene agganciato, questi si mette in marcia fino a raggiungere una velocità di 8 km/h e subito dopo rallenta. Il vagone per la legge di conservazione del moto raggiungerà il tronco di binario di destinazione con velocità di 8 km/h in decremento.
La velocità di 8 km/h (o altra) è ritenuta valida come velocità d’urto contro un altro vagone fermo lungo la linea.

Se la velocità del vagone in arrivo è adeguata, i respingenti del carro, fermo e non frenato, sul binario sopporta senza danno l’impatto

4. Procedura in automatico.

Si tratta di accelerare e quindi di rendere economico la scomposizione e ricomposizione del convoglio.
La soluzione che si adotterà e del tutto simile allo scalo ferroviario della Amtrack di Boston (USA), presentato su SKY, sezione documentari, rubrica How it’s made.

Consiste nello spingere il convoglio su una collina artificiale, sganciare il primo vagone o i primi vagoni se hanno la stessa destinazione, spingerli lungo la discesa della collina indirizzandoli nel tronco binari corrispondenti. La velocità massima del vagone all’ingresso del tronco binario non può essere superiore ad 8 km/h, velocità massima d’impatto, ridotta dai respingenti dei vagoni senza che essi abbiano a subirne danno.
Se la velocità è superiore entrano in funzioni dei frenatoi ad aria compressa posti lungo il binario

T1 – Tratto di binario in cui si effettua la misura della velocità.
T2 – Tratto di binario cui sono posti i 10 frenatori.

L’altezza della collina, la pendenza, la lunghezzza dei tronchi e la velocità ottimale di scontro fra un vagone fermo (non frenato) ed il vagone in arrivo è una questione che riguarda l’ingegneria ferroviaria.
Nel documentario veniva citata una velocità di 8 km/h

Un adetto ha appena sganciato il vagone e comunicato in sala controllo la destinazione riportata sul fianco del carro

Il penultimo vagone è stato sganciato, i deviatoi sono stati azionati dalla sala controllo e sono nella giusta posizione, il vagone può avanzare per mettere in posizione l’ultimo vagone. Il locomotore, considerato le condizioni in cui lavora, è nella realtà telecomandato dalla sala controllo.

6 . Misura della velocità.
Essendo la distanza fra START e STOP nota e di valore fisso basta misurare e lavorare con la misura del
tempo. La barriera può essere costruita con un fotodiodo ad infrarosso recuperabile in vecchi
telecomandi ed un led ricevente recuperabile su vecchi chassis di televisori.

7. Frenatoi.
Una soluzione economica è quella della simulazione con diodi led, l’accensione di un led indica l’azione
di un dispositivo capace di ridurre la velocità del 10%...o una forza frenante pari a -2Km/h

8. Rilevatore di distanza.
Segnale alla sala controllo il tronco di binario pieno ed impedisce il posizionamento del relativo deviatoio.
Usando ARDUINO UNO o equivalenti si può osare il misuratore di distanze ad ultrasuoni SRF05 con un
range da 3 cm a 4 metri
.

9. Deviatoi.
Per i deviatoi si vedano i siti di ferromodellismo.
Come dispositvi di sicurezza si prevedano blocchi per evitare deviazioni con vagone in movimento.

10. Sala controllo.
Il lavoro consiste nel ricevere la comunicazione della destinazione del carro, stabilire su quale tronco
Direzionarlo e premere un solo pulsante per azionare tutti i deviatoi interessati

Distributore di bibite -1

Sequenza di funzionamneto di un distributore di bibite.

PP - Contatto N.A del dispositivo per riconoscere la moneta.
L1 e L2 - Spia ON = Prodotto esaurito
P1 = Birra selezionata.
P2 = Gazzosa selezionata
PR1 e PR2 = LOW se bevanda assente
B1,B2,A1,A2 elettrobobine con pistone.
P3, probabile pulsante di restituisci moneta.

Autovelox

Un oscillatore esterno con frequenza di 1 impulso al secondo

è collegato al pin 4.Quando l'automobile intercetta la fotocellula

di START Arduino conta il numero degli impulsi su tale pin.

La fotocellula di STOP si trova ad una distanza ben precisa,

nello schetch è riportato un valore di 20 metri.La formula è

Velocità= Spazio : Tempo 

Velocità in m/sec. = 20 metri : n. di impulsi al secondo

Velocità in Km/h = Velocità in m/sec. x 3.6 

    # define START   2
    # define STOP    3 
    # define OSC     4
    # define RESET   5
    # define TestLED 7
  
    int  ValueSTART  =  0;
    int  ValueSTOP   =  0;
    int  ValueRESET  =  0; 
    int  ValoreOSC   =  1;
    int  Value1      =  1;
    int  Value2      = 0;
    int  Spazio      = 20;
  
  void setup() 
     { pinMode(START,    INPUT );
       pinMode(STOP,     INPUT );
       pinMode(OSC,      INPUT );
       pinMode(RESET,    INPUT );
       pinMode(TestLED,  OUTPUT);
       Serial.begin(9600);  }

  void loop() {
//*********** OSCILLATORE ESTERNO**************
        int ValoreRESET = digitalRead(RESET);
         if (ValoreRESET == HIGH)
            {Value1 = 1;}
//*********** OSCILLATORE ESTERNO**************  
        int ValoreOSC = digitalRead(OSC);

//********** INPUT DI START  ***************** 
       int ValoreSTART = digitalRead(START);
       if (ValoreSTART == HIGH)
         {ValueSTART = (1 - ValueSTART );}
//-------- Inizio Esecuzione impulso di START----  
      if   (ValueSTART == 1 && ValoreOSC == HIGH)
           {digitalWrite(TestLED, HIGH);
            Value1 = (Value1 + 1);}
//**********Fine esecuzione dell'impulso di start--------     

//********** INPUT DI STOP  ***************** 
       int ValoreSTOP = digitalRead(STOP);
//-------- Inizio Esecuzione impulso di STOP----  
      if (ValoreSTOP == HIGH)
         {digitalWrite(TestLED, LOW);
          Value1 = Value1;
          Value2 =((Spazio / Value1) * 3.6);
          ValueSTART = 0; 
          Serial.print("Velocita km/h : ");
          Serial.println(Value2); }
          
      delay (350); 
      //----------FINE ESECUZIONE--------
      
      
}

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

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

}