Tutorial - RED Brick¶

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:

• Brick Daemon Installation
• Brick Viewer Installation

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.

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 2.0 mit diesem.

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 2.0 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 2.0 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 2.0

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature_v2 import BrickletTemperatureV2

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    t = BrickletTemperatureV2(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")

    input("Press key to exit\n") # Use raw_input() in Python 2
    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 Bricklet 2.0. Die UID kann im Setup Tab des Brick Viewers oder im Tab des Temperature Bricklet 2.0 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 XYZ to the UID of your Temperature Bricklet 2.0

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature_v2 import BrickletTemperatureV2

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    t = BrickletTemperatureV2(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:

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

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.

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

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

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

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.

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.

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

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.

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:

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.

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-

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

import time
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature_v2 import BrickletTemperatureV2

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    t = BrickletTemperatureV2(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¶

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 2.0 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 -*-

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

from PyQt4 import QtGui, QtCore
import sys

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature_v2 import BrickletTemperatureV2

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 = BrickletTemperatureV2(UID, 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(BrickletTemperatureV2.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:

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.

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:

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 2.0 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
40

#!/usr/bin/env python
# -*- coding: utf-8 -*-

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

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

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_temperature_v2 import BrickletTemperatureV2

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 = BrickletTemperatureV2(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
35
36

<?php

require_once('Tinkerforge/IPConnection.php');
require_once('Tinkerforge/BrickletTemperatureV2.php');

use Tinkerforge\IPConnection;
use Tinkerforge\BrickletTemperatureV2;

const HOST = 'localhost';
const PORT = 4223;
const UID = 'XYZ'; // Change XYZ to the UID of your Temperature Bricklet 2.0

$ipcon = new IPConnection(); // Create IP connection
$t = new BrickletTemperatureV2(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.

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: