martedì 26 marzo 2013

semaforo pedonale


- Arduino partiamo da zero - n°4

  

Pulsanti e Led -- Simuliamo un semaforo pedonale

Per questo lavoro si utilizza la gestione pulsanti illustrata nel precedente post.

Si aggiungono tre led e si toglie un pulsante ( ma si può anche lasciare ).




Materiale occorrente:

6  Led ( 2 Rosso, 2 Giallo, 2 Verde ) 
6  Resistenze da 330 ohm.  (  R1 - R6)
2  Resistenze da 10K.  ( R7 - R8 )
2  Pulsanti.
Una BB, filo per collegamenti.


Vediamo qui sotto i collegamenti

 

 

( Si !! lo so il mio montaggio non è così   ma non lo volevo smontare)

Questo è lo schema

 

 

 

Qui sotto trovate lo sketch, ho descritto tutto il funzionamento nei commenti.

/* Sergio & Adriano Prenleloup

    

    20/03/2013

 Semaforo v. 1.0



In questo sketch si utilizza la procedura generica per la gestione 

pulsanti già presentata nel post precedente.



I  pulsanti simuleranno l'arrivo dei pedoni che attendono

al semaforo per attraversare.



Inizialmente si ha la seguente situazione:



  1) Semaforo auto Verde  ---- Semaforo pedoni Rosso

  

  Con la pressione di un pulsante si lascia trascorrere (xT) poi si attiva la 

  procedura semaforo.

  

  che eseguirà i seguenti cambiamenti:

  

  2) Semaforo auto Verde-Giallo ---- Semaforo pedoni Rosso 

  

  3) Semaforo auto Rosso   ------  Semaforo pedoni Verde

   

  4) Semaforo auto Rosso   ------  Semaforo pedoni Verde-Giallo



  5) semaforo auto Verde   ------  Semaforo pedoni Rosso  (come al passo 1)

  

  I tempi per questi passaggi sono più brevi del reale per non allungare troppo

  il filmato di prova ma si possono cambiare facilmente.





*/





//pulsanti = pin
 
int Pulsante_pedoni_a = 8; // simulano i pulsanti dei pedoni
int Pulsante_pedoni_b = 9; 





//stato corrente dei bottoni

int stato_bottoni[2];
boolean stato_switch[2];

// led = pin ( semaforo pedoni)

 int Rosso_ped  = 2;

 int Giallo_ped = 1;

 int Verde_ped =  0;



// led = pin ( semaforo auto )
 int Rosso_auto  = 6;

 int Giallo_auto = 5;

 int Verde_auto =  4;



  int Pedoni = 0;   //ritornerà a 0 dopo la funzione semaforo.





void setup() 

{

  

  // Pulsanti pedoni

  pinMode (Pulsante_pedoni_a, INPUT);

  pinMode (Pulsante_pedoni_b, INPUT);



  

  // Led semaforo pedoni

  pinMode (Rosso_ped, OUTPUT);

  pinMode (Giallo_ped, OUTPUT);

  pinMode (Verde_ped, OUTPUT);

   

  // Led semaforo auto 

   

  pinMode (Rosso_auto, OUTPUT);

  pinMode (Giallo_auto, OUTPUT);

  pinMode (Verde_auto, OUTPUT);

   

   

   stato_bottoni[0] = 0;

   stato_bottoni[1] = 0;

   

  



  

  // condizione iniziale semaforo pedoni

  

  digitalWrite (Rosso_ped, HIGH);

  digitalWrite (Giallo_ped, LOW);

  digitalWrite (Verde_ped, LOW);

  

  // condizione iniziale semaforo auto

  

  digitalWrite (Rosso_auto, LOW);

  digitalWrite (Giallo_auto, LOW);

  digitalWrite (Verde_auto, HIGH);

  

}    



// questa è la procedura generica per utilizzare pulsanti

// chiamata dalla "controllaPulsante"





void aggiornaStato(int bottone, int& statoBottoneVecchio, boolean& statoSwitch)

