Sensore ultrasonico HC -SRTOP 10 Micropython - Esptop 10 e Thonny IDE

Il microphon è ampiamente utilizzato con microcontrollori e sistemi incorporati. Possiamo scrivere codice e librerie all'interno di MicroPython IDE e interfaccia più sensori. Questo commento ti guiderà sulla misurazione della distanza usando ESP32 con sensore HC-SR04.

ESP32 con sensore ad ultrasuoni HC-SR04 con microphon

L'interfaccia ESP32 con ultrasuoni richiede solo due fili per essere collegati. Usando i sensori ad ultrasuoni, possiamo misurare la distanza degli oggetti e possiamo innescare risposte in base a questo sistema come la collisione dei veicoli che evitano i sistemi.

Usando Micropython che è un linguaggio progettato per ESP32 e altri microcontrollori possiamo interfacciarci più sensori come il HC-SR04. Verrà scritto il codice Micropython che calcola il tempo impiegato dall'onda Sonar per raggiungere da un sensore all'oggetto e di nuovo all'oggetto. Successivamente usando la formula della distanza, possiamo calcolare la distanza degli oggetti.

Ecco alcuni punti salienti principali del sensore HC-SR04:

Caratteristiche	Valore
Tensione operativa	5v dc
Corrente operativa	15 mA
Frequenza operativa	40kHz
Intervallo min	2 cm/ 1 pollice
Gamma massima	400 cm/ 13 piedi
Precisione	3 mm
Angolo di misurazione	<15 degree

Pinout HC-SR04HC-SR04 contiene seguenti quattro pin:

• VCC: Connettiti a ESP32 VIN PIN
• GND: Connettersi a GND
• Trig: Pin per ricevere il segnale di controllo dalla scheda ESP32
• Eco: Invia il segnale. La scheda microcontrollore riceve questo segnale per calcolare la distanza usando il tempo

Come funziona l'ultrasonico

Dopo che il sensore HC-SR04 è collegato con ESP32 un segnale al Trig PIN sarà generato per bordo. Una volta ricevuto il segnale sul pin trig del sensore HC-SR04, verrà generata un'onda ad ultrasuoni che lascia il sensore e colpisce l'oggetto o il corpo ad ostacoli. Dopo aver colpito, tornerà sulla superficie dell'oggetto.

Una volta che l'onda riflessa torna al sensore che riceve l'estremità, verrà generato un impulso di segnale su pin di eco. ESP32 riceve il segnale PIN ECHO e calcola la distanza tra oggetto e sensore usando Formula a distanza.

La distanza totale calcolata dovrebbe essere divisa per due all'interno del codice ESP32 poiché la distanza che otteniamo originariamente è uguale alla distanza totale dal sensore all'oggetto e di nuovo all'estremità del sensore che riceve. Quindi la distanza reale è il segnale che equivale a metà di quella distanza.

Schema

Di seguito è riportato lo schema per l'interfaccia ESP32 con sensore ad ultrasuoni:

Collegare il grilletto ed eco del sensore con GPIO 5 e GPIO 18 di ESP32 rispettivamente. Collegare anche ESP32 GND e VIN PIN con perni del sensore.

Sensore ultrasonico HC-SR04	ESP32 PIN
Trig	GPIO 5
Eco	GPIO 18
GND	GND
VCC	Vin

Hardware

I seguenti componenti sono tenuti a programmare il sensore ad ultrasuoni:

• ESP32
• HC-SR04
• Breadboard
• Fili jumper

Come configurare HC-SR04 ad ultrasuoni con ESP32 usando il microphon

Prima di poter programmare ESP32 con un sensore ad ultrasuoni, dobbiamo installare una libreria. Connetti la scheda ESP32 al PC. Seguire i passaggi per completare la configurazione ESP32 con il sensore ad ultrasuoni in Thonny IDE usando Micropython.

Passo 1: Ora aperto Thonny Ide. Crea un nuovo file nella finestra Editor Vai a: File> nuovo o premere Ctrl + n.

Una volta aperto il nuovo file, incolla il seguente codice nella finestra dell'editor IDE Thonny.

