Nota

Ciao, benvenuto nella comunità di appassionati di SunFounder Raspberry Pi, Arduino e ESP32 su Facebook! Approfondisci Raspberry Pi, Arduino ed ESP32 insieme ad altri appassionati.

Perché unirti a noi?

Supporto esperto: Risolvi i problemi post-vendita e le sfide tecniche con l’aiuto della nostra comunità e del nostro team.
Impara e Condividi: Scambia consigli e tutorial per migliorare le tue competenze.
Anteprime esclusive: Accedi in anteprima agli annunci di nuovi prodotti e agli sneak peek.
Sconti speciali: Approfitta di sconti esclusivi sui nostri prodotti più recenti.
Promozioni festive e omaggi: Partecipa a giveaway e promozioni festive.

👉 Pronto per esplorare e creare con noi? Clicca [Qui] e unisciti oggi stesso!

Ultrasonico

Panoramica

Quando stai facendo retromarcia, vedrai la distanza tra l’auto e gli ostacoli circostanti per evitare collisioni. Il dispositivo per rilevare la distanza è un sensore ultrasonico. In questo esperimento, imparerai come l’onda ultrasonica rileva la distanza.

Componenti necessari

In questo progetto, abbiamo bisogno dei seguenti componenti.

È sicuramente conveniente acquistare un kit completo, ecco il link:

Nome	ELEMENTI IN QUESTO KIT	LINK
Elite Explorer Kit	300+	Elite Explorer Kit

Puoi anche acquistarli separatamente dai link qui sotto.

INTRODUZIONE AI COMPONENTI	LINK PER L’ACQUISTO
Arduino Uno R4 WiFi	-
Breadboard	ACQUISTA
Cavi Jumper	ACQUISTA
Modulo Ultrasonico	ACQUISTA
LCD1602 I2C	ACQUISTA

Collegamenti

Schema Elettrico

Codice

Nota

Puoi aprire il file 06-ultrasonic.ino dal percorso elite-explorer-kit-main\basic_project\06-ultrasonic direttamente.
Oppure copia questo codice nell’IDE di Arduino.

06-ultrasonic.ino

/*
  This code read the distance from an ultrasonic sensor and display it on 
  an LCD screen. It uses an Arduino Uno R4 board and a 16x2 Liquid Crystal 
  Display (LCD) connected via I2C. The ultrasonic sensor is connected to 
  pins 3 and 4 for echo and trigger, respectively.

  Board: Arduino Uno R4 
  Component: Ultrasonic Module
*/

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);  // initialize the Liquid Crystal Display object with the I2C address 0x27, 16 columns and 2 rows

// Define the pin numbers for the ultrasonic sensor
const int echoPin = 3;
const int trigPin = 4;

void setup() {
  pinMode(echoPin, INPUT);   // Set echo pin as input
  pinMode(trigPin, OUTPUT);  // Set trig pin as output

  lcd.init();       // initialize the LCD
  lcd.clear();      // clear the LCD display
  lcd.backlight();  // Make sure backlight is on
}

void loop() {
  float distance = readDistance();  // Call the function to read the sensor data and get the distance

  lcd.setCursor(0, 0);           //Place the cursor at Line 1, Column 1. From here the characters are to be displayed
  lcd.print("Distance:");        ////Print Distance: on the LCD
  lcd.setCursor(0, 1);           //Set the cursor at Line 1, Column 0
  lcd.print("               ");  //Here is to leave some spaces after the characters so as to clear the previous characters that may still remain.
  lcd.setCursor(7, 1);           //Set the cursor at Line 1, Column 7.
  lcd.print(distance);           // print on the LCD the value of the distance converted from the time between ping sending and receiving.
  lcd.setCursor(14, 1);          //Set the cursor at Line 1, Column 14.
  lcd.print("cm");               //print the unit "cm"

  delay(800);  // Delay for 800 milliseconds before repeating the loop
}

// Function to read the sensor data and calculate the distance
float readDistance() {
  digitalWrite(trigPin, LOW);   // Set trig pin to low to ensure a clean pulse
  delayMicroseconds(2);         // Delay for 2 microseconds
  digitalWrite(trigPin, HIGH);  // Send a 10 microsecond pulse by setting trig pin to high
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);  // Set trig pin back to low

  // Measure the pulse width of the echo pin and calculate the distance value
  float distance = pulseIn(echoPin, HIGH) / 58.00;  // Formula: (340m/s * 1us) / 2
  return distance;
}

Analisi del Codice

1. Inizializzare il sensore ultrasonico e LCD1602

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);  // inizializza l'oggetto del display LCD con l'indirizzo I2C 0x27, 16 colonne e 2 righe

// Definisci i numeri dei pin per il sensore ultrasonico
const int echoPin = 3;
const int trigPin = 4;

void setup() {
  pinMode(echoPin, INPUT);               // Imposta il pin echo come ingresso
  pinMode(trigPin, OUTPUT);              // Imposta il pin trig come uscita

  lcd.init();       // inizializza l'LCD
  lcd.clear();      // pulisce il display LCD
  lcd.backlight();  // Assicurati che la retroilluminazione sia accesa

}

2. Visualizzare la distanza sull’LCD1602

void loop() {
  float distance = readDistance();  // Chiama la funzione per leggere i dati del sensore e ottenere la distanza

  lcd.setCursor(0, 0);         //Posiziona il cursore alla riga 1, colonna 1. Da qui verranno visualizzati i caratteri
  lcd.print("Distance:");      //Stampa "Distance:" sull'LCD
  lcd.setCursor(0, 1);         //Posiziona il cursore alla riga 1, colonna 0
  lcd.print("               ");  //Lascia alcuni spazi dopo i caratteri per cancellare i caratteri precedenti che potrebbero rimanere.
  lcd.setCursor(7, 1);         //Posiziona il cursore alla riga 1, colonna 7.
  lcd.print(distance);         // stampa sull'LCD il valore della distanza convertito dal tempo tra l'invio e la ricezione del ping.
  lcd.setCursor(14, 1);        //Posiziona il cursore alla riga 1, colonna 14.
  lcd.print("cm");             //stampa l'unità "cm"

  delay(800);                       // Ritarda di 800 millisecondi prima di ripetere il loop
}

3. Convertire il tempo in distanza

float readDistance(){// ...}
Qui, «PING» si riferisce al processo in cui il sensore ultrasonico invia un impulso ultrasonico (o «ping») e poi attende il suo eco.

Il PING viene attivato da un impulso HIGH di 2 o più microsecondi. (Dai un breve impulso LOW prima per assicurarti di avere un impulso HIGH pulito.)
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
Il pin echo viene utilizzato per leggere il segnale del PING, un impulso HIGH la cui durata è il tempo (in microsecondi) dall’invio del ping alla ricezione dell’eco dell’oggetto. Utilizziamo la seguente funzione per ottenere la durata.
pulseIn(echoPin, HIGH);
La velocità del suono è di 340 m/s o 29 microsecondi per centimetro.

Questo dà la distanza percorsa dal ping, in uscita e ritorno, quindi dividiamo per 2 per ottenere la distanza dell’ostacolo.
float distance = pulseIn(echoPin, HIGH) / 29.00 / 2;     // Formula: (340m/s * 1us) / 2