Raspberry Pi¶
Grafcet DIN EN 60848 auf dem 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).
Allgemeines¶
Info
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.
Wie funktioniert es?¶
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).
MQTT Kommunikation über das Internet¶
Hier wird ein öffentlicher MQTT Broker verwendet und die Kommunikation wird über das Internet abgewickelt.
MQTT Kommunikation im lokalen Netzwerk¶
Es geht auch ohne Internet: Im lokalen Netzwerk kann der PC oder der Raspberry Pi einen MQTT-Broker zur Verfügung stellen.
Systemvoraussetzungen¶
- GRAFCET-Studio Pro-Edition oder IoT-Edition oder GRAFCET-Studio Demoversion
- Raspberry Pi (egal welche Variante) mit Python3
Raspberry Pi vorbereiten¶
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:
- Download des Betriebssystems (siehe https://www.raspberrypi.org/downloads/)
- 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
- 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.
- 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.
MQTT installieren¶
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:
Info
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.
MQTT Broker installieren, wenn die Kommunikation über das lokale Netzwerk abgewickelt werden soll¶
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:
Info
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
Grafcet-Engine im Python-Skript einbinden¶
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.
Beispiel 1: GPIO direkt verwenden¶
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:
- Adresse des MQTT Brokers
- Topic 1
- Topic 2
Siehe Bild:
Wie man die MQTT-Parameter in Grafcet-Studio einstellt, können Sie weiter unten nachlesen.
Beispiel 2: Shield verwenden¶
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:
Info
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:
Info
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. |
Symbole von Grafcet-Studio lesen und schreiben¶
Info
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 |
Info
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).
Grafcet-Studio einrichten, s.d. der Raspberry Pi über "Grafcet" progammiert werden kann¶
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:
Zusammenfassung der Möglichkeiten¶
- 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.