Willkommen zu einem weiteren Blogbeitrag in der Reihe, die ein bestimmtes technisches Thema behandelt. Heute nehmen wir uns eine Form der Kommunikation zwischen Geräten vor – die Bluetooth-Technologie (unter Verwendung des Qt Bluetooth-Moduls). Aber wichtiger noch, wir werden uns nicht die klassische Form ansehen, sondern Bluetooth Low Energy (kurz BLE). Wenn Sie ein Projekt haben, das diese Technologie verwendet, lade ich Sie ein, uns zu kontaktieren, wenn Sie Qt-Entwicklungsunterstützung benötigen.

Also ohne weitere Verzögerung, legen wir los!

 

Bluetooth-Technologie – Eine kurze Einführung

Bluetooth-Technologie ist ein drahtloser Kommunikationsstandard, der es Bluetooth-fähigen Geräten ermöglicht, sich zu verbinden und Daten über kurze Distanzen auszutauschen. Entwickelt in den späten 1990er Jahren, hat sie sich zu einem allgegenwärtigen Merkmal moderner elektronischer Geräte entwickelt, einschließlich Smartphones, Laptops, Kopfhörern und Smart-Home-Gadgets. Die Bluetooth Special Interest Group (SIG) legt die Standards für Bluetooth-Technologie fest und stellt deren Kompatibilität und Innovation sicher.

Bluetooth-Technologie arbeitet im 2,4 GHz ISM-Band und nutzt ein Frequenzsprung-Spreizspektrum, um Interferenzen mit anderen drahtlosen Geräten zu minimieren. Im Laufe der Jahre hat sich Bluetooth-Technologie durch mehrere Versionen weiterentwickelt, die jeweils die Datenübertragungsgeschwindigkeit, Reichweite und Energieeffizienz verbessert haben. Die neueste Version (Bluetooth 5.0) hat ihre Reichweite erweitert und die Datenübertragungsraten erhöht, wodurch ihre Rolle im Internet der Dinge (IoT) Ökosystem gestärkt wurde.

Ein wichtiger Vorteil der Bluetooth-Technologie ist ihre Vielseitigkeit. Sie unterstützt eine breite Palette von Anwendungen, von einfachen Dateiübertragungen und Peripheriegeräten bis hin zu komplexem Audio-Streaming und dem Aufbau von Netzwerken. Die Bluetooth-Profile definieren spezifische Anwendungsfälle und gewährleisten die Kompatibilität zwischen Bluetooth-Geräten und ermöglichen nahtlose Interaktionen.

 

Der heutige Star – Bluetooth Low Energy

luBetooth Low Energy (BLE oder Bluetooth LE, manchmal auch Bluetooth Smart) wurde entwickelt, um der steigenden Nachfrage nach drahtloser Kommunikation mit niedrigem Stromverbrauch in batteriebetriebenen Geräten wie Fitness-Trackern, Smartwatches und IoT-Sensoren gerecht zu werden. Das traditionelle klassische Bluetooth, obwohl es eine robuste Verbindung bietet, verbrauchte zu viel Energie für diese Anwendungen.

BLE geht dieses Problem an, indem es den Energieverbrauch erheblich reduziert und es Geräten ermöglicht, über längere Zeiträume mit kleinen Batterien zu arbeiten. Dies erreicht es durch kürzere Kommunikationsintervalle und Schlafmodi zwischen den Übertragungen, wodurch eine zuverlässige Verbindung bei gleichzeitiger Energieeinsparung gewährleistet wird. Das macht BLE ideal für Geräte, die eine lange Akkulaufzeit benötigen, ohne die Leistung zu beeinträchtigen.

 

„Klassisches Bluetooth“ vs. Bluetooth Low Energy

Bluetooth und Bluetooth Low Energy (BLE) sind beide drahtlose Kommunikationstechnologien, die für unterschiedliche Zwecke entwickelt wurden und sich in technischen Merkmalen unterscheiden. Hier ist ein detaillierter Vergleich ihrer wichtigsten Unterschiede.

 

Vergleich von Bluetooth Low Energy

 

Verwendungen von Bluetooth Low Energy und Bluetooth-Geräten

