Kategorie: ESP32

Gewitter-Monitor zum Dritten

Das Thema scheint mich nicht loszulassen. Zum einen hatten wir dieses Jahr einen Sommer mit vielen Unwettern, so dass ich den alten Gewitter-Monitor wieder einmal aus dem Schrank geholt. Zum anderen habe ich eine Reihe von Anfragen bekommen, ob es eine einfache Nachbau-Möglichkeit gibt. Tatsächlich ist das Projekt etwas in die Jahre gekommen und nicht mehr auf der Höhe der Zeit. So kam die Idee, eine neue Version zu entwickeln, die mehr Möglichkeiten bietet und einfacher nachzubauen ist.

Version 3: Neue Ideen für ein bewährtes Konzept

Das Konzept des Gewitter-Monitors ist schnell erklärt: Zwei AM-Empfänger hören im Langewellenbereich in den Äther, um das typische Knacken von Blitzen zu empfangen. Die Empfänger verwenden Ferritstab-Antennen mit einer Richtungsempfindlichkeit. Deshalb gibt es zwei Antennen, die rechtwinklig zueinander montiert werden, so dass 360 Grad abgedeckt sind. Das Empfangsergebnis wird verstärkt, von einem Mikrocontroller mit Analog-Digital-Converter (ADC) ausgewertet und grafisch dargestellt. Insbesondere der zeitliche Verlauf über die letzten Stunden ist hier von Interesse. Ein detaillierte Beschreibung des Prinzips gibt es in einem früheren Beitrag auf dieser Seite: Neues vom Gewitter-Monitor: Version 2 – Elektronik-Labor (laagewitt.de)

Das Konzept von Version 2 hat sich bewährt. Der Empfang der Blitze im Bereich von etwa 100 kHz klappt gut. Deshalb wird die Signalverarbeitung mit Verstärkung und Peak-Detection unverändert übernommen. Die Erfassung der Daten über die Zeit und die Darstellung der letzten 2 oder 3 Stunden mit Trendanalyse sind anschaulich. Soweit bleibt alles beim Alten. Was lässt sich also verbessern?

Farbiges Display

Zuerst einmal ist das einfarbige LC-Display mit einer Auflösung von 192 x 64 Punkten nicht mehr zeitgemäß. Das geht inzwischen deutlich besser. Außerdem hat sich der Nachbau mit dem Smart-I2C-Interface für einige Interessenten als nicht ganz einfach herausgestellt. Inzwischen gibt es kleine, farbige Displays, die gut für Mikrocontroller-Projekte geeignet sind. Ich habe mich für ein 3.5inch TFT-Display entschieden, das eigentlich für den Raspberry Pi vorgesehen ist (siehe 3.5inch RPi Display – LCD wiki). Die Auflösung beträgt 480 x 320 Pixel. Das Display kann alle Farben darstellen. Es hat zusätzlich einen resistiven Touch-Controller, den ich in diesem Projekt aber nicht verwende. Und das Display ist gut verfügbar. Es kann bei den üblichen Online-Händlern unter verschiedenen Namen (z.B. Elegoo 3.5 480×320 SPI) zu akzeptablen Preisen erworben werden. Der Anschluss erfolgt über eine Buchsenleiste mit 26 Kontakten, die eigentlich für den Raspberry Pi vorgesehen ist.

3.5inch TFT-Display mit SPI-Schnittstelle. Auf der Rückseite (rechts) ist die zweipolige Anschlussleiste zu sehen.

Leistungsfähiger Mikrocontroller

Ein grafisches Display mit höherer Auflösung erfordert mehr Rechenkraft. Besonders das verfügbare RAM ist bei den 8-Bit Arduinos nicht ausreichend. Deshalb verwende ich den ESP32, den ich auch bei vielen anderen Projekten einsetze.

ESP32 Devkit

Der ADC des ESP32 arbeitet bei diesem Projekt mit einer im Vergleich zum ATmega328 höheren Frequenz von 10 kHz. Dabei werden immer abwechselnd die beiden Eingangskanäle abgefragt. Jeder Kanal kommt also auf 5 kHz, was zusammen mit der Peak-Detection-Schaltung völlig ausreicht, um zuverlässig alle Ereignisse zu erfassen.

Für das Display gibt es glücklicherweise eine hervorragende Grafik-Bibliothek zur Ansteuerung des oben genannten Displays, die auf GitHub veröffentlich wurde (github.com/Bodmer/TFT_eSPI). Ein besonderer Dank an den Autor und die Community, die diese Bibliothek ständig erweitert!

Die Verbindung zwischen dem ESP32 und dem Display geschieht mit einem SPI-Interface. Die Dokumentation ist nicht gerade selbsterklärend. Hier ist die Liste der Verbindungen, die ich für meine Projekte standardmäßig verwende:

Anschluss-Schema zwischen ESP32 und TFT-Display

Wichtig sind einige Anpassung in der Datei user_setup.h. Die Datei befindet sich in der Bibliothek TFT_eSPI und ist für die Projekt-spezifischen Einstellungen zuständig. Die Details dazu sind im ReadMe bei Bodmer gut beschrieben.

Notwendige Anpassungen in der Datei user_setup.h in der Bibliothek TFT_eSPI. Achtung: Bei neueren Versionen der Datei passen die Zeilennummern nicht mehr exakt mit den hier gezeigten Angaben. Die entsprechenden Zeilen können aber gut gefunden und entsprechend aktiviert oder deaktiviert werden.

Eine herausragende Eigenschaft des ESP32 ist seine Netzwerkfähigkeit. Hier könnte man natürlich spannende Ideen ausprobieren, z.B. das Einspeisen der Messdaten via MQTT in eine Datenbank in der Cloud. Im Moment sind das aber nur Ideen. Die aktuelle Version der Software ist noch nicht so weit. Vielleicht folgt so etwas zu einem späteren Zeitpunkt, gerne auch mit Beiträgen von anderen Autoren. Quellcode und Daten der aktuellen Version sind auf GitHub verfügbar.

Luftdruck und Zeit

Wenn schon alles neu, dann auch richtig! Die neue Version hat einen Luftdrucksensor bekommen (Bosch BMP280). Die Idee ist, zusätzlich zu den Blitzen auch den aktuellen Luftdruck zu beobachten. Gelegentlich zeigt sich ein nahendes Gewitter durch eine Abfall des Luftdrucks. Ob das eine auswertbare Größe ist, muss die praktische Erfahrung zeigen.

Und schließlich möchte ich die Zeitachse mit der Echtzeit beschriften. Dazu hat die Schaltung eine Echtzeituhr (DS3231) bekommen, die vom Prozessor ausgelesen und in der Grafik dargestellt wird.

Die Schaltung

Der Gewitter-Monitor besteht aus zwei Modulen, dem Hauptmodul und dem Antennen-Modul

Das Projekt besteht nach wie vor aus zwei Modulen, dem Hauptmodul mit Prozessor, Display und Zubehör und dem Antennen-Modul mit zwei AM-Empfängern und Ferritstäben.

Schaltplan des Hauptmoduls

Das Hauptmodul trägt den Prozessor (links unten) und das Display (links oben). Außerdem befindet sich dort (Mitte rechts) die Signalverarbeitung zur Verstärkung der Signale von der Antenne zusammen mit zwei OpAmps, die die Peak-Detection übernehmen. Der Output geht dann auf zwei ADC-Eingänge vom Prozessor.

Weiterhin gibt es hier (unten rechts) zwei einstellbare Konstantspannungs-Quellen zur Versorgung der AM-Empfänger auf dem Antennen-Modul. Die Versorgungsspannung regelt die Empfindlichkeit der Empfänger. Jeder Kanal lässt sich mit jeweils einem Trimm-Poti zwischen 0.8 und 1.5V einstellen. Ich habe gute Ergebnisse mit 1.2V erzielt. Die getrennte Einstellung der Spannung für die beiden Kanäle kann zum Ausgleichen von unterschiedlicher Empfindlichkeit genutzt werden, ist in der Praxis aber nicht unbedingt notwendig. Wer beide Kanäle mit derselben Spannung versorgen möchte, kann ein Trimm-Poti weglassen und statt dessen die Brücke “Single Mode” setzen.

Oben rechts befinden sich der Luftdrucksensor und die Echtzeituhr, die über das I2C-Interface mit dem Prozessor kommunizieren.

Im Plan links in der Mitte ist eine kleine Schaltung mit einem P-Kanal MOSFET IRLML2244 gezeigt, mit der das Display ein- bzw. ausgeschaltet werden kann. Der Gewitter-Monitor schaltet das Display ab, wenn nach einer einstellbaren Zeit keine relevanten Signale erkannt werden. Wenn sich ein Gewitter nähert, schaltet das Display automatisch ein.

Unten in der Mitte im Plan sind die Bedienelemente. Es sind 5 Taster vorgesehen. Weiterhin gibt es zwei weiße LEDs, die den Empfang von Blitzen durch kurzes Aufblinken anzeigen, und drei farbige LEDs (grün, gelb, rot), die den Alarmstatus kenntlich machen.

Schließlich befindet sich im Plan links in der Mitte ein Spannungswandler zur Stromversorgung. Die Schaltung kann mit 9 oder 12V aus einem kleinen Netzteil betrieben werden. Alternativ kann aber auch ein Mikro-USB-Kabel in das ESP32-Modul gesteckt werden. In dem Fall kann der Spannungswandler TSR einfach weggelassen werden.

Schaltplan des Antennen-Moduls

Das Antennen-Modul ist deutlich einfacher gestrickt. Jeder Kanal bekommt einen TA7642 AM-Empfänger mit der entsprechenden Beschaltung. Der Eingangskreis mit einer Spule auf einem Ferritstab und einem 1nF Kondensator ist für etwa 100 kHz ausgelegt. Die Spule besteht aus 0.3 mm lack-isoliertem Kupferdraht, sauber gewickelt auf eine Länge von 8 cm über einen 10 cm Ferritstab. Die exakte Frequenz ist nicht relevant, weil Blitze als Breitbandsender einen großen Bereich abdecken.

Die beiden Module werden über ein 6-poliges Flachbandkabel mit Pfostenstecker verbunden.

Platinen

Der Schaltung hat im Vergleich zu den früheren Versionen des Gewitter-Monitors an Komplexität zugenommen. Ein Aufbau auf einer Lochraster-Platine wäre möglich aber recht mühevoll. Deshalb habe ich zwei Platinen entworfen, eine für das Hauptmodul und eine für die Antenne. Alle Bau- und Bedienelemente haben darauf Platz gefunden. Abgesehen vom Verbindungskabel zwischen den Modulen gibt es keine weiteren Verdrahtungsarbeiten.

Platine des Hauptmoduls im Leiterbahnen-Editor. Die aktuelle Version ist 3b.

Die Rückseite der Platine des Hauptmoduls trägt alle Bauelemente. Die Taster, LEDs und das Display sind auf der Vorderseite angeordnet. So ergibt sich eine platzsparende Bauweise.

Rückseite der bestückten Platine. Der ESP32 (rechts), das Uhrenmodul DS3231 (links) und der Luftdrucksensor BME280 (oben) werden über Steckleisten montiert. Links in der Mitte befinden sich die beiden Trimm-Potis zur Einstellung der Betriebsspannung der AM-Empfänger auf dem Antennen-Modul. Rechts oben gibt es Schraubklemmen für die Spannungsversorgung mit einem 9 oder 12V Steckernetzteil.
Vorderseite der Platine. Oben links befindet sich die Steckerleiste für das Display, oben rechts die Leuchtdioden und darunter 5 Taster für die Bedienung.
Die Platine für die Antenne ist vergleichsweise klein. Das Bild zeigt die Platine noch ohne Bestückung.

3D-Druck

Für den mechanischen Aufbau gibt es 4 passgenaue Kunststoffteile aus dem 3D-Drucker. Das größte Teil ist die Frontplatte, an der die Platine verschraubt wird. Alle notendigen Abstandshalter und Durchbrüche für Display, LEDs und Taster sind vorhanden. Dadurch wird die Montage einfach.

Frontplatte aus dem 3D-Drucker
Die Rückseite der Frontplatte trägt Abstandshalter und Bohrungen für die Montage der Platine.

Die Anschlussleiste des Displays ist ausgelegt für den Raspberry Pi. Bei dieser Anwendung steht das Display relativ weit aus der Frontplatte hervor. Deshalb gibt es einen Abstandshalter (Display-Spacer), der unter das Display geschoben wird.

Display-Spacer

Nachdem das Display aufgesteckt ist, wird es von einem Rahmen gehalten, der von oben aufgeschraubt wird. Beim Prototypen wurde der Rahmen mit blauem Filament gedruckt. Die Farbwahl ist offensichtlich Geschmackssache.

Display-Rahmen

Als viertes Teil gibt es einen Träger für das Antennen-Modul mit den beiden Ferritstäben. Die Ferritstäbe werden mit kleinen Kabelbindern an den Stützen fixiert.

Antennen-Träger

Software

Die Elektronik und die Mechanik sind zusammengelötet und verschraubt. Aber erst mit der Software wird daraus ein funktionierendes Gerät. Erst dachte ich, dass das in 1 oder 2 Tagen erledigt ist. Wie so oft beim Freizeit-Programmieren lag ich deutlich falsch. Es benötigte wesentlich mehr Zeit, um alle Funktionen sinnvoll zu gestalten und zu testen. Und die Software ist noch lange nicht fertig (wann ist Software jemals fertig?). Die aktuelle Version der Software kann aber schon eine ganze Menge und scheint weitgehend stabil zu laufen. Mit der Zeit wird noch weitere Funktionalität dazu kommen.

Die Software ist mit der Arduino IDE in C++ geschrieben. Das Hauptprogramm ist gewitter_monitor_v3_esp32.ino. Dazu gibt es eine Reihe von Klassen (display, my_rtc, command_line, menu, keyboard) und eine Sammlung von Hilfsfunktionen util. Die Arduino-Software ist auf GitHub verfügbar. Wer Interesse hat, an der Software-Entwicklung mitzuarbeiten, ist sehr willkommen.

Anwendung und Bedienung

Gewitter-Monitor in Aktion. Der Alarm ist gesetzt und zeigt gelb/rot.

