Revolution Pi

Lesen Sie hier, wie man die GRAFCET-Engine auf dem Revolution Pi verwendet und anschließend einen Grafcet-Plan überträgt.

Sie benötigen GRAFCET-Studio Version 1.0.3.0 oder neuer! Verfügbar ab: 07.12.2018

Die Firma Kunbus bietet auf Basis einer industrietauglichen Raspberry Pi Hardware ein modulares Steuerungssystem auf Hutschiene an: Revolution Pi (RevPi). Mehr Informationen über die Hardware finden Sie hier.

Mit Grafcet-Studio kann dieses System durch einen Grafcet-Plan (DIN EN 60848) visuell programmiert werden. Möglich macht dies eine Portierung der Grafcet-Engine in die Skriptsprache Python (V3). Die Grafcet-Engine ist das Runtime-Modul, welches die Grafcet-Logik abarbeitet. Die Runtime ist für das Device kostenlos. Mit einer Grafcet-Studio Vollversion (z.B. 99€ zzgl. MwSt. für die IoT-Edition) lassen sich so beliebig viele Raspberry-Pi‘s visuell programmieren. Damit Grafcet-Studio den RevPi programmieren kann, wird auf dem Gerät ein Python-Skript gestartet.

Das Python Skript hat folgende Aufgaben:

  • Kommunikation zwischen Grafcet-Studio (Editor) und der Grafcet-Engine (Runtime) über MQTT
  • Datenaustausch der Eingänge und Ausgänge mit der Grafcet-Engine
  • Zyklischer Aufruf der Grafcet-Engine, um die Grafcet-Logik abzuarbeiten.

Das nachfolgende Bild zeigt Grafcet-Studio im Beobachten-Modus (Debuggen). Hier findet ein ständiger Datenaustausch zwischen RevPi und Grafcet-Studio statt. Auf der Zeichenfläche sieht man auf der linken Seite eine kleine Schrittkette, die ein Lauflicht im Sekundentakt erzeugt. Rechts daneben wird eine Variable inkrementiert, bei steigender Flanke von I0.

RevPi und Grafcet-Studio

Punkt Erklärung
1 Zeichenfläche von Grafcet-Studio.
2 Symboltabelle. (Symbolnamen können geändert werden.)
3 Ansicht der Grafcet-Engine (Runtime). Hier sieht man z.B. die aktuelle Zykluszeit, die in diesem Fall 1ms beträgt.
4 IO-Panel mit aktuellen Zuständen aller Variablen inkl. der Ein- und Ausgänge

  • Visuelle Programmierung und Debuggen des RevPi.
  • Einfaches und reduziertes Userinterface (UI) in Grafcet-Studio (= einfache Bedienung).
  • Verwendung der Norm Grafcet DIN EN 60848: Diese Norm ist Bestandteil des Lehrplans von vielen technische Berufen.
  • Die Dokumentation in Grafcet ist gleichzeitig das Steuerungsprogramm
  • Simulator integriert: Sie können ohne Hardware die Grafcet-Logik vorab simulieren, bevor Sie den Grafcet in das Device übertragen
  • Hoch komfortable Entwicklung: Das Programm kann innerhalb 1 Sekunde in das Device übertragen werden und läuft dort autark.
  • Moderne Entwicklungsumgebung: Vektor-orientierte UI auf Basis von Microsoft Windows Presentation Foundation (WPF).
  • Ziel-Plattformübergreifend: Das erstellte Steuerungsprogramm kann ohne Änderungen in ein anderes System (S7-Steuerung von Siemens oder Arduino Due) übertragen werden.
  • Durch das Python Skript können alle verfügbaren Baugruppen in der Grafcet-Logik verwendet werden.
  • Es besteht die Möglichkeit, die Grafcet-Logik durch Python-Befehle zu ergänzen. Beispiel: Wenn ein bestimmtes Ereignis im Grafcet auftritt könnte eine Email über Python versandt werden.
  • Es können mehrere Instanzen der Grafcet-Engine im Python-Skript erzeugt werden, die unabhängig voneinander sind. Diese unterschiedlichen Instanzen können bei Bedarf untereinander kommunizieren.
  • Die Grafcet-Runtime (Grafcet-Engine) ist für das Device kostenlos. Nur den Editor (Grafcet-Studio) muss man erwerben (z.B. IoT-Edition für 99€ +MwSt.)
  • Grafcet-Studio kann im Simulatormodus mit einer virtuellen Anlage/Maschine verbunden werden. So kann der Grafcet sehr effizient überprüft werden. Siehe YouTube-Video.

