Sensore di parcheggio con CrowPanel ESP32 Display

In questo tutorial imparerai come costruire un sensore di parcheggio con il TOF10120 IR Laser Distance Sensor e un CrowPanel 3.5″ ESP32 Display Un sensore di parcheggio aiuta i conducenti a evitare ostacoli durante le manovre, ad esempio misurando la distanza tra l’auto e il muro del garage.

Il breve video qui sotto mostra il sensore di parcheggio. Illustra come le distanze vengono misurate in centimetri e come impostare la distanza per l’allarme di prossimità (colore rosso):

Il sensore TOF10120 usa la tecnologia time-of-flight. Emette un fascio laser a infrarossi e misura quanto tempo impiega il fascio a tornare dopo aver colpito un oggetto. Questo intervallo temporale viene convertito in distanza.

Il microcontrollore ESP32 integrato nel CrowPanel Display elabora i dati del sensore TOF10120. Calcola la distanza e prepara le informazioni per la visualizzazione.

Infine, il display TFT del CrowPanel mostra la distanza in tempo reale. Fornisce l’output visivo, permettendo al guidatore di vedere a che distanza si trova dagli ostacoli.

Nelle sezioni successive imparerai come collegare il sensore TOF10120 al CrowPanel Display e come programmarlo per mostrare le informazioni di distanza. Iniziamo con i componenti necessari.

Componenti necessari

Oltre al sensore TOF10120, avrai bisogno del CrowPanel 3.5″ ESP32 Display di ELECROW e dell’Arduino IDE. Anche alcuni cavi Dupont per collegare sensore e display saranno utili.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Caratteristiche del CrowPanel 3.5″ ESP32 Display

Il CrowPanel 3.5″ ESP32 Display è uno schermo touch resistivo con display TFT a risoluzione 480*320 e un integrato ESP32-WROVER-B come processore di controllo. Puoi ottenere il display con un involucro in acrilico (vedi immagine sotto), il che significa che non devi costruire un case da solo.

Oltre a questo, la scheda dispone di uno slot per TF card, un’interfaccia UART, un’interfaccia I2C, un’interfaccia per speaker, un connettore per batteria con funzione di ricarica e una piccola porta GPIO con due pin GPIO. Vedi il pinout qui sotto:

La tabella seguente elenca quali pin GPIO sono assegnati a ciascuna delle tre interfacce IO.

GPIO_D	IO25; IO32
UART	RX(IO16); TX(IO17)
I2C	SDA(IO22); SCL(IO21)

La scheda può essere alimentata tramite la porta USB (5V, 2A) oppure collegando una batteria LiPo standard da 3.7V al connettore BAT. Fai attenzione alla polarità del connettore e della batteria. Se il cavo USB e la batteria sono collegati contemporaneamente, la scheda caricherà la batteria (corrente massima di carica 500mA).

Puoi programmare la scheda usando vari ambienti di sviluppo come Arduino IDE, Espressif IDF, Lua RTOS e Micro Python, ed è compatibile con il LVGL graphics library. Tuttavia, in questo tutorial useremo l’Arduino IDE e il TFT_eSPI graphics library.

Caratteristiche del TOF10120

Il sensore di distanza Time-of-Flight TOF10120 è molto piccolo (10mm x 13mm), ad alta precisione e utilizza luce infrarossa per misurare le distanze.

Si basa sul principio Time-of-Flight (ToF), in cui il sensore emette impulsi luminosi e misura il tempo necessario al ritorno della luce riflessa per calcolare la distanza. Il TOF10120 ha una portata fino a 180 cm e opera a una lunghezza d’onda di 940nm. L’immagine sotto mostra il cono del LED laser che emette l’impulso luminoso e il cono di vista del rilevatore che registra la luce riflessa.

Il TOF10120 funziona a 3V–5V, con un basso consumo medio di corrente di soli 35 mA. La lista seguente riassume le sue caratteristiche principali:

• Intervallo operativo: 100-1800mm
• Errore di misura: fino al 5%
• Misurazione ad alta velocità: max 30ms
• Interfaccia di comunicazione: UART / I2C
• Parametri di trasmissione UART: 9600 8n1
• Lunghezza d’onda: 940 nm
• Campo visivo: 25°
• Immunità alla luce ambientale: 50k lux
• Gamma di tensione: 3V a 5V
• Consumo medio di corrente: 35 mA