Der Gewitter-Monitor hört ständig in den Äther auf der Suche nach Blitzen. Wenn ein Blitz erkannt wird, wird das Maximum der Feldstärke gesucht. Der Monitor speichert für jede Minute zwei Datenpunkte, die Summe der registrierten Blitz-Maxima für beide Kanäle. Auf der rechten Seite des Displays werden für die laufende Minute die Anzahl der Blitze (Count) und die Summe der Maxima (Sum) angezeigt. Außerdem befindet sich dort der letzte Luftdruck-Messwert und die aktuelle Zeit in Minute und Sekunde.

Der größte Teil des Displays zeigt den Verlauf über die letzten drei Stunden, also Datenpunkte für 180 Minuten. Die X-Achse ist eingeteilt in Stunden mit Markierungen für viertel und halbe Stunden. Die grünen und roten Balken zeigen die registrierten Summen-Werte für die abgelaufene Minute. Die Y-Skala wird automatische skaliert, so dass alle Werte sinnvoll dargestellt werden.

Zusätzlich gibt es eine Trend-Berechnung mit linearer Regression über die letzten 60 Minuten, sofern die aktuellen Daten eine sinnvolle Berechnung zulassen. Die Steigung der Geraden wird als Trend-Wert auf der rechten Seite gezeigt. Positive Werte bedeuten, dass die Gerade ansteigt und Gewitter-Aktivitäten möglicherweise weiter zunehmen.

Die blaue Linie zeigt den relativen Luftdruck. Hier lässt sich die Entwicklung des Luftdrucks über die letzten 3 Stunden ablesen.

Die Funktion der Leuchtdioden ist schnell erklärt. Die beiden weißen Leuchtdioden blinken kurz auf, wenn ein Blitz erkannt wurde. Die grüne, gelbe und rote Leuchtdiode zeigen den Alarm-Status.

Aufstellungs-Ort

Der Gewitter-Monitor hat eine hohe Empfindlichkeit und benötigt eine Standort, der einigermaßen frei von magnetischen Störsignalen ist. Störungen können z.B. von Schaltnetzteilen oder Dimmern kommen. Auch das Netzteil zur Stromversorgung der Schaltung kann stören. Wenn es auch ohne Gewitter immer wieder blinkt, dann kann es helfen, einen anderen Ort zu suchen, der einen geringeren Störlevel hat.

Gegebenenfalls kann es nützlich sein, die Masse (Minus-Pol der Stromversorgung) mit einem Erdungsanschluss zu verbinden (wie früher beim Detektor-Radio). Die Schraubklemmen auf der Platine haben zwei GND-Anschlüsse, von denen einer mit einem Draht z.B. mit einer blanke Stelle einer Wasserleitung oder eines Heizungsrohres verbunden werden kann. Auch ein Anschluss an den Schutzleiter des Hausstromnetzes kann helfen.

Erfahrungen

Bei ruhiger, stabiler Wetterlage registriert der Monitor nur gelegentliche, schwache Ausschläge. Signalpegel unter 500 kann man getrost ignorieren. Dabei handelt es sich wahrscheinlich um technische Schaltvorgänge im Haus oder der Umgebung.

Ein ruhiger Morgen bei stabiler Wetterlage. Einzelne Ausschläge stammen von elektrischen Schaltvorgängen im Haus oder in der Nachbarschaft. Davon sieht man in der Nach weniger als am Tag.

Spannend wird es, wenn in der Atmosphäre etwas passiert, z.B. eine Kaltfront herannaht. Dann gibt es in dichter Folge Ausschläge mit Summenwerten von 1000 oder darüber. Interessanterweise registriert der Gewitter-Monitor auch dann Aktivitäten, wenn die Webseite blitzortung.de (noch) gar nichts zeigt. Ich vermute, dass der Gewitter-Monitor auch schwache Entladungen zwischen den Wolken empfängt, die bei blitzortung.de nicht registriert werden.

Hier war der Nachmittag noch ruhig. Aber ab etwa 16 Uhr zog eine Kaltfront mit viel Wind durch unsere Region. Interessant war, dass auf blitzortung.de keine Blitze registriert wurden.

Wenn Gewitter dann tatsächliche in Erscheinung treten, werden sie schon in Entfernungen von einigen 100 km registriert. Die Ausschläge können dann bis weit über 5000 reichen. In der Nacht ist dann meist Wetterleuchten in der Ferne zu sehen.

Dieses Bild zeigt zwei Vorgänge: Bis etwa 19 Uhr ist eine Gewitterfront durch den Schwarzwald gezogen, etwa 200 km nördlich von uns, und hat sich dann abgeschwächt. Ab etwa 19:30 Uhr gab es mehrere Gewitter in den Schweizer Alpen, nach blitzortung.de etwa 300 km östlich von uns, die später wieder abnahmen.
Durchzug eines lokalen Gewitters in der Nachbarschaft. Das Zentrum hat unseren Ort aber nicht erreicht.

Wenn ein Gewitter in die direkter Nähe kommt, es also hörbar “kracht”, dann reichen die Summen-Werte bis weit über 10000. Die stärksten Werte, die ich bisher registriert habe, lagen bei 50000.

Alarm

Das System arbeitet mit 5 verschiedenen Alarmstufen. Dazu wird der Mittelwert der letzten 5 Minuten berechnet. Wenn dieser Wert festgelegte Schwellen überschreitet, wird der Alarm ausgelöst. Der höchste Level kann mit Hilfe der Konfiguration nach Bedarf justiert werden. Die anderen Stufen ergeben sich als Bruchteile des höchsten Alarm-Levels. Ein Beispiel mit der Standardeinstellung:

  • Werte unter 1000 -> Das Display ist (bzw. wird nach einigen Minuten) ausgeschaltet (display timeout). Die grüne LED leuchtet.
  • Alarm Level 1 – Werte über 1000 -> Das Display wird eingeschaltet, die grüne LED leuchtet
  • Alarm Level 2 – Werte über 2000 -> Die gelbe und die grüne LED leuchten
  • Alarm Level 3 – Werte über 3000 -> Die gelbe LED leuchtet
  • Alarm Level 4 – Werte über 4000 -> Die gelbe und die rote LED leuchten
  • Alarm Level 5 -> Werte über 5000 -> Die rote LED leuchtet

Der Wert für den Alarm-Level 5 lässt sich anpassen. Die anderen Alarm-Level ergeben sich als anteilige Faktoren.

Tastenfeld und Konfiguration

Mit den 5 Tasten (4 mal gelb links, rechts, oben, unten, und einmal blau in der Mitte) können Einstellungen verändert werden.

Mit 5 Tasten können häufige Einstellungen vorgenommen werden

Die Software enthält eine ganze Reihe von Parametern, die vom Anwender angepasst werden können. Die Werte werden im non-volatile Speicher des ESP32 abgelegt, sind also auch über das Abschalten hinaus verfügbar. Das Konfigurations-Menü wird über die blaue Tasten geöffnet und über den Menüpunkt Exit wieder verlassen.

Das Konfigurations-Menü wird über die blaue Taste aufgerufen. Dann können die einzelnen Werte mit den gelben Tasten auf und ab ausgewählt werden. Die Werte werden mit den gelben Tasten links und rechts innerhalb sinnvoller Grenzen verändert. Ein neuer Wert muss mit der blauen Taste übernommen werden, damit er aktiv wird.

Paramater:

  • Hour: aktuelle Stunde der Echtzeituhr
  • Minute: aktuelle Minute der Echtzeituhr. Wenn der Minuten-Wert eingestellt wird, wird die Sekunde auf 0 gesetzt.
  • Detector Threshold: Wenn sich zwei aufeinanderfolgende ADC-Werte um den Threshold unterscheiden, dann wird das Signal als Blitz gewertet. Kleinere Werte bedeuten höhere Empfindlichkeit, größere Werte entsprechend weniger Empfindlichkeit.
  • Flash Duration [ms]: Dauer des Aufleuchtens der weißen LEDs, wenn ein Blitz erkannt wird.
  • Display Timeout [min]: Wenn kein Alarm-Level gesetzt ist, schaltet das Display nach dieser Zeit ab.
  • Alarm Level: Summen-Wert, ab dem die rote Leuchtdiode gesetzt wird. Die niedrigeren Alatm-Level werden als anteilige Faktoren berechnet.
  • Alarm Window: Die Anzahl der letzten Minuten, die für die Durchschnittsberechnung des Alarm-Wertes verwendet werden.
  • Scale Minimum: Die kleinste Skalierung der Y-Achse. Wenn gar keine oder nur sehr geringe Signale gemessen wurden, dann wird die Y-Achse mit diesem Wert skaliert.
  • hPa: Offset für die Luftdruck-Einstellung. Je nach der Höhe des Standortes ist der tatsächlich gemessene Luftdruck geringer als der auf Meeresniveau bezogene Luftdruck. Hier kann ein Standardluftdruck eingebeben werden. Das System berechnet daraus einen Offset zum gemessene Druck, den es dann für die Anzeige verwendet.

Schließlich gibt es noch eine Einstellhilfe für die Spannungsversorgung der AM-Empfänger auf den Antennen. Die Werte werden vom ADC des ESP32 ausgelesen und unter dem Menüpunkt Voltage Adjust angezeigt. Wenn dieser Punkt ausgewählt ist, können die Spannungen an den Trimm-Potis auf der Platine eingestellt werden. Die in diesem Beitrag gezeigten Bilder wurden mit einer Spannung von 1.20 V gemacht.

Einstellung der Spannungsversorgung der AM-Empfänger. Größere Werte ergeben eine höhere Empfindlichkeit, womit aber auch die Anfälligkeit für Störungen zunimmt.

Fazit

Der neue Gewitter-Monitor steht bei mir jetzt einige Wochen im Regal und zeigt immer wieder interessante Grafiken und Daten. Das farbige Display macht sich gut. Wenn sich das Display einschaltet und besonders die gelbe und rote LED aktiv werden, ist das ein untrügliches Zeichen für Gewitter-Aktivitäten in der Atmosphäre.

Die Funktionsweise wurde weitgehend vom Vorgänger übernommen, im Detail aber deutlich überarbeitet. Der Nachbau ist durch die Platine und die Verwendung von Standardbauteilen deutlich einfacher geworden. Zusammen mit den Teilen aus dem 3D-Drucker ergibt sich ein kompaktes Gerät, dass wenig Handarbeit benötigt. Die Entwicklung der Software hat viel Zeit in Anspruch genommen – und reizt noch lange nicht alle Möglichkeiten aus. Hier gibt es noch viel Spielraum.

Ich würde mich freuen, wenn es Interesse gibt, das Projekt nachzubauen oder auch an der Entwicklung mitzuarbeiten, und werde entsprechende Vorhaben nach Möglichkeit unterstützen.

Ressourcen

Alle technischen Details sind verfügbar auf GitHub:

smlaage/GewitterMonitor_v3: Lightning detection system with ESP32 (github.com)

Im Folder gewitter_monitor_v3_esp32 befinden sich der Arduino Source-Code.

Im Folder PCB sind die Gerber- und Bohr-Files für die beiden Platinen für das Hauptmodul und das Antennenmodul.

Der Folder 3D-Printing enthält die STL-Files für die Kunststoffteile wie im Artikel beschrieben.

XY-Plotter

Der Corona-Lockdown bedeutet mehr Zeit zuhause und im Home-Office. Was also machen mit der vielen Zeit? Ich habe eine alte Idee ausgegraben, der Selbstbau eines XY-Plotters, also einer Maschine, die einen Stift über Papier führt und so Zeichnungen produziert.

Natürlich kann jeder Laser- oder Inkjet-Drucker beliebige Bilder mit hoher Qualität ausdrucken. Es reizte mich aber, Zeichnungen mit einem geführten Stift maschinell zu erstellen. Die Resultate sind Unikate, die von den Eigenschaften von Stift und Papier abhängen. Und mir gefiel die selbst gestellte Aufgabe als eine spannende Herausforderung.

Dieses Projekt begann im ersten Corona-Lockdown im März 2020 und hat bis heute einen sehr schön funktionierenden Prototyp und allerlei interessante Zeichnungen ergeben. Eine Galerie findet sich am Ende dieses Beitrags.

Inhalt

Das Konzept

Die Aufgabe eines Plotters ist es, einen Stift zu führen, so dass er Spuren auf dem Papier hinterlässt. Ein Bild kommt aber erst im Zusammenspiel mit einem PC zustande, der die passenden Zeichenanweisungen erzeugt und an den Plotter sendet. Dazu stellt der Plotter Funktionen zum Zeichnen von Linien, Rechtecke, Kreise, Ellipsen, Kreisbögen und mehr bereit, beherrscht sogar einen einfachen Zeichensatz für Texte. Es gibt eine (stetig wachsende) Befehlstabelle (siehe hier). Die Verbindung zwischen PC and Plotter kann über die serielle USB-Schnittstelle oder über das WLAN erfolgen.

Die Zeichnungen können auf dem PC mit beliebiger Software erstellt werden. Ich verwende hauptsächlich Python-Skripts, die ansprechende Grafiken produzieren. Dabei beschäftige ich mich auch mit der Umwandlung von Fotos in Vektor-Zeichnungen im SVG-Format, die dann vom Plotter zu Papier gebracht werden – ein weites Experimentierfeld.

Plotter in action

Die Mechanik

Das Design ist schnell beschrieben. Es gibt eine X- und eine Y-Achse, die mit Schrittmotoren betrieben werden. Die Mechanik basiert auf dem von 3D-Druckern bekannten Verfahren. Die Achsen werden aus Linearwellen (polierter Rundstahl mit 8 mm Durchmesser) aufgebaut, auf denen Schlitten mit Linearlagern laufen. Die horizontale X-Achse ist doppelt ausgeführt und bewegt zwei gegenüberliegende Schlitten, die die vertikale Y-Achse tragen. Auf der Y-Achse bewegt sich ein Schlitten mit dem Stifthalter. Die Positionierung erfolgt über Zahnriemen.

Der Plotter im Überblick

Der Zeichenstift ist an einer Wippe befestigt, die mit einem Modellbau-Servo gehoben oder gesenkt wird. Der Anpressdruck auf dem Papier wird mit einer Feder angepasst. Der Stifthalter kann beliebige Stifte aufnehmen, allerdings nur einen Stift zur Zeit. Mehrere Farben benötigen also einen manuellen Stiftwechsel. Das Papier wird mit Magneten fixiert, so dass es schnell gewechselt werden kann. Die bei professionellen Plottern verbreitete Fixierung mit Unterdruck erschien mir für den Selbstbau zu aufwendig.

