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, FloatType

    26

from time import time as gettime

    27

import numpy

    28

    29

import wx

    30

import wx.lib.buttons

    31

    32

try:

    33

    import matplotlib

    34

    matplotlib.use('WX')

    35

    import matplotlib.pyplot

    36

    from matplotlib.backends.backend_wx import FigureCanvasWx as FigureCanvas

    37

    from mpl_toolkits.mplot3d import Axes3D

    38

    USE_MPL = True

    39

except:

    40

    USE_MPL = False

    41

    42

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    43

from controls import CustomGrid, CustomTable

    44

from dialogs.ForceVariableDialog import ForceVariableDialog

    45

from util.BitmapLibrary import GetBitmap

    46

    47

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

    48

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

    49

    50

def GetDebugVariablesTableColnames():

    51

    _ = lambda x : x

    52

    cols = [_("Variable"), _("Value")]

    53

    if USE_MPL:

    54

        cols.append(_("3DAxis"))

    55

    return cols

    56

    57

class VariableTableItem(DebugDataConsumer):

    58

    59

    def __init__(self, parent, variable):

    60

        DebugDataConsumer.__init__(self)

    61

        self.Parent = parent

    62

        self.Variable = variable

    63

        self.RefreshVariableType()

    64

        self.Value = ""

    65

        self.Axis3D = False

    66

    67

    def __del__(self):

    68

        self.Parent = None

    69

    70

    def SetVariable(self, variable):

    71

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

    72

            self.Variable = variable

    73

            self.RefreshVariableType()

    74

            self.Parent.RefreshGrid()

    75

    76

    def GetVariable(self):

    77

        return self.Variable

    78

    79

    def RefreshVariableType(self):

    80

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

    81

        self.ResetData()

    82

    83

    def GetVariableType(self):

    84

        return self.VariableType

    85

    86

    def GetData(self):

    87

        return self.Data

    88

    89

    def ResetData(self):

    90

        if self.IsNumVariable():

    91

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

    92

        else:

    93

            self.Data = None

    94

    95

    def IsNumVariable(self):

    96

        return self.Parent.IsNumType(self.VariableType)

    97

    98

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

    99

        if self.IsNumVariable():

   100

            value = {True:1., False:0.}.get(value, float(value))

   101

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

   102

            self.Parent.HasNewData = True

   103

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

   104

   105

    def SetForced(self, forced):

   106

        if self.Forced != forced:

   107

            self.Forced = forced

   108

            self.Parent.HasNewData = True

   109

   110

    def SetValue(self, value):

   111

        if self.Value != value:

   112

            self.Value = value

   113

            self.Parent.HasNewData = True

   114

   115

    def GetValue(self):

   116

        if self.VariableType == "STRING":

   117

            return "'%s'" % self.Value

   118

        elif self.VariableType == "WSTRING":

   119

            return "\"%s\"" % self.Value

   120

        elif isinstance(self.Value, FloatType):

   121

            return "%.6g" % self.Value

   122

        return self.Value

   123

   124

    def SetAxis3D(self, axis_3d):

   125

        if self.IsNumVariable():

   126

            self.Axis3D = axis_3d

   127

   128

    def GetAxis3D(self):

   129

        if self.IsNumVariable():

   130

            return self.Axis3D

   131

        return ""

   132

   133

