1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

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

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

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

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

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

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

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

    22

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

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

from __future__ import absolute_import

    27

from datetime import timedelta

    28

import binascii

    29

import numpy as np

    30

from graphics.DebugDataConsumer import DebugDataConsumer, TYPE_TRANSLATOR

    31

from controls.DebugVariablePanel.RingBuffer import RingBuffer

    32

    33

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

    34

#                 Constant for calculate CRC for string variables

    35

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

    36

    37

STRING_CRC_SIZE = 8

    38

STRING_CRC_MASK = 2 ** STRING_CRC_SIZE - 1

    39

    40

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

    41

#                          Debug Variable Item Class

    42

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

    43

    44

    45

class DebugVariableItem(DebugDataConsumer):

    46

    """

    47

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

    48

    stores received values for displaying them in graphic panel or table

    49

    """

    50

    51

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

    52

        """

    53

        Constructor

    54

        @param parent: Reference to debug variable panel

    55

        @param variable: Path of variable to debug

    56

        """

    57

        DebugDataConsumer.__init__(self)

    58

    59

        self.Parent = parent

    60

        self.Variable = variable

    61

        self.StoreData = store_data

    62

    63

        # Get Variable data type

    64

        self.RefreshVariableType()

    65

    66

    def __del__(self):

    67

        """

    68

        Destructor

    69

        """

    70

        # Reset reference to debug variable panel

    71

        self.Parent = None

    72

    73

    def SetVariable(self, variable):

    74

        """

    75

        Set path of variable

    76

        @param variable: Path of variable to debug

    77

        """

    78

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

    79

            # Store variable path

    80

            self.Variable = variable

    81

            # Get Variable data type

    82

            self.RefreshVariableType()

    83

    84

            # Refresh debug variable panel

    85

            self.Parent.RefreshView()

    86

    87

    def GetVariable(self, mask=None):

    88

        """

    89

        Return path of variable

    90

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

    91

        @return: String containing masked variable path

    92

        """

    93

        # Apply mask to variable name

    94

        if mask is not None:

    95

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

    96

    97

            # Extract variable path parts

    98

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

    99

            # Adjust mask size to size of variable path

   100

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

   101

   102

            # Store previous mask

   103

            last = None

   104

            # Init masked variable path

   105

            variable = ""

   106

   107

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

   108

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

   109

                # wasn't masked

   110

                if m == '*':

   111

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

   112

   113

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

   114

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

   115

                    variable += '..'

   116

   117

                last = m

   118

   119

            return variable

   120

   121

        return self.Variable

   122

   123

    def RefreshVariableType(self):

   124

        """

   125

        Get and store variable data type

   126

        """

   127

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

   128

        # Reset data stored

   129

        self.ResetData()

   130

   131

    def GetVariableType(self):

   132

        """

   133

        Return variable data type

   134

        @return: Variable data type

   135

        """

   136

        return self.VariableType

   137

   138

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

   139

        """

   140

        Return data stored contained in given range

   141

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

   142

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

   143

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

   144

        """

   145

        # Return immediately if data empty or none

   146

        if self.Data is None or self.Data.count == 0:

   147

            return None

   148

   149

        # Find nearest data outside given range indexes

   150

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

   151

                     if start_tick is not None

   152

                     else 0)

   153

        end_idx = (self.GetNearestData(end_tick, 1)

   154

                   if end_tick is not None

   155

                   else self.Data.count)

   156

   157

        # Return data between indexes

   158

        return self.Data.view[start_idx:end_idx]

   159

   160

    def GetRawValue(self, index):

   161

        """

   162

        Return raw value at given index for string variables

   163

        @param index: Variable value index

   164

        @return: Variable data type

   165

        """

   166

        if self.VariableType in ["STRING", "WSTRING"] and index < len(self.RawData):

   167

            return self.RawData[index][0]

   168

        return ""

   169

   170

    def GetValueRange(self):

   171

        """

   172

        Return variable value range

   173

        @return: (minimum_value, maximum_value)

   174

        """

   175

        return self.MinValue, self.MaxValue

   176

   177

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

   178

        """

   179

        Return variable data and value range for a given tick range

   180

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

   181

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

   182

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

   183

        calculated on data in given range)

   184

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

   185

                  min_value, max_value)

   186

        """

   187

        # Get data in given tick range

   188

        data = self.GetData(start_tick, end_tick)

   189

   190

        if data is None:

   191

            return None, None, None

   192

   193

        # Value range is calculated on whole data

   194

        if full_range:

   195

            return data, self.MinValue, self.MaxValue

   196

   197

        # Check that data in given range is not empty

   198

        values = data[:, 1]

   199

        if len(values) > 0:

   200

            # Return value range for data in given tick range

   201

            return (data,

   202

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

   203

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

   204

   205

        # Return default values

   206

        return data, None, None

   207

   208

    def ResetData(self):

   209

        """

   210

        Reset data stored when store data option enabled

   211

        """

   212

        if self.StoreData and self.IsNumVariable():

   213

            # Init table storing data

   214

            self.Data = RingBuffer(3)

   215

   216

            # Init table storing raw data if variable is strin

   217

            self.RawData = ([]

   218

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

   219

                            else None)

   220

   221

            # Init Value range variables

   222

            self.MinValue = None

   223

            self.MaxValue = None

   224

   225

        else:

   226

            self.Data = None

   227

            self.MinValue = None

   228

            self.MaxValue = None

   229

        # Init variable value

   230

        self.Value = ""

   231

   232

    def IsNumVariable(self):

   233

        """

   234

        Return if variable data type is numeric. String variables are

   235

        considered as numeric (string CRC). Time variables are considered

   236

        as number of seconds

   237

        @return: True if data type is numeric

   238

        """

   239

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

   240

                self.VariableType in ["STRING", "WSTRING", "TIME", "TOD", "DT", "DATE"])

   241

   242

    def NewValues(self, ticks, values):

   243

        """

   244

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

   245

        @param tick: PLC tick when value was captured

   246

        @param value: Value captured

   247

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

   248

        """

   249

        DebugDataConsumer.NewValues(self, ticks[-1], values[-1], raw=None)

   250

   251

        if self.Data is not None:

   252

   253

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

   254

                last_raw_data = (self.RawData[-1]

   255

                                 if len(self.RawData) > 0 else None)

   256

                last_raw_data_idx = len(self.RawData) - 1

   257

   258

            data_values = []

   259

            for tick, (value, forced) in zip(ticks, values):

   260

                # Translate forced flag to float for storing in Data table

   261

                forced_value = float(forced)

   262

   263

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

   264

                    # String data value is CRC

   265

                    num_value = (binascii.crc32(value) & STRING_CRC_MASK)

   266

                elif self.VariableType in ["TIME", "TOD", "DT", "DATE"]:

   267

                    # Numeric value of time type variables

   268

                    # is represented in seconds

   269

                    num_value = float(value.total_seconds())

   270

                else:

   271

                    num_value = float(value)

   272

   273

                # Update variable range values

   274

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

   275

                                 if self.MinValue is not None

   276

                                 else num_value)

   277

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

   278

                                 if self.MaxValue is not None

   279

                                 else num_value)

   280

   281

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

   282

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

   283

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

   284

                # data third column

   285

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

   286

                    raw_data = (value, forced_value)

   287

                    if len(self.RawData) == 0 or last_raw_data != raw_data:

   288

                        last_raw_data_idx += 1

   289

                        last_raw_data = raw_data

   290

                        self.RawData.append(raw_data)

   291

                    extra_value = last_raw_data_idx

   292

   293

                # In other case, data third column is forced flag

   294

                else:

   295

                    extra_value = forced_value

   296

   297

                data_values.append(

   298

                    [float(tick), num_value, extra_value])

   299

   300

            # Add New data to stored data table

   301

            self.Data.append(data_values)

   302

   303

            # Signal to debug variable panel to refresh

   304

            self.Parent.HasNewData = True

   305

   306

    def SetForced(self, forced):

   307

        """

   308

        Update Forced flag

   309

        @param forced: New forced flag

   310

        """

   311

        # Store forced flag

   312

        if self.Forced != forced:

   313

            self.Forced = forced

   314

   315

            # Signal to debug variable panel to refresh

   316

            self.Parent.HasNewData = True

   317

   318

    def SetValue(self, value):

   319

        """

   320

        Update value.

   321

        @param value: New value

   322

        """

   323

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

   324

        if self.VariableType == "STRING" and value.startswith("'") and value.endswith("'") or \

   325

           self.VariableType == "WSTRING" and value.startswith('"') and value.endswith('"'):

   326

            value = value[1:-1]

   327

   328

        # Store variable value

   329

        if self.Value != value:

   330

            self.Value = value

   331

   332

            # Signal to debug variable panel to refresh

   333

            self.Parent.HasNewData = True

   334

   335

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

   336

        """

   337

        Return current value or value and forced flag for tick given

   338

        @return: Current value or value and forced flag

   339

        """

   340

        # If tick given and stored data option enabled

   341

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

   342

   343

            # Return current value and forced flag if data empty

   344

            if self.Data.count == 0:

   345

                return self.Value, self.IsForced()

   346

   347

            # Get index of nearest data from tick given

   348

            idx = self.GetNearestData(tick, 0)

   349

   350

            # Get value and forced flag at given index

   351

            value, forced = \

   352

                self.RawData[int(self.Data.view[idx, 2])] \

   353

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

   354

                else self.Data.view[idx, 1:3]

   355

   356

            if self.VariableType in ["TIME", "TOD", "DT", "DATE"]:

   357

                value = timedelta(seconds=value)

   358

   359

            # Get raw value if asked

   360

            if not raw:

   361

                value = TYPE_TRANSLATOR.get(

   362

                    self.VariableType, str)(value)

   363

   364

            return value, forced

   365

   366

        # Return raw value if asked

   367

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

   368

            return TYPE_TRANSLATOR.get(

   369

                self.VariableType, str)(self.Value)

   370

        return self.Value

   371

   372

    def GetNearestData(self, tick, adjust):

   373

        """

   374

        Return index of nearest data from tick given

   375

        @param tick: Tick where find nearest data

   376

        @param adjust: Constraint for data position from tick

   377

                       -1: older than tick

   378

                       1:  newer than tick

   379

                       0:  doesn't matter

   380

        @return: Index of nearest data

   381

        """

   382

        # Return immediately if data is empty

   383

        if self.Data is None:

   384

            return None

   385

   386

        # Extract data ticks

   387

        ticks = self.Data.view[:, 0]

   388

   389

        # Get nearest data from tick

   390

        idx = min(np.searchsorted(ticks, tick), self.Data.count - 1)

   391

   392

        # Adjust data index according to constraint

   393

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

   394

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

   395

            idx += adjust

   396

   397

        return idx