def test_extension_object(self):
obj = ua.UserNameIdentityToken()
obj.UserName = "******"
obj.Password = b"pass"
obj2 = ua.extensionobject_from_binary(ua.utils.Buffer(extensionobject_to_binary(obj)))
self.assertEqual(type(obj), type(obj2))
self.assertEqual(obj.UserName, obj2.UserName)
self.assertEqual(obj.Password, obj2.Password)
v1 = ua.Variant(obj)
v2 = ua.Variant.from_binary(ua.utils.Buffer(v1.to_binary()))
self.assertEqual(type(v1), type(v2))
self.assertEqual(v1.VariantType, v2.VariantType)
def test_value(self):
o = self.opc.get_objects_node()
var = ua.Variant(1.98, ua.VariantType.Double)
v = o.add_variable(3, 'VariableValue', var)
val = v.get_value()
self.assertEqual(1.98, val)
dvar = ua.DataValue(var)
dv = v.get_data_value()
self.assertEqual(ua.DataValue, type(dv))
self.assertEqual(dvar.Value, dv.Value)
self.assertEqual(dvar.Value, var)
def reconciliate_subscription(self, subscription):
"""
Reconciliate the server state with the client
"""
node = self.get_node(
ua.FourByteNodeId(ua.ObjectIds.Server_GetMonitoredItems))
# returns server and client handles
monitored_items = node.get_parent().call_method(
ua.uatypes.QualifiedName("GetMonitoredItems"),
ua.Variant(subscription.subscription_id,
ua.datatype_to_varianttype(7)))
return subscription.reconciliate(monitored_items)
def test_functional_advance(self):
basic_struct_name = 'base_structure'
basic_struct = self.dict_builder.create_data_type(basic_struct_name)
basic_struct.add_field('ID', ua.VariantType.Int32)
basic_struct.add_field('Gender', ua.VariantType.Boolean)
basic_struct.add_field('Comments', ua.VariantType.String)
nested_struct_name = 'nested_structure'
nested_struct = self.dict_builder.create_data_type(nested_struct_name)
nested_struct.add_field('Name', ua.VariantType.String)
nested_struct.add_field('Surname', ua.VariantType.String)
nested_struct.add_field('Stuff', basic_struct)
self.dict_builder.set_dict_byte_string()
self.srv.load_type_definitions()
basic_var = self.srv.nodes.objects.add_variable(ua.NodeId(namespaceidx=self.idx), 'BaseStruct',
ua.Variant(None, ua.VariantType.Null),
datatype=basic_struct.data_type)
basic_msg = get_ua_class(basic_struct_name)()
basic_msg.ID = 3
basic_msg.Gender = True
basic_msg.Comments = 'Test string'
basic_var.set_value(basic_msg)
nested_var = self.srv.nodes.objects.add_variable(ua.NodeId(namespaceidx=self.idx), 'NestedStruct',
ua.Variant(None, ua.VariantType.Null),
datatype=nested_struct.data_type)
nested_msg = get_ua_class(nested_struct_name)()
nested_msg.Stuff = basic_msg
nested_msg.Name = 'Max'
nested_msg.Surname = 'Karl'
nested_var.set_value(nested_msg)
basic_result = basic_var.get_value()
self.assertEqual(basic_result, basic_msg)
nested_result = nested_var.get_value()
self.assertEqual(nested_result, nested_msg)
def ComunicacionRTO():
costos = [0]*5
# Lectura de costos del Bloque Lectura
costos[1] = SCADA.read("Deck Variables.CostoA")[0]
costos[2] = SCADA.read("Deck Variables.CostoB")[0]
costos[3] = SCADA.read("Deck Variables.CostoC")[0]
costos[4] = SCADA.read("Deck Variables.CostoD")[0]
costos[5] = SCADA.read("Deck Variables.CostoRef")[0]
# Escritura de los costos al bloque RTO
RTO.get_node("ns=4;s=CostoA").set_value(
ua.Variant(costos[1], ua.VariantType.Double))
RTO.get_node("ns=4;s=CostoB").set_value(
ua.Variant(costos[2], ua.VariantType.Double))
RTO.get_node("ns=4;s=CostoC").set_value(
ua.Variant(costos[3], ua.VariantType.Double))
RTO.get_node("ns=4;s=CostoD").set_value(
ua.Variant(costos[4], ua.VariantType.Double))
RTO.get_node("ns=4;s=CostoRef").set_value(
ua.Variant(costos[5], ua.VariantType.Double))
# Ejecución del RTO
RTO.get_node("ns=2;s=server_methods").call_method(
"5:method_run", ua.Variant("A String", ua.VariantType.String))
# Leer set-points del RTO
T_sp = RTO.get_node("ns=4;s=T").get_value()
Ca_sp = RTO.get_node("ns=4;s=Ca").get_value()
# Enviar set-points al SCADA
SCADA.write(("Deck Variables.T_sp", T_sp))
SCADA.write(("Deck Variables.Ca_sp", Ca_sp))
return [T_sp, Ca_sp]
def test_get_event_from_type_node_Inhereted_AuditEvent(self):
ev = opcua.server.event.get_event_from_type_node(opcua.Node(self.opc.iserver.isession, ua.NodeId(ua.ObjectIds.AuditEventType)))
self.assertIsNot(ev, None) # we did not receive event
self.assertIsInstance(ev, ua.BaseEvent)
self.assertIsInstance(ev, ua.AuditEvent)
self.assertEqual(ev.EventType, ua.NodeId(ua.ObjectIds.AuditEventType))
self.assertEqual(ev.Severity, ua.Variant(1, ua.VariantType.UInt16))
self.assertEqual(ev.ActionTimeStamp, None)
self.assertEqual(ev.Status, False)
self.assertEqual(ev.ServerId, None)
self.assertEqual(ev.ClientAuditEntryId, None)
self.assertEqual(ev.ClientUserId, None)
self.assertEqual(ev._freeze, True)
def _add_node_attr(self,
item,
nodedata,
name,
vtype=None,
add_timestamps=False):
if item.SpecifiedAttributes & getattr(ua.NodeAttributesMask, name):
dv = ua.DataValue(ua.Variant(getattr(item, name), vtype))
if add_timestamps:
# dv.ServerTimestamp = datetime.utcnow() # Disabled until someone explains us it should be there
dv.SourceTimestamp = datetime.utcnow()
nodedata.attributes[getattr(ua.AttributeIds,
name)] = AttributeValue(dv)
def addNewScadaDevice():
"""
Add a new scada device
Usage:
>>> addNewScadaDevice()
"""
client = opcua.Client('opc.tcp://10.11.31.40:4840')
client.connect()
atviseObject = client.get_node('ns=1;s=AGENT.OBJECTS.SCAMPY.newDefault.newDevice')
atviseObject.set_value(ua.DataValue(ua.Variant(True,ua.VariantType.Boolean)))
client.disconnect()
def create_property(parent, nodeid, bname, val, varianttype=None, datatype=None):
"""
create a child node property
args are nodeid, browsename, value, [variant type]
or idx, name, value, [variant type]
"""
nodeid, qname = _parse_nodeid_qname(nodeid, bname)
var = ua.Variant(val, varianttype)
if datatype and isinstance(datatype, int):
datatype = ua.NodeId(datatype, 0)
if datatype and not isinstance(datatype, ua.NodeId):
raise RuntimeError("datatype argument must be a nodeid or an int refering to a nodeid")
return node.Node(parent.server, _create_variable(parent.server, parent.nodeid, nodeid, qname, var, datatype=datatype, isproperty=True))
def Write_LS1_CTRLWord(self):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.connect()
ls1ctrl = self.GetCtrlWord(self._ls1_wd, self._ls1_run,
self._ls1_stop, self._ld1_run,
self._ld1_stop, self._lqt1_run,
self._lqt1_stop)
self._nodels1.set_value(
ua.DataValue(ua.Variant(ls1ctrl, ua.VariantType.Int16)))
except Exception as err:
print(err)
pass
def Write_PLC_B_LS2_CTRLWord(self):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.CHANGE_PLC_B_CTRL_WORD()
ls2ctrl = self.GetCtrlWord(self._ls2_wd, self._ls2_run,
self._ls2_stop, self._ld2_run,
self._ld2_stop, self._lqt2_run,
self._lqt2_stop)
self._nodels2.set_value(
ua.DataValue(ua.Variant(ls2ctrl, ua.VariantType.Int16)))
except Exception as err:
print(err)
pass
def test_read(self):
#
# send read request to the opc ua server
#
node = self.opcua_client.get_node("ns=2;i=208")
node.set_value(ua.DataValue(ua.Variant(555, ua.VariantType.Int32)))
node = self.opcua_client.get_node("ns=2;i=220")
node.set_value(ua.DataValue(True))
req = {
"Header": {
"MessageType": "GW_ReadRequest",
"ClientHandle": "client-handle",
"SessionId": self.sessionId
},
"Body": {
"NodesToRead": [{
"NodeId": {
"Namespace": "2",
"Id": "208"
},
"AttributeId": "13"
}, {
"NodeId": {
"Namespace": "2",
"Id": "220"
},
"AttributeId": "13"
}]
}
}
print("SEND: ", json.dumps(req, indent=4))
self.ws.send(json.dumps(req))
#
# receive read response from the opc ua server
#
str = self.ws.recv()
print("RECV: ", str)
res = json.loads(str)
self.assertEqual(res['Header']['MessageType'], "GW_ReadResponse")
self.assertEqual(res['Header']['ClientHandle'], "client-handle")
self.assertEqual(res['Header']['SessionId'], self.sessionId)
self.assertEqual(res['Header']['StatusCode'], "0")
self.assertEqual(len(res['Body']['Results']), 2)
self.assertIsNotNone(res['Body']['Results'][0]['Value'])
self.assertIsNotNone(res['Body']['Results'][1]['Value'])
self.assertEqual('555', res['Body']['Results'][0]['Value']['Body'])
self.assertEqual('true', res['Body']['Results'][1]['Value']['Body'])
def update(self):
# Mode=0 is disabled/readonly
# Mode=1 is normal: get data from configured external data source such as Modbus RTU, etc.
# Mode=2 is simulation: the tag.Value will be set by the OPC UA server based on the configured limits
if self.Mode == 0: # use this mode as "read only" for now; may need to add a separate mode later
pass
elif self.Mode == 1:
if self.DataSource not in (None, '') and self.DataAddress not in (None, ''):
if self.DataSource == "ModbusRTU":
_data_address = self.DataAddress.split(':')
_slave = int(_data_address[0]) - 1 # slave is offset in the list by 1 (slave 1 is position 0)
_address = int(_data_address[1])
# handle raw value
_address_value = driver_ModbusRTU.slave_list[_slave].Data[_address] / self.Divisor
_dv_raw = ua.DataValue(ua.Variant(_address_value, ua.VariantType.Double))
# handle scaled value
if self.ScalingEnable:
_scaled_value = scale_value(_address_value, self.RawMin, self.RawMax, self.ScaledMin, self.ScaledMax)
_dv_val = ua.DataValue(ua.Variant(_scaled_value, ua.VariantType.Double))
else:
_dv_val = _dv_raw
elif self.DataSource == "OPCUAClient":
pass # fill in with client to external opc ua server later
else:
_dv_raw = ua.DataValue(ua.Variant(0.0, ua.VariantType.Double))
_dv_val = ua.DataValue(ua.Variant(0.0, ua.VariantType.Double))
# value gets set from configured data source here
self.nodes['RawValue'].set_data_value(_dv_raw)
self.nodes['Value'].set_data_value(_dv_val)
else:
print("Device {} is on scan has but has invalid configuration".format(self.b_name))
elif self.Mode == 2:
self.nodes['Value'].set_value(random.uniform(self.SimLowLimit, self.SimHighLimit))
def create_custom_event_type(self, idx, name, baseetype=ua.ObjectIds.BaseEventType, properties=[]):
if isinstance(baseetype, Node):
base_event = baseetype
elif isinstance(baseetype, ua.NodeId):
base_event = Node(self.iserver.isession, baseetype)
else:
base_event = Node(self.iserver.isession, ua.NodeId(baseetype))
custom_event = base_event.add_subtype(idx, name)
for property in properties:
custom_event.add_property(idx, property[0], ua.Variant(None, property[1]))
return custom_event
def value_to_datavalue(val, varianttype=None):
"""
convert anyting to a DataValue using varianttype
"""
datavalue = None
if isinstance(val, ua.DataValue):
datavalue = val
elif isinstance(val, ua.Variant):
datavalue = ua.DataValue(val)
datavalue.SourceTimestamp = datetime.utcnow()
else:
datavalue = ua.DataValue(ua.Variant(val, varianttype))
datavalue.SourceTimestamp = datetime.utcnow()
return datavalue
def opc_hmi_sva():
url = "opc.tcp://192.168.10.1:4840"
sva_nodeid = 'ns=3;s="HMI_IF"."hmi_sva_speak"'
with Client(url=url) as client:
# 发送HMI显示小张说节点ID
hmi_sva_speak = client.get_node(sva_nodeid)
while True:
hmi_sva_speak_value = q_hmi_sva.get()
hmi_sva_speak.set_value(
ua.DataValue(
ua.Variant(hmi_sva_speak_value, ua.VariantType.String)))
q_hmi_sva.task_done()
def Write_LS2_CTRLWord(self):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.connect()
ls2ctrl = self.GetCtrlWord(self._ls2_wd, self._ls2_run,
self._ls2_stop, self._ld2_run,
self._ld2_stop, self._lqt2_run,
self._lqt2_stop)
# self._nodels2 = self._client.get_node('ns = 2;s = SCADA.DO.TSET2')
self._nodels2.set_value(
ua.DataValue(ua.Variant(ls2ctrl, ua.VariantType.Int16)))
except Exception as err:
print(err)
pass
def Write_LS2_Params(self, AEquipment, AValue):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.connect()
if (AEquipment == "LD2"):
self._ld2pv = int(AValue)
self._nodeld2pv.set_value(
ua.DataValue(
ua.Variant(10 * int(self._ld2pv),
ua.VariantType.Int16)))
elif (AEquipment == "LQ2"):
self._lq2pv = int(AValue)
self._nodelq2pv.set_value(
ua.DataValue(
ua.Variant(10 * int(self._lq2pv),
ua.VariantType.Int16)))
# self._nodekt1pv.set_value(ua.DataValue(ua.Variant(10*int(self._kt1pv),ua.VariantType.UInt16)))
# self._nodekt2pv.set_value(ua.DataValue(ua.Variant(10*int(self._kt2pv),ua.VariantType.UInt16)))
# self._nodekt2vpv.set_value(ua.DataValue(ua.Variant(10*int(self._kt2vopen),ua.VariantType.UInt16)))
# self._nodekt1vpv.set_value(ua.DataValue(ua.Variant(10*int(self._kt1vopen),ua.VariantType.UInt16)))
except Exception as err:
print(err)
pass
def __init__(self, isession, etype=None, source=ua.ObjectIds.Server):
if not etype:
etype = ua.BaseEvent()
self.logger = logging.getLogger(__name__)
self.isession = isession
self.event = None
node = None
if isinstance(etype, ua.BaseEvent):
self.event = etype
elif isinstance(etype, Node):
node = etype
elif isinstance(etype, ua.NodeId):
node = Node(self.isession, etype)
else:
node = Node(self.isession, ua.NodeId(etype))
if node:
self.event = get_event_from_type_node(node)
if isinstance(source, Node):
pass
elif isinstance(source, ua.NodeId):
source = Node(isession, source)
else:
source = Node(isession, ua.NodeId(source))
if self.event.SourceNode:
if source.nodeid != self.event.SourceNode:
self.logger.warning(
"Source NodeId: '%s' and event SourceNode: '%s' are not the same. Using '%s' as SourceNode",
str(source.nodeid), str(self.event.SourceNode),
str(self.event.SourceNode))
source = Node(self.isession, self.event.SourceNode)
self.event.SourceNode = source.nodeid
self.event.SourceName = source.get_browse_name().Name
source.set_attribute(ua.AttributeIds.EventNotifier,
ua.DataValue(ua.Variant(1, ua.VariantType.Byte)))
refs = []
ref = ua.AddReferencesItem()
ref.IsForward = True
ref.ReferenceTypeId = ua.NodeId(ua.ObjectIds.GeneratesEvent)
ref.SourceNodeId = source.nodeid
ref.TargetNodeClass = ua.NodeClass.ObjectType
ref.TargetNodeId = self.event.EventType
refs.append(ref)
results = self.isession.add_references(refs)
def set_value(self, node_id, value_type_identifier, desired_value):
"""Set value on the OPC UA server. example parameters:
Node_id=ns=4;s=node_name,
value_type_identifier 0-25
see: https://github.com/FreeOpcUa/python-opcua/blob/master/opcua/ua/uatypes.py#L619),
desired_value could be any value that matches the UA Type
"""
parsed_value, opc_type = map_to_opcua_type_and_value(
value_type_identifier, desired_value)
self.ensure_connection()
node = self._client.get_node(node_id)
dv = ua.DataValue(ua.Variant(parsed_value, opc_type))
node.set_value(dv)
def test_set_value(self):
o = self.opc.get_objects_node()
var = ua.Variant(1.98, ua.VariantType.Double)
dvar = ua.DataValue(var)
v = o.add_variable(3, 'VariableValue', var)
v.set_value(var.Value)
v1 = v.get_value()
self.assertEqual(v1, var.Value)
v.set_value(var)
v2 = v.get_value()
self.assertEqual(v2, var.Value)
v.set_data_value(dvar)
v3 = v.get_data_value()
self.assertEqual(v3.Value, dvar.Value)
def scrivi_float(client, ns, i, VAL):
"""
scrive un valore float all'interno di una variabile
:param client: oggetto per la connessione OPC UA
:param ns: namespace id
:param i: indice del namespace
:param VAL: valore da scrivere
:return:
"""
stringa = "" + "ns=" + str(ns) + ";i=" + str(i)
var = client.get_node(stringa)
# print(var)
datavalue = ua.DataValue(ua.Variant(VAL, ua.VariantType.Float))
var.set_data_value(datavalue)
def cancella_contenuto_array_caratteri(client, ns, i, ARRAY_DIM):
"""
resetta il contenuto di un array di char all'interno della DB di scambio
:param client: oggetto per la connessione OPC UA
:param ns: namespace id
:param i: indice del namespace
:param ARRAY_DIM: dimensioni del vettore definito nella DB di scambio
:return:
"""
for pos in range(ARRAY_DIM + 1):
stringa = "" + "ns=" + str(ns) + ";i=" + str(i + pos + 1)
var = client.get_node(stringa)
datavalue = ua.DataValue(ua.Variant(ord(" "), ua.VariantType.Byte))
var.set_data_value(datavalue)
def _add_variable_value(self, obj):
"""
Returns the value for a Variable based on the objects value type.
"""
self.logger.debug("Setting value with type %s and value %s",
obj.valuetype, obj.value)
if obj.valuetype == 'ListOfExtensionObject':
values = []
for ext in obj.value:
extobj = self._make_ext_obj(ext)
values.append(extobj)
return ua.Variant(values, ua.VariantType.ExtensionObject)
elif obj.valuetype == 'ListOfGuid':
return ua.Variant([uuid.UUID(guid) for guid in obj.value],
getattr(ua.VariantType, obj.valuetype[6:]))
elif obj.valuetype.startswith("ListOf"):
vtype = obj.valuetype[6:]
if hasattr(ua.ua_binary.Primitives, vtype):
return ua.Variant(obj.value, getattr(ua.VariantType, vtype))
else:
return ua.Variant([getattr(ua, vtype)(v) for v in obj.value])
elif obj.valuetype == 'ExtensionObject':
extobj = self._make_ext_obj(obj.value)
return ua.Variant(extobj, getattr(ua.VariantType, obj.valuetype))
elif obj.valuetype == 'Guid':
return ua.Variant(uuid.UUID(obj.value),
getattr(ua.VariantType, obj.valuetype))
elif obj.valuetype == 'LocalizedText':
ltext = ua.LocalizedText()
for name, val in obj.value:
if name == "Text":
ltext.Text = val
else:
self.logger.warning(
"While parsing localizedText value, unkown element: %s with val: %s",
name, val)
return ua.Variant(ltext, ua.VariantType.LocalizedText)
elif obj.valuetype == 'NodeId':
return ua.Variant(ua.NodeId.from_string(obj.value))
else:
return ua.Variant(obj.value, getattr(ua.VariantType,
obj.valuetype))
def run(self):
print("start server")
self.server.start()
try:
while True:
val=ua.Variant(self.sensori["temperatura"], ua.VariantType.Float)
val=ua.DataValue(val)
val.SourceTimestamp=datetime.utcnow()
val.ServerTimestamp=datetime.utcnow()
self.temperatura_s.set_data_value(val)
val2=ua.Variant(self.sensori["counter_bagno"], ua.VariantType.UInt16)
val2=ua.DataValue(val2)
val2.SourceTimestamp=datetime.utcnow()
val2.ServerTimestamp=datetime.utcnow()
self.counterbagno_s.set_data_value(val2)
val3=ua.Variant(self.sensori["counter_salotto"], ua.VariantType.UInt16)
val3=ua.DataValue(val3)
val3.SourceTimestamp=datetime.utcnow()
val3.ServerTimestamp=datetime.utcnow()
self.countersalotto_s.set_data_value(val3)
for x in self.keys:
pin=self.__led[x]
status=gpio.input(pin)
var=ua.Variant(status, ua.VariantType.Boolean)
s=ua.DataValue(var)
s.SourceTimestamp=datetime.utcnow()
s.ServerTimestamp=datetime.utcnow()
self.luci_o_dict[x].set_value(s)
time.sleep(1)
finally:
self.server.stop()
def Datos_MPC(q, qc, T0, Tc0, T, Tc, Ca):
MPC.get_node("ns=4;s=uqant").set_value(
ua.Variant(q, ua.VariantType.Double))
MPC.get_node("ns=4;s=uqcant").set_value(
ua.Variant(qc, ua.VariantType.Double))
MPC.get_node("ns=4;s=q").set_value(
ua.Variant(q, ua.VariantType.Double))
MPC.get_node("ns=4;s=qc").set_value(
ua.Variant(qc, ua.VariantType.Double))
MPC.get_node("ns=4;s=T0").set_value(
ua.Variant(T0, ua.VariantType.Double))
MPC.get_node("ns=4;s=Tc0").set_value(
ua.Variant(Tc0, ua.VariantType.Double))
MPC.get_node("ns=4;s=T").set_value(
ua.Variant(T, ua.VariantType.Double))
MPC.get_node("ns=4;s=Tc").set_value(
ua.Variant(Tc, ua.VariantType.Double))
MPC.get_node("ns=4;s=Ca").set_value(
ua.Variant(Ca, ua.VariantType.Double))
return 0
def variant_from_binary(data):
dimensions = None
array = False
encoding = ord(data.read(1))
int_type = encoding & 0b00111111
vtype = ua.datatype_to_varianttype(int_type)
if test_bit(encoding, 7):
value = unpack_uatype_array(vtype, data)
array = True
else:
value = unpack_uatype(vtype, data)
if test_bit(encoding, 6):
dimensions = unpack_uatype_array(ua.VariantType.Int32, data)
value = _reshape(value, dimensions)
return ua.Variant(value, vtype, dimensions, is_array=array)
def getAASIDByAssetID(ResolutionServerEndpoint, AssetIDSpec, AssetIDType):
client = Client(ResolutionServerEndpoint)
# client = Client("opc.tcp://localhost:16664) #connect using a user
res = ["", "", ""]
try:
client.connect()
nsarray = client.get_node(ua.NodeId(2255, 0))
nsList = nsarray.get_value()
i = -1
for entry in nsList:
i = i + 1
if entry == "http://acplt.org/subModelDiscovery/Ov":
print(entry)
nsopenaas_discovery = i
break
if i == -1:
return res
getAASIDFromAssetId_nodeId = ua.NodeId(
"/TechUnits/openAAS/AASFolder/NetworkAAS.Body/NameResolution",
nsopenaas_discovery)
getAASIDFromASsetIdMethod_nodeId = ua.NodeId(
"/TechUnits/openAAS/AASFolder/NetworkAAS.Body/NameResolution.GetAASIDByAssetIDService",
nsopenaas_discovery)
discoveryNode = client.get_node(getAASIDFromAssetId_nodeId)
discoveryMethodNode = client.get_node(getAASIDFromASsetIdMethod_nodeId)
print(discoveryNode.get_browse_name().Name)
print(discoveryMethodNode.get_browse_name().Name)
res = discoveryNode.call_method(
discoveryMethodNode, ua.Variant(AssetIDType,
ua.VariantType.UInt32),
ua.Variant(AssetIDSpec, ua.VariantType.String))
print("result of method call is %s" % res)
finally:
client.disconnect()
return res
def set_plug_state(parent, args):
ret = False
plug = args.Value[0].Value
state = args.Value[1].Value
if plug in range(0, 4):
print("Plug: " + str(plug) + " to state: " + str(state))
ret = relay_box.setRelayState(plug, state)
else:
print("PlugId is wrong, has to be integer in range 0 ... 3 . not " +
str(plug))
print("opc method answer: " + str(ret))
return [ua.Variant(ret, ua.VariantType.Boolean)]
def set_node_value(self, NODE, VALUE):
'''
This method will autodetect DataType of the current node data type
to set onto the node's value. This is currently only able to detect
datatype from the underlying NODE, but must take care to make sense with
your data types
s
TODO: add more potential DataTypes
'''
try:
DATATYPE = NODE.get_data_type_as_variant_type()
VARIANT = ua.Variant(VALUE, DATATYPE)
NODE.set_attribute(VALUE_ATTRIBUTE_ID, ua.DataValue(VARIANT))
except Exception as e:
print(e)
