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

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

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

    50

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

    51

    52

def GetDebugVariablesTableColnames():

    53

    _ = lambda x : x

    54

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

    59

class VariableTableItem(DebugDataConsumer):

    60

    61

    def __init__(self, parent, variable):

    62

        DebugDataConsumer.__init__(self)

    63

        self.Parent = parent

    64

        self.Variable = variable

    65

        self.RefreshVariableType()

    66

        self.Value = ""

    67

    68

    def __del__(self):

    69

        self.Parent = None

    70

    71

    def SetVariable(self, variable):

    72

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

    73

            self.Variable = variable

    74

            self.RefreshVariableType()

    75

            self.Parent.RefreshView()

    76

    78

        variable = self.Variable

    92

        return variable

    93

    94

    def RefreshVariableType(self):

    95

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

    96

        if USE_MPL:

    97

            self.ResetData()

    98

    99

    def GetVariableType(self):

   100

        return self.VariableType

   101

   102

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

   103

        if USE_MPL and self.IsNumVariable():

   104

            if len(self.Data) == 0:

   105

                return self.Data

   106

   107

            start_idx = end_idx = None

   108

            if start_tick is not None:

   109

                start_idx = self.GetNearestData(start_tick, -1)

   110

            if end_tick is not None:

   111

                end_idx = self.GetNearestData(end_tick, 1)

   112

            if start_idx is None:

   113

                start_idx = 0

   114

            if end_idx is not None:

   115

                return self.Data[start_idx:end_idx + 1]

   116

            else:

   117

                return self.Data[start_idx:]

   118

   119

        return None

   120

   126

    def GetRange(self):

   127

        return self.MinValue, self.MaxValue

   128

   129

    def ResetData(self):

   130

        if self.IsNumVariable():

   134

            self.MinValue = None

   135

            self.MaxValue = None

   136

        else:

   137

            self.Data = None

   138

   139

    def IsNumVariable(self):

   142

   143

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

   144

        if USE_MPL and self.IsNumVariable():

   149

            if self.MinValue is None:

   150

                self.MinValue = num_value

   151

            else:

   152

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

   153

            if self.MaxValue is None:

   154

                self.MaxValue = num_value

   155

            else:

   156

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

   168

            self.Parent.HasNewData = True

   169

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

   170

   171

    def SetForced(self, forced):

   172

        if self.Forced != forced:

   173

            self.Forced = forced

   174

            self.Parent.HasNewData = True

   175

   176

    def SetValue(self, value):

   177

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

   178

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

   179

            value = value[1:-1]

   180

        if self.Value != value:

   181

            self.Value = value

   182

            self.Parent.HasNewData = True

   183

   207

        return self.Value

   208

   209

    def GetNearestData(self, tick, adjust):

   210

        if USE_MPL and self.IsNumVariable():

   211

            ticks = self.Data[:, 0]

   212

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

   213

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

   214

                new_cursor -= 1

   215

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

   216

                new_cursor += 1

   217

            return new_cursor

   218

        return None

   219

   220

class DebugVariableTable(CustomTable):

   221

   222

    def GetValue(self, row, col):

   223

        if row < self.GetNumberRows():

   224

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

   225

        return ""

   226

   227

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

   228

        if col < len(self.colnames):

   229

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

   230

   231

    def GetValueByName(self, row, colname):

   232

        if row < self.GetNumberRows():

   233

            if colname == "Variable":

   234

                return self.data[row].GetVariable()

   235

            elif colname == "Value":

   236

                return self.data[row].GetValue()

   237

        return ""

   238

   239

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

   240

        if row < self.GetNumberRows():

   241

            if colname == "Variable":

   242

                self.data[row].SetVariable(value)

   243

            elif colname == "Value":

   244

                self.data[row].SetValue(value)

   245

   246

    def IsForced(self, row):

   247

        if row < self.GetNumberRows():

   248

            return self.data[row].IsForced()

   249

        return False

   250

   251

    def IsNumVariable(self, row):

   252

        if row < self.GetNumberRows():

   253

            return self.data[row].IsNumVariable()

   254

        return False

   255

   256

    def _updateColAttrs(self, grid):

   257

        """

   258

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

   259

        appropriate renderer given the column name.

   260

   261

        Otherwise default to the default renderer.

   262

        """

   263

   264

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

   265

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

   266

                colname = self.GetColLabelValue(col, False)

   267

                if colname == "Value":

   268

                    if self.IsForced(row):

   269

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

   270

                    else:

   271

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

   272

                grid.SetReadOnly(row, col, True)

   273

            self.ResizeRow(grid, row)

   274

   275

    def AppendItem(self, data):

   276

        self.data.append(data)

   277

   278

    def InsertItem(self, idx, data):

   279

        self.data.insert(idx, data)

   280

   281

    def RemoveItem(self, idx):

   282

        self.data.pop(idx)

   283

   284

    def MoveItem(self, idx, new_idx):

   285

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

   286

   287

    def GetItem(self, idx):

   288

        return self.data[idx]

   289

   290

