Archiv des Autors: spky

Embedded Arduino Entwicklung mit PlatformIO

In letzter Zeit ist bei uns vor Ort das ESP8266-Fieber ausgebrochen!
Der ESP8266 ist ein sehr kleiner Microcontroller, recht preiswert, mit amtlich Dampf unter der Haube, wenig Energieverbrauch und als Sanehäubchen oben drauf: WLAN!!1!
Eine sehr interessante Plattform, womit sich sehr interessante Projekte und Ideen umsetzen lassen.
Deshalb gibt es diese bei uns hin und wieder im Getränkeautomaten (meist nur kurz, weil sofort ausverkauft..).

ESP8266 & Arduino & PlatformIO

Und was hat der ESP8266 jetzt mit Arduino zu tun?
Hier muss man ein bisschen differenzieren, denn das Arduino Projekt besteht aus mehreren Komponenten. Dies sind:

  • die Hardware → Microcontroller Boards: z.B. Arduino Uno, Arduino Mini, Arduino Nano…
  • die Entwicklungsumgebung (IDE) → das Programm, das auf dem lokalen Rechner läuft, um dort zu programmieren, kompilieren, Hardware zu flashen..
  • das Framework → ein großes Paket an Bibliotheken, Funktionen & Helfern die eine von der Hardware unabhänige Programmierung erlauben.
  • (… und vieles mehr)
Besagtes Framework wurde für den ESP8266 portiert.
Das heißt: Wer schon mal ein Programm für einen Arduino Microcontroller geschrieben hat kann nun auch, ohne groß umzulernen, den ESP8266 programmieren.
Und was ist PlatformIO?
PlatformIO ist ein quelloffenes
„Ökosystem“, das es ermöglicht für eine große Reihe von Microcontrollern auf Grundlage einiger Frameworks zu entwickeln.
(Zum Beispiel lassen sich damit Arduino Microcontroller mit dem Arduino-Framework programmieren..)
Dazu gibt es die PlatformIO IDE, die als Plugin für den Text-Editor Atom daherkommt, und damit PlatformIO aus dem Editor heraus kontrollierbar macht.
Mir persönlich sagt die Arduino IDE nicht sehr zu. Also hab ich mich auf die Suche nach Alternativen begeben, und eben PlatformIO entdeckt.
Aller Anfang ist schwer, um Abhilfe zu schaffen, möchte ich in diesem Artikel ein paar Dinge behandeln:
  • Wie man PlatformIO installiert und zum laufen bekommt.
  • Darin ein neues Projekt erstellt.
  • Dieses kompilert, um das auf den ESP8266 zu flashen.
Natürlich lässt sich PlatformIO auch ohne die IDE nutzen, und/oder alle dazu benötigten Komponenten separat installieren.
Dies würde aber den Rahmen des Artikels sprengen, ich beschränke mich auf die Installation mittels Atom-Plugin, da dieses alle Abhänigkeiten mitbringt.

Packliste

  • Als Basis: Den Atom Text Editor.
  • Das PlatformIO IDE Editor Plugin (installiert man in Atom selbst, siehe unten)
  • Clang aus dem LLVM Projekt. Bei der Installation des Plugins wird erkannt, dass Clang fehlt, und es wird ein passender Download angeboten.
  • Einen ESP8266 natürlich. Im Beispiel nutze ich das NodeMCU DEVKIT 1.0 von Amica (das Selbe wie in diesem Artikel hier).
  • Serielle Treiber passend zum Betriebssystem und dem ESP8266.
    Das NodeMCU DEVKIT hat einen CP2102 verbaut, das wären dann die CP210x USB to UART Bridge Virtual COM Port (VCP) Treiber von Silicon Labs.

Installation

Treiber

Falls noch nicht vorhanden, beginnt man mit dem seriellen Treiber. Die Installation variiert je nach Betriebssystem und dem ESP8266.

  • Auf dem Mac lohnt sich der Blick in Homebrew, der Treiber für den CP210x z.B. ist mit dabei:

    brew tap caskroom/drivers
    brew install silicon-labs-vcp-driver
  • Für Wintendo gibt es einen Installer auf der Website.
  • Linux: ja!
  • FreeBSD: CP210x Treiber sind mit im Basissystem: uslcom stellt z.B. /dev/cuaU0 bereit.

Atom Text Editor

Die Installation von Atom selbst bedarf hoffentlich keine größere Erklärung: Die neueste Version herunterladen, und installieren..

atom welcome

Danach begrüßt uns der „Welcome Guide“
Den Haken vor „Show Welcome Guide when opening Atom“ sollte man getrost weg machen.

PlatformIO IDE

Es folgt die IDE: In Atom geht es in die Einstellungen (File > Settings), dort findet sich in der linken Leiste unten der Punkt Install.

install ide
Dort nach platformio-ide suchen, und schön brav auf Installieren klicken…

Das ganze dauert ein bisschen, es wird ein eigener Python Interpreter (2.7) installiert, Platformio selbst als Package darin registriert, und weitere Abhängigkeiten vom Plugin selbst werden installiert (Debugger, Terminal)…

LLVM/Clang

Bei der Installation wird erkannt, dass Clang auf dem System nicht vorhanden ist:

clang missing

Dieser Schritt ist nicht zwingend notwendig, wird aber wärmstens empfohlen.

Unter Windows muss man LLVM der PATH Variable hinzufügen lassen.

clang options

Ob das geklappt hat, kann man in der cmd.exe überprüfen:
Gibt man dort echo %PATH% ein, dann sollte die Ausgabe das hier (oder so ähnlich) mit enthalten: C:\Program Files\LLVM\bin;

