TinkerForge: Einstieg mit Master Brick 2.1, WIFI Master Extension 2.0 und Voltage/Current Bricklet 2.0

TinkerForge ist eine deutsche Firma aus Schloß Holte-Stukenbrock, die sich seit 2011 bemüht, die Arbeit mit eingebetteten Systemen zu vereinfachen. Ein Stecksystem erübrigt den Griff zum Lötkolben und  detaillierte Kenntnisse in Elektronik werden überflüssig. In diesem Artikel möchte ich testen, in wie weit dies gelungen ist und meine persönliche Erfahrung beschreiben.

Einführung

TinkerForge setzt konsequent auf den Open Source Gedanken und veröffentlicht den Quellcode und weitere Informationen zu den einzelnen Produkten im Firmenaccount auf Github in aktuell 178 Repositories.

Um das Ziel der Vereinfachung zu erreichen, setzt TinkerForge auf ein Baukastensystem aus Bricks, Bricklets und Master Extensions.

Bricks und Master Extensions besitzen eine einheitliche Grundfläche von 4x4cm und werden über den Stack Connector zu Stapeln verbunden. Der wichtigste Brick ist dabei der Master Brick, dieser erfüllt mehrere Aufgaben. Zum einen ermöglicht er den Anschluss von bis zu 4 Bricklets,  bietet die direkte Kommunikation via USB zu einem PC und dienst als Master der Kontrolle des Stapels (nur der Master Brick, um unteren Ende des Stapels dient als tatsächlicher Master, die anderen bieten dann nur  den Anschluss von weiteren maximal 4  Bricklets). Weitere Bricks erlauben den direkten Anschluss von Gleichstrommotoren, Modellbauservos und Schrittmotoren oder dienen als 9-Achsen Lagesensor (IMU Brick). In der Dokumentation findet sich eine Liste der Bricks neben einer Liste der Master Extension.

Bei den Bricklets wird bewusst auf ein einheitliches Format verzichtet, da so ganz unterschiedliche Sensoren, Aktoren, Konverter zu anderen Bussystemen und verschiedenen Mensch-Maschine-Schnittstellen verbunden werden können. Eine vollumfängliche Liste der Bricklets findet man sich in der Bricklet-Dokumentation. Verbunden werden die Bricklets mit vorkonfektionierten Kabeln unterschiedlicher Längen von 6cm bis zu 2m.

Allen Modulen gemein ist ein Raster der Befestigungslöcher von 5mm, zur Befestigung bietet Tinkerforge Montageplatten für den schnellen Aufbau auf dem Schreibtisch an.

Tinkerforge bietet aktuell für 14 Sprachen (davon 3 als spezielle Ausprägungen für mobile Geräte) fertig APIs an. Diese basieren alle auf dem TCP/IP Protokoll, deshalb sollte eine Adaption für weitere Sprachen durchführbar sein (Swift fehlt zum Beispiel in der Liste der unterstützten Sprachen bisher).

Persönliche Erfahrung

Für den Einstieg entschied ich mich für folgende 3 Module:

Das Ziel ist die kombinierte Messung der von einer Solarzelle gelieferten Spannungs- und Stromwerte und der Transfer in ein Grafana.

Bestellt habe ich direkt bei TinkerForge, geliefert wurde ohne Aufschlag bereits am nächsten Tag.

Installation des Brick Daemon (brickd)

Der Brick Daemon abstrahiert als Systemdienst die Kommunikation zwischen den APIs und dem Master Brick über USB. Den Quellcode findet man im brickd-Repository und Pakete für Debian-artige Distributionen zum Download auf tinkerforge.com.

Allerdings ist die Standardkonfiguration des suboptimal, da auf allen IP Adressen des Rechners ohne Authentifizierung gelauscht wird. Hier sollte man sich doch eher auf localhost 127.0.0.1 beschränken. Dies kann nachträglich in der Datei /etc/brickd.conf mit der Option listen.address angepasst werden. Zusaetzlich habe ich einen Pull-Request erstellt, der das Default anpasst.

Nach der Einrichtung der WIFI Master Extension kann jedoch direkt deren IP Verbindung genutzt werden und der brickd wird obsolet.

Installation des Brick Viewer (brickv)

Der Brick Viewer ermöglicht den Zugriff auf auf lokal angeschlossene Bricks über USB und auch per IP auf entfernte Bricks. Auch hier ist der Quellcode im entsprechenden brickv-Repository zu finden, deb-Pakete finden sich als Downloads auf tinkerforge.com.

Leerer Master Brick
Setup-Reiter eines Master Brick ohne weitere Module

Der Brick Viewer zeigt bei einem einzelnen Master Brick natürlich noch nicht viele Informationen an:

Update Dialog
Dialog zum Aktualisieren der Firmwares

Allerdings ist schon jetzt eine Verbindung via USB möglich und es kann zum Beispiel ein Update der Firmware vorgenommen werden (Changelog).

Schließt man nun den Voltage/Current Bricklet 2.0 an einen beliebigen Port des Master Bricks an, so wird dieser automatisch erkannt.

