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

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

   101

            self.Data = numpy.append(self.Data, [[float(tick), num_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.VariableType == "STRING" and value.startswith("'") and value.endswith("'") or

   112

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

   113

            value = value[1:-1]

   114

        if self.Value != value:

   115

            self.Value = value

   116

            self.Parent.HasNewData = True

   117

   118

    def GetValue(self):

   119

        if self.VariableType == "STRING":

   120

            return "'%s'" % self.Value

   121

        elif self.VariableType == "WSTRING":

   122

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

   123

        elif isinstance(self.Value, FloatType):

   124

            return "%.6g" % self.Value

   125

        return self.Value

   126

   127

    def SetAxis3D(self, axis_3d):

   128

        if self.IsNumVariable():

   129

            self.Axis3D = axis_3d

   130

   131

    def GetAxis3D(self):

   132

        if self.IsNumVariable():

   133

            return self.Axis3D

   134

        return ""

   135

   136

class DebugVariableTable(CustomTable):

   137

   138

    def GetValue(self, row, col):

   139

        if row < self.GetNumberRows():

   140

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

   141

        return ""

   142

   143

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

   144

        if col < len(self.colnames):

   145

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

   146

   147

    def GetValueByName(self, row, colname):

   148

        if row < self.GetNumberRows():

   149

            if colname == "Variable":

   150

                return self.data[row].GetVariable()

   151

            elif colname == "Value":

   152

                return self.data[row].GetValue()

   153

            elif colname == "3DAxis":

   154

                return self.data[row].GetAxis3D()

   155

        return ""

   156

   157

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

   158

        if row < self.GetNumberRows():

   159

            if colname == "Variable":

   160

                self.data[row].SetVariable(value)

   161

            elif colname == "Value":

   162

                self.data[row].SetValue(value)

   163

            elif colname == "3DAxis":

   164

                self.data[row].SetAxis3D(value)

   165

   166

    def IsForced(self, row):

   167

        if row < self.GetNumberRows():

   168

            return self.data[row].IsForced()

   169

        return False

   170

   171

    def IsNumVariable(self, row):

   172

        if row < self.GetNumberRows():

   173

            return self.data[row].IsNumVariable()

   174

        return False

   175

   176

    def _updateColAttrs(self, grid):

   177

        """

   178

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

   179

        appropriate renderer given the column name.

   180

   181

        Otherwise default to the default renderer.

   182

        """

   183

   184

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

   185

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

   186

                colname = self.GetColLabelValue(col, False)

   187

                if colname == "3DAxis":

   188

                    if self.IsNumVariable(row):

   189

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

   190

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

   191

                        grid.SetReadOnly(row, col, False)

   192

                    else:

   193

                        grid.SetReadOnly(row, col, True)

   194

                else:

   195

                    if colname == "Value":

   196

                        if self.IsForced(row):

   197

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

   198

                        else:

   199

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

   200

                    grid.SetReadOnly(row, col, True)

   201

            self.ResizeRow(grid, row)

   202

   203

    def AppendItem(self, data):

   204

        self.data.append(data)

   205

   206

    def InsertItem(self, idx, data):

   207

        self.data.insert(idx, data)

   208

   209

    def RemoveItem(self, idx):

   210

        self.data.pop(idx)

   211

   212

    def MoveItem(self, idx, new_idx):

   213

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

   214

   215

    def GetItem(self, idx):

   216

        return self.data[idx]

   217

   218

class DebugVariableDropTarget(wx.TextDropTarget):

   219

   220

    def __init__(self, parent):

   221

        wx.TextDropTarget.__init__(self)

   222

        self.ParentWindow = parent

   223

   224

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

   225

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

   226

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

   227

        if row == wx.NOT_FOUND:

   228

            row = self.ParentWindow.Table.GetNumberRows()

   229

        message = None

   230

        try:

   231

            values = eval(data)

   232

        except:

   233

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

   234

            values = None

   235

        if not isinstance(values, TupleType):

   236

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

   237

            values = None

   238

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

   239

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

   240

        if message is not None:

   241

            wx.CallAfter(self.ShowMessage, message)

   242

   243

    def ShowMessage(self, message):

   244

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

   245

        dialog.ShowModal()

   246

        dialog.Destroy()

   247

   248

SCROLLBAR_UNIT = 10

   249

   250

class DebugVariablePanel(wx.SplitterWindow, DebugViewer):

   251

   252

    def __init__(self, parent, producer):

   253

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

   254

        DebugViewer.__init__(self, producer, True)

   255

   256

        self.SetSashGravity(0.5)

   257

        self.SetNeedUpdating(True)

   258

        self.SetMinimumPaneSize(1)

   259

   260

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

   261

   262

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

   263

        main_panel_sizer.AddGrowableCol(0)

   264

        main_panel_sizer.AddGrowableRow(1)

   265

   266

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   267

        main_panel_sizer.AddSizer(button_sizer, border=5, 

   268

              flag=wx.ALIGN_RIGHT|wx.ALL)

   269

   270

        for name, bitmap, help in [

   271

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

   272

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

   273

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

   274

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

   275

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

   276

            button.SetToolTipString(help)

   277

            setattr(self, name, button)

   278

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

   279

   280

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

   281

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self))

   282

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

   283

              self.OnVariablesGridCellRightClick)

   284

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

   285

              self.OnVariablesGridCellLeftClick)

   286

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

   287

              self.OnVariablesGridCellChange)

   288

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

   289

   290

        self.MainPanel.SetSizer(main_panel_sizer)

   291

   292

        self.HasNewData = False

   293

   294

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

   295

        self.VariablesGrid.SetTable(self.Table)

   296

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

   297

                                       "Up": self.UpButton,

   298

                                       "Down": self.DownButton})

   299

   300

        def _AddVariable(new_row):

   301

            return self.VariablesGrid.GetGridCursorRow()

   302

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

   303

   304

        def _DeleteVariable(row):

   305

            item = self.Table.GetItem(row)

   306

            self.RemoveDataConsumer(item)

   307

            self.Table.RemoveItem(row)

   308

            self.ResetGraphics()

   309

            self.RefreshGrid()

   310

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

   311

   312

        def _MoveVariable(row, move):

   313

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

   314

            if new_row != row:

   315

                self.Table.MoveItem(row, new_row)

   316

                self.ResetGraphics()

   317

                self.RefreshGrid()

   318

            return new_row

   319

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

   320

   321

        self.VariablesGrid.SetRowLabelSize(0)

   322

   323

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

   324

            attr = wx.grid.GridCellAttr()

   325

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

   326

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

   327

            else:

   328

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

   329

            self.VariablesGrid.SetColAttr(col, attr)

   330

            self.VariablesGrid.SetColSize(col, 100)

   331

   332

        self.Table.ResetView(self.VariablesGrid)

   333

        self.VariablesGrid.RefreshButtons()

   334

   335

        if USE_MPL:

   336

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

   337

   338

            graphics_panel_sizer = wx.BoxSizer(wx.VERTICAL)

   339

   340

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

   341

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

   342

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

   343

   344

            graphics_canvas_window_sizer = wx.BoxSizer(wx.VERTICAL)

   345

   346

            self.GraphicsFigure = matplotlib.figure.Figure()

   347

            self.GraphicsFigure.subplots_adjust(hspace=0)

   348

            self.GraphicsAxes = []

   349

   350

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

   351

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

   352

   353

            self.GraphicsCanvasWindow.SetSizer(graphics_canvas_window_sizer)

   354

   355

            self.Graphics3DFigure = matplotlib.figure.Figure()

   356

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

   357

   358

            self.LastMotionTime = gettime()

   359

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

   360

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

   361

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

   362

   363

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

   364

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

   365

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

   366

   367

            self.Graphics3DAxes.mouse_init()

   368

   369

            self.GraphicsPanel.SetSizer(graphics_panel_sizer)

   370

   371

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

   372

   373

        else:

   374

            self.Initialize(self.MainPanel)

   375

   376

        self.ResetGraphics()

   377

   378

    def RefreshNewData(self):

   379

        if self.HasNewData:

   380

            self.HasNewData = False

   381

            self.RefreshGrid(only_values=True)

   382

        DebugViewer.RefreshNewData(self)

   383

   384

    def RefreshGrid(self, only_values=False):

   385

        self.Freeze()

   386

        if only_values:

   387

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

   388

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

   389

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

   390

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

   391

        else:

   392

            self.Table.ResetView(self.VariablesGrid)

   393

        self.VariablesGrid.RefreshButtons()

   394

   395

        if USE_MPL:

   396

            # Refresh graphics

   397

            idx = 0

   398

            for item in self.Table.GetData():

   399

                data = item.GetData()

   400

                if data is not None:

   401

                    self.GraphicsAxes[idx].clear()

   402

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

   403

                    idx += 1

   404

            self.GraphicsCanvas.draw()

   405

   406

            # Refresh 3D graphics

   407

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

   408

                self.Graphics3DAxes.lines.pop()

   409

            if self.Axis3DValues is not None:

   410

                self.Graphics3DAxes.plot(

   411

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

   412

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

   413

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

   414

            self.Graphics3DCanvas.draw()

   415

   416

        self.Thaw()

   417

   418

    def UnregisterObsoleteData(self):

   419

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

   420

        items.reverse()

   421

        for idx, item in items:

   422

            iec_path = item.GetVariable().upper()

   423

            if self.GetDataType(iec_path) is None:

   424

                self.RemoveDataConsumer(item)

   425

                self.Table.RemoveItem(idx)

   426

            else:

   427

                self.AddDataConsumer(iec_path, item)

   428

                item.RefreshVariableType()

   429

        self.Freeze()

   430

        self.Table.ResetView(self.VariablesGrid)

   431

        self.VariablesGrid.RefreshButtons()

   432

        self.Thaw()

   433

   434

    def ResetGrid(self):

   435

        self.DeleteDataConsumers()

   436

        self.Table.Empty()

   437

        self.Freeze()

   438

        self.Table.ResetView(self.VariablesGrid)

   439

        self.VariablesGrid.RefreshButtons()

   440

        self.Thaw()

   441

        self.ResetGraphics()

   442

   443

    def GetForceVariableMenuFunction(self, iec_path, item):

   444

        iec_type = self.GetDataType(iec_path)

   445

        def ForceVariableFunction(event):

   446

            if iec_type is not None:

   447

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

   448

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

   449

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

   450

        return ForceVariableFunction

   451

   452

    def GetReleaseVariableMenuFunction(self, iec_path):

   453

        def ReleaseVariableFunction(event):

   454

            self.ReleaseDataValue(iec_path)

   455

        return ReleaseVariableFunction

   456

   457

    def OnVariablesGridCellLeftClick(self, event):

   458

        if event.GetCol() == 0:

   459

            row = event.GetRow()

   460

            data = wx.TextDataObject(str(self.Table.GetValueByName(row, "Variable")))

   461

            dragSource = wx.DropSource(self.VariablesGrid)

   462

            dragSource.SetData(data)

   463

            dragSource.DoDragDrop()

   464

        event.Skip()

   465

   466

    def OnVariablesGridCellRightClick(self, event):

   467

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

   468

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

   469

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

   470

   471

            menu = wx.Menu(title='')

   472

   473

            new_id = wx.NewId()

   474

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

   475

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

   476

   477

            new_id = wx.NewId()

   478

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

   479

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

   480

   481

            if self.Table.IsForced(row):

   482

                menu.Enable(new_id, True)

   483

            else:

   484

                menu.Enable(new_id, False)

   485

   486

            self.PopupMenu(menu)

   487

   488

            menu.Destroy()

   489

        event.Skip()

   490

   491

    def OnVariablesGridCellChange(self, event):

   492

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

   493

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

   494

            wx.CallAfter(self.Reset3DGraphics)

   495

        event.Skip()

   496

   497

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

   498

        if idx is None:

   499

            idx = self.Table.GetNumberRows()

   500

        for item in self.Table.GetData():

   501

            if iec_path == item.GetVariable():

   502

                return

   503

        item = VariableTableItem(self, iec_path)

   504

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

   505

        if result is not None or force:

   506

            self.Table.InsertItem(idx, item)

   507

            item.SetAxis3D(int(axis3D))

   508

            self.ResetGraphics()

   509

            self.RefreshGrid()