Verbinden Sie die gewünschten Module über den Rückwandbus (PiBridge) und führen Sie eine Hardwarekonfiguration mit PICtory durch. PICtory ist der webbasierte Hardwarekonfigurator des RevPi. Er wird über den Browser gestartet. Alle notwendigen Informationen finden Sie im Dokumentationsbereich auf der Webseite der Firma Kunbus. Damit die Arbeit leichter von der Hand geht, empfehlen wir Ihnen, einen Monitor, Maus und Tastatur an den RevPi anzuschließen.

Damit die Grafcet-Logik die Zustände der Eingangssignale (digital oder analog) kennt, müssen die Eingangszustände in die Grafcet-Engine geschrieben werden. Die Zustände der Ausgänge der Grafcet-Engine müssen in die Ausgangsmodule der Hardware geschrieben werden. Die Grafcet-Engine stellt dazu die notwendigen Lese- und Schreibfunktionen zur Verfügung. Im nachfolgenden Python-Beispiel werden die digitalen Ein- und Ausgänge einer DIO-Baugruppe mit der Grafcet-Engine verbunden.

In der nachfolgenden Tabelle finden Sie die Start-Adressen der einzelnen Operandenbereiche der Grafcet-Engine. In dem nachfolgenden Python-Beispiel werden nur digitale Ein- und Ausgänge verwendet. Die Zustände der digitalen Eingänge müssen ab Adresse 0 (siehe Tabelle) geschrieben werden und die digitalen Ausgänge werden ab Adresse 25 (siehe Tabelle) gelesen.

Operand Symbolbereich in Grafcet-Studio Adresse Ausreichend für …
DI – Digitale Eingänge Sensor 0 200 Eingänge
DO – Digitale Ausgänge Aktor 25 200 Ausgänge
AI – Analoger Eingang Sensor 50 25 analoge Eingänge (bei 2-Byte)
AO – Analoger Ausgang Aktor 100 25 analoge Ausgänge (bei 2-Byte)
Data – Bool Variablen Data 150 200 boolesche Variablen
Data – Analog Variablen Data 175 50 (z.B. 50 Int16-Variablen)

Hinweis: Sollte ein Bereich zu klein sein, kann dieser über die Device-Einstellungen in Grafcet-Studio erweitert werden. In diesem Fall würden sich die Startadressen verschieben.

Damit im Python Programm die Hardware-Eingänge ausgelesen und die Hardware-Ausgänge geschrieben werden können, müssen deren Adressen (Offset) im Prozessabbild des RevPi bekannt sein. Diese Offset-Adressen kann man ermitteln, indem man einen Export der Symbole in PICtory durchführt. Wählen Sie in PICtory den Menüpunkt File->Export. Im Dialog wählen Sie dann Export 02 Offset-Liste und markieren Sie Show only:

Offsetliste, Show only markieren Offset Liste wird angezeigt.

Sie sehen somit die Startadresse der Ein- und Ausgänge und deren Länge in Byte. Diese Informationen werden für das Python Skript benötigt.

Laden Sie nachfolgende ZIP Datei herunter:

In der ZIP Datei finden Sie u.a. diese Dateien:

  • grafcet_RevolutionPi.py.py = Hier wird eine Instanz der Grafcet-Engine erzeugt und in einer Schleife aufgerufen. Eine DIO-Baugruppe wird exemplarisch verwendet.
  • GrafcetEngineRuntime.py = Grafcet-Engine als Python Code. Das Beispiel verwendet diese Bibliothek.

Nachfolgend das Python-Skript grafcet_RevolutionPi.py, welches eine DIO-Baugruppe verwaltet:

Das Beispiel Python Skript RevolutionPi.py

Schritt Erklärung
1 Die Grafcet-Engine (Runtime) wird importiert.
2 Die Offsetadressen der RevPi Hardware (DIO-Baugruppe) werden bekannt gemacht.
3 Die Offsetadressen der DI,DO in der Grafcet-Engine werden bekannt gemacht. (Siehe Symboliktabelle Spalte DB-Adresse in Grafcet-Studio).
4 Eine Instanz der Grafcet-Engine wird erzeugt.
5 Die MQTT Kommunikation wird eingerichtet. Die Angaben müssen mit den Angaben in Grafcet-Studio übereinstimmen. Sonst kann keine Kommunikation stattfinden.
6 mit 'f=open(...)' kann nachfolgend auf das Prozessabbild des RevPi lesend und schreibend zugegriffen werden.
7 Mit einer while-Schleife wird ein SPS-Zyklus erzeugt
8 Alle Eingänge der DIO-Baugruppe lesen und in die Grafcet-Engine-Runtime schreiben
9 Grafcet-Engine-Runtime 1x ausführen
10 Ausgänge der Grafcet-Engine lesen und in die Ausgänge der DIO-Baugruppe schreiben
11 Status-Ausgabe