La specifica sopra e il datasheet indicano che la distanza minima misurabile è 100mm. Tuttavia, ho riscontrato che è possibile ottenere misure fino a 10mm e fino a 2000mm, ma sotto i 30mm le letture diventano molto imprecise.

Il TOF10120 comunica con i microcontrollori tramite interfaccia I2C o UART. L’immagine sotto mostra il pinout. SDA e SCL sono per l’interfaccia I2C e RxD e TxD per la comunicazione UART.

Nella sezione successiva imparerai come collegare il TOF10120 al CrowPanel Display.

Collegare il TOF10120 al CrowPanel Display

Il CrowPanel Display ha una porta I2C e viene fornito con un connettore codificato a colori. Ground è nero, l’alimentazione 3.3V è rossa, SCL è bianco (grigio) e SDA è gialla. Collega Ground al pin 1, 3.3V al pin 2, SDA al pin 5 e SCL al pin 6 del TOF10120 come mostrato sotto:

Nota che i pin 3 e 4 (RxD, TxD) del TOF10120 non sono collegati, poiché non stiamo usando l’interfaccia UART ma l’I2C.

L’immagine sotto mostra il cablaggio, seppur un po’ disordinato, del TOF10120 con CrowPanel usando i connettori forniti e alcuni cavi Dupont.

La buona notizia è che non serve una breadboard né saldare alcun filo.

Test del sensore TOF10120

Prima di implementare qualcosa di complesso è meglio verificare che il sensore sia collegato correttamente e funzioni. Per farlo, prima dobbiamo installare una libreria per leggere le misure di distanza dal sensore TOF10120.

Installare la libreria TOF10120

Per installare la libreria TOF10120 vai al tof10120_arduino_lib repo e clicca sul pulsante verde “Code”. Poi clicca su “Download Zip” come mostrato sotto:

Nel Arduino IDE crea il seguente codice di test:

#include "TOF10120.h"

TOF10120 sensor = TOF10120();

void setup() {
  Serial.begin(9600);
  sensor.init();
}

void loop() {
  Serial.print("distance:");
  Serial.println(sensor.distance());
  delay(100);
}

Poi vai su “Sketch” -> “Include Library” -> “Add .Zip Library..” e seleziona il file “tof10120_arduino_lib-main.zip” che hai appena scaricato:

Il codice di test è molto semplice. Per prima cosa include la libreria TOF10120 e crea il TOF10120 sensor oggetto. Nella setup() funzione il sensore viene inizializzato e nella loop() funzione chiamiamo infine sensor.distance() per leggere la distanza misurata dal sensore.

Esegui il codice di test per TOF10120 sensor

Nell’Arduino IDE seleziona “ESP32 Dev Module” come scheda e assicurati che il CrowPanel Display sia collegato alla porta USB e visibile nell’Arduino IDE.

Ora carica il codice sul tuo CrowPanel Display e dovresti vedere i valori di distanza stampati sul Serial Monitor. Se non c’è alcun oggetto davanti al sensore vedrai stampato 2000mm, e se il sensore non viene trovato vedrai -1.

Se hai problemi e il sensore sembra non funzionare assicurati che il cablaggio sia corretto e che siano usati i pin SDA e SCL giusti. Puoi anche controllare il diodo laser del sensore scattando una foto con una fotocamera digitale (telefono). Mentre la luce IR è invisibile all’occhio umano, la fotocamera la può vedere. L’immagine sotto mostra il TOF10120 con il diodo IR chiaramente illuminato:

Se il sensore TOF10120 funziona e vedi le misure di distanza, possiamo iniziare con la struttura del progetto per il codice principale.

Creare la struttura del progetto

In questa sezione creiamo la struttura del progetto e la configurazione per il TFT_eSPI library che è necessario per controllare il display TFT.

Apri il tuo Arduino IDE e crea un progetto “parking_sensor_display” e salvalo (Save As …). Questo creerà una cartella “parking_sensor_display” con il file “parking_sensor_display.ino” al suo interno. In questa cartella crea un altro file chiamato “tft_setup.h“. La cartella del progetto dovrebbe apparire così

e nel tuo Arduino IDE dovresti ora avere due tab chiamate “parking_sensor_display.ino” e “tft_setup.h“.

Clicca sulla scheda “tft_setup.h” per aprire il file e copia il codice seguente al suo interno:

// tft_setup.h
#define ILI9488_DRIVER
#define TFT_HEIGHT  480
#define TFT_WIDTH   320 