Ich habe bereits erwähnt, dass Bluetooth Low Energy in der IoT-Industrie verwendet wird, aber das ist nicht der einzige Bereich, in dem diese Technologie verwendet wird. Lassen Sie uns sehen, wo sie noch eingesetzt wird.

 

Industrieautomation

Bluetooth Low Energy wird in industriellen Umgebungen für Asset-Tracking, vorausschauende Wartung und Umweltüberwachung genutzt, indem Sensoren und Beacons miteinander verbunden werden, um den Standort, die Leistung und die Bedingungen wie Temperatur und Luftfeuchtigkeit in Echtzeit zu überwachen, was die Betriebseffizienz verbessert und Ausfallzeiten verhindert.

 

Medizin

Im medizinischen Bereich ist Bluetooth Low Energy entscheidend für tragbare Gesundheitsmonitore, medizinische Implantate und Fernüberwachung von Patienten, da Bluetooth-Geräte wie Fitness-Tracker, Herzschrittmacher und Blutzuckermessgeräte Gesundheitsdaten drahtlos an Smartphones und medizinische Datenbanken übermitteln, was eine kontinuierliche und fernab der Klinik durchführbare Gesundheitsüberwachung dank dieser drahtlosen Technologie ermöglicht.

 

Verbraucherelektronik

Bluetooth LE wird umfassend in der Verbraucherelektronik eingesetzt, darunter Smart-Home-Geräte, Audiogadgets (wie Kopfhörer) und tragbare Geräte, um energieeffiziente Konnektivität für die Fernsteuerung von Lichtern, Schlössern und Thermostaten, das Streaming von Audio zu kabellosen Kopfhörern und Lautsprechern sowie das Synchronisieren von Daten von Smartwatches und Fitnessbändern mit mobilen Geräten bereitzustellen.

 

Automobilindustrie

In der Automobilindustrie unterstützt Bluetooth Low Energy schlüssellose Zugangssysteme, Fahrzeug-Sensoren und Infotainmentsysteme, die sicheren, freihändigen Zugang zu Fahrzeugen, die Echtzeit-Übertragung von Diagnosedaten aus verschiedenen Sensoren und die nahtlose Verbindung von Smartphones und Tablets mit den Medien- und Kommunikationssystemen des Fahrzeugs ermöglichen.

 

Internet der Dinge (IoT)

Bluetooth LE ist ein Eckpfeiler der IoT-Anwendungen und ermöglicht intelligente Landwirtschaft, Hausautomation und Asset-Management, indem Sensoren und Geräte miteinander verbunden werden, um die Bodenfeuchtigkeit und den Gesundheitszustand von Pflanzen zu überwachen, automatisierte Routinen für Energieeffizienz zu erstellen und Assets sowie Bestände in Echtzeit in Lagern und Einzelhandelsumgebungen zu verfolgen. Ein Gerät arbeitet in verschiedenen Szenarien. Im Fall von IoT ist der Stromverbrauch besonders wichtig.

 

Coole Demo

Natürlich gibt es noch viele weitere Anwendungen, die hier nicht aufgeführt sind. Aber nun kommen wir zum praktischen Teil. Für diesen Blogbeitrag habe ich mich entschieden, einige Low-Energy-Hardware zu verwenden, die ich zur Verfügung hatte, und es als ein sehr cooles Beispiel für den Einsatz von Bluetooth LE zu verwenden, indem ich einen einfachen Parksensor für mein neues Lamborghini Huracan Evo Spyder baue (natürlich in grün – wie die Farben von Scythe Studio)!

 

https://www.forbes.com/sites/kbrauer/2019/08/05/2020-lamborghini-huracan-evo-spyder-supercars-still-drive-this-supercar-brand/

Ich weiß, ich weiß, Sie sind jetzt wahrscheinlich überrascht, dass ein so luxuriöses Auto keinen Parksensor hat? Ha, und hier kommt die Überraschung! Nun, das tut es nicht, weil mein Auto eine etwas einfachere Version ist… Genauer gesagt dieses…

 

https://www.lego.com/pl-pl/product/lamborghini-huracan-tecnica-42161

Das Projekt umfasst den Bau eines Park Sensors, den ich am Auto anbringe und die Daten auf einer Qt-Anwendung lese, die auf meinem Laptop läuft. Die gesamte Kommunikation erfolgt über Bluetooth Low Energy unter Verwendung des Qt Bluetooth Moduls.

Neben dem Auto habe ich die folgenden angeschlossenen Geräte für diese Demo verwendet (Schaltpläne und ähnliche Erklärungen werden später erläutert):

• ESP32-DevKit-Board (ESP32-WROOM-32)
• HC-SR04-justPi Ultraschallsensor – misst die Entfernung
• OLED blaues Grafikdisplay 1.3’’ 128x64px I2C v2 – blaue Zeichen – SH1106
• 8x Verbindungskabel weiblich-weiblich
• Powerbank
• USB-Kabel

 

Generic Attribute Profile (GATT)

Lassen Sie uns nun die technischere Seite der BLE-Technologie besprechen. Ein Schlüsselmerkmal von BLE’s technischer Gestaltung ist das Generic Attribute Profile (GATT), das definiert, wie Daten zwischen Geräten organisiert und ausgetauscht werden. Es basiert auf dem Konzept einer Client-Server-Architektur, bei der der Server Daten in Form von Attributen speichert und der Client diese Daten abruft.

Im Bluetooth LE basiert die Netzwerktopologie auf einer Sternkonfiguration:

Central (Client): Typischerweise ein Smartphone oder Computer, der die Kommunikation initiiert und Daten anfordert.

Peripheral (Server): Üblicherweise ein Sensor oder tragbares Gerät, das Daten speichert und auf Anfragen des Clients antwortet. Es spielt die zentrale Rolle. Diese Topologie ermöglicht eine effiziente Kommunikation, bei der das zentrale Gerät mehrere Peripheriegeräte gleichzeitig verwalten kann.

In unserem Fall ist der Parksensor-Modul der Server und die Qt-Anwendung, die auf einem Laptop läuft, ist der Client.

 

GATT-Transaktionen

GATT-Transaktionen in BLE sind Operationen zwischen dem Client (Central) und dem Server (Peripheral), die einen zuverlässigen Datenaustausch gewährleisten. Dazu gehören:

Service- und Charakteristik-Entdeckung: Der Client sucht nach verfügbaren Diensten und deren Eigenschaften auf dem Server.

Lese- und Schreiboperationen: Der Client liest Daten von einer Eigenschaft (z. B. aktuelle Entfernung vom Parksensor) oder schreibt Daten in eine Eigenschaft (z. B. Sensor-Einstellungen konfigurieren).

Benachrichtigungen und Indikationen: Der Server informiert den Client, wenn sich der Wert einer Eigenschaft ändert (z. B. Benachrichtigung des Fahrzeug-Systems, wenn der Parksensor eine neue Abstandsmessung erfasst). Benachrichtigungen erfordern keine Bestätigung, Indikationen schon.

 

Schlüsselkomponenten von GATT

GATT-Transaktionen in BLE sind um hochgradig verschachtelte Entitäten aufgebaut, die als Profile, Services und Characteristics bezeichnet werden, wie nachfolgend dargestellt.

 

Gatt Transaktionsspezifikation

• Profile – Ein Profil definiert, wie Geräte Dienste und Eigenschaften für einen bestimmten Zweck zusammen verwenden sollen, um sicherzustellen, dass sie gut miteinander arbeiten. Zum Beispiel standardisiert ein Parking Sensor Profile, wie Parksensoren mit dem Fahrzeug-System kommuniziere.

• Service – Ein Service ist eine Gruppe von verwandten Funktionen oder Datenpunkten auf einem Gerät. Jeder Service hat eine eindeutige ID und kann mehrere Eigenschaften enthalten. Ein Parking Sensor Service könnte beispielsweise Funktionen zur Entfernungsme Messung und Sensorstatus enthalten.

• Characteristic – Eine Characteristic ist ein spezifisches Stück Daten, wie die aktuelle Entfernungsmessung von einem Parksensor. Jede Characteristic hat eine eindeutige ID und kann gelesen, geschrieben oder zum Senden von Updates verwendet werden. Deskriptoren können zusätzliche Details zur Eigenschaft wie deren Maßeinheit bereitstellen.

 

Hardware mit ESP32

Jetzt, wo wir wissen, wie man es macht, lassen Sie uns mit der Montage der Hardware beginnen. Unten sehen Sie ein Beispiel, wie man das Display und den Sensor an das Board anschließt.