Konfigurieren

install finished
Hurra, wir sind endlich fertig.
Nach dem Neustart erscheint ein neuer Menüpunkt namens PlatformIO.
Ein Blick in die IDE Settings (PlatformIO > Settings > PlatformIO IDE) lohnt sich:
disable homescreen
Nein, danke, ich möchte gerne sofort losarbeiten, und nicht jedes mal das Zeug wegklicken…
disable login
Habe keinen Account, brauchst mich auch nicht jedes mal wieder danach fragen, danke…

Programmieren

Jetzt können wir loslegen, dazu brauchen wir ein neues Projekt (PlatformIO > Initialize or Update PlatformIO Project):

initialize project

Das NodeMCU DEVKIT hat einen ESP8266-12E verbaut.
Dann noch einen neuen Ordner dazu, fertig.
Fehlende Plattformen/Bibliotheken werden automatisch nachinstalliert.

Innerhalb des Projekts wird im src Ordner der eigene Code abgelegt:

new sourcefiles
Wir brauchen zwei Dateien:

  • src/main.hpp
  • src/main.cpp

main.hpp

Es lassen sich ordentliche Header Files schreiben. Wunderbar.
Wichtig ist, dass das #include <Arduino.h> niemals fehlen sollte. Auch müssen die Signaturen für setup() und loop() definiert werden.
#define LED_PIN D0 verweist auf den Pin der eingebauten Leuchtdiode. (Beim NodeMCU DEVKIT zumindest, ggf. anpassen)
Dazu noch zwei Methoden, damit das Beispiel nicht so langweilig wird.

#ifndef __main_hpp__
#define __main_hpp__

#include <Arduino.h>

#define LED_PIN D0

void setup(void);
void loop(void);

void flashLed(void);
String getUptime(void);

#endif

main.cpp

Hier nicht vergessen, die main.hpp einzubinden.

#include "main.hpp"

void setup(void) {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, HIGH);
  Serial.begin(112500, SERIAL_8N1);
  Serial.println("setup() done");
}

void loop(void) {
  flashLed();
  delay(2048);
  Serial.println("uptime: " + getUptime());
}

void flashLed(void) {
  digitalWrite(LED_PIN, LOW); delay(256);
  digitalWrite(LED_PIN, HIGH); delay(128);
  digitalWrite(LED_PIN, LOW); delay(256);
  digitalWrite(LED_PIN, HIGH); delay(128);
}

String getUptime(void) {
  unsigned long sec = millis() / 1000;
  unsigned long min = sec / 60;
  unsigned long hrs = min / 60;
  unsigned long day = hrs / 24;
  sec = sec - (min * 60);
  min = min - (hrs * 60);
  hrs = hrs - (day * 24);
  static char res[16];
  if (day >= 1) {
    sprintf(res, "%dd %02d:%02d:%02d", day, hrs, min, sec);
  } else {
    sprintf(res, "%02d:%02d:%02d", hrs, min, sec);
  }
  return String(res);
}
Es folgt der Moment der Wahrheit – Keine Fehler gemacht? Kompilert es?
In der linken Seitenleiste sind ein paar Schnellstarter:

  • Haken → Kompilieren
  • Pfeil → Kompilieren & Upload
  • Mülltonne → Aufräumen
compile and upload
Beim initialen Kompilieren oder Upload werden weitere Abhängigkeiten automatisch nachinstalliert..
Der Schnellstarter mit dem Stecker-Symbol öffnet den „Serial Monitor“

serial monitor
Den passenden Port auswählen, die Baudrate anpassen. Muss man nur einmalig machen, die Einstellungen werden gespeichert und beim nächsten mal mit vorgeschlagen. Nett.
Erfolg! Freude! Wir sind fertig!

final
Auf dem Schreibtisch liegt nun ein ESP8266, der auf der internen LED fleißig blinkt, und die Uptime im seriellen Monitor anzeigt.

Fazit

Von Atom mag man halten was man will. Die Entscheidung einen bereits existierenden Editor zu erweitern finde ich aber gut.
Zumindest klüger als mit einer Eigenentwicklung anzutreten, so wie es bei der Arduino IDE der Fall ist.
Es existieren bereits eine Menge interessanter Plugins, die Oberfläche sieht schicker aus, die Keybord Shortcuts sind sinnvoll belegt..
An so Details, dass sich der Serielle Monitor automatisch beendet, wenn man versucht eine neue Firmware zu flashen, sieht man, dass jemand mitgedacht hat (würde die Verbindung offen bleiben, bricht der Flash-Vorgang mit einem Fehler ab → „Verbindung nicht möglich“).

Hübsch: Der Source-Code hat korrekte Dateiendungen, nicht mehr dieses unsägliche .ino oder .pde, das von keinem normalen Syntax-Highlighter erkannt wird.
Da am Ende alles ganz normaler C++ Quellcode ist, lässt sich auch komfortabel die #include Direktive nutzen.
Dies hilft ungemein bei größeren Projekten, um die Übersicht zu behalten.
Somit ist es ganz einfach möglich auch Objekt-Orientiert für die Microcontroller zu programmieren. Mach ich in letzter Zeit sehr gerne, und muss gestehen, erst dadurch ist die Arduino Plattform für mich interessant geworden…
Die Installation & Einrichtung macht man zum Glück nur einmal. Läuft alles wie es soll, kann man viel Freude am Programmieren haben!

Viel Spaß am Gerät!