Master Brick mit Voltage/Current Bricklet 2.0
Setup-Reiter eines Master Brick mit angeschlossenem Voltage/Current Bricklet 2.0

Hat man nun der Beschriftung des Bricklets entsprechend die Stromquelle und den Verbraucher angeschlossen, so kann man auf dem entsprechendem Reiter sofort mit der Messung beginnen.

Erste Messung
Einfache Graphen im Brick Viewer

Über die Funktion “Data Logger” im Setup-Reiter kann bereits jetzt mit einer dauerhaften Aufzeichnung von Daten in eine CSV-Datei begonnen werden. Allerdings ist eine USB Verbindung für eine Messung am Fenster (mit der Solarzelle) nicht praktikabel.

Eine Möglichkeit wäre eine der vielen Bastelplatinen mit USB und WLAN zu verwenden oder man greift zur WIFI Master Extension 2.0. Diese ersetzt die USB-Verbindung und den lokalen Brick Daemon durch ein WLAN Modul.

Aufbau des Stapels

Die Bricks und Master Extensions werden über die mitbestellten Befestigungskits verschraubt, nachdem die Module korrekt ausgerichtet worden (man beachte die weiß markierten Ecken!).

Master Brick und WIFI Master Extension 2.0
Stapel aus Master Brick und WIFI Master Extension 2.0

Auch die WIFI Master Extension wird direkt im Brick Viewer erkannt:

WIFI Konfiguration
Konfiguration der WIFI Master Extension 2.0 im Brick Viewer

Nach der Konfiguration als WLAN-Client (General und Mode) muss noch das richtige WLAN ausgewählt werden. Anschließend kann über “Show Status” geprüft werden, ob die WLAN Einrichtung erfolgreich war und welche IP der Stapel bekommen hat. Die kann man dann zur Kommunikation zwischen Brick Viewer und dem Stapel verwenden.

Nutzung der Python API

Das Modul installiert man einfach mit pip:

pip install --user tinkerforge

Folgendes Skript öffnet zunächst eine IPConnection zu dem aufgebauten Stapel über die WIFI Master Extension. Anschließend wird auf das angeschlossene Bricklet zugegriffen und sekündlich die Werte für Spannung, Stromstärke und Leistung ausgegeben.

HOST = "192.168.178.203"
PORT = 4223
UID = "FKC"

from tinkerforge.ip_connection \
    import IPConnection
from tinkerforge.bricklet_voltage_current_v2 \
    import BrickletVoltageCurrentV2
from time import sleep

if __name__ == "__main__":
    ipcon = IPConnection() 
    ipcon.connect(HOST, PORT) 

    vc = BrickletVoltageCurrentV2(UID, ipcon) 

    while True:
        voltage = vc.get_voltage()/1000.
        current = vc.get_current()/1000.
        power = vc.get_power()/1000.

        print(str(voltage) + " V " + \
              str(current) + " A " + \
              str(power) + " W")
        sleep(1)

Weitere Dokumentation zur API findet sich auf der Webseite von Tinkerforge.

Fazit

Mit den Bricks und Bricklets von TinkerForge erhält man ein einfach zu verwendendes Modulsystem. Die Verarbeitung der Module wirkt qualitativ hochwertig. Dies und die einfache Handhabung durch die unterstützende Software rechtfertig in meinen Augen den leicht höheren Preis. Auch die Auswahl der bereits jetzt existierenden Module lädt zu weiteren Experimenten ein.

Sun Type 6 Keyboard (ohne USB) an modernen PCs (mit USB)

In meinem Keller befand sich noch eine Sun Type 6 Tastatur in der Variante mini-DIN Anschluss. Später hat Sun die Type 6 noch mit USB angeboten, aber so eine habe ich leider nicht.

Was kann man heute mit so einer Tastatur anfangen?

Direkt nicht viel, aber die SPARC Keyboard Specification Version 1 sagt, daß diese Tastaturen ein serielles Protokoll mit negativer Logik mit 1200 Baud sprechen. Ein Test mit einem Arduino ergab, dass die SoftwareSerial-Bibliothek dies unterstützt. Entsprechend kann man mit der Tastaturelektronik sprechen. Richtung PC hilft einem eine serielle Schnittstelle nicht viel, da PCs zunächst einen AT Anschluss, später dann PS/2 und schlussendlich USB für Tastaturen nutzen.

USB ist der aktuelle Standard für den Anschluss von Tastaturen an PCs. Also benutzen wir einen Arduino, der nativer USB Client und platzsparend  ist. Der Vorschlag: ein ATmega32u4 basierter Arduino Micro (oder ein kleinerer Klon).

Die Verkabelung ist einfach:

  • GND der Tastatur (Pin ganz recht) wird mit einen GND Anschluss des Arduinos verbunden
  • VCC der Tastatur (2. Pin von rechts) an den VCC des Arduinos anschließen (5V sind ok)
  • den RX Pin der Tastatur (4. von rechts) an den SoftwareSerial TX Pin (im Code ist dies Pin 15)
  • den TX Pin der Tastatur (5. von rechts) an den SoftwareSerial RX Pin (im Code ist dies Pin 14)