Überall kommen Linear- und Kugellager zum Einsatz, so dass die Mechanik weitgehend spielfrei funktioniert. Die benötigten Komponenten sind bei den üblichen Online-Händlern zu akzeptablen Preisen verfügbar.

Konstruktion der Bauteile mit FreeCAD

Die benötigten Konstruktionsteile kommen aus dem 3D-Drucker. Zur Konstruktion verwende ich durchgängig FreeCad und zur Herstellung der Teile meinen bewährten Dremel 3D40.

Detail-Ansichten

Die Auswahl eines geeignetes Stifts ist nicht ganz unproblematisch. Beim Zeichnen können durchaus lange Strecken zusammenkommen, so dass sich der Stift schnell abnutzt. Ich habe gute Erfahrungen mit Tintenrollern oder Gelrollern gemacht.

Die Elektronik

Im Zentrum der Maschine werkelt ein ESP32. Er treibt die Schrittmotoren XA, XB und Y mit Hilfe der üblichen A4988 Treiber-Module, die als Breakout-Board verfügbar sind. Ich verwende den 8tel-Schritt-Modus (MS1 und MS2 liegen auf +3.3V). Die Enable-Leitungen aller 3 Treiber sind zusammengefasst. Der Prozessor kann damit alle Motoren ein- oder ausschalten. Jeder Motor-Treiber hat einen Step- und einen Dir-Eingang, die unabhängig voneinander angesteuert werden. Für jede Achse gibt es einen Endtaster, der nach dem Einschalten angefahren wird (“Referenzfahrt”), um eine definierte 0-Position zu finden.

Weiterhin gibt es ein alphanumerisches LCD-Display, das über das I2C-Interface betrieben wird. Das Display hat 4 Zeilen mit jeweils 20 Zeichen und gibt Status-Informationen aus.

Das System beinhaltet 3 Taster, mit denen der Anwender den Ablauf beeinflussen kann:

  • Taster 0 (“Stop”, grün) hält die Ausführung an bzw. setzt sie fort.
  • Taster 1 (“Standby”, blau) schaltet den Motostrom ab. Sobald der Plotter irgendein Zeichenkommando bekommt, werden die Motoren wieder eingeschaltet.
  • Taster 2 (“Pen Up/Down”, gelb) hebt oder senkt den Stift. Das ist hilfreich zum Einsetzen eines Stifts.
Die drei Taster befinden sich unterhalb vom LC-Display

Die Schaltung arbeitet mit 3 verschiedenen Spannungen: Sie wird von einem externen Netzteil mit 12V versorgt. Die Spannung dient direkt zum Treiben der Motoren (Vmot). Ein Spannungsregler auf der Platine erzeugt daraus 5V (Vdd) für die Stromversorgung von ESP32, LCD-Display und Stift-Servo. Der ESP32 trägt auf seinem Board einen 3.3V Spannungsregler (Vcc). Diese Spannung wird außerdem für die Versorgung der Logik der Schrittmotortreiber verwendet

Der Schaltplan für den Plotter. Links oben die Spannungsregelung (12 -> 5V). Links der ESP32. Oben Mitte das LC-Display. In der Mitte die drei Motortreiber mit A4988. Unten Mitte die Anschlüsse für die Endschalter, den Servo und die Taster.

Die Schaltung ist im Laufe der Zeit auf einer Lochrasterplatine im Prototyp-Stil “gewachsen”. Das Resultat ist nicht schön, funktioniert aber zuverlässig. Bei Gelegenheit kann man dafür eine Platine anfertigen.

Der Aufbau der Platine ist historisch gewachsen …

Ursprünglich war der Plotter als horizontaler “Flachbett-Plotter” konzipiert. Aus Platzgründen in meinem Home-Office habe ich ihn dann aber auf ein Gestell gesetzt, so dass er mit etwa 60 Grad Neigung im Bücherregal steht. Leider reicht es jetzt nicht mehr ganz für das A3-Papierformat.

Der Plotter steht auf einem Gestell mit etwa 60 Grad Neigung und passt so ins Bücherregal.

Die Software

Wie so oft bei diesen Projekten benötigt die Software den größten Arbeitsaufwand. Die “Firmware” für den ESP32 habe ich mit der Arduino-IDE entwickelt. Sie übernimmt die Steuerung der Motoren und des Servos für den Stift und kann eine Reihe von Grafik-Primitiven ausführen. Eingaben kommen über die serielle Schnittstelle oder das WLAN und landen in einem internen Puffer, der sukzessive abgearbeitet wird.

Die Schrittmotoren werden über einen Timer-Interrupt gesteuert. Der Interrupt beherrscht den Bresenham-Algorithmus, um zwei beliebige Punkte mit einer geraden Linie zu verbinden, was die Grundlage für alle Zeichenfunktionen bildet. Die Motoren werden mit einer Rampe auf Geschwindigkeit gebracht und vor dem Ziel wieder abgebremst. So kann der Plotter den Schlitten relativ schnell bewegen, ohne Schritte zu verlieren. Das klappt tatsächlich ausgesprochen gut. Die Logik unterscheidet zwischen Bewegungen mit gehobenem (schnell) und gesenktem Stift (einstellbare Geschwindigkeit, normalerweise langsamer). Weitere Anforderungen an das Timing müssen beachten werden. Zum Beispiel wird nach dem Befehl pen down für einen kurzen Moment gewartet, bis der Stift auf dem Papier angekommen ist.

Der Eingabepuffer nimmt mit 70 kB den größten Teil des verfügbaren RAM-Speichers auf dem ESP32 in Anspruch. Die Steuerung der Motoren und das Abarbeiten des Puffers geschieht vollständig im Hintergrund. Die Schnittstellen werden auch während des Plot-Betriebs bedient. Das sendende Programm muss allerdings abfragen, ob genügend Platz für weitere Anweisungen im Puffer vorhanden ist. Dazu dient das Kommando F, das den aktuell verfügbaren Speicherplatz zurück gibt.

Für die WLAN-Verbindung verwende ich die Socket-Kommunikation, die an anderer Stelle beschrieben wurde. Bei der ersten Inbetriebnahme muss der Anwender das Netzwerk über die serielle Schnittstelle auswählen und das zugehörige Passwort eingeben. Die Einstellung einer statischen Adresse ist möglich. Die Daten werden im Flash-Speicher abgelegt, so dass sich der Plotter beim nächsten Einschalten direkt und ohne weitere Eingaben mit dem Netzwerk verbindet.

Das LC-Display zeigt einige System-Parameter im laufenden Betrieb.

Die Software ist ein umfangreiches Projekt und hat in der aktuellen Version sicherlich noch einen experimentellen Charakter, läuft aber stabil und produziert schon sehr ansehnliche Bilder.

Protokollarisches

Wie bringt man den Plotter dazu, etwas zu zeichnen? Dafür verwende ich ein einfaches Protokoll. Die Syntax ist angelehnt an die Scalable Vector Graphics-Sprache. Jede Anweisung besteht aus einem Buchstaben, der die Art des Befehls kennzeichnet, gefolgt von Parametern, z.B. Koordinaten. Die Parameter werden durch Komma getrennt. Leerzeichen werden ignoriert. Eine Anweisung wird durch ein Semikolon oder das Zeilenende abgeschlossen.

Der Plotter verwendet ein X/Y-Koordinatensystem. Der Nullpunkt ist unten links und wird nach dem Einschalten angesteuert. Ein Schritt entspricht 0,025 mm, was eine recht hohe Auflösung für diese Anwendung ist. Auch mit sehr feinen Stiften lassen sich keine Treppenstufen erkennen. Zur Zeit gibt es 37 Befehle. Hier ist ein Ausschnitt der Tabelle.

Ausschnitt aus der Befehlstabelle. Die Tabelle umfasst derzeit 37 Anweisungen.

Ein einfaches Beispiel: Die hier gezeigte Sequenz zeichnet ein Smiley, bestehend aus Kreisen, Ellipsen, Kreisbögen und geraden Linien, die ein Dreieck bilden. Die Anweisung Z (Zeile 4) schließt den Polygon-Zug, wobei der Stift an die letzte durch ein M angesteuerte Position zurückkehrt.

M 6000,2000; C 800
M 5700,2200; E 200,80; M 5700,2200; C 60
M 6300,2200; E 200,80; M 6300,2200; C 60
M 6000,2100; L 6200,1800; L 5800,1800; Z
M 6000,2050; C 600,120,240
Smiley (Bleistift auf Zeichenkarton)

Es gibt auch Anweisungen zum Zeichnen von Text. Der Plotter hat einen eingebauten Zeichensatz, der allerdings noch recht eingeschränkt ist und im Wesentlichen die unteren 80 Zeichen der ASCII-Tabelle enthält.

Zeichensatz

Zeichenprogramme

Der Plotter ist ein Werkzeug, das Anweisungen empfängt und den Stift bedient. Eine ansprechende Grafik besteht aber aus sehr vielen Anweisungen und kommt in der Regel von einem Programm auf dem PC. Ich verwende verschiedene Python Programme, die mit unterschiedlichen Algorithmen Grafiken produzieren oder Fotos in Zeichnungen umsetzen.

Zum Testen des Plotters und der Verbindung eignet sich eine kleine Python-Anwendung, die manuelle Eingaben per Tastatur entgegennimmt und über die WebSocket-Schnittstelle an den Plotter sendet. 

# websocket_test.py - gets input from the keyboard and sends it to the plotter
# SLW 03/21

import time
import websocket

plotter_ip = "192.168.1.70:90"

#------------------------------------------
def send_msg(msg):
    """ Sends a message to websocket server.
        Returns the response """
    try:
        ws.send(msg)
        result = ws.recv()
    except OSError as err:
        print(err)
        result = ""
    return result

#------------------------------------------
ws = websocket.WebSocket()
try:
    ws.connect("ws://" + plotter_ip, timeout=3)
    print("Connected to WebSocket server, IP", ip)
    connection = True
except OSError as err:
    connection = False
    print(err)

if connection:
    while True:
        instr = input("> ")
        if len(instr) == 0:
            break
        print(send_msg(instr))
    ws.close()
    print("Connection closed")

Das Skript verbindet sich mit dem WebSocket-Server auf dem Plotter und öffnet eine interaktive Session, in der man die einzelnen Grafik-Befehle ausprobieren kann.

Die Python-Programme, mit denen ich meine Grafiken erstelle, produzieren eine Liste von Zeichenanweisungen, die als Zwischenschritt erst einmal in einer Datei landen. Bei mir heißt diese Datei meistens plot_file.plt. Diese Datei wird dann mit einem Python-Skript zum Plotter gesendet. Dabei muss das Skript regelmäßig den verfügbaren Pufferplatz auf dem Plotter abfragen und darf die Daten nur bei ausreichend Platz senden. Ein sehr einfaches Programm für diese Aufgabe ist hier gezeigt. Dieses Skript hält den Transfer an, wenn der freie Pufferplatz unter 1 kB fällt und startet den Transfer, wenn er über 10 kB ansteigt:

# plot_file.py - reads an input file and sends it to the plotter
# SLW 03/21

import time
import websocket

# Global parameter ---------------------------------------
ip = "192.168.1.70:90"
filename = "plot_file"
extension = ".plt"

#---------------------------------------------------------
def send_msg(msg):
    try:
        ws.send(msg)
        result = ws.recv()
    except websocket._exceptions.WebSocketTimeoutException:
        print("timeout occured")
        result = None
    return result

#----------------------------------------------------------
def get_buffer_size():
    result = send_msg("F")
    if result:
        buffer_size = int(result.split(':')[1])
        return buffer_size
    else:
        return 0

#----------------------------------------------------------
# open communication channel
ws = websocket.WebSocket()
ws.connect("ws://" + ip, timeout=5)
print("Connected to WebSocket server on IP", ip)

# read input file
if filename.find(extension) < 0:
    filename += extension
try:
    with open(filename, "r") as f:
        lines = f.readlines()
    print(len(lines), "lines read")
except IOError:
    print("File '" + filename + "' not available or accessible")
    lines = None

# send data to plotter
if lines:
    buffer_okay = False
    for n, l in enumerate(lines):
        while True:
            buf = get_buffer_size()
            if buf > 10000:
                buffer_okay = True
            elif buf < 1000:
                buffer_okay = False
            if buffer_okay:
                send_msg(l)
                if n % 20 == 0:
                    print(" - {:d} lines sent".format(n))
                break;
            else:
                time.sleep(1)

# finish plot and close connection
send_msg("H; P")
ws.close()
print("Connection closed")

Zum Abschluss ein kurzes Python-Programm, das eine einfache Zeichnung erstellt und in der Datei plot_file.plt ablegt. Die Computer-Grafiken der 80er Jahre feiern hier ein Revival.

# nested_check.py - a program plotting

px, py = 1000, 3000
length, steps = 4000, 40
x, y = [px, px, px+length, px+length], [py, py+length, py+length, py]

f = open("plot_file.plt", "w")
for i in range(steps):
    s = "M {:d}, {:d}; ".format(x[0], y[0])
    for n in range(1, 4):
        s += "L {:d}, {:d}; ".format(x[n], y[n])
    s += "L {:d}, {:d}\n".format(x[0], y[0])
    f.write(s)
    y[0] += length // steps
    x[1] += length // steps
    y[2] -= length // steps
    x[3] -= length // steps

f.close()
Das Ergebnis des Skripts “nested_check.py”

Die Python-Unterstützung des Plotters ist im Moment noch rudimentär und wird im Laufe der Zeit weiter entwickelt. Auch die Erstellung von Grafiken mit Python-Skripts ist ein weites Feld. Zu gegebener Zeit werden weitere Beispiele folge.

Fazit

Spielereien mit Computer-Grafik haben mich schon immer fasziniert. Der Bau eines Plotters ist ein spannendes Projekt. Die mit dem Stift gezeichneten Ergebnisse habe einen eigenen Reiz.

Der Eigenbau eines solchen Gerätes wird durch die Verfügbarkeit von 3D-Druck und leistungsfähiger Hardware-Komponenten erst möglich. Es ist erstaunlich, welche Präzision sich in der heimischen Werkstatt erreichen lässt. Der ESP32 hat mich mit seiner Leistungsfähigkeit wieder einmal beeindruckt. Die Verwaltung der Motoren mit schnellen Interrupt-Folgen parallel zur Bedienung des Eingabepuffers, LCD, Stift-Servo und Netzwerk sind eine anspruchsvolle Aufgabe, die den ESP32 aber noch lange nicht an seine Grenzen bringt.

