Eingangsmodule
Im Allgemeinen gibt es drei Arten von Eingangsmodulen:
-
Eingangsmodul: Das Basismodul für einige Eingangsvariablen und Eingangstags. Zum Beispiel ein OPC UA-Client. -
Eingangsvariable: Ein Modul, das Datenelemente generiert, wenn die konfigurierte Variable geändert wird. Zum Beispiel eine Abonnement auf eine OPC-UA-Variable. -
Eingangstag: Ein Modul, das Daten der konfigurierten Variablen bereitstellt, wenn diese angefordert werden. Zum Beispiel das Lesen einer bestimmten OPC-UA-Variable.
Jeder dieser Typen wird bei der Konfiguration als separater Baustein dargestellt, obwohl sie alle in einer einzigen Python-Datei beschrieben sind. Sie sind alle optional. Das Vorhandensein eines Eingangmoduls ist jedoch nur dann erforderlich, wenn ein Modul für Eingangsvariablen oder Engangstags vorhanden ist.
Eingangsmodule
Eingangsmodule werden hauptsächlich verwendet, um Verbindungen für Variablen- und Tag-Module herzustellen. Auf diese Weise können Sie dieselbe Verbindung für mehrere Instanzen von Variablen- und Tag-Modulen wiederverwenden.
Beispiel
class InputModule(AbstractInputModule):
...
@dataclass
class Configuration(models.InputModule):
anonymous: bool = field(
metadata=dict(description="Is authentication required.",
required=False),
default=True)
username: str = field(
metadata=dict(description="The username for the basic authentication.",
required=False),
default='admin')
password: str = field(
metadata=dict(description="The password for the basic authentication.",
required=False),
default='admin')
def __init__(self, configuration: Configuration):
super().__init__(configuration=configuration)
self.session = None
def start(self):
self.session = requests.Session()
if not self.configuration.anonymous:
self.session.auth = (self.configuration.username,
self.configuration.password)
def stop(self):
self.session.close()Wenn ein Eingangsmodul konfiguriert ist, wird die Modulinstanz als input_module_instance an Variablen- und Tag-Module übergeben. Dort kann die Instanz des Eingangsmoduls verwendet werden. Um das richtige Eingangsmodul zu übergeben, benötigen die Variablen- und Tag-Module den Konfigurationsparameter input_module.
Eingangsvariable
Eine Eingangsvariable ist ein Modul, das in den meisten Fällen eine zyklische Logik ausführt, um Daten zu erzeugen oder anzufordern. Es gibt auch ereignisgesteuerte Abonnements, die Datenobjekte von Drittsystemen empfangen. Eingangsvariablen haben daher keinen Eingangsport, sondern nur einen Ausgangsport zur Weiterleitung von Daten.
Beispiel
from modules.base.inputs.base import AbstractInputModule, AbstractVariableModule, AbstractTagModule, models
class VariableModule(AbstractVariableModule):
...
@dataclass
class Configuration(models.VariableModule):
input_module: str = field(
metadata=dict(description="The id of the input module.",
required=True),
default=None)
url: str = field(
metadata=dict(description="The url of the server.",
required=False,
dynamic=True),
default="http://127.0.0.1:80/api/v1/test")
interval: float = field(
metadata=dict(description="Interval in seconds to poll the endpoint.",
required=False,
validate=Range(min=0, max=1000)),
default=10)
def __init__(self, configuration: Configuration, input_module_instance=None):
super().__init__(configuration=configuration,
input_module_instance=input_module_instance)
def start(self):
Thread(target=self._subscribe,
daemon=False,
name="REST_Get_Variable_Module_Loop_{0}".format(self.configuration.id)).start()
def _subscribe(self):
"""
This method creates a new loop requesting the endpoint in the given interval.
"""
while self.active and self.input_module_instance.session:
try:
response = self.input_module_instance.session.get(url=self._dyn(url))
response.raise_for_status()
fields = response.json()
data = models.Data(measurement=self.configuration.measurement, fields=fields)
self._call_links(data)
time.sleep(self.configuration.interval)
except Exception as e:
self.logger.error("Something unexpected went wrong while requesting: {0}"
.format(str(e)), exc_info=config.EXC_INFO)Sobald das allgemeine Datenobjekt (models.Data) generiert wurde, können Sie es einfach an die verknüpften Module übergeben, indem Sie self._call_links(data) aufrufen.
Eingangstag
Eingangstags sind ähnlich wie Eingangsvariablen. Sie erzeugen jedoch nicht eigenständig Daten, sondern werden nach Daten abgefragt. Ist dies der Fall, müssen sie ein Dictionary mit den entsprechenden Daten zurückgeben.
Beispiel
from modules.base.inputs.base import AbstractInputModule, AbstractVariableModule, AbstractTagModule, models
class TagModule(AbstractTagModule):
...
@dataclass
class Configuration(models.TagModule):
key: str = field(
metadata=dict(description="The key of the constant.",
required=True),
default=None)
value: str | float | int | bool | list = field(
metadata=dict(description="The value of the constant.",
required=True),
default=None)
def __init__(self, configuration: Configuration, input_module_instance=None):
super().__init__(configuration=configuration,
input_module_instance=input_module_instance)
def _run(self) -> dict[str, Any]:
"""
This methods returns the queried data.
:returns: A dict containing the generated key-value pairs.
"""
return {self.configuration.key: self.configuration.value}Ob die zurückgegebenen Daten als Felder oder Tags an das vorhandene Datenobjekt angehängt werden, ist benutzerdefiniert und wird vom zugrunde liegenden Framework gehandhabt.
Data Requirements
Template