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

    USE_MPL = True

    43

except:

    44

    USE_MPL = False

    45

    46

from graphics import DebugDataConsumer, DebugViewer, REFRESH_PERIOD

    47

from controls import CustomGrid, CustomTable

    48

from dialogs.ForceVariableDialog import ForceVariableDialog

    49

from util.BitmapLibrary import GetBitmap

    50

    51

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

    52

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

    53

    54

def GetDebugVariablesTableColnames():

    55

    _ = lambda x : x

    56

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

    57

    58

CRC_SIZE = 8

    59

CRC_MASK = 2 ** CRC_SIZE - 1

    60

    61

class VariableTableItem(DebugDataConsumer):

    62

    63

    def __init__(self, parent, variable):

    64

        DebugDataConsumer.__init__(self)

    65

        self.Parent = parent

    66

        self.Variable = variable

    67

        self.RefreshVariableType()

    68

        self.Value = ""

    69

    70

    def __del__(self):

    71

        self.Parent = None

    72

    73

    def SetVariable(self, variable):

    74

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

    75

            self.Variable = variable

    76

            self.RefreshVariableType()

    77

            self.Parent.RefreshView()

    78

    79

    def GetVariable(self, mask=None):

    80

        variable = self.Variable

    81

        if mask is not None:

    82

            parts = variable.split('.')

    83

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

    84

            last = None

    85

            variable = ""

    86

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

    87

                if m == '*':

    88

                    if last == '*':

    89

                        variable += '.'

    90

                    variable += v

    91

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

    92

                    variable += '..'

    93

                last = m

    94

        return variable

    95

    96

    def RefreshVariableType(self):

    97

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

    98

        if USE_MPL:

    99

            self.ResetData()

   100

   101

    def GetVariableType(self):

   102

        return self.VariableType

   103

   104

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

   105

        if USE_MPL and self.IsNumVariable():

   106

            if len(self.Data) == 0:

   107

                return self.Data

   108

   109

            start_idx = end_idx = None

   110

            if start_tick is not None:

   111

                start_idx = self.GetNearestData(start_tick, -1)

   112

            if end_tick is not None:

   113

                end_idx = self.GetNearestData(end_tick, 1)

   114

            if start_idx is None:

   115

                start_idx = 0

   116

            if end_idx is not None:

   117

                return self.Data[start_idx:end_idx + 1]

   118

            else:

   119

                return self.Data[start_idx:]

   120

   121

        return None

   122

   123

    def GetRawValue(self, idx):

   124

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

   125

            return self.RawData[idx][0]

   126

        return ""

   127

   128

    def GetRange(self):

   129

        return self.MinValue, self.MaxValue

   130

   131

    def ResetData(self):

   132

        if self.IsNumVariable():

   133

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

   134

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

   135

                self.RawData = []

   136

            self.MinValue = None

   137

            self.MaxValue = None

   138

        else:

   139

            self.Data = None

   140

   141

    def IsNumVariable(self):

   142

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

   143

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

   144

   145

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

   146

        if USE_MPL and self.IsNumVariable():

   147

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

   148

                num_value = binascii.crc32(value) & CRC_MASK

   149

            else:

   150

                num_value = float(value)

   151

            if self.MinValue is None:

   152

                self.MinValue = num_value

   153

            else:

   154

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

   155

            if self.MaxValue is None:

   156

                self.MaxValue = num_value

   157

            else:

   158

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

   159

            forced_value = float(forced)

   160

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

   161

                raw_data = (value, forced_value)

   162

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

   163

                    extra_value = len(self.RawData)

   164

                    self.RawData.append(raw_data)

   165

                else:

   166

                    extra_value = len(self.RawData) - 1

   167

            else:

   168

                extra_value = forced_value

   169

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

   170

            self.Parent.HasNewData = True

   171

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

   172

   173

    def SetForced(self, forced):

   174

        if self.Forced != forced:

   175

            self.Forced = forced

   176

            self.Parent.HasNewData = True

   177

   178

    def SetValue(self, value):

   179

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

   180

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

   181

            value = value[1:-1]

   182

        if self.Value != value:

   183

            self.Value = value

   184

            self.Parent.HasNewData = True

   185

   186

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

   187

        if tick is not None and self.IsNumVariable() and len(self.Data) > 0:

   188

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

   189

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

   190

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

   191

                if not raw:

   192

                    if self.VariableType == "STRING":

   193

                        value = "'%s'" % value

   194

                    else:

   195

                        value = '"%s"' % value

   196

                return value, forced

   197

            else:

   198

                value = self.Data[idx, 1]

   199

                if not raw and isinstance(value, FloatType):

   200

                    value = "%.6g" % value

   201

                return value, self.IsForced()

   202

        elif not raw:

   203

            if self.VariableType == "STRING":

   204

                return "'%s'" % self.Value

   205

            elif self.VariableType == "WSTRING":

   206

                return '"%s"' % self.Value

   207

            elif isinstance(self.Value, FloatType):

   208

                return "%.6g" % self.Value

   209

        return self.Value

   210

   211

    def GetNearestData(self, tick, adjust):

   212

        if USE_MPL and self.IsNumVariable():

   213

            ticks = self.Data[:, 0]

   214

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

   215

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

   216

                new_cursor -= 1

   217

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

   218

                new_cursor += 1

   219

            return new_cursor

   220

        return None

   221

   222