Galerie

Baum – entstanden aus einer rekursive Funktion mit zufälligen Variationen
Bäume – rekursive Funktion in Python
dat10 – Drehende gekoppelte Scheiben
dat07 – Noch mehr Drehungen
Pusteblume – rekursive Strukturen im Kreis
Sailboat – Konvertierung eines Handy-Fotos in eine SVG-Grafik mit Nachbearbeitung in Python

Ressourcen

WebSocket-Kommunikation mit dem ESP32 – Eine Wetterstation mit BME280

In den letzten Monaten hat sich der ESP32 zu einem Arbeitspferd für viele Projekte entwickelt. Zum einen ist es ein leistungsfähiger Prozessor mit beachtlicher Busbreite und Taktrate. Zum anderen ist die Kommunikation via WLAN eine sehr praktische Angelegenheit.

Es muss aber nicht immer eine Web-Server sein, der, wie in vielen Tutorials gezeigt, HTML produziert. In diesem Projekt gehe ich auf einen tieferen Level und möchte zeigen, wie man mit der WebSocket-Schnittstelle eine Datenverbindung mit geringem Overhead aufbauen kann. WebSocket bietet eine zuverlässige Verbindung, bei der Nachrichten nicht verloren gehen und in der korrekten Reihenfolge übermittelt werden. Der Komfort steht dem einer seriellen Schnittstelle in nichts nach … ganz ohne lästiges Kabel!

Die Idee

Als Beispiel-Anwendung habe ich mir den Sensor BME280 herausgesucht, der Luftdruck, Luftfeuchtigkeit und Temperatur misst und die Daten per I2C zur Verfügung stellt. Die Daten werden vom ESP32 ausgelesen, der sie dann als WebSocket-Server für Clients abrufbar macht. Bei der Gelegenheit habe ich noch zwei Leuchtdioden an den ESP32 angeschlossen, die über den Client geschaltet werden können. Als Beispiel für einen Client gibt es hier eine GUI-Anwendung mit Python und TKinter, die zum Beispiel auf einem Laptop oder einem Raspberry Pi läuft. Die Verbindung über das serielle Interface und den WebSocket werden exakt gleich behandelt und können vom ESP32 auch gleichzeitig bedient werden. Soweit das Konzept.

Der ESP32 empfängt die Daten vom Sensor (BME280) (rechts) und stellt sie über die serielle Schnittstelle und über den WebSocket-Server zur Verfügung. Als WebSocket-Client dient ein Python-Programm auf einem Computer (links).

Die Schaltung

Die Schaltung ist auf einem Steckbrett schnell zusammengebaut. Für den BME280-Sensor gibt es ein praktisches Breakout-Board, das Masse, Vcc und die beiden I2C-Leitung SCL und SDA herausführt. Die I2C-Leitungen bekommen Pull Up-Widerstände, die den Ruhepegel auf Vcc ziehen. Auf dem Steckbrett befindet sich noch eine zweifarbige LED mit gemeinsamer Kathode, die den Status der Netzwerkverbindung anzeigt. Schließlich gibt es noch zwei Leuchtdioden, die an Ports des ESP32 gelegt sind.

Schaltplan des ESP32 mit dem Sensor BME280 und einigen Leuchtdioden
Aufbau auf einem Steckbrett

BME280

Der Bosch-Sensor ist bereits kalibriert und stellt die Daten in digitaler Form bereit, was die Anwendung enorm vereinfacht. Ich verwende die Arduino-Bibliothek BME280 von Tyler Glenn, die schon in der Version 3.0 vorliegt. Der Sensor wird nach dem Laden der Include-Datei als globales Objekt eingerichtet. Die Funktionen zum Auslesen von Luftdruck, Temperatur und Luftfeuchtigkeit können direkt aufgerufen werden und liefern die Ergebnisse als Float-Variable. 

#include <BME2810I2C.h>

BME280I2C bme;

float pres = bme.pres();
float temp = bme.temp();
float hum = bme.hum();

Verbindungsaufbau mit dem Modul web_socket

Bei meiner Arbeit mit dem ESP32 habe ich ein Software-Modul web_socket entwickelt, das den Verbindungsaufbau übernimmt und Funktionen zum Lesen und Schreiben der Daten zur Verfügung stellt. Es besteht aus den Dateien web_socket.cpp und web_socket.h und verwendet seinerseits die WebSockets-Bibliothek für Arduino (GitHub – Links2004/arduinoWebSockets: arduinoWebSockets), die gegebenenfalls in der Arduino-Umgebung installiert werden muss.

Eine der Aufgaben von web_socket ist der Aufbau der Verbindung zum WLAN-Router. In vielen Beispielen im Internet wird dabei der Namen des Netzwerks (SSID) und das Passwort in den Source-Code eingebettet. Das ist für Experimente praktisch, für reale Anwendungen aber nicht tragbar. Deshalb bietet das Modul web_socket die Möglichkeit, die Netzwerk-Credentials per Dialog über die serielle Schnittstelle abzufragen und im nichtflüchtigen Speicher (preferences) abzulegen. Beim nächsten Start klappt der Verbindungsaufbau dann ohne weitere Angaben. Die Schaltung muss also nur bei der ersten Inbetriebnahme an der seriellen Schnittstelle angeschlossen sein. Außerdem gibt es die Möglichkeit, eine statische IP-Adresse anzugeben, so dass der WebSocket-Server immer unter einer festen Adresse erreichbar ist.

Auf dem PC kann die serielle Schnittstelle z.B. mit dem seriellen Monitor der Arduino-Umgebung oder einem der vielen Terminal-Programme bedient werden. Der Dialog zur Auswahl des Netzwerks und zur Abfrage des Passwords sieht so aus:

Dialog über die serielle Schnittstelle zur Auswahl des Netzwerks und Eingabe der Credentials

Hier eine kurze Beschreibung, wie das Modul web_socket in der Praxis eingesetzt wird. Es enthält die Klasse Socket. Ein Objekt dieser Klasse wird im Anwenderprogramm als globale Variable erstellt.

#include "web_socket.h"
Socket ws;                    // web socket communication

Das Objekt stellt alle Funktionen zum Aufbau der Verbindung und zur Kommunikation mit dem Client bereit. Zuerst wird die Methode begin() aufgerufen. Damit werden die Netzwerk-Daten aus dem nichtflüchtigen Speicher kopiert, sofern sie dort vorhanden sind. begin() meldet true zurück, wenn das der Fall ist. Für den Verbindungsaufbau zum WLAN gibt es die Methode connect(), und zwar in drei Varianten.

  1. connect() ohne Argumente verwendet die vorhanden Netzwerkdaten aus dem nichtflüchtigen Speicher.
  2. connect(ssid, password) stellt eine Verbindung für das angegebene Netzwerk her, wobei die IP-Adresse dynamisch vom Router zugewiesen wird.
  3. connect(ssid, password, static_ip, gateway_ip) stellt eine Verbindung mit einer statischen IP-Adresse her. Das kann natürlich nur dann funktionieren, wenn auf dem Router die statische IP-Adresse auch verfügbar ist.

Wenn eine Verbindung erfolgreich aufgebaut ist, werden die Netzwerk-Daten in den nichtflüchtigen Speicher kopiert und stehen dort für den nächsten Systemstart zur Verfügung.

Die manuelle Auswahl des Netzwerkes mit dem oben gezeigten Dialog kann mit der Methode select() ausgelöst werden. All das kann in der Arduino setup()-Funktion komfortabel erledigt werden, z.B. so:

