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

    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 mpl_toolkits.mplot3d import Axes3D

    39

    USE_MPL = True

    40

except:

    41

    USE_MPL = False

    42

    43

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    44

from controls import CustomGrid, CustomTable

    45

from dialogs.ForceVariableDialog import ForceVariableDialog

    46

from util.BitmapLibrary import GetBitmap

    47

    48

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

    49

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

    50

    51

def GetDebugVariablesTableColnames():

    52

    _ = lambda x : x

    53

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

    54

    55

class VariableTableItem(DebugDataConsumer):

    56

    57

    def __init__(self, parent, variable):

    58

        DebugDataConsumer.__init__(self)

    59

        self.Parent = parent

    60

        self.Variable = variable

    61

        self.RefreshVariableType()

    62

        self.Value = ""

    63

    64

    def __del__(self):

    65

        self.Parent = None

    66

    67

    def SetVariable(self, variable):

    68

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

    69

            self.Variable = variable

    70

            self.RefreshVariableType()

    71

            self.Parent.RefreshView()

    72

    73

    def GetVariable(self, max_size=None):

    74

        variable = self.Variable

    75

        if max_size is not None:

    76

            max_size = max(max_size, 10)

    77

            if len(variable) > max_size:

    78

                variable = "..." + variable[-(max_size - 3):]

    79

        return variable

    80

    81

    def RefreshVariableType(self):

    82

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

    83

        if USE_MPL:

    84

            self.ResetData()

    85

    86

    def GetVariableType(self):

    87

        return self.VariableType

    88

    89

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

    90

        if USE_MPL and self.IsNumVariable():

    91

            if len(self.Data) == 0:

    92

                return self.Data

    93

    94

            start_idx = end_idx = None

    95

            if start_tick is not None:

    96

                start_idx = self.GetNearestData(start_tick, -1)

    97

            if end_tick is not None:

    98

                end_idx = self.GetNearestData(end_tick, 1)

    99

            if start_idx is None:

   100

                start_idx = 0

   101

            if end_idx is not None:

   102

                return self.Data[start_idx:end_idx + 1]

   103

            else:

   104

                return self.Data[start_idx:]

   105

   106

        return None

   107

   108

    def GetRange(self):

   109

        return self.MinValue, self.MaxValue

   110

   111

    def ResetData(self):

   112

        if self.IsNumVariable():

   113

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

   114

            self.MinValue = None

   115

            self.MaxValue = None

   116

        else:

   117

            self.Data = None

   118

   119

    def IsNumVariable(self):

   120

        return self.Parent.IsNumType(self.VariableType)

   121

   122

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

   123

        if USE_MPL and self.IsNumVariable():

   124

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

   125

            if self.MinValue is None:

   126

                self.MinValue = num_value

   127

            else:

   128

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

   129

            if self.MaxValue is None:

   130

                self.MaxValue = num_value

   131

            else:

   132

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

   133

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

   134

            self.Parent.HasNewData = True

   135

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

   136

   137

    def SetForced(self, forced):

   138

        if self.Forced != forced:

   139

            self.Forced = forced

   140

            self.Parent.HasNewData = True

   141

   142

    def SetValue(self, value):

   143

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

   144

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

   145

            value = value[1:-1]

   146

        if self.Value != value:

   147

            self.Value = value

   148

            self.Parent.HasNewData = True

   149

   150

    def GetValue(self):

   151

        if self.VariableType == "STRING":

   152

            return "'%s'" % self.Value

   153

        elif self.VariableType == "WSTRING":

   154

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

   155

        elif isinstance(self.Value, FloatType):

   156

            return "%.6g" % self.Value

   157

        return self.Value

   158

   159

    def GetNearestData(self, tick, adjust):

   160

        if USE_MPL and self.IsNumVariable():

   161

            ticks = self.Data[:, 0]

   162

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

   163

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

   164

                new_cursor -= 1

   165

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

   166

                new_cursor += 1

   167

            return new_cursor

   168

        return None

   169

   170

