1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2012: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 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

    71

        next_tick = (data[0][0]

    72

                     if next_tick is None

    73

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

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

    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

    96

    def __del__(self):

    97

        """

    98

        Destructor

    99

        """

   100

        # Remove reference to Debug Variable Panel

   101

        self.ParentWindow = None

   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)

   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

        """

   121

        # Signal Debug Variable Panel to reset highlight

   122

        self.ParentWindow.ResetHighlight()

   124

        message = None

   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

   135

        # Display message if data is invalid

   136

        if message is not None:

   137

            wx.CallAfter(self.ShowMessage, message)

   139

        # Data contain a reference to a variable to debug

   140

        elif values[1] == "debug":

   142

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

   144

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

   145

                self.ParentWindow.MoveValue(values[0])

   147

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

   148

            else:

   149

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

   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)

   159

    def ShowMessage(self, message):

   160

        """

   161

        Show error message in Error Dialog

   162

        @param message: Error message to display

   163

        """

   167

                                  wx.OK|wx.ICON_ERROR)

   168

        dialog.ShowModal()

   169

        dialog.Destroy()

   170

   171

   172

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

   173

#                      Debug Variable Graphic Panel Class

   174

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

   175

   176

"""

   177

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

   178

"""

   179

   180

class DebugVariablePanel(wx.Panel, DebugViewer):

   182

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

   183

        """

   184

        Constructor

   185

        @param parent: Reference to the parent wx.Window

   186

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

   187

        consumers

   188

        @param window: Reference to Beremiz frame

   189

        """

   190

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

   192

        # Save Reference to Beremiz frame

   193

        self.ParentWindow = window

   195

        # Variable storing flag indicating that variable displayed in table

   196

        # received new value and then table need to be refreshed

   197

        self.HasNewData = False

   199

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

   200

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

   201

        # data is available

   202

        self.Force = False

   204

        self.SetBackgroundColour(wx.WHITE)

   206

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   208

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

   209

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

   210

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

   211

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

   213

        self.DraggingAxesPanel = None

   214

        self.DraggingAxesBoundingBox = None

   215

        self.DraggingAxesMousePos = None

   216

        self.VetoScrollEvent = False

   218

        self.VariableNameMask = []

   220

        self.GraphicPanels = []

   222

        graphics_button_sizer = wx.BoxSizer(wx.HORIZONTAL)

   223

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

   225

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

   226

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

   228

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

   229

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

   231

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

   233

        self.CanvasRange.Clear()

   234

        default_range_idx = 0

   235

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

   236

            self.CanvasRange.Append(text)

   237

            if text == "1s":

   238

                default_range_idx = idx

   239

        self.CanvasRange.SetSelection(default_range_idx)

   241

        for name, bitmap, help in [

   242

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

   243

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

   246

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

   247

            button.SetToolTipString(help)

   248

            setattr(self, name, button)

   249

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

   250

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

   253

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

   255

              self.OnPositionChanging, self.CanvasPosition)

   257

              self.OnPositionChanging, self.CanvasPosition)

   259

              self.OnPositionChanging, self.CanvasPosition)

   261

              self.OnPositionChanging, self.CanvasPosition)

   263

              self.OnPositionChanging, self.CanvasPosition)

   264

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

   266

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

   267

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

   269

        self.TickLabel = wx.StaticText(self)

   270

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

   272

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

   273

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

   275

        self.TickTimeLabel = wx.StaticText(self)

   276

        self.TickSizer.AddWindow(self.TickTimeLabel)

   278

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

   279

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   280

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   281

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

   282

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

   283

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

   284

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

   286

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

   288

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

   289

        self.GraphicsWindow.SetSizer(self.GraphicsSizer)

   291

        DebugViewer.__init__(self, producer, True)

   293

        self.SetSizer(main_sizer)

   294

        self.SetTickTime()

   296

    def SetTickTime(self, ticktime=0):

   297

        """

   298

        Set Ticktime for calculate data range according to time range selected

   299

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

   300

        """

   301

        # Save ticktime

   302

        self.Ticktime = ticktime

   304

        # Set ticktime to millisecond if undefined

   305

        if self.Ticktime == 0:

   306

            self.Ticktime = MILLISECOND

   308

        # Calculate range to apply to data

   309

        self.CurrentRange = RANGE_VALUES[

   310

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

   312

    def SetDataProducer(self, producer):

   313

        """

   314

        Set Data Producer

   315

        @param producer: Data Producer

   316

        """

   317

        DebugViewer.SetDataProducer(self, producer)

   319

        # Set ticktime if data producer is available

   320

        if self.DataProducer is not None:

   321

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

   323

    def RefreshNewData(self):

   324

        """

   325

        Called to refresh Panel according to values received by variables

   326

        Can receive any parameters (not used here)

   327

        """

   328

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

   329

        if self.HasNewData or self.Force:

   330

            self.HasNewData = False

   331

            self.RefreshView()

   333

        DebugViewer.RefreshNewData(self)

   335

    def NewDataAvailable(self, ticks):

   336

        """

   337

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

   338

        graphs

   339

        @param tick: PLC tick captured

   341

        """

   342

        # If tick given

   343

        if ticks is not None:

   344

            tick = ticks[-1]

   346

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

   347

            if len(self.Ticks) == 0:

   348

                self.StartTick = ticks[0]

   350

            # Add tick to list of ticks received

   351

            self.Ticks = numpy.append(self.Ticks, ticks)

   353

            # Update start tick for range if range follow ticks received

   354

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

   355

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

   357

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

   358

            # is too small to fill data range selected

   359

            if self.Fixed and \

   360

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

   361

                self.Force = True

   363

            self.HasNewData = False

   364

            self.RefreshView()

   366

        else:

   367

            DebugViewer.NewDataAvailable(self, ticks)

   369

    def ForceRefresh(self):

   370

        """

   371

        Called to force refresh of graphs

   372

        """

   373

        self.Force = True

   374

        wx.CallAfter(self.NewDataAvailable, None)

   376

    def SetCursorTick(self, cursor_tick):

   377

        """

   378

        Set Cursor for displaying values of items at a tick given

   379

        @param cursor_tick: Tick of cursor

   380

        """

   381

        # Save cursor tick

   382

        self.CursorTick = cursor_tick

   383

        self.Fixed = cursor_tick is not None

   386

    def MoveCursorTick(self, move):

   387

        if self.CursorTick is not None:

   390

                              self.Ticks[-1]))

   391

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

   392

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

   395

                                      len(self.Ticks) - 1))

   396

            self.CursorTick = self.Ticks[cursor_tick_idx]

   397

            self.StartTick = max(self.Ticks[

   399

                                        self.CursorTick + self.CurrentRange))],

   400

                             min(self.StartTick, self.CursorTick))

   401

            self.RefreshCanvasPosition()

   404

    def ResetCursorTick(self):

   405

        self.CursorTick = None

   406

        self.Fixed = False

   407

        self.UpdateCursorTick()

   409

    def UpdateCursorTick(self):

   410

        for panel in self.GraphicPanels:

   411

            if isinstance(panel, DebugVariableGraphicViewer):

   412

                panel.SetCursorTick(self.CursorTick)

   413

        self.ForceRefresh()

   415

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

   416

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

   417

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

   418

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   419

            width, height = panel.GetSize()

   420

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

   421

            self.DraggingAxesPanel.ResetGraphics()

   422

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

   423

        else:

   424

            self.DraggingAxesPanel = panel

   425

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

   426

        self.DraggingAxesMousePos = wx.Point(

   428

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   429

        self.MoveDragNDrop(x_mouse, y_mouse)

   431

    def MoveDragNDrop(self, x_mouse, y_mouse):

   432

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

   433

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

   434

        self.RefreshHighlight(x_mouse, y_mouse)

   436

    def RefreshHighlight(self, x_mouse, y_mouse):

   437

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

   438

            x, y = panel.GetPosition()

   439

            width, height = panel.GetSize()

   440

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

   442

                idx == 0 and y_mouse < 0 or

   443

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

   444

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

   445

            else:

   446

                panel.SetHighlight(HIGHLIGHT_NONE)

   447

        if wx.Platform == "__WXMSW__":

   448

            self.RefreshView()

   449

        else:

   450

            self.ForceRefresh()

   452

    def ResetHighlight(self):

   453

        for panel in self.GraphicPanels:

   454

            panel.SetHighlight(HIGHLIGHT_NONE)

   455

        if wx.Platform == "__WXMSW__":

   456

            self.RefreshView()

   457

        else:

   458

            self.ForceRefresh()

   460

    def IsDragging(self):

   461

        return self.DraggingAxesPanel is not None

   463

    def GetDraggingAxesClippingRegion(self, panel):

   464

        x, y = panel.GetPosition()

   465

        width, height = panel.GetSize()

   466

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

   467

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   468

        bbox.x -= x

   469

        bbox.y -= y

   470

        return bbox

   472

    def GetDraggingAxesPosition(self, panel):

   473

        x, y = panel.GetPosition()

   474

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

   475

                        self.DraggingAxesBoundingBox.y - y)

   477

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

   478

        if self.DraggingAxesPanel not in self.GraphicPanels:

   479

            self.DraggingAxesPanel.Destroy()

   480

        self.DraggingAxesPanel = None

   481

        self.DraggingAxesBoundingBox = None