//--------------------------------------------------------------------
void setup() {
  // start network connection
  if (ws.begin()) {   // check if network credentials are on file
    ws.connect();     // if yes, connect to network
  } else {
    ws.select();      // if not, enter network selection dialog
  }

Senden und Empfangen

Jetzt können eingehende Nachrichten mit read_chararray(char buf[], int size) gelesen oder ausgehende Nachrichten mit send(char buf[]) gesendet werden. Um die Sache einfach zu halten, beschränke ich mich auf Text-Nachrichten von maximal 256 ASCII-Zeichen. Das ist für die kleinen Datenmengen, um die es hier geht, völlig ausreichend und hat den angenehmen Nebeneffekt, dass der Programmierer bei Bedarf mitlesen kann.

Das Modul web_socket enthält einen internen Puffer (2048 Bytes), der mehrere eingehende Nachrichten aufnehmen kann. Die Methode available() gibt die aktuelle Zahl der Zeichen im Eingangspuffer aus.

Hier ist eine Übersicht der Methoden des Objekts Socket:

public:
    bool begin(void);
    void connect(void);
    void connect(char ssid[], char password[]);
    void connect(char ssid[], char password[], char local_ip_chr[], char gateway_ip_chr[]);
    void disconnect(void);
    void select(void);                // select network for connection via dialog
    uint16_t available(void);         // returns number of chars in buffer
    void read_chararray(char buf[], int size);
    void send(char buf[]);
    void get_local_ip(char buf[]);    // copies local IP address to buf[]
    uint8_t get_port(void);           // returns port for websocket server
    bool get_net_status(void);        // true if WLAN connection exists
    bool get_socket_status(void);     // true if websocket client is connected
    void run_socket_loop(void);       // needs to be executed frequently

Wichtig ist, dass die Methode run_socket_loop() regelmässig aufgerufen wird. Diese Funktion bedient die webSocket.loop(), die benötigt wird, um auf Ereignisse zu reagieren. In meinen Anwendungen wird run_socket_loop() mehrmals pro Sekunde aufgerufen. So werden timeout-Fehler auf der Client-Seite vermieden.

Gesprächsbedarf: Das Protokoll

Für die Kommunikation zwischen Client und Sever verwende ich bei meinen Projekten ein einfaches Protokoll. Dabei sendet der Client eine Anfrage an den Server. Diese Anfrage beginnt immer mit einem “Command-Token”. Das ist ein ASCII-Zeichen, das die Art der Anfrage kennzeichnet. Gegebenenfalls können zusätzliche Daten folgen. Der Server antwortet dann mit den gewünschten Daten und/oder führt die jeweilige Aktion aus, z.B. An- oder Ausschalten einer LED. Ich habe mir angewöhnt, in jedem Fall eine Antwort zum Client zu senden, auch dann, wenn eigentlich kein Bedarf für eine Rückmeldung besteht. So kann der Client sicherstellen, dass er “gehört” wurde.

Das Protokoll für den Datenaustausch ist für das konkrete Beispiel sehr einfach. Es gibt die folgenden Command-Token:

Die Arduino loop()-Funktion des EPS32 hat die Aufgabe, das serielle Interface und den WebSocket-Server ständig abzufragen, ob eine Nachricht angekommen ist. Wenn das der Fall ist, wird die einkommende Nachricht in der Funktion process_input() bearbeitet, also z.B. der Luftdruck-Wert gelesen und oder eine der LEDs geschaltet. Die booleschen Variablen net_input und ser_input merken sich, aus welchem Kanal die Eingabe kam, und verwendet diese, um die Antwort an den richtigen Kanal zurück zu senden.

  // check for input via websocket or serial interface
  ws.run_socket_loop();
  if (ws.available() > 0) {
    ws.read_chararray(input_buf, BUF_SIZE);
    net_input = true;
  } else if (Serial.available() > 0) {
    get_serial_input(input_buf, BUF_SIZE);
    ser_input = true;
  }

  // process input
  if (net_input || ser_input) 
    process_input(input_buf, output_buf, ser_input);

  // send output back to client
  if (net_input) {
      ws.send(output_buf);
      net_input = false;
  };
  if (ser_input) {
    Serial.println(input_buf);
    Serial.println(output_buf);
    ser_input = false;
  }

Der Luftdruck bekommt eine zusätzliche Behandlung: Die eigentlich interessante Information ist die zeitliche Entwicklung. Deshalb wird alle 10 Minuten der Luftdruck gemessen und in einem Array float pres_trend[] abgelegt. Dort ist Platz für 30 Werte, also die Daten der letzten 5 Stunden. Die Daten können mit dem Command-Token “D” abgerufen werden. Daraus produziert der Client eine kleine Grafik zum zeitlichen Verlauf.

Das Protokoll kann mit dem seriellen Monitor der Arduino-IDE sehr schön ausprobiert werden. Die ASCII-String-Kommunikation macht es möglich. Hier eine Beispiel-Session mit dem seriellen Monitor der Arduino-IDE:

Das Protokoll wird an der seriellen Schnittstelle ausprobiert. Die Pfeile markieren die Eingaben von der Tastatur.

WebSocket Client

Für erste Tests verwende ich ein einfaches Python Skript, das auf einem PC oder Raspberry Pi läuft. Der PC und der ESP32 müssen in demselben Netzwerk angemeldet sein, so dass sie sich im Netzwerk “sehen” können. IP-Adresse und Port-Nummer des Servers müssen natürlich bekannt sein, in meinem Fall 192.168.1.210 und Port 90.

Auf der Python-Seite verwende ich das Modul websocket, das gegebenenfalls mit pip nachinstalliert werden muss. Das Skript verbindet sich mit dem WebSocket-Server, wartet auf einer User-Eingabe, sendet diese an den Server und zeigt die Antwort. Natürlich kann es immer die Situation geben, dass der Server nicht erreichbar ist (z.B. abgeschaltet oder hat eine andere IP-Adresse). Dafür gibt es eine Fehlerbehandlung mit try … except. 

import time
import websocket

def send_msg(msg):
    """ Sends a message to the websocket server.
        Returns the response """
    try:
        ws.send(msg)
        result = ws.recv()
    except OSError as err:
        print(err)
        result = ""
    return result

#------------------------------------------
ws = websocket.WebSocket()
ip = "192.168.1.210:91"  # ip address and port
try:
    ws.connect("ws://" + ip, timeout=3)
    print("Connected to WebSocket server, IP", ip)
    connection = True
except OSError as err:
    connection = False
    print(err)

if connection:
    while True:
        instr = input("> ")
        if len(instr) == 0:
            break
        print(send_msg(instr))
    ws.close()
    print("Connection closed")

Jetzt sind die Dienstleistungen des WebSocket-Servers genau wie mit der seriellen Schnittstelle abrufbar. Hier eine Beispiel-Session mit der Python-Shell:

Zum Abschluss: Eine GUI-Applikation mit Wetter-Daten

Nachdem die Verbindung zuverlässig und stabil ist, kann man mit etwas Python und TKinter eine kleine GUI-Applikation zusammensetzen. Das Skript besteht aus nur einem File “bme.py”. Es öffnet ein Fenster auf dem Desktop, platziert alle Widgets und führt ein regelmäßiges Refresh der Daten durch, so dass die Daten immer aktuell sind. Damit die Datenbeschaffung per WebSocket die Antwortzeiten des User-Interface nicht beeinträchtigt, wird sie in einen eigenen Thread ausgelagert, der im Hintergrund läuft und alle 120 Sekunden die aktuellen Werte anfordert. Außerdem gibt es noch eine Konfigurations-Datei bme_config.dat, in der die wichtigsten Parameter, besonders die IP-Adresse und die Port-Nummer bereit liegen müssen. Diese Datei wird beim Start des Python-Skripts eingelesen.

Die Datei bme_config.dat hält die wichtigsten System-Parameter bereit.

Das Ergebnis ist eine kleine “Wetter-App”, die die Daten vom BME280 auf dem Desktop sichtbar macht.

Downloads

Der Source Code für die Arduino-Anwendung und alle hier erwähnten Python-Skripts sind auf GitHub verfügbar. Dort befinden sich auch der Schaltplan und weitere Fotos.

Link: smlaage/esp32_websocket: ESP32 WebSocket Server with Python Client (github.com)

WLAN IR Brücke mit ESP32

Der letzte Blog-Eintrag Lernende Infrarot-Fernbedienung hat gezeigt, wie man mit dem ESP32 Infrarot-Fernbedienungssignale aufzeichnen und wiedergeben kann. Nachdem das gut funktioniert, ergibt sich die Frage, ob man die IR-Kommandos über eine WiFi-Verbindung (statt mit den Tastern an der Schaltung) steuern kann. In diesem Eintrag geht es darum, die angelernten IR-Kommandos über eine Web-Page abrufbar zu machen, eine WLAN-IR-Brücke.

Wofür braucht man so etwas? Es ist doch sehr komfortabel, ein elektronisches Gerät, z.B. eine Radio oder eine Stereo-Anlage, mit der zugehörigen Fernbedienung direkt zu steuern. Tatsächlich gibt es aber durchaus Fälle, in denen der Zugriff über eine Web-Page hilfreich sein kann, z.B., wenn das Gerät in einem anderen Raum steht und über IR nicht erreichbar ist, oder das Radio aus der Ferne an – oder ausgeschaltet werden soll.

Dieses Projekt hat zwei Komponenten. Erstens wurden die IR-Funktionen aus dem vorherigen Blog-Eintrag in eine eigene C++-Klasse IR_Module verpackt, wodurch sie einfacher zu verwenden sind. Zweitens kommt das WiFi-Modul des ESP32 zum Einsatz, um eine Web-Page mit Buttons zu erzeugen. Die Web-Page ist mit jedem normalen Browsers auf Computer, Tablett oder Handy aufrufbar, ohne dass weitere Installation auf dem Gerät notwendig sind. Aber der Reihe nach:

Die Hardware

Im Vergleich zum vorherigen Beispiel ist die Schaltung etwas einfacher geworden. IR-Empfänger und IR-Sender mit Transistor und IR-LED bleiben unverändert. Es gibt jetzt nur noch einen Taster, der zum Anlernen der IR-Fernbedienung benötigt wird. Die Tasten zum Abruf der IR-Signale sind nicht mehr nötig, weil der Abruf jetzt über die Buttons auf der Web-Page geschieht. Schließlich gibt es noch eine zweifarbige Leuchtiode zur Kommunikation mit dem Anwender.

Die Schaltung ist einfacher geworden. Die Hardware-Taster zum Auslösen der IR-Kommandos sind verschwunden. Sie werden durch Buttons auf der Web-Page ersetzt.
Aufbau der WLAN-IR-Bridge auf einem Breadboard

Klasse IR_Module

Die Vorgehensweise zum Lernen und Abspielen von IR-Signalen wurden im vorherigen Blog-Eintrag beschrieben. Um die Anwendung der zugehörigen Funktionen zu vereinfachen, haben ich Daten und Funktionen in einer Klasse zusammengefasst. Der Quellcode der Klasse besteht aus zwei Dateien, die Header-Datei ESP32_IR_module.h und die Methoden-Datei ESP32_IR_module.cpp.

In der Header-Datei werden die benötigten Daten bereit gestellt. Dreh- und Angelpunkt sind die Daten der IR-Signale. Sie werden in einem zweidimensionalen Array ir_data[][] abgelegt. 

uint32_t ir_data[CHANNEL_MAX][IR_DATA_SIZE];     
int ir_data_len[CHANNEL_MAX];
int channel_cnt = 0;

Man kann sich das Array als Tabelle mit Zeilen und Spalten vorstellen. Jede Zeile bildet ein IR-Kommando und enthält als Spalten die Ein- und Ausschalt-Zeitpunkte des zugehörigen IR-Signals. Das Array verwendet 32-Bit-Integer Variablen, die die Zeitpunkte in Mikrosekunden relativ zum Anfang des Signals darstellen. Der ESP32 biete viel Speicherplatz. Hier werden maximal 10 (definiert in CHANNEL_MAX) angelernte Kommandos mit jeweils bis zu 250 (definiert in IR_DATA_SIZE) Umschaltzeitpunkten bereit gestellt. Es hat sich gezeigt, dass die Datenmenge ausreichend für die üblichen Anwendungen ist.

Das eindimensionale Array ir_data_len[] hält fest, wieviel Datenpunkte in jeder Zeile von ir_data[][] tatsächlich verwendet werden. Die Variable channel_cnt enthält die aktuelle genutzte Anzahl der IR-Signale, also die Zahl der verwendeten Zeilen.

Die Klasse stellt eine Reihe von Methoden bereit. load_ir_data(), save_ir_data() und clear_ir_data() dienen dem Speichermanagement. Die angelernten IR-Daten werden mit save_ir_data() in den permanenten “non-volatile” Speicher übertragen. Beim Systemstart können sie mit load_ir_data() aus dem permanenten Speicher in das RAM geladen und damit verfügbar gemacht werden. Mit clear_ir_data() werden die bestehenden Daten gelöscht, z.B. wenn eine neuen Fernbedienung angerlernt werden soll.

Mit der Methode read_ir_data() werden IR-Daten angelernt. Dabei wartet die Schaltung auf IR-Signale von einer Fernbedienung und speichert neue Kommandos ab. Die Funktion führt auch eine einfache Plausibilitäts-Prüfungen durch und quittiert IR-Impulse, die offensichtloch kein sinnvolles IR-Fernbedienungssignal darstellen, mit einer Fehlermeldung.

Die Methode play_ir_data(int channel) spielt das angewählte IR-Signal aus dem Speicher ab, sendet also das gewünschte Signal aus.

Die Methode print_ir_data(int chnnel) gibt die Daten eines Kanals auf dem seriellen Monitor aus. Das ist nur für debugging-Zwecke gedacht.

Und schließlich gibt es noch die Methode get_channel_cnt(), die die Anzahl der gespeicherten IR-Kommandos zurück gibt.

Um die Klasse zu verwenden, muss das aufrufende Programm ein Objekt vom Typ IR_Module anlegen, üblicherweise als globale Variable, so dass alle Funktionen darauf zugreifen können. Der Konstruktor benötigt die Pin-Nummern, an denen der IR-Empfänger und der IR-Sender angeschlossen sind.

IR_Module ir(34, 33);    // receiver and transmitter pin number

Web-Server mit dem ESP32

Es wurde schon viel über das WiFi-Modul des ESP32 geschrieben, deshalb hier nur in Kürze. Ich verwende einen Web-Server, der sich mit einer festen (statischen) IP-Adresse (hier 192.168.1.222) in das Heimnetzwerk einklinkt. Der Vorteil der statischen IP-Adresse ist, dass die zugehörige Web-Page direkt über die IP-Adresse abrufbar ist. Natürlich muss sichergestellt werden, dass die IP-Adresse im Netzwerk frei und verfügbar ist. Gegebenenfalls lässt sich das im Router einstellen. Der zugehörige Programm-Code sieht so aus:

#include <WiFi.h>
#include <WebServer.h>

// Create webserver operating on port 80, set static IP address
WebServer server(80);
IPAddress local_IP(192, 168, 1, 222);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

In der Arduino-Setup-Funktion verbindet sich der Web-Server mit dem Netzwerk. Die Zugangsdaten mit SSID und Passwort sind der Einfachheit halber direkt in den Programm-Code eingebettet. Während des Verbindungsaufbaus blinkt die rote LED. Wenn alles geklappt hat, gibt es eine Sekunde lang ein grünes Signal.

// Connect to WiFi network
if (!WiFi.config(local_IP, gateway, subnet)) {
  Serial.println("Failed to configure static IP address");
}
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  digitalWrite(led_green, !digitalRead(led_green));
  Serial.print(".");
  delay(500);
}
Serial.println();
Serial.println("WiFi connected");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
digitalWrite(led_green, HIGH);
delay(1000);
digitalWrite(led_green, LOW);

Wenn die Verbindung steht, kann der Web-Server gestartet werden. Die Web-Page ist dann über die http://192.168.1.222 erreichbar.

Die Tasten werden als eigene Seiten unter dieser Adresse, also über 192.168.1.222/0, …/1, …/2 usw. bereit gestellt. Wenn eine Taste auf der Web-Page gedrückt wird, erzeugt der Browser einen Aufruf der entsprechenden URL. Der Web-Server des ESP32 empfängt den Aufruf und leitet ihn auf die Funktion handle_channel(). Diese führt dann die gewünschte Aktion aus, als das Abspielen des jeweiligen IR-Signals.

Der Start des Web-Servers in der setup()-Funktion ist hier gezeigt:

 // prepare and start web server
  char url_str[4] = "/ ";
  server.on("/", handle_OnConnect);
  for (int button_channel = 0; button_channel < CHANNEL_MAX; ++button_channel) {
    url_str[1] = '0' + button_channel;
    server.on(url_str, handle_channel);
  }
  server.onNotFound(handle_NotFound);
  server.begin();

Schließlich fehlt noch der HTML-Code, der an den Browser gesendet wird, wenn dieser sich mit der Seite verbindet. Dazu dient die Funktion send_html(), die den HTML-Code generiert und an den Client sendet. Die Buttons sind als Cascading Style Sheets (CSS) in den HTML-Code integriert. Der CSS-Code definiert die Farbe, Größe und Text der Buttons. Außerdem sorgt der Code mit Hilfe des Strings href dafür, dass bei einem Tastendruck die entsprechende URL aufgerufen wird. Damit ist der Kreis zum Web-Server und der Funktion handle_channel() geschlossen.

Die Hauptarbeit des Programms wird vom Web-Server und der Funktion handle-channel() übernommen. Entsprechend kurz fällt die Arduino loop()-Funktion au. Hier wird abgefragt, ob die Learn-Taste der Schaltung für mindestens 3 Sekunden gedrückt wurde. Wenn das der Fall ist, dann verzweigt das Programm in die Funktion learn_sequence(), die zum Anlernen einer neuen IR-Fernbedienung dient. Außerdem wird regelmäßig die Methode handleClient() des Web-Servers aufgerufen. Dadurch wird sichergestellt, dass der Web-Server auf die Verbindungsaufnahem durch einen Client reagiert.

void loop() {
  uint8_t learn_pressed_cnt = 0;

  // check whether the learn button is pressed for at least 3 seconds
  while (digitalRead(bt_learn) == LOW) {
    delay(200);
    ++learn_pressed_cnt;
    if (learn_pressed_cnt >= 15) {
      learn_sequence();
      ir.save_ir_data_set();
      learn_pressed_cnt = 0;
    }
  }

  // manage requests from web clients
  server.handleClient();
}

Inbetriebnahme

Hier eine kurze Beschreibung, wie die Schaltung und das Programm in Betrieb genommen werden.

Das Programm besteht aus 3 Dateien: ESP32_WLAN_IR_Bridge.ino, ESP32_IR_module.cpp und ESP32_IR_Module.h. Alle 3 Dateien müssen im entsprechenden Arduino-Folder liegen.

In der Datei ESP32_WLAN_IR_Bridge.ino gibt es einige Anpassungen am Anfang des Programms zu machen. Name und Zugangspasswort für das Heimnetz müssen bei SSID und Password eingetragen werden. Die globale Konstante char *bt_labels bietet die Möglichkeit, die Buttons auf der Web-Page mit sinnvollen kurzen Labels zu versehen, je nachdem, was die IR-Steuerung machen soll. Das Programm kann maximal 10 Buttons (Kanäle) bedienen. Im Zweifelsfall kann man einfach eine fortlaufende Nummer verwenden. Schließlich sollte die statische IP-Adresse entsprechende den eigenen Bedürfnissen angepasst werden

// network credentials - insert your data
const char ssid[] = "your network name";
const char password[] = "your network password";

// Labels for up to 10 buttons on the web page - customize for your needs.
const char *bt_label[] = {"On/Off", "Mode", "Vol +", "Vol -", "P +", "P -", "7", "8", "9", "10"};

// Create webserver operating on port 80, set static IP address
WebServer server(80);
IPAddress local_IP(192, 168, 1, 222);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

Wenn das Programm kompiliert und auf den ESP32 übertragen ist, ist das System einsatzbereit. Nach dem Einschalten verbindet sich der ESP32 mit dem Netzwerk. Das ist an der blinkenden Leuchtdiode erkennbar. Wenn die Verbindung erfolgreich ist, zeigt die LED eine Sekunde lang grün und geht dann aus. Die Web-Page ist jetzt über einen Browser über die IP-Adresse abrufbar.

