HC-SR04 Sensori a ultrasuoni su scheda Arduino Uno

Posto su 2019-09-17

HC-SR04 Sensori a ultrasuoni su scheda Arduino Uno

La lettura in un sensore HC-SR04 su una scheda Arduino è relativamente semplice, ma cosa succede se si desidera leggere in più sensori? Come farlo in modo efficiente? Questo articolo spiega utilizzando un esempio come leggere in modo efficiente in 4 sensori e come espanderlo ulteriormente a più sensori.

Costruisci 4 sensori a ultrasuoni HC-SR04 su una scheda Arduino Uno

Cos'è un HC-SR04

L'HC-SR04 è una scheda breakout con sensori a ultrasuoni. Su questo cartello ci sono due oggetti cilindrici, uno dei quali è contrassegnato dalla lettera “T”, che sta per “Transmitter”, che significa “mittente”, mentre l'altro è contrassegnato dalla lettera “R” per “Receiver”, che significa "ricevitore". Il trasmettitore emette un'onda sonora ultrasonica e il ricevitore "ascolta" che questa onda sonora entri in collisione con un oggetto e venga riflessa indietro. Il tempo che intercorre tra la trasmissione e la ricezione indica la distanza dell'oggetto dal sensore. Pipistrelli, delfini, balene e sonar nelle navi funzionano secondo un principio simile, e questo principio viene spesso definito "localizzazione dell'eco".

Scheda breakout HC-SR04

Riesci a sentire un'onda sonora ultrasonica

A meno che tu non abbia le orecchie del tuo cane, non puoi sentire le onde sonore ultrasoniche. L'HC-SR04 utilizza un'onda sonora con una frequenza di 40kHz, mentre un orecchio umano può sentire solo 16kHz e le persone più giovani possono sentire fino a 20-22kHz. Molto al di sotto della frequenza di un'onda sonora ultrasonica.

Inoltre, un'onda sonora ultrasonica non è un'onda radio (come le onde di uno smartphone) ed è completamente innocua per la salute.

Come funziona l'HC-SR04

Come accennato in precedenza, l'HC-SR04 emette un suono ultrasonico, che si scontra con un oggetto e ritorna al sensore. Il sensore conta il tempo che intercorre tra l'invio e la ricezione di questo segnale. Se conosci la velocità del suono, puoi calcolare la distanza tra il sensore e l'oggetto. Naturalmente, il suono non viaggia all'infinito e poiché l'onda sonora del sensore è relativamente debole, anche il campo di misurazione è piuttosto limitato. L'HC-SR04 può misurare distanze fino a circa 400 cm (4 m). Anche l'“angolo di visione” o “angolo di misurazione” del sensore non è infinito. Gli oggetti che cadono al di fuori di un angolo di 15° non possono essere rilevati dal sensore. Ecco perché a volte è interessante utilizzare più sensori, che si posizionano in cerchio, ad esempio. In questo modo è possibile aumentare l'angolo di misurazione.

Leggi il sensore

Per leggere l'HC-SR04 è necessario generare un impulso di avvio sul pin "trigger" del sensore. La risposta del sensore apparirà sul suo pin "echo". Entrambi i pin sono collegati ai pin I/O digitali di Arduino .

Grilletto

Per generare un impulso di avvio, è necessario completare i seguenti passaggi

Il pin del trigger deve essere basso per almeno 2µs (microsecondi).
Il pin del trigger deve quindi essere alto per 10 µs
Perno del grilletto in basso

Con Arduino puoi farlo facilmente con il seguente pezzo di codice:

HC-SR04 "Trigger"

// Zend start signaal "trigger"
digitalWrite(2, LOW);   // Zet pin 2 LAAG
delayMicroseconds(2);   // Wacht 2µs
digitalWrite(2, HIGH);  // Zet pin 2 HOOG
delayMicroseconds(10);  // Wacht 10µs
digitalWrite(2, LOW);   // Zet pin 2 terug LAAG