Für einfache Aufgaben reicht die Keyboard und Maus Bibliothek von Arduino. Allerdings nimmt diese intern bereits ein Mapping auf ASCII vor (“Note: Not every possible ASCII character, particularly the non-printing ones, can be sent with the Keyboard library.”). Dies bereitet dann prompt Probleme beim Umsetzen der kompletten Tastatur mit einem Arduino. Ebenso lässt sich die Kommunikation des Hosts mit der Tastatur (Schalten der LEDs) nicht abbilden. Dies wird durch Nico Hood’s HID Projekt (Version von Commit 3c5000c4b606b85054150a201f0c6229a9148068) ermöglicht.

Den Code des Sketches findet sich im GitHub Repository: sun-type6-to-USB

Nach dem Flashen des Sketches in den Arduino ist es möglich einen Text wie diesen auf einer Sun Type 6 an einem modernen PC zu schreiben.

AM2302/DHT22 auf RS232 Adapter

Um der Arietta G25 einen praktischen Nutzen zu verleihen, soll sie als Logger für Temperatur und Feuchtigkeit benutzt werden. Hierzu soll der Sensor AM2302/DHT22 über UART angebunden werden.

Als Adapter habe ich mich für einen minimalistischen ATTINY45 (den hatte ich noch) entschieden.

Das entsprechende Projekt findet man auf GitHub: https://github.com/shing19m/AM2302-ATTINY45-RS232

 

Arietta G25 und das WPA-WLAN

Das Arietta G25 ist ein Embedded Linux Board mit:

  • 400Mhz ARM-9 CPU Atmel AT91SAM9G25
  • 128 oder 256 MByte DDR2 RAM
  • MicroSD Karten Slot für bis zu 64 GB
  • Debug-Port für optionales Debug-Modul
  • 3 USB Ports (1 Port für optionales WLAN reserviert)
  • 20×2 Pin Header im 2,54 mm für
    • I2C
    • USB
    • UART
    • PWM

Die komplette Liste der Ausstattung findet man auf der Herstellerseite.Das WLAN Modul WIFI-2-IA mit RaLink RT5370N kann fest auf die Basisplatine gelötet werden und belegt dann einen der 3 USB-Ports.

Anschließend kann man sich auf der Arietta einloggen (entweder per ssh über USB-LAN oder über serielle Konsole und den Debug-Port). In beiden Fällen ist das voreingestellte Passwort für den root-Nutzer “acmesystems”.

Mit wpa_passphrase SSID PASSWORT kann man sich den notwendigen Wert für die Konfiguration in /etc/network/interfaces berechnen lassen. Als Ergebnis erhält man:

network={
        ssid="SSID-WERT"
        psk=PSK-WERT
}

Daraus ergibt sich für WLAN0 folgendes:

auto wlan0
iface wlan0 inet dhcp 
        wpa-ssid "SSID-WERT"
        wpa-psk PSK-WERT

Dabei sind die Anführungszeichen zu beachten. Mit ifup wlan0 kann die Schnittstelle aktiviert werden und sollte sich dann per DHCP eine IP-Adresse und Default-Route erhalten.

 

Morse-Blinker mit einer LED

Beim Geocachen ist mir jetzt 2-3 mal Rätzel mit Morse-Code untergekommen. Meist in Verbindung mit ein klein wenig Elektronik und LEDs. Die Frage die sich aufgedrängt hat, wieviel Aufwand ist so eine Schaltung denn eigentlich?

Die Antwort: erstaunlich wenig Material ist notwendig um eine LED Morse-Codes blinken zu lassen:

  • 1 LED die direkt an 3V betrieben werden kann und dabei ausrechend hell ist
  • 1 ATtiny 13
  • 3V Knopfzelle (idealerweise mit Halter)
  • 1 Taster (ist optional, dann muss die Batterie nicht immer rein und raus)

Der Schaltplan ist recht einfach:

SingleLedMorser_Schaltplan
Schaltplan

Sobald der  ATtiny mit Strom versorgt wird (über Taster oder Einlegen der Batterie), beginnt die LED zu Blinken und morst ihre Nachricht. Dazu muss natürlich die interne Programmierung passen. Der verwendete ATtiny hat nur 1kB Flash, deshalb lasse ich die Morsezeichen vor dem flashen der Firmware generieren (morse_prepare.c). Die Ausgabe ist dann für SOS folgendes: ….L—L…W

Das spart den Speicher für die Kodierung im ATtiny. Anschließend beginnt die Firmware mit dem Abspielen der Nachricht. Die kurzen Pausen innerhalb der einzelnen Symbole werden dabei vom ATtiny eingefügt. Den Code kann man hier herunterladen.

Ergebnis nach dem Aufbau auf einer Platine:

front
Probeaufbau auf Platine

Viel spass beim Nachbauen!