class DebugVariableTable(CustomTable):

   171

   172

    def GetValue(self, row, col):

   173

        if row < self.GetNumberRows():

   174

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

   175

        return ""

   176

   177

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

   178

        if col < len(self.colnames):

   179

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

   180

   181

    def GetValueByName(self, row, colname):

   182

        if row < self.GetNumberRows():

   183

            if colname == "Variable":

   184

                return self.data[row].GetVariable()

   185

            elif colname == "Value":

   186

                return self.data[row].GetValue()

   187

        return ""

   188

   189

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

   190

        if row < self.GetNumberRows():

   191

            if colname == "Variable":

   192

                self.data[row].SetVariable(value)

   193

            elif colname == "Value":

   194

                self.data[row].SetValue(value)

   195

   196

    def IsForced(self, row):

   197

        if row < self.GetNumberRows():

   198

            return self.data[row].IsForced()

   199

        return False

   200

   201

    def IsNumVariable(self, row):

   202

        if row < self.GetNumberRows():

   203

            return self.data[row].IsNumVariable()

   204

        return False

   205

   206

    def _updateColAttrs(self, grid):

   207

        """

   208

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

   209

        appropriate renderer given the column name.

   210

   211

        Otherwise default to the default renderer.

   212

        """

   213

   214

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

   215

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

   216

                colname = self.GetColLabelValue(col, False)

   217

                if colname == "Value":

   218

                    if self.IsForced(row):

   219

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

   220

                    else:

   221

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

   222

                grid.SetReadOnly(row, col, True)

   223

            self.ResizeRow(grid, row)

   224

   225

    def AppendItem(self, data):

   226

        self.data.append(data)

   227

   228

    def InsertItem(self, idx, data):

   229

        self.data.insert(idx, data)

   230

   231

    def RemoveItem(self, idx):

   232

        self.data.pop(idx)

   233

   234

    def MoveItem(self, idx, new_idx):

   235

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

   236

   237

    def GetItem(self, idx):

   238

        return self.data[idx]

   239

   240

class DebugVariableDropTarget(wx.TextDropTarget):

   241

   242

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

   243

        wx.TextDropTarget.__init__(self)

   244

        self.ParentWindow = parent

   245

        self.ParentControl = control

   246

   247

    def __del__(self):

   248

        self.ParentWindow = None

   249

        self.ParentControl = None

   250

   251

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

   252

        message = None

   253

        try:

   254

            values = eval(data)

   255

        except:

   256

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

   257

            values = None

   258

        if not isinstance(values, TupleType):

   259

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

   260

            values = None

   261

   262

        if message is not None:

   263

            wx.CallAfter(self.ShowMessage, message)

   264

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

   265

            if isinstance(self.ParentControl, CustomGrid):

   266

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

   267

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

   268

                if row == wx.NOT_FOUND:

   269

                    row = self.ParentWindow.Table.GetNumberRows()

   270

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

   271

            elif self.ParentControl is not None:

   272

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

   273

                target_idx = self.ParentControl.GetIndex()

   274

                merge_type = GRAPH_PARALLEL

   275

                if self.ParentControl.Is3DCanvas():

   282

                else:

   283

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

   284

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

   285

                                   aw * width, ah * height)

   286

                    if rect.InsideXY(x, y):

   287

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

   288

                                             aw * width / 2., ah * height)

   289

                        if merge_rect.InsideXY(x, y):

   290

                            merge_type = GRAPH_ORTHOGONAL

   291

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

   292

                    else:

   301

            else:

   302

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

   303

   304

    def ShowMessage(self, message):

   305

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

   306

        dialog.ShowModal()

   307

        dialog.Destroy()

   308

   309

