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

from types import TupleType, ListType, FloatType

    26

from time import time as gettime

    27

import math

    28

import numpy

    29

import binascii

    30

    31

import wx

    32

import wx.lib.buttons

    33

    34

try:

    35

    import matplotlib

    36

    matplotlib.use('WX')

    37

    import matplotlib.pyplot

    38

    from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    39

    from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    40

    from matplotlib.backends.backend_agg import FigureCanvasAgg

    41

    from mpl_toolkits.mplot3d import Axes3D

    43

    USE_MPL = True

    44

except:

    45

    USE_MPL = False

    46

    47

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    48

from controls import CustomGrid, CustomTable

    49

from dialogs.ForceVariableDialog import ForceVariableDialog

    50

from util.BitmapLibrary import GetBitmap

    51

    52

def AppendMenu(parent, help, id, kind, text):

    53

    parent.Append(help=help, id=id, kind=kind, text=text)

    54

    55

def GetDebugVariablesTableColnames():

    56

    _ = lambda x : x

    57

    return [_("Variable"), _("Value")]

    58

    59

CRC_SIZE = 8

    60

CRC_MASK = 2 ** CRC_SIZE - 1

    61

    62

class VariableTableItem(DebugDataConsumer):

    63

    64

    def __init__(self, parent, variable):

    65

        DebugDataConsumer.__init__(self)

    66

        self.Parent = parent

    67

        self.Variable = variable

    68

        self.RefreshVariableType()

    69

        self.Value = ""

    70

    71

    def __del__(self):

    72

        self.Parent = None

    73

    74

    def SetVariable(self, variable):

    75

        if self.Parent and self.Variable != variable:

    76

            self.Variable = variable

    77

            self.RefreshVariableType()

    78

            self.Parent.RefreshView()

    79

    80

    def GetVariable(self, mask=None):

    81

        variable = self.Variable

    82

        if mask is not None:

    83

            parts = variable.split('.')

    84

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

    85

            last = None

    86

            variable = ""

    87

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

    88

                if m == '*':

    89

                    if last == '*':

    90

                        variable += '.'

    91

                    variable += v

    92

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

    93

                    variable += '..'

    94

                last = m

    95

        return variable

    96

    97

    def RefreshVariableType(self):

    98

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

    99

        if USE_MPL:

   100

            self.ResetData()

   101

   102

    def GetVariableType(self):

   103

        return self.VariableType

   104

   105

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

   106

        if USE_MPL and self.IsNumVariable():

   107

            if len(self.Data) == 0:

   108

                return self.Data

   109

   110

            start_idx = end_idx = None

   111

            if start_tick is not None:

   112

                start_idx = self.GetNearestData(start_tick, -1)

   113

            if end_tick is not None:

   114

                end_idx = self.GetNearestData(end_tick, 1)

   115

            if start_idx is None:

   116

                start_idx = 0

   117

            if end_idx is not None:

   118

                return self.Data[start_idx:end_idx + 1]

   119

            else:

   120

                return self.Data[start_idx:]

   121

   122

        return None

   123

   124

    def GetRawValue(self, idx):

   125

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

   126

            return self.RawData[idx][0]

   127

        return ""

   128

   129

    def GetRange(self):

   130

        return self.MinValue, self.MaxValue

   131

   132

    def ResetData(self):

   133

        if self.IsNumVariable():

   134

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

   135

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

   136

                self.RawData = []

   137

            self.MinValue = None

   138

            self.MaxValue = None

   139

        else:

   140

            self.Data = None

   141

   142

    def IsNumVariable(self):

   143

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

   144

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

   145

   146

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

   147

        if USE_MPL and self.IsNumVariable():

   148

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

   149

                num_value = binascii.crc32(value) & CRC_MASK

   150

            else:

   151

                num_value = float(value)

   152

            if self.MinValue is None:

   153

                self.MinValue = num_value

   154

            else:

   155

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

   156

            if self.MaxValue is None:

   157

                self.MaxValue = num_value

   158

            else:

   159

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

   160

            forced_value = float(forced)

   161

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

   162

                raw_data = (value, forced_value)

   163

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

   164

                    extra_value = len(self.RawData)

   165

                    self.RawData.append(raw_data)

   166

                else:

   167

                    extra_value = len(self.RawData) - 1

   168

            else:

   169

                extra_value = forced_value

   170

            self.Data = numpy.append(self.Data, [[float(tick), num_value, extra_value]], axis=0)

   171

            self.Parent.HasNewData = True

   172

        DebugDataConsumer.NewValue(self, tick, value, forced)

   173

   174

    def SetForced(self, forced):

   175

        if self.Forced != forced:

   176

            self.Forced = forced

   177

            self.Parent.HasNewData = True

   178

   179

    def SetValue(self, value):

   180

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

   181

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

   182

            value = value[1:-1]

   183

        if self.Value != value:

   184

            self.Value = value

   185

            self.Parent.HasNewData = True

   186

   187

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

   205

        elif not raw:

   206

            if self.VariableType == "STRING":

   207

                return "'%s'" % self.Value

   208

            elif self.VariableType == "WSTRING":

   209

                return '"%s"' % self.Value

   210

            elif isinstance(self.Value, FloatType):

   211

                return "%.6g" % self.Value

   212

        return self.Value

   213

   214

    def GetNearestData(self, tick, adjust):

   215

        if USE_MPL and self.IsNumVariable():

   216

            ticks = self.Data[:, 0]

   217

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

   218

            if adjust == -1 and ticks[new_cursor] > tick and new_cursor > 0:

   219

                new_cursor -= 1

   220

            elif adjust == 1 and ticks[new_cursor] < tick and new_cursor < len(ticks):

   221

                new_cursor += 1

   222

            return new_cursor

   223

        return None

   224

   225

