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

import binascii

    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 matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    40

    from matplotlib.backends.backend_agg import FigureCanvasAgg

    41

    from mpl_toolkits.mplot3d import Axes3D

    42

    color_cycle = matplotlib.rcParams['axes.color_cycle']

    43

    USE_MPL = True

    44

except:

    45

    USE_MPL = False

    46

    47

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    48

from controls import CustomGrid, CustomTable

    49

from dialogs.ForceVariableDialog import ForceVariableDialog

    50

from util.BitmapLibrary import GetBitmap

    51

    52

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

    53

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

    54

    55

def GetDebugVariablesTableColnames():

    56

    _ = lambda x : x

    57

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

    58

    59

CRC_SIZE = 8

    60

CRC_MASK = 2 ** CRC_SIZE - 1

    61

    62

class VariableTableItem(DebugDataConsumer):

    63

    64

    def __init__(self, parent, variable):

    65

        DebugDataConsumer.__init__(self)

    66

        self.Parent = parent

    67

        self.Variable = variable

    68

        self.RefreshVariableType()

    69

        self.Value = ""

    70

    71

    def __del__(self):

    72

        self.Parent = None

    73

    74

    def SetVariable(self, variable):

    75

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

    76

            self.Variable = variable

    77

            self.RefreshVariableType()

    78

            self.Parent.RefreshView()

    79

    80

    def GetVariable(self, mask=None):

    81

        variable = self.Variable

    82

        if mask is not None:

    83

            parts = variable.split('.')

    84

            mask = mask + ['*'] * max(0, len(parts) - len(mask))

    85

            last = None

    86

            variable = ""

    87

            for m, v in zip(mask, parts):

    88

                if m == '*':

    89

                    if last == '*':

    90

                        variable += '.'

    91

                    variable += v

    92

                elif last is None or last == '*':

    93

                    variable += '..'

    94

                last = m

    95

        return variable

    96

    97

    def RefreshVariableType(self):

    98

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

    99

        if USE_MPL:

   100

            self.ResetData()

   101

   102

    def GetVariableType(self):

   103

        return self.VariableType

   104

   105

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

   106

        if USE_MPL and self.IsNumVariable():

   107

            if len(self.Data) == 0:

   108

                return self.Data

   109

   110

            start_idx = end_idx = None

   111

            if start_tick is not None:

   112

                start_idx = self.GetNearestData(start_tick, -1)

   113

            if end_tick is not None:

   114

                end_idx = self.GetNearestData(end_tick, 1)

   115

            if start_idx is None:

   116

                start_idx = 0

   117

            if end_idx is not None:

   118

                return self.Data[start_idx:end_idx + 1]

   119

            else:

   120

                return self.Data[start_idx:]

   121

   122

        return None

   123

   124

    def GetRawValue(self, idx):

   125

        if self.VariableType in ["STRING", "WSTRING"] and idx < len(self.RawData):

   126

            return self.RawData[idx][0]

   127

        return ""

   128

   129

    def GetRange(self):

   130

        return self.MinValue, self.MaxValue

   131

   132

    def ResetData(self):

   133

        if self.IsNumVariable():

   134

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

   135

            if self.VariableType in ["STRING", "WSTRING"]:

   136

                self.RawData = []

   137

            self.MinValue = None

   138

            self.MaxValue = None

   139

        else:

   140

            self.Data = None

   141

   142

    def IsNumVariable(self):

   143

        return (self.Parent.IsNumType(self.VariableType) or 

   144

                self.VariableType in ["STRING", "WSTRING"])

   145

   146

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

   147

        if USE_MPL and self.IsNumVariable():

   148

            if self.VariableType in ["STRING", "WSTRING"]:

   149

                num_value = binascii.crc32(value) & CRC_MASK

   150

            else:

   151

                num_value = float(value)

   152

            if self.MinValue is None:

   153

                self.MinValue = num_value

   154

            else:

   155

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

   156

            if self.MaxValue is None:

   157

                self.MaxValue = num_value

   158

            else:

   159

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

   160

            forced_value = float(forced)

   161

            if self.VariableType in ["STRING", "WSTRING"]:

   162

                raw_data = (value, forced_value)

   163

                if len(self.RawData) == 0 or self.RawData[-1] != raw_data:

   164

                    extra_value = len(self.RawData)

   165

                    self.RawData.append(raw_data)

   166

                else:

   167

                    extra_value = len(self.RawData) - 1

   168

            else:

   169

                extra_value = forced_value

   170

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

   171

            self.Parent.HasNewData = True

   172

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

   173

   174

    def SetForced(self, forced):

   175

        if self.Forced != forced:

   176

            self.Forced = forced

   177

            self.Parent.HasNewData = True

   178

   179

    def SetValue(self, value):

   180

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

   181

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

   182

            value = value[1:-1]

   183

        if self.Value != value:

   184

            self.Value = value

   185

            self.Parent.HasNewData = True

   186

   187

    def GetValue(self, tick=None, raw=False):

   188

        if tick is not None and self.IsNumVariable():

   189

            if len(self.Data) > 0:

   190

                idx = numpy.argmin(abs(self.Data[:, 0] - tick))

   191

                if self.VariableType in ["STRING", "WSTRING"]:

   192

                    value, forced = self.RawData[int(self.Data[idx, 2])]

   193

                    if not raw:

   194

                        if self.VariableType == "STRING":

   195

                            value = "'%s'" % value

   196

                        else:

   197

                            value = '"%s"' % value

   198

                    return value, forced

   199

                else:

   200

                    value = self.Data[idx, 1]

   201

                    if not raw and isinstance(value, FloatType):

   202

                        value = "%.6g" % value

   203

                    return value, self.Data[idx, 2]

   204

            return self.Value, self.IsForced()

   205

        elif not raw:

   206

            if self.VariableType == "STRING":

   207

                return "'%s'" % self.Value

   208

            elif self.VariableType == "WSTRING":

   209

                return '"%s"' % self.Value

   210

            elif isinstance(self.Value, FloatType):

   211

                return "%.6g" % self.Value

   212

        return self.Value

   213

   214

    def GetNearestData(self, tick, adjust):

   215

        if USE_MPL and self.IsNumVariable():

   216

            ticks = self.Data[:, 0]

   217

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

   218

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

   219

                new_cursor -= 1

   220

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

   221

                new_cursor += 1

   222

            return new_cursor

   223

        return None

   224

   225

