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

    26

import math

    27

import numpy

    28

    29

import wx

    30

import wx.lib.buttons

    31

    32

import matplotlib

    33

matplotlib.use('WX')

    34

import matplotlib.pyplot

    35

from matplotlib.backends.backend_wxagg import _convert_agg_to_wx_bitmap

    36

    37

from editors.DebugViewer import DebugViewer

    38

from util.BitmapLibrary import GetBitmap

    39

    40

from DebugVariableItem import DebugVariableItem

    41

from DebugVariableTextViewer import DebugVariableTextViewer

    42

from DebugVariableGraphicViewer import *

    43

    44

MILLISECOND = 1000000       # Number of nanosecond in a millisecond

    45

SECOND = 1000 * MILLISECOND # Number of nanosecond in a second

    46

MINUTE = 60 * SECOND        # Number of nanosecond in a minute

    47

HOUR = 60 * MINUTE          # Number of nanosecond in a hour

    48

DAY = 24 * HOUR             # Number of nanosecond in a day

    49

    50

# List of values possible for graph range

    51

# Format is [(time_in_plain_text, value_in_nanosecond),...]

    52

RANGE_VALUES = \

    53

    [("%dms" % i, i * MILLISECOND) for i in (10, 20, 50, 100, 200, 500)] + \

    54

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

    55

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

    56

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

    57

    58

# Scrollbar increment in pixel

    59

SCROLLBAR_UNIT = 10

    60

    61

def compute_mask(x, y):

    62

    return [(xp if xp == yp else "*")

    63

            for xp, yp in zip(x, y)]

    64

    65

