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

   235

    def NewValue(self, tick, value, forced=False):

   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

        """

   242

        DebugDataConsumer.NewValue(self, tick, value, forced, raw=None)

   243

   244

        if self.Data is not None:

   245

            # String data value is CRC

   246

            num_value = (binascii.crc32(value) & STRING_CRC_MASK

   247

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

   248

                         else float(value))

   249

   250

            # Update variable range values

   251

            self.MinValue = (min(self.MinValue, num_value)

   252

                             if self.MinValue is not None

   253

                             else num_value)

   254

            self.MaxValue = (max(self.MaxValue, num_value)

   255

                             if self.MaxValue is not None

   256

                             else num_value)

   257

   258

            # Translate forced flag to float for storing in Data table

   259

            forced_value = float(forced)

   260

   261

            # In the case of string variables, we store raw string value and

   262

            # forced flag in raw data table. Only changes in this two values

   263

            # are stored. Index to the corresponding raw value is stored in 

   264

            # data third column

   265

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

   266

                raw_data = (value, forced_value)

   267

                if len(self.RawData) == 0 or self.RawData[-1] != raw_data:

   268

                    extra_value = len(self.RawData)

   269

                    self.RawData.append(raw_data)

   270

                else:

   271

                    extra_value = len(self.RawData) - 1

   272

   273

            # In other case, data third column is forced flag

   274

            else:

   275

                extra_value = forced_value

   276

   277

            # Add New data to stored data table

   278

            self.Data = numpy.append(self.Data, 

   279

                    [[float(tick), num_value, extra_value]], axis=0)

   280

   281

            # Signal to debug variable panel to refresh

   282

            self.Parent.HasNewData = True

   283

   284

    def SetForced(self, forced):

   285

        """

   286

        Update Forced flag

   287

        @param forced: New forced flag

   288

        """

   289

        # Store forced flag

   290

        if self.Forced != forced:

   291

            self.Forced = forced

   292

   293

            # Signal to debug variable panel to refresh

   294

            self.Parent.HasNewData = True

   295

   296

    def SetValue(self, value):

   297

        """

   298

        Update value.

   299

        @param value: New value

   300

        """

   301

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

   302

        if (self.VariableType == "STRING" and

   303

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

   304

            self.VariableType == "WSTRING" and

   305

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

   306

            value = value[1:-1]

   307

   308

        # Store variable value

   309

        if self.Value != value:

   310

            self.Value = value

   311

   312

            # Signal to debug variable panel to refresh

   313

            self.Parent.HasNewData = True

   314

   315

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

   316

        """

   317

        Return current value or value and forced flag for tick given

   318

        @return: Current value or value and forced flag

   319

        """

   320

        # If tick given and stored data option enabled

   321

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

   322

   323

            # Return current value and forced flag if data empty

   324

            if len(self.Data) == 0:

   325

                return self.Value, self.IsForced()

   326

   327

            # Get index of nearest data from tick given

   328

            idx = self.GetNearestData(tick, 0)

   329

   330

            # Get value and forced flag at given index

   331

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

   332

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

   333

                            else self.Data[idx, 1:3]

   334

   335

            # Get raw value if asked

   336

            if not raw:

   337

                value = TYPE_TRANSLATOR.get(

   338

                        self.VariableType, str)(value)

   339

   340

            return value, forced

   341

   342

        # Return raw value if asked

   343

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

   344

            return TYPE_TRANSLATOR.get(

   345

                    self.VariableType, str)(self.Value)

   346

        return self.Value

   347

   348

    def GetNearestData(self, tick, adjust):

   349

        """

   350

        Return index of nearest data from tick given

   351

        @param tick: Tick where find nearest data

   352

        @param adjust: Constraint for data position from tick

   353

                       -1: older than tick

   354

                       1:  newer than tick

   355

                       0:  doesn't matter

   356

        @return: Index of nearest data

   357

        """

   358

        # Return immediately if data is empty

   359

        if self.Data is None:

   360

            return None

   361

   362

        # Extract data ticks

   363

        ticks = self.Data[:, 0]

   364

   365

        # Get nearest data from tick

   366

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

   367

   368

        # Adjust data index according to constraint

   369

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

   370

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

   371

            idx += adjust

   372

   373

        return idx