In unserem alten Revolutionsumbau, wurde die Steuerung für den Handbetrieb über Bedienflaschen realisiert. Nun wollen wir ein Panel PC mit Visualisierung!
Unser neuer Schaltschrank!
Die Taster für die grundlegende Steuerung der Anlagenfunktionen sind nun in der Schaltschranktür. Diese sind direkt an die „DI“ und „DO“ Devices vom RevPi angeklemmt.
Benutzer steuert über Panel PC
Außerdem hat der neue Revolutionsumbau nun einen Panel PC bekommen! Dieser trägt bei der miprotek GmbH den Produktnamen „m4 Panel“ und läuft mit einem Windows 8 Embedded System.
Bei dem Visualisierungsprogramm handelt es sich um eine pyQt5 Anwendung, welche auch unser RevPiModIO Modul verwendet. Dieses kann in einer internen Testversion auch über das Netzwerk mit dem Revolution Pi kommunizieren! Als Gegenstück auf dem RevPi dient unser RevPiPyLoad System.
Wie funktioniert das?
Hinweis: Quellcodes basieren auf Version 2 von RevPiModIO
Die eigentliche Steuerung der Anlage läuft natürlich als Python SPS Programm auf dem Revolution Pi! Unabhängig vom Panel PC kontrolliert er die Anlage. Das Visualisierungsprogramm instanziiert das RevPiModIO Modul im „monitoring“ Modus und lesenden Zugriff auf alle echten Devices zu bekommen.
self.rpi = revpimodio2.RevPiNetIOSelected(
"172.29.255.200",
["di01", "di02", "do01", "do02", "aio01"],
monitoring=True,
autorefresh=True
)
Der Austausch zwischen Panel PC und der Steuerung läuft über das virtuelle Device, welches wir vor einiger Zeit in unsere piCtory Konfiguration einfügten.
Aus Steuerungssicht befinden sich dort Inputs für die maximal zulässige Magazinfüllung und einige Bytes mit dem Namen „pbitN_M“, außerdem Outputs für den aktuellen Magazinfüllstand und Bytes mit dem Namen „meldungN_M“.
Dieses virtuelle Device „virt01“ wird von RevPiModIO auf dem Panel nun als RevPiModIODriver instanziiert. Damit kann das Panel in die Inputs der Steuerung schreiben und die Outputs der Steuerung nur lesen!
self.virt = revpimodio2.RevPiNetIODriver(
"172.29.255.200",
"virt01",
autorefresh=True,
syncoutputs=True
)
Und so realisieren wir nun den Handbetrieb
Da die Taster für den Handbetrieb nun Buttons in der Visualisierung sind, müssen wir ein Byte des virtuellen Devices in Bits aufbrechen. Das macht uns mit RevPiModIO die spätere Arbeit mit diesen IOs sehr leicht.
Auf der Steuerungsseite legen wir uns die IOs mit den selben Namen an, die damals die Taster hatten. Damit müssen wir nichts weiter ändern:
# Panel Eingänge Byte 1
self.rpi.io.pbit8_15.replace_io("t_m1", "?", bit=0)
# (...)
self.rpi.io.pbit8_15.replace_io("t_motorstart", "?", bit=5)
# (...)
# Und für die IOs registrieren wir Events
self.rpi.io.t_m1.reg_event(self.evt_zylinder, edge=revpimodio2.RISING)
# (...)
self.rpi.io.t_motorstart.reg_event(self.evt_bandlauf)
Auf der Visualisierungsseite legen wir uns die selben Bits mit dem selben Namen an, um diese später mit den Buttons einfach auf True oder False zu setzen:
# Panel Ausgänge Byte 1
self.virt.io.pbit8_15.replace_io("t_m1", "?", bit=0)
# (...)
self.virt.io.pbit8_15.replace_io("t_motorstart", "?", bit=5)
# (...)
# Buttons für Zylindersteuerung
self.ui.btnHandM1.pressed.connect(lambda: self.evt_btn_chvalue("t_m1", True))
self.ui.btnHandM1.released.connect(lambda: self.evt_btn_chvalue("t_m1", False))
# (...)
# Buttons für Motorsteuerung
self.ui.btnHandRechts.toggled.connect(lambda value: self.evt_btn_chvalue("t_rechts", value))
self.ui.btnHandSchnell.toggled.connect(lambda value: self.evt_btn_chvalue("t_schnell", value))
self.ui.btnHandStart.pressed.connect(lambda: self.evt_btn_chvalue("t_motorstart", True))
self.ui.btnHandStart.released.connect(lambda: self.evt_btn_chvalue("t_motorstart", False))
Durch das Eventhandling können wir natürlich auch auf das Hochzählen des Magazins reagieren und die Füllstände der Magazine in der Visualisierung aktualisieren.
Zusätzlich gibt es „Sicherheitsfunktionen“ die einen bestimmten Zustand der IOs auf dem virtuellen Device herstellen, sollte die Netzwerkverbindung mal abreißen.
Weitere Infos und Quellcodes stellen wir bald zur Verfügung!