Auslesen von Prozessdaten aus einer SIMATIC S7-1200 / S7-1500 mit OPC UA und Python (OPC UA Secure)
Mit steigender Nachfrage an IoT und Industrie 4.0 Applikationen seitens der Endanwender, wird auch die Anforderung an die Interoperabilität von Steuerungen, Peripherie und SPS unterschiedlicher Hersteller immer größer. Während bei Steuerungen früherer Generationen die Auswahl an Schnittstellen zum Zugriff auf die Prozessdaten meist auf herstellergebundene Protokolle (Feldbus-Protokolle) beschränkt waren, hat man heute als Softwareentwickler wesentlich mehr Möglichkeiten.
Neben dem Zugriff auf die Prozessdaten mittels in den Steuerungen integrierten Webserver, besteht zudem auch die Option neuere "IoT Protokolle" zu nutzen, darunter z.B. MQTT oder OPC UA.
In diesem Artikel werden wir auf einer SIMATIC S7-1200 bzw. S7-1500 den OPC UA Server aktivieren, konfigurieren und mit einem Python Skript auf den freigegebenen Speicherbereich zugreifen:
- OPC UA Server im TIA Projekt aktiveren
- Zugriffe für Clients konfigurieren und Datenübertragung absichern (mit X.509-Zertifikaten)
- Mit einem Python Client den internen Speicher der SIMATIC Steuerung lesen und schreiben (Bibliothek: FreeOpcUa/python-opcua)
OPC UA steht als Akronym für den Namen und die aktuelle Spezifikation des Protokolls bzw. der Schnittstelle: Open Platform Communications Unified Architecture. Sie unterscheidet sich damit als neueste Generation aller vorherigen OPC Spezifikationen erheblich von seinen Vorgängern.
Die in diesem Beitrag gezeigten Schritte können sowohl für eine SIMATIC S7-1200 als auch für eine SIMATIC S7-1500 angewandt werden. Bei der Konfiguration gibt es zwischen den beiden Steuerungen kleinere Unterschiede, die ich aber entsprechend kennzeichne. Als Hardware-Basis für diesen Blogbeitrag dient unser S7-1200 / S7-1500 PLC Trainer, das TIA Portal hat Version 16 Update 4 - Professional.
Die S7-1200 unterstützt den OPC UA Server erst seit Firmware Version 4.4 - wie ein Firmware Update für die S7-1200 durchgeführt wird, sehr ihr hier: OPC UA Server auf der SIMATIC S7-1200 aktivieren
OPC UA Server auf der SIMATIC S7 im TIA Portal aktivieren
OPC UA setzt auf dem TCP/IP Protokoll Stack auf und kann auf einer SIMATIC S7-1200 oder S7-1500 Steuerung recht komfortabel über das TIA Portal aktiviert werden.
Es wird eine Lizenz benötigt, diese wird im Projekt jedoch lediglich als "vorhanden" gekennzeichnet. Es gibt keinen Lizenz Schlüssel oder eine Lizenz Datei, die auf der Steuerung hinterlegt werden muss. Für den Einsatz in produktiven Umgebungen muss jedoch zwingend ein Lizenz-Zertifikat von Siemens erworben werden!
Der OPC UA Server wird in den PLC Einstellungen aktiviert und konfiguriert, die gesamte Konfiguration ist projektspezifisch. Die Konfiguration des OPC UA Servers verlangt einige Schritte, darunter:
- Sicherheitseinstellungen für OPC UA konfigurieren: Der OPC UA Server auf der SIMATIC S7 erlaubt den Clients sich per Benutzername/Passwort zu authentifizieren, zusätzlich kann die Verbindung zwischen den Kommunikationspartnern verschlüsselt, bzw. signiert werden. Zur komfortableren Konfiguration verwenden wir in diesem Beitrag den projektweiten Zertifikatsmanager und die projektweite Benutzerverwaltung (nicht PLC/SPS spezifisch). Dies ist gerade bei der Verwendung von mehreren Steuerungen in einem TIA-Projekt von Vorteil.
- Client Zugriffe konfigurieren: Damit die Clients Zugriff auf den OPC UA Server erhalten können, müssen Benutzername und Passwort zur Authentifizierung festgelegt werden. Hinzu kommt die Erstellung von Server und Client Zertifikaten zur gegenseitigen kryptografischen Authentifizierung beider Kommunikationspartner - welche Algorithmen zur Verschlüsselung und Authentifizierung genutzt werden sollen, lässt sich ebenfalls auswählen.
- Datenblöcke zum Zugriff über OPC UA freigeben: Die SIMATIC S7-1200 und die S7-1500 unterscheiden sich, wie die internen Variablen über OPC UA freigegeben werden. Während bei der S7-1500 alle Variablen von bsp. Datenblöcken zur Verfügung stehen (wenn diese entsprechend als in OPC UA verfügbar gekennzeichnet sind), müssen bei der S7-1200 zusätzlich sog. OPC UA server interfaces angelegt und konfiguriert werden.
Konnektivität und Anbindung
Die Anbindung von Client und Server benötigt keine spezielle Hardware, da OPC UA auf dem TCP/IP Standard aufbaut und sowohl die S7-1200 als auch die S7-1500 über einen Ethernet Port verfügen. Die IP Adressen können wahlweise über DHCP vergeben werden, eine manuelle Adresskonfiguration an den beiden Kommunikationspartnern ist aber ebenfalls möglich.
Grundkonfiguration
Als aller erstes wird der OPC UA Server in den PLC Eigenschaften aktiviert und die projektweite erweiterte Benutzerverwaltung ausgewählt. Dies erlaubt die Anpassung von Benutzereinstellungen auf Projektebene und nicht nur auf SPS-Ebene (ist vor allem dann nützlich, wenn man mehr als eine SPS im TIA Projekt programmiert).
Die Verwendung der projektweiten Benutzerverwaltung führt dazu, dass TIA von uns verlangt, das gesamte Projekt zu "schützen". Dies erfolgt, indem ein oder mehrere Projektbenutzer angelegt (siehe folgenden Screenshot) und entsprechende Passwörter vergeben werden. Dies ist in unserem Kontext durchaus sinnvoll, da wir im späteren Verlauf des Projekts auch x.509 Zertifikate und entsprechende private Schlüssel erstellen werden. Diese sollten immer besonders gut geschützt werden, da sie in einer Kommunikation als Vertrauensnachweis dienen.
Zertifikate generieren und Sicherheitseinstellungen festlegen
Im nächsten Schritt werden für den Client und für den Server jeweils ein Schlüsselpaar erstellt (Private Key und Zertifikat). Diese werden zur gegenseitigen Authentifizierung verwendet. Beim Verbindungsaufbau präsentiert der Server sein Zertifikat, erkennt der Client dieses wieder und hat es als "vertrauensvoll" gekennzeichnet, dann akzeptiert der Client den Server als Kommunikationspartner. Gleiches gilt in umgekehrter Richtung, der Client präsentiert sein Zertifikat dem Server, erkennt dieser das Zertifikat wieder und hat es als "vertrauensvoll" markiert, dann lässt er die Verbindung zu.
In unserem Beispielprojekt kann z.B. die gegenseitige Vertrauensstellung dadurch herbeigeführt werden, dass sowohl das Client- als auch das Serverzertifikat von der gleichen CA signiert wurden. Der jeweils private Schlüssel der beiden Kommunikationspartner wird für die Signierung der einzelnen Datenpakete verwendet (Sign), die Kommunikationspartner verwenden jeweils das Zertifikat des Anderen zur Verschlüsselung (Sign&Encrypt). Beide Zertifikate - Client und Server - können im TIA Portal in unserem Projekt erstellt werden, eine CA zum Signieren der beiden Zertifikate ist im Projekt standardmäßig vorhanden.
Genau wie für die Benutzerverwaltung, aktivieren wir auch die projektweite Zertifikatsverwaltung über den Zertifikats-Manager. Achtung: Diese Einstellung wird nicht unter OPC UA vorgenommen, sondern unter "Protection & Security". So können wir alle im Projekt vorhandenen Zertifikate global verwalten und haben einen besseren Überblick über die vorhandenen CA's, Zertifikate und deren Eigenschaften.
Serverzertifikat erstellen
Nun sind die Grundeinstellungen erfolgt und wir können mit der Erstellung des Serverzertifikats fortfahren (genauer: privater und öffentlicher Schlüssel für den Server, öffentlicher Schlüssel = Zertifikat). Dazu bleiben wir unter Protection & Security und fügen ein neues Zertifikat bei Device Certificates hinzu. Da wir bisher noch kein Zertifikat erstellt haben, klicken wir auf Add New und ein Dialogfenster öffnet sich. Hier können wir alle wichtigen Einstellungen anpassen, darunter:
- CA Name: Name der "Certificate Authority", vorausgewählt, für die Server- und Clientzertifikate sollte die gleiche CA ausgewählt werden
- Common Name of Subject: Name der Anwendung des Servers, hier kann der Vorschlag des Dialogfensters übernommen oder angepasst werden
- Signature: Algorithmus der später "im Betrieb" zur Signierung der übertragenen Datenpakete genutzt werden soll
- Valid from / Valid until: Gültigkeitsdauer des Zertifikates, bevorzugt einen Zeitraum wählen, der in etwa der zukünftigen Nutzungsdauer der Maschine entspricht, da ein Zugang zur Maschine bzw. Steuerung nach der Inbetriebnahme u.U. sehr schwierig werden kann (TIA schlägt eine Gültigkeit von ca. 15 Jahren vor).
- Usage: der Verwendungszweck des Zertifikats, für Server: OPC UA server auswählen, für Client: OPC UA client auswählen. Alternativ kann auch ein Zertifikat erstellt werden, das sowohl für den Client als auch für den Server genutzt werden kann (OPC UA client & server)
- Subject Alternative Name (SAN): dies ist eine Erweiterung der x.509 Spezifikation für PKI und erlaubt weitere Attribute für das Zertifikat zu definieren, z.B. eine URI oder eine IP Adresse
- URI: unser später verwendeter Client verlangt einen bestimmten Namen der als URI Attribut gekennzeichnet ist:
urn:freeopcua:client - IP: IP Adresse des Servers bzw. IP Adresse des Clients (je nach dem, für welchen Kommunikationspartner das zu erstellende Zertifikat gedacht ist)
Diese Prozedur wird 2x ausgeführt, sodass am Ende jeweils ein eigenes Zertifikat für den Server und ein eigenes Zertifikat für den Client vorhanden ist. Diese beiden Zertifikate sind dann in den Device Certificates und im globalen Certificate Manager sichtbar.
Im Certificate Manager können alle Zertifikate projektweit verwaltet werden. Droht ein Zertifikat abzulaufen, oder wurde versehentlich ein Zertifikat mit falschen Eigenschaften erstellt, dann können diese Zertifikate nicht nur gelöscht sondern auch "erneuert" werden.
OPC UA Server konfigurieren und Zertifikat zuordnen
An dieser Stelle sind nun alle benötigten Zertifikate vorhanden, sodass nun die Konfiguration der Sicherheitseinstellungen für den OPC UA Server erfolgen kann. Als aller erstes wird das Serverzertifikat ausgewählt und im darauffolgenden Schritt die Security Policy angepasst. Hier können verschiedene Verschlüsselungen und Signaturalgorithmen ausgewählt werden, die der Server anbieten soll.
Es empfiehlt sich hierbei nicht No Security auszuwählen, da der Server dann unverschlüsselte und nicht-signierte Verbindungen erlauben würde. Dies betrifft zum Einen die Verschlüsselung, da dann alle Daten im Klartext übertragen würden und zum Anderen würde der Server jeden Client akzeptieren. Somit fände keine Authentifizierung statt und jeder erlangt Zugriff auf die Daten in der Steuerung! Es gibt natürlich Fälle, bei denen man auf die Verschlüsselung und Signatur verzichten kann, in diesem Beitrag wollen wir jedoch die Konfigurationsschritte für die bestmögliche Sicherheit erläutern.
OPC UA Clientzugriff konfigurieren
Im nächsten Schritt werden die "Trusted Clients" angegeben. Das sind diejenigen Clients, die sich mit dem oben erstellen Clientzertifikat beim Server authentifizieren. Dies erfolgt, indem das erstellte Clientzertifikat angegeben wird. Präsentiert ein Client beim Verbindungsaufbau ein dort nicht angegebenes Zertifikat, wird er abgelehnt - die Verbindung kommt nicht zustande. Soll das vom Client präsentierte Zertifikat nicht geprüft, sondern immer akzeptiert werden, kann Automatically accept client certificates during runtime ausgewählt werden. Die übertragenen Datenpakete können dann dennoch verschlüsselt und signiert werden, da beide Kommunikationspartner eine sichere Verbindung aufbauen. Der Server hat jedoch keinen fundierten Vertrauensnachweis über den Client, hier kann letztlich auch jeder Client eine Verbindung zum Server aufbauen.
In Ergänzung dazu ist es dann empfehlenswert, zusätzlich die Authentifizierung über Benutzername und Passwort zu aktivieren. Der Client muss dann beim Verbindungsaufbau zusätzlich zu seinem Zertifikat auch über einen korrekten Benutzernamen und Passwort verfügen. Dabei ist darauf zu achten, dass keine anonymen Benutzer zugelassen werden und die entsprechenden Nutzer auch angelegt und aktiviert sind. Benutzername und Passwort können frei vergeben werden.
Sobald die Steuerung über Ethernet an ein (Firmen-) Netzwerk angebunden ist, sollte unbedingt darauf geachtet werden, dass alle möglichen Maßnahmen ergriffen wurden, die Steuerung vor unbefugtem Zugriff zu schützen. In diesem Beitrag konzentrieren wir uns jedoch nur auf die Sicherheitseinstellungen die OPC UA betreffen!
Datenblöcke für OPC UA freigeben
Nicht alle Variablen bzw. Datenblöcke sind über den OPC UA Server erreichbar. Auf welche Variablen zugegriffen werden kann, und ob darauf Lese- und Schreibberechtigung besteht, kann für jede Variable in einem Datenblock individuell festgelegt werden. Außerdem muss der gesamte Datenblock für OPC UA freigegeben werden. Dies kann in den Eigenschaften für jeden Datenblock einzeln festgelegt werden.
OPC UA Client vorbereiten
Die Konfiguration des OPC UA Servers ist an dieser Stelle nun abgeschlossen und sollte auf der Steuerung zur Verfügung stehen, sobald die Konfiguration / das Programm auf die Steuerung übertragen wurde. Damit sich unser Client jetzt auch tatsächlich mit dem Server verbinden kann, müssen wir ihn mit den notwendigen Zertifikaten und Zugangsdaten ausstatten. Dazu exportieren wir als erstes das Clientzertifikat, das wir oben mit dem TIA Portal erstellt haben.
Clientzertifikat exportieren
In der globalen Zertifikatsverwaltung im TIA Portal wird nun das für den Client erstellte Zertifikat ausgewählt und exportiert. Dabei wird der Export zwei Mal durchgeführt. Einmal, um das Zertifikat in einer einzelnen Datei zu exportieren (im DER Format) und beim zweiten Mal, um den gesamten Schlüssel (privaten Schlüssel + Zertifikat) in einer einzigen Datei zu exportieren. Dies geschieht jeweils mit Rechtsklick auf den Eintrag und dann auf "Export...".
Beim Export des Zertifikates ist nur darauf zu achten, dass es im DER Format exportiert wird. Beim Export des gesamten Schlüssels muss nun aktiv ausgewählt werden, dass auch der private Schlüssel in der selben Datei abgespeichert wird. Hinzu kommt außerdem die gesamte Zertifikatskette (Certificate Chain), diese soll ebenfalls in der Datei exportiert werden. Immer, wenn der private Schlüssel exportiert wird, hat man die Möglichkeit diesen mit einem extra Passwort zu sichern. Wir verzichten in diesem Fall darauf, da unser Client möglicherweise autark läuft und kein menschlicher Benutzer zur Eingabe des Passworts (für den privaten Schlüssel) vorhanden ist.
OPC UA Client vorbereiten (Python Bibliothek installieren)
Als nächstes wollen wir alle benötigten Bibliotheken auf dem Client-Computer installieren. Für diesen Beitrag spielt es keine Rolle, ob der Client Computer Windows, Linux oder macOS verwendet, die vorgesehene Bibliothek läuft plattformunabhängig. Die einzige Voraussetzung ist, dass auf dem Computer Python in der Version > 3.7 installiert ist und über das Terminal/CLI aufgerufen werden kann. Ich habe mir für das Projekt eine virtuelle Python Umgebung auf Basis von venv erstellt, es geht aber auch ohne. Dort hinein installieren wir jetzt alle Bibliotheken, die wir für den Zugriff auf die SIMATIC S7 mit OPC UA brauchen. Es werden folgende Pakete über pip installiert: pip3 install opcua opcua-client PyQt5 crypto cryptography pyqtgraph numpy
Für die OPC UA Bibliothek opcua gibt es einen kompletten Client (mit GUI geschrieben in Qt5), den wir ebenfalls nutzen wollen. Daher müssen wir auch opcua-client und PyQt5 installieren. Die Cryptopakete benötigen wir, damit unser Client die Verschlüsselung und Authentifizierung unterstützt, pyqtgraph und numpy benötigt unser Client, um die Prozessdaten des OPC UA Servers zu plotten.
Sobald alle o.g. Pakete installiert sind, können wir testen, ob die Installation erfolgreich verlaufen ist. Im Terminal (in unserem venv) starten wir über den Befehl opcua-client den eben installieren Client.
Im nächsten Schritt verbinden wir uns mit der SIMATIC S7, indem wir im Client die URL angeben. Das Format für den Connection String folgt dabei folgender Regel (identisch zu anderen Protokollen): opc.tcp://<username>opc.tcp://OPCUser01:11223344Ki@192.168.1.232:4840
Bevor wir uns nun endlich verbinden können, müssen wir dem Client noch die Konfiguration des Secure Channels mitgeben. Dies geschieht über "Connect Options" und dann über "Query Server Capability". Der Client erfragt die möglichen Konfigurationen für die verschlüsselte Verbindung beim Server und setzt die Eigenschaften entsprechend. Jetzt wählen wir nur noch das Client Zertifikat und den Client Private Key aus. Im Anschluss daran können wir uns direkt verbinden und die Prozessdaten sowohl abfragen als auch schreiben.
Eigenen OPC UA Client in Python skripten
Um nun auf die Prozessdaten aus der SIMATIC S7 in eigenen Anwendungen und Apps zuzugreifen, wollen wir als letzten Schritt in diesem Beitrag mit unserem eigenen Skript einen OPC UA Client für unsere Steuerung schreiben. Dazu müssen wir als erstes die Adressen der für uns relevanten Variablen herausfinden. Das sind sog. OPC UA Node IDs, diese können wir bequem über den o.g. Democlient browsen und notieren (bzw. über Rechtsklick Kontextmenü Copy NodeId in den Zwischenspeicher legen). Diese nutzen wir später in unserem Skript, um auf die Variablen zuzugreifen. Solange das Programm in der SIMATIC S7 nicht verändert wird, bleiben die OPC UA Adressen der Variablen erhalten. Durch hinzufügen/bearbeiten weiterer Variablen in der Steuerung kann sich das Mapping jedoch ändern und muss im Client angepasst werden.
Im Demoskript sehen wir in der Methode get_data_nodes die entsprechenden Node IDs unserer Variablen, darüber lesen und schreiben wir die Variablen in der Steuerung.
Demo zum Ansteuern und Auslesen der Daten unseres PLC Trainers
from opcua import Client, ua
from datetime import datetime
#*********************************************#
# Decorators #
#*********************************************#
def check_connection(plc_client_request):
"""
Check connection to PLC before performing request
"""
def call(self, *args, **kwargs):
if self.is_connected:
return plc_client_request(self, *args, **kwargs)
else:
print("Not connected! Connect, then perform your request!")
return call
#*********************************************#
# OPC UA PLC Client #
#*********************************************#
class OPCUAPLCClient:
def __init__(self):
"""
Init OPC UA client
"""
## client connection settings
self.connection_string = None
self.security_string = None
self.opcuaclient = None
self.is_connected = False
def server_settings(self, serverip, serverport, ccert, ckey, username, password):
self.connection_string = ("opc.tcp://" + username + ":" + password + "@" + serverip + ":" + str(serverport) + "/")
self.security_string = ("Basic256Sha256,SignAndEncrypt," + ccert + "," + ckey)
def connect(self):
try:
self.opcuaclient = Client(self.connection_string, timeout=3000)
self.opcuaclient.set_security_string(self.security_string)
self.opcuaclient.connect()
self.is_connected = True
## get data notes
self.get_data_nodes()
return True
except:
print("Error connecting... Aborting...")
self.is_connected = False
return False
@check_connection
def disconnect(self):
self.opcuaclient.disconnect()
self.is_connected = False
@check_connection
def get_data_nodes(self):
"""
Read predefined opc ua nodes from PLC
"""
## read given nodes from PLC --> readable
self.fan1_status_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan1_status"')
self.fan2_status_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan2_status"')
self.fan1_error_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan1_error"')
self.fan2_error_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan2_error"')
self.fan1_rpm_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan1_rpm"')
self.fan2_rpm_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan2_rpm"')
self.temp1_degc_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."temp1_deg_c"')
self.temp2_degc_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."temp2_deg_c"')
self.virt_blue_led_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."virt_blue_led"')
self.virt_green_led_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."virt_green_led"')
self.current_mA_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."current_mA"')
## read given nodes from PLC --> readable and writable
self.fan1_power_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan1_power"')
self.fan2_power_node = self.opcuaclient.get_node('ns=3;s="HMI_Interchange"."fan2_power"')
@check_connection
def refresh_data_values(self):
"""
Read data values from opc ua nodes from PLC
"""
## get nominal values from nodes
self.fan1_status = bool(self.fan1_status_node.get_value())
self.fan2_status = bool(self.fan2_status_node.get_value())
self.fan1_error = bool(self.fan1_error_node.get_value())
self.fan2_error = bool(self.fan2_error_node.get_value())
self.fan1_rpm = int(self.fan1_rpm_node.get_value())
self.fan2_rpm = int(self.fan2_rpm_node.get_value())
self.temp1_degc = round(float(self.temp1_degc_node.get_value()), 1)
self.temp2_degc = round(float(self.temp2_degc_node.get_value()), 1)
self.virt_blue_led = bool(self.virt_blue_led_node.get_value())
self.virt_green_led = bool(self.virt_green_led_node.get_value())
self.current_mA = int(self.current_mA_node.get_value())
@check_connection
def set_fan1(self, state):
"""
Set fan 1 (On, Off)
Parameters:
state: Booleane
True: Switch on fan 1
False: Switch off fan 1
"""
dv = ua.DataValue(ua.Variant(state, ua.VariantType.Boolean))
dv.ClientTimestamp = None #datetime.now()
dv.SourceTimestamp = None #datetime.now()
self.fan1_power_node.set_data_value(dv)
@check_connection
def set_fan2(self, state):
"""
Set fan 2 (On, Off)
Parameters:
state: Booleane
True: Switch on fan 2
False: Switch off fan 2
"""
dv = ua.DataValue(ua.Variant(state, ua.VariantType.Boolean))
dv.ClientTimestamp = None #datetime.now()
dv.SourceTimestamp = None #datetime.now()
self.fan2_power_node.set_data_value(dv)
if __name__ == "__main__":
plclcient = OPCUAPLCClient()
plclcient.server_settings("192.168.1.232", "4840", "./PLC-Main-Siincos-Demo-Client-2.der", "./PLC-Main-Siincos-Demo-Client-2.pem", "OPCUser01", "11223344Ki")
plclcient.connect()
plclcient.set_fan1(True)
plclcient.set_fan2(True)
plclcient.refresh_data_values()
print("Fan 1 status: " + str(plclcient.fan1_status))
print("Fan 2 status: " + str(plclcient.fan2_status))
print("Fan 1 error: " + str(plclcient.fan1_error))
print("Fan 2 error: " + str(plclcient.fan2_error))
print("Fan 1 speed (rpm): " + str(plclcient.fan1_rpm))
print("Fan 2 speed (rpm): " + str(plclcient.fan2_rpm))
print("Temperature 1 (°C): " + str(plclcient.temp1_degc))
print("Temperature 2 (°C): " + str(plclcient.temp2_degc))
print("Virtual blue LED: " + str(plclcient.virt_blue_led))
print("Virtual green LED: " + str(plclcient.virt_green_led))
print("Current Consumption (mA): " + str(plclcient.current_mA))
plclcient.set_fan1(False)
plclcient.set_fan2(False)
plclcient.disconnect()
Bei dem gezeigten Quellcode handelt es sich um ein Beispiel zum Auslesen und Schreiben der gezeigten Prozessdaten. Da OPC UA beispielsweise das Publish/Subscribe Konzept unterstützt, empfiehlt es sich vor dem Beginn eines größeren Projekts die gesamte Dokumentation der Python OPC UA Bibliothek zu lesen.
Da die hier verwendeten Python Bibliotheken permanent weiterentwickelt werden, sind die hier gezeigten Skripte und Befehle ggf. nicht mehr aktuell und nicht kompatibel zu zukünftigen/aktuellen Versionen.
Unterschied zur SIMATIC S7-1200
Während in der SIMATIC S7-1500 alle Variablen der Datenblöcke gebrowst werden können, für die der OPC UA Zugriff aktiviert wurde, muss in der S7-1200 vorher erst ein sog. OPC UA server interface erstellt werden. Hier werden die Datenblöcke lediglich nochmals individuell aufgeführt, damit sie über OPC UA gelesen und geschrieben werden können.
