• Node-ID
• Node-Klasse
• Browse-Name
• Anzeigename
• Beschreibung

Node-IDs

• Numeric
  Ein numeric Identifier bezeichnet einfach eine vorzeichenlose Zahl. Bei der Serealisierung dieses Identifiers wird die Bezeichnung i verwendet.
• String
  Bei einem String handelt es sich um eine lesbare Zeichenfolge. Bei der Serealisierung wird der Identifier mit s gekennzeichnet.
• Bytestring (Opaque)
  Ein Opaque Identifier ist ein Identifier, der nach einem Namespace-Spezifischen Schema erstellt worden ist. Dieser wird zur Serealisierung in einen Base64-String umgewandelt. Dies ist wichtig, da im Bytestring auch Zeichen vorkommen können, die nicht darstellbar sind. Der verwendete Buchstabe zur Kenzeichnung ist b.
• GUID
  Eine GUID ist eine 16-Byte hexadezimal Zahl, die im folgenden Format abgebildet ist: uint32-uint16-uint16-uint8[2]-uint8[6] Ein Beispiel für eine GUID ist 9EAA3455-92B1-C9C6-89C8-2CA23723B2EB.

Node-Klassen

• Object
  Ein Object, zu Deutsch Objekt, wird verwendet, um Systeme oder Subsysteme zu erzeugen. Dabei ist es egal, ob es sich um physische oder virtuelle Systeme handelt, die abgebildet werden. Folgende Attribute kommen zu den Grundattributen hinzu:
  • Event-Notifier
    Damit wird signalisiert, welche Events überwacht werden können.
• Variable
  Eine Variable wird verwendet, um einem Objekt einen Inhalt zu geben. Da eine Variable einen gewissen Wert repräsentiert, besitzt eine Variable sehr viel mehr Attribute:
  • DataType
    Dies ist die Node-ID des Datentypes.
  • ValueRank
    Der ValueRank gibt an, ob die Daten ein einzelner Wert, oder eine Liste an Werten ist. Genauer gesagt, können die Werte als Skalar, eindimensionales Array oder mehrdimensionales Array vorliegen.
  • ArrayDimensions
    Dieses Element gibt an, wie groß die einzelnen Dimensionen sind. Dieses Attribut ist nur relevant, wenn die Daten nicht als Skalar vorliegen.
  • Value
    Dies ist der Wert, der vom Node verwaltet wird. Wie dieses Element zu interpretieren ist, hängt von den Attributen DataType, ValueRank und ArrayDimensions ab.
  • Historizing
    Dieses Element gibt an, ob auf dem Server eine Historie der Daten gespeichert wird.
  • AccessLevel
    Dieses Element gibt an, welche Berechtigungen im Allgemeinen gewährt werden. Mögliche Berechtigungen sind Lesen und Schreiben des aktuellen Wertes und Lesen/Schreiben der Historie.
  • UserAccessLevel
    Dieses Element gibt an, welche Berechtigungen der aktuelle Benutzer besitzt.
  • MinimumSamplingInterval
    Dieses Element gibt an, wie schnell der Server Änderungen eines Wertes erfassen kann. Dies ist vor allem dann interessant, wenn der Server die Information erst von einem Subsystem anfordern muss.
• Methods
  Methods, zu Deutsch Methoden, sind Funktionen die auf dem Server ausgeführt werden können.
  • Executable
    Dieses Attribut gibt an, ob die Funktion aktuell ausführbar ist.
  • UserExecutable
    Dieses Attribut gibt an, ob die Funktion vom aktuellen Benutzer ausführbar ist.