Wir beginnen mit dem Abstandssensor auf der linken Seite. Er arbeitet, indem er Ultraschallwellen aussendet. Dieser Sensor hat 4 Pins, die wie folgt angeschlossen sind:

• VCC ↔ VIN (rotes Kabel) – Stromversorgung (5V)
• GND ↔ GND (schwarzes Kabel) – Masse
• TRIG ↔ D26 (gelbes Kabel) – Auslöser, verantwortlich für die Aktivierung des Sensors
• ECHO ↔ D25 (grünes Kabel) – Echo, von diesem Pin lesen wir die Daten

Rechts haben wir das OLED-Display mit einer Auflösung von 128×64. Hier haben wir ebenfalls 4 Pins, die wie folgt verbunden werden:

• VCC ↔ 3V3 (rotes Kabel) – Stromversorgung (3.3V)
• GND ↔ GND (schwarzes Kabel) – Masse
• SCL ↔ D22 (lila Kabel) – CLK, Takt
• Echo ↔ D21 (blaues Kabel) – MOSI Datenübertragung

Nach dem Zusammenbau und dem Anbringen am Auto sieht es so aus.

Software für den Server

Nachdem wir uns mit der Hardware beschäftigt haben, ist es Zeit, etwas zu programmieren. Beginnen wir mit unserem Server, dem Näherungssensor-Modul. Dazu verbinden wir unser ESP32 mit einem Laptop und schreiben den Code in der IDE unserer Wahl (ich habe die Arduino IDE verwendet). Ich habe den Code in separate Abschnitte unterteilt, um ihn leichter verständlich zu machen. Zuerst konzentrieren wir uns nur auf den Abstandssensor selbst.

rel=“nofollow“

constexpr int TRIG_PIN = 26;
constexpr int ECHO_PIN = 25;

float duration_us = 0;
float distance_cm = 0;

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
}

void loop() {
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  duration_us = pulseIn(ECHO_PIN, HIGH);
  distance_cm = 0.017 * duration_us;
}

Die Funktionsweise dieses Codes ist ganz einfach. Zuerst definieren wir die entsprechenden Ein- und Ausgabepins. Dann, in einer Programmschleife, schalten wir den Sensor für einen kurzen Moment ein (10 Mikrosekunden), was dazu führt, dass die Entfernungsinformation am Ausgabepin erscheint. Um den Wert in cm zu erhalten, reicht es aus, den erhaltenen Wert (in Mikrosekunden) mit 0,017 zu multiplizieren (dies stammt aus der Formel für die Entfernung abhängig von der Schallgeschwindigkeit). Jetzt schauen wir uns an, wie man diese Daten über Bluetooth LE überträgt.

rel=“nofollow“

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>

constexpr int TRIG_PIN = 26;
constexpr int ECHO_PIN = 25;

constexpr char *SERVICE_UUID = “a05fde7e-bacb-40b9-9856-efb85cdb8f66”;
constexpr char *CHARACTERISTIC_UUID = “eb99eb2b-048a-4fa7-a81f-4f62ca333f07”;

BLEServer *pServer = nullptr;
BLEService *pService = nullptr;
BLECharacteristic *pCharacteristic = nullptr;
float duration_us = 0;
float distance_cm = 0;

void setup() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);

  BLEDevice::init("Scyhte_ESP32");
  pServer = BLEDevice::createServer();
  pService = pServer->createService(SERVICE_UUID);
  pCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID,
    BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY
  );
  pService->start();

  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);
  pAdvertising->setMinPreferred(0x12);
  BLEDevice::startAdvertising();
}

void loop() {
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);

  duration_us = pulseIn(ECHO_PIN, HIGH);
  distance_cm = 0.017 * duration_us;

  pCharacteristic->setValue(distance_cm);
  pCharacteristic->notify();
}

Das erste, was wir tun, ist, die UUID für unseren Dienst und die Eigenschaften zu definieren. Diese Werte können mit einem im Internet verfügbaren Generator erzeugt werden. Dann erstellen wir unser BLEDevice mit dem Namen Scythe_ESP32. Der nächste Schritt ist, ein Server-Objekt mit Dienst und Eigenschaften darin zu erstellen (in unserem Fall nur eine Eigenschaft mit den Flags READ und NOTIFY). Dann erstellen wir ein BLEAdvertising-Objekt, um unsere Informationen zu senden. Wir setzen die UUID und zusätzliche Parameter und starten unseren Dienst.

