beremiz: comparison controls/DebugVariablePanel/DebugVariableItem.py

equal deleted inserted replaced

-:d51af006fa6b
+:64d8f52bc8c8
 Class that implements an element that consumes debug values for PLC variable and
 stores received values for displaying them in graphic panel or table
 """
 class DebugVariableItem(DebugDataConsumer):
 def __init__(self, parent, variable, store_data=False):
 """
 Constructor
 @param parent: Reference to debug variable panel
 @param variable: Path of variable to debug
 """
 DebugDataConsumer.__init__(self)
 self.Parent = parent
 self.Variable = variable
 self.StoreData = store_data
 # Get Variable data type
 self.RefreshVariableType()
 def __del__(self):
 """
 Destructor
 """
 # Reset reference to debug variable panel
 self.Parent = None
 def SetVariable(self, variable):
 """
 Set path of variable
 @param variable: Path of variable to debug
 """
 if self.Parent is not None and self.Variable != variable:
 # Store variable path
 self.Variable = variable
 # Get Variable data type
 self.RefreshVariableType()
 # Refresh debug variable panel
 self.Parent.RefreshView()
 def GetVariable(self, mask=None):
 """
 Return path of variable
 @param mask: Mask to apply to variable path [var_name, '*',...]
 @return: String containing masked variable path
 """
 # Apply mask to variable name
 if mask is not None:
 # '#' correspond to parts that are different between all items
 # Extract variable path parts
 parts = self.Variable.split('.')
 # Adjust mask size to size of variable path
 mask = mask + ['*'] * max(0, len(parts) - len(mask))
 # Store previous mask
 last = None
 # Init masked variable path
 variable = ""
 for m, p in zip(mask, parts):
 # Part is not masked, add part prefixed with '.' is previous
 # wasn't masked
 if m == '*':
 variable += ('.' if last == '*' else '') + p
 # Part is mask, add '..' if first or previous wasn't masked
 elif last is None or last == '*':
 variable += '..'
 last = m
 return variable
 return self.Variable
 def RefreshVariableType(self):
 """
 Get and store variable data type
 """
 self.VariableType = self.Parent.GetDataType(self.Variable)
 # Reset data stored
 self.ResetData()
 def GetVariableType(self):
 """
 Return variable data type
 @return: Variable data type
 """
 return self.VariableType
 def GetData(self, start_tick=None, end_tick=None):
 """
 Return data stored contained in given range
 @param start_tick: Start tick of given range (default None, first data)
 @param end_tick: end tick of given range (default None, last data)
 @return: Data as numpy.array([(tick, value, forced),...])
 """
 # Return immediately if data empty or none
 if self.Data is None or len(self.Data) == 0:
 return self.Data
 # Find nearest data outside given range indexes
 start_idx = (self.GetNearestData(start_tick, -1)
 if start_tick is not None
 else 0)
 end_idx = (self.GetNearestData(end_tick, 1)
 if end_tick is not None
 else len(self.Data))
 # Return data between indexes
 return self.Data[start_idx:end_idx]
 def GetRawValue(self, index):
 """
 Return raw value at given index for string variables
 @param index: Variable value index
 @return: Variable data type
 """
 if (self.VariableType in ["STRING", "WSTRING"] and
 index < len(self.RawData)):
 return self.RawData[index][0]
 return ""
 def GetValueRange(self):
 """
 Return variable value range
 @return: (minimum_value, maximum_value)
 """
 return self.MinValue, self.MaxValue
 def GetDataAndValueRange(self, start_tick, end_tick, full_range=True):
 """
 Return variable data and value range for a given tick range
 @param start_tick: Start tick of given range (default None, first data)
 @param end_tick: end tick of given range (default None, last data)
 @param full_range: Value range is calculated on whole data (False: only
 calculated on data in given range)
 @return: (numpy.array([(tick, value, forced),...]),
 min_value, max_value)
 """
 # Get data in given tick range
 data = self.GetData(start_tick, end_tick)
 # Value range is calculated on whole data
 if full_range:
 return data, self.MinValue, self.MaxValue
 # Check that data in given range is not empty
 values = data[:, 1]
 if len(values) > 0:
 # Return value range for data in given tick range
 return (data,
 data[numpy.argmin(values), 1],
 data[numpy.argmax(values), 1])
 # Return default values
 return data, None, None
 def ResetData(self):
 """
 Reset data stored when store data option enabled
 """
 if self.StoreData and self.IsNumVariable():
 # Init table storing data
 self.Data = numpy.array([]).reshape(0, 3)
 # Init table storing raw data if variable is strin
 self.RawData = ([]
 if self.VariableType in ["STRING", "WSTRING"]
 else None)
 # Init Value range variables
 self.MinValue = None
 self.MaxValue = None
 else:
 self.Data = None
 # Init variable value
 self.Value = ""
 def IsNumVariable(self):
 """
 Return if variable data type is numeric. String variables are
 considered as numeric (string CRC)
 @return: True if data type is numeric
 """
 return (self.Parent.IsNumType(self.VariableType) or
 self.VariableType in ["STRING", "WSTRING"])
 def NewValues(self, ticks, values):
 """
 Function called by debug thread when a new debug value is available
 @param tick: PLC tick when value was captured
 @param value: Value captured
 @param forced: Forced flag, True if value is forced (default: False)
 """
 DebugDataConsumer.NewValues(self, ticks[-1], values[-1], raw=None)
 if self.Data is not None:
 if self.VariableType in ["STRING", "WSTRING"]:
 last_raw_data = (self.RawData[-1]
 if len(self.RawData) > 0 else None)
 last_raw_data_idx = len(self.RawData) - 1
 data_values = []
 for tick, (value, forced) in zip(ticks, values):
 # Translate forced flag to float for storing in Data table
 forced_value = float(forced)
 # String data value is CRC
 num_value = (binascii.crc32(value) & STRING_CRC_MASK
 if self.VariableType in ["STRING", "WSTRING"]
 else float(value))
 # Update variable range values
 self.MinValue = (min(self.MinValue, num_value)
 if self.MinValue is not None
 else num_value)
 self.MaxValue = (max(self.MaxValue, num_value)
 if self.MaxValue is not None
 else num_value)
 # In the case of string variables, we store raw string value and
 # forced flag in raw data table. Only changes in this two values
 # are stored. Index to the corresponding raw value is stored in
 # data third column
 if self.VariableType in ["STRING", "WSTRING"]:
 raw_data = (value, forced_value)
 if len(self.RawData) == 0 or last_raw_data != raw_data:
 last_raw_data_idx += 1
 last_raw_data = raw_data
 self.RawData.append(raw_data)
 extra_value = last_raw_data_idx
 # In other case, data third column is forced flag
 else:
 extra_value = forced_value
 data_values.append(
 [float(tick), num_value, extra_value])
 # Add New data to stored data table
 self.Data = numpy.append(self.Data, data_values, axis=0)
 # Signal to debug variable panel to refresh
 self.Parent.HasNewData = True
 def SetForced(self, forced):
 """
 Update Forced flag
 @param forced: New forced flag
 """
 # Store forced flag
 if self.Forced != forced:
 self.Forced = forced
 # Signal to debug variable panel to refresh
 self.Parent.HasNewData = True
 def SetValue(self, value):
 """
 Update value.
 @param value: New value
 """
 if (self.VariableType == "STRING" and
 value.startswith("'") and value.endswith("'") or
 self.VariableType == "WSTRING" and
 value.startswith('"') and value.endswith('"')):
 value = value[1:-1]
 # Store variable value
 if self.Value != value:
 self.Value = value
 # Signal to debug variable panel to refresh
 self.Parent.HasNewData = True
 def GetValue(self, tick=None, raw=False):
 """
 Return current value or value and forced flag for tick given
 @return: Current value or value and forced flag
 """
 # If tick given and stored data option enabled
 if tick is not None and self.Data is not None:
 # Return current value and forced flag if data empty
 if len(self.Data) == 0:
 return self.Value, self.IsForced()
 # Get index of nearest data from tick given
 idx = self.GetNearestData(tick, 0)
 # Get value and forced flag at given index
 value, forced = self.RawData[int(self.Data[idx, 2])] \
 if self.VariableType in ["STRING", "WSTRING"] \
 else self.Data[idx, 1:3]
 # Get raw value if asked
 if not raw:
 value = TYPE_TRANSLATOR.get(
 self.VariableType, str)(value)
 return value, forced
 # Return raw value if asked
 if not raw and self.VariableType in ["STRING", "WSTRING"]:
 return TYPE_TRANSLATOR.get(
 self.VariableType, str)(self.Value)
 return self.Value
 @return: Index of nearest data
 """
 # Return immediately if data is empty
 if self.Data is None:
 return None
 # Extract data ticks
 ticks = self.Data[:, 0]
 # Get nearest data from tick
 idx = numpy.argmin(abs(ticks - tick))
 # Adjust data index according to constraint
 if (adjust < 0 and ticks[idx] > tick and idx > 0 or
 adjust > 0 and ticks[idx] < tick and idx < len(ticks)):
 idx += adjust
 return idx

changeset 1730	64d8f52bc8c8
parent 1571	486f94a8032c
child 1736	7e61baa047f0