Il MB1240 XL-MaxSonar-EZ4 è un sensore di distanza ad ultrasuoni ad alte prestazioni con un intervallo da 20 a 765 cm. È un’ottima alternativa al popolare HC-SR04 quando hai bisogno di un migliore filtraggio del rumore e affidabilità. Anche se questo tutorial è scritto per il MB1240, può essere utilizzato anche con altri sensori MaxBotix.
In questo tutorial imparerai come funziona il sensore e come usarlo con un Arduino. Ho incluso 3 esempi con schemi di collegamento che mostrano il funzionamento base del sensore. Esamineremo le diverse uscite del sensore e come attivarlo con un pulsante.
Materiali
Componenti hardware
 | MB1240 XL-MaxSonar EZ4 | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Breadboard | × 1 | Amazon | |
| Jumper wires | ~ 10 | Amazon | |
| Header pins (opzionale) | × 7 | Amazon | |
 | Momentary push button | × 1 | Amazon |
| USB cable type A/B | × 1 | Amazon |
Software
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.
Come funziona un sensore a ultrasuoni?
Un sensore di distanza a ultrasuoni funziona emettendo onde ultrasoniche. Queste onde vengono riflesse da un oggetto e il sensore le rileva. Misurando il tempo trascorso tra l’emissione e la ricezione delle onde sonore, puoi calcolare la distanza tra il sensore e l’oggetto.
Distanza (cm) = Velocità del suono (cm/µs) × Tempo (µs) / 2
Dove Tempo è il tempo tra l’emissione e la ricezione delle onde sonore in microsecondi.
Nota che devi dividere il risultato per due. Questo perché le onde sonore viaggiano dal sensore all’oggetto e poi tornano dall’oggetto al sensore. Quindi la distanza tra il sensore e l’oggetto è solo la metà della distanza percorsa dalle onde sonore.
Per maggiori informazioni su come funzionano i sensori a ultrasuoni, puoi consultare il mio articolo How to use an HC-SR04 Ultrasonic Distance Sensor with Arduino. In questo articolo, i principi di funzionamento di un sensore di distanza a ultrasuoni sono spiegati in modo più dettagliato.
Informazioni sul sensore
Il MB1240 XL-MaxSonar-EZ4 è un sensore di distanza a ultrasuoni prodotto da MaxBotix Inc. MaxBotix è un produttore statunitense specializzato in sensori a ultrasuoni. Producono sensori per ogni tipo di applicazione, sia per uso interno che esterno.
Il MB1240 è uno dei loro sensori più popolari ed è ideale per applicazioni robotiche. La famiglia XL-MaxSonar-EZ ha un’alta tolleranza alle interferenze da rumore acustico o elettrico. Questo significa che puoi usarlo in applicazioni robotiche con più motori e servocomandi.
Il MB1240 che ho usato in questo tutorial ha un intervallo fino a 765 cm e offre una risoluzione di 1 cm. MaxBotix vende anche sensori con risoluzione di 1 mm (HRLV-MaxSonar-EZ) e frequenza di aggiornamento più alta (LV-MaxSonar-EZ). La linea HR di sensori include anche la compensazione interna della temperatura.
Specifiche TM1240 XL-MaxSonar-EZ4
| Tensione di funzionamento | 3.3 – 5.5 V |
| Corrente di funzionamento | 3.4 mA in media (picco 100 mA) |
| Intervallo | (0)* 20 – 765 cm |
| Risoluzione | 1 cm |
| Frequenza | 42 kHz |
| Frequenza di lettura | 10 Hz |
| Uscite del sensore | Tensione analogica, larghezza impulso, RS232 |
| Dimensioni complessive | 22.1 x 19.9 x 25.11 mm |
| Temperatura di funzionamento | 0 – 65 °C |
| Vantaggi | Compatto, leggero, fascio stretto, calibrazione automatica (tensione, umidità, rumore ambientale), filtraggio firmware, facile da usare |
| Prodotto in | USA |
| Costo | Check price |
*Il sensore ha praticamente nessuna zona morta, gli oggetti più vicini di 20 cm vengono rilevati come a 20 cm.
Per maggiori informazioni, puoi consultare il datasheet qui:
Uscite sensori MaxBotix
Come puoi aver visto nella tabella delle specifiche sopra, i sensori MaxBotix della famiglia MaxSonar hanno diverse uscite: tensione analogica, larghezza impulso e seriale RS232 e I2C. In questo tutorial esamineremo sia l’uscita a tensione analogica che quella a larghezza impulso.
Tensione analogica
Questa è probabilmente la modalità più semplice per leggere la distanza misurata dal sensore. L’uscita a tensione analogica del sensore fornisce una tensione lineare che aumenta man mano che un bersaglio si allontana dal sensore.
Possiamo leggere questa uscita con un microcontrollore come Arduino e calcolare la distanza moltiplicando la lettura per un fattore di scala costante (questo fattore dipende dal tipo esatto di sensore, vedi datasheet).
Larghezza impulso
Un’altra opzione è usare l’uscita a larghezza impulso. Questo pin fornisce una rappresentazione della distanza tramite la larghezza di un impulso. Puoi usare la funzione pulseIn() nel codice Arduino per leggere la durata di questo impulso in microsecondi (µs). Per ottenere la distanza, devi moltiplicare questa lettura per un fattore di scala costante. Per il MB1240 (sensori XL-MaxSonar), il fattore di scala è 58 µs/cm. Quindi puoi semplicemente dividere la lettura TOF per 58 per ottenere la distanza in centimetri.
Per altri tipi di sensori, puoi trovare i fattori di scala nei datasheet.
MaxBotix MB1240 vs HC-SR04
Quando cerchi un sensore di distanza a ultrasuoni, probabilmente hai incontrato anche il popolare HC-SR04. Questo sensore a basso costo è disponibile da molti produttori cinesi. L’HC-SR04 e il MB1240 operano su un principio simile, ma ci sono alcune differenze chiave (principalmente in qualità e prezzo).
La prima cosa che potresti notare è la differenza di dimensioni. Il MaxBotix MB1240 usa un solo trasduttore ultrasonico sia per l’emissione che per la ricezione delle onde sonore. L’HC-SR04, invece, ne usa due. Questo significa che il MB1240 è notevolmente più piccolo.
Montare un sensore HC-SR04 può essere difficile e spesso richiede viti piccole, mentre il MB1240 ha due fori per bulloni M3.
Per me, i principali vantaggi dei sensori MaxBotix sono la calibrazione automatica in tempo reale, l’angolo del fascio stretto, l’alta tolleranza al rumore e il filtraggio a bordo.
Il MB1240 ha un fascio molto stretto su tutto il suo intervallo di misura (per oggetti grandi). Questo lo rende ideale per mappare accuratamente una stanza (robot evitatori di ostacoli) e significa che non avrai riflessi precoci da oggetti vicini al sensore. L’HC-SR04 ha un fascio a forma di cono 3D di 15°. Questo significa che non puoi misurare con precisione oggetti lontani dal sensore. Il fascio è semplicemente troppo ampio e rileverà oggetti più vicini.
Inoltre, mi piace il funzionamento continuo dei sensori (ne parleremo più avanti) e l’uscita analogica. L’uscita analogica rende la programmazione dei sensori molto semplice. Queste caratteristiche extra sono molto utili, ma tieni presente che il prezzo è anche abbastanza più alto rispetto ai sensori cinesi. In generale, se cerchi un sensore affidabile e di alta qualità, i sensori MaxBotix potrebbero essere una buona scelta. Per un confronto, guarda la tabella qui sotto.
Tabella di confronto MB1240 vs HC-SR04
| MB1240 | HC-SR04 | |
|---|---|---|
| Tensione di funzionamento | 3.3 – 5.5 V | 5 V |
| Corrente di funzionamento | 3.4 mA in media (picco 100 mA) | 15 mA |
| Intervallo | (0) 20 – 765 cm | 2 – 400 cm |
| Risoluzione | 1 cm | >3 mm |
| Pattern del fascio | see here | Cono 15° |
| Frequenza | 42 kHz | 40 kHz |
| Uscite del sensore | Tensione analogica, larghezza impulso, RS232 | Larghezza impulso |
| Dimensioni | 22.1 x 19.9 x 25.11 mm | 45 x 20 x 15 mm |
| Compensazione temperatura* | No | No |
| Filtraggio | Sì | No |
| Calibrazione automatica in tempo reale | Sì | No |
| Tolleranza al rumore | Alta | Bassa |
| Prodotto in | USA | Cina |
| Prezzo | Check price | Check price |
*Quello che potresti non sapere è che la velocità del suono dipende fortemente dalla temperatura e dall’umidità dell’aria. La velocità del suono nell’aria aumenta di circa 0,6 metri al secondo per ogni grado centigrado.
Sia l’HC-SR04 che il MB1240 non compensano le variazioni di temperatura dell’aria durante il funzionamento. I sensori XL-MaxSonar e LV-MaxSonar assumono una temperatura dell’aria di 22,5 gradi Celsius. La HR line linea HR di sensori include la calibrazione interna della temperatura, quindi non devi aggiungere sensori esterni. Se vuoi vedere un esempio che include un sensore di temperatura per calibrare la velocità del suono in tempo reale, dai un’occhiata al tutorial How to use an HC-SR04 Ultrasonic Distance Sensor with Arduino.
Collegamenti – Connessione MaxBotix MB1240 ad Arduino UNO
Come accennato nell’introduzione, i sensori MaxBotix possono essere usati in diverse modalità. Gli schemi di collegamento qui sotto mostrano come collegare il sensore MB1240 ad Arduino per funzionamento a tensione analogica o larghezza impulso.
Puoi saldare i fili direttamente al sensore, oppure installare dei pin header (come ho fatto io) o un connettore.
Le connessioni sono anche riportate nella tabella seguente:
Connessioni MB1240 – Tensione analogica
| Sensore MaxBotix MB1240 | Arduino |
|---|---|
| GND | GND |
| V+ | 5 V |
| Pin 3 | A0 |
Connessioni MB1240 – Larghezza impulso
| Sensore MaxBotix MB1240 | Arduino |
|---|---|
| GND | GND |
| V+ | 5 V |
| Pin 2 | Pin 2 |
Esempio di codice Arduino MaxBotix MB1240 – Tensione analogica
Con il seguente esempio puoi leggere la distanza misurata e mostrarla sul monitor seriale. Come puoi vedere, il codice è molto semplice ma sotto trovi alcune spiegazioni sul suo funzionamento.
Puoi caricare il codice esempio con l’IDE Arduino.
/* Arduino example code for MaxBotix MB1240 XL-MaxSonar-EZ4
ultrasonic distance sensor: analog voltage output.
More info: www.www.makerguides.com */
#define sensorPin A0
int distance = 0;
void setup() {
Serial.begin(9600);
}
void read_sensor() {
distance = analogRead(sensorPin) * 1;
}
void print_data() {
Serial.print("distance = ");
Serial.print(distance);
Serial.println(" cm");
}
void loop() {
read_sensor();
print_data();
delay(1000);
}
Dovresti vedere il seguente output sul Monitor Seriale (Ctrl + Shift + M).
Come funziona il codice
Il primo passo è definire il pin di collegamento. L’istruzione #define viene usata per assegnare un nome a un valore costante. Quando il programma viene compilato, il compilatore sostituirà ogni riferimento a questa costante con il valore definito. Quindi ovunque menzioni sensorPin, il compilatore lo sostituirà con A0 durante la compilazione.
#define sensorPin A0
Successivamente, dobbiamo creare una variabile per memorizzare la distanza misurata.
int distance = 0;
Nel setup, inizializziamo la comunicazione seriale a 9600 baud. Successivamente mostreremo la distanza misurata nel monitor seriale, accessibile con Ctrl + Shift + M o Tools > Serial Monitor. Assicurati che anche il monitor seriale sia impostato a 9600 baud.
void setup() {
Serial.begin(9600);
}
Dopodiché, ho creato due funzioni: read_sensor e print_data.
Nella funzione read_sensor, leggiamo semplicemente l’uscita a tensione analogica del sensore con la funzione analogRead(pin). Le schede Arduino contengono un convertitore analogico-digitale multicanale a 10 bit. Questo significa che mapperà la tensione in ingresso tra 0 e la tensione di alimentazione in valori interi tra 0 e 1023. Su un Arduino Uno, questo corrisponde a 5 volt / 1024 unità, ovvero 4,9 mV per unità.
Il MB1240 usa un fattore di scala di (Vcc/1024) per cm o 4,9 mV/cm usando un’alimentazione a 5 V. Questo rende molto semplice convertire il valore analogRead in centimetri, puoi semplicemente moltiplicare il risultato per 1 (analogRead(sensorPin) = distanza in centimetri).
void read_sensor() {
distance = analogRead(sensorPin) * 1;
}
Nella funzione print_data, stampiamo la distanza misurata sul monitor seriale.
void print_data() {
Serial.print("distance = ");
Serial.print(distance);
Serial.println(" cm");
}
Nel loop, chiamiamo prima la funzione read_sensor per ottenere la distanza e poi la funzione print_data per inviarla al monitor seriale. Ho aggiunto un ritardo di 1000 millisecondi, ma puoi ridurlo a 100 se vuoi. La frequenza di lettura del MB1240 è 10 Hz, quindi puoi fare 10 letture al secondo.
void loop() {
read_sensor();
print_data();
delay(1000);
}
Esempio di codice Arduino MaxBotix MB1240 – Larghezza impulso
In questo esempio useremo l’altra uscita del sensore: l’uscita a larghezza impulso.
/* Arduino example code for MaxBotix MB1240 XL-MaxSonar-EZ4
ultrasonic distance sensor: pulse width output.
More info: www.www.makerguides.com */
#define sensorPin 2
long distance = 0;
long duration = 0;
void setup() {
pinMode(sensorPin, INPUT);
Serial.begin(9600);
}
void read_sensor() {
duration = pulseIn(sensorPin, HIGH);
distance = duration / 58;
}
void print_data() {
Serial.print("distance = ");
Serial.print(distance);
Serial.println(" cm");
}
void loop() {
read_sensor();
print_data();
delay(1000);
}
Spiegazione del codice
Dopo aver definito il pin di collegamento, ho creato due variabili: duration e distance. Duration memorizza la durata dell’impulso inviato dal sensore. La variabile distance serve a memorizzare la distanza calcolata.
long distance = 0; long duration = 0;
Nel setup, oltre a inizializzare la comunicazione seriale, dobbiamo impostare sensorPin come INPUT. Per questo usiamo la funzione pinMode(pin, mode).
void setup() {
pinMode(sensorPin, INPUT);
Serial.begin(9600);
}
La funzione read_sensor è diversa dall’esempio precedente. Ora non misureremo la tensione analogica, ma la durata dell’impulso inviato dal sensore. Per questo usiamo la funzione pulseIn(pin, value). Questa funzione aspetta che il pin passi da LOW a HIGH, inizia il conteggio, poi aspetta che il pin torni LOW e ferma il conteggio. Restituisce la durata dell’impulso in microsecondi.
Dopodiché, possiamo calcolare la distanza in centimetri dividendo la durata per 58. Per altri sensori MaxBotix, puoi trovare questo fattore di scala nel datasheet.
void read_sensor() {
duration = pulseIn(sensorPin, HIGH);
distance = duration / 58;
}
Il resto del codice è uguale all’esempio precedente.
Modalità di funzionamento con trigger
Tutti i sensori MaxSonar funzionano in modalità free-running di default. Questo significa che il sensore continua a misurare finché è alimentato. Invia venti onde a 42 kHz ogni 99 ms (frequenza di lettura 10 Hz per MB1240, vedi datasheet per altri sensori).
Questa è generalmente la modalità più semplice per usare il sensore, perché non devi attivarlo manualmente e puoi semplicemente leggere la tensione analogica o la larghezza impulso per ottenere la distanza.
Per alcune applicazioni, come l’uso del sensore con batteria, può essere meglio usare un trigger. Questo significa che puoi dire al sensore di iniziare un ciclo di misurazione solo quando gli viene richiesto. In questo modo puoi controllare il massimo assorbimento di corrente, che avviene quando trasmette un impulso sonar.
Per usare il sensore con trigger, useremo un collegamento extra tra il pin 4 del sensore e l’Arduino. Se non colleghi nulla a questo pin, come negli esempi precedenti, il sensore misura alla frequenza di aggiornamento indicata nel datasheet.
Per attivare il sensore quando serve, devi portare il pin 4 a livello logico basso. Quando vuoi fare una lettura, devi portare il pin 4 alto per almeno 20 μs. Il sensore inizierà un ciclo di misurazione.
Lo schema di collegamento qui sotto mostra quali connessioni fare per questo esempio.
In questo esempio useremo un pulsante momentaneo per attivare il sensore. Collega una delle gambe a massa e la gamba diagonalmente opposta al pin 4 di Arduino. Le connessioni sono anche riportate nella tabella sottostante.
Connessioni MB1240 – Modalità trigger
| Pin | Arduino |
|---|---|
| GND | GND |
| V+ | 5 V |
| Pin 2 | Pin 2 |
| Pin 4 | Pin 3 |
| Pulsante pin 1 | Pin 4 |
| Pulsante pin 2 | GND |
Esempio di codice Arduino MaxBotix MB1240 – Trigger con pulsante
Puoi usare questo sketch di esempio per controllare il sensore con un trigger. In questo caso, il sensore farà una lettura quando premi il pulsante e mostrerà la distanza sul Monitor Seriale. Puoi anche chiamare la funzione read_sensor quando vuoi fare una lettura.
/* Arduino example code for MaxBotix MB1240 XL-MaxSonar-EZ4
ultrasonic distance sensor with push button.
More info: www.www.makerguides.com */
#define readPin 2
#define triggerPin 3
#define buttonPin 4
long distance = 0;
long duration = 0;
int buttonState = HIGH;
int previous = HIGH;
long time = 0;
long debounce = 200;
void setup() {
pinMode(readPin, INPUT);
pinMode(buttonPin, INPUT_PULLUP);
pinMode(triggerPin, OUTPUT);
digitalWrite(triggerPin, LOW);
Serial.begin(9600);
delay(3000);
Serial.println("Sensor is ready, waiting for button press!");
}
void read_sensor() {
digitalWrite(triggerPin, HIGH);
delayMicroseconds(20);
digitalWrite(triggerPin, LOW);
duration = pulseIn(readPin, HIGH);
distance = duration / 58;
delay(100);
}
void print_data() {
Serial.print("distance = ");
Serial.print(distance);
Serial.println(" cm");
}
void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState == LOW && previous == HIGH && millis() - time > debounce) {
read_sensor();
print_data();
time = millis();
}
previous = buttonState;
}
Dovresti vedere il seguente output nel Monitor Seriale (Ctrl + Shift + M).
Come funziona il codice
Il primo passo è definire le connessioni. Useremo l’uscita a larghezza impulso del sensore per leggere la distanza.
#define readPin 2 #define triggerPin 3 #define buttonPin 4
Oltre alle variabili duration e distance usate nell’esempio precedente, servono nuove variabili per memorizzare lo stato del pulsante. Le variabili time e debounce servono per il debounce dell’input.
Puoi aumentare il tempo di debounce se ricevi falsi trigger.
long distance = 0; long duration = 0; int buttonState = HIGH; int previous = HIGH; long time = 0; long debounce = 200;
Nel setup, impostiamo triggerPin come output e read e buttonPin come input. Nota che ho usato INPUT_PULLUP nella funzione pinMode. Ci sono resistenze di pullup da 20K integrate nel chip Atmega accessibili via software. Questa impostazione porta buttonPin a HIGH quando non premuto e a LOW quando premi il pulsante.
Successivamente, impostiamo triggerPin a LOW, così il sensore non inizierà a misurare.
Per stampare i dati del sensore, iniziamo la comunicazione seriale a 9600 baud.
void setup() {
pinMode(readPin, INPUT);
pinMode(buttonPin, INPUT_PULLUP);
pinMode(triggerPin, OUTPUT);
digitalWrite(triggerPin, LOW);
Serial.begin(9600);
delay(3000);
Serial.println("Sensor is ready, waiting for button press!");
}
Dopodiché, ho definito due funzioni, read_sensor e print_data.
Nella funzione read_sensor, vedrai che impostiamo triggerPin alto per 20 microsecondi. Questo dice al sensore di inviare un impulso sonar. Poi leggiamo la durata dell’impulso in uscita e la convertiamo in distanza (come nell’esempio precedente). Ho aggiunto un ritardo di 100 ms, che è il tempo minimo tra due letture.
La funzione print_data è uguale a quella degli esempi precedenti.
void read_sensor() {
digitalWrite(triggerPin, HIGH);
delayMicroseconds(20);
digitalWrite(triggerPin, LOW);
duration = pulseIn(readPin, HIGH);
distance = duration / 58;
delay(100);
}
Nel loop, leggiamo prima lo stato del pulsante (premuto / non premuto) e lo memorizziamo in buttonState. La riga successiva verifica se hai premuto il pulsante (cioè se l’input è passato da HIGH a LOW) e se è passato abbastanza tempo dall’ultima pressione per ignorare il rumore.
Se è vero, chiama le funzioni read_sensor e print_data e resetta il timer.
void loop() {
buttonState = digitalRead(buttonPin);
if (buttonState == LOW && previous == HIGH && millis() - time > debounce) {
read_sensor();
print_data();
time = millis();
}
previous = buttonState;
}
Infine, la variabile previous viene aggiornata con l’attuale buttonState.
CAD
MaxBotix fornisce file CAD gratuiti per tutti i loro sensori sul loro sito web. Questo rende molto facile progettare parti o supporti personalizzati da usare con il sensore. Puoi scaricare un file zip con un modello 3D del sensore qui sotto (7 formati diversi). Altri modelli di sensori diversi si trovano sul loro Website.
Conclusione
In questo articolo ti ho mostrato come usare il sensore di distanza a ultrasuoni MaxBotix MB1240 XL-MaxSonar-EZ4 con Arduino.
Se vuoi saperne di più su altri sensori di distanza, gli articoli qui sotto potrebbero esserti utili:
- Waterproof JSN-SR04T Ultrasonic Distance Sensor with Arduino Tutorial
- How to use a SHARP GP2Y0A21YK0F IR Distance Sensor with Arduino
- How to use a SHARP GP2Y0A710K0F IR Distance Sensor with Arduino
- How to use a HC-SR04 Ultrasonic Distance Sensor
Se hai domande, suggerimenti o pensi che manchi qualcosa in questo tutorial, per favore lascia un commento qui sotto.
