IDE
!!! Überholt, wird demnächst neu bearbeitet. Die aufgeführten Werkzeuge sind inzwischen deutlich weiter entwickelt, so dass die hier gemachten Aussagen teilweise nicht mehr gültig sind.
Die Entwicklungsumgebungen zur Programmierung von Mikrocontrollern unterliegen einem ständigen Wandel. So wurde z.B. die Entwicklung von APPs für das Betriebssystem Android zunächst mit Eclipse und einer Ergänzung von Google vorgenommen. Allerdings hat Google intensiv an einer alternativen IDE gearbeitet, die einfacher zu installieren und zu handhaben ist, als die genannte Eclipse-Anwendung. Demzufolge wurde auf Android Studio gewechselt.
Auch bei der Programmierung von Arduino-Boards wurden mehrere Varianten probiert. Die Verwendung der Arduino-IDE ließ viele Wünsche offen. Eine von Visual Micro zur Verfügung gestellte Erweiterung von Visual Studio unterstützte nach einiger Zeit nicht mehr die immer noch weit verbreitete Version VS2010 und fiel damit durch das Raster. Weitere Tests wurden mit PlatformIO und Visual Studio Code durchgeführt. Damit gelang aber nicht die Abbildung der eigenen gewünschten Projekt- und Verzeichnisstruktur. Schließlich haben wir für die Mikrocontrollerprogrammierung Sloeber (Eclipse mit Arduino-plug-in) gewählt. Dessen Anwendung wird hier beschrieben.
Inhaltsverzeichnis
Sloeber (Eclipse mit Arduino-plug-in)
Mit dieser Umgebung ist es uns gelungen, nahezu beliebige Ablagestrukturen für unsere Software in der IDE zu nutzen. Im Folgenden wird die Installation und Inbetriebnahme von Sloeber beschrieben. Dabei wurde die Nutzung der für die dezentrale Heimautomatisierung entwickelten Bibliotheken auf einem Arduino Due angenommen. Weiter unten wird beschrieben, wie der ESP32 eingebunden und Git angewendet wird.
Kochrezept Installation Sloeber (mit Arduino Due)
- Das Betriebssystem wählen/ermitteln.
Bei den folgenden Schritten steht OS für das Betriebssystem und XX für 32 oder 64 Bits. - Im Browser öffnen: http://eclipse.baeyens.it
- In der Menüleiste (oberer Rand) [Install] klicken und [Stable / OS] wählen
- Den dicken grünen Button [Download XX Bundle] klicken.
- Den Download speichern unter .../User/Downloads/
(oder beliebigen anderen Ordner, der dafür vorgesehen ist)
Es sind über 200 MB, er Download kann entsprechend lange dauern. - Falls kein geeigneter Entpacker (z.B. WinZIP) auf dem PC installiert ist, dann jetzt einen installieren (z.B. 7-zip von http://7-zip.de/)
- Die heruntergeladene Datei (z.B. V4.1_win64.2017-05-25_16-52-16.tar.gz) in einen beschreibbaren Ordner (ggf. einrichten, z.B. C:/ExtraProgramme) entpacken. Dort sollte jetzt das Verzeichnis [sloeber] existieren.
- Im Verzeichnis [sloeber] die IDE (sloeber-ide.exe) starten. (Beim ersten Mal dauert das etwas länger.) Nun einen geeigneten Arbeitsbereich wählen, z.B. C:/Entwicklung/Arduino/mplab
Jetzt wird (automatisch) die Arduino-Umgebung installiert. Das dauert etwas und man muss den Internet-Zugriff zulassen, wenn sich die Firewall meldet. - Im Verzeichnis [sloeber] ist nun ein neuer Ordner [arduinoPlugin] und darin der Ordner [libraries], den wir jetzt öffnen.
Wir finden darin eine Liste von Ordnern mit allgemeinen Arduino-Bibliotheksprogrammen. - Jetzt holen wir die Bibliotheken für die dezentrale Heimautomatisierung von GitHub.
Dazu im Browser öffnen: https://github.com/RobertPatzke/homeautomation und unten/mitte/rechts den grünen Button [Clone or download] klicken.
In dem sich öffnenden Menü unten rechts den Button [Download ZIP] klicken und speichern unter .../User/Downloads/ (oder anderen Ordner, aber merken!). - Wir richten uns einen zugreifbaren Ordner für die heruntergeladene Software ein, z.B. C:/Entwicklung/homeautomation, und entpacken da hinein den Inhalt des Ordners [homeautomation-master] aus der heruntergeladenen ZIP-Datei.
In [homautomation] sollte jetzt enthalten sein:
[apps] [devices] [libraries] README.md - Nun schließen wir den Welcome-Reiter in Eclipse. Es baut sich der Arbeitsbildschirm auf. In der Menüleiste (oben) klicken wir auf [Arduino] und weiter auf [Preferences] (unten).
Wir finden auf der rechten Seite zwei Fenster mit Pfadangaben. Diese werden nun gelöscht indem wir die Pfade anklicken und danach rechts den Button [Remove].
Im oberen Fenster richten wir jetzt einen neuen Pfad ein (über Button [New]) und suchen dabei den Ordner C:/Entwicklung/homeautomation/libraries (siehe Schritt 11.).
Danach wählen wir links im geöffneten Menübaum [Platforms and Boards] und öffnen im jetzt erscheinenden Fenster das Verzeichnis [] arduino. Darin dann [] Arduino SAM Boards und darunter setzen wir einen Haken bei [] 1.6.11.
Nach dem Schließen des Fenster mit Klicken auf OK wird die Umgebung für den Arduino Due geladen. Das kann, je nach Internetverbindung, wieder mehrere Minuten dauern. - Die Wartezeit nutzen wir, um den Arduino Due über USB an den Programming Port (siehe Beschriftung Platinenrückseite) anzuschließen.
Es kann sein, dass das unter Windows etwas umständlich wird, weil da die USB-Treiber getrennt verwaltet werden. Ggf. muss hier im Internet recherchiert werden.
Wenn Alles klappt taucht nach einiger Zeit (bei Windows) die Meldung Arduino Due an COMx installiert auf. - Wir richten ein neues Projekt ein, indem wir auf [Arduino]/New Sketch klicken. Projektname ist (für diese Beispielanwendung) baseDevice.
Nach dem Klick auf [Next] wählen wir bei Platform folder: ..../sam/1.6.11. Anschließend
bei Board: die Auswahl [Arduino Due (Programming Port)].
Bei Port: sollte in der Liste die Schnittstelle COMx auftauchen, die wir wählen.
Mit [Finish] beenden wir diese Einstellungen. - Das Projekt ist eingerichtet. Wir öffnen es (darauf klicken) und finden neben den Ordnern [Includes], [core] und [Release] die vorbereitete Datei baseDevice.ino.
Nun öffnen wir in der heruntergeladenen und unter [homeautomation] entpackten Software den Ordner [devices] und darin den Ordner [arduino] und finden dort die Dateien baseDevice.ino und baseDevice.h
In unserem Arbeitsverzeichnis (C:/Entwicklung/Arduino/mplab, siehe Schritt 8.) finden wir jetzt den Ordner [baseDevice] mit dem neuen Projekt.
Darin die Datei baseDevice.ino, die wir mit der gleichnamigen Datei aus homeautomation/devices/arduino/baseDevice.ino überschreiben [Kopieren und Ersetzen]. Dazu kopieren wir auch noch die Datei baseDevice.h. - In Eclipse klicken wir nun doppelt auf baseDevice.ino und werden aufgefordert, die Datei mit F5 zu aktualisieren, dem wir nachkommen.
Nun müssen wir die Dateien socManNetUser.h und environment.h bearbeiten. Dazu öffnen wir den Ordner libraries in unserem Projekt (in Eclipse) und darin den Ordner environment. Zunächst wird auf socManNetUser.h doppelt geklickt. Die Datei öffnet sich im Editierfenster.
Dort wird nun ziemlich am Anfang die Definition #define TestAtMFP auskommentiert. Weitere Inhalte werden an unser aktuelles Netzwerk und Arduino-Board angepasst. (Das machen wir im Mikrocontroller-Labor gemeinsam.) - Nun doppelklicken wir auf environment.h
Zunächst kommentieren wir im Bereich // Hardware, Boards, ... die Definition #define smnNodeMCU10 aus und löschen die Kommentarzeichen vor #define smnArduinoDue und #define smnArduinoShieldEthernet.
Dann gehen wir zum Bereich // Prozessoren, Microcontroller, .... und kommentieren #define smnESP8266 aus und löschen die Kommentarzeichen vor #define smnSAM3X. - Jetzt noch die Ethernet-Bibliothek laden, indem wir im Menü [Arduino] (oberste Zeile) [Add a Library to the selected project] wählen und dann ein Häkchen bei Ethernet setzen.
- Nun können wir kompilieren und die Software auf das Arduino-Board laden.
Weitere Hinweise zu Eclipse/Sloeber
Wenn im Editor Syntaxfehler angezeigt werden, die Übersetzung aber trotzdem ohne Fehler erfolgt, dann ist wahrscheinlich der Indexer nicht mehr aktuell. Klicke mit der rechten Maustaste auf den Projektknoten im Projektbaum und wähle [Index]->Rebuild.
Wenn im Editor keine Syntaxfehler angezeigt werden, die Übersetzung aber Fehler meldet, dann ist wahrscheinlich die Build-Umgebung nicht mehr aktuell. Klicke mit der rechten Maustaste auf den Projektknoten und wähle [Clean Project].
Nutzung von ESP32 mit Sloeber
Bei dieser Gelegenheit werden wir auch Git einsetzen, um die verwendeten Bibliotheken schnell aktualisieren zu können.
Git installieren und anwenden
Zunächst den Browser öffnen und zum Download von Git gehen. Nun das Betriebssystem wählen und den Download speichern. Für Windows ist es eine EXE-Datei, z.B. Git-2.15.0-64-bit.exe (je nach Version). Diese Datei starten und Git mit den Standardeinstellungen installieren.
Nun ein Verzeichnis XXX einrichten oder wählen, in dem das Repository (alle Dateien) mit dem Namen [android-esp32] eingerichtet werden soll. Darin richtet Git selbst das entsprechende Verzeichnis [android-esp32] ein.
Jetzt GitBash starten und mit cd XXX in das eingerichtete Verzeichnis verzweigen.
Git zum Herunterladen der Dateien nutzen mit
git clone https://github.com/espressif/arduino-esp32
Es wird das Verzeichnis [arduino-esp32] eingerichtet und alle Dateien des master-branch darin abgelegt (dauert etwas).
Das Verzeichnis [arduino-esp32] mit dem Explorer öffnen, in den Ordner [tools] gehen und die Datei get.exe aufrufen. Jetzt wird der Compiler für den ESP32 heruntergeladen und betriebsbereit gemacht. Das dauert etwas und es werden während der Zeit keine Meldungen in der Konsole ausgegeben. Also Geduld.
Das war es schon. Wenn bei GitHub neue Versionen vorliegen, dann kann man das lokale Repository mit
git pull origin
aktualisieren.
Sloeber anpassen
Wir öffnen in Sloeber den Menüpunkt [Arduino] (Menüleiste ganz oben) und dann [Preferences]. Dort finden wir im Knoten [Arduino] des Menübaumes im linken Rahmen auf der rechten Seite zwei Fenster zum eintragen privater Pfade. Diese können wir verwenden, um beliebig auf dem PC abgelegte Umgebungen zu integrieren.
Im oberen Fenster (Private library path) tragen wir den Pfad auf den Ordner [libraries] im geklonten Repository ein. Damit stehen die in diesem Ordner abgelegten Bibliotheken für die Kompilierung zur Verfügung.
In das untere Fenster (Private hardware path) tragen wir den Pfad auf den Repository-Ordner selbst ein, also auf [arduino-esp32]. Die darin befindliche Datei boards.txt wird ausgewertet, wenn wir ein neues Projekt einrichten.
Das war es schon. Nun können wir auch Programme für den ESP32 schreiben und auf eine geeignete Hardware laden.
Komplette IDE auf bootfähigem Stick
Nachdem ich fast jedes Semester aufgrund gewollter und auch ungewollter Updates die Entwicklungsumgebung an den Laborplätzen nacharbeiten musste, habe ich mich entschieden, die komplette Entwicklungsumgebung (Android, Arduino und direkte Mikrocontroller-Programmierung) nebst Beispielanwendungen auf einem bootfähigen Stick unterzubringen.
Die Grundlagen dafür hat ein Student in einem Projekt erarbeitet und auch eine erste Version auf einem 8-GB-Stick untergebracht. Eine Erweiterung auf 32 GB war dann erforderlich, um mehr Ressourcen nutzen zu können. Basierend auf dieser studentischen Arbeit habe ich dann einen bootfähigen 32-GB-Stick erstellt, der nicht mehr mit FAT32 formatiert ist, sondern mit ext4 und NTFS alle Möglichkeiten der Dateiverwaltung in LINUX ausnutzt und mit der NTFS-Partition einen gemeinsamen Pool mit Windows-Betriebssystemen bereitstellt.
Die Entwicklung mit ESP32, ESP8266 und Arduino-Due (sowie allen AVR-Arduinos) ist bereits installiert und mit lauffähigen Beispielprogrammen für kommunizierende Geräte versehen. Entsprechendes gilt auch für die Android-Entwicklung. Auch hier sind Beispielprogramme für lauffähige Geräte (Tablets und Smartphones) vorbereitet.
Wenn der PC mitspielt und man von einem USB-Stick booten kann, dann hat man mit dem Stick Alles parat und kann gleich loslegen, ohne noch irgendwelche IDE-Einstellungen vornehmen zu müssen.
