ESP32-Projekt: Wie einfach es ist, eine eigene App zu erstellen, um einen ESP32 per Bluetooth zu steuern

Eigentlich wollte ich lediglich das 2022 gebaute Fahrzeug mit Arduino plus Bluetooth Modul umbauen auf ein ESP32, um das BT Modul anderweitig zu verwenden.
Doch je tiefer ich über die Möglichkeiten der App-Erstellung für den ESP32 recherchierte, desto spannender fand ich die Idee, eine eigene App zur Steuerung zu erstellen. So wurde aus dem geplanten Umbau ein neues, faszinierendes Projekt. In diesem Artikel zeige ich euch, wie einfach es ist, mit einer individuellen App den ESP32 per Bluetooth zu steuern.

Hardware:
ESP32 Wroom 32
Motortreiber TB6612FNG Modul
Motoren DC 3-6V mit Reifen
AA Batterien 1,5V Halterung plus 4 Batterien

Verdrahtung:

Das TB6612FNG-Modul ist ein kompakter Motortreiber, der zwei Motoren steuern kann. Es verfügt über folgende Anschlüsse und Funktionen:

Motoranschlüsse (A und B): Diese sind für die Verbindung mit den Motoren vorgesehen. Jeder Kanal kann bis zu 3 Ampere kurzzeitig und 1 Ampere dauerhaft liefern.
PWM-Eingänge (PWMA und PWMB): Diese steuern die Geschwindigkeit der Motoren über Pulsweitenmodulation.
Richtungseingänge (AIN1, AIN2, BIN1, BIN2): Diese bestimmen die Drehrichtung der Motoren.
Versorgungsspannung (VM): Hier wird die Motorspannung angeschlossen, die zwischen 4,5 und 13,5 Volt liegen kann.
Logikspannung (VCC): Dieser Anschluss versorgt die Steuerlogik des Moduls mit 2,7 bis 5,5 Volt.
GND: Masseanschluss für die Stromversorgung.
STBY: Dieser Eingang aktiviert oder deaktiviert das Modul.

Moniert wurde es auf selben 3D Druckvorlage des letzten Projektes.

Grundplatte zum ausdrucken auf einem 3D-Drucker:
Arduino Robot Car Chassis 4WD

Verwendeter Sketch:

#include <Arduino.h>
#include "BluetoothSerial.h" // Bibliothek für Bluetooth-Kommunikation

// Steuerpins für Motor A definieren
const int PWMA = 26; // PWM-Steuerung (Geschwindigkeit von Motor A)
const int AIN1 = 13; // Richtungspin 1 für Motor A
const int AIN2 = 14; // Richtungspin 2 für Motor A

// Steuerpins für Motor B definieren
const int PWMB = 25; // PWM-Steuerung (Geschwindigkeit von Motor B)
const int BIN1 = 12; // Richtungspin 1 für Motor B
const int BIN2 = 27; // Richtungspin 2 für Motor B

// Standby-Pin definieren (gemeinsam für beide Motoren)
const int STBY = 33; // Pin für Aktivierung/Deaktivierung des Moduls

// Bluetooth-Objekt erstellen
BluetoothSerial SerialBT; // Bluetooth-Kommunikation mit ESP32

// Variable zur Speicherung der Geschwindigkeit (Standardwert)
int motorSpeed = 200; // Geschwindigkeit zwischen 0 und 255
String currentDirection = "stopp"; // Aktuelle Bewegungsrichtung

void setup() {
  // Pins für Motor A als Ausgänge festlegen
  pinMode(PWMA, OUTPUT);
  pinMode(AIN1, OUTPUT);
  pinMode(AIN2, OUTPUT);

  // Pins für Motor B als Ausgänge festlegen
  pinMode(PWMB, OUTPUT);
  pinMode(BIN1, OUTPUT);
  pinMode(BIN2, OUTPUT);

  // Standby-Pin als Ausgang festlegen und Modul aktivieren
  pinMode(STBY, OUTPUT);
  digitalWrite(STBY, HIGH); // Aktiviert das Motor-Treiber-Modul

  // Bluetooth initialisieren
  Serial.begin(115200); // Baudrate für seriellen Monitor
  SerialBT.begin("ESP32-Auto"); // Geräte-Name für Bluetooth
}