Sobald alle erforderlichen Objekte eingerichtet sind, wird unser distance_cm-Wert als Wert der Eigenschaft gesetzt, und mit jeder neuen Abrufung dieses Wertes benachrichtigen wir alle Geräte, die mit dieser Eigenschaft verbunden sind.

 

Software für den Client – Zwei Geräte verbinden

Wir haben bereits einen funktionierenden Server, es war Zeit für den Client. Dazu habe ich mich entschieden, eine einfache Anwendung auf der Grundlage von Qt mit der Qt Bluetooth API und einer GUI, die in QML geschrieben wurde, zu erstellen.

Das Modul und die Qt Bluetooth API umfassen Klassen für die BLE-Gerätesuche, Dienstsuche und Datenübertragung. Mit Qt Bluetooth können Sie Bluetooth-Verbindungen verwalten, nach nahegelegenen Low Energy Geräten suchen und mit Bluetooth-Diensten wie seriellen Ports oder Gesundheitsgeräten interagieren. Qt Bluetooth unterstützt sowohl klassisches Bluetooth als auch Bluetooth Low Energy (BLE), was es vielseitig für verschiedene Arten von Bluetooth-Anwendungen macht. Ein wichtiger Vorteil von Qt Bluetooth ist seine Fähigkeit, sich nahtlos in andere Qt-Module zu integrieren, was eine reibungslose Entwicklungserfahrung für die Erstellung verbundener Anwendungen gewährleistet.

Natürlich wird die Qt Bluetooth API auf verschiedenen Plattformen unterstützt, sodass Sie Ihre App auf einem iOS- oder Android-Mobiltelefon, Desktop oder anderen Plattformen ausführen können. Sie haben sicherlich viele Optionen, Ihre Hauptanwendung mit anderen Bluetooth-Geräten zu verbinden.

Die gesamte Logik befindet sich in einer Klasse – BLEController.cpp:

rel=“nofollow“

#include "BLEController.h"
#include <QTimer>

const QString TARGET_DEVICE_NAME = "Scyhte_ESP32";
const QString SERVICE_UUID = "a05fde7e-bacb-40b9-9856-efb85cdb8f66";
const QString CHARACTERISTIC_UUID = "eb99eb2b-048a-4fa7-a81f-4f62ca333f07";

BLEController::BLEController(QObject *parent)
    : QObject{parent}
{}

void BLEController::startBLE()
{
    discoveryAgent = new QBluetoothDeviceDiscoveryAgent(this);
    connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::deviceDiscovered, this, &BLEController::deviceDiscovered);
    connect(discoveryAgent, &QBluetoothDeviceDiscoveryAgent::finished, this, &BLEController::scanFinished);

    discoveryAgent->start();
}

void BLEController::deviceDiscovered(const QBluetoothDeviceInfo &device)
{
    qDebug() << "Discovered device:" << device.name() << device.address().toString();

    if (device.name() == TARGET_DEVICE_NAME) {
        qDebug() << "Target device found.";
        discoveryAgent->stop();

        controller = QLowEnergyController::createCentral(device, this);
        connect(controller, &QLowEnergyController::connected, this, &BLEController::deviceConnected);
        connect(controller, &QLowEnergyController::disconnected, this, &BLEController::deviceDisconnected);
        connect(controller, &QLowEnergyController::serviceDiscovered, this, &BLEController::serviceDiscovered);
        connect(controller, &QLowEnergyController::discoveryFinished, this, &BLEController::serviceScanDone);

        controller->connectToDevice();
    }
}

void BLEController::scanFinished()
{
    qDebug() << "Device scan finished.";
    if (!controller) {
        qDebug() << "Target device not found.";
    }
}

void BLEController::deviceConnected()
{
    qDebug() << "Connected to device.";
    controller->discoverServices();
}

void BLEController::deviceDisconnected()
{
    qDebug() << "Disconnected from device.";
}

void BLEController::serviceDiscovered(const QBluetoothUuid &newService)
{
    qDebug() << "Service discovered:" << newService.toString();
}