class DebugVariableTable(CustomTable):

   223

   224

    def GetValue(self, row, col):

   225

        if row < self.GetNumberRows():

   226

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

   227

        return ""

   228

   229

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

   230

        if col < len(self.colnames):

   231

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

   232

   233

    def GetValueByName(self, row, colname):

   234

        if row < self.GetNumberRows():

   235

            if colname == "Variable":

   236

                return self.data[row].GetVariable()

   237

            elif colname == "Value":

   238

                return self.data[row].GetValue()

   239

        return ""

   240

   241

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

   242

        if row < self.GetNumberRows():

   243

            if colname == "Variable":

   244

                self.data[row].SetVariable(value)

   245

            elif colname == "Value":

   246

                self.data[row].SetValue(value)

   247

   248

    def IsForced(self, row):

   249

        if row < self.GetNumberRows():

   250

            return self.data[row].IsForced()

   251

        return False

   252

   253

    def IsNumVariable(self, row):

   254

        if row < self.GetNumberRows():

   255

            return self.data[row].IsNumVariable()

   256

        return False

   257

   258

    def _updateColAttrs(self, grid):

   259

        """

   260

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

   261

        appropriate renderer given the column name.

   262

   263

        Otherwise default to the default renderer.

   264

        """

   265

   266

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

   267

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

   268

                colname = self.GetColLabelValue(col, False)

   269

                if colname == "Value":

   270

                    if self.IsForced(row):

   271

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

   272

                    else:

   273

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

   274

                grid.SetReadOnly(row, col, True)

   275

            self.ResizeRow(grid, row)

   276

   277

    def AppendItem(self, data):

   278

        self.data.append(data)

   279

   280

    def InsertItem(self, idx, data):

   281

        self.data.insert(idx, data)

   282

   283

    def RemoveItem(self, idx):

   284

        self.data.pop(idx)

   285

   286

    def MoveItem(self, idx, new_idx):

   287

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

   288

   289

    def GetItem(self, idx):

   290

        return self.data[idx]

   291

   292

class DebugVariableDropTarget(wx.TextDropTarget):

   293

   294

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

   295

        wx.TextDropTarget.__init__(self)

   296

        self.ParentWindow = parent

   297

        self.ParentControl = control

   298

   299

    def __del__(self):

   300

        self.ParentWindow = None

   301

        self.ParentControl = None

   302

   303

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

   304

        message = None

   305

        try:

   306

            values = eval(data)

   307

        except:

   308

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

   309

            values = None

   310

        if not isinstance(values, TupleType):

   311

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

   312

            values = None

   313

   314

        if message is not None:

   315

            wx.CallAfter(self.ShowMessage, message)

   316

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

   317

            if isinstance(self.ParentControl, CustomGrid):

   318

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

   319

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

   320

                if row == wx.NOT_FOUND:

   321

                    row = self.ParentWindow.Table.GetNumberRows()

   322

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

   323

            elif self.ParentControl is not None:

   324

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

   325

                target_idx = self.ParentControl.GetIndex()

   326

                merge_type = GRAPH_PARALLEL

   327

                if self.ParentControl.Is3DCanvas():

   328

                    if y > height / 2:

   329

                        target_idx += 1

   330

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

   331

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

   332

                    else:

   333

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

   334

                else:

   335

                    rect = self.ParentControl.GetAxesBoundingBox()

   336

                    if rect.InsideXY(x, y):

   337

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

   338

                        if merge_rect.InsideXY(x, y):

   339

                            merge_type = GRAPH_ORTHOGONAL

   340

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

   341

                    else:

   342

                        if y > height / 2:

   343

                            target_idx += 1

   344

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

   345

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

   346

                        else:

   347

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

   348

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

   349

                self.ParentWindow.MoveGraph(values[0])

   350

            else:

   351

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

   352

   353

    def ShowMessage(self, message):

   354

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

   355

        dialog.ShowModal()

   356

        dialog.Destroy()

   357

   358

