seeseekey.net - Invictus Deus Ex Machina

Wenn man einen ESP8266 programmiert, so wird man dessen GPIOs nutzen um externe Dinge wie Sensoren oder ähnliches anzusteuern bzw. auszulesen. Versucht man das gleiche mit einem NodeMCU-Board wird man feststellen das die Pinbelegung des Boards nicht mit der vom ESP8266 übereinstimmt.

Das NodeMCU-Board in Version 3

Wenn man die Pinbelegung des NodeMCU-Boards mit der vom ESP8266 in Reinform vergleicht, ergibt sich folgendes Bild:

NodeMCU D0 zu ESP8266 16
NodeMCU D1 zu ESP8266 5
NodeMCU D2 zu ESP8266 4
NodeMCU D3 zu ESP8266 0
NodeMCU D4 zu ESP8266 2
NodeMCU D5 zu ESP8266 14
NodeMCU D6 zu ESP8266 12
NodeMCU D7 zu ESP8266 13
NodeMCU D8 zu ESP8266 15
NodeMCU D9 zu ESP8266 3
NodeMCU D10 zu ESP8266 1

Bei der Entwicklung über die Arduino IDE braucht man allerdings keine Sorgen machen. Wird hier das NodeMCU-Board genutzt, so findet man definierte Konstanten von D0 bis D10 um die NodeMCU-GPIOs direkt anzusprechen. Einige der Pins haben auf dem Board eine besondere Funktion:

D1 (I2C Bus / SCL (Clock-Signal))
D2 (I2C Bus / SDA (Datenleitung))
D4 (wie LED_BUILTIN, aber invertierte Logik)
D5 (SPI Bus SCK (Clock-Signal))
D6 (PI Bus MISO)
D7 (SPI Bus MOSI)
D8 (SPI Bus SS (CS))
D9 (Serielle Konsole RX)
D10 (Serielle Konsole TX)

Wenn man das Android Studio unter macOS installiert hat, wird man unter Umständen feststellen dass man es nicht ohne Rückstände wieder deinstallieren kann. Es reicht nicht die Android Studio App zu löschen, stattdessen müssen ein paar Ordner mehr angefasst werden. Wer es sich einfach machen möchte kann folgende Kommandos im Terminal eingeben:

rm -Rf /Applications/Android\ Studio.app
rm -Rf ~/.AndroidStudio*
rm -Rf ~/.gradle
rm -Rf ~/Library/Preferences/AndroidStudio*
rm -Rf ~/Library/Preferences/com.google.android.*
rm -Rf ~/Library/Preferences/com.android.*
rm -Rf ~/Library/Application\ Support/AndroidStudio*
rm -Rf ~/Library/Logs/AndroidStudio*
rm -Rf ~/Library/Caches/AndroidStudio*

Zusätzlich kann man die SDK-Tools und die virtuellen Maschinen für den Android Emulator löschen. Allerdings sollte man hier sicher sein, das sie von keiner anderen Anwendung wie z.B. dem Xamarin Studio noch benötigt werden:

rm -Rf ~/.android
rm -Rf ~/Library/Android*

Für ein kleineres Projekt habe ich vor einiger Zeit eine HTML5-Single-Page-Application entwickelt und stand dann vor dem Problem wie ich unterschiedliche Views innerhalb dieser Seite realisiere. Da ich möglichst ohne schwerfälliges Framework auskommen wollte, habe ich mich für eine Lösung mittels jQuery entschieden. Im HTML habe ich dazu mehrere Views definiert:

<div id="options" class="widget" style="display: none">
</div>

<div id="game" class="widget">
</div>

Der Inhalt des div-Elements mit der Id options ist dabei standardmäßig ausgeblendet. Nun kann die Ansicht der beiden Views mittels der Funktion switchView gewechselt werden:

switchView() {
	  
    if(this.activeView==this.Views.Game) {
        $("#game").css({"display": "none"});
        $("#options").css({"display": "block"});
        this.activeView = this.Views.Options;
    }
    else if (this.activeView==this.Views.Options) {
        $("#options").css({"display": "none"});
        $("#game").css({"display": "block"});
        this.activeView = this.Views.Game;
    }
}

In der Funktion wird das CSS der jeweiligen div-Elemente manipuliert. Dadurch wird die Sichtbarkeit der Blöcke gewechselt und man hat eine einfache View Umschaltung realisiert.

Wenn man unter JUnit für mehrere Tests einige vorbereitende Schritte benötigt, so kann man dafür die @Before Annotation nutzen:

@Before
public void setup() {
    // Prepare something
}

Das Problem an dieser Methode ist, das dass ganze auf eine Klasse beschränkt ist. Benötigt man die vorbereitenden Schritte in mehreren Klassen, so muss man sich unter JUnit 4 anders behelfen. Dort führt die Lösung über eine abstrakte Klasse:

public abstract class TestBase {
    @Before
    public void setup() {
        // Prepare something
    }
}

Von dieser Klasse können die Klassen mit den Testfällen abgeleitet werden. Allerdings muss man beachten, das es hierbei zu doppelter Initialisierung kommen kann. Unter JUnit 5 kann man dies nun wesentlich einfacher lösen. Dort gibt es die neue Annotation @BeforeAll:

@BeforeAll
public void setup() {
    // Prepare something
}

Mit diese Annotation wird die Initialisierung vor der Ausführung der Tests durchgeführt.

Das auf dem ESP8266 basierendem Entwicklungsboard NodeMCU gibt es unterschiedlichen Varianten, die sich unter anderem durch die Größe des Flashspeichers unterscheiden. Möchte man nun ermitteln welche Größe der Speicher beim eigenen NodeMCU-Board hat kann man dies mit einem Programm aus einem der ESP8266-Repositories sehr unkompliziert ermittelt.

Die Größe des Flashspeichers wird über die serielle Schnittstelle ausgegeben

Nachdem die Arduino IDE mit dem Programm geöffnet wurde und das Programm auf das NodeMCU-Board geflasht wurde, kann die Ausgabe über die serielle Schnittstelle ausgelesen werden. Dazu muss der serielle Monitor, im Menü unter Werkzeuge -> Serieller Monitor zu finden, aktiviert werden. Wichtig ist es, dass hier die korrekte Baudrate eingestellt wird.

Enums gibt es unter JavaScript nicht. Damit könnte der Artikel an dieser Stelle vorbei sein. Allerdings gibt es viele Wege um in JavaScript ein Verhalten oder die Strukturen zu simulieren, die am Ende gewünscht sind. Bei einem Enum würde dies so aussehen:

var DayOfTheWeek = {
  Monday: 1,
  Tuesday: 2,
  Wednesday: 3,
  Thursday: 4,
  Friday: 5,
  Saturday: 6,
  Sunday: 7
};

Genutzt wird das ganze dann so:

var dayOfTheWeek = DayOfTheWeek.Thursday;

Wer mehr über die Hintergründe rund um Enums unter JavaScript erfahren möchte dem sei der ausgezeichnete Blogbeitrag Enums in Javascript empfohlen.

Unter Java ist es möglich mit sogenannten Keystores zu arbeiten. Dabei handelt es sich um Containerdateien in welchen Zertifikate gespeichert werden können. Diese können dann z.B. beim Start eines Tomcat mit übergeben werden. Damit sind die Zertifikate der Java-Applikation bekannt. Möchte man ein solches Zertifikat in einen Keystore importieren, so nutzt man das Tool keytool:

keytool -importcert -file server-ca-web.pem -keystore store.jks -alias "server-ca-web"

Das Tool ist im Java SDK enthalten und wird für die Verwaltung der Keystores genutzt. In diesem Fall wird das Zertifikat server-ca-web.pem in den Keystore store.jks geschrieben.

Reguläre Ausdrücke sind mächtig. Wenn man einen solchen Ausdruck entwickelt z.B. um eine Zeichenkette zu extrahieren, ist es enorm hilfreich das ganze zeitnah zu debuggen. Mit der Webseite regexr.com gibt es dafür einen Dienst mit welchem eigene reguläre Ausdrücke schnell überprüft und getestet werden können. Dabei wird der Ausdruck auf der Seite eingegeben und anschließend gegen den angegebenen Text überprüft.

regexr.com

regexr.com

Daneben bietet der Dienst eine Reihe von Zusatzfunktionalitäten, wie die von Nutzern befüllte Bibliothek von regulären Ausdrücken für bestimmte Funktionalitäten. Der Quelltext des Dienstes ist auf GitHub zu finden – er ist unter der MIT-Lizenz lizenziert und damit freie Software.

Für das Build-Management-Tool Maven gibt es eine große Anzahl an Plugins mit welchen die Funktionalität von Maven erweitert werden kann. Eines dieses Plugins ist das Maven Enforcer Plugin. Dieses Plugin überprüft ob die Abhängigkeiten zwischen JDK, Bibliotheken und vielem mehr gegeben sind. Ist dies nicht der Fall wird der Kompiliervorgang abgebrochen. Möchte man diese Überprüfung temporär deaktivieren muss die Kommandozeile um den Parameter -Denforcer.fail=false erweitert werden:

mvn clean compile -Denforcer.fail=false

Damit wird die Funktionalität des Enforcer Plugins für den Vorgang deaktiviert. Mittelfristig sollen natürlich die Abhängigkeiten korrigiert werden, so dass der Vorgang mit aktiviertem Plugin erfolgreich durchlaufen werden kann.