#define TFT_BACKLIGHT_ON HIGH
#define TFT_BL   27 
#define TFT_MISO 12
#define TFT_MOSI 13
#define TFT_SCLK 14
#define TFT_CS   15
#define TFT_DC    2 
#define TFT_RST  -1
#define TOUCH_CS 33

#define SPI_FREQUENCY        27000000
#define SPI_TOUCH_FREQUENCY   2500000
#define SPI_READ_FREQUENCY   16000000

#define LOAD_GLCD   // Font 1. Original Adafruit 8 pixel font needs ~1820 bytes in FLASH
#define LOAD_FONT2  // Font 2. Small 16 pixel high font, needs ~3534 bytes in FLASH, 96 characters
#define LOAD_FONT4  // Font 4. Medium 26 pixel high font, needs ~5848 bytes in FLASH, 96 characters
#define LOAD_FONT6  // Font 6. Large 48 pixel font, needs ~2666 bytes in FLASH, only characters 1234567890:-.apm
#define LOAD_FONT7  // Font 7. 7 segment 48 pixel font, needs ~2438 bytes in FLASH, only characters 1234567890:-.
#define LOAD_FONT8  // Font 8. Large 75 pixel font needs ~3256 bytes in FLASH, only characters 1234567890:-.
#define LOAD_GFXFF  // FreeFonts. Include access to the 48 Adafruit_GFX free fonts FF1 to FF48 and custom fonts

Questo codice indica al TFT_eSPI library quale display stiamo usando. In particolare, informiamo la libreria delle dimensioni del display (TFT_WIDTH, TFT_WIDTH), del suo driver (ILI9488_DRIVER), di quali pin SPI vengono usati per controllarlo e di quali font caricare. Senza queste impostazioni non sarà possibile visualizzare nulla sul display.

Per informazioni più dettagliate dai un’occhiata al tutorial CrowPanel 2.8″ ESP32 Display : Easy Setup Guide. Lì spieghiamo come configurare il Display da 2.8″. Ma i passaggi e le descrizioni si applicano anche al Display da 3.5″ nello stesso modo. Solo le impostazioni per le dimensioni dello schermo e il driver sono diverse.

Calibrazione del touchscreen

Il CrowPanel 3.5″ Display è dotato di uno schermo touch resistivo che va calibrato prima di poterlo usare con la libreria TFT_eSPI. Copia il codice qui sotto nel file “parking_sensor_display.ino“, compila e caricalo sul CrowPanel 3.5” Display. Come prima, usa la scheda ESP32 Dev Module come scheda.

#include "tft_setup.h"
#include "TFT_eSPI.h"

TFT_eSPI tft = TFT_eSPI();

void setup() {
  Serial.begin(9600);
  tft.begin();
  tft.setRotation(3);
}

void loop() {
  uint16_t cal[5];
  tft.fillScreen(TFT_BLACK);
  tft.setCursor(20, 0);
  tft.setTextFont(2);
  tft.setTextSize(1);
  tft.setTextColor(TFT_WHITE, TFT_BLACK);
  tft.print("Touch corners ... ");
  tft.calibrateTouch(cal, TFT_MAGENTA, TFT_BLACK, 15);
  tft.println("done.");

  Serial.printf("cal: {%d, %d, %d, %d, %d}\n",
                cal[0], cal[1], cal[2], cal[3], cal[4]);
  delay(10000);
}

Quando il codice è in esecuzione il display mostra una freccia e ti chiede di toccare l’angolo verso cui punta. Questo verrà ripetuto per gli altri tre angoli. Usa la piccola penna gialla fornita con il Display per farlo e cerca di toccare gli angoli il più precisamente possibile.

Al termine della procedura di calibrazione il codice stampa i 5 parametri di calibrazione (coordinate degli angoli e orientamento dello schermo) sul Serial Monitor. Dovresti vedere qualcosa del genere:

cal: { 273, 3534, 286, 3615, 4 }

Copia i parametri da qualche parte, poiché ti serviranno nel codice principale. La calibrazione si ripete ogni 10 secondi, quindi puoi fare diversi tentativi per ottenere i parametri più accurati. Per informazioni più dettagliate sul processo di calibrazione consulta il CrowPanel 2.8″ ESP32 Display : Easy Setup Guide tutorial.

Codice per il sensore di parcheggio

In questa sezione scriviamo il codice principale per il sistema di sensore di parcheggio usando il display CrowPanel ESP32 e il sensore di distanza laser TOF10120. Il sistema misura continuamente la distanza da un oggetto e la mostra sullo schermo, cambiando colore in base alla prossimità dell’oggetto. Un pulsante sul display permette all’utente di impostare una soglia di distanza minima.

Lo screenshot seguente mostra gli elementi principali dell’interfaccia utente:

Dai prima uno sguardo veloce al codice completo, poi entriamo nei dettagli:

#include "stdarg.h"
#include "tft_setup.h"
#include "TFT_eSPI.h"
#include "TOF10120.h"

TFT_eSPI tft = TFT_eSPI();
TOF10120 sensor = TOF10120();

uint16_t cal[5] = { 273, 3534, 286, 3615, 4 };
int minDist = 50;


int getDistance() {
  return sensor.distance() / 10;
}

void drawString(int16_t x, int16_t y, uint8_t font, const char* format, ...) {
  static char buf[64];
  va_list args;
  va_start(args, format);
  vsnprintf(buf, 64, format, args);
  tft.setTextDatum(MC_DATUM);
  tft.drawString(buf, x, y, font);
}

void drawDistance() {
  static char buf[32];
  int dist = getDistance();
  uint32_t color = TFT_GREEN;
  if (dist < minDist * 1.5) color = TFT_YELLOW;
  if (dist < minDist) color = TFT_RED;
  tft.setTextColor(color, TFT_BLACK);
  tft.setTextSize(3);
  drawString(tft.width() / 2, 120, 7, "   %d   ", dist);
}

void drawButton() {
  static bool oldTouch = true;
  int cx = tft.width() / 2;
  int bw = 140, bh = 50, bt = 3;
  int x = cx - bw / 2, y = tft.height() - bh - 10;

  uint16_t tx, ty;
  bool isTouch = tft.getTouch(&tx, &ty);
  isTouch = isTouch && (abs(tx - cx) < bw / 2) && (ty > y);
  if (isTouch == oldTouch) return;
  oldTouch = isTouch;

  tft.fillSmoothRoundRect(x, y, bw, bh, 10, TFT_WHITE);
  if (isTouch) {
    tft.setTextColor(TFT_BLACK, TFT_WHITE, true);
    minDist = getDistance();
  } else {
    tft.fillSmoothRoundRect(x + bt, y + bt, bw - 2 * bt, bh - 2 * bt, 10, TFT_BLACK);
    tft.setTextColor(TFT_WHITE, TFT_BLACK, true);
  }
  drawString(cx, y + bh / 2, 1, "set");
  tft.setTextColor(TFT_SILVER, TFT_BLACK, true);
  drawString(cx, y - 30, 1, "  %d  ", minDist);
}

void setup(void) {
  sensor.init();
  tft.init();
  tft.setRotation(3);
  tft.fillScreen(TFT_BLACK);
}

void loop() {
  drawDistance();
  drawButton();
  delay(100);
}

Suddividiamo il codice nei suoi componenti per una migliore comprensione.

Inclusioni di librerie

Iniziamo includendo le librerie necessarie per il nostro progetto. Queste librerie forniscono le funzionalità richieste per interagire con il display e il sensore di distanza.

#include "stdarg.h"
#include "tft_setup.h"
#include "TFT_eSPI.h"
#include "TOF10120.h"

Inizializzazione degli oggetti

Successivamente, creiamo istanze del display e del sensore. Il TFT_eSPI oggetto tft viene usato per controllare il display, mentre il TOF10120 oggetto sensor viene usato per interagire con il sensore laser di distanza.

TFT_eSPI tft = TFT_eSPI();
TOF10120 sensor = TOF10120();

Calibrazione e distanza minima

Definiamo un array cal per i valori di calibrazione e un intero minDist che imposta la soglia di distanza minima per il sensore. Questa soglia verrà usata per cambiare il colore della distanza visualizzata in base a quanto è vicino un oggetto. I valori di calibrazione provengono dal processo di calibrazione del touchscreen descritto in precedenza.

uint16_t cal[5] = { 273, 3534, 286, 3615, 4 };
int minDist = 50;

Funzione di lettura della distanza

La getDistance() funzione recupera la distanza misurata dal sensore e la converte da millimetri a centimetri dividendo per 10.

int getDistance() {
  return sensor.distance() / 10;
}

Funzione per disegnare stringhe

La drawString() funzione è una utility per mostrare testo formattato sullo schermo. Usa argomenti variabili per formattare la stringa e poi la disegna centrata alle coordinate specificate con un font specifico.

