Taugt Visual Studio Code mit Platform IO als Ersatz für die die Arduino IDE?

Die Arduino IDE funktioniert einwandfrei und man kann mit ihr eigentlich alles machen, was man so braucht. Mit ihr kann man nicht nur Mikrocontroller der die Arduino Familie programmieren, sondern auch den STM32, den ESP8266, den ESP32 und mehr.

Aber: hat man mehrere Boards und Bibliotheken installiert, wird es schnell unübersichtlich und man muss sich durch elendig lange Liste in Drop-down-Menüs scrollen, wenn man den Controller öfter mal wechselt oder auch nur nach einem Beispiel sucht.

Und auch der Editor ist eher als rudimentär zu bezeichnen. Okay, er ist immer noch besser als Notepad, beherrscht er doch wenigstens Syntax Highlighting und Codesegement-Faltung. Aber das war es auch schon. Es gibt keine Lesezeichen, Syntax-Vervollständigung und andere Features, die einem das Leben als Programmierer leichter und angenehmer machen.

Schon das betagte Visual Basic von 1998 hatte diese Features mit Intellisense eingebaut. Zudem bin ich persönlich von den Visual Studios von Microsoft für C, C++, C#, VB.net, asp.net verwöhnt, die ich jahrzehntelang benutzt habe und von daher einen gewissen Komfort gewöhnt bin. Aber auch andere Entwicklungsumgebungen wie Eclipse oder NetBeans, die ich benutzt habe, hatten diese Komfortfunktionen im Editor.

Für kürzere Programme taugt die Arduino IDE schon, auch weil man sich in mehrerer Tabs organisieren kann. Doch bei längeren, komplexeren Programmen vermisse ich diese Komfortfunktionen schon. Das würde mir viel Zeit und Mühe kosten.

Vorzüge VS Code mit Platform IO

Beispiel: will ich wissen, welche Funktionen ich einer Klasse einer gerade neu eingebundenen Biliothek noch so bietet, dann muss ich in den Bibliotheksmanager, dort die Library suchen, dort auf "mehr Infos" klicken, was mich auf die Arduino oder eine GitHub-Seite bringt, in der ich eine mehr oder meist weniger gute Dokumentation im readme.md vorfinde. Oft hilft das nicht, und ich muss mir die Funktionen selbst im Header-File oder im C++-File anschauen, um heruaszufinden, welche Funktionen es gibt und wie sie aufzurufen sind. Da gehen jedesmal ein paar Minuten ins Land.

Das geht aber auch anders mit der Syntax-Vervollständigung von den oben angesprochenen IDEs. Dort tippe ich den Objektnamen des aus der Klasse instanziierten Objektes ein, gefolgt von einem Punkt und bekommen dann gewöhnlich eine Liste der Funktionen (Methoden), die diese Klasse versteht. Mit zu übergebenen Variablentypen, Paramternamen und oft sogar mit einer kleinen Beschreibung, was die Methode tut.





Visual Studio Code (kurz VS Code) bietet diese Funktionen und mit der Platform IO lassen sich auch Mikrocontroller programmieren, wobei hier die Liste der unterstützen Boards noch größer ist als in der Arduino IDE. Ich kann Arduinos programmieren, den STM32 und die ESPs wie bisher mit dem Arduino Framework - insgesamt über 700 Boards stehen zur Auswahl.



Wähle ich dort das Arduino Framework, kann ich meine Projekte wie in der Arduino IDE programmieren (mit kleinen Abweichungen, auf die ich später noch zu sprechen komme). Ich kann aber z. B. auch STM32Cube als Framework auswählen und habe dann die selben Funktionsumgebung als ob ich STM32Cube von STMicroelectronics verwenden würde:



Und das, ohne die IDE zu wechseln. Wenn ich jetzt nur STM32s programmieren würde, etwa als Angestellter einer Firma, die sich auf diesen Mikrocontrollertypen spezialisiert hat, dann würde ich eher das STM32Cube von STM benutzen, da dort wahrscheinlich die integrierte Hilfe und Dokumentation besser ist, aber mit VS Code / Platform IO behalte ich so die IDE bei und muss mich nicht neu eingewöhnen.