class DebugVariableTable(CustomTable):

   134

   135

    def GetValue(self, row, col):

   136

        if row < self.GetNumberRows():

   137

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

   138

        return ""

   139

   140

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

   141

        if col < len(self.colnames):

   142

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

   143

   144

    def GetValueByName(self, row, colname):

   145

        if row < self.GetNumberRows():

   146

            if colname == "Variable":

   147

                return self.data[row].GetVariable()

   148

            elif colname == "Value":

   149

                return self.data[row].GetValue()

   150

            elif colname == "3DAxis":

   151

                return self.data[row].GetAxis3D()

   152

        return ""

   153

   154

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

   155

        if row < self.GetNumberRows():

   156

            if colname == "Variable":

   157

                self.data[row].SetVariable(value)

   158

            elif colname == "Value":

   159

                self.data[row].SetValue(value)

   160

            elif colname == "3DAxis":

   161

                self.data[row].SetAxis3D(value)

   162

   163

    def IsForced(self, row):

   164

        if row < self.GetNumberRows():

   165

            return self.data[row].IsForced()

   166

        return False

   167

   168

    def IsNumVariable(self, row):

   169

        if row < self.GetNumberRows():

   170

            return self.data[row].IsNumVariable()

   171

        return False

   172

   173

    def _updateColAttrs(self, grid):

   174

        """

   175

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

   176

        appropriate renderer given the column name.

   177

   178

        Otherwise default to the default renderer.

   179

        """

   180

   181

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

   182

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

   183

                colname = self.GetColLabelValue(col, False)

   184

                if colname == "3DAxis":

   185

                    if self.IsNumVariable(row):

   186

                        grid.SetCellRenderer(row, col, wx.grid.GridCellBoolRenderer())

   187

                        grid.SetCellEditor(row, col, wx.grid.GridCellBoolEditor())

   188

                        grid.SetReadOnly(row, col, False)

   189

                    else:

   190

                        grid.SetReadOnly(row, col, True)

   191

                else:

   192

                    if colname == "Value":

   193

                        if self.IsForced(row):

   194

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

   195

                        else:

   196

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

   197

                    grid.SetReadOnly(row, col, True)

   198

            self.ResizeRow(grid, row)

   199

   200

    def AppendItem(self, data):

   201

        self.data.append(data)

   202

   203

    def InsertItem(self, idx, data):

   204

        self.data.insert(idx, data)

   205

   206

    def RemoveItem(self, idx):

   207

        self.data.pop(idx)

   208

   209

    def MoveItem(self, idx, new_idx):

   210

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

   211

   212

    def GetItem(self, idx):

   213

        return self.data[idx]

   214

   215

class DebugVariableDropTarget(wx.TextDropTarget):

   216

   217

    def __init__(self, parent):

   218

        wx.TextDropTarget.__init__(self)

   219

        self.ParentWindow = parent

   220

   221

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

   222

        x, y = self.ParentWindow.VariablesGrid.CalcUnscrolledPosition(x, y)

   223

        row = self.ParentWindow.VariablesGrid.YToRow(y - self.ParentWindow.VariablesGrid.GetColLabelSize())

   224

        if row == wx.NOT_FOUND:

   225

            row = self.ParentWindow.Table.GetNumberRows()

   226

        message = None

   227

        try:

   228

            values = eval(data)

   229

        except:

   230

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

   231

            values = None

   232

        if not isinstance(values, TupleType):

   233

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

   234

            values = None

   235

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

   236

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

   237

        if message is not None:

   238

            wx.CallAfter(self.ShowMessage, message)

   239

   240

    def ShowMessage(self, message):

   241

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

   242

        dialog.ShowModal()

   243

        dialog.Destroy()

   244

   245

SCROLLBAR_UNIT = 10

   246

   247