Eco

La risposta che compare sull'echo pin del sensore è un impulso la cui durata è pari al tempo che intercorre tra la trasmissione e la ricezione dell'onda sonora ultrasonica, espressa in µs (microsecondi). Una possibilità per misurare un tale impulso su Arduino è con la funzione "pulseIn":

Meet "echo"

reistijd_geluidsgolf = pulseIn(2, HIGH);   // Meet de tijd dat de puls HOOG (true) is op pin 2

Calcola la distanza

Certo, dopo tutto questo conoscete solo il tempo di percorrenza dell'onda sonora, ma questo non significa che conoscete la distanza. Fortunatamente, la velocità del suono è nota e la distanza può essere calcolata con questo:

distanza [m] = velocità_suono [m/s] * tempo [s]

e la velocità del suono è di 343 m/s, quindi

distanza [m] = 343 [m/s] * tempo [s]

Tuttavia, l'HC-SR04 fornisce il tempo in µs, e per un facile conteggio la distanza in cm sarebbe più conveniente, ma con alcuni calcoli la formula può essere regolata per

distanza [cm] = 0,0343 [cm/µs] * tempo [µs]

L'unico problema che rimane ora è che il tempo indicato dall'HC-SR04 è il tempo in cui l'impulso viaggia avanti E indietro, e poiché solo la distanza dall'oggetto è utile, devi solo dividere il tempo per 2:

distanza = 0,0343 * (tempo/2)

Semplice configurazione di prova

Un rapido set-up di prova per testare il funzionamento dell'HC-SR04 può essere realizzato con il seguente schema e codice:

Un sensore HC-SR04 su Arduino Uno

Eenvoudige code voor het testen van een HC-SR04 op een Arduino Uno

#define triggerPin 4      // Pin voor de trigger
#define echoPin 2         // Pin voor de echo
#define soundSpeed 343.0  // Snelheid van het geluid (m/s)

// Init variables
long echoTime = 0;
float distance = 0;

// Eenmalige doorloop (setup)
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
    ; // Wacht op seriele monitor
  }
  Serial.println("--- Seriele monitor gestart ---");
  pinMode(triggerPin, OUTPUT);  // Zet trigger pin als uitgang
  pinMode(echoPin, INPUT);      // Zet echo pin als ingang
}

// Continue doorloop (loop)
void loop()
{
  // Zend startpuls (trigger)
  digitalWrite(triggerPin, LOW);    // Make sure trigger pin is low
  delayMicroseconds(2);             // for at least 2µs
  digitalWrite(triggerPin, HIGH);   // Set trigger pin HIGH
  delayMicroseconds(10);            // for at least 10µs
  digitalWrite(triggerPin, LOW);    // Set LOW again

  // Meet lengte van de echo puls
  echoTime = pulseInLong(echoPin, HIGH);
  // en bereken hiermee de aftsand (in cm)
  distance = float(echoTime) / 2 * (soundSpeed / 10000.0);
  // Geef weer op de seriele monitor
  Serial.print("Afstand = ");
  Serial.print((String)distance);
  Serial.println(" cm");
  // And wacht 500ms
  delay(500);
}

Multi HC-SR04

Da qui diventa un po' più difficile. Poiché la funzione "pulseIn" mette in pausa il codice e non è sufficientemente precisa, il codice esteso utilizza registri di porta e interruzioni. Se questo suona strano, puoi trovare maggiori informazioni sul sito web dell'autore di questo articolo: http://kunoichi.be/projects/
(il sito è disponibile solo in inglese)

Più sensori

Per utilizzare più sensori, puoi procedere in tre modi:

grilletto separato per sensore; eco separato per sensore
innesco comune; eco separato per sensore
grilletto separato per sensore; eco comune

grilletto separato per sensore; eco separato per sensore

Il modo più semplice, e meno efficiente, è quello di collegare ciascun pin di trigger ed eco di ciascun sensore a un pin separato Arduino .
In altre parole, 2 pin su Arduino per sensore.