void loop() {
  // Prüfen, ob Daten über Bluetooth empfangen wurden
  if (SerialBT.available()) {
    String befehl = SerialBT.readStringUntil('\n'); // Empfangenes Kommando der App lesen
    befehl.trim(); // Leerzeichen oder Zeilenumbrüche entfernen

    // Empfangene Daten im seriellen Monitor ausgeben
    Serial.println("Empfangenes Kommando: " + befehl);

    if (befehl.startsWith("speed:")) {
      String speedValue = befehl.substring(6); // Extrahiere den Wert nach "speed:"
      motorSpeed = speedValue.toInt(); // Konvertiere den Wert in eine Ganzzahl
      motorSpeed = constrain(motorSpeed, 0, 255); // Begrenze den Wert auf 0-255
      Serial.println("Geschwindigkeit gesetzt auf: " + String(motorSpeed));
    } else if (befehl == "vorwaerts") {
      currentDirection = "vorwaerts";
    } else if (befehl == "rueckwaerts") {
      currentDirection = "rueckwaerts";
    } else if (befehl == "links") {
      currentDirection = "rechts"; 
    } else if (befehl == "rechts") {
      currentDirection = "links"; 
    } else if (befehl == "stopp") {
      currentDirection = "stopp";
    }
  }

  // Bewegungsrichtung ausführen
  if (currentDirection == "vorwaerts") {
    fahreVorwaerts();
  } else if (currentDirection == "rueckwaerts") {
    fahreRueckwaerts();
  } else if (currentDirection == "links") {
    dreheLinks(); // Links ist angepasst
  } else if (currentDirection == "rechts") {
    dreheRechts(); // Rechts ist angepasst
  } else if (currentDirection == "stopp") {
    halteAn();
  }
}

// Funktion: Vorwärtsfahren 
void fahreVorwaerts() {
  digitalWrite(AIN1, LOW); // Linke Räder vorwärts
  digitalWrite(AIN2, HIGH);
  digitalWrite(BIN1, LOW); // Rechte Räder vorwärts
  digitalWrite(BIN2, HIGH);

  analogWrite(PWMA, motorSpeed);
  analogWrite(PWMB, motorSpeed);
}

// Funktion: Rückwärtsfahren 
void fahreRueckwaerts() {
  digitalWrite(AIN1, HIGH); // Linke Räder rückwärts
  digitalWrite(AIN2, LOW);
  digitalWrite(BIN1, HIGH); // Rechte Räder rückwärts
  digitalWrite(BIN2, LOW);

  analogWrite(PWMA, motorSpeed);
  analogWrite(PWMB, motorSpeed);
}

// Funktion: Linksdrehung 
void dreheLinks() {
  digitalWrite(AIN1, LOW); // Linke Räder vorwärts
  digitalWrite(AIN2, HIGH);
  analogWrite(PWMA, motorSpeed / 2); // Langsamere Drehung

  digitalWrite(BIN1, HIGH); // Rechte Räder rückwärts
  digitalWrite(BIN2, LOW);
  analogWrite(PWMB, motorSpeed);
}

// Funktion: Rechtsdrehung
void dreheRechts() {
  digitalWrite(AIN1, HIGH); // Linke Räder rückwärts
  digitalWrite(AIN2, LOW);
  analogWrite(PWMA, motorSpeed);

  digitalWrite(BIN1, LOW); // Rechte Räder vorwärts
  digitalWrite(BIN2, HIGH);
  analogWrite(PWMB, motorSpeed / 2); // Langsamere Drehung
}

// Funktion: Motoren stoppen
void halteAn() {
  analogWrite(PWMA, 0);
  analogWrite(PWMB, 0);

  digitalWrite(AIN1, LOW);
  digitalWrite(AIN2, LOW);
  digitalWrite(BIN1, LOW);
  digitalWrite(BIN2, LOW);
}