void BLEController::serviceScanDone()
{
    qDebug() << "Service scan done.";
    service = controller->createServiceObject(QBluetoothUuid(SERVICE_UUID), this);
    if (!service) {
        qDebug() << "Service not found.";
        return;
    }

    qDebug() << "Creating service object: " << service->serviceUuid();

    connect(service, &QLowEnergyService::stateChanged, this, [this](const QLowEnergyService::ServiceState &newState){
        qDebug() << "State changed to: " << newState;
        if (newState == QLowEnergyService::RemoteServiceDiscovered) {
            characteristic = service->characteristic(QBluetoothUuid(CHARACTERISTIC_UUID));
            qDebug() << "Characteristic: " << characteristic.uuid();
            if (!characteristic.isValid()) {
                qDebug() << "Characteristic not found.";
                return;
            }
            service->readCharacteristic(characteristic);
        }
    });

    connect(service, &QLowEnergyService::characteristicRead, this, &BLEController::characteristicChanged);
    connect(service, &QLowEnergyService::characteristicChanged, this, &BLEController::characteristicChanged);
    service->discoverDetails();
}

void BLEController::characteristicChanged(const QLowEnergyCharacteristic &characteristic, const QByteArray &value)
{
    if (characteristic.uuid() == QBluetoothUuid(CHARACTERISTIC_UUID)) {
        qDebug() << "Characteristic value changed:" << value;
        m_distance = value.toFloat();
        emit distanceChanged();
        service->readCharacteristic(characteristic);
    }
}

Lassen Sie uns mit der startBLE()-Funktion beginnen, die aufgerufen wird, wenn die entsprechende Taste in der Anwendung gedrückt wird. In dieser sehen wir die Erstellung eines QBluetoothDeviceDiscoveryAgent-Objekts. Dieses Objekt wird verwendet, um alle Bluetooth-Geräte in unserem Bereich zu finden. Falls ein Gerät gefunden wird, wird die Funktion deviceDiscovered() aufgerufen.

In dieser Funktion prüfen wir zunächst, ob das gefundene Gerät den gesuchten Namen (Scythe_ESP32) hat. Falls ja, erstellen wir ein Objekt der Klasse QLowEnergyController, das den Zugriff auf Bluetooth Low Energy Geräte ermöglicht. Wir verbinden dann die entsprechenden Signale mit der Funktion und verbinden uns mit dem Gerät. Am wichtigsten ist die Funktion serviceScanDone().

In dieser Funktion verbinden wir uns mit dem entsprechenden Dienst (basierend auf SERVICE_UUID). Wenn die Verbindung erfolgreich ist, verbinden wir uns mit der entsprechenden Eigenschaft (basierend auf CHARACTERSITIC_UUID). Jetzt müssen wir nur noch die entsprechenden Slots mit den Signalen dieser Eigenschaft verbinden und ihren Wert lesen.

Die Funktion characteristicChanged() wird jedes Mal aufgerufen, wenn sich der Wert einer Eigenschaft ändert (und damit der Abstand sich geändert hat). In diesem Fall lesen wir diesen Wert und propagieren ihn dann an die Benutzeroberfläche.

Wie Sie sehen, bietet die Qt Bluetooth API alles, was wir brauchen, um unsere Anwendung zu erstellen. Wenn Sie mehr interessiert sind, unterstützt das Qt Bluetooth-Modul auch Bluetooth-Mesh-Netzwerke, mit denen große Gerätet Netzwerke mit robusten Kommunikationsfähigkeiten aufgebaut werden können.

Der GUI-Teil ist ziemlich einfach. Wir brauchen nur einen Button, um die Verbindung zum Gerät zu starten und 3 rechteckige Balken, die ihre Farbe basierend auf der Entfernung ändern.

Hier sehen Sie das Endergebnis unserer Arbeit 😉 Ich hoffe, dass Sie beim Lesen dieses Artikels neues Wissen gewonnen haben und den Wind in den Haaren gespürt haben, indem Sie dieses sportliche Lamborghini gefahren sind 😉 Wir laden Sie ein, uns zu kontaktieren, um zu entdecken, wie wir Bluetooth Low Energy Technologie angehen können und von niedrigem Energieverbrauch in Ihrem Fall profitieren können.