Auto della polizia con Arduino!

Ant

Lampeggiante della polizia, con tanto di audio della sirena, usando componenti del kit Arduino!

Componenti utilizzati:

Breadboard 170 fori
2 led, uno rosso, uno blu
Buzzer attivo
x2 resistori da 220 ohm
4 jumper
scheda arduino

Inizia collegando il buzzer alla scheda Arduino.
Il buzzer attivo ha due pin, uno per l'alimentazione e uno per il segnale. Collega il pin per l'alimentazione (+) al pin 5V della scheda Arduino, e il pin per il segnale al pin 8.
Successivamente collega i LED alla scheda Arduino. I LED hanno anche due pin, uno per l'anodo (+) e uno per il catodo (-). Collega l'anodo del LED rosso al pin 9 della scheda Arduino e il catodo al pin GND della scheda Arduino con una resistenza di 220 ohm. Fai la stessa cosa per il LED blu, ma collegalo al pin 10.
Poi teoricamente se tutto va bene e avviato il codice dovrebbe andare tutto.! Guarda l'immagine

Codice:

const int buzzerPin = 8;
const int ledRedPin = 9;
const int ledBluePin = 10;
 
const int sirenFrequency = 500;
 
const int interval = 250;
 
void setup() {
  pinMode(buzzerPin, OUTPUT);
  pinMode(ledRedPin, OUTPUT);
  pinMode(ledBluePin, OUTPUT);
}
 
void loop() {
  for (int i = 0; i < 3; i++) {
    tone(buzzerPin, sirenFrequency);
    delay(interval);
    noTone(buzzerPin);
 
    digitalWrite(ledRedPin, HIGH);
    delay(interval);
    digitalWrite(ledRedPin, LOW);
 
    digitalWrite(ledBluePin, HIGH);
    delay(interval);
    digitalWrite(ledBluePin, LOW);
 
    delay(interval);
  }
}

👇👇👇

Samueleex

Grandissimo!!
Allego anche uno screenshot di Tinkercad:

Vista schematica:

Ovviamente molto basic ma non si toglie la possibilità di upgrade futuri! :)

👇👇👇

Samueleex

Aggiornamento:

Abbiamo aggiornato il progetto aggiungendo un motore CC e sensore a ultrasuoni.

Componenti utilizzati

Spiegazione codice C++

In questo progetto si utilizza un sensore a ultrasuoni, un motore, un buzzer, un LED rosso e un LED blu per simulare una macchina della polizia americana.
Inizialmente vengono definite alcune costanti per i pin: "buzzerPin" è il pin per il buzzer, "ledRedPin" è il pin per il LED rosso, "ledBluePin" è il pin per il LED blu, "motorPin" è il pin per il motore, "triggerPin" e "echoPin" sono i pin per il sensore di distanza.
Viene anche scritta la costante "maxDistance" che sarebbe la distanza massima che il sensore è in grado di rilevare (in cm) e "sirenFrequency" che rappresenta la frequenza del suono del buzzer.
Nella funzione "setup" vengono impostati i pin come input o output a seconda del loro utilizzo.
Nella funzione "loop" viene eseguito un ciclo "for" per svolgere 3 volte la funzione di emettere un suono dal buzzer, accendere il LED rosso e poi il LED blu per un determinato intervallo di tempo (dalla costante "interval").
Viene poi inviato un impulso al sensore di distanza tramite il pin "triggerPin" e viene misurata la durata dell'impulso dal pin "echoPin".
La distanza viene calcolata con la formula "duration / 58.2" e confrontata con la costante "maxDistance".
Importante ricordare che se la distanza rilevata è inferiore o uguale alla distanza massima il motore viene acceso quindi scoprendo il sensore abbiamo la vera e propria partenza della macchina.
Infine abbiamo inserito un ritardo prima di ripetere il ciclo.

Nuovo codice C++:

const int buzzerPin = 8;
const int ledRedPin = 9;
const int ledBluePin = 10;
const int motorPin = 3;
const int triggerPin = 4;
const int echoPin = 2;

const int maxDistance = 30; // cm

const int sirenFrequency = 500;


const int interval = 200;

void setup() {

  pinMode(buzzerPin, OUTPUT);
  pinMode(ledRedPin, OUTPUT);
  pinMode(ledBluePin, OUTPUT);
  pinMode(motorPin, OUTPUT);
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {

  for (int i = 0; i < 3; i++) {

    tone(buzzerPin, sirenFrequency);
    delay(interval);
    noTone(buzzerPin);


    digitalWrite(ledRedPin, HIGH);
    delay(interval);
    digitalWrite(ledRedPin, LOW);


    digitalWrite(ledBluePin, HIGH);
    delay(interval);
    digitalWrite(ledBluePin, LOW);
  }

  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  long duration = pulseIn(echoPin, HIGH);

  int distance = duration / 58.2;
  if (distance <= maxDistance) {
    digitalWrite(motorPin, HIGH);
  } else {
    digitalWrite(motorPin, LOW);
  }
  delay(interval);
}

Immagini utili

Screenshot Tinkercad:

Vista schematica:

Manca solo montare tutto e vedere la macchina sfrecciare, rimanete connessi!

Giulio_M

Samueleex Manca solo montare tutto e vedere la macchina sfrecciare, rimanete connessi!

Fantastico davvero!! Non vediamo l'ora!!😀

Solamente un consiglio da "maniaco delle performance", lavorando con C/C++ nel caso si debba lavorare con cicli (va beh, in questo caso non è fondamentale in quanto le iterazioni sono poche), dove possibile farei questo:

provare a memorizzare una variabile come "register" ovvero nei registri della CPU anziché nella memoria principale (RAM); per Arduino i registri della CPU sono ancora più piccoli rispetto ad un processore per desktop, quindi potrai memorizzare si e no un paio di variabili di tipo int (può avere senso per l'indice di un ciclo, ad esempio); in alcuni casi questo può avere senso, come dalla discussione Benchmark performance C, Python, MATLAB - GNU Octave, JavaScript, PHP, codice C praticamente uguale, registri di sistema vs RAM, differenza del tempo totale di esecuzione del programma, del 23% circa... A parità di condizioni, non è poco! Si potrebbe quindi fare una semplice prova: se l'allocazione nei registri della CPU fallisce (non c'è spazio sufficiente) in automatico va a prendere la successiva memoria ovvero la RAM
non sono pratico di Arduino, ma provare dove possibile anche ad allocare lo spazio strettamente necessario per le variabili? La cosa ovviamente ha senso quando abbiamo particolare richiesta di memoria e numero di iterazioni elevato con quella variabile (analogamente a salvarla nei registri della CPU, come detto prima). Per capirci, abbiamo:
- char: 1 byte allocato (1 byte = 8 bit, 2⁸=256 = (0:255), se aggiungiamo "unsigned" raddoppia)
- short: 2 byte allocati
- int: 4 byte allocati
- float: 4 byte allocati
- long int: 8 byte allocati
- double: 8 byte allocati
- long double: 16 byte allocati

Ripeto, quando opportuno, in base al numero di bit si può considerare il massimo numero esprimibile per quel tipo di dato e, se restiamo ad esempio sotto il 255, ha più senso una variabile "char" piuttosto che un "long int" che alloca 8 volte più memoria e arriva fino a 2⁶⁴-1 ovvero circa 1,8*(10¹⁹), numero a dir poco enorme che probabilmente va molto oltre le nostre necessità

Fondatori