Embedded Arduino Entwicklung mit PlatformIO

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.

• Wie man PlatformIO installiert und zum laufen bekommt.
• Darin ein neues Projekt erstellt.
• Dieses kompilert, um das auf den ESP8266 zu flashen.

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

Atom Text Editor

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

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.

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:

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

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

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

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:

Nein, danke, ich möchte gerne sofort losarbeiten, und nicht jedes mal das Zeug wegklicken...

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):

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:

Wir brauchen zwei Dateien:

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

main.hpp

#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

#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

Beim initialen Kompilieren oder Upload werden weitere Abhängigkeiten automatisch nachinstalliert..

Der Schnellstarter mit dem Stecker-Symbol öffnet den "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!

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

Fazit

Viel Spaß am Gerät!