• ReferenceType
  ReferenceTypes, zu Deutsch Referenztypen, beschreiben die Relation zwischen Elementen auf dem Server. Eine genaue Erklärung zu Referenzen findet sich im nächsten Abschnitt.
  • isAbstract
    Dieses Attribut gibt an, ob es sich bei dem Typ um ein Organisationselement der Hierarchie handelt, oder ob er tatsächlich verwendet werden kann. Sollte der Typ abstrakt sein, so kann er nicht erzeugt werden, aber sehr wohl verwendet werden um bestehende Elemente eines Subtyps ansprechen zu können. Auf Referenzen wird im späteren Abschnitt noch näher eingegangen.
  • symmetric
    Dieses Attribut gibt an, ob die Referenz symmetrisch ist. Wenn sie symmetrisch ist, dann besitzt die Referenz in die umgekehrte Richtung die selbe Bedeutung. Ein Beispiel für eine nicht symmetrische Referenz ist die Eltern-Kind Beziehung; so ist zB.: A der Elternteil von B und B ist das Kind von A. Ein Beispiel für eine symmetrische Referenz ist die Geschwister-Beziehung.
  • inverseName
    Wenn die Referenz nicht symmetrisch ist, gibt dieses Element den Namen der umgekehrten Referenz an. Beim vorhergehenden Beispiel war der Elternteil von der reguläre Name der Referenz und ist das Kind von der Name der umgekehrten Referenz.
• DataType
  Ein DataType, zu Deutsch Datentyp, definiert wie die Daten zu interpretieren sind. Die von der OPC UA Foundation vorgegebenen Datentypen sind in Namespace 0 zu finden und stellen grundlegende Datentypen dar. Neben den grundlegenden Datentypen ist es auch möglich eigene Datentypen zu definieren. Es ist jedoch sinnvoller, Variablen-Typen und Objekt-Typen zu definieren.
  • isAbstract
    Dieses Attribut gibt, genau wie bei den Referenzen, an, ob es sich um ein organisatorisches Element handelt oder nicht.
• VariableType
  Ein VariableType, zu Deutsch Typdefinition einer Variable, wird verwendet um den Datenelementen eine Bedeutung zu geben. Dies ist vor allem interessant, wenn man sich ein Beispiel ansieht. Beispiel: Ein Node vom BaseVariableType, einem generischen Variablen-Type, ist auf dem Server verfügbar. Der Node repräsentiert eine Temperatur. Jetzt ist unbekannt, ob es sich bei der Temperatur um Celsius, Kelvin oder Fahrenheit handelt. Wenn jedoch ein Celsius-Typ definiert und verwendet wird, ist sofort klar, wie die Daten zu interpretieren sind. Alternativ kann auch ein Temperatur-Datentyp definiert werden, bei dem in der Beschreibung die Interpretation deklariert wird. Dies hat jedoch den Nachteil, dass nicht sofort aus dem Variablentyp klar ist, wie die Daten zu interpretieren sind.
  • DataType
    Dies ist die Node-ID des Datentypes.
  • ValueRank
    Der ValueRank gibt an, ob die Daten ein einzelner Wert, oder eine Liste an Werten ist. Genauer gesagt, können die Werte als Skalar, eindimensionales Array oder mehrdimensionales Array vorliegen.
  • ArrayDimensions
    Dieses Element gibt an, wie groß die einzelnen Dimensionen sind. Dieses Attribut ist nur relevant, wenn die Daten nicht als Skalar vorliegen.
  • Value
    Dies ist der Wert, der vom Node verwaltet wird. Wie dieses Element zu interpretieren ist, hängt von den Attributen DataType, ValueRank und ArrayDimensions ab.
  • isAbstract
    Dieses Attribut gibt, genau wie bei den Referenzen, an, ob es sich um ein organisatorisches Element handelt oder nicht.
• ObjectType
  Ein ObjectType, zu Deutsch Typdefinition eines Objektes, wird verwendet um sicherzustellen, dass ein Objekt bei der Erstellung gewisse Attribute besitzt. In objektorientierten Programmiersprachen würde man dieses Konstrukt auch Klasse nennen.
  • isAbstract
    Dieses Attribut gibt, genau wie bei den Referenzen, an, ob es sich um ein organisatorisches Element handelt oder nicht.
