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 math

    28

import numpy

    29

    30

import wx

    31

import wx.lib.buttons

    32

    33

try:

    34

    import matplotlib

    35

    matplotlib.use('WX')

    36

    import matplotlib.pyplot

    37

    from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas

    38

    #from matplotlib.backends.backend_wx import FigureCanvasWx as FigureCanvas

    39

    from mpl_toolkits.mplot3d import Axes3D

    40

    USE_MPL = True

    41

except:

    42

    USE_MPL = False

    43

    44

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    45

from controls import CustomGrid, CustomTable

    46

from dialogs.ForceVariableDialog import ForceVariableDialog

    47

from util.BitmapLibrary import GetBitmap

    48

    49

SECOND = 1000000000

    50

MINUTE = 60 * SECOND

    51

HOUR = 60 * MINUTE

    52

    53

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

    54

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

    55

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

    56

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

    57

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

    58

    59

GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

    60

    61

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

    62

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

    63

    64

def GetDebugVariablesTableColnames():

    65

    _ = lambda x : x

    66

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

    67

    68

class VariableTableItem(DebugDataConsumer):

    69

    70

    def __init__(self, parent, variable):

    71

        DebugDataConsumer.__init__(self)

    72

        self.Parent = parent

    73

        self.Variable = variable

    74

        self.RefreshVariableType()

    75

        self.Value = ""

    76

    77

    def __del__(self):

    78

        self.Parent = None

    79

    80

    def SetVariable(self, variable):

    81

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

    82

            self.Variable = variable

    83

            self.RefreshVariableType()

    84

            self.Parent.RefreshGrid()

    85

    86

    def GetVariable(self):

    87

        return self.Variable

    88

    89

    def RefreshVariableType(self):

    90

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

    91

        self.ResetData()

    92

    93

    def GetVariableType(self):

    94

        return self.VariableType

    95

    96

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

    97

        if self.IsNumVariable():

    98

            if len(self.Data) == 0:

    99

                return self.Data

   100

   101

            start_idx = end_idx = None

   102

            if start_tick is not None:

   103

                start_idx = self.GetNearestData(start_tick, -1)

   104

            if end_tick is not None:

   105

                end_idx = self.GetNearestData(end_tick, 1)

   106

            if start_idx is None:

   107

                start_idx = 0

   108

            if end_idx is not None:

   109

                return self.Data[start_idx:end_idx + 1]

   110

            else:

   111

                return self.Data[start_idx:]

   112

   113

        return None

   114

   115

    def GetRange(self):

   116

        return self.MinValue, self.MaxValue

   117

   118

    def ResetData(self):

   119

        if self.IsNumVariable():

   120

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

   121

            self.MinValue = None

   122

            self.MaxValue = None

   123

        else:

   124

            self.Data = None

   125

   126

    def IsNumVariable(self):

   127

        return self.Parent.IsNumType(self.VariableType)

   128

   129

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

   130

        if self.IsNumVariable():

   131

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

   132

            if self.MinValue is None:

   133

                self.MinValue = num_value

   134

            else:

   135

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

   136

            if self.MaxValue is None:

   137

                self.MaxValue = num_value

   138

            else:

   139

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

   140

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

   141

            self.Parent.HasNewData = True

   142

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

   143

   144

    def SetForced(self, forced):

   145

        if self.Forced != forced:

   146

            self.Forced = forced

   147

            self.Parent.HasNewData = True

   148

   149

    def SetValue(self, value):

   150

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

   151

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

   152

            value = value[1:-1]

   153

        if self.Value != value:

   154

            self.Value = value

   155

            self.Parent.HasNewData = True

   156

   157

    def GetValue(self):

   158

        if self.VariableType == "STRING":

   159

            return "'%s'" % self.Value

   160

        elif self.VariableType == "WSTRING":

   161

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

   162

        elif isinstance(self.Value, FloatType):

   163

            return "%.6g" % self.Value

   164

        return self.Value

   165

   166

    def GetNearestData(self, tick, adjust):

   167

        if self.IsNumVariable():

   168

            ticks = self.Data[:, 0]

   169

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

   170

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

   171

                new_cursor -= 1

   172

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

   173

                new_cursor += 1

   174

            return new_cursor

   175

        return None

   176

   177

