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[idx][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 OrthogonalDataAndRange(self, start_tick, end_tick):

   176

        """

   177

        Return variable value 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

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

   181

                  min_value, max_value)

   182

        """

   183

        # Calculate min_value and max_value so that range size is greater

   184

        # than 1.0

   185

        if self.MinValue is not None and self.MaxValue is not None:

   186

            center = (self.MinValue + self.MaxValue) / 2.

   187

            range = max(1.0, self.MaxValue - self.MinValue)

   188

        else:

   189

            center = 0.5

   190

            range = 1.0

   191

        return (self.GetData(start_tick, end_tick), 

   192

                center - range * 0.55, center + range * 0.55)

   193

   194

    def ResetData(self):

   195

        """

   196

        Reset data stored when store data option enabled

   197

        """

   198

        if self.StoreData and self.IsNumVariable():

   199

            # Init table storing data

   200

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

   201

   202

            # Init table storing raw data if variable is strin

   203

            self.RawData = ([]

   204

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

   205

                            else None)

   206

   207

            # Init Value range variables

   208

            self.MinValue = None

   209

            self.MaxValue = None

   210

   211

        else:

   212

            self.Data = None

   213

   214

        # Init variable value

   215

        self.Value = ""

   216

   217

    def IsNumVariable(self):

   218

        """

   219

        Return if variable data type is numeric. String variables are

   220

        considered as numeric (string CRC)

   221

        @return: True if data type is numeric

   222

        """

   223

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

   224

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

   225

   226

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

   227

        """

   228

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

   229

        @param tick: PLC tick when value was captured

   230

        @param value: Value captured

   231

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

   232

        """

   233

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

   234

   235

        if self.Data is not None:

   236

            # String data value is CRC

   237

            num_value = (binascii.crc32(value) & STRING_CRC_MASK

   238

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

   239

                         else float(value))

   240

   241

            # Update variable range values

   242

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

   243

                             if self.MinValue is not None

   244

                             else num_value)

   245

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

   246

                             if self.MaxValue is not None

   247

                             else num_value)

   248

   249

            # Translate forced flag to float for storing in Data table

   250

            forced_value = float(forced)

   251

   252

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

   253

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

   254

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

   255

            # data third column

   256

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

   257

                raw_data = (value, forced_value)

   258

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

   259

                    extra_value = len(self.RawData)

   260

                    self.RawData.append(raw_data)

   261

                else:

   262

                    extra_value = len(self.RawData) - 1

   263

   264

            # In other case, data third column is forced flag

   265

            else:

   266

                extra_value = forced_value

   267

   268

            # Add New data to stored data table

   269

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

   270

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

   271

   272

            # Signal to debug variable panel to refresh

   273

            self.Parent.HasNewData = True

   274

   275

    def SetForced(self, forced):

   276

        """

   277

        Update Forced flag

   278

        @param forced: New forced flag

   279

        """

   280

        # Store forced flag

   281

        if self.Forced != forced:

   282

            self.Forced = forced

   283

   284

            # Signal to debug variable panel to refresh

   285

            self.Parent.HasNewData = True

   286

   287

    def SetValue(self, value):

   288

        """

   289

        Update value.

   290

        @param value: New value

   291

        """

   292

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

   293

        if (self.VariableType == "STRING" and

   294

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

   295

            self.VariableType == "WSTRING" and

   296

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

   297

            value = value[1:-1]

   298

   299

        # Store variable value

   300

        if self.Value != value:

   301

            self.Value = value

   302

   303

            # Signal to debug variable panel to refresh

   304

            self.Parent.HasNewData = True

   305

   306

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

   307

        """

   308

        Return current value or value and forced flag for tick given

   309

        @return: Current value or value and forced flag

   310

        """

   311

        # If tick given and stored data option enabled

   312

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

   313

   314

            # Return current value and forced flag if data empty

   315

            if len(self.Data) == 0:

   316

                return self.Value, self.IsForced()

   317

   318

            # Get index of nearest data from tick given

   319

            idx = self.GetNearestData(tick, 0)

   320

   321

            # Get value and forced flag at given index

   322

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

   323

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

   324

                            else self.Data[idx, 1:3]

   325

   326

            # Get raw value if asked

   327

            if not raw:

   328

                value = TYPE_TRANSLATOR.get(

   329

                        self.VariableType, str)(value)

   330

   331

            return value, forced

   332

   333

        # Return raw value if asked

   334

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

   335

            return TYPE_TRANSLATOR.get(

   336

                    self.VariableType, str)(self.Value)

   337

        return self.Value

   338

   339

    def GetNearestData(self, tick, adjust):

   340

        """

   341

        Return index of nearest data from tick given

   342

        @param tick: Tick where find nearest data

   343

        @param adjust: Constraint for data position from tick

   344

                       -1: older than tick

   345

                       1:  newer than tick

   346

                       0:  doesn't matter

   347

        @return: Index of nearest data

   348

        """

   349

        # Return immediately if data is empty

   350

        if self.Data is None:

   351

            return None

   352

   353

        # Extract data ticks

   354

        ticks = self.Data[:, 0]

   355

   356

        # Get nearest data from tick

   357

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

   358

   359

        # Adjust data index according to constraint

   360

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

   361

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

   362

            idx += adjust

   363

   364

        return idx