Raspberry Pi

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

Informationen über den Raspberry Pi finden Sie hier (in Englisch).

Sie benötigen GRAFCET-Studio Version 1.0.3.0 oder neuer!

Anwender des Raspberry Pi's verwenden meist die Python-Programmiersprache, weil diese sehr leicht zu erlernen und leicht anwendbar ist. Aus diesem Grund stellen wir die Grafcet-Engine als Python (V3) Bibliothek zur Verfügung.

Auf dem Raspberry Pi läuft ein Python Skript (V3) und kommuniziert über MQTT mit einem Windows-PC auf dem die Software Grafcet-Studio läuft. Mit Grafcet-Studio können Grafcet-Pläne erstellt und per Knopfdruck in den Raspberry Pi übertragen werden. Die Grafcet-Logik läuft anschließend autark auf dem Raspberry Pi.

Die Kombination aus Raspberry Pi und Grafcet-Studio bietet folgende Möglichkeiten:

  • Erstellung der Grafcet-Logik mit Grafcet-Studio
  • Download der Grafcet-Logik in den Raspberry Pi (dies dauert nur 1 Sekunde)
  • Beobachtung (Debuggen) der Grafcet-Logik
  • Über die Grafcet-Logik können beliebige Sensoren und Aktoren verwendet werden, die über Python ansprechbar sind (= keine Einschränkungen).
  • Der Raspberry Pi kann über das lokale Netzwerk oder über das Internet angesprochen werden (MQTT macht es möglich)

Nachfolgend finden Sie je ein Schaubild über MQTT-Kommunikation zwischen PC und Raspberry Pi (mit und ohne dem Internet).

Hier wird ein öffentlicher MQTT Broker verwendet und die Kommunikation wird über das Internet abgewickelt.

Es geht auch ohne Internet: Im lokalen Netzwerk kann der PC oder der Raspberry Pi einen MQTT-Broker zur Verfügung stellen.

  • GRAFCET-Studio Pro-Edition oder IoT-Edition oder GRAFCET-Studio Demoversion
  • Raspberry Pi (egal welche Variante) mit Python3

Wir empfehlen das Betriebssystem Raspian zu verwenden. Nach der Installation steht Python3 sofort zur Verfügung.

Das Image kann hier geladen werden: https://www.raspberrypi.org/downloads/

