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)