def test_update_message(self):
print("set value <ns=2;i=220> to False")
node = self.opcua_client.get_node("ns=2;i=220")
node.set_value(ua.DataValue(False))
print("start monitor")
self.start_monitor_('BooleanTest')
print("set value <ns=2;i=220> to True")
node.set_value(ua.DataValue(True))
print("read data from web server")
resp = json.loads(self.ws.recv())
print(resp)
self.assertEqual('1', resp['Body']['Value']['Type'])
self.assertEqual('true', resp['Body']['Value']['Body'])
node.set_value(ua.DataValue(False))
resp = json.loads(self.ws.recv())
print(resp)
self.assertEqual('false', resp['Body']['Value']['Body'])
self.stop_monitor_('BooleanTest')
def opc_snd_plc():
url = "opc.tcp://192.168.10.1:4840"
rev_nodeid = 'ns=3;s="OPCUA_REV"."srm_mqtt_sub"'
rev_flg_nodeid = 'ns=3;s="OPCUA_REV"."srm_mqtt_sub_flg"'
with Client(url=url) as client:
# 发送到PLC节点ID
rev_srm_mqtt_sub = client.get_node(rev_nodeid)
rev_srm_mqtt_sub_flg = client.get_node(rev_flg_nodeid)
# 初始化同步PLC的数据
# 发送给PLC
rev_srm_mqtt_sub_flg_value = rev_srm_mqtt_sub_flg.get_value()
while True:
# 发送PLC消息
rev_srm_mqtt_sub_value = q_opc.get()
rev_srm_mqtt_sub.set_value(
ua.DataValue(
ua.Variant(rev_srm_mqtt_sub_value, ua.VariantType.String)))
if rev_srm_mqtt_sub_flg_value >= 32767:
rev_srm_mqtt_sub_flg_value = -32768
else:
rev_srm_mqtt_sub_flg_value = rev_srm_mqtt_sub_flg_value + 1
rev_srm_mqtt_sub_flg.set_value(
ua.DataValue(
ua.Variant(rev_srm_mqtt_sub_flg_value,
ua.VariantType.Int16)))
q_opc.task_done()
def set_value(self, device="", value=""):
"""
Assign a value to the specified device listed on the dictionary (use labview name)
These values have to match the data type set on the PLC (SPS). eg. float, UInt16, etc.
The SPS can recieve either a variant or a datavalue variable, but it seems to accept
more the Datavalue as in Set_Value, therefore its better to send it this way.
Refer to uatypes.py for more information regarding variant types.
the Timestamp also on uatypes.py has to be set to 0 or none.
https://github.com/FreeOpcUa/python-opcua/issues/9
"""
child = self.root.get_child(self.variables_location + \
[self.devices[str(device)]])
if isinstance(value, float):
dv = ua.DataValue(ua.Variant(float(value), ua.VariantType.Float))
elif isinstance(value, bool):
dv = ua.DataValue(ua.Variant(bool(value), ua.VariantType.Boolean))
else:
print(
'At the moment Bool and Float variant types are accepted, for adding'
'an extra type please refer to microkwkkcom.py document')
child.set_value(dv)
value = child.get_value()
return {device: value}
def set_writable(self, writable=True):
"""
Set node as writable by clients.
A node is always writable on server side.
"""
if writable:
self.set_attribute(
ua.AttributeIds.AccessLevel,
ua.DataValue(
ua.Variant(ua.AccessLevelMask.CurrentWrite,
ua.VariantType.Byte)))
self.set_attribute(
ua.AttributeIds.UserAccessLevel,
ua.DataValue(
ua.Variant(ua.AccessLevelMask.CurrentWrite,
ua.VariantType.Byte)))
else:
self.set_attribute(
ua.AttributeIds.AccessLevel,
ua.DataValue(
ua.Variant(ua.AccessLevelMask.CurrentRead,
ua.VariantType.Byte)))
self.set_attribute(
ua.AttributeIds.AccessLevel,
ua.DataValue(
ua.Variant(ua.AccessLevelMask.CurrentRead,
ua.VariantType.Byte)))
def Write_LS_FaultReset(self, AEquipment):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.connect()
if (AEquipment == "LS1"):
lsctrl = self.GetFaultCtrlWord(100, 1)
self.CHANGE_PLC_A_CTRL_WORD()
self._nodels1.set_value(
ua.DataValue(ua.Variant(int(lsctrl),
ua.VariantType.Int16)))
time.sleep(3)
self.CHANGE_PLC_B_CTRL_WORD()
self._nodels1.set_value(
ua.DataValue(ua.Variant(int(lsctrl),
ua.VariantType.Int16)))
time.sleep(3)
# lsctrl = self.GetFaultCtrlWord(100, 0)
# self._nodels1.set_value(ua.DataValue(ua.Variant(int(lsctrl), ua.VariantType.Int16)))
elif (AEquipment == "LS2"):
lsctrl = self.GetFaultCtrlWord(100, 1)
self.CHANGE_PLC_A_CTRL_WORD()
self._nodels2.set_value(
ua.DataValue(ua.Variant(int(lsctrl),
ua.VariantType.Int16)))
time.sleep(3)
self.CHANGE_PLC_B_CTRL_WORD()
self._nodels2.set_value(
ua.DataValue(ua.Variant(int(lsctrl),
ua.VariantType.Int16)))
time.sleep(3)
# lsctrl = self.GetFaultCtrlWord(100, 0)
# self._nodels2.set_value(ua.DataValue(ua.Variant(int(lsctrl), ua.VariantType.Int16)))
except Exception as err:
print(err)
pass
def test_datavalue(self):
dv = ua.DataValue(123)
self.assertEqual(dv.Value, ua.Variant(123))
self.assertEqual(type(dv.Value), ua.Variant)
dv = ua.DataValue('abc')
self.assertEqual(dv.Value, ua.Variant('abc'))
now = datetime.utcnow()
dv.SourceTimestamp = now
async def status_updater(status_node):
while True:
status_node.set_value(
ua.DataValue(
ua.Variant(ua.ServerState.Running, ua.VariantType.Int32)))
await asyncio.sleep(10)
status_node.set_value(
ua.DataValue(
ua.Variant(ua.ServerState.Suspended, ua.VariantType.Int32)))
await asyncio.sleep(10)
def _add_node(self, item, user):
result = ua.AddNodesResult()
if item.RequestedNewNodeId in self._aspace:
self.logger.warning("AddNodeItem: node already exists")
result.StatusCode = ua.StatusCode(ua.StatusCodes.BadNodeIdExists)
return result
nodedata = NodeData(item.RequestedNewNodeId)
# add common attrs
nodedata.attributes[ua.AttributeIds.NodeId] = AttributeValue(ua.DataValue(ua.Variant(item.RequestedNewNodeId, ua.VariantType.NodeId)))
nodedata.attributes[ua.AttributeIds.BrowseName] = AttributeValue(ua.DataValue(ua.Variant(item.BrowseName, ua.VariantType.QualifiedName)))
nodedata.attributes[ua.AttributeIds.NodeClass] = AttributeValue(ua.DataValue(ua.Variant(item.NodeClass, ua.VariantType.Int32)))
# add requested attrs
self._add_nodeattributes(item.NodeAttributes, nodedata)
# add parent
if item.ParentNodeId == ua.NodeId():
#self.logger.warning("add_node: creating node %s without parent", item.RequestedNewNodeId)
pass
elif item.ParentNodeId not in self._aspace:
#self.logger.warning("add_node: while adding node %s, requested parent node %s does not exists", item.RequestedNewNodeId, item.ParentNodeId)
result.StatusCode = ua.StatusCode(ua.StatusCodes.BadParentNodeIdInvalid)
return result
else:
if not user == User.Admin:
result.StatusCode = ua.StatusCode(ua.StatusCodes.BadUserAccessDenied)
return result
desc = ua.ReferenceDescription()
desc.ReferenceTypeId = item.ReferenceTypeId
desc.NodeId = item.RequestedNewNodeId
desc.NodeClass = item.NodeClass
desc.BrowseName = item.BrowseName
desc.DisplayName = ua.LocalizedText(item.BrowseName.Name)
desc.TypeDefinition = item.TypeDefinition
desc.IsForward = True
self._aspace[item.ParentNodeId].references.append(desc)
# now add our node to db
self._aspace[item.RequestedNewNodeId] = nodedata
# add type definition
if item.TypeDefinition != ua.NodeId():
addref = ua.AddReferencesItem()
addref.SourceNodeId = item.RequestedNewNodeId
addref.IsForward = True
addref.ReferenceTypeId = ua.NodeId(ua.ObjectIds.HasTypeDefinition)
addref.TargetNodeId = item.TypeDefinition
addref.TargetNodeClass = ua.NodeClass.DataType
self._add_reference(addref, user)
result.StatusCode = ua.StatusCode()
result.AddedNodeId = item.RequestedNewNodeId
return result
def _add_node_attributes(self, nodedata, item):
# add common attrs
nodedata.attributes[ua.AttributeIds.NodeId] = AttributeValue(
ua.DataValue(ua.Variant(nodedata.nodeid, ua.VariantType.NodeId)))
nodedata.attributes[ua.AttributeIds.BrowseName] = AttributeValue(
ua.DataValue(
ua.Variant(item.BrowseName, ua.VariantType.QualifiedName)))
nodedata.attributes[ua.AttributeIds.NodeClass] = AttributeValue(
ua.DataValue(ua.Variant(item.NodeClass, ua.VariantType.Int32)))
# add requested attrs
self._add_nodeattributes(item.NodeAttributes, nodedata)
def test_read_float(self):
node = self.opcua_client.get_node("ns=2;i=216")
node.set_value(ua.DataValue(2.8))
resp = self.read_('FloatTest')
print(resp)
self.assertEqual('11', resp['Body']['Value']['Type'])
self.assertEqual('2.8', resp['Body']['Value']['Body'])
node.set_value(ua.DataValue(-30.0))
resp = self.read_('FloatTest')
self.assertEqual('-30', resp['Body']['Value']['Body'])
def test_read_int(self):
node = self.opcua_client.get_node("ns=2;i=208")
node.set_value(ua.DataValue(555))
resp = self.read_('Int32Test')
print(resp)
self.assertEqual('8', resp['Body']['Value']['Type'])
self.assertEqual('555', resp['Body']['Value']['Body'])
node.set_value(ua.DataValue(-450))
resp = self.read_('Int32Test')
self.assertEqual('-450', resp['Body']['Value']['Body'])
def test_read_bool(self):
node = self.opcua_client.get_node("ns=2;i=220")
node.set_value(ua.DataValue(True))
resp = self.read_('BooleanTest')
print(resp)
self.assertEqual('1', resp['Body']['Value']['Type'])
self.assertEqual('true', resp['Body']['Value']['Body'])
node.set_value(ua.DataValue(False))
resp = self.read_('BooleanTest')
self.assertEqual('false', resp['Body']['Value']['Body'])
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 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
async def random_updater(random_node):
while True:
await asyncio.sleep(random.randint(1, 100) / 10) #<-------------
random_node.set_value(
ua.DataValue(
ua.Variant(random.randint(70, 90), ua.VariantType.UInt64)))
print(datetime.now(), "datachange")
def _send_state(self, state_num):
"""
Changes state to the specified number and sets "request" to True.
"""
dt = ua.DataValue(ua.Variant(state_num, ua.VariantType.Int16))
self.request_state_num.set_value(dt)
self.request.set_value(True)
def read_node_history(self, node_id, start, end, nb_values):
with self._lock:
_c_read = self._conn.cursor()
table = self._get_table_name(node_id)
start_time, end_time, order, limit = self._get_bounds(start, end, nb_values)
cont = None
results = []
# select values from the database; recreate UA Variant from binary
try:
for row in _c_read.execute('SELECT * FROM "{tn}" WHERE "SourceTimestamp" BETWEEN ? AND ? '
'ORDER BY "_Id" {dir} LIMIT ?'.format(tn=table, dir=order),
(start_time, end_time, limit,)):
# rebuild the data value object
dv = ua.DataValue(variant_from_binary(Buffer(row[6])))
dv.ServerTimestamp = row[1]
dv.SourceTimestamp = row[2]
dv.StatusCode = ua.StatusCode(row[3])
results.append(dv)
except sqlite3.Error as e:
self.logger.error('Historizing SQL Read Error for %s: %s', node_id, e)
if nb_values:
if len(results) > nb_values:
cont = results[nb_values].SourceTimestamp
results = results[:nb_values]
return results, cont
def Write_LS_INIWORD(self, AEquip, AWD):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.connect()
lsctrl = self.GetCtrlWord(int(AWD), 0, 0, 0, 0, 0, 0)
if AEquip == "LS1":
# self._nodels1 = self._client.get_node('ns = 2;s = SCADA.DO.TSET1')
self._nodels1.set_value(
ua.DataValue(ua.Variant(lsctrl, ua.VariantType.Int16)))
elif AEquip == "LS2":
# self._nodels2 = self._client.get_node('ns = 2;s = SCADA.DO.TSET2')
self._nodels2.set_value(
ua.DataValue(ua.Variant(lsctrl, ua.VariantType.Int16)))
except Exception as err:
print(err)
pass
def Equip_PLC_B_LS2Control(self, AEquip, AType):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.CHANGE_PLC_B_CTRL_WORD()
self._ls2_run = 0
self._ls2_stop = 0
self._ld2_run = 0
self._ld2_stop = 0
self._lqt2_run = 0
self._lqt2_stop = 0
if ((AEquip == "LS2") and (AType == "RUN")):
self._ls2_run = 1
elif ((AEquip == "LS2") and (AType == "STOP")):
self._ls2_stop = 1
elif ((AEquip == "LD2") and (AType == "RUN")):
self._ld2_run = 1
elif ((AEquip == "LD2") and (AType == "STOP")):
self._ld2_stop = 1
elif ((AEquip == "LQT2") and (AType == "RUN")):
self._lqt2_run = 1
elif ((AEquip == "LQT2") and (AType == "STOP")):
self._lqt2_stop = 1
ls2ctrl = self.GetCtrlWord(int(100), 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 Equip_LS1Control(self, AEquip, AType):
# client = Client('opc.tcp://127.0.0.1:49320')
try:
self.connect()
self._ls1_run = 0
self._ls1_stop = 0
self._ld1_run = 0
self._ld1_stop = 0
self._lqt1_run = 0
self._lqt1_stop = 0
if ((AEquip == "LS1") and (AType == "RUN")):
self._ls1_run = 1
elif ((AEquip == "LS1") and (AType == "STOP")):
self._ls1_stop = 1
elif ((AEquip == "LD1") and (AType == "RUN")):
self._ld1_run = 1
elif ((AEquip == "LD1") and (AType == "STOP")):
self._ld1_stop = 1
elif ((AEquip == "LQT1") and (AType == "RUN")):
self._lqt1_run = 1
elif ((AEquip == "LQT1") and (AType == "STOP")):
self._lqt1_stop = 1
ls1ctrl = self.GetCtrlWord(int(100), 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 add_device(self, dev_type_node, device, gate, inputs, outputs,
commands):
dev_node = self.objects.add_object(self.idx, device, dev_type_node)
self.devices[device] = dev_node
hs = redis_rtdb.hgetall(device)
for input in inputs:
input = _dict(input)
s = hs.get(input.name + "/value")
if s:
val = json.loads(s)
varid = '%d:' % self.idx + input.name
var = dev_node.get_child(varid)
if var:
datavalue = ua.DataValue(val[1])
datavalue.SourceTimestamp = datetime.datetime.utcfromtimestamp(
val[0])
#self.server.set_attribute_value(var.nodeid, datavalue)
#var.set_value(datavalue)
self.server.iserver.aspace._nodes[var.nodeid].attributes[
ua.AttributeIds.Value].value = datavalue
handle = self.server.create_subscription(500, OutputHandler(device))
output_nodes = []
for output in outputs:
output = _dict(output)
varid = '%d:' % self.idx + output.name
var = dev_node.get_child(varid)
if var:
output_nodes.append(var)
if len(output_nodes) > 0:
handle.subscribe_data_change(output_nodes)
self.devices_sub_handle[device] = handle
return
def set_value(self, node, value):
try :
node = self.opc_ua_client.get_node(node)
node.set_attribute(ua.AttributeIds.Value, ua.DataValue(value))
except Exception as e:
self.add_to_log_box("set_value error : {}".format(str(e)))
pass
def set_value(node, value):
if is_connected:
try:
tmp = opc_ua_client.get_node(node)
tmp.set_attribute(ua.AttributeIds.Value, ua.DataValue(value))
except Exception as e:
print(str(e))
def get_attribute_value(self, nodeid, attr):
with self._lock:
self.logger.debug("get attr val: %s %s", nodeid, attr)
if nodeid not in self._nodes:
dv = ua.DataValue()
dv.StatusCode = ua.StatusCode(ua.StatusCodes.BadNodeIdUnknown)
return dv
node = self._nodes[nodeid]
if attr not in node.attributes:
dv = ua.DataValue()
dv.StatusCode = ua.StatusCode(ua.StatusCodes.BadAttributeIdInvalid)
return dv
attval = node.attributes[attr]
if attval.value_callback:
return attval.value_callback()
return attval.value
def stop_machine(self):
self.node.set_attribute(ua.AttributeIds.Value, ua.DataValue(variant=ua.Variant(True)))
self.isStopFlag = self.node.get_value()
self.textBrowser.append('机器停机,停止检测！！！')
time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
self.textBrowser.append('时间:' + time)
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 set_array_dimensions(self, value):
"""
Set attribute ArrayDimensions of node
make sure it has the correct data type
"""
v = ua.Variant(value, ua.VariantType.UInt32)
self.set_attribute(ua.AttributeIds.ArrayDimensions, ua.DataValue(v))
def _add_node_attr(self, item, nodedata, name, vtype=None):
if item.SpecifiedAttributes & getattr(ua.NodeAttributesMask, name):
dv = ua.DataValue(ua.Variant(getattr(item, name), vtype))
dv.ServerTimestamp = datetime.utcnow()
dv.SourceTimestamp = datetime.utcnow()
nodedata.attributes[getattr(ua.AttributeIds,
name)] = AttributeValue(dv)
def read_node_history(self, node_id, start, end, nb_values):
with self._lock:
_c_read = self._conn.cursor()
order = "ASC"
if start is None or start == ua.DateTimeMinValue:
order = "DESC"
start = ua.DateTimeMinValue
if end is None or end == ua.DateTimeMinValue:
end = datetime.utcnow() + timedelta(days=1)
if start < end:
start_time = start.isoformat(' ')
end_time = end.isoformat(' ')
else:
order = "DESC"
start_time = end.isoformat(' ')
end_time = start.isoformat(' ')
if nb_values:
limit = nb_values + 1 # add 1 to the number of values for retrieving a continuation point
else:
limit = -1 # in SQLite a LIMIT of -1 returns all results
table = self._get_table_name(node_id)
cont = None
results = []
# select values from the database; recreate UA Variant from binary ORDER BY "ServerTimestamp" DESC
try:
for row in _c_read.execute(
'SELECT * FROM "{tn}" WHERE "ServerTimestamp" BETWEEN ? AND ? '
'ORDER BY "Id" {dir} LIMIT ?'.format(tn=table,
dir=order), (
start_time,
end_time,
limit,
)):
dv = ua.DataValue(ua.Variant.from_binary(Buffer(row[6])))
dv.ServerTimestamp = row[1]
dv.SourceTimestamp = row[2]
dv.StatusCode = ua.StatusCode(row[3])
results.append(dv)
except sqlite3.Error as e:
self.logger.error('Historizing SQL Read Error for %s: %s',
node_id, e)
if nb_values:
if start > ua.DateTimeMinValue and len(results) > nb_values:
cont = results[nb_values].ServerTimestamp
results = results[:nb_values]
return results, cont
def disable_history_data_change(self, node):
"""
Set attribute Historizing of node to False and stop storing data for history
"""
node.set_attribute(ua.AttributeIds.Historizing, ua.DataValue(False))
node.unset_attr_bit(ua.AttributeIds.AccessLevel, ua.AccessLevel.HistoryRead)
node.unset_attr_bit(ua.AttributeIds.UserAccessLevel, ua.AccessLevel.HistoryRead)
self.history_manager.dehistorize(node)
