Bemerkung

Hallo und willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Gemeinschaft auf Facebook! Tauchen Sie tiefer ein in die Welt von Raspberry Pi, Arduino und ESP32 mit anderen Enthusiasten.

Warum beitreten?

• Expertenunterstützung: Lösen Sie Nachverkaufsprobleme und technische Herausforderungen mit Hilfe unserer Gemeinschaft und unseres Teams.

• Lernen & Teilen: Tauschen Sie Tipps und Anleitungen aus, um Ihre Fähigkeiten zu verbessern.

• Exklusive Vorschauen: Erhalten Sie frühzeitigen Zugang zu neuen Produktankündigungen und exklusiven Einblicken.

• Spezialrabatte: Genießen Sie exklusive Rabatte auf unsere neuesten Produkte.

• Festliche Aktionen und Gewinnspiele: Nehmen Sie an Gewinnspielen und Feiertagsaktionen teil.

👉 Sind Sie bereit, mit uns zu erkunden und zu erschaffen? Klicken Sie auf [ hier ] und treten Sie heute bei!

Bluetooth-Nachrichtenbox

Dieses Projekt empfängt Nachrichten und zeigt sie auf einem LCD-Bildschirm an.

Sie können es als Familien-Nachrichtentafel nutzen, um Familienmitglieder, die noch nicht gegangen sind, daran zu erinnern, ihre Schlüssel mitzunehmen.

Benötigte Komponenten

Für dieses Projekt benötigen wir die folgenden Komponenten.

Es ist definitiv praktisch, ein ganzes Kit zu kaufen, hier ist der Link:

Name	ARTIKEL IN DIESEM KIT	LINK
Elite Explorer Kit	300+	Elite Explorer Kit

Sie können sie auch separat über die untenstehenden Links kaufen.

KOMPONENTENBESCHREIBUNG	KAUF-LINK
Arduino Uno R4 WiFi	-
Steckbrett	KAUFEN
Jumperkabel	KAUFEN
I2C LCD1602	KAUFEN

Verdrahtung

Schaltplan

UUID generieren

UUIDs spielen eine entscheidende Rolle bei der BLE-Kommunikation und gewährleisten die Einzigartigkeit von Geräten sowie die Genauigkeit des Datenaustauschs zwischen ihnen. Sie müssen UUIDs anpassen, um Ihre eigenen BLE-Dienste und -Merkmale für spezifische Anforderungen zu erstellen. (Hier müssen wir ein Merkmal erstellen, das Texteingaben unterstützt.)

1. Verwenden Sie das Online UUID Generator Tool, um UUIDs zu erstellen, die einzigartig für Sie sind, um UUID-Konflikte zu vermeiden.

2. Erzeugen Sie zwei UUIDs der Version 4.

   
   
   

3. Kopieren Sie sie und ersetzen Sie die beiden UUIDs in Ihrem Code.

   #define SERVICE_UUID "uuid1"
   #define CHARACTERISTIC_UUID "uuid2"
   

Bibliothek installieren

ArduinoBLE.h: Wird für die Verwaltung von Bluetooth Low Energy (BLE) Kommunikation verwendet. LiquidCrystal_I2C.h: Wird verwendet, um einen 16x2-Zeichen-LCD-Bildschirm mit einer I2C-Schnittstelle zu steuern.

Code ausführen

Bemerkung

• Sie können die Datei 07_lightblue_lcd.ino direkt unter dem Pfad elite-explorer-kit-main\iot_project\07_lightblue_lcd öffnen.

• Oder kopieren Sie diesen Code in die Arduino IDE.

Bemerkung

Um die Bibliothek zu installieren, verwenden Sie den Arduino-Bibliotheksmanager, um nach „ArduinoBLE“ und „LiquidCrystal I2C“ zu suchen und diese zu installieren.

07_lightblue_lcd.ino

