Feinstaubsensor – Teil 4: Feinstaub-Software flashen

Wenn die Arduino IDE auf einem PC installiert ist und die USB-Verbindung vom PC zum NodeMCU-Board funktioniert, dann können wir uns dran machen, die Feinstaub-Software aufzuspielen. Das sollte in jedem Fall passieren, bevor wir die Komponenten verkabeln und unter Strom setzen, damit keine ungewollten Spannungspegel die Bauteile zerstören können. Das Flashen der Feinstaub-Software kann auf zwei verschiedene Arten geschehen. Wir können eine fertig kompilierte Version flashen, oder wir kompilieren selbst in der Arduino IDE. Ich zeige hier beide Möglichkeiten für einen Linux-PC.

Ich verweise hier wieder auf die originale Anleitung des Stuttgarter Feinstaub Projekts, die man in jedem Fall gelesen haben sollte, vor allem, wenn man unter Windows oder Mac-OS arbeitet. Diese Anleitung ist allerdings – was das Flashen angeht – ziemlich knapp gehalten. Ich werde das für Linux etwas genauer beschreiben und eine zweite Flash-Methode vorstellen.

Voraussetzung für beide Methoden ist, dass am PC die Arduino IDE und der Boardmanager für das NodeMCU-Board installiert sind.

Methode A: Flashen einer vorkompilierten Feinstaub-Firmware

Das ist die einfachste Methode und die wird auch vom Stuttgarter Feinstaubprojekt vorgeschlagen. Hier laden wir uns eine fertig kompilierte Feinstaub-Firmware herunter und flashen sie mit einem einzigen Commandline-Befehl auf den Mikrocontroller.

Download

Link: https://www.madavi.de/sensor/update/data/latest_de.bin

Der Link bietet eine Datei latest_de.bin zum Download an. Wir öffnen die Datei nicht, sondern speichern sie ab. Unter Linux erfolgt das typischerweise ins Verzeichnis Downloads innerhalb des persönlichen Ordners.

Flashen

So sieht der Befehl aus, der die Bin-Datei auf den Mikrocontroller flasht. Ja, der ist wirklich so lang.

~/.arduino15/packages/esp8266/tools/esptool/0.4.9/esptool -vv -cd nodemcu -cb 57600 -ca 0x00000 -cp USB-Schnittstelle -cf Pfad_zur_Firmwaredatei 

Wir müssen aber noch zwei individuelle Anpassungen vornehmen. Hinter

  • -cp muss die eigene USB-Serial-Schnittstelle eingetragen werden. Das ist die, die wir in der Arduino IDE ausgewählt hatten und nach
  • -cf wird die eben heruntergeladene Firmwaredatei angegeben.

Dann können wir damit loslegen:

$ ~/.arduino15/packages/esp8266/tools/esptool/0.4.9/esptool -vv -cd nodemcu -cb 57600 -ca 0x00000 -cp /dev/ttyUSB0 -cf ~/Downloads/latest_de.bin
esptool v0.4.9 - (c) 2014 Ch. Klippel <ck@atelier-klippel.de>
	setting board to nodemcu
	setting baudrate from 115200 to 57600
	setting address from 0x00000000 to 0x00000000
	setting port from /dev/ttyUSB0 to /dev/ttyUSB0
	espcomm_upload_file
	espcomm_upload_mem
opening port /dev/ttyUSB0 at 57600
	tcgetattr
	tcsetattr
	serial open
opening bootloader
resetting board
trying to connect
	espcomm_send_command: sending command header
	espcomm_send_command: sending command payload
trying to connect
	espcomm_send_command: sending command header
	espcomm_send_command: sending command payload
	espcomm_send_command: receiving 2 bytes of data
	espcomm_send_command: receiving 2 bytes of data
	espcomm_send_command: receiving 2 bytes of data
	espcomm_send_command: receiving 2 bytes of data
	espcomm_send_command: receiving 2 bytes of data
	espcomm_send_command: receiving 2 bytes of data
	espcomm_send_command: receiving 2 bytes of data
	espcomm_send_command: receiving 2 bytes of data