{

  //Si legge lo stato corrente del bottone (se premuto o no)

  int statoBottoneCorrente = digitalRead (bottone);

  

  //Se lo stato corrente del bottone è cambiato (diverso dal vecchio stato)

  //si deve gestire il nuovo stato

  if (statoBottoneCorrente != statoBottoneVecchio)

  {

      //se stiamo passando da rilasciato a premuto allora gestiamo la 

      //logica antirimbalzo e attiviamo/disattiviamo lo swith

     if (statoBottoneCorrente == HIGH)

     {

       delay(15);

       statoSwitch = !statoSwitch;

     }

     //il nuovo stato diventa lo stato corrente

     statoBottoneVecchio = statoBottoneCorrente;  

  }

}



void controllaPulsante()

{

    aggiornaStato(Pulsante_pedoni_a, stato_bottoni[0], stato_switch[0]);

    aggiornaStato(Pulsante_pedoni_b, stato_bottoni[1], stato_switch[1]);

    

}





//con questa procedura si conteggiano i pedoni ( numero delle volte premuto il pulsante)

// in realtà con i tempi di attesa attuali non è utilissima

// ma se si allungano i tempi iniziali di attesa si potrebbe conteggiare più di un pedone.







void conta_pedoni()

{ 

  if (stato_switch[0] == 1
 
  {  

    Pedoni = Pedoni + 1;   

  } 
  
  if (stato_switch[1] == 1)
 
  {  

    Pedoni = Pedoni + 1; 

  }     
}

  

// questa procedura simula il semaforo

// si avvia con la presenza di almeno un pedone

// Per una migliore lettura

// Ho riportato sempre i tre led (auto) ed i tre led ( pedoni )

// anche se era più compatto scrivere solo i led che cambiano stato.

// I tempi utilizzati sono più brevi del realistico.





void semaforo()

{

  // auto fase 1 ( verde)
 
  digitalWrite (Rosso_auto, LOW);

  digitalWrite (Giallo_auto, LOW);

  digitalWrite (Verde_auto, HIGH);

  

   // pedoni fase 1 (rosso)

  
  digitalWrite (Rosso_ped, HIGH);

  digitalWrite (Giallo_ped, LOW);

  digitalWrite (Verde_ped, LOW);

       delay (2000);  // le auto passano pedoni fermi

  

  // auto fase due giallo e verde

  digitalWrite (Rosso_auto, LOW);

  digitalWrite (Giallo_auto, HIGH);

  digitalWrite (Verde_auto, HIGH);

  
  //pedoni fase 2 ( rosso)

  digitalWrite (Rosso_ped, HIGH);

  digitalWrite (Giallo_ped, LOW);

  digitalWrite (Verde_ped, LOW);
 
     delay (2000);   // il giallo ferma le auto



  // auto fase 3 scatta il rosso

  digitalWrite (Rosso_auto, HIGH);

  digitalWrite (Giallo_auto, LOW);

  digitalWrite (Verde_auto, LOW);

  

  //pedoni fase 3 ( verde)

     delay (300);

  digitalWrite (Rosso_ped, LOW);

  digitalWrite (Giallo_ped, LOW);

  digitalWrite (Verde_ped, HIGH);
 
     delay (6000);   // pedoni attraversano





// auto fase 4 rimane rosso

  digitalWrite (Rosso_auto, HIGH);

  digitalWrite (Giallo_auto, LOW);

  digitalWrite (Verde_auto, LOW);
 
   //pedoni fase 4 giallo e verde
 
  digitalWrite (Rosso_ped, LOW);

  digitalWrite (Giallo_ped, HIGH);

  digitalWrite (Verde_ped, HIGH);

  
      delay (2000);  // il giallo ferma i pedoni





 // auto fase 1 ( verde)
 
  digitalWrite (Rosso_auto, LOW);

  digitalWrite (Giallo_auto, LOW);

  digitalWrite (Verde_auto, HIGH);
 
   // pedoni fase 1 (rosso)

  
  digitalWrite (Rosso_ped, HIGH);

  digitalWrite (Giallo_ped, LOW);

  digitalWrite (Verde_ped, LOW);

  
     delay (100);  // siamo tornati alla confizione iniziale

     

     // ripristiniamo lo stato iniziale dei Pulsanti e dei pedoni

     

     Pedoni = 0;

     stato_switch[0] = 0;

     stato_switch[1] = 0;

}  









void loop()

{  

for ( int i = 0; i < 50; i++) // questo ciclo simula l'attesa per i pedoni 


 {

  controllaPulsante();
  conta_pedoni(); 
  delay (100);  

 }



 if (Pedoni >= 1 )  //se il pulsante è stato premuto si esegue "semaforo" 

                    // poi tutto torna alla fase iniziale.

   { 

    semaforo();

    }

 }

Lo Sketch completo

======================

/* Sergio & Adriano Prenleloup
   
    20/03/2013
 Semaforo v. 1.0
 
In questo sketch si utilizza la procedura generica per la gestione
pulsanti già presentata nel post precedente.

I  pulsanti simuleranno l'arrivo dei pedoni che attendono
al semaforo per attraversare.

Inizialmente si ha la seguente situazione:

  1) Semaforo auto Verde  ---- Semaforo pedoni Rosso
 
  Con la pressione di un pulsante si lascia trascorrere (xT) poi si attiva la
  procedura semaforo.
 
  che eseguirà i seguenti cambiamenti:
 
  2) Semaforo auto Verde-Giallo ---- Semaforo pedoni Rosso
 
  3) Semaforo auto Rosso   ------  Semaforo pedoni Verde
   
  4) Semaforo auto Rosso   ------  Semaforo pedoni Verde-Giallo
 
  5) semaforo auto Verde   ------  Semaforo pedoni Rosso  (come al passo 1)
 
  I tempi per questi passaggi sono più brevi del reale per non allungare troppo
  il filmato di prova ma si possono cambiare facilmente.


*/


//pulsanti = pin

int Pulsante_pedoni_a = 8; // simulano i pulsanti dei pedoni
int Pulsante_pedoni_b = 9;


//stato corrente dei bottoni
int stato_bottoni[2];
boolean stato_switch[2];


// led = pin ( semaforo pedoni)
 int Rosso_ped  = 2;
 int Giallo_ped = 1;
 int Verde_ped =  0;

// led = pin ( semaforo auto )

 int Rosso_auto  = 6;
 int Giallo_auto = 5;
 int Verde_auto =  4;

  int Pedoni = 0;   //ritornerà a 0 dopo la funzione semaforo.


void setup()
{
 
  // Pulsanti pedoni
  pinMode (Pulsante_pedoni_a, INPUT);
  pinMode (Pulsante_pedoni_b, INPUT);
 
 
  // Led semaforo pedoni
  pinMode (Rosso_ped, OUTPUT);
  pinMode (Giallo_ped, OUTPUT);
  pinMode (Verde_ped, OUTPUT);
   
  // Led semaforo auto
   
  pinMode (Rosso_auto, OUTPUT);
  pinMode (Giallo_auto, OUTPUT);
  pinMode (Verde_auto, OUTPUT);
   
   
   stato_bottoni[0] = 0;
   stato_bottoni[1] = 0;
   
 
 
 
  // condizione iniziale semaforo pedoni
 
  digitalWrite (Rosso_ped, HIGH);
  digitalWrite (Giallo_ped, LOW);
  digitalWrite (Verde_ped, LOW);
 
  // condizione iniziale semaforo auto
 
  digitalWrite (Rosso_auto, LOW);
  digitalWrite (Giallo_auto, LOW);
  digitalWrite (Verde_auto, HIGH);
 
}    
 
// questa è la procedura generica per utilizzare pulsanti
// chiamata dalla "controllaPulsante"


void aggiornaStato(int bottone, int& statoBottoneVecchio, boolean& statoSwitch)
{
  //Si legge lo stato corrente del bottone (se premuto o no)
  int statoBottoneCorrente = digitalRead (bottone);
 
  //Se lo stato corrente del bottone è cambiato (diverso dal vecchio stato)
  //si deve gestire il nuovo stato
  if (statoBottoneCorrente != statoBottoneVecchio)
  {
      //se stiamo passando da rilasciato a premuto allora gestiamo la
      //logica antirimbalzo e attiviamo/disattiviamo lo swith
     if (statoBottoneCorrente == HIGH)
     {
       delay(15);
       statoSwitch = !statoSwitch;
     }
     //il nuovo stato diventa lo stato corrente
     statoBottoneVecchio = statoBottoneCorrente;  
  }
}

void controllaPulsante()
{
    aggiornaStato(Pulsante_pedoni_a, stato_bottoni[0], stato_switch[0]);
    aggiornaStato(Pulsante_pedoni_b, stato_bottoni[1], stato_switch[1]);
   
}


//con questa procedura si conteggiano i pedoni ( numero delle volte premuto il pulsante)
// in realtà con i tempi di attesa attuali non è utilissima
// ma se si allungano i tempi iniziali di attesa si potrebbe conteggiare più di un pedone.



void conta_pedoni()
{

   
  if (stato_switch[0] == 1)
 
  {  
    Pedoni = Pedoni + 1;  
  }  
   
  if (stato_switch[1] == 1)
 
  {  
    Pedoni = Pedoni + 1;
  }  
 

}
 


// questa procedura simula il semaforo
// si avvia con la presenza di almeno un pedone
// Per una migliore lettura
// Ho riportato sempre i tre led (auto) ed i tre led ( pedoni )
// anche se era più compatto scrivere solo i led che cambiano stato.
// I tempi utilizzati sono più brevi del realistico.


void semaforo()
{
  // auto fase 1 ( verde)
 
  digitalWrite (Rosso_auto, LOW);
  digitalWrite (Giallo_auto, LOW);
  digitalWrite (Verde_auto, HIGH);
 
   // pedoni fase 1 (rosso)
 
  digitalWrite (Rosso_ped, HIGH);
  digitalWrite (Giallo_ped, LOW);
  digitalWrite (Verde_ped, LOW);
 
 
     delay (2000);  // le auto passano pedoni fermi
 
  // auto fase due giallo e verde
  digitalWrite (Rosso_auto, LOW);
  digitalWrite (Giallo_auto, HIGH);
  digitalWrite (Verde_auto, HIGH);
 
 
  //pedoni fase 2 ( rosso)
  digitalWrite (Rosso_ped, HIGH);
  digitalWrite (Giallo_ped, LOW);
  digitalWrite (Verde_ped, LOW);

     delay (2000);   // il giallo ferma le auto

  // auto fase 3 scatta il rosso
  digitalWrite (Rosso_auto, HIGH);
  digitalWrite (Giallo_auto, LOW);
  digitalWrite (Verde_auto, LOW);
 
 
  //pedoni fase 3 ( verde)
  delay (300);
  digitalWrite (Rosso_ped, LOW);
  digitalWrite (Giallo_ped, LOW);
  digitalWrite (Verde_ped, HIGH);
 

     delay (6000);   // pedoni attraversano


// auto fase 4 rimane rosso
  digitalWrite (Rosso_auto, HIGH);
  digitalWrite (Giallo_auto, LOW);
  digitalWrite (Verde_auto, LOW);
 
 
  //pedoni fase 4 giallo e verde
 
  digitalWrite (Rosso_ped, LOW);
  digitalWrite (Giallo_ped, HIGH);
  digitalWrite (Verde_ped, HIGH);
 
      delay (2000);  // il giallo ferma i pedoni


 // auto fase 1 ( verde)
 
  digitalWrite (Rosso_auto, LOW);
  digitalWrite (Giallo_auto, LOW);
  digitalWrite (Verde_auto, HIGH);
 
   // pedoni fase 1 (rosso)
 
  digitalWrite (Rosso_ped, HIGH);
  digitalWrite (Giallo_ped, LOW);
  digitalWrite (Verde_ped, LOW);
 
     delay (100);  // siamo tornati alla confizione iniziale
     
     // ripristiniamo lo stato iniziale dei Pulsanti e dei pedoni
     
     Pedoni = 0;
     stato_switch[0] = 0;
     stato_switch[1] = 0;
}  




void loop()
{
 
 
for ( int i = 0; i < 50; i++) // questo ciclo simula l'attesa per i pedoni
 
 {
  controllaPulsante();
 
  conta_pedoni();
  delay (100);  
 }
 
 if (Pedoni >= 1 )  //se il pulsante è stato premuto si esegue "semaforo"
                    // poi tutto torna alla fase iniziale.
   {
    semaforo();
    }
 }
 

================ END ==============================

Sul mio canale trovate un piccolo video dimostrativo


Attendo Vostri commenti.
Un saluto a tutti.
Sergio

Nessun commento:

Posta un commento

Vi ringrazio per la lettura e vi invito al prossimo post.
Se il post vi è stato utile, vi è piaciuto oppure no, scrivete un commento.

Un saluto a tutti.
Sergio

Copyright - Condizioni d’uso - Disclaimer
http://avventurarduino.blogspot.it/2012/10/inizia-lavventura-arduino-12-settembre.html