Zum Anlernen einer IR-Fernbedienung muss die Lern-Taste für mindestens 3 Sekunden gedrückt werden. Achtung, dadurch werden alle bestehenden Daten gelöscht! Die blinkende LED zeigt jetzt an, dass die Schaltung bereit ist zum Lernen. Die gewünschten Fernbedienung wird auf den IR-Empfänger gerichtet und die erste Taste kurz (!) gedrückt. Wenn das Signal akzeptiert wurde, leuchtet die LED grün auf. Nach einer kurzen Pause ist die Schaltung bereit zum Lernen der nächsten Taste, was wieder durch Blinken angezeigt wird. Das Spiel geht solange, bis entweder für 20 Sekunden keine IR-Signal mehr kommt oder der Speicher mit 10 gelernten Tasten voll ist. Übrigens hat sich in der Praxis gezeigt, dass beim Anlernen direkte Beleuchtung mit manchen LED-Lampen etwas stören kann. Wenn es Probleme gibt, kann es helfen, z.B. das Schreibtischlicht auszuschalten.

Die WLAN-IR-Brücke wird mit den IR-Signalen einer Fernbedienung angelernt.

Nach dem erfolgreichen Lern-Prozess sind die IR-Kommandos über die Web-Page verfügbar. Die IR-Sende-Diode sollte in die Richtung des zu gewünschten Geräts gerichtet sein. Die IR-Kommandos stehen über die Web-Page via Computer oder Handy zur Verfügung, und das Zielgerät kann über das Web gesteuert werden.

So meldet sich der ESP32 beim Aufruf mit dem Browser.

Wie immer an dieser Stelle wünsche ich viel Spaß mit dem kleinen Projekt. Rückmeldung, Kommentare und Verbesserungsvorschläge sind willkommen.

Arduino-Software zur ESP32 WLAN-IR-Bridge

ESP32_WLAN_IR_BridgeHerunterladen

Lernende Infrarot-Fernbedienung mit ESP32

In einem Kurs mit dem ESP32 kam die Frage, ob man einen Sender für eine Infrarot-Fernbedienung selbst bauen kann. Ja, das geht. Es ist eine schöne Anwendung für den ESP32.

Zielvorgaben

Worum geht es also? Die Idee war, Signale von einer vorhandenen Infrarot-Fernbedienung einzulesen und dann gesteuert durch den Mikrocontroller zu reproduzieren. Der Controller kann z.B. zu einer bestimmten Zeit das Radio einschalten. Oder man kann einen kleinen Web-Server programmieren, der vom Smartphone gesteuert Licht oder Musik ein- oder ausschaltet. Geräte lassen sich automatisch steuern, ohne dass irgendein Eingriff in das Gerät notwendig ist. Vieles ist denkbar.

Um die Komplexität in Grenzen zu halten, nehmen wir für den Anfang nur drei Kanäle. Es soll also 3 Tasten geben, die jeweils ein angelerntes Signal abspielen können. Eine weitere Taste wird gebraucht, um das kleine Gerät in den Lernmodus zu versetzen. Wenn die Anlern-Taste für eine bestimmte Zeit (hier 3 Sekunden) gedrückt wird, soll das Gerät bereit sein, Signale von einer IR-Fernbedienung zu empfangen und aufzuzeichnen. Schließlich möchten wir noch Leuchtdioden haben, die den aktuellen Status anzeigen. Und die angelernten Daten sollen natürlich dauerhaft über das Stromabschalten hinaus erhalten bleiben. Das ist dann eigentlich schon alles.

IR Signal-Übertragung

Wie funktioniert die IR-Signalübertragung? Die üblichen IR-Sender produzieren Lichtsignale, die mit einer festen Frequenz zwischen 36 und 40 kHz moduliert sind, also sehr schnell ein- und ausgeschaltet werden. Dieser Frequenzbereich wurde gewählt, um den Signalabstand zu Störungen möglichst groß zu halten, denn schließlich ist Infrarotlicht allgegenwärtig, sei es als natürliches Licht von der Sonne oder als gepulstes Licht von diversen Lampen. Die eigentliche Information (z.B. “Radio einschalten”) befindet sich digital kodiert in der zeitlichen Abfolge von kurzen und langen Pulsen (“bursts”) mit z.B. 38 kHz. Ein typisches Signal von einer Fernbedienung kann z.B. 30 Millisekunden lang sein und 30, 40 oder 50 Pulse von kurzer oder langer Dauer enthalten.

Soweit die Theorie. Zum Glück ist in diesem Fall die Praxis nicht weit: Man kann mit einem Oszilloskop das Signal einer IR-Fernbedienung an einer Infrarot-Photodiode gut beobachten.

Schaltung zur Messung des Infrarot-Signals mit einer IR-Fotodiode. Die Fotodiode muss in Sperrrichtung gepolt sein.
Gemessene 38 kHz Bursts einer IR-Fernbedienung, hier eine “Bose Wave” Anlage. Einzelne Bursts sind etwa 550 Mikrosekunden lang. Die gesamte Sequenz erstreckt sich über 30 Millisekunden.

Für unsere Anwendung müssen wir das Signal zum Glück nicht “verstehen”. Aber es muss möglichst exakt aufgezeichnet und wieder abgespielt werden, damit das empfangende Gerät entsprechend reagiert.

Hardware

Es ist relativ einfach, IR-Signale mit einem Mikrocontroller zu generieren. Mit einem Timer wird eine Rechteckschwingung von 38 kHz erzeugt und auf einen der Ports gegeben. Typische IR-Leuchtdioden vertragen Ströme von bis zu 100 mA, was den Port überfordern würde. Deshalb kommt ein einfacher Transistor hinzu, z.B. ein BC337, der das Signal verstärkt. Um die 3.3V Board-Spannung des ESP32 nicht zu sehr durch die 38 kHz Pulse von 100mA zu belasten, wird die Infrarot-LED mit einem 33 Ohm Widerstand nach +5V verschaltet. Damit ist der Strom auf etwas unter 100 mA begrenzt.

Auf der Empfangsseite wird eine Schaltung benötigt, die möglichst empfindlich und gleichzeitig selektiv 38 kHz-IR-Signale herausfiltert und diese dann als digitale Zustände Ein (= Signal vorhanden) oder Aus (= kein Signal vorhanden) verfügbar macht. Das könnte aufwendig werden, wenn es dafür nicht fertige und preisgünstige Komponenten gäbe. Ich verwende den TSOP1138. Dieser oder ähnliche Empfänger mit guter Selektivität und hoher Empfindlichkeit sind in der Arduino-Welt verbreitet und z.B. in Funduino-Bausätzen enthalten. Der TSOP1138 hat drei Anschlüsse: Ground, Spannungsversorgung Vs und Signalausgang. Das Datenblatt sagt, dass die Betriebsspannung 5V betragen sollte. Tatsächlich habe ich sehr gute Ergebnisse mit den 3.3V des ESP32 erreicht. Es besteht also kein Bedarf für Pegelumsetzer.

TSOP1138

Schließlich kommen noch 4 Taster und 3 Leuchtdioden dazu. Damit ist die Hardware komplett. Die Schaltung ist einfach und kann gut auf einem Steckbrett aufgebaut werden.

Schaltbild IR Remote Control
Die Schaltung ist schnell auf einem Breadboard zusammengesetzt. Oben links befindet sich die IR-Sende-Diode mit dem Transistor zur Verstärkung. Oben mittig ist der IR-Empfänger. Taster und Leuchtdioden befinden sich auf der rechten Seite.

Wenn der Schaltplan klar ist, kann man die entsprechenden GPIO-Nummern im Sketch bereitstellen. Das geschieht im Programm ganz am Anfang als globale Konstanten. Damit sind die Definitionen an einem Ort und können bei Bedarf schnell angepasst werden.

// pin assignments
const int bt_learn = 16;
const int bt_play[] = {17, 5, 18};
const int ir_receiver = 34, ir_transmitter = 33;
const int led[] = {27, 26, 25};

Software

Der eigentlich spannende Teil des Projekts ist die Software. Natürlich gibt es ausgefeilte Bibliotheken für die Bearbeitung von Infrarot-Signalen mit einem Arduino (z.B. die multi-protocol-infrared-remote-library von Ken Shirriff). Diese sind aber nicht unbedingt für den ESP32 geeignet. Außerdem fand ich es interessanter, die notwendige Funktionalität mit Board-Mitteln zu programmieren.

System-Takt in Mikrosekunden

Grundsätzlich gibt es zwei mögliche Ansätze, um Zeitverläufe von Signalen aufzuzeichnen:

  1. Man kann mit einem regelmäßigen, möglichst engen Abstand den Zustand des Eingangs-Port testen und den jeweils aktuellen Wert als 0 oder 1 abspeichern. Üblich ist z.B. eine Abtastrate von 50 Mikrosekunden. Der Nachteil dieser Methode besteht darin, dass die Abtastrate unweigerlich einen möglichen zeitlichen Fehler (hier +/- 25 Mikrosekunden) mitbringt.
  2. Alternativ kann der Eingangs-Port ständig mit hoher Geschwindigkeit abgefragt (“Polling”) und jeweils der Zeitpunkt der Umschaltung aufgezeichnet werden. Wenn das Polling ausreichend schnell geschieht, ist die zeitliche Auflösung dieser Methode besser. Dieser Ansatz setzt allerdings eine möglichst exakte System-Uhr im Bereich von Mikrosekunden voraus.

Glücklicherweise verfügt der ESP32 über genau das: Eine Timer-gesteuerte System-Uhr, die die Anzahl der Mikrosekunden seit dem Einschalten zur Verfügung stellt: esp_timer_get_time() (siehe ESP Referenz). Die Ausführung der Funktion benötigt selbst weniger als eine Mikrosekunde, stellt also keine besondere Systemlast dar.

Die Zeitpunkte (Mikrosekunden) des Anfangs (Einschalten) und Ende (Ausschaltens) der einzelnen Bursts werden in Arrays abgelegt. Da wir mit 3 Kanälen arbeiten, gibt es ein zwedimensionales Array, um die Signal-Zeitpunkte abzuspeichern: ir_data[3][250] . Es enthält drei Zeilen, wobei jede Zeile bis zu 250 Datenpunkte aufnehmen kann. In meinen bisherigen Versuchen waren in der Regel nie mehr als 100 Datenpunkte für ein IR-Signal notwendig – aber es kann nicht schaden, Luft nach oben zu lassen.

Zusätzlich benötigen wir noch jeweils eine Integer-Variable, die die tatsächliche Anzahl der Einträge in den Arrays abspeichert. Ich nenne sie ir_data_len[3], ebenfalls ein Array mit 3 Werten für drei Kanäle. ir_data[][] und ir_data_len[] werden als globale Variablen definiert, also im Programmablauf vor allen Funktionen. 

// global constants 
const int channel_cnt = 3;                  // this version supports 3 channels (maximum is 10)
const uint16_t ir_data_size = 250;          // size of ir data sequence

// global variables
Preferences prefs;                            // access to non volatile storage (NVS)
uint32_t ir_data[channel_cnt][ir_data_size];  // IR data set, 3 rows of up to 250 data items each
int ir_data_len[channel_cnt] = {0, 0, 0};
bool learn_bt_pressed = false;

Funktion read_ir_data()

Damit wird die Funktion zum Einlesen der IR-Signale read_ir_data() unkompliziert. Die Funktion übernimmt einen Zeiger auf das Daten-Array, in dem die Daten abgelegt werden, und einen Zeiger auf die zugehörige Zähler-Variable. Am Anfang des Lesevorgangs wartet die Software auf das erste Signal von der IR-Fernbedienung und erfasst die aktuelle Startzeit (start_time). Ab jetzt wird bei jedem Wechsel des Eingangs-Ports die aktuelle Zeit gelesen, die Differenz zur Startzeit errechnet (time_stamp) und diese im Array gespeichert. Die boolesche Variable edge sorgt für die Unterscheidung zwischen dem Wechsel von LOW -> HIGH oder HIGH -> LOW. Nach dem Ablauf der voreingestellten Zeit, hier 250 Millisekunden, wird die Erfassung beendet. Die Arrays mit den Umschalt-Zeitpunkten bilden die Datenbasis für eine exakte Reproduktion des Signals.

/* read_ir_data ---------------------------------------------------------------------------
Reads a sequence of ir data via the IR receiver. Captures the start- and stop time points
of each burst and stores them to the array ir_data[]. Data reading continues until either 
the data storage is exceeded or reading timeout is reached. Flashes the corresponding LED
during the reading process. 
Input:    channel -> channel number (0 … 2)
Output:   array ir_data -> ir data points
          int *ir_data_len -> number of data points stored in the array 
*/
void read_ir_data(int channel, uint32_t ir_data[], int *ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;            // false for falling edge, true for rising edge

  ledcAttachPin(led[channel], led_pwm_channel);                     // flash LED
  ledcWrite(led_pwm_channel, 128);
  *ir_data_len = 0;                                                    // reset array index
  while (digitalRead(ir_receiver) == HIGH);                         // wait for falling edge
  start_time = esp_timer_get_time();                                // capture start time
  do {
    time_stamp = (uint32_t) (esp_timer_get_time() - start_time);    // refresh time stamp 
    if (edge) {                                                     
      if (digitalRead(ir_receiver) == HIGH) {                       // waiting for rising edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp
        ++*ir_data_len;
        edge = false;                                               // switch to falling edge
      };  
    } else {                                                       
      if (digitalRead(ir_receiver) == LOW) {                        // waiting for falling edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp 
        ++*ir_data_len;
        edge = true;                                                // switch to rising edge
      };  
    };
  } while ((time_stamp < ir_read_timeout) && (*ir_data_len < ir_data_size));
  ledcDetachPin(led[channel]);                                      // clear flashing LED
  digitalWrite(led[channel], HIGH);                                 // switch off LED
}

Um die Arbeitsweise zu kontrollieren, gibt es eine Funktion print_ir_data(), die die eingelesenen Daten auf dem seriellen Monitor ausgibt. Hier die Daten für “Einschalten” bei der “Bose Wave” Anlage. Das Signal wird zum Zeitpunkt 0 eingeschaltet, nach 1047 Mikrosekunden aus, dann nach 2499 Mikrosekunden wieder ein, nach 3040 Mikrosekunden aus, usw.

Channel 0  IR data (71):
1047, 2499, 3040, 3521, 4041, 4491, 5032, 6490, 7034, 8489, 9038, 
9512, 10029, 10507, 11030, 12480, 13023, 13503, 14024, 15475, 16016, 17475, 
18019, 18497, 19010, 19466, 20011, 21465, 22015, 23465, 24007, 24486, 25009, 
26452, 27001, 77482, 78523, 79984, 80526, 81005, 81527, 82002, 82518, 83975, 
84521, 85974, 86524, 86992, 87515, 87992, 88516, 89964, 90508, 90987, 91510, 
92960, 93502, 94960, 95505, 95981, 96496, 96950, 97498, 98949, 99500, 100949, 
101493, 101971, 102494, 103937, 104486

