Tutorial - RED Brick

Das folgende Tutorial zeigt wie man mit dem RED Brick zusammen mit anderen Bricks und Bricklets Software entwickelt. Ein vollständiges Schritt-für-Schritt Tutorial, das zeigt wie man Bricks, Bricklets und Extensions nutzt steht mit dem Erste Schritte Tutorial ebenfalls zur Verfügung.

Der RED Brick kann als Gehirn des Tinkerforge Baukastensystems bezeichnet werden. Ein Programm, welches Bricks und Bricklets steuert, kann auf diesen hochgeladen und ausgeführt werden.

In diesem Tutorial werden wir die verschiedenen Fähigkeiten des RED Bricks vorstellen. Um das Beispiel einfach zu halten nutzen wir einen kleinen Aufbau, bestehend aus einem RED Brick, einem Master Brick und einem Temperature Bricklet. Später stecken wir eine Ethernet Extension hinzu um Zugriff auf das Internet zu bekommen.

Als erstes werden wir ein einfaches Programm an einem PC entwickeln und testen und dieses anschließend auf den RED Brick hochladen und ausführen. Das Programm wird einfach nur die aktuelle Temperatur ausgeben. Danach werden wir das Programm erweitern, so dass auch die grafischen Nutzerschnittstelle (GUI) genutzt wird und zeigen auf einen HDMI Monitor die aktuelle Uhrzeit an. Im nächsten Schritt werden wir eine Web Schnittstelle anbieten, mit der wir auf die gemessene Temperatur zugreifen können. Die Fähigkeiten dieses Beispiel sind sicherlich nicht sonderlich sinnvoll, zeigen aber die wichtigsten Möglichkeiten der Nutzung eines RED Bricks.

Für die eigene Anwendung werden sicher andere Bricks, Bricklets oder eine andere Programmiersprache verwendet, als die in diesem Beispiel. Die vorgestellten Konzepte und Abläufe sind aber für alle im wesentlichen die gleichen.

Notwendige Software installieren

Als erstes müssen der: Brick Daemon und der Brick Viewer auf einem PC oder Mac installiert werden. Dazu sind die dokumentierten Schritte zu befolgen:

Teste den RED Brick

Nachdem die notwendige Software installiert wurde kann der RED Brick getestet werden. Dazu stecken wir eine Micro-SD-Karte mit RED Brick Software Image in den Micro-SD-Karten Slot des RED Bricks. Dieser befindet sich auf der Unterseite des Bricks (eine Micro-SD-Karte mit vorinstalliertem Image kann in unserem Shop gefunden werden). Anschließend wird der RED Brick per Mini-USB Kabel mit dem Rechner verbunden.

RED Brick mit Mini-USB-Kabel

Nun starten wir die Brick Viewer Software und klicken auf Connect. Ein Tab mit RED Brick bezeichnet sollte nun auftauchen. Klicke auf diesen. Der Tab zeigt Informationen zum Status des RED Bricks. Eine volle Beschreibung zum RED Brick Tab des Brick Viewers ist hier dokumentiert.

Der RED Brick ist nun bereit!

Bricks und Bricklets hinzufügen

Nun wissen wir das der RED Brick wie erwartet funktioniert. Bevor andere Bricks/Bricklets hinzugesteckt werden, sollte der RED Brick heruntergefahren werden. Dazu klickt man im RED Brick Tab des Brick Viewers in der oberen rechten Ecke auf System, wählt Shutdown und wartet bis alle LEDs aus sind. Anschließend stecken wir den Master Brick auf den RED Brick und verbinden das Temperature Bricklet mit diesem.

RED Brick mit Master Brick und Temperature Bricklet

Danach wird der RED Brick wieder mit dem Computer verbunden, der Brick Viewer geöffnet und auf Connect geklickt. Es sollten Tabs für den RED Brick, Master Brick und das Temperature Bricklet angezeigt werden. Klicke durch die Tabs um die angeschlossene Hardware zu testen.

Beispielprogramm ausführen

Bevor das erste eigene Programm geschrieben wird, sollte ein Blick in die API Dokumentation der genutzten Bricks/Bricklets geworfen werden, um einen Eindruck von deren unterstützen Funktionen zu bekommen. Jede Dokumentationsseite beginnt mit Beispielen. Wir empfehlen diese Beispielprogramm zuerst auszuführen. Wir nehmen das "Simple" Beispiel des Temperature Bricklet API Dokumentation und führen es aus.

