Dazu betrachten wir den folgenden einfachen Fall: Die App soll den aktuellen Neigungswinkel des Handys jede 100 ms per Bluetooth an einen Mikrocontroller (in unserem Fall einen TTGO) übermitteln. Dieser soll dann den Neigungswinkel auf dem Terminal anzeigen und zusätzlich diesen Wert (quasi als Kontrolle) wieder an die App zurücksenden, um ihn dort in einem Textfeld anzuzeigen.
Mit dem Neigungswinkel könnte der Mikrocontroller z. B. per PWM die Helligkeit einer LED steuern; damit hätten wir einen per Bluetooth gesteuerten Dimmer realisiert.
Unsere Schritte:
- HC-05-Modul an TTGO anschließen
- TTGO an den PC anschließen
- BE-App starten und mit HC-05-Modul “verbinden” (Connecting)
- Panel mit den erforderlichen Objekten erzeugen
- MicroPython-Programm erstellen
- Test und Analyse der übertragenen Signale
1. HC-05-Modul an TTGO anschließen
| BT-Modul | ESP32 |
| VCC | 5 V |
| GND | G |
| TXD | GPIO 13 (rx von uart1) |
| RXD | GPIO 12 (tx von uart1) |
Dabei entsprechen die Anschlüsse 12 und 13 den Parametern tx und rx bei der Instanziierung des UART-Objekts (vgl. Punkt 5).
2. TTGO an den PC anschließen
Nach dem Anschließen des TTGOs an den PC wird das HC-05-Modul mit Strom versorgt. Die Kontroll-LED des HC-05-Moduls blinkt in rascher Folge auf.
3. Connecting
Starten Sie nun die BE-App auf ihrem Handy. Sollte die App sofort die Panel-Ansicht anzeigen, betätigen Sie dort oben rechts die Schaltfläche “Connecting”. Sie gelangen so auf die Startseite; dort wählen Sie die Option “Bluetooth Classic” aus und betätigen die Schaltfläche “Next >“. Mit Hilfe des nächsten Formulars können Sie die Verbindung herstellen: Zunächst muss das Handy das benutzte HC-05-Modul erkennen und in seine Geräteliste aufnehmen; dies bezeichnet man als Pairing (Koppeln). Danach erscheint der Name dieses HC-05-Moduls in der rechten Liste. Wählen Sie hier durch Antippen Ihr Modul aus und stellen Sie die Verbindung her, indem Sie die Schaltfläche “Connect” betätigen. Ist die Verbindung zustande gekommen, wird dies in der oberen Zeile des Formulars angezeigt; gleichzeitig ändert sich das Blinkverhalten der LED. Mehr dazu in meinen Beiträgen https://www.forum.g-heinrichs.de/viewto ... ?f=12&t=57 und https://www.forum.g-heinrichs.de/viewto ... f=16&t=133. Tippen Sie nun zum Abschießen des Verbindens die Schaltfläche “Done”.
- Abb. 1: Connecting
- Screenshot_3_app.jpg (346.64 KiB) 12141 mal betrachtet
4. Panel mit den erforderlichen Objekten erzeugen
Wir wählen durch Antippen ein freies Panel aus und betätigen die Schaltfläche “Edit”. Nun befinden wir uns im Panel-Editor. Wie in viewtopic.php?f=16&t=133 legen wir aus der Accelerometer-Gruppe ein Roll-Element per Drag and Drop auf das Panel.
In dem Feld unten rechts tippen wir auf die Edit-Schaltfläche. In dem nun angezeigten Editierformular geben wir für das Roll-Element als Start-Kennung den Buchstaben A und als End-Kennung den Buchstaben a ein. Darunter geben wir ein, in welchen Zeitabständen der Roll-Wert gesendet werden soll; wir wählen hier 100 ms. Die Eingabe bestätigen wir mit der OK-Schaltfläche. Insbesondere wenn man mit mehreren unterschiedlichen Messwert-Objekten arbeiten will, ist es sinnvoll Anfangs- und Ende-Tag mit zueinander passenden Groß- und Kleinbuchstaben zu kennzeichnen. Dadurch wird die Auswertung der empfangenen Daten durch den Mikrocontroller übersichtlicher.
Nun legen wir aus der Text-Gruppe ein Text-Feld (mittlerer Größe) auf das Panel. Standardmäßig ist dieses Feld “statisch”, d. h. der beim Editieren eingegebene Wert (Text) bleibt während der Ausführung des Panels unverändert. In unserem Fall soll aber der Mikrocontroller immer wieder den gerade empfangenen Roll-Wert an das Handy senden und dort im Text-Feld anzeigen lassen. Deswegen betätigen wir die zugehörige Edit-Schaltfläche. In dem nun angezeigten Editierformular geben wir als zugehörigen Tag (Receive Character) den Buchstaben R ein. Bei Bedarf kann auch die Ausrichtung der anzuzeigenden Zahl und die Schriftfarbe geändert werden. Die Eingabe bestätigen wir wieder mit der OK-Schaltfläche.
Mit der <-Schaltfläche gelangen wir zurück zur Panel-Übersicht. Von hier aus können wir das Panel mit der Run-Schaltfläche ausführen lassen.
Übrigens: Beim Schließen der App werden sämtliche Panels automatisch (in einer einzigen Datei) gespeichert. Den Namen dieser Datei kann man über das Disketten-Symbol festlegen. Diese Panel-Sammlung wird beim nächsten Start der App automatisch geladen.
5. MicroPython-Programm erstellen
Das folgende Micropython-Programm empfängt mit der Funktion read_roll() fortwährend Roll-Werte und sendet dabei den gerade empfangenen Wert mit der UART-Methode write(...) wieder an das Handy zurück.
Für das Verständnis der Funktionsweise von read_roll() ist wichtig zu wissen: Gelangen Daten über den RXD-Eingang zum TTGO/ESP, so werden sie in einem Puffer abgelegt. Auf diesen Puffer kann über unser Objekt uart1 (s. Programm) zugegriffen werden:
Die any-Methode gibt an, ob sich Daten im Puffer befinden: Ist der Puffer nicht leer, ist der Rückgabewert True, ansonsten False.
Mit der Methode read(n) liest man n Bytes aus dem Puffer. Mit read_message(tag) wird solange ein Byte aus dem Puffer gelesen, bis das im Argument angegebene Tag-Zeichen auftaucht.
Beachten Sie:
- Das hier benutzte HC-05-Modul arbeitet mit 19200 Baud. Wenn Ihr Modul mit 9600 Baud arbeitet, müssen Sie im Programm den baudrate-Parameter bei der Instanziierung entsprechend ändern (vgl. https://www.forum.g-heinrichs.de/viewto ... ?f=12&t=57)
- Beim Inhalt des Puffers handelt es sich um einen Bytestring. Weitere Erläuterungen zur Funktionsweise des Programms entnehmen Sie bitte den Kommentaren.
Code: Alles auswählen
# UART ...
from machine import UART
uart1 = UART(1, baudrate=19200, bits=8, parity=None, stop=1, tx=12, rx=13) # BT1 mit 19200 Baud
# Messen...
def read_message(tag): # liest den Bytestring bis zu dem angegebenen Tag aus dem Lese-Puffer
z = b''
zk = b''
while z != tag:
if uart1.any():
z = uart1.read(1) # readline() nicht mehr nötig
zk = zk + z
return zk
def read_roll():
read_message(b'A') # liest den Byte-String bis zum Tag "A" aus dem Lese-Puffer der UART (und vergisst ihn)
roll = read_message(b'a') # liest den Byte-String bis zum Tag "a" aus dem Lese-Puffer der UART (und speichert ihn in der Variablen roll)
return roll[0:-1] # die Zeichenkette zwischen "A" und "a" (ausschließlich) als Funktionswert zurückgeben
def stop(zk): # stop() liefert True, wenn der Betrag des roll-Werts > 60 ist, sonst False
p = float(zk)
return abs(p) > 60
print('Roll-Werte empfangen und zurückgeben')
print()
zk_roll = b'0'
while not stop(zk_roll): # Schleife wird solange durchlaufen, wie der Betrag des Rollwerts unter 60 liegt
zk_roll = read_roll()
uart1.write(b'*R' + zk_roll) # zur Kontrolle am Handy
print(zk_roll) # zur Kontrolle am Terminal
print('Alles gestoppt!')
6. Test und Analyse der übertragenen Signale
Nach erfolgreicher Verbindung wählen wir unser Panel aus Schritt 4 aus. Bevor es ausgeführt wird, müssen wir den Beschleunigungsmesser (Accelerator) kalibrieren. Dazu tippen wir zunächst auf das Roll-Objekt und dann auf die Calibrate-Schaltfläche (im Feld unten rechts). Anschließend folgen wir den Anweisungen der App. Nach erfolgreicher Kalibrierung betätigen wir das <-Symbol am rechten Rand. Anschließend lassen wir das Panel ausführen.
Nun starten wir das Programm auf dem TTGO. Auf dem Terminal und auch in dem Text-Feld der BE-App werden jetzt die Roll-Werte fortlaufend angezeigt. Wenn der Betrag des Roll-Werts über 60 steigt, wird das Programm angehalten. Abb. 2 zeigt das Signal, welches das HC-05-Modul für einen einzigen Messwert an den TTGO sendet.
- Abb. 2
- roll_1_Wert_ausschnitt.jpg (17.7 KiB) 12122 mal betrachtet
Wie regelmäßig gelangen nun die vom Handy gemessenen Roll-Werte zum TTGO? Um diese Frage zu beantworten, habe ich die RxD-Signale beim TTGO mit einem Logik-Analysator aufgezeichnet. Dabei stellte sich heraus, dass das vorgegebene Zeitintervall von 100 ms nur sehr grob eingehalten wurde (vgl. Abb. 3).
- Abb. 3
- roll_mehrere_Werte_ausschnitt.jpg (16.33 KiB) 12121 mal betrachtet