class DebugVariableTable(CustomTable):

   226

   227

    def GetValue(self, row, col):

   228

        if row < self.GetNumberRows():

   229

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

   230

        return ""

   231

   232

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

   233

        if col < len(self.colnames):

   234

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

   235

   236

    def GetValueByName(self, row, colname):

   237

        if row < self.GetNumberRows():

   238

            if colname == "Variable":

   239

                return self.data[row].GetVariable()

   240

            elif colname == "Value":

   241

                return self.data[row].GetValue()

   242

        return ""

   243

   244

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

   245

        if row < self.GetNumberRows():

   246

            if colname == "Variable":

   247

                self.data[row].SetVariable(value)

   248

            elif colname == "Value":

   249

                self.data[row].SetValue(value)

   250

   251

    def IsForced(self, row):

   252

        if row < self.GetNumberRows():

   253

            return self.data[row].IsForced()

   254

        return False

   255

   256

    def IsNumVariable(self, row):

   257

        if row < self.GetNumberRows():

   258

            return self.data[row].IsNumVariable()

   259

        return False

   260

   261

    def _updateColAttrs(self, grid):

   262

        """

   263

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

   264

        appropriate renderer given the column name.

   265

   266

        Otherwise default to the default renderer.

   267

        """

   268

   269

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

   270

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

   271

                colname = self.GetColLabelValue(col, False)

   272

                if colname == "Value":

   273

                    if self.IsForced(row):

   274

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

   275

                    else:

   276

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

   277

                grid.SetReadOnly(row, col, True)

   278

            self.ResizeRow(grid, row)

   279

   280

    def AppendItem(self, data):

   281

        self.data.append(data)

   282

   283

    def InsertItem(self, idx, data):

   284

        self.data.insert(idx, data)

   285

   286

    def RemoveItem(self, idx):

   287

        self.data.pop(idx)

   288

   289

    def MoveItem(self, idx, new_idx):

   290

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

   291

   292

    def GetItem(self, idx):

   293

        return self.data[idx]

   294

   295

class DebugVariableDropTarget(wx.TextDropTarget):

   296

   297

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

   298

        wx.TextDropTarget.__init__(self)

   299

        self.ParentWindow = parent

   300

        self.ParentControl = control

   301

   302

    def __del__(self):

   303

        self.ParentWindow = None

   304

        self.ParentControl = None

   305

   306

    def OnDragOver(self, x, y, d):

   307

        if self.ParentControl is not None:

   308

            self.ParentControl.OnCanvasDragging(x, y)

   309

        return wx.TextDropTarget.OnDragOver(self, x, y, d)

   310

   311

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

   312

        message = None

   313

        try:

   314

            values = eval(data)

   315

        except:

   316

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

   317

            values = None

   318

        if not isinstance(values, TupleType):

   319

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

   320

            values = None

   321

   322

        if message is not None:

   323

            wx.CallAfter(self.ShowMessage, message)

   324

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

   325

            if isinstance(self.ParentControl, CustomGrid):

   326

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

   327

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

   328

                if row == wx.NOT_FOUND:

   329

                    row = self.ParentWindow.Table.GetNumberRows()

   330

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

   331

            elif self.ParentControl is not None:

   332

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

   333

                target_idx = self.ParentControl.GetIndex()

   334

                merge_type = GRAPH_PARALLEL

   335

                if self.ParentControl.Is3DCanvas():

   336

                    if y > height / 2:

   337

                        target_idx += 1

   339

                else:

   340

                    rect = self.ParentControl.GetAxesBoundingBox()

   341

                    if rect.InsideXY(x, y):

   342

                        merge_rect = wx.Rect(rect.x, rect.y, rect.width / 2., rect.height)

   343

                        if merge_rect.InsideXY(x, y):

   344

                            merge_type = GRAPH_ORTHOGONAL

   345

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

   346

                    else:

   347

                        if y > height / 2:

   348

                            target_idx += 1

   351

   352

    def OnLeave(self):

   353

        if self.ParentControl is not None:

   354

            self.ParentControl.OnCanvasLeave()

   355

        return wx.TextDropTarget.OnLeave(self)

   356

   357

    def ShowMessage(self, message):

   358

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

   359

        dialog.ShowModal()

   360

        dialog.Destroy()

   361

   362

