Soluzione parcheggio auto con arduino

Piero è un appassionato arduino e makers che ha realizzato una Soluzione Parcheggio Auto con arduino.

soluzione parcheggio auto

Piero ha voluto condividere con noi il suo progetto e mi ha inviato un dettagliato documento di presentazione sia personale sia del progetto che riporto fedelmente, buona lettura.

Mi presento

Ciao, prima di esporvi il mio progetto, mi presento: sono Piero Alaimo, uno studente di ingegneria elettronica dell’università di Palermo, alle prime armi con Arduino.

Dopo i primi semplici circuiti implementati per familiarizzare con la scheda, spinto dalla curiosità e dalla voglia di sperimentare, mi sono cimentato in questo mio primo (e credo non ultimo) progetto che spero possa essere per tutti voi uno spunto per ulteriori miglioramenti e sviluppi. Spero vi piaccia!!!

Prima però volevo ringraziare Mauro per avermi concesso la possibilità di pubblicarlo sul suo blog (che consiglio a tutti di visitare in quanto ben fatto e da cui personalmente ho tratto ispirazione).

Finalità del progetto

Il seguente lavoro ha lo scopo di descrivere le funzionalità, le caratteristiche e le scelte adottate che mi hanno condotto alla realizzazione di questo prototipo di parcheggio automatizzato (vedi fig. 1). La finalità del progetto è quella di automatizzare le operazioni di ingresso e uscita da un parcheggio auto evitando l’ausilio di personale e dunque riducendo drasticamente i costi di gestione e permettendo dunque di massimizzare i profitti.

Il sistema progettato, è infatti in grado di discriminare se vi è una automobile che vuole entrare od uscire e in base al valore di un contatore e di led di segnalazione è in grado di segnalare la disponibilità o meno di posti auto all’interno. L’accesso al parcheggio è inoltre regolamentata da una sbarra anch’essa pilotata attraverso il nostro sistema di controllo e che svolge azioni diverse in base allo stato di ricevitori ad IR e dello stato dello stesso contatore. Nel sistema progettato abbiamo inoltre previsto la segnalazione numerica dei posti auto disponibili (oltre a quella visiva tramite led) sullo schermo di un PC attraverso porta di comunicazione seriale. Un ulteriore sviluppo sarebbe dunque implementare anche un visualizzatore a led (con poche e semplici modifiche a livello hardware/software).

Specifiche di progetto

Il progetto da realizzare attraverso scheda Arduino (modello da scegliere) riguarda un parcheggio automatizzato per auto. Si prevedono le seguenti specifiche:

  • L’ingresso e l’uscita dal parcheggio (esclusivamente per auto) è unico e permette il passaggio di una sola vettura alla volta in ingresso oppure in uscita. Non si considera il passaggio pedonale in quanto per essi è previsto un apposito accesso ;
  • Si prevedono un numero ben preciso N di posti auto disponibili (nel caso specifico 9);
  • Due led posti in corrispondenza dell’ingresso (di color verde e rosso rispettivamente) segneleranno la disponibilità o meno di posti auto (led verde acceso = disponibilità posti auto; led rosso acceso = posti auto esauriti);
  • Si prevedono due coppie di Tx-Rx ad IR utilizzati per aggiornare il conteggio (disposti rispettivamente lato ingresso e lato uscita) in modo tale da poter decrementare (incrementare) il contatore dei posti auto disponibili quando una vettura entra (esce) dal locale parcheggio;
  • L’ingresso e l’uscita dal posteggio sarà regolamentata da una sbarra automatizzata pilotata da un servomotore posta tra i due sensori (vedi figura 3). Il suo funzionamento sarà il seguente:
    1. Se l’auto esce dal posteggio, la sbarra si alzerà lasciandola passare. Immediatamente dopo la sbarra si abbasserà e il contatore posti auto disponibili verrà incrementato;
    2. Se invece vi sarà un autoveicolo in ingresso la sbarra si alzerà e il contatore posti auto disponibili verrà decrementato (soltanto se vi saranno posti auto disponibili);