PWM zur Erzeugung des 38 kHz-Signals

Zum Abspielen der aufgezeichneten Signale muss ein 38 kHz-Signal erzeugt und entsprechend ein- und ausgeschaltet werden. Dazu eignet sich die PWM-Funktion der Arduinos. Diese unterscheidet sich beim ESP32 von den 8-Bit-Arduinos, die über die Funktion analogWrite() verfügen. Der ESP32 hat mehr Hardware-Möglichkeiten, insbesondere mehr PWM-Kanäle. Hier wird die PWM mit drei Low Level-Funktionen gesteuert. 

1) ledcSetup(<channel>, <frequency>, <bit resolution>); 
2) ledcAttachPin(<GPIO no>, <channel>);
3) ledcWrite(<channel>, <duty cycle>);

Mit ledcSetup() wird der gewünschte PWM-Kanals konfiguriert. Die Frequenz ist in unserem Fall 38 kHz. Die Funktion ledcAttachPin() bindet den PWM-Kanal an einen der Ausgabe-Ports (hier der Port für die Infrarot-Leuchtdiode). Schließlich setzt ledcWrite() den gewünschten Duty-Cycle. Wir arbeiten mit einer Bit Resolution von 8, so dass der Wert für Duty Cycle zwischen 0 (entspricht dauerhaft Aus) und 255 (entspricht dauerhaft Ein) liegen darf.

Eine gute Zusammenfassung der PWM beim ESP32 gibt es hier: EPS32 Arduino LED PWM Fading.

Der entsprechende Code im setup()-Block sieht so aus:

  // setup PWM for IR transmitter
  ledcSetup(ir_pwm_channel, ir_pwm_frequency, 8);    // pwm runs with 8 bit resolution
  ledcAttachPin(ir_transmitter, ir_pwm_channel);
  ledcWrite(ir_pwm_channel, 0);                      // switch off the IR transmitter for now

Funktion play_ir_data()

Im Programm übernimmt die Funktion play_ir_data() die Aufgabe, das IR-Signal – basierend auf den angelernten Daten – zu reproduzieren. Dabei kommt wieder die System-Uhr zur Hilfe, um im richtigen Moment die jeweiligen Bursts ein- oder auszuschalten. Einschalten heißt, den Duty-Cycle auf die Hälfte des Maximalwertes, also 128, zu setzen, so dass das PWM ein möglichst ausgeprägtes 38 kHz Signal erzeugt. Ausschalten heißt, den Duty-Cycle auf 0 zu setzen. 

/* play_ir_data ---------------------------------------------------------------------------
Plays an IR data sequence
Input:  array ir_data -> holds the start- and stop time points for the bursts
        int ir_data_len -> number of data points in the array
*/
void play_ir_data(uint32_t ir_data[], uint16_t ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;                     // true for active, false for pause
  int i = 0;

  if (ir_data_len == 0) return;         // if data set is empty, then nothing to do

  start_time = esp_timer_get_time();    // capture start time
  ledcWrite(ir_pwm_channel, 128);       // activate IR transmitter
  do {
    time_stamp = esp_timer_get_time() - start_time;
    if (time_stamp >= ir_data[i]) {
      if (edge) {
         ledcWrite(ir_pwm_channel, 0);    // stop IR transmitter
         edge = false;
      } else {
         ledcWrite(ir_pwm_channel, 128);  // activate IR transmitter
         edge = true;
      };
      ++i;
    }
  } while (i < ir_data_len);
  ledcWrite(ir_pwm_channel, 0);           // ensure that IR transmitter is stopped 
}

Das Oszilloskop zeigt, dass das ursprüngliche Signal mit guter Genauigkeit reproduziert wird.

Ausgangs-Signal am IR-Empfänger für die Funktion “Einschalten” des Bose Wave-Systems
Signal am GPIO-Ausgang des ESP32. Der zeitliche Verlauf des ursprünglichen Signals wird exakt reproduziert.

Daten langfristig sichern: Preferences

Schließlich gibt es noch die Anforderung, dass der ESP32 die Daten der gelernten Signale über das Ausschalten hinaus im Speicher behalten soll. Beim 8-Bit Arduino gibt es das EEPROM zum dauerhaften Abspeichern von Daten. Leider ist der Speicherplatz des EEPROMS begrenzt und die Programmierung dazu etwas umständlich.

Der ESP32 bietet die Möglichkeit, aus dem Programm heraus den Flash-Speicher, in der ESP-Terminologie non-volatile storage (NVS), zu lesen und zu beschreiben. Der hat natürlich sehr viel Platz. Im Arduino-Framework gibt es das Preference-Objekt, mit dem der Flash-Speicher erreichbar ist. Dazu wird ein globales Objekt prefs vom Typ Preferences erzeugt.

#include <Preferences.h>
Preferences prefs;

Dort kann man Bereiche einrichten, die zum Abspeichern beliebiger Daten zur Verfügung stehen. Der Bereich bekommt einen Namen, der als String übergeben wird, und wird mit Begin geöffnet. Der Name kann willkürlich gewählt werden, hier ir_nvs.

prefs.begin("ir_nvs", false);

False bedeutet, dass der Bereich sowohl gelesen als auch beschrieben werden darf. Zum Lesen und Schreiben gibt es die Objekt-Methoden get…() und put…(), jeweils für die üblichen Datentypen, z.B. 

 prefs.putUShort(<name_string>, <int value>);

zum Schreiben eines 16-Bit Integer-Wertes ohne Vorzeichen. Der name_string kann wieder beliebig gewählt werden, muss aber eindeutig sein und dient zur Identifikation der Variable. Eine gute Praxis ist, dafür den Namen der entsprechenden Variable im RAM zu verwenden.

Für Arrays und andere größere Objekte kann man auf die Funktion 

prefs.putBytes(<name_string>, <pointer>, <size>);

zurückgreifen, die den entsprechenden Speicherbereich ins Flash kopiert und so dauerhaft verfügbar macht.

Als Gegenstück kann mit

 <short_value> = prefs.getUShort(<name_string>);

der gespeicherte Wert gelesen werden. Wenn man auf einen bisher noch unbeschrieben Namen zugreift, bekommt man den Wert 0.

Im Programm werden nach dem Einschalten im setup()-Block die Anzahl der abgespeicherten Daten für die drei Kanäle aus dem Flash-Speicher in das Array ir_data_len[] gelesen. Wenn die Werte größer als 0 sind, dann gibt es tatsächlich abgelegte IR-Daten, die dann in das Array ir_data[][] im RAM kopiert werden und für die Funktion play_ir_data() zur Verfügung stehen. 

  // read IR data from NVS
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";

  prefs.begin("ir_nvs", false);
  Serial.println();
  Serial.println("Reading NVS ir_data ");
  for (int i = 0; i < channel_cnt; ++i) {
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    ir_data_len[i] = prefs.getUShort(ir_len_str);
    Serial.print("Channel " + String(i) + ": ");
    Serial.println(String(ir_data_len[i]) + " Entries");
    if (ir_data_len[i] > 0) 
      prefs.getBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  }       
  Serial.println();

Entsprechend werden nach dem Anlernen von IR-Signalen die Daten in den Flash-Speicher geschrieben, so dass sie dauerhaft erhalten bleiben und beim nächsten Einschalten des Geräts gelesen werden können. Das übernimmt die Funktion learn_sequence(), die nacheinander für alle 3 Kanäle die Funktion read_ir_data() aufruft und die Daten dann in den Flash-Speicher schreibt.

/* -------------------------------------------------------------------------------------*/
void learn_sequence(void) {
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";
  for (int i = 0; i < channel_cnt; ++i) {
    read_ir_data(i, ir_data[i], &ir_data_len[i]);
    print_ir_data(i, ir_data[i], ir_data_len[i]);
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    prefs.putUShort(ir_len_str, ir_data_len[i]);
    prefs.putBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  };
}

Alle Komponenten zusammen setzen

Damit sind die wesentlichen Komponenten für das System vorhanden. Die Schleife loop() fragt die Buttons ab und verzweigt in die jeweiligen Funktionen. 

