In diesem Tutorial lernst du, wie du den TF-Luna Laser-Entfernungssensor mit einem Arduino oder einem anderen gängigen Mikrocontroller (ESP32/ESP8266) verwendest, um Entfernungen zu messen.
Der TF-Luna ist ein kompakter und genauer LiDAR-/Nähe-Sensor, der Entfernungen von bis zu 8 Metern misst. Er verwendet infrarotes Laserlicht und das Time-of-Flight (ToF)-Prinzip. Durch die Messung der Zeit, die das Licht benötigt, um von einem Objekt reflektiert zu werden, kann er Entfernungen mit hoher Genauigkeit und Geschwindigkeit berechnen.
In dieser Anleitung behandeln wir die Einrichtung, Verkabelung und Programmierung, die nötig sind, um deinen TF-Luna mit Arduino zum Laufen zu bringen.
Benötigte Teile
Du benötigst einen TF-Luna Sensor (siehe unten). Als Mikrocontroller habe ich für dieses Projekt einen Arduino Uno verwendet, aber jeder andere Arduino oder ein ESP32/ESP8266 funktioniert ebenfalls. Außerdem verwenden wir ein OLED-Display, um die vom TF-Luna gemessenen Entfernungen anzuzeigen.
TF-Luna Entfernungssensor
Arduino Uno
USB-Kabel für Arduino UNO
Dupont-Kabelset
Breadboard
OLED-Display
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.
Eigenschaften des TF-Luna
Der TF-Luna Sensor verwendet das Time-of-Flight (TOF)-Prinzip zur Entfernungsmessung. Er sendet periodisch modulierte Nahinfrarotwellen aus und berechnet die Zeit, indem er die Phasendifferenz zwischen der
ursprünglichen Welle und der reflektierten Welle misst. Siehe die folgende Abbildung unten:
Der Betriebsbereich (innen) des Sensors liegt bei 0,2 m bis 8 m mit einer Genauigkeit von ±6 cm @ (0,2-3 m) oder ±2 % @ (3 m-8 m) und einer Auflösung von 1 cm. Der TF-Luna benötigt eine Versorgungsspannung von 3,7 V bis 5,2 V und zieht im Durchschnitt etwa 70 mA, mit einem Spitzenstrom von bis zu 150 mA. Die Kommunikation erfolgt über UART oder I2C. Für weitere Details siehe das unten verlinkte Datenblatt:
TF-Luna als Teil eines LiDAR-Systems
Es gibt viele Anwendungen für Laser-Entfernungssensoren, wie z.B. Parkabstandswarnung, Eindringlingserkennung, Hindernisvermeidung in der Robotik und mehr. Am wichtigsten sind Laser-Entfernungssensoren häufig in LiDAR Systemen, die für Licht Detektion und Reichweitenmessung stehen und zur Erstellung hochpräziser 3D-Karten und Modelle verwendet werden.
Neben dem Laser-Entfernungssensor verfügt ein LiDAR-System typischerweise über eine GPS-Einheit und eine Trägheitsmesseinheit (IMU). Der Scanner ist ein Mechanismus, der den Laserstrahl über ein großes Gebiet bewegt, sodass das System Daten aus verschiedenen Winkeln und Positionen erfassen kann. Die GPS Einheit liefert genaue Standortdaten. Schließlich verfolgt die IMU die Orientierung und Bewegung des LiDAR-Systems, was für die Genauigkeit während des Scannens entscheidend ist.
Während die Laserimpulse ausgesendet und reflektiert werden, zeichnet das System kontinuierlich die Entfernungswerte zusammen mit den entsprechenden Winkeln und Positionen auf. Diese Daten werden dann verwendet, um eine Punktwolke zu erstellen, die die räumliche Verteilung der Objekte im gescannten Bereich darstellt.
Du kannst ein einfaches LiDAR selbst bauen, indem du den Laser-Entfernungssensor an einem Servo befestigst und den Servo benutzt, um die Umgebung zu scannen, während der Sensor die Entfernungen misst. In diesem Tutorial verwenden wir jedoch nur den Laser-Entfernungssensor selbst, ohne ein Scan-Gerät.
Pinbelegung des TF-Luna
Der TF-Luna hat 6 Pins. Das Bild unten zeigt die Seite des Sensors mit dem Anschluss und seinen sechs Pins:
Pin 1 (5V) und Pin 4 (GND) sind für die Stromversorgung. Pins 2 und 3 sind für die I2C- oder UART-Kommunikation. Welches Protokoll verwendet wird, hängt vom Zustand von Pin 5 (CFG) ab. Wenn dieser auf Masse gezogen wird, ist I2C aktiviert. Pin 6 (MUX) liefert ein Datenbereit-Signal, wenn I2C aktiviert ist.
Beachte, dass das Anschlusskabel, das typischerweise mit dem TF-Luna Sensor geliefert wird, willkürliche Farben verwendet. Verlasse dich nicht auf die Farben, um zu erkennen, welches Kabel an welchen Arduino-Pin angeschlossen wird.
Anschluss des TF-Luna
Der TF-Luna Sensor kann über UART oder I2C kommunizieren. Wir verwenden die I2C-Schnittstelle. Verbinde zuerst Pin 1 (VCC) des TF-Luna mit dem 5V-Ausgang des Arduino. Verbinde dann SDA (Pin 2) des TF-Luna mit dem SDA-Pin des Arduino. Anschließend verbinde SCL (Pin 3) des TF-Luna mit dem SCL des Arduino.
Schließlich musst du die Pins 4 und 5 des TF-Luna mit Masse (GND) verbinden. Pin 6 bleibt unverbunden. Siehe das vollständige Schaltbild unten:
Die folgende Tabelle listet alle Verbindungen auf, die du herstellen musst.
| TF-Luna | Arduino |
|---|---|
| Pin 1 (VCC) | 5V |
| Pin 2 (SDA) | SDA |
| Pin 3 (SCL) | SCL |
| Pin 4 (GND) | GND |
| Pin 5 (CFG) | GND |
| Pin 6 (MUX) | nicht verbunden |
Beachte, dass der TF-Luna 5V als Stromversorgung benötigt. Im Gegensatz zu vielen anderen kleinen IR-Abstandssensoren funktioniert er nicht mit 3,3V.
Du kannst ihn jedoch mit einem 3,3V-Mikrocontroller, z.B. einem ESP32, verwenden. Achte nur darauf, den 5V-Ausgang oder eine andere 5V-Stromquelle zu verwenden. Das Bild unten zeigt, wie du den TF-Luna an einen ESP32 C3 Mini anschließt, zum Beispiel:
Im nächsten Abschnitt schreiben wir einfachen Code, um den Sensor zu testen.
Code zum Messen von Entfernungen mit TF-Luna
Bevor du Entfernungen mit dem TF-Luna Sensor messen kannst, musst du eine Bibliothek installieren. Wir verwenden die TFL22C library by Bud Ryerson. Um sie zu installieren, öffne den Library Manager, suche nach „TFLuna“, finde die Bibliothek von Bud Ryerson und installiere sie durch Drücken des „INSTALL“-Buttons.
Mit installierter Bibliothek testen wir den Sensor. Der folgende Code liest die vom TF-Luna Sensor gemessenen Entfernungen aus und gibt sie im Serial Monitor aus.
#include "Wire.h"
#include "TFLI2C.h"
TFLI2C sensor;
void setup() {
Serial.begin(9600);
Wire.begin();
}
void loop() {
int16_t dist;
if (sensor.getData(dist, 0x10)) {
Serial.print("dist:");
Serial.println(dist);
}
delay(100);
}
Der Code beginnt mit dem Einbinden der notwendigen Bibliotheken für die I2C-Kommunikation und den TF-Luna Sensor.
#include "Wire.h" #include "TFLI2C.h"
Die Wire.h Bibliothek wird für die I2C-Kommunikation verwendet, während TFLI2C.h eine spezifische Bibliothek für die Ansteuerung des TF-Luna Sensors ist.
Als nächstes erstellen wir eine Instanz der TFLI2C Klasse, die unseren Entfernungssensor repräsentiert.
TFLI2C sensor;
setup-Funktion
In der setup() Funktion initialisieren wir die serielle Kommunikation und den I2C-Bus.
void setup() {
Serial.begin(9600);
Wire.begin();
}
Der Serial.begin(9600) Befehl startet den Serial Monitor mit einer Baudrate von 9600 bps, sodass wir Daten senden und empfangen können. Der Wire.begin() Befehl initialisiert den I2C-Bus und ermöglicht die Kommunikation mit dem Sensor.
loop-Funktion
In der loop() Funktion lesen wir kontinuierlich die Entfernungsdaten vom Sensor aus.
void loop() {
int16_t dist;
if (sensor.getData(dist, 0x10)) {
Serial.print("dist:");
Serial.println(dist);
}
delay(100);
}
Hier deklarieren wir eine Variable dist vom Typ int16_t, um den Entfernungswert zu speichern. Die sensor.getData(dist, 0x10) Funktion versucht, die Entfernungsdaten vom Sensor zu lesen. Sollte der getData() Aufruf fehlschlagen, findest du die Bedeutungen der error codes im Header der Bibliothek.
Der zweite Parameter 0x10 ist die Standard-I2C-Adresse des Sensors. Der TF-Luna Sensor hat eine konfigurierbare I2C-Adresse (0x08 … 0x77). Wenn du sie ändern möchtest, kannst du die Set_I2C_Addr() Funktion aufrufen.
Wenn die Daten erfolgreich abgerufen wurden, geben wir den Entfernungswert mit Serial.print() und Serial.println() im Serial Monitor aus. Der delay(100) Befehl fügt eine Pause von 100 Millisekunden vor der nächsten Messung ein.
Diese Schleife läuft unendlich und misst sowie zeigt kontinuierlich die vom TF-Luna Sensor erfasste Entfernung an. Wenn du den Code hochlädst und ausführst, solltest du die gemessenen Entfernungen in Zentimetern im Serial Monitor sehen:
Der TF-Luna Sensor kann Entfernungen bis zu 8 m (=800 cm) messen. Darüber hinaus gibt der Code eine Entfernung von 900 aus, was bedeutet, dass kein Objekt erkannt wurde.
Unten siehst du einige Entfernungsmessungen des TF-Luna, dargestellt im Serial Plotter, während ich meine Hand näher und weiter weg bewege:
Im nächsten Abschnitt fügen wir unserem Schaltkreis ein OLED hinzu und zeigen die Entfernungen darauf an, anstatt sie im Serial Monitor auszugeben.
Hinzufügen eines OLED zur Anzeige der TF-Luna Entfernungsdaten
Da das OLED ebenfalls ein I2C-Gerät ist, ist der Anschluss einfach. Wir verbinden SDA und SCL mit denselben Pins, an denen der TF-Luna Sensor angeschlossen ist. Und da das OLED mit 5V betrieben werden kann, können wir auch die Stromversorgungsleitungen teilen.
Code zur Anzeige der vom TF-Luna gemessenen Entfernungen auf dem OLED
Der folgende Code liest die Entfernungswerte vom TF-Luna Sensor aus und zeigt sie auf dem OLED an. Schau dir zuerst den kompletten Code an, danach besprechen wir die Details.
#include "Wire.h"
#include "TFLI2C.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
TFLI2C sensor;
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void display() {
static char text[30];
static int16_t dist;
if (sensor.getData(dist, 0x10)) {
sprintf(text, "%4d cm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
}
void setup() {
Wire.begin();
oled_init();
}
void loop() {
display();
delay(100);
}
Bibliotheken und Display-Initialisierung
Wir beginnen mit dem Einbinden der Wire-Bibliothek für die I2C-Kommunikation, TFL22C library für den Sensor und Adafruit_SSD1306 Library für das OLED-Display. Dann erstellen wir das oled Objekt und das sensor Objekt.
#include "Wire.h" #include "TFLI2C.h" #include "Adafruit_SSD1306.h" Adafruit_SSD1306 oled(128, 64, &Wire, -1); TFLI2C sensor;
Falls du die Adafruit_SSD1306 Library noch nicht installiert hast, musst du das tun. Installiere sie einfach wie gewohnt über den Library Manager:
oled_initsetup-Funktion
Die oled_init() Funktion initialisiert das Display, löscht es, setzt die Textgröße und die Textfarbe.
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Beachte, dass die I2C-Adresse für das OLED-Display auf 0x3C in oled.begin() gesetzt ist. Die meisten dieser kleinen OLEDs verwenden diese Adresse (or 0x27), aber deine könnte anders sein. Wenn du nichts auf dem OLED siehst, hat es höchstwahrscheinlich eine andere I2C-Adresse und du musst die Adresse ändern.
Wenn du die I2C-Adresse nicht kennst, schau dir das How to Interface the SSD1306 I2C OLED Graphic Display With Arduino Tutorial an, um sie herauszufinden. Auch das Use SSD1306 I2C OLED Display With Arduino Tutorial erklärt mehr zur Verwendung eines OLED.
display-Funktion
Die display() Funktion ruft sensor.getData() auf, um die Entfernungsmessung vom TF-Luna Sensor zu erhalten. Dann löscht sie das Display und gibt die Entfernung aus. Die sprintf() Funktion wird verwendet, um den Entfernungswert in einen formatierten Text umzuwandeln.
void display() {
static char text[30];
static int16_t dist;
if (sensor.getData(dist, 0x10)) {
sprintf(text, "%4d cm", dist);
oled.clearDisplay();
oled.setCursor(20, 25);
oled.print(text);
oled.display();
}
}
Wenn du ein Objekt vor den Sensor hältst, sollte das Display die gemessene Entfernung in Zentimetern anzeigen. Siehe das folgende Beispiel unten.
setup-Funktion
In der setup() Funktion rufen wir zuerst Wire.begin() auf, um die I2C-Kommunikation zu starten, und dann oled_init(), das das OLED initialisiert.
void setup() {
Wire.begin();
oled_init();
}
loop-Funktion
Die loop() Funktion ruft einfach alle 100 ms die display() Funktion auf.
void loop() {
display();
delay(100);
}
Und das war’s. Mit dem TF-Luna kannst du Entfernungen von 3 cm bis 800 cm messen, wobei Entfernungen unter 20 cm nicht sehr genau sind.
Fazit
In diesem Tutorial hast du gelernt, wie du den TF-Luna Entfernungssensor mit einem Arduino benutzt, um Entfernungen zu messen und sie auf einem OLED anzuzeigen.
Im Gegensatz zu anderen Time-of-Flight Sensoren wie dem VL53L0X, dem VL53L1X oder dem TOF10120 ist der TF-Luna größer, benötigt 5V als Stromversorgung, hat aber eine viel größere Reichweite. Die Auflösung liegt jedoch nur im Zentimeterbereich (nicht Millimeter) und der Sensor ist teurer. Wenn du noch mehr Reichweite brauchst und bereit bist, mehr Geld auszugeben, schau dir den TFmini-S an, der eine Reichweite von bis zu 12 m hat!
Andere gängige Infrarot-Abstandssensoren wie der GP2Y0A710K0F oder der GP2Y0A21YK0F sind ähnlich groß, verwenden aber Triangulation zur Abstandsermittlung basierend auf dem Winkel des reflektierten IR-Lichts und haben eine viel kürzere Reichweite.
Der TF-Luna eignet sich am besten für die Langstreckenerkennung von Objekten im Außenbereich. Beachte jedoch, dass die Rückseite des Sensors nicht vergossen ist und du die Elektronik schützen musst, wenn du ihn draußen verwendest.
Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.
Viel Spaß beim Tüfteln ; )