Si prevede durante il funzionamento della sbarra l’accensione di un led (giallo) di segnalazione – sbarra in movimento.

Modalità di funzionamento e descrizione del sistema

I due sensori ottici di rilevamento del passaggio sono dei ricevitori ad infrarosso integrati (che da ora in poi verranno definiti sensore_A e sensore_B) posti rispettivamente in ingresso e in uscita del parcheggio auto; il loro compito è rilevare l’interruzione del fascio di luce emesso da due led ad infrarosso posti in prossimità rispettivamente del sensore_A e del sensore_B.

E’ ovvia la scelta di utilizzare dei trasmettitori ad IR. Così facendo, i ricevitori saranno immuni alla luce ambientale.

In Figura 2 è riportata la disposizione corretta dei led emettitori IR e dei relativi sensori, insieme ad una schematizzazione di insieme. Si ricordi che l’automobile in entrata e in uscita deve percorrere uno stretto corridoio dove risultano posizionati i due sensori determinando in tal modo l’interruzione del fascio luminoso emesso dai duel led IR. Tra le due coppie di Tx-Rx è inoltre posta una sbarra (azionata tramite servomotore) che regola il transito auto.

Sono inoltre presenti, in ingresso tre led di segnalazione di colore verde, rosso e giallo (che segnalano quando accesi rispettivamente: posti auto disponibili, posti auto esauriti, barra in movimento).

soluzione parcheggio auto diagramma

In tab. 3 è riassunta la lista dei componenti principali che ho adoperato, mentre in fig. 3 la loro connessione.

soluzione parcheggio auto tabella

lo schema elettrico del progetto:

soluzione parcheggio auto schema

Software per progettazione PCB – KiCad

Per progettare il nostro circuito stampato (PCB), abbiamo adoperato KiCad, una suite open source di Electronic Design Automation (EDA) per il disegno di schemi elettrici e circuiti stampati.

E’ un ambiente di sviluppo integrato (IDE) che raggruppa un editor di schematici (EeSchema), un programma per componenti e moduli (Cvpcb), un editor di circuiti stampati (Pcbnew) e infine un visualizzatore di file Gerber (GerbView – l’unico modulo che non ho adoperato nel mio progetto).

soluzione parcheggio auto pcb schema

PCB schema

A fianco riportiamo il layout della scheda comprendente le due coppie di Tx-Rx ad infrarosso, i 3 led di segnalazione, con in più i connettori per collegare la scheda con Arduino, con il servomotore e per collegare il pacco batterie (4 pile da 1,5V) per l’alimentazione eslusiva del servo. Dunque avrò due linee di alimentazione separate: una per il servo e l’altra per il resto del circuito (attraverso porta seriale connessa al PC)

soluzione parcheggio auto pcb shield

PCb lato componenti

Questo a sinistra è il layout 3D (lato componenti)

soluzione parcheggio auto pcb shield saldature

PCB lato piste

Questo a destra è invece il layout 3D (lato saldature)

Dimensioni della scheda: 9×7 cm.

Listato Commentato

/*
 * Programma
 * Posteggio auto
 */

#define LEDverde 13   // Led Verde connesso al pin 13
                      // Led segnalaz. posti disponibili
#define LEDgiallo 8   // Led Giallo connesso al pin 8 
                      // Led segnalaz. barra in movim.
#define LEDrosso 5    // Led Rosso connesso al pin 5
                      // Led segnalaz. posti auto esauriti
#define RXTSOP 2      // Ricevitore TSOP connesso alla porta 2
#define TXIR 11       // Trasmettitore IR connesso al pin 11
#define RXTSOPB 4     // Ricevitore TSOPB connesso alla porta 4
#define TXIRB 3       // Trasmettitore IR B connesso al pin 3
#include <Servo.h>    // Includi libreria Servo
Servo myservo;        // Creo l’oggetto myservo per controllare 
                      // la rotaz. del servo
#define ServoM    12  //Servomotore connesso al pin 12
#define BarLow    177 //Barra abbassata
#define BarUp     95  //Barra alzata

int val = 0;               // Definisco una variabile 
                           // di tipo intero (integer) val 