Uploading 445904 bytes from /home/helmut/Downloads/latest_de.bin to flash at 0x00000000
	erasing flash
	size: 06cdd0 address: 000000
	first_sector_index: 0
	total_sector_count: 109
	head_sector_count: 16
	adjusted_sector_count: 93
	erase_size: 05d000
	espcomm_send_command: sending command header
	espcomm_send_command: sending command payload
	setting timeout 15000
	setting timeout 100
	espcomm_send_command: receiving 2 bytes of data
	writing flash
................................................................................ [ 18% ]
................................................................................ [ 36% ]
................................................................................ [ 55% ]
................................................................................ [ 73% ]
................................................................................ [ 91% ]
....................................                                             [ 100% ]
starting app without reboot
	espcomm_send_command: sending command header
	espcomm_send_command: sending command payload
	espcomm_send_command: receiving 2 bytes of data
closing bootloader

Damit ist das Flashen beendet. Wir können das schnell mit dem Smartphone überprüfen – es gibt jetzt ein WLAN-Netz mit Namen Feinstaubsensor-xxxxxx.

Methode B: Feinstaub-Firmware selbst kompilieren und flashen

Diese Methode ist etwas aufwändiger, weil wir erst alle verwendeten Bibliotheken einbinden müssen.

Download

Bei diesem Verfahren laden wir uns keine fertig kompilierte Software herunter, sondern den Quellcode in Form mehrerer Textdateien, die zu einem ZIP-Archiv zusammengefasst sind. Ausgangspunkt für den Download ist die Stuttgarter Projektseite bei Github.com.

Link: https://github.com/opendata-stuttgart/sensors-software

Auf dieser Seite werfen wir einen Blick in die Anleitung (readme.md) unten, die Auskunft über die verschiedenen Verzeichnisse gibt. Der entnehmen wir, dass die aktuelle Firmware (im Sommer 2017) im Verzeichnis airrohr.firmware liegt. Wir laden uns aber das ganze Projekt herunter, in dem wir auf der Seite sensors-software (besagter Link) oben rechts auf den grünen Button Clone or Download klicken und dann auf Download ZIP. Die Zip-Datei in unserem Downloads-Verzeichnis heißt dann beispielsweise sensors-software-master.zip und die öffnen wir mit der Archivverwaltung und entpacken sie in unser Arduino Sketchbook. Das ist das Verzeichnis Arduino im persönlichen Ordner. Dort gibt es dann ein Unterverzeichnis sensors-software-master und darin finden wir die gesamte Verzeichnisstruktur wie online auf Github.

Bibliotheken nachinstallieren

Mit dem Quellcode der Feinstaub-Firmware allein ist es nicht getan. Die verwendet zahlreiche Software-Bibliotheken und wenn wir selbst kompilieren wollen, dann brauchen wir die alle in unserer Arduino IDE.

Informationen, welche Bibliotheken wir installieren müssen und wo wir die her bekommen, finden wir in der readme.md-Datei im Verzeichnis airrohr-firmware. Die können wir entweder auf unserem eigenen PC im Verzeichnis  Arduino/sensors-software-master/airrohr-firmware mit einem Texteditor öffnen, oder online in Github im Browser (was die schönere Darstellung ist). In der Readme-Datei blättern wir nach unten zum Abschnitt Benötigte Software. Ich führe hier explizit nicht alle Bibliotheken auf, die installiert werden müssen. Denn das kann sich mit jeder neuen Software-Version ändern und mit jeder neuen Sensor-Hardware, die in das Projekt aufgenommen wird.