In diesem Beispiel wird eine DIO-Baugruppe verwendet. Wenn Sie andere Baugruppen verwenden, dann müssen Sie Punkte 8 und 10 im Python Skript anpassen.

Die Grafcet-Eingangssymbole müssen also mit den aktuellen Werten der Hardwareeingänge beschrieben werden und die Zustände der Grafcet-Ausgänge werden in die Hardwareausgänge des R-Pi geschrieben.

Folgende Lesefunktionen für Grafcet-Operanden (Symbole) stehen bereit:

Lesefunktion Erklärung
read_bit(addr, bit) Liefert als Funktionsergebnis true oder false (1 Bit)
read_uint8(addr) Liefert als Funktionsergebnis ein Byte-Wert (8 Bit)
read_uint16(addr) Liefert als Funktionsergebnis ein unsigned 16-Bit Integer Wert
read_uint32(addr) Liefert als Funktionsergebnis ein unsigned 32-Bit Integer Wert
read_int16(addr) Liefert als Funktionsergebnis ein signed 16-Bit Integer Wert
read_int32(addr) Liefert als Funktionsergebnis ein signed 32-Bit Integer Wert
read_float(addr) Liefert als Funktionsergebnis ein float Wert (32 Bit)

Folgende Schreibfunktionen für Grafcet-Operanden (Symbole) stehen bereit:

Schreibfunktion Erklärung
write_bit(addr, bit, bitvalue) Der angegebene value wird an der übergebenen Adresse geschrieben
write_uint8(addr, bytevalue) Der angegebene value wird an der übergebenen Adresse geschrieben
write_uint16(addr, uint16value) Der angegebene value wird an der übergebenen Adresse geschrieben
write_uint32(addr, uint32value) Der angegebene value wird an der übergebenen Adresse geschrieben
write_int16(addr, int16value) Der angegebene value wird an der übergebenen Adresse geschrieben
write_int32(addr, int32value) Der angegebene value wird an der übergebenen Adresse geschrieben
write_float(addr, floatvalue) Der angegebene value wird an der übergebenen Adresse geschrieben

Die Grafcet-Engine verwendet für die Kommunikation mit Grafcet-Studio (auf dem PC) das MQTT Protokoll. Aus diesem Grund, muss ein Mqtt Client auf dem RevPi installiert werden. Dies kann mit folgendem Befehl ausgeführt werden: Geben Sie über das Terminal folgenden Befehl ein:

pip3 install paho-mqtt

Im Python-Skript wird ein öffentlicher Broker verwendet: broker.mqttdashboard.com Somit benötigt der RevPi und der PC einen Internetzugang. Sie können aber auch einen lokalen MQTT Broker auf dem RevPi oder auf dem PC installieren. Diese sind kostenlos im Internet verfügbar. Dann wäre keine Internetverbindung mehr notwendig.

Hier können Sie kostenlos einen MQTT Broker für den PC herunterladen: https://mosquitto.org/download/

Im Python-Skript müssen Sie dann bei InitMqtt im 1. Parameter die IP-Adresse des PCs angeben. Bei Grafcet-Studio geben Sie dann die LocalHost Adresse ein: 127.0.0.1

Nachdem das Python Skript gestartet ist, können Sie nun mit Grafcet-Studio einen Grafcet-Plan erstellen und diesen sehr einfach, sehr schnell und überaus komfortabel in das Device übertragen. Im nächsten Abschnitt lesen Sie, wie man mit Grafcet-Studio den RevPi programmiert und beobachtet.

Bringen Sie das Fenster Grafcet-Engine zur Ansicht und fügen Sie ein Device für den RevPi hinzu:

Schritt Erklärung
1 Den Plus-Button drücken.
2 Als Deviceart Grafcet-Engine MQTT auswählen.
3 Namen vergeben für das neue Device.
4 MQTT Parameter festlegen. Topic1 und Topic2 muss mit dem Python Skript übereinstimmen. Verwenden Sie für Topic1 und Topic2 nicht die gleichen Parameter wie im Bild.
5 OK-Button
6 Das neue Device aus der Liste auswählen.
7 Verbinden-Button drücken

Wenn das Python-Skript gestartet ist und wenn die MQTT Parameter richtig sind, dann sollte eine Verbindung zustande kommen.

Wenn eine Verbindung vorhanden ist, werden die Zähler (siehe Bild) inkrementiert.

In der Symboltabelle können Sie die Symbole (Variablen) nach Ihren Wünschen umbenennen:

Für jedes Symbol können Sie auch den Datentyp (Bool, Int16, Int32, ...) einstellen. Über die Symbole können Sie die Ein- und Ausgänge des RevPi verwenden. Voraussetzung ist natürlich, dass Sie die Ein- und Ausgänge im Python Skript in die Grafcet-Engine geschrieben haben. In der Spalte DB-Adresse (DB address) sehen Sie die Offset-Adresse des Symbols. Diese Offset-Adresse kann nicht manuell eingestellt werden. Sie wird von oben nach unten berechnet.

Jedes Symbol kann auf "Sensor", "Aktor" oder "Data" eingestellt werden. Jeder dieser Bereiche verwendet eine andere Start-Offset-Adresse in der Grafcet-Engine. Eingänge sollten immer auf "Sensor" und Ausgänge sollten immer auf "Aktor" eingestellt werden. Der Bereich "Data" beinhaltet weder Ein- noch Ausgänge. In diesem Bereich sollten Symbole für Zwischenergebnisse oder Ähnliches abgelegt werden. Über das Python-Skript können Sie auf alle Symbole lesend und schreibend zugreifen.

Idee: Sie können z.B. die Uhrzeit (Stunden, Minuten, Sekunden) über das Python Skript einem Eingangs- oder Data-Symbol übergeben. So können Sie im Grafcet die aktuelle Uhrzeit auswerten.

Ein kurzes Tutorial finden Sie hier.

Oder hier kurze Videos, die zeigen, wie man einen Grafcet mit Grafcet-Studio zeichnet.

Wenn die Verbindung zwischen RevPi und Grafcet-Studio steht, kann man über den Button "Schreiben" den Grafcet in das Device übertragen:

Der Button befindet sich im Fenster "Grafcet-Engine".

Nachdem der Grafcet in das Device geschrieben worden ist, kann man über den Button mit der Brille den Debugmodus (Beobachten) einschalten:

So können Sie das Python-Skript nach dem booten des RevPi automatisch und unabhängig von einer Useranmeldung starten:

Öffnen Sie den Editor 'nano':

sudo nano /etc/rc.local

Fügen Sie vor exit0 ein:

python3 /home/pi/Documents/grafcet_RevolutionPi.py &

Der Pfad inkl. Dateiname muss evtl. bei Ihnen angepasst werden, wenn Sie die Datei in einem anderen Ordner gespeichert haben.
Achtung: Das &-Zeichen am Ende der Zeile ist wichtig! Sonst bootet der RevPi nicht vollständig

Tipp: Um zu erkennen, ob das Python-Skript läuft, können Sie z.B. die A1-Led an der CPU-Baugruppe im Python Skript einschalten:

RevPiLed=bytearray(1)
RevPiLed[0]=1
f.seek(6)
f.write(bytes(RevPiLed))

Dieser Code kann im Skript grafcet_RevolutionPi.py verwendet werden.

Siehe auch Webseite Fa. Kunbus.

Den Autostart sollten Sie nur einrichten, wenn Ihr RevPi im Dauerbetrieb eingesetzt werden soll. Wenn ein Skript im Hintergrund abläuft führt dies zu Problemen, wenn Sie ein zweites Skript starten, welches auch in die Ausgänge schreibt. Mit dem Terminal Befehl top können Sie alle Prozesse anzeigen. Mit kill können Sie einen Prozess entfernen.

  • Wenn Sie einen öffentlichen MQTT Broker verwenden, dann achten Sie darauf, dass die Parameter Topic1, Topic2 der Funktion MqttInit (siehe Python-Skript) selbst gewählt sind. Verwenden Sie nicht die gleichen Strings wie im Beispiel. Sonst kann es passieren, dass eine andere Person die gleichen Parameter verwendet. Beim Verbindungsaufbau würde dann eine Fehlermeldung erscheinen.
  • Tipp: Der MQTT Broker könnte auch ein 3. Device (z.B. PC oder Linux Rechner) in Ihrem lokalen Netzwerk sein.

Bei Verbindungsproblemen bitte folgendes prüfen:

  • Wenn ein lokaler MQTT Broker verwendet wird: Ist der RevPi über die IP-Adresse erreichbar? PC und RevPi müssen im gleichen Subnetz sein. Beispiel: RevPi-IP: 192.168.2.118, PC-IP= 192.168.2.101
  • Ist das Python-Skript gestartet?
  • MQTT: Ist Topic1 und Topic2 im Python-Skript und in Grafcet-Studio identisch (2. und 3. Parameter der InitMqtt-Funktion)?
  • MQTT: Verwenden beide Kommunikationspartner den gleichen MQTT broker (das ist der 1. Parameter der InitMqtt-Funktion)

Alle Bilder des RevPi stammen von der Webseite https://www.kunbus.de