void drawString(int16_t x, int16_t y, uint8_t font, const char* format, ...) {
  static char buf[64];
  va_list args;
  va_start(args, format);
  vsnprintf(buf, 64, format, args);
  tft.setTextDatum(MC_DATUM);
  tft.drawString(buf, x, y, font);
}

Funzione per disegnare la distanza

Nella drawDistance() funzione, prima otteniamo la distanza corrente usando getDistance(). Determiniamo poi il colore del testo in base alla distanza: verde per distanze sicure, giallo per attenzione e rosso per pericolo.

void drawDistance() {
  static char buf[32];
  int dist = getDistance();

  uint32_t color = TFT_GREEN;
  if (dist < minDist * 1.5) color = TFT_YELLOW;
  if (dist < minDist) color = TFT_RED;

  tft.setTextColor(color, TFT_BLACK);
  tft.setTextSize(3);
  drawString(tft.width() / 2, 120, 7, "   %d   ", dist);
}

Infine, mostriamo la distanza con un font grande sullo schermo. I tre screenshot seguenti mostrano tre distanze (in centimetri) nei tre colori differenti:

Funzione per disegnare il pulsante

La drawButton() funzione gestisce la visualizzazione di un pulsante sullo schermo. Controlla l’input touch e aggiorna la soglia di distanza minima quando il pulsante viene premuto.

void drawButton() {
  static bool oldTouch = true;
  int cx = tft.width() / 2;
  int bw = 140, bh = 50, bt = 3;
  int x = cx - bw / 2, y = tft.height() - bh - 10;

  uint16_t tx, ty;
  bool isTouch = tft.getTouch(&tx, &ty);
  isTouch = isTouch && (abs(tx - cx) < bw / 2) && (ty > y);
  if (isTouch == oldTouch) return;
  oldTouch = isTouch;

  tft.fillSmoothRoundRect(x, y, bw, bh, 10, TFT_WHITE);
  if (isTouch) {
    tft.setTextColor(TFT_BLACK, TFT_WHITE, true);
    minDist = getDistance();
  } else {
    tft.fillSmoothRoundRect(x + bt, y + bt, bw - 2 * bt, bh - 2 * bt, 10, TFT_BLACK);
    tft.setTextColor(TFT_WHITE, TFT_BLACK, true);
  }
  drawString(cx, y + bh / 2, 1, "set");
  tft.setTextColor(TFT_SILVER, TFT_BLACK, true);
  drawString(cx, y - 30, 1, "  %d  ", minDist);
}

L’aspetto del pulsante cambia in base al fatto che sia premuto o meno. L’immagine sotto mostra il pulsante “set” quando non è premuto:

Setup Function

Nella setup() funzione inizializziamo il sensore e il display, impostiamo la rotazione del display e riempiamo lo schermo con uno sfondo nero.

void setup(void) {
  sensor.init();
  tft.init();
  tft.setRotation(3);
  tft.fillScreen(TFT_BLACK);
}

Loop Function

Infine, il loop() funzione chiama continuamente drawDistance() e drawButton() per aggiornare il display con la distanza corrente e gestire le interazioni del pulsante. È aggiunto un breve ritardo per evitare aggiornamenti eccessivi.

void loop() {
  drawDistance();
  drawButton();
  delay(100);
}

Conclusioni

In questo tutorial hai imparato come costruire un sensore di parcheggio con il TOF10120 IR Laser Distance Sensor e un CrowPanel 3.5″ ESP32 Display.

Ci sono molte possibili estensioni a questo progetto. Ad esempio, potresti collegare un LED luminoso alla porta GPIO e attivarlo quando viene raggiunta la distanza minima.

Allo stesso modo, potresti usare la porta speaker del CrowPanel Display per far suonare un allarme se un oggetto si avvicina troppo. Esiste infatti un CrowPanel Pico 4.3″ Display basato su RP2040 che ha un buzzer integrato che potresti usare, oppure, naturalmente, puoi collegare un buzzer alla porta GPIO. Vedi il Scribble on CrowPanel Pico 4.3″ Display per maggiori dettagli.

Infine, invece del TOF10120 potresti usare altri sensori di distanza a infrarossi come il comune GP2Y0A710K0F o il GP2Y0A21YK0F. Anche comunemente usato è il sensore di distanza a ultrasuoni HC-SR04 che usa onde sonore per misurare la distanza. Tuttavia, i sensori laser IR sono più precisi e hanno una portata maggiore rispetto ai sensori a ultrasuoni.

Se hai domande sentiti libero di lasciarle nella sezione commenti.

Buona sperimentazione ; )