In questo tutorial imparerai come utilizzare il sensore di distanza laser VL6180X con un Arduino o qualsiasi altro microcontrollore comune (ESP32/ESP8266) per misurare distanze fino a 100 mm.
Il VL6180X è un sensore di distanza Time-of-Flight (ToF) molto piccolo che utilizza luce laser a infrarossi per misurare la prossimità di un oggetto. Misurando il tempo impiegato dalla luce per riflettersi su un oggetto, può calcolare distanze con alta precisione. Grazie al suo raggio d’azione relativamente corto, è particolarmente adatto come sensore di prossimità o per un semplice riconoscimento di gesti.
Componenti necessari
Ovviamente, ti servirà un sensore di distanza VL6180X. Per quanto riguarda il microcontrollore, ho usato un Arduino Uno per questo progetto, ma va bene anche qualsiasi altro Arduino o ESP32/ESP8266, dato che il sensore funziona sia a 5V che a 3.3V. Useremo anche un display OLED per mostrare le distanze misurate dal VL6180X.
Sensore di distanza VL6180X
Arduino Uno
Cavo USB per Arduino UNO
Set di fili Dupont
Breadboard
Display OLED
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 VL6180X
Il VL6180X è un chip minuscolo (4.8 x 2.8 x 1.0 mm) con diversi fori sulla parte superiore. Uno è per l’emettitore del laser, uno per il rilevatore della luce laser e c’è anche un rilevatore di luce ambientale. Vedi l’immagine qui sotto:
Il VL6180X funziona emettendo un impulso di luce laser dall’emettitore, ricevendo la luce riflessa da un oggetto nel rilevatore e, basandosi sul tempo impiegato (time-of-flight), calcola la distanza dall’oggetto. L’immagine sotto mostra i coni dell’emettitore (illuminazione) e del rilevatore (vista).
Ecco le principali caratteristiche e specifiche tecniche del VL6180X secondo il datasheet:
Nota che, mentre il datasheet indica un raggio di 100 mm, sono riuscito a misurare distanze fino a 170 mm. D’altra parte, se l’oggetto si avvicina a meno di 10 mm, le letture diventano imprecise.
Schema applicativo del VL6180X
Lo schema applicativo seguente mostra il cablaggio esterno necessario per usare il chip VL6180X. Puoi vedere le resistenze di pull-up per l’interfaccia I2C che collega il VL6180X a un microcontrollore, e due condensatori che stabilizzano la linea di alimentazione a 2.8V.
SDA e SCL sono i pin per l’interfaccia I2C. GPIO0 è il pin di abilitazione del chip. Su sensori laser simili come VL53L1X o VL53L0X questo pin è etichettato come XSHUT (shutdown), che permette di spegnere il sensore quando viene portato a livello basso. Questo è utile se vuoi collegare più sensori sulla stessa linea I2C. GPIO1 è un pin di interrupt che può segnalare al microcontrollore che i dati sono pronti.
Invece di usare direttamente il piccolo chip VL6180X, è meglio procurarsi una breakout board che integra già l’elettronica sopra descritta ed è molto più facile da collegare.
Breakout board per VL6180X
L’immagine seguente mostra la breakout board per il VL6180X. Il chip rettangolare al centro è il VL6180X. La scheda ha anche un regolatore di tensione e level shifter, così puoi collegarla a microcontrollori a 5V o 3.3V.
Il pinout corrisponde in gran parte ai pin mostrati nello schema applicativo. SDA, SCL per I2C, VIN e GND per l’alimentazione e GPIO1 come segnale di interrupt. SHDN (= GPIO0, XSHUT) è il pin di abilitazione/spegnimento del chip. Infine, 2v8 è l’uscita a 2.8V dal regolatore di tensione a bordo, che può fornire fino a 100mA.
Collegare il VL6180X ad Arduino
Grazie all’interfaccia I2C del VL6180X, collegarlo ad Arduino è semplice. Prima collega i pin SCL e SDA della breakout board VL6180X ai corrispondenti pin sull’Arduino come mostrato sotto. Poi collega il GND a massa e il 3.3V al VIN del VL6180X e hai finito.
La breakout board VL6180X funziona a 5V o 3.3V e puoi usare uno dei due per VIN. Ora scriviamo un po’ di codice per testare il funzionamento del sensore VL6180X.
Codice per misurare la distanza con VL6180X
Prima di poter misurare distanze con il sensore VL6180X, devi installare una libreria. Le più comuni sono Adafruit VL6180X Library e VL6180X library by Pololu. Tuttavia, ho avuto problemi con le librerie Adafruit mentre scrivevo il tutorial per il VL53L0X Distance Sensor, quindi userò la VL6180X library by Pololu.
Installare la libreria VL6180X di Pololu
Per installare la VL6180X library by Pololu, cerca semplicemente VL6180X, trova quella di Pololu e installala usando il Library Manager. L’immagine sotto mostra come appare una volta installata la libreria:
Con la libreria installata, proviamo il sensore. Il codice seguente legge le distanze misurate dal VL6180X e le stampa sul monitor seriale.
#include "Wire.h"
#include "VL6180X.h"
VL6180X sensor;
void setup() {
Serial.begin(9600);
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
void loop() {
Serial.println(sensor.readRangeSingleMillimeters());
delay(1000);
}
Diamo un’occhiata più da vicino al codice di esempio sopra.
Inclusione delle librerie
La prima parte del codice include le librerie necessarie per la comunicazione con il sensore.
#include "Wire.h" #include "VL6180X.h"
La libreria Wire.h è usata per la comunicazione I2C, che è il modo in cui Arduino comunica con il sensore VL6180X. La libreria VL6180X.h contiene le funzioni e le definizioni specifiche per il sensore VL6180X, facilitandone l’interazione.
Creazione di un oggetto sensore
Successivamente, creiamo un’istanza della classe VL6180X.
VL6180X sensor;
Questa riga dichiara una variabile chiamata sensor che useremo per accedere ai metodi forniti dalla libreria VL6180X.
Funzione Setup
Nella funzione setup() inizializziamo la comunicazione seriale e il sensore.
void setup() {
Serial.begin(9600);
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
Serial.begin(9600)inizializza la comunicazione seriale a una velocità di 9600 baud, permettendoci di inviare dati al Monitor Serial.Wire.begin()inizializza il bus I2C, abilitando la comunicazione con il sensore.sensor.init()inizializza il sensore VL6180X, preparandolo all’uso.sensor.configureDefault()configura il sensore con le impostazioni di default, assicurandosi che sia pronto per la misurazione della distanza.sensor.setTimeout(500)imposta un timeout per le letture del sensore a 500 millisecondi. Se il sensore non risponde entro questo tempo, restituirà un errore.
Funzione Loop
La funzione loop() legge continuamente la distanza dal sensore e la stampa sul Monitor Serial.
void loop() {
Serial.println(sensor.readRangeSingleMillimeters());
delay(1000);
}
La funzione readRangeSingleMillimeters() legge la distanza misurata dal sensore e la restituisce in millimetri. Questo valore viene poi stampato sul Monitor Serial. Se il sensore non rileva alcun oggetto (fuori portata), verrà stampato il valore 255. Lo screenshot seguente mostra alcune misurazioni di esempio sul Monitor Serial:
La funzione delay(1000) mette in pausa il programma per 1000 millisecondi (1 secondo) prima della lettura successiva, rallentando le letture del sensore.
Nella sezione successiva aggiungeremo un OLED al nostro circuito e visualizzeremo le distanze su di esso, invece di stamparle sul Monitor Serial.
Aggiungere un OLED per visualizzare i dati del VL6180X
Poiché l’OLED è anch’esso un dispositivo I2C, il collegamento è semplice. Basta collegare SDA e SCL agli stessi pin a cui è collegato il sensore VL6180X. E dato che l’OLED funziona a 3.3V, possiamo condividere anche le linee di alimentazione.
Codice per visualizzare le distanze misurate dal VL6180X sull’OLED
Il codice seguente legge le misurazioni di distanza dal sensore VL6180X e le visualizza sull’OLED. Dai prima un’occhiata al codice completo, poi ne discuteremo i dettagli.
#include "Wire.h"
#include "VL6180X.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
VL6180X sensor;
void sensor_init() {
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
static char text[30];
int dist = sensor.readRangeSingleMillimeters();
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
void setup() {
oled_init();
sensor_init();
}
void loop() {
display();
}
Suddividiamo il codice nelle sue parti per una migliore comprensione.
Librerie incluse
All’inizio del codice includiamo le librerie necessarie per la comunicazione I2C (Wire), il sensore VL6180X e il display OLED Adafruit SSD1306.
#include "Wire.h" #include "VL6180X.h" #include "Adafruit_SSD1306.h"
Se non hai ancora installato la Adafruit_SSD1306 Library, dovrai farlo. Basta installarla tramite il Library Manager come al solito:
Inizializzazione degli oggetti
Creiamo istanze del display OLED e del sensore VL6180X. Il display OLED è inizializzato con una larghezza di 128 pixel e un’altezza di 64 pixel.
Adafruit_SSD1306 oled(128, 64, &Wire, -1); VL6180X sensor;
Funzione di inizializzazione del sensore
La funzione sensor_init() inizializza la comunicazione I2C e configura il sensore VL6180X con le impostazioni di default. Imposta anche un timeout di 500 millisecondi per le letture del sensore.
void sensor_init() {
Wire.begin();
sensor.init();
sensor.configureDefault();
sensor.setTimeout(500);
}
Funzione di inizializzazione OLED
La funzione oled_init() inizializza il display OLED. Imposta il display per usare la pompa di carica interna e specifica l’indirizzo I2C (0x3C). La dimensione del testo è impostata a 2 e il colore del testo è bianco.
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Nota che l’indirizzo I2C per il display OLED è impostato a 0x3C in oled.begin(). La maggior parte di questi piccoli OLED usa questo indirizzo, ma il tuo potrebbe essere diverso. Se non vedi nulla sull’OLED, probabilmente ha un indirizzo I2C differente e dovrai cambiarlo. Se non conosci l’indirizzo I2C, dai un’occhiata al tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino.
Funzione di visualizzazione
La funzione display() legge la distanza dal sensore in millimetri e la formatta in una stringa. Poi cancella il display OLED, imposta la posizione del cursore, stampa la distanza e aggiorna il display.
void display() {
static char text[30];
int dist = sensor.readRangeSingleMillimeters();
sprintf(text, "%4d mm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
Se il sensore non riesce a rilevare un oggetto perché fuori portata, sull’OLED verrà mostrato il valore 255 mm:
Funzione Setup
Nella funzione setup() chiamiamo le funzioni di inizializzazione sia per il display OLED che per il sensore per prepararli all’uso.
void setup() {
oled_init();
sensor_init();
}
Funzione Loop
Infine, la funzione loop() chiama continuamente la funzione display(), permettendo di aggiornare in tempo reale le letture di distanza sul display OLED.
void loop() {
display();
}
Il breve video seguente mostra il sensore VL6180X e il display in azione:
Conclusioni
In questo tutorial hai imparato come usare il sensore di distanza VL6180X con un Arduino per misurare distanze e visualizzarle su un OLED.
Il sensore VL6180X è un sensore molto piccolo che usa luce laser a infrarossi per misurare distanze. Il VL6180X è simile ai sensori VL53L1X, VL53L0X e TOF10120 ma ha un raggio d’azione più corto. Se ti serve un sensore per distanze molto più lunghe, dai un’occhiata al TF Luna che può misurare distanze fino a 8 metri.
È più adatto come sensore di prossimità o per semplici gesti che come misuratore di distanza a lungo raggio. Include anche un sensore di luce ambientale integrato, anche se non sono riuscito a ottenere letture dal sensore di luce usando la libreria VL6180X di Pololu.
Se hai domande, sentiti libero di lasciarle nella sezione commenti.
Buon divertimento con il tinkering ; )
