beremiz

fix not saving location address from variable panel

2016-10-26, Andrey Skvortsov
deadfe7377e9
fix not saving location address from variable panel

this regression was introduced by commit 3518d10
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor
#based on the plcopen standard.
#
#Copyright (C) 2012: Edouard TISSERANT and Laurent BESSARD
#
#See COPYING file for copyrights details.
#
#This library is free software; you can redistribute it and/or
#modify it under the terms of the GNU General Public
#License as published by the Free Software Foundation; either
#version 2.1 of the License, or (at your option) any later version.
#
#This library is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
#General Public License for more details.
#
#You should have received a copy of the GNU General Public
#License along with this library; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
import numpy
import binascii
from graphics.DebugDataConsumer import DebugDataConsumer, TYPE_TRANSLATOR
#-------------------------------------------------------------------------------
# Constant for calculate CRC for string variables
#-------------------------------------------------------------------------------
STRING_CRC_SIZE = 8
STRING_CRC_MASK = 2 ** STRING_CRC_SIZE - 1
#-------------------------------------------------------------------------------
# Debug Variable Item Class
#-------------------------------------------------------------------------------
"""
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
"""
# Remove quote and double quote surrounding string value to get raw 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
def GetNearestData(self, tick, adjust):
"""
Return index of nearest data from tick given
@param tick: Tick where find nearest data
@param adjust: Constraint for data position from tick
-1: older than tick
1: newer than tick
0: doesn't matter
@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