• View
  Eine View, zu Deutsch Ansicht, bezeichnet eine Liste an Nodes, die für eine bestimmte Aufgabe interessant sein können. So kann zum Beispiel eine Ansicht definiert werden, die für die Wartung interessant ist, und eine andere Ansicht, die für den regulären Gebrauch interessant ist. Damit muss nicht der Gesamte Adressraum des Servers abgesucht werden.
  • ContainsNoLoop
    Dieses Attribut gibt an, ob die dargestellten Nodes eine zirkuläre Hierarchie aufbauen, wenn man den Referenzen folgt.
  • EventNotifier
    Dieses Attribut gibt an, ob man über diese Ansicht Events generieren lassen kann (zB bei Datenänderung) und ob die Event-Historie lesbar und änderbar ist.

• Quelle
• Ziel
• Referenztyp

• Organizes
  Diese Referenz wird verwendet, wenn Objekte oder Variablen in einem Ordner zusammengefasst werden. Ein Ordner ist ein Objekt, das nur zum Zusammenfassen von Informationspunkten dient. Ordner werden zum Beispiel im Standard-Informations-Modell verwendet, um alle Objekte, alle Typdefinitionen und alle Views zusammenzufassen.
• HasProperty
  Diese Referenz wird verwendet, um Eigenschaften von Objekten und Variablen abzubilden. Properties selbst können keine Quellen von weiteren Referenzen sein. Ein Beispiel für eine Eigenschaft wäre bei einer Datei das Änderungsdatum.
• HasComponent
  Diese Referenz wird verwendet um Inhalte eines Objektes zu definieren. Elemente die über diese Referenzart erstellt worden sind, können weiterhin die Quelle für neue Referenzen sein.
• HasOrderedComponent
  Diese Referenz wird verwendet, um einem Objekt Methoden zu geben.

NodeId

ExpandedNodeId

NodeIDs werden verwendet um Datenelemente eines Servers zu bezeichnen. Darauf wurde im vorhergehenden Abschnitt bereits eingegangen. NodeIDs werden verwendet um lokale Nodes eines Servers zu identifizieren. ExpandedNodeIDs erlauben es, Nodes eines anderen Servers zu referenzieren. So wäre es zum Beispiel möglich alle Variablen und Objektdefinitionen auf einem zentralen Server zu hinterlegen und diese von anderen Servern referenzieren zu lassen.

DateTime

DateTime wird verwendet, um einen Zeitstempel zu erzeugen.

DataValue

Dies bezeichnet einen Datenwert mit einem Statuscode und einem Zeitstempel.

QualifiedName

Ein QualifiedName bezeichnet einen String, der mit einem Namespace-Index versehen ist. Der Browse-Name eines Nodes ist ein Beispiel für einen QualifiedName. Dieser wird in den Angaben dieser Übung wie folgt gekennzeichnet: qn=<namespaceIndex>;<name>.

Number

Dieser Datentyp fasst alle Zahlen zusammen. Die Art der Zahl ist hierbei irrelevant.

Integer

UInteger

Hierbei handelt es sich um vorzeichenbehaftete oder vorzeichenfreie Ganzzahlen. Hier gibt die Zahl an, wie viele Bits zur Verfügung stehen.

Float

Double

Dies sind Gleitkommazahlen mit einfacher und doppelter Genauigkeit.

DiagnosticInfo

Dieser Datentyp bietet detaillierte Informationen in einem Fehlerfall.

Boolean

Dieser Datentyp repräsentiert einen Wert der Wahr oder Falsch sein kann.

String

ByteString

Strings und ByteStrings sind Zeichenketten. Während Strings Zeichenketten aus druckbaren Zeichen bestehen, bestehen ByteStrings aus allen möglichen Zeichen. Da ein ByteString sehr häufig Zeichen beinhaltet, die nicht dargestellt werden können, werden sie Base64 kodiert dargestellt.

LocalizedText

Ein LocalizedText ist eine Struktur, die Informationen in einer gewissen Sprache kommuniziert. Ein LocalizedText besitzt damit zwei Elemente, die Sprache in der die Information vorliegt und die Information selbst.

GUID

Ein 16 Byte Wert, der als globale einzigartige Identifikationsnummer verwendet wird. Der Wert setzt sich aus einem 32-Bit Wert, zwei 16-Bit Werten und acht 8-Bit Werten.

XMLElement

Ein XML Element ist ein Element der Extensible Markup Language.

Discovery