innesco comune; eco separato per sensore

Un altro modo è collegare tutti i trigger dei sensori e collegarli a 1 pin su Arduino . Il pin echo di ciascun sensore deve quindi essere collegato a un pin separato su Arduino . Il vantaggio, così come lo svantaggio, è che tutti i sensori inviano la loro risposta contemporaneamente. C'è la possibilità che i sensori interferiscano tra loro e hai anche bisogno di un pin di interruzione separato per ciascun sensore (l' Arduino Uno ne ha solo 2). Potresti usare spilli normali, ma poi la precisione diminuirebbe un po '.

grilletto separato per sensore; eco comune

Se la lettura super veloce non è necessaria, puoi comunque ottenere un'ottima precisione con il terzo metodo e non hai lo svantaggio che i sensori interferiscano l'uno con l'altro.
Ogni pin trigger del sensore è collegato separatamente ad Arduino e tutti i pin echo sono collegati a 1 singolo pin Arduino . Questo pin è chiamato pin di interrupt. Poiché decidi quale trigger è controllato, sai quale è la risposta del sensore al pin dell'eco comune.
Questo è il modo più efficiente per utilizzare più sensori HC-SR04 su una singola scheda Arduino .

schema

Un piccolo svantaggio con il comune metodo del pin echo è che i sensori possono interferire tra loro su questo pin, ma ciò può essere facilmente risolto utilizzando i diodi. La struttura del sistema è la seguente:

Schema 4 sensori HC-SR04 su pin echo comune

Il diagramma temporale mostra l'andamento dei segnali.

Viene inviato l'impulso di avvio (trigger) per il sensore 4.
Questo risponde al pin echo.
Viene inviato l'impulso di avvio (trigger) per il sensore 3.
Risponde allo stesso pin echo, ma poiché l'impulso di avvio viene monitorato, è noto da quale sensore proviene la risposta.
Viene inviato l'impulso di avvio (trigger) per il sensore 2.
...
Ripetere dal passaggio 1

Il resto è letteralmente copia/incolla e può essere facilmente esteso a più (o meno) sensori in questo modo.

Grafico temporale 4 trigger, 1 eco

Il codice per la lettura dei sensori è il seguente:
(La spiegazione del codice è fornita tramite campi di commento nel codice stesso)

Uitbreidbare code voor het uitlezen van meerdere sensoren

#define tSENS 4            // Totaal aantal sensoren
#define echoPin 2          // Pin van de gemeenschappelijke echo --> Dit is een interrupt PIN !
#define pingDelay 50       // Tijd tussen elke nieuwe meting (best > 5ms houden)
#define soundSpeed 343.0   // Snelheid van het geluid in m/s

volatile unsigned long startEcho;     // Place to store start time (interrupt)
volatile unsigned long stopEcho;      // Place to store stop time (interrupt)
float distancesCm[tSENS];             // Distances in cm

// Plaats de pin nummers van de trigger pinnen hier (aantal = tSENS !)
int triggerPins[tSENS] = {4, 5, 6, 7};      // Trigger pin voor elke sensor

// Poll timer
unsigned long lastPingMillis;

/****************************************************************
      SETUP
****************************************************************/
void setup()
{
  Serial.begin(115200);
  while (!Serial) {
    ; // Wait for Serial
  }
  Serial.println("--- Serial monitor started ---");
  // Zet alle trigger pinnen als uitgangen
  for (int i = 0; i < tSENS; i++) {
    pinMode(triggerPins[i], OUTPUT);
  }
  // Set echo pin
  pinMode(echoPin, INPUT);                  // Zet echo pin as ingang (geen pullup bij diodes !)
  attachInterrupt(0, ISR_ECHO, CHANGE );    // Definieer interrupt call voor echo pin
  lastPingMillis = millis();
}