class DebugVariableTable(CustomTable):

   226

   227

    def GetValue(self, row, col):

   228

        if row < self.GetNumberRows():

   229

            return self.GetValueByName(row, self.GetColLabelValue(col, False))

   230

        return ""

   231

   232

    def SetValue(self, row, col, value):

   233

        if col < len(self.colnames):

   234

            self.SetValueByName(row, self.GetColLabelValue(col, False), value)

   235

   236

    def GetValueByName(self, row, colname):

   237

        if row < self.GetNumberRows():

   238

            if colname == "Variable":

   239

                return self.data[row].GetVariable()

   240

            elif colname == "Value":

   241

                return self.data[row].GetValue()

   242

        return ""

   243

   244

    def SetValueByName(self, row, colname, value):

   245

        if row < self.GetNumberRows():

   246

            if colname == "Variable":

   247

                self.data[row].SetVariable(value)

   248

            elif colname == "Value":

   249

                self.data[row].SetValue(value)

   250

   251

    def IsForced(self, row):

   252

        if row < self.GetNumberRows():

   253

            return self.data[row].IsForced()

   254

        return False

   255

   256

    def IsNumVariable(self, row):

   257

        if row < self.GetNumberRows():

   258

            return self.data[row].IsNumVariable()

   259

        return False

   260

   261

    def _updateColAttrs(self, grid):

   262

        """

   263

        wx.grid.Grid -> update the column attributes to add the

   264

        appropriate renderer given the column name.

   265

   266

        Otherwise default to the default renderer.

   267

        """

   268

   269

        for row in range(self.GetNumberRows()):

   270

            for col in range(self.GetNumberCols()):

   271

                colname = self.GetColLabelValue(col, False)

   272

                if colname == "Value":

   273

                    if self.IsForced(row):

   274

                        grid.SetCellTextColour(row, col, wx.BLUE)

   275

                    else:

   276

                        grid.SetCellTextColour(row, col, wx.BLACK)

   277

                grid.SetReadOnly(row, col, True)

   278

            self.ResizeRow(grid, row)

   279

   280

    def AppendItem(self, data):

   281

        self.data.append(data)

   282

   283

    def InsertItem(self, idx, data):

   284

        self.data.insert(idx, data)

   285

   286

    def RemoveItem(self, idx):

   287

        self.data.pop(idx)

   288

   289

    def MoveItem(self, idx, new_idx):

   290

        self.data.insert(new_idx, self.data.pop(idx))

   291

   292

    def GetItem(self, idx):

   293

        return self.data[idx]

   294

   295