def NextTick(variables):

    66

    next_tick = None

    67

    for item, data in variables:

    68

        if len(data) == 0:

    69

            continue

    70

    71

        next = (data[0][0]

    72

                if next_tick is None

    73

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

    74

    75

    return next_tick

    76

    77

#-------------------------------------------------------------------------------

    78

#                    Debug Variable Graphic Panel Drop Target

    79

#-------------------------------------------------------------------------------

    80

    81

"""

    82

Class that implements a custom drop target class for Debug Variable Graphic

    83

Panel

    84

"""

    85

    86

class DebugVariableDropTarget(wx.TextDropTarget):

    87

    88

    def __init__(self, window):

    89

        """

    90

        Constructor

    91

        @param window: Reference to the Debug Variable Panel

    92

        """

    93

        wx.TextDropTarget.__init__(self)

    94

        self.ParentWindow = window

    95

    96

    def __del__(self):

    97

        """

    98

        Destructor

    99

        """

   100

        # Remove reference to Debug Variable Panel

   101

        self.ParentWindow = None

   102

   103

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

   104

        """

   105

        Function called when mouse is dragged over Drop Target

   106

        @param x: X coordinate of mouse pointer

   107

        @param y: Y coordinate of mouse pointer

   108

        @param d: Suggested default for return value

   109

        """

   110

       # Signal Debug Variable Panel to refresh highlight giving mouse position

   111

        self.ParentWindow.RefreshHighlight(x, y)

   112

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

   113

   114

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

   115

        """

   116

        Function called when mouse is released in Drop Target

   117

        @param x: X coordinate of mouse pointer

   118

        @param y: Y coordinate of mouse pointer

   119

        @param data: Text associated to drag'n drop

   120

        """

   124

        message = None

   125

   126

        # Check that data is valid regarding DebugVariablePanel

   127

        try:

   128

            values = eval(data)

   129

            if not isinstance(values, TupleType):

   130

                raise ValueError

   131

        except:

   132

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

   133

            values = None

   134

   135

        # Display message if data is invalid

   136

        if message is not None:

   137

            wx.CallAfter(self.ShowMessage, message)

   138

   139

        # Data contain a reference to a variable to debug

   140

        elif values[1] == "debug":

   141

   142

            # Drag'n Drop is an internal is an internal move inside Debug

   143

            # Variable Panel 

   144

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

   145

                self.ParentWindow.MoveValue(values[0])

   146

   147

            # Drag'n Drop was initiated by another control of Beremiz

   148

            else:

   149

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

   150

   151

    def OnLeave(self):

   152

        """

   153

        Function called when mouse is leave Drop Target

   154

        """

   155

        # Signal Debug Variable Panel to reset highlight

   156

        self.ParentWindow.ResetHighlight()

   157

        return wx.TextDropTarget.OnLeave(self)

   158

   159

    def ShowMessage(self, message):

   160

        """

   161

        Show error message in Error Dialog

   162

        @param message: Error message to display

   163

        """

   164

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

   165

        dialog.ShowModal()

   166

        dialog.Destroy()

   167

   168

   169

#-------------------------------------------------------------------------------

   170

#                      Debug Variable Graphic Panel Class

   171

#-------------------------------------------------------------------------------

   172

   173

"""

   174

Class that implements a Viewer that display variable values as a graphs

   175

"""

   176

   177

class DebugVariableGraphicPanel(wx.Panel, DebugViewer):

   178

   179

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

   180

        """

   181

        Constructor

   182

        @param parent: Reference to the parent wx.Window

   183

        @param producer: Object receiving debug value and dispatching them to

   184

        consumers

   185

        @param window: Reference to Beremiz frame

   186

        """

   187

        wx.Panel.__init__(self, parent, style=wx.SP_3D|wx.TAB_TRAVERSAL)

   188

   189

        # Save Reference to Beremiz frame

   190

        self.ParentWindow = window

   191

   192

        # Variable storing flag indicating that variable displayed in table

   193

        # received new value and then table need to be refreshed

   194

        self.HasNewData = False

   195

   196

        # Variable storing flag indicating that refresh has been forced, and

   197

        # that next time refresh is possible, it will be done even if no new

   198

        # data is available

   199

        self.Force = False

   200

   201

        self.SetBackgroundColour(wx.WHITE)

   202

   203

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   204

   205

        self.Ticks = numpy.array([]) # List of tick received

   206

        self.StartTick = 0           # Tick starting range of data displayed

   207

        self.Fixed = False           # Flag that range of data is fixed

   208

        self.CursorTick = None       # Tick of cursor for displaying values

   209

   210

        self.DraggingAxesPanel = None

   211

        self.DraggingAxesBoundingBox = None

   212

        self.DraggingAxesMousePos = None

   213

        self.VetoScrollEvent = False

   214

   215

        self.VariableNameMask = []

   216

   217

        self.GraphicPanels = []

   218

   219

        graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   220

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

   221

   222

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

   223

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

   224

   225

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

   226

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

   227

        graphics_button_sizer.AddWindow(self.CanvasRange, 1, 

   228

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

   229

   230

        self.CanvasRange.Clear()

   231

        default_range_idx = 0

   232

        for idx, (text, value) in enumerate(RANGE_VALUES):

   233

            self.CanvasRange.Append(text)

   234

            if text == "1s":

   235

                default_range_idx = idx

   236

        self.CanvasRange.SetSelection(default_range_idx)

   237

   238

        for name, bitmap, help in [

   239

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

   240

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

   241

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

   242

                  bitmap=GetBitmap(bitmap), 

   243

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

   244

            button.SetToolTipString(help)

   245

            setattr(self, name, button)

   246

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

   247

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

   248

   249

        self.CanvasPosition = wx.ScrollBar(self, 

   250

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

   251

        self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK, 

   252

              self.OnPositionChanging, self.CanvasPosition)

   253

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP, 

   254

              self.OnPositionChanging, self.CanvasPosition)

   255

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN, 

   256

              self.OnPositionChanging, self.CanvasPosition)

   257

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP, 

   258

              self.OnPositionChanging, self.CanvasPosition)

   259

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN, 

   260

              self.OnPositionChanging, self.CanvasPosition)

   261

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

   262

   263

        self.TickSizer = wx.BoxSizer(wx.HORIZONTAL)

   264

        main_sizer.AddSizer(self.TickSizer, border=5, flag=wx.ALL|wx.GROW)

   265

   266

        self.TickLabel = wx.StaticText(self)

   267

        self.TickSizer.AddWindow(self.TickLabel, border=5, flag=wx.RIGHT)

   268

   269

        self.MaskLabel = wx.TextCtrl(self, style=wx.TE_READONLY|wx.TE_CENTER|wx.NO_BORDER)

   270

        self.TickSizer.AddWindow(self.MaskLabel, 1, border=5, flag=wx.RIGHT|wx.GROW)

   271

   272

        self.TickTimeLabel = wx.StaticText(self)

   273

        self.TickSizer.AddWindow(self.TickTimeLabel)

   274

   275

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

   276

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   277

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   278

        self.GraphicsWindow.Bind(wx.EVT_ERASE_BACKGROUND, self.OnGraphicsWindowEraseBackground)

   279

        self.GraphicsWindow.Bind(wx.EVT_PAINT, self.OnGraphicsWindowPaint)

   280

        self.GraphicsWindow.Bind(wx.EVT_SIZE, self.OnGraphicsWindowResize)

   281

        self.GraphicsWindow.Bind(wx.EVT_MOUSEWHEEL, self.OnGraphicsWindowMouseWheel)

   282

   283

        main_sizer.AddWindow(self.GraphicsWindow, 1, flag=wx.GROW)

   284

   285

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

   286

        self.GraphicsWindow.SetSizer(self.GraphicsSizer)

   287

   288

        DebugViewer.__init__(self, producer, True)

   289

   290

        self.SetSizer(main_sizer)

   291

   292

    def SetTickTime(self, ticktime=0):

   293

        """

   294

        Set Ticktime for calculate data range according to time range selected

   295

        @param ticktime: Ticktime to apply to range (default: 0)

   296

        """

   297

        # Save ticktime

   298

        self.Ticktime = ticktime

   299

   300

        # Set ticktime to millisecond if undefined

   301

        if self.Ticktime == 0:

   302

            self.Ticktime = MILLISECOND

   303

   304

        # Calculate range to apply to data

   305

        self.CurrentRange = RANGE_VALUES[

   306

            self.CanvasRange.GetSelection()][1] / self.Ticktime

   307

   308

    def SetDataProducer(self, producer):

   309

        """

   310

        Set Data Producer

   311

        @param producer: Data Producer

   312

        """

   313

        DebugViewer.SetDataProducer(self, producer)

   314

   315

        # Set ticktime if data producer is available

   316

        if self.DataProducer is not None:

   317

            self.SetTickTime(self.DataProducer.GetTicktime())

   318

   319

    def RefreshNewData(self, *args, **kwargs):

   320

        """

   321

        Called to refresh Panel according to values received by variables

   322

        Can receive any parameters (not used here)

   323

        """

   324

        # Refresh graphs if new data is available or refresh is forced

   325

        if self.HasNewData or self.Force:

   326

            self.HasNewData = False

   327

            self.RefreshView()

   328

   329

        DebugViewer.RefreshNewData(self, *args, **kwargs)

   330

   331

    def NewDataAvailable(self, tick, *args, **kwargs):

   332

        """

   333

        Called by DataProducer for each tick captured or by panel to refresh

   334

        graphs

   335

        @param tick: PLC tick captured

   336

        All other parameters are passed to refresh function 

   337

        """

   338

        # If tick given

   339

        if tick is not None:

   340

   341

            # Save tick as start tick for range if data is still empty

   342

            if len(self.Ticks) == 0:

   343

                self.StartTick = tick 

   344

   345

            # Add tick to list of ticks received

   346

            self.Ticks = numpy.append(self.Ticks, [tick])

   347

   348

            # Update start tick for range if range follow ticks received

   349

            if not self.Fixed or tick < self.StartTick + self.CurrentRange:

   350

                self.StartTick = max(self.StartTick, tick - self.CurrentRange)

   351

   352

            # Force refresh if graph is fixed because range of data received

   353

            # is too small to fill data range selected

   354

            if self.Fixed and \

   355

               self.Ticks[-1] - self.Ticks[0] < self.CurrentRange:

   356

                self.Force = True

   357

   358

        DebugViewer.NewDataAvailable(self, tick, *args, **kwargs)

   359

   360

    def ForceRefresh(self):

   361

        """

   362

        Called to force refresh of graphs

   363

        """

   364

        self.Force = True

   365

        wx.CallAfter(self.NewDataAvailable, None, True)

   366

   367

    def SetCursorTick(self, cursor_tick):

   368

        self.CursorTick = cursor_tick

   369

        self.Fixed = cursor_tick is not None

   370

        self.UpdateCursorTick() 

   371

   372

    def MoveCursorTick(self, move):

   373

        if self.CursorTick is not None:

   374

            cursor_tick = max(self.Ticks[0], 

   375

                          min(self.CursorTick + move, 

   376

                              self.Ticks[-1]))

   377

            cursor_tick_idx = numpy.argmin(numpy.abs(self.Ticks - cursor_tick))

   378

            if self.Ticks[cursor_tick_idx] == self.CursorTick:

   379

                cursor_tick_idx = max(0, 

   380

                                  min(cursor_tick_idx + abs(move) / move, 

   381

                                      len(self.Ticks) - 1))

   382

            self.CursorTick = self.Ticks[cursor_tick_idx]

   383

            self.StartTick = max(self.Ticks[

   384

                                numpy.argmin(numpy.abs(self.Ticks - 

   385

                                        self.CursorTick + self.CurrentRange))],

   386

                             min(self.StartTick, self.CursorTick))

   387

            self.RefreshCanvasPosition()

   388

            self.UpdateCursorTick() 

   389

   390

    def ResetCursorTick(self):

   391

        self.CursorTick = None

   392

        self.UpdateCursorTick()

   393

   394

    def UpdateCursorTick(self):

   395

        for panel in self.GraphicPanels:

   396

            if isinstance(panel, DebugVariableGraphicViewer):

   397

                panel.SetCursorTick(self.CursorTick)

   398

        self.ForceRefresh()

   399

   400

    def StartDragNDrop(self, panel, item, x_mouse, y_mouse, x_mouse_start, y_mouse_start):

   401

        if len(panel.GetItems()) > 1:

   402

            self.DraggingAxesPanel = DebugVariableGraphicViewer(self.GraphicsWindow, self, [item], GRAPH_PARALLEL)

   403

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   404

            width, height = panel.GetSize()

   405

            self.DraggingAxesPanel.SetSize(wx.Size(width, height))

   406

            self.DraggingAxesPanel.ResetGraphics()

   407

            self.DraggingAxesPanel.SetPosition(wx.Point(0, -height))

   408

        else:

   409

            self.DraggingAxesPanel = panel

   410

        self.DraggingAxesBoundingBox = panel.GetAxesBoundingBox(parent_coordinate=True)

   411

        self.DraggingAxesMousePos = wx.Point(

   412

            x_mouse_start - self.DraggingAxesBoundingBox.x, 

   413

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   414

        self.MoveDragNDrop(x_mouse, y_mouse)

   415

   416

    def MoveDragNDrop(self, x_mouse, y_mouse):

   417

        self.DraggingAxesBoundingBox.x = x_mouse - self.DraggingAxesMousePos.x

   418

        self.DraggingAxesBoundingBox.y = y_mouse - self.DraggingAxesMousePos.y

   419

        self.RefreshHighlight(x_mouse, y_mouse)

   420

   421

    def RefreshHighlight(self, x_mouse, y_mouse):

   422

        for idx, panel in enumerate(self.GraphicPanels):

   423

            x, y = panel.GetPosition()

   424

            width, height = panel.GetSize()

   425

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

   426

            if (rect.InsideXY(x_mouse, y_mouse) or 

   427

                idx == 0 and y_mouse < 0 or

   428

                idx == len(self.GraphicPanels) - 1 and y_mouse > panel.GetPosition()[1]):

   429

                panel.RefreshHighlight(x_mouse - x, y_mouse - y)

   430

            else:

   431

                panel.SetHighlight(HIGHLIGHT_NONE)

   432

        if wx.Platform == "__WXMSW__":

   433

            self.RefreshView()

   434

        else:

   435

            self.ForceRefresh()

   436

   437

    def ResetHighlight(self):

   438

        for panel in self.GraphicPanels:

   439

            panel.SetHighlight(HIGHLIGHT_NONE)

   440

        if wx.Platform == "__WXMSW__":

   441

            self.RefreshView()

   442

        else:

   443

            self.ForceRefresh()

   444

   445

    def IsDragging(self):

   446

        return self.DraggingAxesPanel is not None

   447

   448

    def GetDraggingAxesClippingRegion(self, panel):

   449

        x, y = panel.GetPosition()

   450

        width, height = panel.GetSize()

   451

        bbox = wx.Rect(x, y, width, height)

   452

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   453

        bbox.x -= x

   454

        bbox.y -= y

   455

        return bbox

   456

   457

    def GetDraggingAxesPosition(self, panel):

   458

        x, y = panel.GetPosition()

   459

        return wx.Point(self.DraggingAxesBoundingBox.x - x,

   460

                        self.DraggingAxesBoundingBox.y - y)

   461

   462

    def StopDragNDrop(self, variable, x_mouse, y_mouse):

   463

        if self.DraggingAxesPanel not in self.GraphicPanels:

   464

            self.DraggingAxesPanel.Destroy()

   465

        self.DraggingAxesPanel = None

   466

        self.DraggingAxesBoundingBox = None

   467

        self.DraggingAxesMousePos = None

   468

        for idx, panel in enumerate(self.GraphicPanels):

   469

            panel.SetHighlight(HIGHLIGHT_NONE)

   470

            xw, yw = panel.GetPosition()

   471

            width, height = panel.GetSize()

   472

            bbox = wx.Rect(xw, yw, width, height)

   473

            if bbox.InsideXY(x_mouse, y_mouse):

   474

                panel.ShowButtons(True)

   475

                merge_type = GRAPH_PARALLEL

   476

                if isinstance(panel, DebugVariableTextViewer) or panel.Is3DCanvas():

   477

                    if y_mouse > yw + height / 2:

   478

                        idx += 1

   479

                    wx.CallAfter(self.MoveValue, variable, idx, True)

   480

                else:

   481

                    rect = panel.GetAxesBoundingBox(True)

   482

                    if rect.InsideXY(x_mouse, y_mouse):

   483

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

   484

                        if merge_rect.InsideXY(x_mouse, y_mouse):

   485

                            merge_type = GRAPH_ORTHOGONAL

   486

                        wx.CallAfter(self.MergeGraphs, variable, idx, merge_type, force=True)

   487

                    else:

   488

                        if y_mouse > yw + height / 2:

   489

                            idx += 1

   490