class DebugVariableTable(CustomTable):

   178

   179

    def GetValue(self, row, col):

   180

        if row < self.GetNumberRows():

   181

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

   182

        return ""

   183

   184

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

   185

        if col < len(self.colnames):

   186

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

   187

   188

    def GetValueByName(self, row, colname):

   189

        if row < self.GetNumberRows():

   190

            if colname == "Variable":

   191

                return self.data[row].GetVariable()

   192

            elif colname == "Value":

   193

                return self.data[row].GetValue()

   194

        return ""

   195

   196

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

   197

        if row < self.GetNumberRows():

   198

            if colname == "Variable":

   199

                self.data[row].SetVariable(value)

   200

            elif colname == "Value":

   201

                self.data[row].SetValue(value)

   202

   203

    def IsForced(self, row):

   204

        if row < self.GetNumberRows():

   205

            return self.data[row].IsForced()

   206

        return False

   207

   208

    def IsNumVariable(self, row):

   209

        if row < self.GetNumberRows():

   210

            return self.data[row].IsNumVariable()

   211

        return False

   212

   213

    def _updateColAttrs(self, grid):

   214

        """

   215

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

   216

        appropriate renderer given the column name.

   217

   218

        Otherwise default to the default renderer.

   219

        """

   220

   221

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

   222

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

   223

                colname = self.GetColLabelValue(col, False)

   224

                if colname == "Value":

   225

                    if self.IsForced(row):

   226

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

   227

                    else:

   228

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

   229

                grid.SetReadOnly(row, col, True)

   230

            self.ResizeRow(grid, row)

   231

   232

    def AppendItem(self, data):

   233

        self.data.append(data)

   234

   235

    def InsertItem(self, idx, data):

   236

        self.data.insert(idx, data)

   237

   238

    def RemoveItem(self, idx):

   239

        self.data.pop(idx)

   240

   241

    def MoveItem(self, idx, new_idx):

   242

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

   243

   244

    def GetItem(self, idx):

   245

        return self.data[idx]

   246

   247

class DebugVariableDropTarget(wx.TextDropTarget):

   248

   249

    def __init__(self, parent, control):

   250

        wx.TextDropTarget.__init__(self)

   251

        self.ParentWindow = parent

   252

        self.ParentControl = control

   253

   254

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

   255

        message = None

   256

        try:

   257

            values = eval(data)

   258

        except:

   259

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

   260

            values = None

   261

        if not isinstance(values, TupleType):

   262

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

   263

            values = None

   264

   265

        if message is not None:

   266

            wx.CallAfter(self.ShowMessage, message)

   267

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

   268

            if self.ParentControl == self.ParentWindow.VariablesGrid:

   269

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

   270

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

   271

                if row == wx.NOT_FOUND:

   272

                    row = self.ParentWindow.Table.GetNumberRows()

   273

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

   274

            else:

   275

                width, height = self.ParentWindow.GraphicsCanvas.GetSize()

   276

                target = None

   277

                merge_type = GRAPH_PARALLEL

   278

                for infos in self.ParentWindow.GraphicsAxes:

   279

                    if infos["axes"] != self.ParentWindow.Graphics3DAxes:

   280

                        ax, ay, aw, ah = infos["axes"].get_position().bounds

   281

                        rect = wx.Rect(ax * width, height - (ay + ah) * height,

   282

                                       aw * width, ah * height)

   283

                        if rect.InsideXY(x, y):

   284

                            target = infos

   285

                            merge_rect = wx.Rect(ax * width, height - (ay + ah) * height,

   286

                                                 aw * width / 2., ah * height)

   287

                            if merge_rect.InsideXY(x, y):

   288

                                merge_type = GRAPH_ORTHOGONAL

   289

                            break

   290

                self.ParentWindow.MergeGraphs(values[0], target, merge_type, force=True)

   291

   292

    def ShowMessage(self, message):

   293

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

   294

        dialog.ShowModal()

   295

        dialog.Destroy()

   296

   297