Auch könnte ich das ESP-IDF Framework für den ESP32 benutzen (oder halt das Arduino), auch in der selben IDE, nämlich VS Code und würde das Look and Feel beibehalten. Das ist ein großer Vorteil, wenn man auf mehreren Platformen programmieren will.

Man kann also, wenn man professioneller werden will, erstmal seine Arduino Projekte in VS Code bringen und dort mit dem Arduino Framework weitermachen und wenn man dann Funktionen braucht, die es im Arduino Framework nicht gibt, auf das STM32Cube oder ESP-IDF Framework wechseln. Dazu gibt es wohl eine Funktion "Import Arduino Project", aber von der rate ich ab, denn die hat mir irgendwie den Compiler durcheinandergebracht (siehe dazu das Video weiter unten) und man spart sich auch keine Arbeit. Copy and Paste vom Source Code in ein neues Projekt geht fast genau so schnell und ist sicherer.

Installation VS Code mit Platform IO

Auf platformio.org findet man eine Beschreibung und auch die Installationsanleitung, aber im Grunde ist die Platform IO kein eigenständiges Programm, sondern ein Plugin für VS Code.

Darum müssen wir zuerst VS Code installieren, das finden wir zum Download unter code.visualstudio.com. Ich empfehle eher den System Installer, da der User Installer das Programm in den Windows-User-Pfad "einsperrt" (wobei das bei der System-Installation auch nicht groß anders ist). Die meisten werden wohl die 64Bit-Version benötigen.

Ist VS Code installiert, starten wir ihn und begeben uns dort nach View / Extensions und geben dort in die Suchzeile "platformio" ein.



Bei "PlatformIO IDE" klicken wir dann auf Install und warten, bis Platform IO installiert ist. Danach sollten wir noch die Extension C/C++ installieren, falls dies noch nicht automatisch passiert ist.



Von der Arduino-Extension rate ich übrigens ab, denn erstens funktioniert der Serial Monitor und Co auch ohne diese Extension und zu zweiten beißt die sich irgendwie mit etwa anderem und führt zu Fehlermeldungen.

Ist die Platform IO installiert, erscheint am unteren Bildschirmrand eine blaue Leiste:


   A   B    C   D   E   F   G   H   I    J   K

Dabei bedeuten:

Bugs und Eigenarten von VS Code

Ich will ehrlich sein: Wenn VS Code die Funktionen, die es hat, fehlerfrei umsetzen würde, wäre es eine tolle Entwicklungsumgebung. Aber ich habe das Gefühl, dass VS Code bei weitem nicht an die Qualität anderer professioneller Microsoft-Visual Studios heranreicht.

Das fängt schon damit an, dass es VS Code nur mit englischsprachiger Oberfläche gibt, manche Fehlermeldungen dann aber doch wieder in deutsch angezeigt werden.

Auch fehlt die Lesezeichen-Funktion. Breakpoints kann man zwar setzen, aber keine Lesezeichen. Dafür kann man mit Alt+Cursor links/rechts an die Stellen springen, an denen man zuletzt etwas geändert hat.

Auf der Habenseite wieder das Kontextmenü, mit dem man sich Definition, Deklaration und Referenzen eines Objektes (Funktion, Klasse, Variable) anzeigen lassen kann:



So kann man mal schnell in einen Funktionskopf hineinschauen oder schauen, wie groß man ein char-Array definiert hat. Sehr praktisch. Das kannte ich eher nur von Eclipse und für objektorientiere Programmiersprachen.

Tja, und dann wären noch das sonderbare Verhalten des Oberflächen-Compilers. Der ist natürlich erstmal furchtbar praktisch. Wenn ich irgendwo mal wieder ein Semikolon oder eine schließende Klammer vergessen habe, dann war es in der Arduino-IDE so, dass ich erst den gesamten Code kompilieren musste, nur um nach einer Minute oder so zu erfahren, dass ich eben ein Semikolon vergessen habe.

Hier punkte VS Code mit dem Oberflächen-Compiler, der den Code während des Editierens parst und mit solche Fehler gleich anzeigt, mit einer Unterwellung. Nur macht er dann leider nicht richtig. Ich hatte die wildestens, komplett unlogische Fehler, die einfach nicht sein konnten unterwellt. Z. B. so etwas:



Wie kann ein Kommentar einen Fehler werfen? Was als Erklärung folgt, ist kompletter Mumpitz und extrem verwirrend.
Oft funktioniert der Oberflächen-Compiler einfach nicht richtig. Wenn man das Programm dann "richtig" kompiliert ist komischerweise alles in Ordnung und das Programm läuft einwandfrei auf dem Mikrocontroller. Darum sind die Unterwellungen mit Vorsicht zu genießen. Genau wie die angezeigte Fehleranzahl in der Platfrom-IO-Leiste am unteren Bildschirmrand. Ich bin ein Typ, der sich erst wohl fühlt, wenn Errors und Warnings auf 0 stehen und es bereitet mir etwas Unbehagen, dass dies hier nicht der Fall ist, auch wenn ich weiß, dass der Code in Ordnung ist und nur der Oberflächer-Compiler spinnt.

Man kann die Unterwellung ausschalten. Das erspart einem verwirrenden "falsche Fehler". Aber man hat dann auch nicht mehr die furchtbar praktische "hier hast du ein SEmikolon oder eine geschweifte Klammer vergessen"-Erinnerungen vor der zeitaufwendigen Realkompilierung. Ich werde die Unterwellung also an lassen und lernen, was ich zu ignorieren habe. Besonders am Rumspinnen war er bisher bei #inlcude-Statements.

Und als ich einmal zum Test ein Arduino Projekt importiert habe - in der Hoffnung, er findet die Library Referenzen automatisch und setzt mir die und alles geschähe auf wundervolle Weise automatisch und ich könnte einfach so im neuen Editor weitermachen - wurde ich jäh aus meinem Wunschtraum aufgeweckt und mit völlig unlogischen Fehlermeldungen bombardiert. Wie kann zum Beispiel an #define PinSDA 4 etwas falsch sein? Nichts. Aber es wurde eine unpassende Fehlermeldung angezeigt (sie Video).

Darum rate ich der Funktion "Import Arduino Project" ab, denn die bringt außer Ärger nichts. Es werden keine automatischen Library-Verbindungen erkannt. Wobei wir beim nächsten Thema wären: der Konfiguration über die platform.ini.

Konfiguration über die platformio.ini

Die Arduino IDE arbeitet mit globalen Libraries. Das heißt, wenn ich einmal einen Library installiert habe, dann kann ich überall, in jedem Programm auf alle Libraries zugreifen und deren Header-File mit #include einbinden. Das ist zunächst mal praktisch, aber was ist, wenn ich zwei Projekte habe und eines braucht eine andere Version einer Library als ein anderes? Dann habe ich in der Arduino IDE Pech gehabt.

In VS Code muss ich angeben, welche Libraries ich in einem Projekt benutzen will. Das ist zunächst erstmal nervig, hat aber den Vorteil, dass ich das genau für jeden Projekt definieren kann und eben für das eine diese Versionsnummer und für das andere eine andere Versionsnummer benutzen kann.

Bei der Installation der Library hilft uns der Library-Manager der Platform IO, den wir über das kleine Häuschen in der blauen Platform Io Zeile am unteren Bildschirmrand und dann Libraries erreichen.



Hier geben wir nach dem Sensornamen oder ähnlichem, um die richtige Library zu finden. Wir müssen darauf achten, dass in den aufgelisteten Boards dasjenige befindet, mit dem wir arbeiten. Ich suche gerade die Library von ThingPulse für mein OLED-Display, weil ich mein letztes Projekt von der Arduino IDE zu VS Code portieren will.

Wenn ich meine, das richtige gefunden zu haben, klicke ich auf den Eintrag und erhalte die Details und auch die Liste der mitgelieferten Beispiele:



Zuerst klicken ich auf Install, um die Library zu installieren. Dann kann ich einfach den Source-Code per Copy and Paste in ein neues Projekt kopieren, dieses kompilieren und uploaden und so sehen, ob es funktioniert.

