def _modify_monitored_item_request(self, new_queuesize, new_samp_time, mod_filter, client_handle):
req_params = ua.MonitoringParameters()
with self._lock:
req_params.ClientHandle = client_handle
req_params.QueueSize = new_queuesize
req_params.Filter = mod_filter
req_params.SamplingInterval = new_samp_time
return req_params
def create_monitored_items(sub, dirty_nodes, attr):
mirs = []
for dirty_node in dirty_nodes:
try:
node_var = Node(sub.server, NodeId().from_string(dirty_node["node"]))
rv = ua.ReadValueId()
rv.NodeId = node_var.nodeid
rv.AttributeId = attr
# rv.IndexRange //We leave it null, then the entire array is returned
mparams = ua.MonitoringParameters()
with sub._lock:
sub._client_handle += 1
mparams.ClientHandle = sub._client_handle
mparams.SamplingInterval = dirty_node["samplingInterval"]
mparams.QueueSize = dirty_node["queueSize"]
mparams.DiscardOldest = dirty_node["queueDiscardOldest"] == "True"
if dirty_node["filter"] != "None":
try:
mfilter = DataChangeFilter()
#DataChangeTrigger(0) = Status, DataChangeTrigger(1) = StatusValue, DataChangeTrigger(2) = StatusValueTimestamp
mfilter.Trigger = DataChangeTrigger[dirty_node["filter"]["Trigger"]]
# DeadbandType(0) = None, DeadbandType(1) = Absolute, DeadbandType(2) = Percent
mfilter.DeadbandType = DeadbandType[dirty_node["filter"]["DeadbandType"]]
mfilter.DeadbandValue = dirty_node["filter"]["DeadbandValue"]
except:
mfilter = None
print(f"\n\nWARNING: Can't apply filter on node {dirty_node['node']}")
else:
mfilter = None
if mfilter:
mparams.Filter = mfilter
mir = ua.MonitoredItemCreateRequest()
mir.ItemToMonitor = rv
mir.MonitoringMode = ua.MonitoringMode.Disabled if dirty_node["monitoringMode"] == "Disabled" else ua.MonitoringMode.Sampling if dirty_node["monitoringMode"] == "Sampling" else ua.MonitoringMode.Reporting
mir.RequestedParameters = mparams
mirs.append(mir)
except:
print("\nUnable to create monitored item for node {dirty_node['node']}")
mids, results = sub_monitored_items_creation(sub, mirs)
for i, r in enumerate(results):
if dirty_node["samplingInterval"] != r.RevisedSamplingInterval or dirty_node["queueSize"] != r.RevisedQueueSize:
print(f"\nServer has changed monitored item properties for node {dirty_node['node']}")
print(f"Monitored item id: {r.MonitoredItemId}")
print(f"Revised SamplingInterval: {r.RevisedSamplingInterval}")
print(f"Revised QueueSize: {r.RevisedQueueSize}")
print(f"Filter Result: {r.FilterResult}\n")
return mids
def make_monitored_item_request(self, subscription, node, attr, sampling_interval, client_handle, filter, queuesize, discard_oldest):
rv = ua.ReadValueId()
rv.NodeId = node.nodeid
rv.AttributeId = attr
mparams = ua.MonitoringParameters()
with subscription._lock:
subscription._client_handle = client_handle
mparams.ClientHandle = subscription._client_handle
mparams.SamplingInterval = sampling_interval
mparams.QueueSize = queuesize
mparams.DiscardOldest = discard_oldest
if filter:
mparams.Filter = filter
mir = ua.MonitoredItemCreateRequest() #stack request
mir.ItemToMonitor = rv
mir.MonitoringMode = ua.MonitoringMode.Reporting
mir.RequestedParameters = mparams
return mir
def _make_monitored_item_request(self, node, attr, mfilter, queuesize):
rv = ua.ReadValueId()
rv.NodeId = node.nodeid
rv.AttributeId = attr
# rv.IndexRange //We leave it null, then the entire array is returned
mparams = ua.MonitoringParameters()
with self._lock:
self._client_handle += 1
mparams.ClientHandle = self._client_handle
mparams.SamplingInterval = self.parameters.RequestedPublishingInterval
mparams.QueueSize = queuesize
mparams.DiscardOldest = True
if mfilter:
mparams.Filter = mfilter
mir = ua.MonitoredItemCreateRequest()
mir.ItemToMonitor = rv
mir.MonitoringMode = ua.MonitoringMode.Reporting
mir.RequestedParameters = mparams
return mir
def _subscribe(self, node, attr, mfilter=None, queuesize=0):
rv = ua.ReadValueId()
rv.NodeId = node.nodeid
rv.AttributeId = attr
# rv.IndexRange //We leave it null, then the entire array is returned
mparams = ua.MonitoringParameters()
self._client_handle += 1
mparams.ClientHandle = self._client_handle
mparams.SamplingInterval = self.parameters.RequestedPublishingInterval
mparams.QueueSize = queuesize
mparams.DiscardOldest = True
if mfilter:
mparams.Filter = mfilter
mir = ua.MonitoredItemCreateRequest()
mir.ItemToMonitor = rv
mir.MonitoringMode = ua.MonitoringMode.Reporting
mir.RequestedParameters = mparams
params = ua.CreateMonitoredItemsParameters()
params.SubscriptionId = self.subscription_id
params.ItemsToCreate.append(mir)
params.TimestampsToReturn = ua.TimestampsToReturn.Neither
with self._lock:
results = self.server.create_monitored_items(params)
result = results[0]
result.StatusCode.check()
data = SubscriptionItemData()
data.client_handle = mparams.ClientHandle
data.node = node
data.attribute = attr
data.server_handle = result.MonitoredItemId
data.mfilter = ua.downcast_extobject(result.FilterResult)
self._monitoreditems_map[mparams.ClientHandle] = data
return result.MonitoredItemId
def create_monitored_items(self, nodes, index):
monitored_items = []
if not isinstance(nodes, list):
nodes = [nodes]
for node in nodes:
# Set item to monitor
rv = ua.ReadValueId()
rv.NodeId = node.nodeid
rv.AttributeId = ua.AttributeIds.Value
# Set monitoring parameters
mparams = ua.MonitoringParameters()
self._client_handle += 1
mparams.ClientHandle = self._client_handle
mparams.SamplingInterval = self.samplingInterval
mparams.QueueSize = self.queueSize
mparams.DiscardOldest = self.discardOldest
# Create monitored item filter
if self.dataChangeFilter:
mfilter = ua.DataChangeFilter()
mfilter.Trigger = ua.DataChangeTrigger(self.dataChangeTrigger)
if self.deadbandType == ua.DeadbandType.Absolute:
if node.get_data_value(
).Value.VariantType in self.numericTypes:
mfilter.DeadbandType = self.deadbandType
mfilter.DeadbandValue = self.deadbandValue # absolute float value or from 0 to 100 for percentage deadband
else:
self.deadbandType = ua.DeadbandType.None_
mfilter.DeadbandType = self.deadbandType
elif self.deadbandType == ua.DeadbandType.Percent:
has_EURange = False
if node.get_type_definition(
).Identifier == ua.object_ids.ObjectIds.AnalogItemType:
# Get node properties
descriptions = node.get_references(
ua.ObjectIds.HasProperty,
ua.BrowseDirection.Forward, ua.NodeClass.Variable,
False)
for desc in descriptions:
if desc.BrowseName.Name == "EURange" and self.get_node(
desc.NodeId).get_value() is not None:
has_EURange = True
if has_EURange:
mfilter.DeadbandType = self.deadbandType
mfilter.DeadbandValue = self.deadbandValue # absolute float value or from 0 to 100 for percentage deadband
else:
self.deadbandType = ua.DeadbandType.None_
mfilter.DeadbandType = self.deadbandType
else:
mfilter = None
mparams.Filter = mfilter
# Create monitored item request
mir = ua.MonitoredItemCreateRequest()
mir.ItemToMonitor = rv
mir.MonitoringMode = ua.MonitoringMode.Reporting
mir.RequestedParameters = mparams
# Append to list
monitored_items.append(mir)
sub, monitored_items_handles = self._datachange_subs[index]
handles = sub.create_monitored_items(monitored_items)
for i in range(len(handles)):
handle = handles[i]
if type(handle) == ua.StatusCode:
handle.check()
monitored_items_handles[nodes[i].nodeid] = handle