if USE_MPL:

   310

    SECOND = 1000000000

   311

    MINUTE = 60 * SECOND

   312

    HOUR = 60 * MINUTE

   313

   314

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

   315

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

   316

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

   317

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

   318

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

   319

   320

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   321

   322

    SCROLLBAR_UNIT = 10

   323

   324

    def NextTick(variables):

   325

        next_tick = None

   326

        for var_name, data in variables:

   327

            if len(data) > 0:

   328

                if next_tick is None:

   329

                    next_tick = data[0][0]

   330

                else:

   331

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

   332

        return next_tick

   333

   334

    def OrthogonalData(item, start_tick, end_tick):

   335

        data = item.GetData(start_tick, end_tick)

   336

        min_value, max_value = item.GetRange()

   337

        if min_value is not None and max_value is not None:

   338

            center = (min_value + max_value) / 2.

   339

            range = max(1.0, max_value - min_value)

   340

        else:

   341

            center = 0.5

   342

            range = 1.0

   343

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

   344

   345

    class DebugVariableViewer(wx.Panel):

   346

   347

        def AddViewer(self):

   348

            pass

   349

   350

        def AddButtons(self):

   351

            pass

   352

   353

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

   354

            wx.Panel.__init__(self, parent)

   355

            self.SetBackgroundColour(wx.WHITE)

   356

            self.SetDropTarget(DebugVariableDropTarget(window, self))

   357

   358

            self.ParentWindow = window

   359

            self.Items = items

   360

   361

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

   362

            self.AddViewer()

   363

            self.AddButtons()

   364

            self.MainSizer.AddGrowableCol(0)

   365

   366

            self.SetSizer(self.MainSizer)

   367

   368

        def __del__(self):

   369

            self.ParentWindow = None

   370

   371

        def GetIndex(self):

   372

            return self.ParentWindow.GetViewerIndex(self)

   373

   374

        def GetItem(self, variable):

   375

            for item in self.Items:

   376

                if item.GetVariable() == variable:

   377

                    return item

   378

            return None

   379

   380

        def GetItems(self):

   381

            return self.Items

   382

   383

        def GetVariables(self):

   384

            if len(self.Items) > 1:

   385

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

   386

                if self.GraphType == GRAPH_ORTHOGONAL:

   387

                    return tuple(variables)

   388

                return variables

   389

            return self.Items[0].GetVariable()

   390

   391

        def AddItem(self, item):

   392

            self.Items.append(item)

   393

   394

        def RemoveItem(self, item):

   395

            if item in self.Items:

   396

                self.Items.remove(item)

   397

   398

        def Clear(self):

   399

            for item in self.Items:

   400

                self.ParentWindow.RemoveDataConsumer(item)

   401

            self.Items = []

   402

   403

        def IsEmpty(self):

   404

            return len(self.Items) == 0

   405

   406

        def UnregisterObsoleteData(self):

   407

            for item in self.Items[:]:

   408

                iec_path = item.GetVariable().upper()

   409

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

   410

                    self.ParentWindow.RemoveDataConsumer(item)

   411

                    self.RemoveItem(item)

   412

                else:

   413

                    self.ParentWindow.AddDataConsumer(iec_path, item)

   414

                    item.RefreshVariableType()

   415

   416

        def ResetData(self):

   417

            for item in self.Items:

   418

                item.ResetData()

   419

   420

        def Refresh(self):

   421

            pass

   422

   423

        def OnForceButton(self, event):

   424

            if len(self.Items) == 1:

   425

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

   426

            else:

   427

                menu = wx.Menu(title='')

   428

                for item in self.Items:

   429

                    new_id = wx.NewId()

   430

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

   431

                        text=item.GetVariable(20))

   432

                    self.Bind(wx.EVT_MENU, 

   433

                        self.GetForceVariableMenuFunction(item),

   434

                        id=new_id)

   435

                self.PopupMenu(menu)

   436

            event.Skip()

   437

   438

        def OnReleaseButton(self, event):

   439

            if len(self.Items) == 1:

   440

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

   441

            else:

   442

                menu = wx.Menu(title='')

   443

                for item in self.Items:

   444

                    new_id = wx.NewId()

   445

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

   446

                        text=item.GetVariable(20))

   447

                    self.Bind(wx.EVT_MENU, 

   448

                        self.GetReleaseVariableMenuFunction(item),

   449

                        id=new_id)

   450

   451

                self.PopupMenu(menu)

   452

            event.Skip()

   453

   454

        def OnDeleteButton(self, event):

   455

            if len(self.Items) == 1:

   456

                wx.CallAfter(self.ParentWindow.DeleteValue, self, self.Items[0])

   457

            else:

   458

                menu = wx.Menu(title='')

   459

                for item in self.Items:

   460

                    new_id = wx.NewId()

   461

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

   462

                        text=item.GetVariable(20))

   463

                    self.Bind(wx.EVT_MENU, 

   464

                        self.GetDeleteValueMenuFunction(item),

   465

                        id=new_id)

   466

   467

                new_id = wx.NewId()

   468

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

   469

                self.Bind(wx.EVT_MENU, self.OnDeleteAllValuesMenu, id=new_id)

   470

   471

                self.PopupMenu(menu)

   472

            event.Skip()

   473

   474

        def GetForceVariableMenuFunction(self, item):

   475

            def ForceVariableFunction(event):

   476

                self.ForceValue(item)

   477

            return ForceVariableFunction

   478

   479

        def GetReleaseVariableMenuFunction(self, item):

   480

            def ReleaseVariableFunction(event):

   481

                self.ReleaseValue(item)

   482

            return ReleaseVariableFunction

   483

   484

        def GetDeleteValueMenuFunction(self, item):

   485

            def DeleteValueFunction(event):

   486

                self.ParentWindow.DeleteValue(self, item)

   487

            return DeleteValueFunction

   488

   489

        def ForceValue(self, item):

   490

            iec_path = item.GetVariable().upper()

   491

            iec_type = self.ParentWindow.GetDataType(iec_path)

   492

            if iec_type is not None:

   493

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

   494

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

   495

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

   496

   497

        def ReleaseValue(self, item):

   498

            iec_path = item.GetVariable().upper()

   499

            self.ParentWindow.ReleaseDataValue(iec_path)

   500

   501

        def OnDeleteAllValuesMenu(self, event):