1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2012: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

import numpy

    26

import binascii

    27

    28

from graphics.DebugDataConsumer import DebugDataConsumer, TYPE_TRANSLATOR

    29

    30

#-------------------------------------------------------------------------------

    31

#                 Constant for calculate CRC for string variables

    32

#-------------------------------------------------------------------------------

    33

    34

STRING_CRC_SIZE = 8

    35

STRING_CRC_MASK = 2 ** STRING_CRC_SIZE - 1

    36

    37

#-------------------------------------------------------------------------------

    38

#                          Debug Variable Item Class

    39

#-------------------------------------------------------------------------------

    40

    41

"""

    42

Class that implements an element that consumes debug values for PLC variable and

    43

stores received values for displaying them in graphic panel or table

    44

"""

    45

    46

class DebugVariableItem(DebugDataConsumer):

    47

    48

    def __init__(self, parent, variable, store_data=False):

    49

        """

    50

        Constructor

    51

        @param parent: Reference to debug variable panel

    52

        @param variable: Path of variable to debug

    53

        """

    54

        DebugDataConsumer.__init__(self)

    55

    56

        self.Parent = parent

    57

        self.Variable = variable

    58

        self.StoreData = store_data

    59

    60

        # Get Variable data type

    61

        self.RefreshVariableType()

    62

    63

    def __del__(self):

    64

        """

    65

        Destructor

    66

        """

    67

        # Reset reference to debug variable panel

    68

        self.Parent = None

    69

    70

    def SetVariable(self, variable):

    71

        """

    72

        Set path of variable 

    73

        @param variable: Path of variable to debug

    74

        """

    75

        if self.Parent is not None and self.Variable != variable:

    76

            # Store variable path

    77

            self.Variable = variable

    78

            # Get Variable data type

    79

            self.RefreshVariableType()

    80

    81

            # Refresh debug variable panel

    82

            self.Parent.RefreshView()

    83

    84

    def GetVariable(self, mask=None):

    85

        """

    86

        Return path of variable 

    87

        @param mask: Mask to apply to variable path [var_name, '*',...]

    88

        @return: String containing masked variable path

    89

        """

    90

        # Apply mask to variable name

    91

        if mask is not None:

    92

            # '#' correspond to parts that are different between all items

    93

    94

            # Extract variable path parts

    95

            parts = self.Variable.split('.')

    96

            # Adjust mask size to size of variable path

    97

            mask = mask + ['*'] * max(0, len(parts) - len(mask))

    98

    99

            # Store previous mask

   100

            last = None

   101

            # Init masked variable path

   102

            variable = ""

   103

   104

            for m, p in zip(mask, parts):

   105

                # Part is not masked, add part prefixed with '.' is previous

   106

                # wasn't masked

   107

                if m == '*':

   108

                    variable += ('.' if last == '*' else '') + p

   109

   110

                # Part is mask, add '..' if first or previous wasn't masked

   111

                elif last is None or last == '*':

   112

                    variable += '..'

   113

   114

                last = m

   115

   116

            return variable

   117

   118

        return self.Variable

   119

   120

    def RefreshVariableType(self):

   121

        """

   122

        Get and store variable data type

   123

        """

   124

        self.VariableType = self.Parent.GetDataType(self.Variable)

   125

        # Reset data stored

   126

        self.ResetData()

   127

   128

    def GetVariableType(self):

   129

        """

   130

        Return variable data type

   131

        @return: Variable data type

   132

        """

   133

        return self.VariableType

   134

   135

    def GetData(self, start_tick=None, end_tick=None):

   136

        """

   137

        Return data stored contained in given range

   138

        @param start_tick: Start tick of given range (default None, first data)

   139

        @param end_tick: end tick of given range (default None, last data)

   140

        @return: Data as numpy.array([(tick, value, forced),...])

   141

        """

   142

        # Return immediately if data empty or none

   143

        if self.Data is None or len(self.Data) == 0:

   144

            return self.Data

   145

   146

        # Find nearest data outside given range indexes

   147

        start_idx = (self.GetNearestData(start_tick, -1)

   148

                     if start_tick is not None

   149

                     else 0)

   150

        end_idx = (self.GetNearestData(end_tick, 1)

   151

                   if end_tick is not None

   152

                   else len(self.Data))

   153

   154

        # Return data between indexes

   155

        return self.Data[start_idx:end_idx]

   156

   157

    def GetRawValue(self, index):

   158

        """

   159

        Return raw value at given index for string variables

   160

        @param index: Variable value index

   161

        @return: Variable data type

   162

        """

   163

        if (self.VariableType in ["STRING", "WSTRING"] and

   164

            index < len(self.RawData)):

   165

            return self.RawData[index][0]

   166

        return ""

   167

   168

    def GetValueRange(self):

   169

        """

   170

        Return variable value range

   171

        @return: (minimum_value, maximum_value)

   172

        """

   173

        return self.MinValue, self.MaxValue

   174

   175

    def GetDataAndValueRange(self, start_tick, end_tick, full_range=True):

   176

        """

   177

        Return variable data and value range for a given tick range

   178

        @param start_tick: Start tick of given range (default None, first data)

   179

        @param end_tick: end tick of given range (default None, last data)

   180

        @param full_range: Value range is calculated on whole data (False: only

   181

        calculated on data in given range)

   182

        @return: (numpy.array([(tick, value, forced),...]), 

   183

                  min_value, max_value)

   184

        """

   185

        # Get data in given tick range

   186

        data = self.GetData(start_tick, end_tick)

   187

   188

        # Value range is calculated on whole data

   189

        if full_range:

   190

            return data, self.MinValue, self.MaxValue

   191

   192

        # Check that data in given range is not empty

   193

        values = data[:, 1]

   194

        if len(values) > 0:

   195

            # Return value range for data in given tick range

   196

            return (data,

   197

                    data[numpy.argmin(values), 1],

   198

                    data[numpy.argmax(values), 1])

   199

   200

        # Return default values

   201

        return data, None, None

   202

   203

    def ResetData(self):

   204

        """

   205

        Reset data stored when store data option enabled

   206

        """

   207

        if self.StoreData and self.IsNumVariable():

   208

            # Init table storing data

   209

            self.Data = numpy.array([]).reshape(0, 3)

   210

   211

            # Init table storing raw data if variable is strin

   212

            self.RawData = ([]

   213

                            if self.VariableType in ["STRING", "WSTRING"]

   214

                            else None)

   215

   216

            # Init Value range variables

   217

            self.MinValue = None

   218

            self.MaxValue = None

   219

   220

        else:

   221

            self.Data = None

   222

   223

        # Init variable value

   224

        self.Value = ""

   225

   226

    def IsNumVariable(self):

   227

        """

   228

        Return if variable data type is numeric. String variables are

   229

        considered as numeric (string CRC)

   230

        @return: True if data type is numeric

   231

        """

   232

        return (self.Parent.IsNumType(self.VariableType) or 

   233

                self.VariableType in ["STRING", "WSTRING"])

   234

   236

        """

   237

        Function called by debug thread when a new debug value is available

   238

        @param tick: PLC tick when value was captured

   239

        @param value: Value captured

   240

        @param forced: Forced flag, True if value is forced (default: False)

   241

        """

   243

   244

        if self.Data is not None:

   251

            # Translate forced flag to float for storing in Data table

   252

            forced_value = float(forced)

   253

   283

                else:

   288

   289

            # Add New data to stored data table

   292

            # Signal to debug variable panel to refresh

   293

            self.Parent.HasNewData = True

   294

   295

    def SetForced(self, forced):

   296

        """

   297

        Update Forced flag

   298

        @param forced: New forced flag

   299

        """

   300

        # Store forced flag

   301

        if self.Forced != forced:

   302

            self.Forced = forced

   303

   304

            # Signal to debug variable panel to refresh

   305

            self.Parent.HasNewData = True

   306

   307

    def SetValue(self, value):

   308

        """

   309

        Update value.

   310

        @param value: New value

   311

        """

   312

        # Remove quote and double quote surrounding string value to get raw value

   313

        if (self.VariableType == "STRING" and

   314

            value.startswith("'") and value.endswith("'") or

   315

            self.VariableType == "WSTRING" and

   316

            value.startswith('"') and value.endswith('"')):

   317

            value = value[1:-1]

   318

   319

        # Store variable value

   320

        if self.Value != value:

   321

            self.Value = value

   322

   323

            # Signal to debug variable panel to refresh

   324

            self.Parent.HasNewData = True

   325

   326

    def GetValue(self, tick=None, raw=False):

   327

        """

   328

        Return current value or value and forced flag for tick given

   329

        @return: Current value or value and forced flag

   330

        """

   331

        # If tick given and stored data option enabled

   332

        if tick is not None and self.Data is not None:

   333

   334

            # Return current value and forced flag if data empty

   335

            if len(self.Data) == 0:

   336

                return self.Value, self.IsForced()

   337

   338

            # Get index of nearest data from tick given

   339

            idx = self.GetNearestData(tick, 0)

   340

   341

            # Get value and forced flag at given index

   342

            value, forced = self.RawData[int(self.Data[idx, 2])] \

   343

                            if self.VariableType in ["STRING", "WSTRING"] \

   344

                            else self.Data[idx, 1:3]

   345

   346

            # Get raw value if asked

   347

            if not raw:

   348

                value = TYPE_TRANSLATOR.get(

   349

                        self.VariableType, str)(value)

   350

   351

            return value, forced

   352

   353

        # Return raw value if asked

   354

        if not raw and self.VariableType in ["STRING", "WSTRING"]:

   355

            return TYPE_TRANSLATOR.get(

   356

                    self.VariableType, str)(self.Value)

   357

        return self.Value

   358

   359

    def GetNearestData(self, tick, adjust):

   360

        """

   361

        Return index of nearest data from tick given

   362

        @param tick: Tick where find nearest data

   363

        @param adjust: Constraint for data position from tick

   364

                       -1: older than tick

   365

                       1:  newer than tick

   366

                       0:  doesn't matter

   367

        @return: Index of nearest data

   368

        """

   369

        # Return immediately if data is empty

   370

        if self.Data is None:

   371

            return None

   372

   373

        # Extract data ticks

   374

        ticks = self.Data[:, 0]

   375

   376

        # Get nearest data from tick

   377

        idx = numpy.argmin(abs(ticks - tick))

   378

   379

        # Adjust data index according to constraint

   380

        if (adjust < 0 and ticks[idx] > tick and idx > 0 or

   381

            adjust > 0 and ticks[idx] < tick and idx < len(ticks)):

   382

            idx += adjust

   383

   384

        return idx