if USE_MPL:

   359

    MILLISECOND = 1000000

   360

    SECOND = 1000 * MILLISECOND

   361

    MINUTE = 60 * SECOND

   362

    HOUR = 60 * MINUTE

   363

    DAY = 24 * HOUR

   364

   365

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

   366

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

   367

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

   368

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

   369

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

   370

   371

    GRAPH_PARALLEL, GRAPH_ORTHOGONAL = range(2)

   372

   373

    SCROLLBAR_UNIT = 10

   374

   375

    def NextTick(variables):

   376

        next_tick = None

   377

        for item, data in variables:

   378

            if len(data) > 0:

   379

                if next_tick is None:

   380

                    next_tick = data[0][0]

   381

                else:

   382

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

   383

        return next_tick

   384

   385

    def OrthogonalData(item, start_tick, end_tick):

   386

        data = item.GetData(start_tick, end_tick)

   387

        min_value, max_value = item.GetRange()

   388

        if min_value is not None and max_value is not None:

   389

            center = (min_value + max_value) / 2.

   390

            range = max(1.0, max_value - min_value)

   391

        else:

   392

            center = 0.5

   393

            range = 1.0

   394

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

   395

   396

    class DebugVariableViewer(wx.Panel):

   397

   398

        def AddViewer(self):

   399

            pass

   400

   401

        def AddButtons(self):

   402

            pass

   403

   404

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

   405

            wx.Panel.__init__(self, parent)

   406

            self.SetBackgroundColour(wx.WHITE)

   407

            self.SetDropTarget(DebugVariableDropTarget(window, self))

   408

   409

            self.ParentWindow = window

   410

            self.Items = items

   411

            self.ResetVariableNameMask()

   412

   413

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

   414

            self.AddViewer()

   415

            self.AddButtons()

   416

            self.MainSizer.AddGrowableCol(0)

   417

   418

            self.SetSizer(self.MainSizer)

   419

   420

        def __del__(self):

   421

            self.ParentWindow = None

   422

   423

        def GetIndex(self):

   424

            return self.ParentWindow.GetViewerIndex(self)

   425

   426

        def GetItem(self, variable):

   427

            for item in self.Items:

   428

                if item.GetVariable() == variable:

   429

                    return item

   430

            return None

   431

   432

        def GetItems(self):

   433

            return self.Items

   434

   435

        def GetVariables(self):

   436

            if len(self.Items) > 1:

   437

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

   438

                if self.GraphType == GRAPH_ORTHOGONAL:

   439

                    return tuple(variables)

   440

                return variables

   441

            return self.Items[0].GetVariable()

   442

   443

        def ResetVariableNameMask(self):

   444

            if len(self.Items) > 1:

   445

                self.VariableNameMask = reduce(compute_mask,

   446

                    [item.GetVariable().split('.') for item in self.Items])

   447

            elif len(self.Items) > 0:

   448

                self.VariableNameMask = self.Items[0].GetVariable().split('.')[:-1] + ['*']

   449

            else:

   450

                self.VariableNameMask = []

   451

   452

        def AddItem(self, item):

   453

            self.Items.append(item)

   454

            self.ResetVariableNameMask()

   455

   456

        def RemoveItem(self, item):

   457

            if item in self.Items:

   458

                self.Items.remove(item)

   459

            self.ResetVariableNameMask()

   460

   461

        def Clear(self):

   462

            for item in self.Items:

   463

                self.ParentWindow.RemoveDataConsumer(item)

   464

            self.Items = []

   465

            self.ResetVariableNameMask()

   466

   467

        def IsEmpty(self):

   468

            return len(self.Items) == 0

   469

   470

        def UnregisterObsoleteData(self):

   471

            for item in self.Items[:]:

   472

                iec_path = item.GetVariable().upper()

   473

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

   474

                    self.ParentWindow.RemoveDataConsumer(item)

   475

                    self.RemoveItem(item)

   476

                else:

   477

                    self.ParentWindow.AddDataConsumer(iec_path, item)

   478

                    item.RefreshVariableType()

   479

            self.ResetVariableNameMask()

   480

   481

        def ResetData(self):

   482

            for item in self.Items:

   483

                item.ResetData()

   484

   485

        def Refresh(self):

   486

            pass

   487

   488

        def OnForceButton(self, event):

   489

            if len(self.Items) == 1:

   490

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

   491

            else:

   492

                menu = wx.Menu(title='')

   493

                for item in self.Items:

   494

                    new_id = wx.NewId()

   495

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

   496

                        text=item.GetVariable(self.VariableNameMask))

   497

                    self.Bind(wx.EVT_MENU, 

   498

                        self.GetForceVariableMenuFunction(item),

   499