• Browse
  Beim Browsen gibt man einen Node an und erhält alle Nodes, die den angegebenen Node als Quelle einer Referenz haben. Man kann zusätzlich noch nach Referenzen und Node-Klassen filtern. An diesem Punkt sind die zuvor erwähnten abstrakten Referenzen hilfreich, da dadurch eine Vielzahl an konkreten Referenzen abgedeckt werden kann. Folgende Informationen werden immer für jeden Node zurückgegeben:
  • Referenz
  • Node-ID
  • Browsename
  • Displayname
  • Node-Klasse
  Ausgewählte vordefinierte Elemente des Standard-Informations-Modells von OPC-UA sind:
  • qn=0;Root
    • qn=0;Objects
      • qn=0;Server
        • qn=0;NamespaceArray
        • qn=0;ServerArray
    • qn=0;Types
      • qn=0;DataTypes
      • qn=0;ObjectTypes
      • qn=0;ReferennceTypes
      • qn=0;VariableTypes
    • qn=0;Views
• BrowseNext
  Diese Funktion kann verwendet werden, wenn nicht alle Nodes zurückgegeben werden konnten. Dies kann vor allem dann hilfreich sein, wenn mehr Nodes gefunden wurden, als auf einmal gesendet werden können.
• TranslateBrowsePathToNodeID
  Mit diesem Service kann ein Browsepath in eine Node-ID umgewandelt werden. Dies ist gerade dann interessant, wenn man zwar weiß wie der Datenpunkt heißt, aber die Node-ID unbekannt ist. Da man aber die Node-ID braucht um Nodes ansprechen zu können, ist dieses Service unumgänglich. Der Browsepath ist eine Liste von Browsenames der einzelnen Nodes. Diese Funktionalität ist vor allem dann wichtig, wenn die Elemente auf dem Server semantisch oder durch eine Ontologie beschrieben werden können.
• Register/Unregister Nodes
  Mit dieser Funktionalität kann man einem Server mitteilen, dass die aktuelle Verbindung vermehrt auf die angegebenen Nodes zugreifen wird. Dabei geschehen zwei Sachen. Erstens wird die Menge an Information reduziert, die übertragen werden muss. Dies geschieht dadurch, dass der Client eine numerische Node-ID bekommt. Diese ist am einfachsten zu übertragen. Zweitens optimiert der Server den Zugriff auf den Datenpunkt selbst, damit das Schreiben auf oder Ausführen von dem Node effizienter geschieht. Unregister teilt dem Server mit, dass der Node nicht mehr vermehrt benötigt wird. Diese Funktionalität sollte nicht verwendet werden, wenn der Node nur ausgelesen wird, da es dazu effizientere Mechanismen gibt. Auf diese Mechanismen wird im Punkt Read/Write eingegangen.

Read

Write

Subscriptions und Monitored Items

• Anonym
• Benutzername/Passwort
• X509v3 Zertifikat
• WS-SecurityToken

• None - Die Kommunikation wird nicht verschlüsselt.
• Basic128RSA15
• Basic256

Server/Client

Chained Server

Server to Server

Aggregating Server

• Server: engine.ie.technikum-wien.at
• Port: 4840

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
import time
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
import time
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        try:
            # Loop
            while True:
                print("connected with server")
                # Sleep
                time.sleep(1)
        except KeyboardInterrupt:
            pass
    finally:
        # Disconnect
        CLIENT.disconnect()

• Server: engine.ie.technikum-wien.at
• Port: 4840
• Username: student
• Password: student

#!/usr/bin/env python3
"""
This example shows how to connect to the server with credentials
"""
import time
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    USER = "student"
    PASS = "student"
    CREDENTIALS = "{}:{}".format(USER, PASS)
    # This syntax does provide credentials.
    CLIENT = Client("opc.tcp://{}@{}:{}/".format(CREDENTIALS, HOST, PORT))
    try:
        # Connect to the Server
        CLIENT.connect()
        try:
            # Loop
            while True:
                print("connected with server")
                # Sleep
                time.sleep(1)
        except KeyboardInterrupt:
            pass
    finally:
        # Disconnect
        CLIENT.disconnect()