SCROLLBAR_UNIT = 10

   298

   299

def NextTick(variables):

   300

    next_tick = None

   301

    for var_name, data in variables:

   302

        if len(data) > 0:

   303

            if next_tick is None:

   304

                next_tick = data[0][0]

   305

            else:

   306

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

   307

    return next_tick

   308

   309

def OrthogonalData(item, start_tick, end_tick):

   310

    data = item.GetData(start_tick, end_tick)

   311

    min_value, max_value = item.GetRange()

   312

    if min_value is not None and max_value is not None:

   313

        center = (min_value + max_value) / 2.

   314

        range = max(1.0, max_value - min_value)

   315

    else:

   316

        center = 0.5

   317

        range = 1.0

   318

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

   319

   320

class DebugVariablePanel(wx.SplitterWindow, DebugViewer):

   321

   322

    def __init__(self, parent, producer, window):

   323

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

   324

   325

        self.ParentWindow = window

   326

   327

        DebugViewer.__init__(self, producer, True)

   328

   329

        self.SetSashGravity(0.5)

   330

        self.SetNeedUpdating(True)

   331

        self.SetMinimumPaneSize(1)

   332

   333

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

   334

   335

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

   336

        main_panel_sizer.AddGrowableCol(0)

   337

        main_panel_sizer.AddGrowableRow(1)

   338

   339

        button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   340

        main_panel_sizer.AddSizer(button_sizer, border=5, 

   341

              flag=wx.ALIGN_RIGHT|wx.ALL)

   342

   343

        for name, bitmap, help in [

   344

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

   345

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

   346

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

   347

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

   348

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

   349

            button.SetToolTipString(help)

   350

            setattr(self, name, button)

   351

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

   352

   353

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

   354

        self.VariablesGrid.SetDropTarget(DebugVariableDropTarget(self, self.VariablesGrid))

   355

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

   356

              self.OnVariablesGridCellRightClick)

   357

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

   358

              self.OnVariablesGridCellLeftClick)

   359

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

   360

   361

        self.MainPanel.SetSizer(main_panel_sizer)

   362

   363

        self.HasNewData = False

   364

        self.Ticks = numpy.array([])

   365

        self.RangeValues = None

   366

        self.StartTick = 0

   367

        self.Fixed = False

   368

        self.Force = False

   369

   370

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

   371

        self.VariablesGrid.SetTable(self.Table)

   372

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

   373

                                       "Up": self.UpButton,

   374

                                       "Down": self.DownButton})

   375

   376

        def _AddVariable(new_row):

   377

            return self.VariablesGrid.GetGridCursorRow()

   378

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

   379

   380

        def _DeleteVariable(row):

   381

            item = self.Table.GetItem(row)

   382

            self.RemoveDataConsumer(item)

   383

            for infos in self.GraphicsAxes:

   384

                if item in infos["items"]:

   385

                    if len(infos["items"]) == 1:

   386

                        self.GraphicsAxes.remove(infos)

   387

                    else:

   388

                        infos["items"].remove(item)

   389

                    break

   390

            self.Table.RemoveItem(row)

   391

            self.ResetGraphics()

   392

            self.RefreshGrid()

   393

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

   394

   395

        def _MoveVariable(row, move):

   396

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

   397

            if new_row != row:

   398

                self.Table.MoveItem(row, new_row)

   399

                self.ResetGraphics()

   400

                self.RefreshGrid()

   401

            return new_row

   402

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

   403

   404

        self.VariablesGrid.SetRowLabelSize(0)

   405

   406

        self.GridColSizes = [200, 100]

   407

   408

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

   409

            attr = wx.grid.GridCellAttr()

   410

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

   411

            self.VariablesGrid.SetColAttr(col, attr)

   412

            self.VariablesGrid.SetColSize(col, self.GridColSizes[col])

   413

   414

        self.Table.ResetView(self.VariablesGrid)

   415

        self.VariablesGrid.RefreshButtons()

   416

   417

        if USE_MPL:

   418

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

   419

   420

            self.GraphicsPanelSizer = wx.BoxSizer(wx.VERTICAL)

   421

   422

            graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   423

            self.GraphicsPanelSizer.AddSizer(graphics_button_sizer, border=5, flag=wx.GROW|wx.ALL)

   424

   425

            range_label = wx.StaticText(self.GraphicsPanel, label=_('Range:'))

   426

            graphics_button_sizer.AddWindow(range_label, flag=wx.ALIGN_CENTER_VERTICAL)

   427

   428

            self.CanvasRange = wx.ComboBox(self.GraphicsPanel, style=wx.CB_READONLY)

   429

            self.Bind(wx.EVT_COMBOBOX, self.OnRangeChanged, self.CanvasRange)

   430

            graphics_button_sizer.AddWindow(self.CanvasRange, 1, 

   431

                  border=5, flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL)

   432

   433

            for name, bitmap, help in [

   434

                ("ResetButton", "reset", _("Clear the graph values")),

   435

                ("CurrentButton", "current", _("Go to current value")),

   436

                ("ExportGraphButton", "export_graph", _("Export graph values to clipboard"))]:

   437

                button = wx.lib.buttons.GenBitmapButton(self.GraphicsPanel, 

   438

                      bitmap=GetBitmap(bitmap), 

   439

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

   440

                button.SetToolTipString(help)

   441

                setattr(self, name, button)

   442

                self.Bind(wx.EVT_BUTTON, getattr(self, "On" + name), button)

   443

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

   444

   445

            self.CanvasPosition = wx.ScrollBar(self.GraphicsPanel, 

   446

                  size=wx.Size(0, 16), style=wx.SB_HORIZONTAL)

   447

            self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK, 

   448

                  self.OnPositionChanging, self.CanvasPosition)

   449

            self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP, 

   450

                  self.OnPositionChanging, self.CanvasPosition)

   451

            self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN, 

   452

                  self.OnPositionChanging, self.CanvasPosition)

   453

            self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP, 

   454

                  self.OnPositionChanging, self.CanvasPosition)

   455

            self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN, 

   456

                  self.OnPositionChanging, self.CanvasPosition)

   457

            self.GraphicsPanelSizer.AddWindow(self.CanvasPosition, border=5, flag=wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM)

   458

   459

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

   460

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

   461

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

   462

   463

            graphics_canvas_window_sizer = wx.BoxSizer(wx.VERTICAL)

   464

   465

            self.GraphicsFigure = matplotlib.figure.Figure()

   466

            self.GraphicsAxes = []

   467

   468

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

   469

            self.GraphicsCanvas.mpl_connect("button_press_event", self.OnGraphicsCanvasClick)

   470

            self.GraphicsCanvas.SetDropTarget(DebugVariableDropTarget(self, self.GraphicsCanvas))

   471

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

   472

   473

            self.GraphicsCanvasWindow.SetSizer(graphics_canvas_window_sizer)

   474

   475

            self.Graphics3DFigure = matplotlib.figure.Figure()

   476

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

   477

   478

            self.LastMotionTime = gettime()

   479

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

   480

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

   481

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

   482

   483

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

   484

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

   485

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

   486

   487

            self.Graphics3DAxes.mouse_init()

   488

   489

            self.GraphicsPanel.SetSizer(self.GraphicsPanelSizer)

   490

   491

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

   492

   493

        else:

   494

            self.Initialize(self.MainPanel)

   495

   496

        self.ResetGraphics()

   497

        self.RefreshCanvasRange()

   498

        self.RefreshScrollBar()

   499

   500

    def SetDataProducer(self, producer):

   501

        DebugViewer.SetDataProducer(self, producer)

   502