Download (example_simple.py)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/usr/bin/env python
# -*- coding: utf-8 -*-

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your Temperature Bricklet

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature import BrickletTemperature

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    t = BrickletTemperature(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Get current temperature
    temperature = t.get_temperature()
    print("Temperature: " + str(temperature/100.0) + " °C")

    raw_input("Press key to exit\n") # Use input() in Python 3
    ipcon.disconnect()

Dazu laden wir das example_simple.py Python Programm herunter und ersetzen die UID in der Zeile UID = "XYZ" mit der UID des Temperature Bricklets. Die UID kann im Setup Tab des Brick Viewers oder im Tab des Temperature Bricklets ermittelt werden.

Führe dieses Programm auf dem PC aus. Wenn alles wie erwartet funktioniert sollte die aktuelle Temperatur in der Kommandozeile ausgegeben werden.

Führe das Programm auf dem RED Brick aus

Nun haben wir das Beispiel ausgeführt und wissen nun das es korrekt funktioniert. Das Beispiel wartet auf eine Benutzereingabe mittels:

raw_input('Press key to exit\n')

Diese Zeile dient zum verhindern, dass sich die Kommandozeile sofort beendet. Auf dem RED Brick wird es keine Benutzereingabe geben. Wir wollen, dass das Programm nur einmal die gemessene Temperatur ausgibt und sich anschließend beendet. Dazu entfernen wir diese Zeile.

Download (example_simple_red.py)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/usr/bin/env python
# -*- coding: utf-8 -*-  

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change to your UID

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature import Temperature

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    t = Temperature(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Get current temperature (unit is °C/100)
    temperature = t.get_temperature()/100.0

    print('Temperature: ' + str(temperature) + ' °C')

    ipcon.disconnect()

Nun können wir das Programm auf dem RED Brick ausführen. Die allgemeine Beschreibung wie Programme hochgeladen werden findet sich in der RED Brick Brick Viewer Beschreibung. Nachfolgend werden wir nur die notwendigen Schritte beschreiben:

Screenshot des RED Brick Programm Uploads Schritt 1

Als erstes öffnen wir im Brick Viewer den RED Brick Tab und wählen den Untertab Program aus.

Screenshot des RED Brick Programm Uploads Schritt 2

Mit dem New Button öffnen wir den New Program Wizard. Wir geben "Temperature Logger" als Name für das Programm ein und wählen Python als Sprache. Anschließend klicken wir auf Next.

Screenshot des RED Brick Programm Uploads Schritt 3

Wir klicken auf Add Files und wählen das example_simple_red.py Programm. Klicke auf Next.

Screenshot des RED Brick Programm Uploads Schritt 4

Wir werden Python Version 2.7.3, Script File als Start Mode und unsere Datei als Script File nutzen. Diese Einstellungen sind alle voreingestellt. Wir klicken wieder auf Next.

Screenshot des RED Brick Programm Uploads Schritt 5

Unser einfaches Beispielprogramm benötigt keine Argumente oder Umgebungsvariablen, so dass wir einfach wieder auf Next klicken.

Screenshot des RED Brick Programm Uploads Schritt 6

Wir nutzen Pipe als Standard Input und loggen alle Ausgaben (Standard Output und Standard Error) in einer fortlaufenden Logdatei. Es sind also wieder keine Änderungen notwendig. Wir klicken wieder auf Next.

Screenshot des RED Brick Programm Uploads Schritt 7

Es gibt viele Optionen für das Scheduling des Programms. Eine der einfachsten Optionen ist es das Programm in einem gegebenen Intervall auszuführen. Dazu wählen wir Interval mit einer Zeit von 10 Minuten (600 Sekunden). Somit wird unser Programm alle 10 Minuten ausgeführt und die Temperatur alle 10 Minuten einmal ausgegeben.

Screenshot des RED Brick Programm Uploads Schritt 8

Die Übersichtsseite zeigt die gewählten Einstellungen. Klicke auf Next.

Screenshot des RED Brick Programm Uploads Schritt 9

Klicke auf den Start Upload Button um die Datei hochzuladen. Klicke anschließend auf Finish. Nun können wir der Logdatei des Programms, die gemessenen Temperaturen entnehmen.

Screenshot Log Files

In der Browser-Ansicht können Log Dateien ausgewählt und mittels des Download Buttons auf den PC heruntergeladen werden. Der View Button ermöglicht es die Log Dateien direkt einzusehen. Soll eine Log Datei auf dem RED Brick gelöscht werden, so ist dies mit dem Delete Button möglich.

Zugriff auf das Internet bekommen

Um Zugriff auf das Internet zu bekommen kann entweder ein USB WLAN oder Ethernet Stick oder eine Ethernet Extension mit dem RED Brick verbunden werden. In diesem Beispiel werden wir eine Ethernet Extension nutzen:

RED Brick mit Master Brick, Temperature Bricklet und Ethernet Extension

Fahre den RED Brick herunter und entferne die Stromversorgung bevor du die Ethernet Extension auf den Stapel steckst.

Nachdem wieder die Stromversorgung angeschlossen wurde und der erweiterte Stapel fertig gebootet hat, klicke auf Settings. Der Network Abschnitt sollte geöffnet sein und als Interface tfX: Wired (X ist eine Zahl) ausgewählt sein. Wähle zwischen DHCP oder einer statischen IP und klicke Connect. Nach ein paar Sekunden sollte der Current Network Status auf Connected wechseln.

Screenshot of RED Brick network settings.

Nachdem wir nun Zugriff auf das Internet haben können wir Internet-of-Things oder ähnliche Anwendungen einfach implementieren. Ein weiterer Vorteil des Internetzugriffs ist, dass das RED Brick automatisch die Systemzeit mittels NTP aktualisieren wird.

Somit können wir jeder Messung die entsprechende Uhrzeit zuordnen.

Download (example_time_red.py)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/usr/bin/env python
# -*- coding: utf-8 -*-  

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change to your UID

import time

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature import Temperature

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    t = Temperature(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Get current temperature (unit is °C/100)
    temperature = t.get_temperature()/100.0
    print('Temperature of ' + str(temperature) + ' °C on ' + time.ctime())

    ipcon.disconnect()

Dieses Programm kann genauso wie das vorherige hochgeladen werden.

Entwicklung von GUI Programmen mit dem RED Brick

Bemerkung

Programme mit grafischer Nutzerschnittstelle (GUI) können nur auf dem Full Image ausgeführt werden.

Eine weitere Art von Programmen, die auf dem RED Brick ausgeführt werden können, sind Programme mit grafischer Nutzerschnittstelle (GUI), die über die HDMI Schnittstelle des Bricks angezeigt werden. In diesem Beispiel fügen wir eine PyQt GUI unserem einfachen Temperature Bricklet Programm hinzu.

Download (example_gui_red.py)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from PyQt4 import QtGui, QtCore
import sys

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature import Temperature

HOST = "localhost"
PORT = 4223
UID_TEMPERATURE = "XYZ" # Enter Temperature Bricklet UID here

class Window(QtGui.QWidget):
    qtcb_temperature = QtCore.pyqtSignal(int)

    def __init__(self):
        QtGui.QWidget.__init__(self)
        self.button = QtGui.QPushButton('Refresh', self)
        self.button.clicked.connect(self.handle_button)
        self.label = QtGui.QLabel('TBD')
        layout = QtGui.QVBoxLayout(self)
        layout.addWidget(self.button)
        layout.addWidget(self.label)

        self.ipcon = IPConnection()
        self.temperature = Temperature(UID_TEMPERATURE, self.ipcon)
        self.ipcon.connect(HOST, PORT)

        # We send the callback through the Qt signal/slot
        # system to make sure that we can change the label
        self.qtcb_temperature.connect(self.cb_temperature)
        self.temperature.register_callback(Temperature.CALLBACK_TEMPERATURE, self.qtcb_temperature.emit)

        # Refresh every second
        self.temperature.set_temperature_callback_period(1000)
        
        # Refresh once on startup
        self.handle_button()

    # Refresh by hand
    def handle_button(self):
        self.cb_temperature(self.temperature.get_temperature())

    def cb_temperature(self, temperature):
        # Show temperature
        self.label.setText(u"Temperature: {0} °C".format(temperature/100.0))

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    window = Window()
    window.show()              # In window
    # window.showFullScreen()  # Fullscreen
    sys.exit(app.exec_())

Die GUI besitzt ein Label, dass jede Sekunde mit der aktuellen Temperatur aktualisiert wird. Zusätzlich gibt es einen Refresh Button, der die Aktualisierung erzwingt.

Das Programm kann mit kleinen Änderungen genauso hochgeladen werden wie das Programm zuvor. Dabei sind zwei Änderungen vorzunehmen:

Screenshot der RED Brick GUI Umgebung

In Schritt 4 muss die Umgebungsvariable DISPLAY mit dem Wert :0 gesetzt werden. Damit wird das Programm auf dem RED Brick Desktop angezeigt. Diese Variable muss gesetzt werden, da sonst das Programm nicht startet.

Screenshot des RED Brick GUI Schedulers

Für den Scheduler möchte man Always auswählen und Continue After Error abwählen. Diese Konfiguration startet das Programm und dessen GUI automatisch neu wenn es beendet wurde.

Auf dem RED Brick Desktop sieht dann die kleine GUI Anwendung wie folgt aus:

Screenshot des RED Brick Temperature GUI.

Entwicklung eines eigenen RED Brick Web Interfaces

Wenn der RED Brick über eine Netzwerkschnittstelle verfügt (WLAN Stick oder Ethernet Extension), dann kann er auch dazu genutzt werden um eine dynamische Webseite anzuzeigen. Aktuell werden HTML/JavaScript, PHP und Python dafür unterstützt.

Die Beschreibung der RED Brick Web Interface Dokumentation gibt mehr Informationen dazu. Im wesentlichen kann eine als Startpunkt eines Pfades dienende index.html, index.php oder index.py genutzt werden.

Unser einfaches Temperature Bricklet Programm mit Web Interface sieht wie folgt aus (Python und PHP):

Download (index.py)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#!/usr/bin/env python
# -*- coding: utf-8 -*-  

from flask import Flask       # Use Flask framework
application = Flask(__name__) # Function "application" is used by Apache/wsgi
app = application             # Use shortcut for routing

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change to your UID

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature import Temperature

PAGE = u"""
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<html>
 <head>
  <title>Temperature</title>
 </head>
 <body>
  <p>Temperature: {0} °C<p>
 </body>
</html>
"""

@app.route('/')
def index():
    ipcon = IPConnection() # Create IP connection
    t = Temperature(UID, ipcon) # Create device object

    ipcon.connect(HOST, PORT) # Connect to brickd
    # Don't use device before ipcon is connected

    # Get current temperature (unit is °C/100)
    temperature = t.get_temperature()/100.0

    ipcon.disconnect()
    return PAGE.format(temperature)

Download (index.php)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php
require_once('Tinkerforge/IPConnection.php');
require_once('Tinkerforge/BrickletTemperature.php');

use Tinkerforge\IPConnection;
use Tinkerforge\BrickletTemperature;

const HOST = 'localhost';
const PORT = 4223;
const UID = 'XYZ'; // Change to your UID

$ipcon = new IPConnection(); // Create IP connection
$t = new BrickletTemperature(UID, $ipcon); // Create device object

$ipcon->connect(HOST, PORT); // Connect to brickd
// Don't use device before ipcon is connected

// Get current temperature (unit is °C/100)
$temperature = $t->getTemperature() / 100.0;

$ipcon->disconnect();

header('content-type: text/html; charset=utf-8');
?>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<html>
 <head>
  <title>Temperature</title>
 </head>
 <body>
  <p>Temperature: <?php echo $temperature; ?> °C<p>
 </body>
</html>

Wenn das Programm ein Web Interface nutzt, müssen die auszuführende Datei, deren Argumente, Umgebungsvariablen und Arbeitsverzeichnis nicht angegeben werden. Schritte 4-6 werden ausgelassen wenn Web Interface in Schritt 3 ausgewählt wird.

Screenshot des RED Brick Web Interface: Ausführungskonfiguration

Um das eigene Web Interface aufzurufen, müssen nur die IP Adresse oder der Hostname des RED Bricks im Browser aufgerufen werden und der Bin Button des eigenen Programms geklickt werden. Dies öffnet den Pfad zum eigenen Programm für den die Indexdatei automatisch aufgerufen wird:

Screenshot des RED Brick Web Interface