/* -------------------------------------------------------------------------------------*/
void loop() {
  uint8_t learn_pressed_cnt = 0;

  // check whether the learn button is pressed for at least 3 seconds
  while (digitalRead(bt_learn) == LOW) {
    delay(200);
    ++learn_pressed_cnt;
    if (learn_pressed_cnt >= 15) {
      learn_sequence();
      learn_pressed_cnt = 0;
    }
  }

  // check the play buttons and play correspoding sequence 
  for (int i = 0; i < channel_cnt; ++i) {
    if (digitalRead(bt_play[i]) == LOW) {
      digitalWrite(led[i], LOW);
      play_ir_data(ir_data[i], ir_data_len[i]);
      digitalWrite(led[i], HIGH);
      delay(250);
    }
  }

Die Bedienung geschieht folgendermaßen:

  • Nach dem Einschalten (Power On) werden die drei Leuchtdioden der Reihe nach kurz durchgeschaltet, um zu zeigen, dass das System aktiv ist.
  • Das Gerät kann drei verschiedene Signale aufzeichnen und abspielen. Dazu dienen die drei Taster. Ein Druck auf einen der Taster bewirkt das Aussenden des entsprechenden Signals. Dabei leuchtet die zugehörige Leuchtdiode kurz auf.
  • Um in den Lernmodus zu gelangen, muss die Anlern-Taste für mindestens 3 Sekunden gedrückt werden. Dann blinkt die Leuchtdiode des ersten Kanals in einem schnellen Rhythmus, um anzuzeigen, dass das Gerät auf ein Signal zum Anlernen wartet. Man sollte jetzt die Fernbedienung auf den IR-Empfänger richten und kurz (!) die gewünschte Funktion drücken. Nachdem das passiert ist, wiederholt sich der Vorgang für Kanal 2 und 3. Damit ist das Gerät programmiert und bereit zum Einsatz.

Hier das ganze Programm.

/* ir_remote_control

This scetch records and reproduces IR signals from any IR remote control.
The IR data is stored in NVS memory and therefore retained beyond power off.
This version supports 3 channels. It can easily be extended to more channels.

Pin assignments:
  bt_learn        input pullup    GPIO16          learn button, push for at least 3 seconds
  bt_play         input pullup    GPIO17, 5, 18   buttons to send signal 
  ir receiver     input           GPIO34          IR receiver chip, e.g.TSOP1138 
  ir transmitter  output          GPIO33          IR transmitter diode, connected via a transistor
  led             output          GPIO27, 26, 25  control leds
  
SLW 10-Sep-2019
*/

#include <Arduino.h>
#include <Preferences.h>

// pin assignments
const int bt_learn = 16;
const int bt_play[] = {17, 5, 18};
const int ir_receiver = 34, ir_transmitter = 33;
const int led[] = {27, 26, 25};

// global constants 
const int channel_cnt = 3;                  // this version supports 3 channels (maximum is 10)
const uint16_t ir_data_size = 250;          // size of ir data sequence
const uint16_t ir_pwm_frequency = 38000;    // ir signal sends at 38kHz
const uint8_t ir_pwm_channel = 0;           // first pwm channel for ir signal
const uint8_t led_pwm_channel = 2;          // second pwm channel for LEDs
const uint16_t led_pwm_frequency = 8;       // frequency for flashing LEDs
const uint32_t ir_read_timeout = 250000;    // max duration is 0.2 sec 

// global variables
Preferences prefs;                            // access to non volatile storage (NVS)
uint32_t ir_data[channel_cnt][ir_data_size];  // IR data set, 3 rows of up to 250 data items each
int ir_data_len[channel_cnt] = {0, 0, 0};
bool learn_bt_pressed = false;

/* startup_msg ---------------------------------------------------------------------------
Flashes the LEDs at startup, just to show that the system is active.
*/
void startup_msg(void) {
  for (int i = 0; i < channel_cnt; ++i) {
    digitalWrite(led[i], LOW);
    delay(500);
    digitalWrite(led[i], HIGH);
  }
}

/* read_ir_data ---------------------------------------------------------------------------
Reads a sequence of ir data via the IR receiver. Captures the start- and stop time points
of each burst and stores them to the array ir_data[]. Data reading continues until either 
the data storage is exceeded or reading timeout is reached. Flashes the corresponding led
during the reading process. 
Input:    channel number
Output:   array ir_data -> ir data points
          int *ir_data_len -> number of data points stored in the array 
*/
void read_ir_data(int channel, uint32_t ir_data[], int *ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;            // false for falling edge, true for rising edge

  ledcAttachPin(led[channel], led_pwm_channel);                     // flash LED
  ledcWrite(led_pwm_channel, 128);
  *ir_data_len = 0;                                                    // reset array index
  while (digitalRead(ir_receiver) == HIGH);                         // wait for falling edge
  start_time = esp_timer_get_time();                                // capture start time
  do {
    time_stamp = (uint32_t) (esp_timer_get_time() - start_time);    // refresh time stamp 
    if (edge) {                                                     
      if (digitalRead(ir_receiver) == HIGH) {                       // waiting for rising edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp
        ++*ir_data_len;
        edge = false;                                               // switch to falling edge
      };  
    } else {                                                       
      if (digitalRead(ir_receiver) == LOW) {                        // waiting for falling edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp 
        ++*ir_data_len;
        edge = true;                                                // switch to rising edge
      };  
    };
  } while ((time_stamp < ir_read_timeout) && (*ir_data_len < ir_data_size));
  ledcDetachPin(led[channel]);                                      // clear flashing LED
  digitalWrite(led[channel], HIGH);                                 // switch off LED
}

/* play_ir_data ---------------------------------------------------------------------------
Plays an IR data sequence
Input:  array ir_data -> holds the start- and stop time points for the bursts
        int ir_data_len -> number of data points in the array
*/
void play_ir_data(uint32_t ir_data[], uint16_t ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;                     // true for active, false for pause
  int i = 0;

  if (ir_data_len == 0) return;         // if data set is empty, then nothing to do

  start_time = esp_timer_get_time();    // capture start time
  ledcWrite(ir_pwm_channel, 128);       // activate IR transmitter
  do {
    time_stamp = esp_timer_get_time() - start_time;
    if (time_stamp >= ir_data[i]) {
      if (edge) {
         ledcWrite(ir_pwm_channel, 0);    // stop IR transmitter
         edge = false;
      } else {
         ledcWrite(ir_pwm_channel, 128);  // activate IR transmitter
         edge = true;
      };
      ++i;
    }
  } while (i < ir_data_len);
  ledcWrite(ir_pwm_channel, 0);           // ensure that IR transmitter is stopped 
}

/* print_ir_data ---------------------------------------------------------------------------
Prints ir data to the serial monitor, for control purpose only
*/
void print_ir_data(int channel, uint32_t ir_data[], uint16_t ir_data_len) {
  int line_cnt = 0;

  Serial.println();
  Serial.print("Channel " + String(channel) + "  IR data (");
  Serial.print(ir_data_len);
  Serial.println("):");
  for (int i = 0; i < ir_data_len; ++i) {
    Serial.print(ir_data[i]);
    if (i < ir_data_len - 1) Serial.print(", ");
    ++line_cnt;
    if (line_cnt > 10) {
      Serial.println();
      line_cnt = 0;
    }
  }
  Serial.println();
}

/* -------------------------------------------------------------------------------------*/
void learn_sequence(void) {
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";
  for (int i = 0; i < channel_cnt; ++i) {
    read_ir_data(i, ir_data[i], &ir_data_len[i]);
    print_ir_data(i, ir_data[i], ir_data_len[i]);
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    prefs.putUShort(ir_len_str, ir_data_len[i]);
    prefs.putBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  };
}

/* -------------------------------------------------------------------------------------*/
void setup() {
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";

  Serial.begin(115200);

  // read IR data from NVS
  prefs.begin("ir_nvs", false);
  Serial.println();
  Serial.println("Reading NVS ir_data ");
  for (int i = 0; i < channel_cnt; ++i) {
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    ir_data_len[i] = prefs.getUShort(ir_len_str);
    Serial.print("Channel " + String(i) + ": ");
    Serial.println(String(ir_data_len[i]) + " Entries");
    if (ir_data_len[i] > 0) 
      prefs.getBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  }       
  Serial.println();

  // set pin modes
  for (int i = 0; i < channel_cnt; ++i) {
    pinMode(bt_play[i], INPUT_PULLUP);        // define ports for buttons
    pinMode(led[i], OUTPUT);                  // define ports for LEDs
    digitalWrite(led[i], HIGH);               // switch off the LEDs
  };
  pinMode(bt_learn, INPUT_PULLUP);
  pinMode(ir_receiver, INPUT);
 
  // setup PWM for IR transmitter
  ledcSetup(ir_pwm_channel, ir_pwm_frequency, 8);    // pwm runs with 8 bit resolution
  ledcAttachPin(ir_transmitter, ir_pwm_channel);
  ledcWrite(ir_pwm_channel, 0);                      // switch off the IR transmitter, for now

  // setup PWM for flashing LEDs
  ledcSetup(led_pwm_channel, led_pwm_frequency, 8);

  // show welcome message
  startup_msg();
}

/* -------------------------------------------------------------------------------------*/
void loop() {
  uint8_t learn_pressed_cnt = 0;

  // check whether the learn button is pressed for at least 3 seconds
  while (digitalRead(bt_learn) == LOW) {
    delay(200);
    ++learn_pressed_cnt;
    if (learn_pressed_cnt >= 15) {
      learn_sequence();
      learn_pressed_cnt = 0;
    }
  }

  // check the play buttons and play correspoding sequence
  for (int i = 0; i < channel_cnt; ++i) {  
    if (digitalRead(bt_play[i]) == LOW) {
      digitalWrite(led[i], LOW);
      play_ir_data(ir_data[i], ir_data_len[i]);
      digitalWrite(led[i], HIGH);
      delay(250);
    }
  }
}

Fazit

Eine lernfähige IR-Fernbedienung kann mit dem ESP32 relativ schnell entwickelt werden. Das Gerät arbeitet zuverlässig und hat sich bei verschiedenen Anwendungen bewährt. Die Genauigkeit der Reproduktion ist sehr hoch. Bei mir haben die Zielgeräte bisher klaglos die Signale der “fremden” Fernbedienung akzeptiert.

Bei Bedarf kann die Anzahl der Kanäle weiter erhöht werden, solange GPIOs für Tasten und Leuchtdioden vorhanden sind.

Bleibt die Frage, ob der ESP32 für diese Anwendung Vorteile im Vergleich zum 8-Bit Arduino bietet. Natürlich kann man ein ähnliches Ergebnis auch mit eine Arduino Nano erreichen. Dabei würde es aber im RAM knapp. 3 * 250 Datenpunkte von jeweils 32 Bit belegen mehr als 2 kB und würden das verfügbare RAM des ATmega328 bereits überfordern. Außerdem macht sich beim ESP32 der schnelle Systemtakt für eine höhere Genauigkeit der reproduzierten Signale und der der große Flash-Speicher zum dauerhaften Ablegen der Sequenzen nützlich. Spätestens wenn mehr Kanäle notwendig werden, wird der 8-Bitter nicht ausreichen. Und als Erweiterung kann der ESp32 die Bedienung über ein Web-Interface ermöglichen, was ein weiterer Schritt in Richtung Smart-Home wäre.

Downloads

ESP32_ir_remote_controlHerunterladen

ESP32

Die 8-Bit Mikroprozessoren sind aus dem elektronischen Alltag nicht mehr wegzudenken. Es gibt kaum ein Projekt in meiner Werkstatt, das nicht mindestens einen ATmega328 verwendet, sei es als “nackter” Prozessor auf der Platine oder zusammen mit USB-Interface und Quarz als Arduino Nano. Die Chips sind zuverlässig, vielseitig und vertraut – wie ein Werkzeug, das sehr gut in der Hand liegt.

Aber das Design der AVR-Prozessoren geht zurück auf die 90er Jahre und stößt natürlich an Grenzen. Besonders wünschenswert wären mehr RAM-Speicher, eine Floating-Point-Unit, mehr Timer und eine höhere Taktrate, die für zeitkritische Anwendungen hilfreich sein kann. Schon seit einiger Zeit gibt es verschiedene 32-Bit-Prozessoren, die mit wesentlich mehr Leistung anbieten und für eigene Entwicklungen geeignet sind. Hervorzuheben sind die STM32-Controller von ST (Nucleo-Boards) oder die SAM D21-Chips von Microchip Technology. Beide haben es auch in die Arduino-Welt geschafft (z.B. Arduino Due, Arduino-Board mit 32-Bit Architektur). Jedoch haben sich diese Chips in der Maker-Szene nicht so durchgesetzt, wie man es hätte erwarten können.

Anders erging des dem ESP32, eine neuere Entwicklung der chinesischen Firma Espressif. Dieser Chip verfügt über (fast) alles, was das Bastler-Herz begehrt, arbeitet mit Taktfrequenzen bis zu 240 MHz und ist darüber hinaus auf kleinen, günstigen Breakout-Boards verfügbar. Espressif hat es geschafft, den ESP32 sehr gut in die Arduino-Welt einzubetten, so dass der Umstieg von anderen Arduinos nicht schwer fällt. So ist es vielleicht nicht überraschend, dass der ESP32 eine beachtliche Verbreitung gefunden hat.

ESP32 Breakout Boards: Links das ESP32 Dev Modul, das leider etwas zu breit für einfache Steckbretter ist, dafür aber sehr preisgünstig. Rechts das etwas teurere ESP32 Pico Board.

Ein Grund für die große Akzeptanz ist sicherlich die Tatsache, dass Espressif WLAN- und Bluetooth-Kommunikation integriert hat. Ein zweiter Prozessor kümmert sich um die Netzwerkschnittstellen und arbeitet die entsprechenden Protokolle ab. Als Anwendungsentwickler hat man auch bei aktivem Netzwerk den Hauptprozessor vollständig zur Verfügung und muss sich nicht mit den Details der Kommunikation beschäftigen. Damit sind auch kleine Projekte ohne großen Aufwand über das Netz erreichbar. Der ESP32 ist zu einer Ikone des Internet of Things (IoT) geworden.

Breakout-Boards

Bei den Boards für den ESP32 gibt es etwas Wildwuchs. In meiner Praxis arbeite ich mit dem ESP32 Dev Module oder dem ESP32 Pico Board. Leider ist das preisgünstige Dev Module etwas zu breit für einfache Breadboards. Man kann aber zwei Breadboards zusammenstecken, so dass das Dev Module gut Platz findet.

ESP32 Dev Module auf zwei zusammengesetzten Breadboards.

Und es muss nicht unbedingt ein Steckbrett sein. Ich habe die Boards mit entsprechenden Buchsen-Leisten auch auf fertigen Platinen im Einsatz.

Die Boards haben viele Pins. Hier ist eine Übersicht der Pins mit ihren wichtigsten Funktionen für das Dev Module:

ESP32 Dev Module Pinout

Wie üblich sind die Pins mehrfach belegt und bieten je nach Konfiguration verschiedenen Funktionen an. Es gibt aber eine Reihe von Einschränkungen:

  • Die Pins 34, 35, 36 und 39 sind nur als Eingänge verfügbar. Eine digitalWrite()-Anweisung für diese Ports wird von der Arduino-IDE klaglos akzeptiert, bleibt aber völlig wirkungslos.
  • GPIO 6 bis 11 werden für den integrierten Flash-Speicher verwendet und stehen daher nicht frei zur Verfügung.
  • Der zweite ADC ist nicht verfügbar, solange der WiFi-Modus aktiv ist.

Wen man diese Dinge nicht weiß, kann die Fehlersuche sehr mühsam werden. Eine gute Zusammenstellung der möglichen Verwendung der Pins gibt es hier: https://randomnerdtutorials.com/esp32-pinout-reference-gpios/

Viel Peripherie

Ich beschäftige mich seit einigen Jahren mit dem ESP32 und habe ihn für verschiedene Projekte eingesetzt, durchweg mit guten Resultaten. Selbst wenn das WLAN nicht gebraucht wird, verfügt der Chip über eine ganze Menge nützlicher Peripherie. Neben den GPIOs und den üblichen Schnittstellen (ISP, SPI, UART) gibt es zwei ADCs, einen DAC, Deep-Sleep-Modus, Zugriff auf den Flash zur permanenten Speicherung von Daten und vieles mehr. Einzig die ADCs erfüllen nicht ganz die Erwartungen. Sie arbeiten zwar mit einer Auflösung von bis zu beachtlichen 12 Bit, leider aber mit mäßiger Linearität (siehe ESP32 ADC Non-linear Issue). Damit sind die ADCs für absolute und genaue Messungen nur eingeschränkt brauchbar. Für relative Vergleiche von Messwerten reicht es aber auf jeden Fall. Wenn für eine gegebene Anwendung ein exakter ADC unentbehrlich ist, dann bleibt natürlich noch die Möglichkeit, einen externen ADC über I2C oder SPI anzuschließen. Ein Ansatz, der z.B. beim Raspberry Pi in jedem Fall notwendig ist.

Vereinfachtes Pinout des ESP32 Dev Module

PlatformIO als Entwicklungsumgebung

Es gibt eine Reihe von Entwicklungsumgebungen, die zur Programmierung verwendet werden können. An erster Stelle steht natürlich die Arduino-IDE, die über den Boardverwalter mit der URL https://dl.espressif.com/dl/package_esp32_index.json für den ESP32 leicht erweitert werden kann. Man fühlt sich schnell Zuhause, wenn auch die Arduino-IDE für komplexere Projekte zu einfach gestrickt ist.

Eine positive Überraschung war für mich PlatformIO (https://platformio.org/), eine komfortable, plattform-übergreifende und als Open Source kostenlose IDE, mit der ich inzwischen sehr gerne an Mikrocontroller-Projekten arbeite. Die Bibliotheken für Arduino und für den ESP32 werden als Extensions installiert. Danach hat man eine große Auswahl an ESP32-Boards.

Der Umgang mit PlatformIO ist im Vergleich zur Arduino IDE etwas gewöhnungsbedürftig. Aber schon nach kurzer Zeit findet man alles, was gebraucht wird. Die zentralen Projekt-Einstellungen werden über die Datei platformio.ini vorgenommen. Hier ein typisches Beispiel für den ESP32:

platformio.ini für ein Projekt mit dem ESP32

Der serielle Monitor, als Debugging-Tool unerlässlich, lässt sich unter den Project Tasks mit “Monitor” anwählen. Mit “Upload and Monitor” wird direkt nach dem Laden des Programms der serielle Monitor aktiviert.

PlatformIO Tasks. Hier findet sich auch der serielle Monitor.

Außerdem sind die wichtigsten Funktionen (Übersetzen, Upload, serieller Monitor und mehr) über eine kleine Taskleiste am unteren Bildschirmrand verfügbar.

PlatformIO Task-Leiste mit vielen Funktionen

Die umfangreiche Funktionalität des ESP32 ist weitgehend in Arduino-Funktionen verpackt, so dass die ersten Programme ohne große Umstellung funktionieren. Wenn man auf spezifische Funktionen des ESP32 zugreifen möchte, dann ist auch das kein Problem. Wie üblich im Ardunio Framework sind die Bibliotheken des Herstellers (nach Einbinden der entsprechenden Header-Files) transparent verfügbar, z.B. Funktionen wie adc1_get_raw(), um den ADC anzusprechen, oder esp_adc_cal_raw_to_voltage() für die Umrechnung der Werte mit Kompensierung von Referenzspannungs-Abweichungen (siehe ESP ADC Reference). Damit steht dem tieferen Einstieg in die Welt des ESP32 nichts im Wege – sofern man bereit ist, sich durch die Beschreibungen und Datenblätter zu arbeiten.

Fazit

Der ESp32 hat sich schnell in meinen Arbeitsalltag integriert und kommt oft zum Einsatz. Umfang und Leistungsfähigkeit stehen zwischen den 8-Bit AVRs auf der einen Seite und dem Raspberry Pi auf der anderen Seite. wobei der Chip kaum teurer ist, als ein einfacher Arduino. Die Integration in das Arduino-Framework und die Verfügbarkeit einer leistungsfähigen Open Source-IDE lassen kaum Wünsche offen.