class DebugVariableDropTarget(wx.TextDropTarget):

   291

   292

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

   293

        wx.TextDropTarget.__init__(self)

   294

        self.ParentWindow = parent

   295

        self.ParentControl = control

   296

   297

    def __del__(self):

   298

        self.ParentWindow = None

   299

        self.ParentControl = None

   300

   301

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

   302

        message = None

   303

        try:

   304

            values = eval(data)

   305

        except:

   306

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

   307

            values = None

   308

        if not isinstance(values, TupleType):

   309

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

   310

            values = None

   311

   312

        if message is not None:

   313

            wx.CallAfter(self.ShowMessage, message)

   314

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

   315

            if isinstance(self.ParentControl, CustomGrid):

   316

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

   317

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

   318

                if row == wx.NOT_FOUND:

   319

                    row = self.ParentWindow.Table.GetNumberRows()

   320

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

   321

            elif self.ParentControl is not None:

   322

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

   323

                target_idx = self.ParentControl.GetIndex()

   324

                merge_type = GRAPH_PARALLEL

   325

                if self.ParentControl.Is3DCanvas():

   326

                    if y > height / 2:

   327

                        target_idx += 1

   328

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

   329

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

   330

                    else:

   331

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

   332

                else:

   333

                    ax, ay, aw, ah = self.ParentControl.Axes.get_position().bounds

   334

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

   335

                                   aw * width, ah * height)

   336

                    if rect.InsideXY(x, y):

   337

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

   338

                                             aw * width / 2., ah * height)

   339

                        if merge_rect.InsideXY(x, y):

   340

                            merge_type = GRAPH_ORTHOGONAL

   341

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

   342

                    else:

   343

                        if y > height / 2:

   344

                            target_idx += 1

   345

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

   346

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

   347

                        else:

   348

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

   349

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

   350

                self.ParentWindow.MoveGraph(values[0])

   351

            else:

   352

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

   353

   354

    def ShowMessage(self, message):

   355

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

   356

        dialog.ShowModal()

   357

        dialog.Destroy()

   358

   359

if USE_MPL:

   362

    MINUTE = 60 * SECOND

   363

    HOUR = 60 * MINUTE

   365

   366

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

   367

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

   368

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

   369

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

   370

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

   371

   372

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   373

   374

    SCROLLBAR_UNIT = 10

   375

   376

    def NextTick(variables):

   377

        next_tick = None

   379

            if len(data) > 0:

   380

                if next_tick is None:

   381

                    next_tick = data[0][0]

   382

                else:

   383

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

   384

        return next_tick

   385

   386

    def OrthogonalData(item, start_tick, end_tick):

   387

        data = item.GetData(start_tick, end_tick)

   388

        min_value, max_value = item.GetRange()

   389

        if min_value is not None and max_value is not None:

   390

            center = (min_value + max_value) / 2.

   391

            range = max(1.0, max_value - min_value)

   392

        else:

   393

            center = 0.5

   394

            range = 1.0

   395

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

   396

   397

    class DebugVariableViewer(wx.Panel):

   398

   399

        def AddViewer(self):

   400

            pass

   401

   402

        def AddButtons(self):

   403

            pass

   404

   405

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

   406

            wx.Panel.__init__(self, parent)

   407

            self.SetBackgroundColour(wx.WHITE)

   408

            self.SetDropTarget(DebugVariableDropTarget(window, self))

   409

   410

            self.ParentWindow = window

   411

            self.Items = items

   413

   414

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

   415

            self.AddViewer()

   416

            self.AddButtons()

   417

            self.MainSizer.AddGrowableCol(0)

   418

   419

            self.SetSizer(self.MainSizer)

   420

   421

        def __del__(self):

   422

            self.ParentWindow = None

   423

   424

        def GetIndex(self):

   425

            return self.ParentWindow.GetViewerIndex(self)

   426

   427

        def GetItem(self, variable):

   428

            for item in self.Items:

   429

                if item.GetVariable() == variable:

   430

                    return item

   431

            return None

   432

   433

        def GetItems(self):

   434

            return self.Items

   435

   436

        def GetVariables(self):

   437

            if len(self.Items) > 1:

   438

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

   439

                if self.GraphType == GRAPH_ORTHOGONAL:

   440

                    return tuple(variables)

   441

                return variables

   442

            return self.Items[0].GetVariable()

   443

   453

        def AddItem(self, item):

   454

            self.Items.append(item)

   456

   457

        def RemoveItem(self, item):

   458

            if item in self.Items:

   459

                self.Items.remove(item)

   461

   462

        def Clear(self):

   463

            for item in self.Items:

   464

                self.ParentWindow.RemoveDataConsumer(item)

   465

            self.Items = []

   467

   468

        def IsEmpty(self):

   469

            return len(self.Items) == 0

   470

   471

        def UnregisterObsoleteData(self):

   472

            for item in self.Items[:]:

   473

                iec_path = item.GetVariable().upper()

   474

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

   475

                    self.ParentWindow.RemoveDataConsumer(item)

   476

                    self.RemoveItem(item)

   477

                else:

   478

                    self.ParentWindow.AddDataConsumer(iec_path, item)

   479

                    item.RefreshVariableType()

   481

   482

        def ResetData(self):

   483

            for item in self.Items:

   484

                item.ResetData()

   485

   486

        def Refresh(self):

   487

            pass

   488

   489

        def OnForceButton(self, event):

   490

            if len(self.Items) == 1:

   491

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

   492

            else:

   493

                menu = wx.Menu(title='')

   494

                for item in self.Items:

   495

                    new_id = wx.NewId()

   496

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

   498

                    self.Bind(wx.EVT_MENU, 

   499

                        self.GetForceVariableMenuFunction(item),