class DebugVariablePanel(wx.SplitterWindow, DebugViewer):

   248

   249

    def __init__(self, parent, producer):

   250

        wx.SplitterWindow.__init__(self, parent, style=wx.SP_3D)

   251

        DebugViewer.__init__(self, producer, True)

   252

   253

        self.SetSashGravity(0.5)

   254

        self.SetNeedUpdating(True)

   255

        self.SetMinimumPaneSize(1)

   256

   257

        self.MainPanel = wx.Panel(self, style=wx.TAB_TRAVERSAL)

   258

   259

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

   260

        main_panel_sizer.AddGrowableCol(0)

   261

        main_panel_sizer.AddGrowableRow(1)

   262

   263

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   264

        main_panel_sizer.AddSizer(button_sizer, border=5, 

   265

              flag=wx.ALIGN_RIGHT|wx.ALL)

   266

   267

        for name, bitmap, help in [

   268

                ("DeleteButton", "remove_element", _("Remove debug variable")),

   269

                ("UpButton", "up", _("Move debug variable up")),

   270

                ("DownButton", "down", _("Move debug variable down"))]:

   271

            button = wx.lib.buttons.GenBitmapButton(self.MainPanel, bitmap=GetBitmap(bitmap), 

   272

                  size=wx.Size(28, 28), style=wx.NO_BORDER)

   273

            button.SetToolTipString(help)

   274

            setattr(self, name, button)

   275

            button_sizer.AddWindow(button, border=5, flag=wx.LEFT)

   276

   277

        self.VariablesGrid = CustomGrid(self.MainPanel, size=wx.Size(-1, 150), style=wx.VSCROLL)

   278

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self))

   279

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, 

   280

              self.OnVariablesGridCellRightClick)

   281

        self.VariablesGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, 

   282

              self.OnVariablesGridCellChange)

   283

        main_panel_sizer.AddWindow(self.VariablesGrid, flag=wx.GROW)

   284

   285

        self.MainPanel.SetSizer(main_panel_sizer)

   286

   287

        self.HasNewData = False

   288

   289

        self.Table = DebugVariableTable(self, [], GetDebugVariablesTableColnames())

   290

        self.VariablesGrid.SetTable(self.Table)

   291

        self.VariablesGrid.SetButtons({"Delete": self.DeleteButton,

   292

                                       "Up": self.UpButton,

   293

                                       "Down": self.DownButton})

   294

   295

        def _AddVariable(new_row):

   296

            return self.VariablesGrid.GetGridCursorRow()

   297

        setattr(self.VariablesGrid, "_AddRow", _AddVariable)

   298

   299

        def _DeleteVariable(row):

   300

            item = self.Table.GetItem(row)

   301

            self.RemoveDataConsumer(item)

   302

            self.Table.RemoveItem(row)

   303

            self.ResetGraphics()

   304

            self.RefreshGrid()

   305

        setattr(self.VariablesGrid, "_DeleteRow", _DeleteVariable)

   306

   307

        def _MoveVariable(row, move):

   308

            new_row = max(0, min(row + move, self.Table.GetNumberRows() - 1))

   309

            if new_row != row:

   310

                self.Table.MoveItem(row, new_row)

   311

                self.ResetGraphics()

   312

                self.RefreshGrid()

   313

            return new_row

   314

        setattr(self.VariablesGrid, "_MoveRow", _MoveVariable)

   315

   316

        self.VariablesGrid.SetRowLabelSize(0)

   317

   318

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

   319

            attr = wx.grid.GridCellAttr()

   320

            if self.Table.GetColLabelValue(col, False) == "3DAxis":

   321

                attr.SetAlignment(wx.ALIGN_CENTER, wx.ALIGN_CENTER)

   322

            else:

   323

                attr.SetAlignment(wx.ALIGN_RIGHT, wx.ALIGN_CENTER)

   324

            self.VariablesGrid.SetColAttr(col, attr)

   325

            self.VariablesGrid.SetColSize(col, 100)

   326

   327

        self.Table.ResetView(self.VariablesGrid)

   328

        self.VariablesGrid.RefreshButtons()

   329

   330

        if USE_MPL:

   331

            self.GraphicsPanel = wx.Panel(self, style=wx.TAB_TRAVERSAL)

   332

   333

            graphics_panel_sizer = wx.BoxSizer(wx.VERTICAL)

   334

   335

            self.GraphicsCanvasWindow = wx.ScrolledWindow(self.GraphicsPanel, style=wx.HSCROLL|wx.VSCROLL)

   336

            self.GraphicsCanvasWindow.Bind(wx.EVT_SIZE, self.OnGraphicsCanvasWindowResize)

   337

            graphics_panel_sizer.AddWindow(self.GraphicsCanvasWindow, 1, flag=wx.GROW)

   338

   339

            graphics_canvas_window_sizer = wx.BoxSizer(wx.VERTICAL)

   340

   341

            self.GraphicsFigure = matplotlib.figure.Figure()

   342

            self.GraphicsFigure.subplots_adjust(hspace=0)

   343

            self.GraphicsAxes = []

   344

   345

            self.GraphicsCanvas = FigureCanvas(self.GraphicsCanvasWindow, -1, self.GraphicsFigure)

   346

            graphics_canvas_window_sizer.AddWindow(self.GraphicsCanvas, 1, flag=wx.GROW)

   347

   348

            self.GraphicsCanvasWindow.SetSizer(graphics_canvas_window_sizer)

   349

   350

            self.Graphics3DFigure = matplotlib.figure.Figure()

   351

            self.Graphics3DFigure.subplotpars.update(left=0.0, right=1.0, bottom=0.0, top=1.0)

   352

   353

            self.LastMotionTime = gettime()

   354

            self.Graphics3DAxes = self.Graphics3DFigure.gca(projection='3d')

   355

            self.Graphics3DAxes.set_color_cycle(['b'])

   356

            setattr(self.Graphics3DAxes, "_on_move", self.OnGraphics3DMotion)

   357

   358

            self.Graphics3DCanvas = FigureCanvas(self.GraphicsPanel, -1, self.Graphics3DFigure)

   359

            self.Graphics3DCanvas.SetMinSize(wx.Size(0, 0))

   360

            graphics_panel_sizer.AddWindow(self.Graphics3DCanvas, 1, flag=wx.GROW)

   361

   362

            self.Graphics3DAxes.mouse_init()

   363

   364

            self.GraphicsPanel.SetSizer(graphics_panel_sizer)

   365

   366

            self.SplitHorizontally(self.MainPanel, self.GraphicsPanel, -200)

   367

   368

        else:

   369

            self.Initialize(self.MainPanel)

   370

   371

        self.ResetGraphics()

   372

   373

    def RefreshNewData(self):

   374

        if self.HasNewData:

   375

            self.HasNewData = False

   376

            self.RefreshGrid(only_values=True)

   377

        DebugViewer.RefreshNewData(self)

   378

   379

    def RefreshGrid(self, only_values=False):

   380

        self.Freeze()

   381

        if only_values:

   382

            for col in xrange(self.Table.GetNumberCols()):

   383

                if self.Table.GetColLabelValue(col, False) == "Value":

   384

                    for row in xrange(self.Table.GetNumberRows()):

   385

                        self.VariablesGrid.SetCellValue(row, col, str(self.Table.GetValueByName(row, "Value")))

   386

        else:

   387

            self.Table.ResetView(self.VariablesGrid)

   388

        self.VariablesGrid.RefreshButtons()

   389

   390

        if USE_MPL:

   391

            # Refresh graphics

   392

            idx = 0

   393

            for item in self.Table.GetData():

   394

                data = item.GetData()

   395

                if data is not None:

   396

                    self.GraphicsAxes[idx].clear()

   397

                    self.GraphicsAxes[idx].plot(data[:, 0], data[:, 1])

   398

                    idx += 1

   399

            self.GraphicsCanvas.draw()

   400

   401

            # Refresh 3D graphics

   402

            while len(self.Graphics3DAxes.lines) > 0:

   403

                self.Graphics3DAxes.lines.pop()

   404

            if self.Axis3DValues is not None:

   405

                self.Graphics3DAxes.plot(

   406

                    self.Axis3DValues[0][1].GetData()[self.Axis3DValues[0][0]:, 1],

   407

                    self.Axis3DValues[1][1].GetData()[self.Axis3DValues[1][0]:, 1],

   408

                    zs = self.Axis3DValues[2][1].GetData()[self.Axis3DValues[2][0]:, 1])

   409

            self.Graphics3DCanvas.draw()

   410

   411

        self.Thaw()

   412

   413

    def UnregisterObsoleteData(self):

   414

        items = [(idx, item) for idx, item in enumerate(self.Table.GetData())]

   415

        items.reverse()

   416

        for idx, item in items:

   417

            iec_path = item.GetVariable().upper()

   418

            if self.GetDataType(iec_path) is None:

   419

                self.RemoveDataConsumer(item)

   420

                self.Table.RemoveItem(idx)

   421

            else:

   422

                self.AddDataConsumer(iec_path, item)

   423

                item.RefreshVariableType()

   424

        self.Freeze()

   425

        self.Table.ResetView(self.VariablesGrid)

   426

        self.VariablesGrid.RefreshButtons()

   427

        self.Thaw()

   428

   429

    def ResetGrid(self):

   430

        self.DeleteDataConsumers()

   431

        self.Table.Empty()

   432

        self.Freeze()

   433

        self.Table.ResetView(self.VariablesGrid)

   434

        self.VariablesGrid.RefreshButtons()

   435

        self.Thaw()

   436

        self.ResetGraphics()

   437

   438

    def GetForceVariableMenuFunction(self, iec_path, item):

   439

        iec_type = self.GetDataType(iec_path)

   440

        def ForceVariableFunction(event):

   441

            if iec_type is not None:

   442

                dialog = ForceVariableDialog(self, iec_type, str(item.GetValue()))

   443

                if dialog.ShowModal() == wx.ID_OK:

   444

                    self.ForceDataValue(iec_path, dialog.GetValue())

   445

        return ForceVariableFunction

   446

   447

    def GetReleaseVariableMenuFunction(self, iec_path):

   448

        def ReleaseVariableFunction(event):

   449

            self.ReleaseDataValue(iec_path)

   450

        return ReleaseVariableFunction

   451

   452

    def OnVariablesGridCellRightClick(self, event):

   453

        row, col = event.GetRow(), event.GetCol()

   454

        if self.Table.GetColLabelValue(col, False) == "Value":

   455

            iec_path = self.Table.GetValueByName(row, "Variable").upper()

   456

   457

            menu = wx.Menu(title='')

   458

   459

            new_id = wx.NewId()

   460

            AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=_("Force value"))

   461

            self.Bind(wx.EVT_MENU, self.GetForceVariableMenuFunction(iec_path.upper(), self.Table.GetItem(row)), id=new_id)

   462

   463

            new_id = wx.NewId()

   464

            AppendMenu(menu, help='', id=new_id, kind=wx.ITEM_NORMAL, text=_("Release value"))

   465

            self.Bind(wx.EVT_MENU, self.GetReleaseVariableMenuFunction(iec_path.upper()), id=new_id)

   466

   467

            if self.Table.IsForced(row):

   468

                menu.Enable(new_id, True)

   469

            else:

   470

                menu.Enable(new_id, False)

   471

   472

            self.PopupMenu(menu)

   473

   474

            menu.Destroy()

   475

        event.Skip()

   476

   477

    def OnVariablesGridCellChange(self, event):

   478

        row, col = event.GetRow(), event.GetCol()

   479

        if self.Table.GetColLabelValue(col, False) == "3DAxis":

   480

            wx.CallAfter(self.Reset3DGraphics)

   481

        event.Skip()

   482

   483

    def InsertValue(self, iec_path, idx = None, force=False, axis3D=False):

   484

        if idx is None:

   485

            idx = self.Table.GetNumberRows()

   486

        for item in self.Table.GetData():

   487

            if iec_path == item.GetVariable():

   488

                return

   489

        item = VariableTableItem(self, iec_path)

   490

        result = self.AddDataConsumer(iec_path.upper(), item)

   491

        if result is not None or force:

   492

            self.Table.InsertItem(idx, item)

   493

            item.SetAxis3D(int(axis3D))

   494

            self.ResetGraphics()

   495

            self.RefreshGrid()

   496

   497

    def GetDebugVariables(self):

   498

        return [item.GetVariable() for item in self.Table.GetData()]

   499

   500

    def GetAxis3D(self):

   501

        return [item.GetVariable() for item in self.Table.GetData() if item.GetAxis3D()]

   502

   503

    def ResetGraphicsValues(self):

   504

        for item in self.Table.GetData():

   505

            item.ResetData()

   506

   507

    def ResetGraphics(self):

   508

        if USE_MPL:

   509

            self.GraphicsFigure.clear()

   510