int val2 = 0;              // Definisco una variabile 
                           // di tipo intero (integer) val2
int vecchio_val = 0;       // Definisco una variabile 
                           // di tipo intero (integer) vecchio_val
int vecchio_val2 = 0;      // Definisco una variabile 
                           // di tipo intero (integer) vecchio_val2
int vecchio_val3 = 0;      // Definisco una variabile 
                           // di tipo intero (integer) vecchio_val3
int vecchio_val4 = 1;      // Definisco una variabile 
                           // di tipo intero (integer) vecchio_val4
int posti_auto_disp;       // Variabile posti auto disponibili
int posti_auto_disp_old=-1 // Definisco una variabile 
                           // di tipo intero (integer)
int state = 0;             // Definisco la variabile state
#include <EEPROM.h>        // Includo libreria EEPROM per conservare 
                           // in memoria non volatile

void turn_off_IR ()        // Inizializzazione registri Timer2
{
  TCCR2A = 0; 
  TCCR2B = 0; 
  OCR2A = 0
    OCR2B = 0;  
  digitalWrite(TXIR, LOW);   // Tx off
  digitalWrite(TXIRB, LOW);  // Tx B off
}

void turn_on_IR ()   // Set up Timer 2 (connesso alle porte 3 e 11)
{
  TCCR2A = _BV(WGM21) | _BV(COM2A0) | _BV(COM2B0); // Timer impost. 
                                                   // a 01010010
  TCCR2B = _BV(CS20);                  // No prescaler
  OCR2A = 210;                         // Il pin 11 è settato per emettere 
                                       // un segnale a 38 khz
  OCR2B = 210;                         // Il pin 3 è settato per emettere 
                                       // un segnale a 38 khz
}

void setup(){
  Serial.begin(9600);                  // Apre la porta seriale e imposta 
                                       // la velocità di trasm. a 9600 bps
  posti_auto_disp  = EEPROM.read (10); // Memorizzo su memoria 
                                       // non volatile posti_auto_disp
  pinMode(LEDverde, OUTPUT);           // Imposta il Pin come uscita
  pinMode(LEDgiallo, OUTPUT);          // Imposta il Pin come uscita
  pinMode(LEDrosso, OUTPUT);           // Imposta il Pin come uscita
  pinMode(TXIR, OUTPUT);               // Imposta il Pin come uscita
  pinMode(RXTSOP, INPUT);              // Imposta il Pin come ingresso
  pinMode(TXIRB, OUTPUT);              // Imposta il Pin come uscita
  pinMode(RXTSOPB, INPUT);             // Imposta il Pin come ingresso
  digitalWrite(verde, HIGH);           // Accende il led verde

  digitalWrite(LEDrosso, LOW);         // Spegne il led rosso
  turn_on_IR(); // search for IR       // I due Tx ad IR emettono segnale 
                                       // a frequenza 38 kHz
  myservo.write(BarLow);               // Barra abbassata
}