class DebugVariableDropTarget(wx.TextDropTarget):

   296

   297

    def __init__(self, parent, control=None):

   298

        wx.TextDropTarget.__init__(self)

   299

        self.ParentWindow = parent

   300

        self.ParentControl = control

   301

   302

    def __del__(self):

   303

        self.ParentWindow = None

   304

        self.ParentControl = None

   305

   311

    def OnDropText(self, x, y, data):

   312

        message = None

   313

        try:

   314

            values = eval(data)

   315

        except:

   316

            message = _("Invalid value \"%s\" for debug variable")%data

   317

            values = None

   318

        if not isinstance(values, TupleType):

   319

            message = _("Invalid value \"%s\" for debug variable")%data

   320

            values = None

   321

   322

        if message is not None:

   323

            wx.CallAfter(self.ShowMessage, message)

   324

        elif values is not None and values[1] == "debug":

   325

            if isinstance(self.ParentControl, CustomGrid):

   326

                x, y = self.ParentControl.CalcUnscrolledPosition(x, y)

   327

                row = self.ParentControl.YToRow(y - self.ParentControl.GetColLabelSize())

   328

                if row == wx.NOT_FOUND:

   329

                    row = self.ParentWindow.Table.GetNumberRows()

   330

                self.ParentWindow.InsertValue(values[0], row, force=True)

   331

            elif self.ParentControl is not None:

   332

                width, height = self.ParentControl.Canvas.GetSize()

   333

                target_idx = self.ParentControl.GetIndex()

   334

                merge_type = GRAPH_PARALLEL

   335

                if self.ParentControl.Is3DCanvas():

   336

                    if y > height / 2:

   337

                        target_idx += 1

   338

                    if len(values) > 2 and values[2] == "move":

   339

                        self.ParentWindow.MoveGraph(values[0], target_idx)

   340

                    else:

   341

                        self.ParentWindow.InsertValue(values[0], target_idx, force=True)

   342

                else:

   343

                    rect = self.ParentControl.GetAxesBoundingBox()

   344

                    if rect.InsideXY(x, y):

   345

                        merge_rect = wx.Rect(rect.x, rect.y, rect.width / 2., rect.height)

   346

                        if merge_rect.InsideXY(x, y):

   347

                            merge_type = GRAPH_ORTHOGONAL

   348

                        wx.CallAfter(self.ParentWindow.MergeGraphs, values[0], target_idx, merge_type, force=True)

   349

                    else:

   350

                        if y > height / 2:

   351

                            target_idx += 1

   352

                        if len(values) > 2 and values[2] == "move":

   353

                            self.ParentWindow.MoveGraph(values[0], target_idx)

   354

                        else:

   355

                            self.ParentWindow.InsertValue(values[0], target_idx, force=True)

   356

            elif len(values) > 2 and values[2] == "move":

   357

                self.ParentWindow.MoveGraph(values[0])

   358

            else:

   359

                self.ParentWindow.InsertValue(values[0], force=True)

   366

    def ShowMessage(self, message):

   367

        dialog = wx.MessageDialog(self.ParentWindow, message, _("Error"), wx.OK|wx.ICON_ERROR)

   368

        dialog.ShowModal()

   369

        dialog.Destroy()

   370

   371

