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

    26

    27

    28

from functools import reduce

    29

import numpy as np

    30

    31

import wx

    32

import wx.lib.buttons

    33

    34

    35

# pylint: disable=wrong-import-position

    36

import matplotlib

    37

matplotlib.use('WX')   # noqa

    38

import matplotlib.pyplot

    39

    40

from editors.DebugViewer import DebugViewer

    41

from util.BitmapLibrary import GetBitmap

    42

    43

from controls.DebugVariablePanel.DebugVariableItem import DebugVariableItem

    44

from controls.DebugVariablePanel.DebugVariableTextViewer import DebugVariableTextViewer

    45

from controls.DebugVariablePanel.DebugVariableGraphicViewer import *

    46

from controls.DebugVariablePanel.RingBuffer import RingBuffer

    47

    48

    49

MILLISECOND = 1000000        # Number of nanosecond in a millisecond

    50

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

    51

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

    52

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

    53

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

    54

    55

# Scrollbar increment in pixel

    56

SCROLLBAR_UNIT = 10

    57

    58

    59

def compute_mask(x, y):

    60

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

    61

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

    62

    63

    64

def NextTick(variables):

    65

    next_tick = None

    66

    for _item, data in variables:

    67

        if len(data) == 0:

    68

            continue

    69

    70

        next_tick = (data[0][0]

    71

                     if next_tick is None

    72

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

    73

    74

    return next_tick

    75

    76

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

    77

#                    Debug Variable Graphic Panel Drop Target

    78

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

    79

    80

    81

class DebugVariableDropTarget(wx.TextDropTarget):

    82

    """

    83

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

    84

    Panel

    85

    """

    86

    87

    def __init__(self, window):

    88

        """

    89

        Constructor

    90

        @param window: Reference to the Debug Variable Panel

    91

        """

    92

        wx.TextDropTarget.__init__(self)

    93

        self.ParentWindow = window

    94

    95

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

    96

        """

    97

        Function called when mouse is dragged over Drop Target

    98

        @param x: X coordinate of mouse pointer

    99

        @param y: Y coordinate of mouse pointer

   100

        @param d: Suggested default for return value

   101

        """

   102

        # Signal Debug Variable Panel to refresh highlight giving mouse position

   103

        self.ParentWindow.RefreshHighlight(x, y)

   104

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

   105

   106

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

   107

        """

   108

        Function called when mouse is released in Drop Target

   109

        @param x: X coordinate of mouse pointer

   110

        @param y: Y coordinate of mouse pointer

   111

        @param data: Text associated to drag'n drop

   112

        """

   113

        # Signal Debug Variable Panel to reset highlight

   114

        self.ParentWindow.ResetHighlight()

   115

   116

        message = None

   117

   118

        # Check that data is valid regarding DebugVariablePanel

   119

        try:

   120

            values = eval(data)

   121

            if not isinstance(values, tuple):

   122

                raise ValueError

   123

        except Exception:

   124

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

   125

            values = None

   126

   127

        # Display message if data is invalid

   128

        if message is not None:

   129

            wx.CallAfter(self.ShowMessage, message)

   130

            return False

   131

   132

        # Data contain a reference to a variable to debug

   133

        elif values[1] == "debug":

   134

   135

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

   136

            # Variable Panel

   137

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

   138

                self.ParentWindow.MoveValue(values[0])

   139

   140

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

   141

            else:

   142

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

   143

   144

            return True

   145

        return False

   146

   147

    def OnLeave(self):

   148

        """

   149

        Function called when mouse is leave Drop Target

   150

        """

   151

        # Signal Debug Variable Panel to reset highlight

   152

        self.ParentWindow.ResetHighlight()

   153

        return wx.TextDropTarget.OnLeave(self)

   154

   155

    def ShowMessage(self, message):

   156

        """

   157

        Show error message in Error Dialog

   158

        @param message: Error message to display

   159

        """

   160

        dialog = wx.MessageDialog(self.ParentWindow,

   161

                                  message,

   162

                                  _("Error"),

   163

                                  wx.OK | wx.ICON_ERROR)

   164

        dialog.ShowModal()

   165

        dialog.Destroy()

   166

   167

   168

class DebugVariablePanel(wx.Panel, DebugViewer):

   169

    """

   170

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

   171

    """

   172

   173

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

   174

        """

   175

        Constructor

   176

        @param parent: Reference to the parent wx.Window

   177

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

   178

        consumers

   179

        @param window: Reference to Beremiz frame

   180

        """

   181

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

   182

   183

        # List of values possible for graph range

   184

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

   185

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

   186

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

   187

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

   188

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

   189

   190

        # Save Reference to Beremiz frame

   191

        self.ParentWindow = window

   192

   193

        # Variable storing flag indicating that variable displayed in table

   194

        # received new value and then table need to be refreshed

   195

        self.HasNewData = False

   196

   197

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

   198

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

   199

        # data is available

   200

        self.Force = False

   201

   202

   203

        main_sizer = wx.BoxSizer(wx.VERTICAL)

   204

   205

        self.Ticks = RingBuffer()  # 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.Add(graphics_button_sizer, border=5, flag=wx.GROW | wx.ALL)

   221

   222

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

   223

        graphics_button_sizer.Add(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.Add(self.CanvasRange, 1,

   228

                                        border=5,

   229

                                        flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL)

   230

   231

        self.CanvasRange.Clear()

   232

        default_range_idx = 0

   233

        for idx, (text, _value) in enumerate(self.RANGE_VALUES):

   234

            self.CanvasRange.Append(text)

   235

            if _value == 1000000000:

   236

                default_range_idx = idx

   237

        self.CanvasRange.SetSelection(default_range_idx)

   238

   239

        for name, bitmap, help in [

   240

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

   241

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

   242

            button = wx.lib.buttons.GenBitmapButton(

   243

                self, bitmap=GetBitmap(bitmap),

   244

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

   245

            button.SetToolTip(help)

   246

            setattr(self, name, button)

   247

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

   248

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

   249

   250

        self.CanvasPosition = wx.ScrollBar(

   251

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

   252

        self.CanvasPosition.Bind(wx.EVT_SCROLL_THUMBTRACK,

   253

                                 self.OnPositionChanging, self.CanvasPosition)

   254

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEUP,

   255

                                 self.OnPositionChanging, self.CanvasPosition)

   256

        self.CanvasPosition.Bind(wx.EVT_SCROLL_LINEDOWN,

   257

                                 self.OnPositionChanging, self.CanvasPosition)

   258

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEUP,

   259

                                 self.OnPositionChanging, self.CanvasPosition)

   260

        self.CanvasPosition.Bind(wx.EVT_SCROLL_PAGEDOWN,

   261

                                 self.OnPositionChanging, self.CanvasPosition)

   262

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

   263

   264

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

   265

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

   266

   267

        self.TickLabel = wx.StaticText(self)

   268

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

   269

   270

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

   271

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

   272

   273

        self.TickTimeLabel = wx.StaticText(self)

   274

        self.TickSizer.Add(self.TickTimeLabel)

   275

   276

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

   277

        self.GraphicsWindow.SetBackgroundColour(wx.WHITE)

   278

        self.GraphicsWindow.SetDropTarget(DebugVariableDropTarget(self))

   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.Add(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

        self.SetTickTime()

   292

   293

    def SetTickTime(self, ticktime=0):

   294

        """

   295

        Set Ticktime for calculate data range according to time range selected

   296

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

   297

        """

   298

        # Save ticktime

   299

        self.Ticktime = ticktime

   300

   301

        # Set ticktime to millisecond if undefined

   302

        if self.Ticktime == 0:

   303

            self.Ticktime = MILLISECOND

   304

   305

        # Calculate range to apply to data

   306

        self.CurrentRange = self.RANGE_VALUES[

   307

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

   308

   309

    def SetDataProducer(self, producer):

   310

        """

   311

        Set Data Producer

   312

        @param producer: Data Producer

   313

        """

   314

        DebugViewer.SetDataProducer(self, producer)

   315

   316

        # Set ticktime if data producer is available

   317

        if self.DataProducer is not None:

   318

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

   319

   320

    def RefreshNewData(self):

   321

        """

   322

        Called to refresh Panel according to values received by variables

   323

        Can receive any parameters (not used here)

   324

        """

   325

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

   326

        if self.HasNewData or self.Force:

   327

            self.HasNewData = False

   328

            self.RefreshView()

   329

   330

        DebugViewer.RefreshNewData(self)

   331

   332

    def NewDataAvailable(self, ticks):

   333

        """

   334

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

   335

        graphs

   336

        @param tick: PLC tick captured

   337

        All other parameters are passed to refresh function

   338

        """

   339

        # If tick given

   340

        if ticks is not None:

   341

            tick = ticks[-1]

   342

   343

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

   344

            if self.Ticks.count == 0:

   345

                self.StartTick = ticks[0]

   346

   347

            # Add tick to list of ticks received

   348

            self.Ticks.append(ticks)

   349

   350

            # Update start tick for range if range follow ticks received

   351

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

   352

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

   353

   354

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

   355

            # is too small to fill data range selected

   356

            if self.Fixed :

   357

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

   358

                    self.Force = True

   359

                if self.Ticks.view[0] > self.StartTick:

   360

                    self.StartTick = self.Ticks.view[0]

   361

                    self.Force = True

   362

   363

   364

            self.HasNewData = False

   365

            self.RefreshView()

   366

   367

        else:

   368

            DebugViewer.NewDataAvailable(self, ticks)

   369

   370

    def ForceRefresh(self):

   371

        """

   372

        Called to force refresh of graphs

   373

        """

   374

        self.Force = True

   375

        wx.CallAfter(self.NewDataAvailable, None)

   376

   377

    def SetCursorTick(self, cursor_tick):

   378

        """

   379

        Set Cursor for displaying values of items at a tick given

   380

        @param cursor_tick: Tick of cursor

   381

        """

   382

        # Save cursor tick

   383

        self.CursorTick = cursor_tick

   384

        self.Fixed = cursor_tick is not None

   385

        self.UpdateCursorTick()

   386

   387

    def MoveCursorTick(self, move):

   388

        if self.CursorTick is not None:

   389

            cursor_tick = max(self.Ticks.view[0],

   390

                              min(self.CursorTick + move, self.Ticks.view[-1]))

   391

            cursor_tick_idx = min(np.searchsorted(self.Ticks.view, cursor_tick), self.Ticks.count - 1)

   392

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

   393

                cursor_tick_idx = max(0,

   394

                                      min(cursor_tick_idx + abs(move) // move,

   395

                                          self.Ticks.count - 1))

   396

            self.CursorTick = self.Ticks.view[cursor_tick_idx]

   397

            self.StartTick = max(

   398

                self.Ticks.view[min(np.searchsorted(self.Ticks.view,  self.CursorTick - self.CurrentRange), self.Ticks.count - 1)],

   399

                min(self.StartTick, self.CursorTick))

   400

            self.RefreshCanvasPosition()

   401

            self.UpdateCursorTick()

   402

   403

    def ResetCursorTick(self):

   404

        self.CursorTick = None

   405

        self.Fixed = False

   406

        self.UpdateCursorTick()

   407

   408

    def UpdateCursorTick(self):

   409

        for panel in self.GraphicPanels:

   410

            if isinstance(panel, DebugVariableGraphicViewer):

   411

                panel.SetCursorTick(self.CursorTick)

   412

        self.ForceRefresh()

   413

   414

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

   415

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

   416

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

   417

            self.DraggingAxesPanel.SetCursorTick(self.CursorTick)

   418

            width, height = panel.GetSize()

   419

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

   420

            self.DraggingAxesPanel.ResetGraphics()

   421

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

   422

        else:

   423

            self.DraggingAxesPanel = panel

   424

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

   425

        self.DraggingAxesMousePos = wx.Point(

   426

            x_mouse_start - self.DraggingAxesBoundingBox.x,

   427

            y_mouse_start - self.DraggingAxesBoundingBox.y)

   428

        self.MoveDragNDrop(x_mouse, y_mouse)

   429

   430

    def MoveDragNDrop(self, x_mouse, y_mouse):

   431

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

   432

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

   433

        self.RefreshHighlight(x_mouse, y_mouse)

   434

   435

    def RefreshHighlight(self, x_mouse, y_mouse):

   436

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

   437

            x, y = panel.GetPosition()

   438

            width, height = panel.GetSize()

   439

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

   440

            if rect.Contains(x_mouse, y_mouse) or \

   441

               idx == 0 and y_mouse < 0 or \

   442

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

   443

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

   444

            else:

   445

                panel.SetHighlight(HIGHLIGHT_NONE)

   446

        if wx.Platform == "__WXMSW__":

   447

            self.RefreshView()

   448

        else:

   449

            self.ForceRefresh()

   450

   451

    def ResetHighlight(self):

   452

        for panel in self.GraphicPanels:

   453

            panel.SetHighlight(HIGHLIGHT_NONE)

   454

        if wx.Platform == "__WXMSW__":

   455

            self.RefreshView()

   456

        else:

   457

            self.ForceRefresh()

   458

   459

    def IsDragging(self):

   460

        return self.DraggingAxesPanel is not None

   461

   462

    def GetDraggingAxesClippingRegion(self, panel):

   463

        x, y = panel.GetPosition()

   464

        width, height = panel.GetSize()

   465

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

   466

        bbox = bbox.Intersect(self.DraggingAxesBoundingBox)

   467

        bbox.x -= x

   468

        bbox.y -= y

   469

        return bbox

   470

   471

    def GetDraggingAxesPosition(self, panel):

   472

        x, y = panel.GetPosition()

   473

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

   474

                        self.DraggingAxesBoundingBox.y - y)

   475

   476

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

   477

        if self.DraggingAxesPanel not in self.GraphicPanels:

   478

            self.DraggingAxesPanel.Destroy()

   479

        self.DraggingAxesPanel = None