Macchina di importazione, tempo
dal pin di importazione macchina
Classe HCSR04:
# echo_timeout_us è basato nel limite di gamma chip (400 cm)
def __init __ (self, trigger_pin, echo_pin, echo_timeout_us = 500*2*30):
se stesso.echo_timeout_us = echo_timeout_us
# PIN trigger init (out)
se stesso.trigger = pin (trigger_pin, modalità = pin.Fuori, pull = nessuno)
se stesso.grilletto.valore (0)
# Init echo pin (in)
se stesso.echo = pin (echo_pin, modalità = pin.In, pull = nessuno)
def _send_pulse_and_wait (self):
se stesso.grilletto.Valore (0) # stabilizzare il sensore
tempo.sleep_us (5)
se stesso.grilletto.valore (1)
# Invia un impulso 10U.
tempo.sleep_us (10)
se stesso.grilletto.valore (0)
Tentativo:
pulse_time = macchina.time_pulse_us (self.eco, 1, sé.echo_timeout_us)
restituire pulse_time
Tranne Oserror come ex:
Se ex.Args [0] == 110: # 110 = EtimeDout
Raccogli Oserror ('fuori portata')
sollevare ex
def distange_mm (self):
pulse_time = self._send_pulse_and_wait ()
mm = pulse_time * 100 // 582
restituire mm
def distance_cm (self):
pulse_time = self._send_pulse_and_wait ()
CMS = (pulse_time / 2) / 29.1
restituire CMS

Passo 2: Dopo aver scritto il biblioteca Codice all'interno della finestra Editor ora dobbiamo salvarlo all'interno del dispositivo Micropython.

Passaggio 3: Vai a: File> salva o premere Ctrl + s.

Passaggio 4: Apparirà una nuova finestra. Assicurati che ESP32 sia collegato al PC. Seleziona il dispositivo Micropython per salvare il file della libreria.

Passaggio 5: Salva il file della libreria ad ultrasuoni con il nome HCSR04.Py e clicca OK.

Ora la libreria del sensore HCSR04 ad ultrasuoni viene aggiunta correttamente alla scheda ESP32. Ora possiamo chiamare le funzioni della libreria all'interno del codice per misurare la distanza di oggetti diversi.

Codice per sensore ad ultrasuoni usando il microphon

Per il codice del sensore ad ultrasuoni crea un nuovo file (Ctrl + n). Nella finestra dell'editor, inserisci il codice indicato di seguito e salvalo all'interno del principale.Py O stivale.Py file. Questo codice stamperà la distanza di qualsiasi oggetto che arriva davanti a HC-SR04.

Codice avviato chiamando biblioteche importanti come HCSR04 E tempo biblioteca insieme a sonno per dare ritardi.

Successivamente, abbiamo creato un nuovo oggetto con un nome sensore. Questo oggetto sta prendendo tre diversi argomenti: trigger, eco e timeout. Qui il timeout è definito come il tempo massimo dopo che il sensore è uscito dalla portata.

sensor = hcsr04 (trigger_pin = 5, echo_pin = 18, echo_timeout_us = 10000)

Per misurare e risparmiare distanza un nuovo oggetto chiamato distanza è creato. Questo oggetto salverà la distanza in CM.

Distanza = sensore.Distance_cm ()

Scrivi il seguente codice per ottenere dati in MM.

Distanza = sensore.distance_mm ()

Successivamente, abbiamo stampato il risultato sul guscio IDE MicroPython.

print ("distanza:", distanza, "cm")

Alla fine viene dato un ritardo di 1 sec.

sonno (1)

Il codice completo è riportato di seguito:

da HCSR04 Import HCSR04
Dal tempo Import Sleep
# ESP32
sensor = hcsr04 (trigger_pin = 5, echo_pin = 18, echo_timeout_us = 10000)
# ESP8266
#sensor = hcsr04 (trigger_pin = 12, echo_pin = 14, echo_timeout_us = 10000)
mentre è vero:
Distanza = sensore.Distance_cm ()
print ("distanza:", distanza, "cm")
sonno (1)

Dopo aver scritto e salvato il codice all'interno del dispositivo Micropython, ora eseguo il sensore ad ultrasuoni principale.Py codice file. Fai clic sul pulsante Play o premi F5.

Output del sensore ad ultrasuoni quando l'oggetto è vicino

Ora posiziona un oggetto vicino al sensore ad ultrasuoni e controlla la distanza misurata sulla finestra del monitor seriale di Arduino IDE.

La distanza degli oggetti è mostrata nel terminale della shell. Ora l'oggetto è posizionato a 5 cm dal sensore ad ultrasuoni.

Output del sensore ad ultrasuoni quando l'oggetto è lontano

Ora per verificare il nostro risultato posizioneremo oggetti lontani dal sensore e controlleremo il funzionamento del sensore ad ultrasuoni. Posiziona oggetti come mostrato nell'immagine qui sotto:

La finestra di uscita ci darà una nuova distanza e come possiamo vedere che l'oggetto è lontano dal sensore, quindi la distanza misurata è ca. 15 cm dal sensore ad ultrasuoni.

Conclusione

La distanza di misurazione ha un'ottima applicazione quando si tratta di robotica e altri progetti, ci sono diversi modi per misurare la distanza. HC-SR04 con ESP32 può misurare la distanza di oggetti diversi. Qui questo commento coprirà tutti i passaggi necessari per integrare e iniziare a misurare la distanza con ESP32.