Sketch auf den ESP32 laden und mit Batterien in Betrieb nehmen.

Dateien: Sketch und Steuerungszeichen als png-Dateien unter Github

Passende App erstellen:

Im Rahmen meines ESP32-Projekts habe ich mich dazu entschieden, meine erste eigene App zur Steuerung des ESP32 zu erstellen. Dabei habe ich den MIT App Inventor, einen benutzerfreundlichen Online-Editor, verwendet. Der Grund für diese Wahl ist die intuitive Bedienung und die Möglichkeit, ohne tiefgehende Programmierkenntnisse eine voll funktionsfähige App zu erstellen. Der Editor bietet die perfekte Plattform, um kreative Ideen schnell in die Realität umzusetzen.

Gehe auf die MIT App Inventor Website und erstelle ein neues Projekt.
Wähle die passende Betriebssystem-Option, damit die App auf einem ios oder Android Smartphone läuft.

Füge Steuerelemente wie Buttons (z. B. für Vorwärts, Rückwärts, Links, Rechts) und Labels (z. B. Logo) hinzu.
Füge einen List Picker hinzu, um verfügbare Bluetooth-Geräte anzuzeigen.

Erster Entwurf sah noch so aus:

Blöcke programmieren:

Geräteauswahl: Verwende den List Picker, um verfügbare BT-Geräte anzuzeigen und eine Verbindung herzustellen.
Befehle senden: Nutze Blöcke, um Steuerbefehle (z. B. „vorwärts“, „rechts“, „links“, „rückwärts“) über BT an das ESP32 zu senden.
Verbindungsstatus: Implementiere Blöcke, um den Verbindungsstatus anzuzeigen. Beispiel für die Blöcke:
Beim Start der App: Suche nach BT-Geräten und zeige sie im List Picker an.
Beim Auswählen eines Geräts: Stelle eine Verbindung her.
Beim Drücken eines Buttons: Sende den entsprechenden Steuerbefehl.

Erstellte App testen:

Auf dem Smartphone die App „MIT App Inventor“ installiert.
Sketch muss bereits auf den ESP32 geladen worden sein.
Smartphone mit ESP32 per Bluetooth verbinden.
In der WebAplikation auf Verbinden per „AI Companion“ ein Upload auf das Smartphone auslösen.

Angezeigter QR Code abfotografieren oder per Code händig übertragen.
Im Listpicker dann die BT Verbindung auswählen und schon sollte die Steuerung funktionieren.

Youtube Video:

APK-Datei exportieren und auf einem Android-Gerät installieren

Falls du eine eigene App erstellen und unabhängig installieren oder weiter verteilen möchtest, ist dies tatsächlich ganz einfach. Mit ein paar Schritten kannst du eine APK-Datei generieren und auf einem beliebigen Android-Smartphone nutzen:

APK-Datei erstellen
Nachdem du deine App fertiggestellt hast, kannst du mit einer Entwicklungsumgebung wie Android Studio ganz einfach eine APK-Datei exportieren. Das geht über die Option „Erzeugen > Android App (.apk)
Übertragung auf dein Smartphone
Die erstellte APK-Datei kannst du beispielsweise per USB-Kabel, E-Mail oder über einen Cloud-Dienst wie Google Drive auf dein Gerät übertragen.
Installation der APK-Datei
Um die Datei zu installieren, aktiviere auf deinem Gerät unter „Einstellungen“ > „Sicherheit“ die Option, Apps aus unbekannten Quellen zuzulassen. Danach öffnest du die APK-Datei über deinen Dateimanager und folgst den Installationsanweisungen.
App starten und nutzen
Sobald die Installation abgeschlossen ist, kannst du deine App wie gewohnt starten – ganz ohne Play Store.

Update:

Um das Kurvenverhalten meines kleinen Fahrzeuges zu verbessern, sind nun omnidirektionale Räder (Wheels) angebracht worden.