if USE_MPL:

   363

    MILLISECOND = 1000000

   364

    SECOND = 1000 * MILLISECOND

   365

    MINUTE = 60 * SECOND

   366

    HOUR = 60 * MINUTE

   367

    DAY = 24 * HOUR

   368

   369

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

   370

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

   371

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

   372

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

   373

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

   374

   375

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   376

   377

    SCROLLBAR_UNIT = 10

   378

   379

    def NextTick(variables):

   380

        next_tick = None

   381

        for item, data in variables:

   382

            if len(data) > 0:

   383

                if next_tick is None:

   384

                    next_tick = data[0][0]

   385

                else:

   386

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

   387

        return next_tick

   388

   389

    def OrthogonalData(item, start_tick, end_tick):

   390

        data = item.GetData(start_tick, end_tick)

   391

        min_value, max_value = item.GetRange()

   392

        if min_value is not None and max_value is not None:

   393

            center = (min_value + max_value) / 2.

   394

            range = max(1.0, max_value - min_value)

   395

        else:

   396

            center = 0.5

   397

            range = 1.0

   398

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

   399

   400

    class DebugVariableViewer(wx.Panel):

   401

   402

        def AddViewer(self):

   403

            pass

   404

   405

        def AddButtons(self):

   406

            pass

   407

   408

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

   409

            wx.Panel.__init__(self, parent)

   410

            self.SetBackgroundColour(wx.WHITE)

   411

            self.SetDropTarget(DebugVariableDropTarget(window, self))

   412

   413

            self.ParentWindow = window

   414

            self.Items = items

   415

   416

        def __del__(self):

   417

            self.ParentWindow = None

   418

   419

        def GetIndex(self):

   420

            return self.ParentWindow.GetViewerIndex(self)

   421

   422

        def GetItem(self, variable):

   423

            for item in self.Items:

   424

                if item.GetVariable() == variable:

   425

                    return item

   426

            return None

   427

   428

        def GetItems(self):

   429

            return self.Items

   430

   431

        def GetVariables(self):

   432

            if len(self.Items) > 1:

   433

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

   434

                if self.GraphType == GRAPH_ORTHOGONAL:

   435

                    return tuple(variables)

   436

                return variables

   437

            return self.Items[0].GetVariable()

   438

   439

        def AddItem(self, item):

   440

            self.Items.append(item)

   441

   442

        def RemoveItem(self, item):

   443

            if item in self.Items:

   444

                self.Items.remove(item)

   445

   446

        def Clear(self):

   447

            for item in self.Items:

   448

                self.ParentWindow.RemoveDataConsumer(item)

   449

            self.Items = []

   450

   451

        def IsEmpty(self):

   452

            return len(self.Items) == 0

   453

   454

        def UnregisterObsoleteData(self):

   455

            for item in self.Items[:]:

   456

                iec_path = item.GetVariable().upper()

   457

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

   458

                    self.ParentWindow.RemoveDataConsumer(item)

   459

                    self.RemoveItem(item)

   460

                else:

   461

                    self.ParentWindow.AddDataConsumer(iec_path, item)

   462

                    item.RefreshVariableType()

   463

   464

        def ResetData(self):

   465

            for item in self.Items:

   466

                item.ResetData()

   467

   468

        def Refresh(self):

   469

            pass

   470

   471

        def OnForceButton(self, event):

   472

            if len(self.Items) == 1:

   473

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

   474

            else:

   475

                menu = wx.Menu(title='')

   476

                for item in self.Items:

   477

                    new_id = wx.NewId()

   478

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

   479

                        text=item.GetVariable(self.ParentWindow.GetVariableNameMask()))

   480

                    self.Bind(wx.EVT_MENU, 

   481

                        self.GetForceVariableMenuFunction(item),

   482

                        id=new_id)

   483

                self.PopupMenu(menu)

   484

            event.Skip()

   485

   486

        def OnReleaseButton(self, event):

   487

            if len(self.Items) == 1:

   488

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

   489

            else:

   490

                menu = wx.Menu(title='')

   491

                for item in self.Items:

   492

                    new_id = wx.NewId()

   493

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

   494

                        text=item.GetVariable(self.ParentWindow.GetVariableNameMask()))

   495

                    self.Bind(wx.EVT_MENU, 

   496

                        self.GetReleaseVariableMenuFunction(item),

   497

                        id=new_id)

   498