if USE_MPL:

   372

    MILLISECOND = 1000000

   373

    SECOND = 1000 * MILLISECOND

   374

    MINUTE = 60 * SECOND

   375

    HOUR = 60 * MINUTE

   376

    DAY = 24 * HOUR

   377

   378

    ZOOM_VALUES = map(lambda x:("x %.1f" % x, x), [math.sqrt(2) ** i for i in xrange(8)])

   379

    RANGE_VALUES = map(lambda x: (str(x), x), [25 * 2 ** i for i in xrange(6)])

   380

    TIME_RANGE_VALUES = [("%ds" % i, i * SECOND) for i in (1, 2, 5, 10, 20, 30)] + \

   381

                        [("%dm" % i, i * MINUTE) for i in (1, 2, 5, 10, 20, 30)] + \

   382

                        [("%dh" % i, i * HOUR) for i in (1, 2, 3, 6, 12, 24)]

   383

   384

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   385

   386

    SCROLLBAR_UNIT = 10

   387

   388

    def NextTick(variables):

   389

        next_tick = None

   390

        for item, data in variables:

   391

            if len(data) > 0:

   392

                if next_tick is None:

   393

                    next_tick = data[0][0]

   394

                else:

   395

                    next_tick = min(next_tick, data[0][0])

   396

        return next_tick

   397

   398

    def OrthogonalData(item, start_tick, end_tick):

   399

        data = item.GetData(start_tick, end_tick)

   400

        min_value, max_value = item.GetRange()

   401

        if min_value is not None and max_value is not None:

   402

            center = (min_value + max_value) / 2.

   403

            range = max(1.0, max_value - min_value)

   404

        else:

   405

            center = 0.5

   406

            range = 1.0

   407

        return data, center - range * 0.55, center + range * 0.55

   408

   409

    class DebugVariableViewer(wx.Panel):

   410

   411

        def AddViewer(self):

   412

            pass

   413

   414

        def AddButtons(self):

   415

            pass

   416

   417

        def __init__(self, parent, window, items=[]):

   418

            wx.Panel.__init__(self, parent)

   419

            self.SetBackgroundColour(wx.WHITE)

   420

            self.SetDropTarget(DebugVariableDropTarget(window, self))

   421

   422

            self.ParentWindow = window

   423

            self.Items = items

   424

   425

            self.MainSizer = wx.FlexGridSizer(cols=2, hgap=0, rows=1, vgap=0)

   426

            self.AddViewer()

   427

            self.AddButtons()

   428

            self.MainSizer.AddGrowableCol(0)

   429

   430

            self.SetSizer(self.MainSizer)

   431

   432

        def __del__(self):

   433

            self.ParentWindow = None

   434

   435

        def GetIndex(self):

   436

            return self.ParentWindow.GetViewerIndex(self)

   437

   438

        def GetItem(self, variable):

   439

            for item in self.Items:

   440

                if item.GetVariable() == variable:

   441

                    return item

   442

            return None

   443

   444

        def GetItems(self):

   445

            return self.Items

   446

   447

        def GetVariables(self):

   448

            if len(self.Items) > 1:

   449

                variables = [item.GetVariable() for item in self.Items]

   450

                if self.GraphType == GRAPH_ORTHOGONAL:

   451

                    return tuple(variables)

   452

                return variables

   453

            return self.Items[0].GetVariable()

   454

   455

        def AddItem(self, item):

   456

            self.Items.append(item)

   458

        def RemoveItem(self, item):

   459

            if item in self.Items:

   460

                self.Items.remove(item)

   461

   462

        def Clear(self):

   463

            for item in self.Items:

   464

                self.ParentWindow.RemoveDataConsumer(item)

   465

            self.Items = []

   467

        def IsEmpty(self):

   468

            return len(self.Items) == 0

   469

   470

        def UnregisterObsoleteData(self):

   471

            for item in self.Items[:]:

   472

                iec_path = item.GetVariable().upper()

   473

                if self.ParentWindow.GetDataType(iec_path) is None:

   474

                    self.ParentWindow.RemoveDataConsumer(item)

   475

                    self.RemoveItem(item)

   476

                else:

   477

                    self.ParentWindow.AddDataConsumer(iec_path, item)

   478

                    item.RefreshVariableType()

   480

        def ResetData(self):

   481

            for item in self.Items:

   482

                item.ResetData()

   483

   484

        def Refresh(self):

   485

            pass

   486

   487

        def OnForceButton(self, event):

   488

            if len(self.Items) == 1:

   489

                wx.CallAfter(self.ForceValue, self.Items[0])

   490

            else:

   491

                menu = wx.Menu(title='')

   492

                for item in self.Items:

   493

                    new_id = wx.NewId()

   494

                    AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, 

   496

                    self.Bind(wx.EVT_MENU, 

   497

                        self.GetForceVariableMenuFunction(item),

   498

                        id=new_id)

   499