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à

Stefano

Samueleex Progetto carino :)

Samueleex

Purtroppo il progetto con il sensore ad ultrasuoni è fallito, nella teoria funziona ma in pratica non c'è abbastanza potenza per mandare avanti la macchina (circa 1kg).
Non mi sono arreso e facendo varie ricerche ho scoperto che il modulo "L293D" funge anche da amplificatore come un transistor e avendo 4 ingressi è risultato perfetto per 4 motori.
Ecco i materiali necessari:

Qui è come ho gestito il cablaggio:

Il motore 1 è stato collegato al pin 4, il motore 2 al pin 5, il motore 3 al pin 12 e il motore 4 al pin 8.
Per ogni motore il pin dell'Arduino viene collegato all'ingresso del modulo (secondo e penultimo dentino) mentre l'uscita (terzo e terzultimo dentino) va collegata al motore: al + se volete che il motore giri in senso orario mentre al - se volete che il motore giri in senso antiorario, l'altro filo va sempre collegato al GND dell'Arduino (-).
Il sensore a infrarossi è collegato al 2 pin all'uscita, il GND al GND dell'Arduino e l'alimentazione (VCC) ai 3.3V.

Nel codice all'inizio viene richiamata la libreria per il sensore IR: IRremote.h.
int RECV_PIN = 2; viene definita la variabile per il sensore e assegnato il pin 2, vengono anche definiti i pin per ogni motore.
Nella funzione setup(): Serial.begin(9600) inizializza la comunicazione a una velocità di 9600 baud per inviare dati alla console per il debug.
IrReceiver.begin(RECV_PIN, ENABLE_LED_FEEDBACK); inizializza il ricevitore IR con il pin RECV_PIN definito all'inizio e abilita il LED del ricevitore infrarosso.
pinMode(motor1, OUTPUT); ecc... configura i pin dei motori come pin di output per controllare l'alimentazione.
Nella funzione loop() (cuore del programma): if (IrReceiver.decode()) controlla se è stato ricevuto un segnale IR valido.
unsigned long irCode = IrReceiver.decodedIRData.decodedRawData; estrae il valore IR ricevuto e lo memorizza nella variabile irCode.
Il programma quindi verifica il valore di irCode e in base a questo valore esegue determinate azioni:
In questo caso, se è uguale a 0xF30CBF00 rileva che è stato premuto il tasto 0 quindi la macchina andrà avanti in trazione posteriore.
Se irCode è uguale a 0xEF10BF00 rileva che è stato premuto il tasto 1 quindi la macchina andrà in retromarcia in trazione anteriore.
Se irCode è uguale a 0xEE11BF00 rivela che è stato premuto il tasto 2 e la macchina viene configurata per "sterzare a sinistra". Entra in gioco il Motore2 (verso antiorario) e Motore3 (verso orario) che generano un meccanismo simile ad una coppia di forze che fa cambiare direzione alla macchina. Comportamento simile per il tasto 3 con irCode 0xED12BF00 altro che si usano i motori 1 e 4.
Dopo l'esecuzione di una delle condizioni, il programma riprende la ricezione dei segnali IR con IrReceiver.resume(), in modo che possa ripetersi il ciclo per rispondere in continuazione ai comandi IR successivi.

Come detto in precedenza i codici esadecimali cambiano in base ai materiali che avete, vi consiglio di provare prima con quelli indicati nella spiegazione, se non vanno potete aggiungere queste righe di codice:

Serial.print("Codice IR ricevuto: 0x");
Serial.println(irCode, HEX);

Che vi restituiscono sulla console i risultati IR dopo aver premuto un tasto.

Ecco il codice completo:

#include <IRremote.h>

int RECV_PIN = 2;

int motor1 = 4;
int motor2 = 5;
int motor3 = 12;
int motor4 = 8;

void setup() {
  Serial.begin(9600);
  IrReceiver.begin(RECV_PIN, ENABLE_LED_FEEDBACK);
  pinMode(motor1, OUTPUT);
  pinMode(motor2, OUTPUT);
  pinMode(motor3, OUTPUT);
  pinMode(motor4, OUTPUT);
}

void loop() {
  if (IrReceiver.decode()) {
    unsigned long irCode = IrReceiver.decodedIRData.decodedRawData;
    Serial.print("Codice IR ricevuto: 0x");
    Serial.println(irCode, HEX); // IR esadecimale

    if (irCode == 0xF30CBF00) { // "0"
      // trazione posteriore
      digitalWrite(motor1, HIGH);
      digitalWrite(motor2, LOW);
      digitalWrite(motor3, HIGH);
      digitalWrite(motor4, LOW);
    } else if (irCode == 0xEF10BF00) { // "1"
      // trazione anteriore
      digitalWrite(motor1, LOW);
      digitalWrite(motor2, HIGH);
      digitalWrite(motor3, LOW);
      digitalWrite(motor4, HIGH);
    } else if (irCode == 0xEE11BF00) { // "2"
      // Sterza sx
      digitalWrite(motor1, LOW);
      digitalWrite(motor2, HIGH);
      digitalWrite(motor3, HIGH);
      digitalWrite(motor4, LOW);
    } else if (irCode == 0xED12BF00) { // "3"
      // Sterza dx
      digitalWrite(motor1, HIGH);
      digitalWrite(motor2, LOW);
      digitalWrite(motor3, LOW);
      digitalWrite(motor4, HIGH);
    }
    IrReceiver.resume(); // IR
  }
}

Fondatori