• Namespace des Hauptservers: opc.tcp://engine.ie.technikum-wien.at
• Namespace des Beispielservers: opc.tcp://engine.ie.technikum-wien.at/OPCExamples
• NodeID des Beispielservers: ns=1;s=OPC Examples

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        # There are multiple Namespaces on the Server and we want to query them
        NAMESPACES = CLIENT.get_namespace_array()
        print(">Namespaces")
        for namespace in NAMESPACES:
            print(" {}".format(namespace))

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        # There are multiple Namespaces on the Server and we want to query them
        NAMESPACES = CLIENT.get_namespace_array()
        print(">Namespaces")
        for namespace in NAMESPACES:
            print(" {}".format(namespace))
        # In order to browse, we need some node as a starting point.
        STARTNODE = CLIENT.get_objects_node()
        # The method get_children returns all children of the Node in question
        NODES = STARTNODE.get_children()
        print(">Browsing")
        print(" Children of: {}".format(STARTNODE.nodeid.to_string()))
        for node in NODES:
            print(" {} -- {} -- {}".format(
                node.nodeid.to_string(),                  # Short form of NodeID
                node.get_browse_name().to_string(),       # Short form
                ua.NodeClass(node.get_node_class()).name))# Name of the nodeclass

#!/usr/bin/env python3
"""
This example shows how to connect to the server without credentials
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        # This function connects to the server. If the connection has already
        # been implemented, nothing is done. If the connection terminated the
        # function reconnects
        CLIENT.connect()
        # There are multiple Namespaces on the Server and we want to query them
        NAMESPACES = CLIENT.get_namespace_array()
        print(">Namespaces")
        for namespace in NAMESPACES:
            print(" {}".format(namespace))
        # In order to browse, we need some node as a starting point.
        STARTNODE = CLIENT.get_objects_node()
        # The method get_children returns all children of the Node in question
        NODES = STARTNODE.get_children()
        print(">Browsing")
        print(" Children of: {}".format(STARTNODE.nodeid.to_string()))
        for node in NODES:
            print(" {} -- {} -- {}".format(
                node.nodeid.to_string(),                  # Short form of NodeID
                node.get_browse_name().to_string(),       # Short form
                ua.NodeClass(node.get_node_class()).name))# Name of the nodeclass
        # As we know the Node-ID, we can access the node directly
        STARTNODE = CLIENT.get_node("ns=1;s=OPC Examples")
        NODES = STARTNODE.get_children()
        print(" Children of: {}".format(STARTNODE.nodeid.to_string()))
        for node in NODES:
            print(" {} -- {} -- {}".format(
                node.nodeid.to_string(),                  # Short form of NodeID
                node.get_browse_name().to_string(),       # Short form
                ua.NodeClass(node.get_node_class()).name))# Name of the nodeclass
    finally:
        # Disconnect
        CLIENT.disconnect()

• Namespace des Nodes: opc.tcp://engine.ie.technikum-wien.at/OPCExamples
• Node ID Part des auszulesenden Nodes: s=ExampleVariable

#!/usr/bin/env python3
"""
This example shows how to read a variable from the server
"""
from opcua import Client

if __name__ == "__main__":
    # Create a OPC-UA Client with the following specification:
    # Server: engine.ie.technikum-wien.at
    # Port: 4840
    HOST = "engine.ie.technikum-wien.at"
    PORT = 4840
    # This syntax does not provide credentials and we are logging in anonymously
    # at the specified server. The Server has been configured to allow anonymous
    # users to read every datapoint. All other actions are prohibited.
    CLIENT = Client("opc.tcp://{}:{}/".format(HOST, PORT))
    try:
        # Connect to the Server
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExamples")
        # Get Node from the client based on the NodeID
        NODE = CLIENT.get_node("ns={};s=ExampleVariable".format(IDX))
        # Read the current value
        VALUE = NODE.get_value()
        # Print the Information
        print("{}: {}".format(NODE, VALUE))
    finally:
        # Disconnect
        CLIENT.disconnect()

• Namespace des Nodes: opc.tcp://engine.ie.technikum-wien.at/OPCExamples
• Node ID Part des auszulesenden Nodes: s=ExampleVariable

• __init__(self)
  Nachdem eine Instanz der Klasse erstellt wird, wird ein Zähler initiiert. Der Zähler soll die Anzahl der Wertänderungen speichern.
• __del__(self)
  Wenn eine Instanz der Klasse gelöscht wird, wird mitgeteilt wie viele Wertänderungen registriert wurden.
• datachange_notification(self, node, value, _)
  Diese Funktion wird aufgerufen, wenn eine Wertänderung des übergebenen node registriert wird. Der Parameter value beinhaltet den aktuellen Wert des Nodes. Der Parameter _ speichert die Rohdaten der Benachrichtigung, der hier aber nicht weiter beachtet werden muss. In diesem Beispiel soll der aktuelle Wert ausgegeben werden. Zusätzlich wird noch der Zähler bei jeder Wertänderung um eins erhöht. Der Funktionsname datachange_notification ist durch die OPC-UA Bibliothek vorgegeben und wird bei Wertänderungen automatisch aufgerufen, wenn dies gewollt ist. Wie die Benachrichtigung bei Wertänderungen definiert wird, wird im nächsten Abschnitt erklärt.

#!/usr/bin/env python3
"""
This example shows how to create a subscription to a variable
"""
import time
from opcua import Client

class SubscriptionHandler(object): # pylint: disable=too-few-public-methods
    """
    Subsrciption handler.
    """
    def __init__(self):
        self.counter = 0

    def __del__(self):
        print("Observed {} datachanges".format(self.counter))

    def datachange_notification(self, node, value, _):
        """
        Function that's called when data is changed

        Args:
            node: The node id that had a datachange
            value: The current value
            _: The raw data of the notification

        Returns:
            None
        """
        print("{}: {}".format(node, value))
        self.counter = self.counter + 1

#!/usr/bin/env python3
"""
This example shows how to create a subscription to a variable
"""
import time
from opcua import Client

class SubscriptionHandler(object): # pylint: disable=too-few-public-methods
    """
    Subsrciption handler.
    """
    def __init__(self):
        self.counter = 0

    def __del__(self):
        print("Observed {} datachanges".format(self.counter))

    def datachange_notification(self, node, value, _):
        """
        Function that's called when data is changed

        Args:
            node: The node id that had a datachange
            value: The current value
            _: The raw data of the notification

        Returns:
            None
        """
        print("{}: {}".format(node, value))
        self.counter = self.counter + 1

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExamples")
        NODE = CLIENT.get_node("ns={};s=ExampleVariable".format(IDX))
        # Create a handler to work with the updated data
        HANDLER = SubscriptionHandler()
        # Create a subscription
        SUB = CLIENT.create_subscription(500, HANDLER)
        # Connect NodeIDs to the Subscription
        SUB.subscribe_data_change(NODE)
        try:
            # Loop -- only needed so the program doesn't stop right away
            while True:
                # Sleep
                time.sleep(1)
        except KeyboardInterrupt:
            pass
        SUB.delete()
    finally:
        CLIENT.disconnect()

Finden Sie heraus, welche Datenpunkte über den Node ns=1;s=OPC Exercises erreicht werden können. Ermitteln Sie die Node-IDs im angegebenen Namespace, den Anzeigenamen und die Klasse.

#!/usr/bin/env python3
"""
This is an example-solution
"""
from opcua import Client

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        print("Nodes in ns={}:".format(IDX))
        NODE = CLIENT.get_node("ns=1;s=OPC Exercises")
        NODES = NODE.get_children()
        for node in NODES:
            if node.nodeid.NamespaceIndex != IDX: # Required as we get all children of the node
                continue
            print("{} -- {} -- {}".format(
                node.nodeid.to_string(),             # Get a short printable NodeId
                node.get_display_name().to_string(), # Get a short printable Display Name
                node.get_node_class().name))         # Get a short readbale nodeclass
    finally:
        CLIENT.disconnect()

Geben Sie die Beschreibung der in der vorhergehenden Aufgabe ermittelten Nodes aus. Lesen Sie - bei den Variablen - über 10 Sekunden im 1-Sekunden-Intervall die Werte der einzelnen Nodes und geben Sie die ermittelten Werte aus.

#!/usr/bin/env python3
"""
This is an example-solution
"""
import time
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        NODE = CLIENT.get_node("ns=1;s=OPC Exercises")
        NODES = NODE.get_children()
        for node in NODES:
            if node.nodeid.NamespaceIndex != IDX:
                continue
            print("{}: {}".format(node.nodeid.to_string(), node.get_description().to_string()))
            if node.get_node_class() == ua.NodeClass.Variable:
                values = []
                for i in range(10):
                    values.append(node.get_value())
                    time.sleep(1)
                print("Values: {}".format(values))
    finally:
        CLIENT.disconnect()

Ermitteln Sie, welche Parameter die von Ihnen ermittelten Methoden benötigen und welche Ergebnisse die Methoden liefern.

#!/usr/bin/env python3
"""
This is an example solution
"""
from opcua import Client
from opcua import ua

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        PARENT = CLIENT.get_node("ns=1;s=OPC Exercises")
        for child in PARENT.get_children():
            if child.nodeid.NamespaceIndex != IDX:
                continue
            if child.get_node_class() != ua.NodeClass.Method:
                continue
            print("{}: {}".format(child.nodeid.to_string(), child.get_display_name().to_string()))
            for arg in child.get_children():
                print(arg.get_display_name().to_string())
                for param in arg.get_value():
                    print("{}: {}".format(param.Name, param.Description.to_string()))
    finally:
        CLIENT.disconnect()

Führen Sie alle Methoden aus, die Sie ermittelt haben.

#!/usr/bin/env python3
"""
This is an example solution
"""
from opcua import Client

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        METHOD1 = CLIENT.get_node("ns={};i=318".format(IDX))
        METHOD2 = CLIENT.get_node("ns={};i=320".format(IDX))
        PARENT = CLIENT.get_node("ns=1;s=OPC Exercises")
        for idx, res in enumerate(PARENT.call_method(METHOD1)):
            print("{}: {}".format(idx, res))
        RES = PARENT.call_method(METHOD2, "Test String")
        print(RES)
    finally:
        CLIENT.disconnect()

Subscriben Sie zu den Variablen für 10 Sekunden und lassen Sie sich die empfangenen Werte nachher anzeigen.

#!/usr/bin/env python3
"""
This is an example-solution
"""
import time
from opcua import Client
from opcua import ua

class SubscriptionHandler(object): # pylint: disable=too-few-public-methods
    """
    Subsrciption handler.
    """
    def __init__(self):
        self.counter = 0
        self.items = {}

    def __del__(self):
        print("Observed {} datachanges".format(self.counter))
        for key, value in self.items.items():
            print("{} ({} values): {}".format(key.nodeid.to_string(), len(value), value))

    def datachange_notification(self, node, value, _):
        """
        Function that's called when data is changed

        Args:
            node: The node id that had a datachange
            value: The current value
            _: The raw data of the notification

        Returns:
            None
        """
        if node not in self.items.keys():
            self.items[node] = []
        self.items[node].append(value)
        self.counter = self.counter + 1

if __name__ == "__main__":
    CLIENT = Client("opc.tcp://student:student@engine.ie.technikum-wien.at:4840/")
    try:
        CLIENT.connect()
        IDX = CLIENT.get_namespace_index("opc.tcp://engine.ie.technikum-wien.at/OPCExercises")
        print("Namespace Index of Exercises: {}".format(IDX))
        NODE = CLIENT.get_node("ns=1;s=OPC Exercises")
        NODES = NODE.get_children()
        HANDLER = SubscriptionHandler()
        SUB = CLIENT.create_subscription(500, HANDLER)
        for child in NODES:
            if child.nodeid.NamespaceIndex != IDX:
                continue
            if child.get_node_class() == ua.NodeClass(2):
                print("{}: {}".format(
                    child.nodeid.to_string(),
                    child.get_description().to_string()))
                SUB.subscribe_data_change(child)
        print("Setup done; sleep 10 Seconds")
        time.sleep(10)
        SUB.delete()
    finally:
        CLIENT.disconnect()