Wichtig ist auch noch der Button "Installation" und hier der Code im Abschnitt Project Dependencies ; PlatformIO Project Configuration File ; ; Build options: build flags, source filter ; Upload options: custom upload port, speed and extra flags ; Library options: dependencies, extra library storages ; Advanced options: extra scripting ; ; Please visit documentation for the other options and examples ; http://docs.platformio.org/page/projectconf.html [env:my_build_env] platform = espressif32 framework = arduino lib_deps = # Using a library name ESP8266 and ESP32 OLED driver for SSD1306 displays # ... or using library Id 2978 # ... or depend on a specific version ESP8266 and ESP32 OLED driver for SSD1306 displays@4.1.0 # Semantic Versioning Rules # http://docs.platformio.org/page/userguide/lib/cmd_install.html#description ESP8266 and ESP32 OLED driver for SSD1306 displays@^4.1.0 ESP8266 and ESP32 OLED driver for SSD1306 displays@~4.1.0 ESP8266 and ESP32 OLED driver for SSD1306 displays@>=4.1.0 Das gelb markierte kopieren wir in unsere platformio.ini, die zu jedem Projekt gehört. Statt des Library-Namens in gelb könnte wir auch dessen Nummer (grau) in die ini schreiben, aber den komplette Namen findet ich sehr viel übersichtlicher. Wenn es eine besondere Version sein soll, dann wird die Versionsnummer (grün) einfach hinter den Eintrag gehangen.

lib_deps darf mehrere Zeilen beinhalten. Die platformio.ini für das portierte Arduino Projekt esp8266-oled-ntp.ino sieht bei mir dann so aus: [env:d1_mini] platform = espressif8266 board = d1_mini framework = arduino monitor_speed = 115200 monitor_port = COM20 upload_port = COM20 lib_deps = ESP8266 and ESP32 OLED driver for SSD1306 displays NTPClient Außer der OLED-Library steht unter lib_deps nun auch noch die NTPClient-Library, um die Zeit zu holen. Diese Einträge können wir jetzt in jede platformio.ini eines jeden neuen Projektes kopieren, wo wir sie benötigen und haben damit für diese Projekte die nötigen Verbindungen zu den Bibliotheken hergestellt.

Die weiteren Einträge in der platformio.ini bedeuten: Es gibt noch ein paar weitere Einstellmöglichkeiten, die unter https://docs.platformio.org/en/latest/projectconf/section_env.html aufgeführt sind.

Sind alle nötigen Einstellungen in der PlatformIO.ini gemacht, dann sollte sich das Projekt ohne Fehler kompilieren, hochladen und auf dem Mikrocontroller ausführen lassen.

Ich habe auch ein Video gemacht, das zeigt wie man PlatformIO installiert und VS Code benutzt, inklusive Demonstration einiger Fallstricke und Problemchen:



Fazit

Mein Fazit: Die Editorfunktionen von VS Code wie etwa Syntax Vervollständigung sind schon eine große Erleichterung beim Programmieren größerer Projekte. Auch ist VS Code übersichtlicher und man sich nicht durch elend lange Scrolldown-Liste scrollen wie mancherorts in der Arduino IDE.

Doch hat VS Code mit PlatformIO auch seine Tücken und Fallstricke, in denen man sich schnell verheddern und die Lust verlieren kann.

Wer nur kleine Projekte hat oder Projekte per Copy and Paste übernimmt, der kann bei der Arduino IDE bleiben. Wer ein bisschen Geduld aufbringen kann, schon routinierter in der Softwareentwicklung ist (und sich nicht so schnell durch "falsche Fehler" aus der Bahn kicken lässt), der sollte VS Studio und die PlatformIO mal ausprobieren. Es bedarf vielleicht ein wenig Einarbeitungszeit und das Finden des einen oder anderen Work-Arounds, aber dann hat man einen mächtigen Editor mit (fast) Allem, was man sich wünschen kann.

Auch gerade, wenn man jetzt oder in Zukunft auch Projekte außerhalb des Arduino Frameworks programmieren will, sei VS Code empfohlen. Es macht die Einarbeitung in den Editor von STM32Cube oder die ESP-IDF überflüssig, denn diese Frameworks beherrscht die PlatformIO ebenso. Heißt: Beherrscht man erstmal die PlatformIO, dann kann man so zielich alles an Mikrocontrollern programmieren, was da draußen rumkreucht und fleucht.