/*
  The code implements a Bluetooth Low Energy (BLE) peripheral using an Arduino Uno R4 WiFi 
  board. It advertises a BLE service with a custom UUID and a characteristic that can be read 
  and written to. A Liquid Crystal Display (LCD) with an I2C interface is used to display the 
  message when the BLE central device writes to the characteristic. 

  Board: Arduino Uno R4 WiFI
  Component: Liquid Crystal Display 1602 with I2C Interface
  Library: https://www.arduino.cc/reference/en/libraries/liquidcrystal-i2c/ (LiquidCrystal I2C by Frank de Brabander)
           https://www.arduino.cc/reference/en/libraries/arduinoble/ (ArduinoBLE by Arduino)
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <ArduinoBLE.h>

#define SERVICE_UUID "19B10002-E8AA-548E-4F6C-D104768A1214"
#define CHARACTERISTIC_UUID "19B10003-E8AA-548E-4F6C-D104768A1214"

// Define a BLE service with a UUID
BLEService boxService(SERVICE_UUID);

// Define a BLE characteristic with a UUID and properties
char *stringValue = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
BLECharacteristic boxCharacteristic(CHARACTERISTIC_UUID, BLERead | BLEWrite, stringValue);

// Initialize a 16x2 LCD using I2C
LiquidCrystal_I2C lcd(0x27, 16, 2);

void setup() {
  Serial.begin(9600);
  while (!Serial)
    ;
  if (!BLE.begin()) {
    Serial.println("starting Bluetooth® Low Energy module failed!");
    while (1)
      ;
  }

  // Set advertised local name and service UUID:
  BLE.setLocalName("UNO R4 BLE");
  BLE.setAdvertisedService(boxService);
  // Add characteristics to the service
  boxService.addCharacteristic(boxCharacteristic);

  // Add service
  BLE.addService(boxService);

  // Start advertising
  BLE.advertise();
  Serial.println("BLE Peripheral");

  // Initialize the LCD
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Bluetooth LCD");
}

void loop() {
  BLEDevice central = BLE.central();
  if (central) {  // If a central device is connected
    Serial.print("Connected to central: ");
    Serial.println(central.address());

    while (central.connected()) {                      // While the central device is connected
      if (boxCharacteristic.written()) {               // Check if the characteristic has been written
        int length = boxCharacteristic.valueLength();  // Get the length of the written value
        byte buffer[length + 1];                       // Create a buffer to store the value
        boxCharacteristic.readValue(buffer, length);   // Read the value into the buffer
        buffer[length] = '\0';                         // Null-terminate the buffer to treat it as a string
        Serial.print("Characteristic event, written: ");
        Serial.print((char *)buffer);

        // Print the received message to the LCD
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Message:       ");
        lcd.setCursor(0, 1);
        lcd.print((char *)buffer);
      }
    }
    Serial.print("Disconnected from central: ");
    Serial.println(central.address());
  }
}

Wie funktioniert des?

Um mit den in diesem Sketch erstellten Diensten und Merkmalen zu interagieren, sollten Sie eine generische Bluetooth® Low Energy-Zentral-App wie LightBlue (verfügbar für iOS und Android) oder nRF Connect (für Android) verwenden.

Wir verwenden LightBlue als Beispiel, um zu demonstrieren, wie man Arduino’s LED über Bluetooth steuert.

1. Laden Sie die LightBlue-App aus dem App Store (für iOS) oder Google Play (für Android) herunter.

   

2. Verbinden des Arduino mit Ihrem Smartphone über Bluetooth

   Gehen Sie zu Ihren Bluetooth-Einstellungen und suchen Sie das Gerät namens „UNO R4 BLE.“ Stellen Sie eine Verbindung dazu her.

   
   
   

3. Interaktion mit Arduino über Bluetooth mit LightBlue

   Starten Sie LightBlue und tippen Sie auf den Reiter Bonded unten in der Schnittstelle. Hier sehen Sie eine Liste der BLE-Geräte, mit denen Ihr Smartphone zuvor gekoppelt wurde. Finden Sie UNO R4 BLE und tippen Sie auf CONNECT.

   

   Nachdem Sie verbunden sind, erhalten Sie Zugang zu detaillierten Informationen über das Bluetooth-Gerät. Scrollen Sie nach unten, um Ihre Dienst-UUID und Ihre Charakteristik-UUID zu finden.

   Tippen Sie auf die Charakteristik. Sie werden feststellen, dass diese Charakteristik sowohl lesbar als auch beschreibbar ist, was Ihnen erlaubt, sowohl davon zu lesen als auch darauf zu schreiben.

   Scrollen Sie weiter zum Abschnitt „Datenformat“ und ändern Sie ihn auf UTF-8-String. Geben Sie Text in das Textfeld ein und klicken Sie auf schreiben. Die von Ihnen eingegebene Nachricht erscheint auf dem LCD.

   

Wie funktioniert des?

Hier sind die Hauptteile des Codes und Erklärungen ihrer Funktionen:

1. Einbinden der erforderlichen Bibliotheken:

   • ArduinoBLE.h: Wird für die Handhabung von BLE-Kommunikation verwendet.

   • Wire.h: Wird für I2C-Kommunikation verwendet.

   • LiquidCrystal_I2C.h: Wird verwendet, um einen 16x2-Zeichen-LCD-Bildschirm mit einer I2C-Schnittstelle zu steuern.

2. Definieren eines BLE-Dienstes und einer BLE-Charakteristik:

   • Verwenden Sie die Klasse BLEService, um einen BLE-Dienst zu definieren und ihm eine einzigartige UUID zuzuweisen.

   • Verwenden Sie die Klasse BLECharacteristic, um eine BLE-Charakteristik zu definieren, ihr eine einzigartige UUID zuzuweisen und ihr Lese- (BLERead) und Schreibrechte (BLEWrite) zu geben.

   • Erstellen Sie ein Zeichen-Array stringValue als Anfangswert der Charakteristik.

3. Initialisieren eines 16x2-Zeichen-LCD-Bildschirms (LCD):

   • Verwenden Sie die Klasse LiquidCrystal_I2C, um ein LCD zu initialisieren, indem Sie die I2C-Adresse (0x27) und die Anzahl der Zeilen und Spalten (16x2) angeben.

   • Schalten Sie die Hintergrundbeleuchtung des LCD ein, löschen Sie den Bildschirm, bewegen Sie den Cursor zum Anfang der ersten Zeile und zeigen Sie „Bluetooth LCD“ an.

4. Durchführung der Initialisierung in der Funktion setup():

   • Initialisieren der seriellen Kommunikation.

   • Initialisieren des BLE-Moduls und, falls die Initialisierung fehlschlägt, in eine unendliche Schleife eintreten.

   • Setzen des lokalen Namens und der Service-UUID für das BLE-Peripheriegerät.

   • Hinzufügen der BLE-Charakteristik zum BLE-Dienst.

   • Starten der Werbung für den BLE-Dienst, damit zentrale Geräte ihn entdecken und sich damit verbinden können.

   • Initialisieren des LCD.

5. Die Funktion loop():

   • Überprüfen, ob ein zentrales Gerät mit dem BLE-Peripheriegerät verbunden ist, indem BLE.central() aufgerufen wird. Wenn ein zentrales Gerät verbunden ist, in die Logik der Verbindungsbearbeitung eintreten.

   • Im verbundenen Zustand überprüfen, ob Daten in die BLE-Charakteristik geschrieben wurden, indem boxCharacteristic.written() überprüft wird.

   • Wenn Daten geschrieben wurden, die Länge der geschriebenen Daten mit boxCharacteristic.valueLength() ermitteln und ein Byte-Array buffer erstellen, um die geschriebenen Daten zu speichern.

   • Verwenden Sie boxCharacteristic.readValue(), um Daten aus der BLE-Charakteristik in den buffer zu lesen.

   • Ein Nullzeichen '\0' an das Ende des buffer hinzufügen, um es in einen String zu konvertieren.

   • Die empfangene Nachricht auf dem seriellen Monitor ausgeben und auf dem LCD anzeigen.

   • Weiterhin auf das nächste zentrale Gerät warten, das sich verbindet, nachdem das zentrale Gerät getrennt wurde.