/****************************************************************
      LOOP
****************************************************************/
void loop()
{
  // Ping elke x ms
  if (millis() - lastPingMillis >= pingDelay)
  {
    doMeasurement();  // Roep meet procedure op
    // Toon metingen op seriele monitor
    Serial.println(String(distancesCm[0]) + " - " + String(distancesCm[1]) + " - " + String(distancesCm[2])  + " - " + String(distancesCm[3]));
    lastPingMillis = millis();
  }
}

/****************************************************************
      Retrieve measurement and set next trigger
****************************************************************/
void doMeasurement()
{
  // Eerste uitlezing is fout of 0
  unsigned long startWait;
  unsigned long timeout = 30; // 30ms is de max tijd wachten op echo (23ms = 4m = buiten bereik)
  // Voor elke sensor ...
  for (int s = 0; s < tSENS; s++)
  {
    startEcho = 0;  // Reset start tijd
    stopEcho = 0;   // Reset stop tijd
    // Start volgende trigger
    // digitalWrite(triggerPins[s], LOW);  // Hier niet nodig
    // delayMicroseconds(2);
    digitalWrite(triggerPins[s], HIGH);    // HOOG gedurende min. 10µs
    delayMicroseconds(10);
    digitalWrite(triggerPins[s], LOW);    // Terug LAAG
    startWait = millis();   // Onthoud de start tijd "wachten op echo"
    while (startEcho == 0 or stopEcho == 0) {
      // Doorloop tot start en stoptijd verschillend is van 0, of timeout optreedt
      if (startWait + timeout < millis())
      {
        // Forceer resultaat naar 0
        startEcho = 0;
        stopEcho = 0;
        break;  // onderbreak de while cycles
      }
    }
    noInterrupts();   // cli()
    distancesCm[s] = (stopEcho - startEcho) * (float)soundSpeed / 1000.0 / 10.0 / 2.0;   // in cm
    interrupts();   // sei();
  }
}

/****************************************************************
      INTERRUPT handling (keep as fast(=short) as possible)
****************************************************************/
void ISR_ECHO()
{
  // For ATmega328(P) chips, INT0 as at pin PD2
  byte pinRead = PIND >> 2 & B0001;  // Lees de status van de interrupt pin 2 (Arduino Uno)
  if (pinRead)  {
    // Pin = HOOG -> Onthoud de start tijd
    startEcho = micros();
  }
  else {
    // Pin is LAAG -> Onthoud de stop tijd
    stopEcho = micros();
  }
}
//EINDE

Sebbene questo non sia il metodo più veloce e con lunghe distanze e molti sensori il tempo di consegna può essere relativamente elevato, questo metodo offre alcuni vantaggi

è necessario solo 1 pin di interruzione
molto facilmente espandibile
i sensori non interferiscono tra loro
uso ottimale del numero di sensori rispetto ai pin I/O disponibili

Nota sull'alimentazione

Poiché il pin da 5 V su Arduino può fornire una corrente limitata, si consiglia di fornire un'alimentazione aggiuntiva da 5 V CC per alimentare i sensori. Per questo motivo, un "alimentatore Breadbard" è incluso nell'elenco dei componenti, ma in sostanza può essere sostituito da qualsiasi fonte di alimentazione a 5 V CC.

Componenti

I componenti utilizzati in questo progetto sono tutti disponibili su Opencircuit, e sono di seguito elencati:

HC-SR04 Modulo di rilevamento della distanza ad ultrasuoni disponibile € 2,25 Breadboard 830 punti - bianco Esaurito € 3,05 Maglione Uomo-Maschio set 65 pezzi disponibile € 3,00 Alimentatore per tagliere Esaurito € 2,25 Arduino Uno R3 - clone disponibile € 11,60 1N4004 Diodo raddrizzatore 400V 1A - 50 pezzi Esaurito € 2,55 Totale € 31,45

Pubblicato da Arashi Sito web

HC-SR04 Sensori a ultrasuoni su scheda Arduino Uno