Was die Installation der Bibliotheken angeht, gibt es prinzipiell drei Fälle, die wir unterscheiden müssen:

  1. Bibliotheken, die wir bereits installiert haben, zum einen mit der Arduino IDE selbst und zum zweiten mit dem Boardmanager für den ESP8266-Chip. Diese Bibliotheken werden in der Readme-Datei aufgeführt, für uns ist aber nichts weiter zu tun.
  2. Bibliotheken, die über die Arduino IDE installierbar sind. Für die ist in der Readme-Datei jeweils die erforderliche Version angegeben. Die Vorgehensweise ist folgende: In der Arduino IDE gehen wir auf Sketch – Bibliothek einbinden – Bibliotheken verwalten und suchen die jeweilige Bibliothek. Die Verwendung des Suchfelds rechts oben ist sinnvoll. Dann klicken wir auf den entsprechenden Eintrag, wählen die benötigte Softwareversion aus und klicken auf Installieren. Und das der Reihe nach für alle aufgeführten Bibliotheken.
  3. Bibliotheken, die manuell installiert werden müssen. Im Sommer 2017 ist das nur eine einzige (nämlich TinyGPS++). Hier müssen wir über den in der Readme-Datei angegebenen Link die Software als ZIP-Datei herunterladen. Die können wir gepackt im Downloads-Verzeichnis liegen lassen und wechseln in die Arduino IDE. Dort gehen wir auf Sketch – Bibliothek einbinden – .ZIP-Bibliothek hinzufügen und wählen die downgeloadete Zip-Datei aus.

Damit haben wir sowohl den Quellcode der Feinstaub-Firmware in die Arduino IDE geladen, als auch alle benötigten Bibliotheken. An dieser Stelle bietet es sich an, die Arduino IDE neu zu starten, bevor es ans Kompilieren geht.

Anpassen, Kompilieren und Flashen

Nachdem wir bei diesem Verfahren die Feinstaubsoftware im Quellcode vorliegen haben, können wir die auch anpassen. Das soll jetzt keine Aufforderung sein, die Software umzuschreiben, aber wir können an dieser Stelle bereits Konfigurationen vornehmen.

Öffnen wir zuerst einmal das Feinstaub-Projekt in der Arduino IDE. Und zwar mit Datei – Öffnen und dann wählen wir im persönlichen Ordner im Verzeichnis Arduino/sensors-software-master/airrohr-firmware die Datei airrohr-firmware.ino aus. Es werden jede Menge Reiter geöffnet, darunter auch ext_def.h. In dieser Datei könnten wir zum Beispiel gleich die WLAN-Zugangsdaten eingeben. Das muss aber nicht sein, konfigurieren können wir die Feinstaub-Software auch später über den eigenen WLAN-Accesspoint, den die Feinstaubsoftware zur Konfiguration anbietet. Wir können die Dateien also getrost unverändert belassen.

Kompiliert wird mit dem Häkchen-Symbol (Überprüfen) ganz links in der Symbolleiste. Dabei achten wir auf die Meldungen im unteren Programmfenster – vor allem auf Fehlermeldungen. Diesen Schritt können wir aber auch übergehen, beim Flashen wird das Kompilieren automatisch mit ausgeführt.

Spätestens zum Flashen (Pfeil nach rechts in der Symbolleiste für Hochladen) muss natürlich das NodeMCU-Board über ein möglichst kurzes USB-Kabel an den PC angeschlossen sein. Während des Hochladens blinkt die blaue LED am NodeMCU-Board und die Ausgabe der Arduino IDE sieht so ähnlich wie diese aus:

WARNUNG: Bibliothek LiquidCrystal_I2C behauptet auf (avr) Architektur(en) ausgeführt werden zu können und ist möglicherweise inkompatibel mit Ihrem derzeitigen Board, welches auf (esp8266) Architektur(en) ausgeführt wird.
Archiving built core (caching) in: /tmp/arduino_cache_94628/core/core_esp8266_esp8266_nodemcuv2_CpuFrequency_80,UploadSpeed_115200,FlashSize_4M3M_012ea8a310a8a8eb2b525b90e8223795.a
Der Sketch verwendet 441783 Bytes (42%) des Programmspeicherplatzes. Das Maximum sind 1044464 Bytes.
Globale Variablen verwenden 47960 Bytes (58%) des dynamischen Speichers, 33960 Bytes für lokale Variablen verbleiben. Das Maximum sind 81920 Bytes.
Uploading 445936 bytes from /tmp/arduino_build_147695/airrohr-firmware.ino.bin to flash at 0x00000000
................................................................................ [ 18% ]
................................................................................ [ 36% ]
................................................................................ [ 55% ]
................................................................................ [ 73% ]
................................................................................ [ 91% ]
....................................                                             [ 100% ]

Den Erfolg können wir auch bei dieser Methode mit dem Smartphone überprüfen – es muss jetzt ein WLAN-Netz mit Namen Feinstaubsensor-xxxxxx verfügbar sein.

Welche Flash-Methode verwenden?

Wer es einfach haben will, der verwendet ganz klar die Methode A. Da muss man sich keine Gedanken ums Kompilieren machen und vor allem keine Bibliotheken installieren. Die Firmware ist fertig kompiliert, allerdings nicht zwangsweise die letzte Entwicklungsversion sondern eher die letzte stabile Version, was ja durchaus in Ordnung ist. Allerdings muss man sich mit diesem langen kryptischen Kompilierbefehl rumschlagen, was etwas nervig ist, wenn es nicht funktioniert.

Methode B, also das Selber-Kompilieren, ist eher was für diejenigen, die die absolut neueste Version brauchen (wegen neu unterstützter Sensoren zum Beispiel). Der Aufwand ist ein gutes Stück höher, dafür kann bequem in der Arduino IDE gearbeitet werden. Auch wer mehr über die Programmierung von Mikrocontrollern lernen möchte, wählt dieses Verfahren.

Die Feinstaub-Firmware ist nun auf den NodeMCU-Chip geflasht, wir können ihn vom PC abstecken und uns den nächsten Schritten zuwenden.

Exkurs: Firmware, Software oder Sketch?

Mal heißt es Feinstaub-Software, mal Feinstaub-Firmware und was ist überhaupt ein Sketch? Hier eine kurze Begriffsklärung. Was die harte und was die weiche Ware ist, darunter können wir uns nach Jahrzehnten mit Computer-Englisch alle etwas vorstellen. Die feste Ware, also die Firmware ist natürlich auch Software, allerdings eine, die fest mit der Hardware verbunden ist und nicht ohne weiteres verändert werden kann. Die interne Software einer Fritzbox wäre zum Beispiel eine typische Firmware, oder die Software eines internetfähigen Fernsehers oder eines Navigationsgeräts. Und eben auch die Software eines Feinstaub-Sensors. Das Feste bei der Feinstaub-Firmware liegt darin begründet, dass die Firmware per PC-Verbindung geflasht werden muss und dann dieser Flash-Memory nicht mehr so einfach zu verändern ist.

So weit die reine Lehre. Dass sich die Konturen dieser Begrifflichkeiten aber zunehmend aufweichen, sieht man daran, dass die Feinstaub-Firmware durchaus in der Lage ist, sich selber im laufenden Betrieb mit Software-Updates zu flashen. So fest ist die Firmware also gar nicht.

Und der Sketch? Das ist ein Begriff aus der Arduino-Welt und er steht für Programme, die in der Arduino IDE geschrieben, kompiliert und dann geflasht werden. In der restlichen Mikrocontroller-Welt außerhalb von Arduino ist das Wort Sketch eher verpönt, dort bezeichnet man Programme für Mikrocontroller als Programm und nicht als Skizze.

Im Falle dieses Feinstaub-Projekts sind die Begriffe Software, Firmware und Sketch also weitgehend synonym zu betrachten.

 


Weitere Artikel in dieser Kategorie:

Schreiben Sie einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.