void loop(){
  delay(50);                           // Ritardo di 50 ms
  myservo.attach(ServoM);              // Lega l’oggetto myservo al Pin 12 
                                       // a cui abbiamo collegato il servo
  val = digitalRead(RXTSOPB);          // Memorizzo in val lo stato 
                                       // del ricevitore TSOPB 
  val2 = digitalRead(RXTSOP);          // Memorizzo in val2 lo stato 
                                       // del ricevitore TSOP
  if (posti_auto_disp_old!=posti_auto_disp)
    Serial.println(posti_auto_disp);   // Visualizzo il numero di posti 
                                       // disponibili via seriale
  posti_auto_disp_old=posti_auto_disp;


  ******** sezione ingresso auto *************

    if ((val == HIGH) && (vecchio_val == LOW)){ // Transizione 0 → 1 TSOPB
    if ((val2 == LOW)){                         // Fascio TSOP 
                                                // non interrotto
      state=0; 
      if ((posti_auto_disp > 0)){               // Ci sono posti diponibili
        digitalWrite(LEDgiallo, HIGH);    
        myservo.write(BarUp);
      }
    }
  }   
  delay(200);        // Attesa di 200 millisecondi  
  vecchio_val = val; // Memorizzo in vecchio_val lo stato di TSOPB  

  if ((val2 == LOW) && (vecchio_val2 == HIGH)){ // Transizione 1 → 0 TSOP
    if ((val == LOW)){            // Fascio TSOPB non interrotto
      if ((posti_auto_disp > 0)){ // Ci sono posti diponibili
        if ((state == 0)){
          posti_auto_disp --;
          EEPROM.write (10, posti_auto_disp);  // Scrivo su memoria EEPROM 
                                               // posti_auto_disp
          Serial.println (“AutoIn”);    // Visualizzo su PC  “AutoIn” 
                                        // via seriale
          digitalWrite(LEDverde, HIGH); // Accende led verde
          digitalWrite(LEDrosso, LOW);  // Spegne led rosso
          myservo.write(BarLow);        // Abbassa la sbarra
          digitalWrite(LEDgiallo, LOW); // Spegne led giallo
        }	

      }
      if ((posti_auto_disp == 0)){     //Non ci  sono più posti diponibili
        digitalWrite(LEDverde, LOW);   //Spegne il led verde 
        digitalWrite(LEDrosso, HIGH);  //Accende il led rosso
        myservo.write(BarLow);         //Abbassa la sbarra
        digitalWrite(LEDgiallo, LOW);  //Spegne il led giallo
      }
    }
  }   
  delay(200);          // Attesa di 200 millisecondi  
  vecchio_val2 = val2; // Memorizzo lo stato di TSOP

  ******** sezione uscita auto **************
    if ((val2 == HIGH) && (vecchio_val3 == LOW)){ //Transizione 0 → 1 TSOP
    if ((val == LOW)){                 // Fascio TSOPB non interrotto
      state=1;
      if ((posti_auto_disp != 9)){     // Ci sono macchine 
                                       // nel il parcheggio
        myservo.write(BarUp);          // Alzo la sbarra
        digitalWrite(LEDgiallo, HIGH); // Accendo il led giallo
      }
    }
  }
  delay(200);          // Attesa di 200 millisecondi  
  vecchio_val3 = val2; // Memorizzo lo stato di TSOP  

  if ((val == LOW) && (vecchio_val4 == HIGH)){ // Transizione 1 → 0 TSOPB
    if ((val2 == LOW)){                        // Fascio TSOP non interrotto
      if ((posti_auto_disp < 9)){              // Ci sono posti auto 
                                               // disponibili
        if ((state == 1)){
          posti_auto_disp ++;                  // Incrementa posti auto 
                                               // disponibili
          EEPROM.write (10, posti_auto_disp);  // Scrivo in memoria 
                                               // posti_auto_disp
          Serial.println (“AutoOut”);          // Visualizzo su PC “AutoOut” 
                                               // via seriale
          digitalWrite(LEDverde, HIGH);        // Accende il led verde 
          digitalWrite(LEDrosso, LOW);         // Spegne il led rosso 
          myservo.write(BarLow);               // Abbassa la sbarra
          digitalWrite(LEDgiallo, LOW);        // Spegne led giallo 
        }
      }
      if ((posti_auto_disp == 9)){             // Raggiunta Capacità Max 
                                               // Non incremento contatore

        digitalWrite(LEDrosso, LOW);           // Spengo led rosso  
        digitalWrite(LEDverde, HIGH);          // Accendo led verde  
        myservo.write(BarLow);                 // Abbasso sbarra
        digitalWrite(LEDgiallo, LOW);          // Spengo led giallo 
      }
    }
  }
  delay(200);                                  // Attesa di 
                                               // 200 millisecondi  
  vecchio_val4 = val;                          // Memorizzo lo stato TSOPB  
}

Il video realizzato da Piero

Buon parcheggio !!!

Prima di inserire un commento, per favore, leggi il regolamento

Permanent link to this article: https://www.mauroalfieri.it/elettronica/soluzione-parcheggio-auto-con-arduino.html

Lascia un commento

Your email address will not be published.

Questo sito usa Akismet per ridurre lo spam. Scopri come i tuoi dati vengono elaborati.