Vorgehensweise:

  1. Download des Betriebssystems (siehe https://www.raspberrypi.org/downloads/)
  2. Kopieren Sie das Image auf eine SD-Karte (mind. 16 GB). Für das Schreiben des Images können Sie z.B. den Win32 Diskmanager verwenden
  3. Schieben Sie die SD-Karte in den entsprechenden Einschub auf dem Raspberry Pi und schalten Sie ihn ein. Bildschirm, Maus und Tastatur sollten angeschlossen sein.
  4. Nach dem Booten legen Sie das Land und die Sprache fest. Dann folgt noch die Festlegung des Passwortes und die WLAN-Einstellungen. Nach dem Reboot steht der Desktop zur Verfügung.

Die Grafcet-Engine kommuniziert mit Grafcet-Studio über MQTT. Deshalb muss die Bibliothek "paho-mqtt" installiert werden. Starten Sie das Terminal und geben Sie als Befehl ein:

sudo pip3 install paho-mqtt

Wenn der PC und der Raspberry Pi mit dem Internet verbunden sind, kann ein öffentlicher MQTT-Broker verwendet werden. In diesem Fall müssen die Schritte im nächsten Abschnitt nicht durchgeführt werden.

Damit die Kommunikation ohne Internet funktioniert, installieren Sie auf dem PC oder auf dem Raspberry Pi ein MQTT Broker. Hier können Sie z.B. einen MQTT Broker für den PC kostenlos herunterladen:

MQTT Broker für den PC: https://mosquitto.org/download/

Nach dem Start des MQTT Brokers öffnet sich ein Command-Fenster (Konsole) und anschließend kann darüber im lokalen Netzwerk kommuniziert werden. In Grafcet-Studio müssen Sie in diesem Fall in den Verbindungseinstellungen bei "IP Adresse" die Local-Host Adresse angeben: 127.0.0.1

Laden Sie nachfolgende ZIP Datei herunter:

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

  • grafcet_Raspberry_gpio.py = 1. Beispiel mit Verwendung des GPIO
  • grafcet_pibrella.py = 2. Beispiel mit Verwendung eines E/A Shields
  • GrafcetEngineRuntime.py = Grafcet-Engine als Python Code. Die 2 Beispiele verwenden diese Bibliothek.

Der Versuchsaufbau: 4 LEDs an den Pins 14,15,18,23 (BCM-Nummerierung)

Das Python-Skript grafcet_Raspberry_gpio.py:

In diesem Beispiel werden 4 Ausgänge des R-Pi verwendet.

Nr Erklärung
1 Pin 14, 15,18,23 werden als Ausgänge definiert (BCM-Nummerierung).
2 Eine Instanz der Grafcet-Engine wird erzeugt.
3 Die Kommunikation wird konfiguriert.
4 In der Schleife: Hier werden die ersten 4 digitalen Eingänge zu Testzwecken mit 1-0-1-0 beschrieben. Hardware-Eingänge werden in diesem Beispiel nicht benutzt.
5 In der Schleife: Die Grafcet-Engine wird aufgerufen.
6 In der Schleife: Die ersten 4 dig. Ausgänge werden gelesen und in Q0-Q3 gespeichert.
7 In der Schleife: Die Zustände von Q0-Q3 werden in die Hardwareausgänge geschrieben.

Folgenden Grafcet könnte man verwenden, um einen Test durchzuführen:

Damit die Kommunikation zwischen dem R-Pi und dem PC korrekt stattfinden kann, müssen diese drei Parameter identisch sein:

  1. Adresse des MQTT Brokers
  2. Topic 1
  3. Topic 2

Siehe Bild:

Wie man die MQTT-Parameter in Grafcet-Studio einstellt, können Sie weiter unten nachlesen.

In diesem Beispiel verwenden wir das Pibrella I/O Shield: http://pibrella.com/

Eigenschaften des Shields:

  • 4 Eingänge (DI) mit LED
  • 4 Ausgänge (DO) mit LED
  • 3 LEDs (Grün, Gelb, Rot)
  • 1 einfachen Lautsprecher (buzzer)
  • 1 roter Taster

Über folgenden Befehl kann die notwendige Bibliothek für das Shield installiert werden:

sudo pip3 install pibrella

Über die Grafcet-Logik lassen wir die grüne und gelbe LED blinken und die rote LED und der Lautsprecher kann über den roten Taster eingeschaltet werden. Im nachfolgenden Bild, wird gerade der rote Taster gedrückt:

Im Bild sehen Sie die Grafcet-Logik:

Hier können Sie den Grafcet-Plan im Grafcet-Studio Format downloaden: Test-Pibrella-Shield.zip

Nr Erklärung
1 Grafcet-Logik für LED Grün und Gelb.
2 Grafcet-Logik für LED Rot und Lautsprecher. Diese werden über den roten Taster eingeschaltet.
3 I/O-Panel: Anzeige der Eingänge und Ausgänge und dessen Zustände.
4 Symbol-Tabelle
5 Die Ausgänge beginnen bei Adresse 25.

Hier das dazugehörige Python-Skript grafcet_pibrella.py:

Nr Erklärung
1 Die Grafcet-Engine wird importiert.
2 Die Bibliothek für das Pibrella-Shield wird importiert.
3 Eine Instanz der Grafcet-Engine wird erzeugt.
4 Die Kommunikation wird eingerichtet (die Parameter müssen mit den Parameter in Grafcet-Studio übereinstimmen)
5 In der Schleife: der Zustand des Tasters wird in den Grafcet-Eingang "I0" geschrieben (Adresse 0.0).
6 In der Schleife: Die Grafcet-Ausgänge werden gelesen.
7 In der Schleife: Die Grafcet-Ausgänge werden in das Shield geschrieben.

Damit über die Grafcet-Logik die Hardware des Raspberry Pi angesprochen werden kann, müssen die Grafcet-Eingänge geschrieben und die Grafcet-Ausgänge ausgelesen werden.

Erklärung: In Grafcet-Studio werden Symbole für Eingänge und Symbole für Ausgänge definiert. Mit diesen Symbolen arbeitet die Grafcet-Logik.

Es muss jetzt eine Verbindung hergestellt werden, zwischen der Hardware des Raspberry Pi und diesen Symbolen, damit die Grafcet-Logik die Hardware des Raspberry Pi verwenden kann.

Dafür werden Lese und Schreibfunktionen bereitgestellt. (Die read_bit- und die write_bit Funktionen wurde in den Beispiel-Python-Skripten bereits verwendet.)

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

Zusammenfassung: Folgende drei Dinge müssen in einer Schleife ausgeführt werden: die Hardware-Eingangszustände müssen in die Grafcet-Eingänge geschrieben werden, der Grafcet-Zyklus 'GrafcetCyclic' muss aufgerufen werden und die Ausgangszustände der Grafcet-Ausgänge müssen in die Hardware Ausgänge geschrieben werden. In ähnlicher Weise arbeitet auch eine speicherprogrammierbare Steuerung (SPS).

Legen Sie in Grafcet-Studio ein MQTT Device an:

Schritt Erklärung
1 Das Fenster 'Grafcet-Engine' zur Ansicht bringen und den Plus-Button drücken. Sollte der Simulator noch verbunden sein, dann drücken Sie vorher den Trennen-Button.
2 Es erscheint der Dialog 'Gerät hinzufügen'. Wählen Sie aus der Liste aus: 'Grafcet-Engine MQTT'
3 Geben Sie eine kurze Beschreibung ein. Dies wird später als Auswahl in der Liste zur Verfügung stehen.
4 Drücken Sie den Button 'Ok'
5 Geben Sie die Verbindungsparameter ein: Adresse des Mqtt-Brokers, Topic1 und Topic2. Die zwei Topics sind beliebig, aber mind. 3 Zeichen lang. Über diese Topics wird das Gerät identifiziert. Diese Topics müssen mit den Topics im Python-Code übereinstimmen. Sonst kommt keine Verbindung zu Stande.
6 Drücken Sie den Button 'Ok'
7 Wählen Sie das soeben erstellte Device aus
8 Drücken Sie den Verbinden-Button. Das Python-Skript sollte bereits gestartet sein.

Im Python-Skript müssen die Verbindungseinstellungen identisch sein. Siehe Punkt 5. Sonst kann keine Kommunikation stattfinden. Hier nochmals das entsprechende Bild:

  • Der Raspberry Pi kann über "Grafcet" programmiert werden.
  • Auch andere Microcontroller Boards, die Python unterstützen, können auf die gleiche Weise programmiert werden
  • Über Grafcet-Studio kann der Zustand des Grafcets beobachtet werden (debuggen)
  • Es kann jede Art von Shields verwendet werden
  • Der R-Pi kann sich im lokalen Netzwerk befinden oder er kann auch über das Internet angesprochen werden.