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

from __future__ import absolute_import

    27

from __future__ import division

    28

import math

    29

from time import time as gettime

    30

from threading import Lock

    31

from future.builtins import round

    32

    33

import wx

    34

from six.moves import xrange

    35

    36

from plcopen.structures import *

    37

from plcopen.types_enums import ComputePouName

    38

from PLCControler import ITEM_VAR_LOCAL, ITEM_POU, ITEM_PROGRAM, ITEM_FUNCTIONBLOCK

    39

    40

from graphics.GraphicCommons import *

    41

from graphics.FBD_Objects import *

    42

from graphics.LD_Objects import *

    43

from graphics.SFC_Objects import *

    44

from graphics.RubberBand import RubberBand

    45

from graphics.DebugDataConsumer import DebugDataConsumer

    46

    47

from dialogs import *

    48

from editors.DebugViewer import DebugViewer, REFRESH_PERIOD

    49

from editors.EditorPanel import EditorPanel

    50

    51

SCROLLBAR_UNIT = 10

    52

WINDOW_BORDER = 10

    53

SCROLL_ZONE = 10

    54

    55

CURSORS = None

    56

SFC_Objects = (SFC_Step, SFC_ActionBlock, SFC_Transition, SFC_Divergence, SFC_Jump)

    57

    58

    59

def ResetCursors():

    60

    global CURSORS

    61

    if CURSORS is None:

    62

        CURSORS = [wx.NullCursor,

    63

                   wx.Cursor(wx.CURSOR_HAND),

    64

                   wx.Cursor(wx.CURSOR_SIZENWSE),

    65

                   wx.Cursor(wx.CURSOR_SIZENESW),

    66

                   wx.Cursor(wx.CURSOR_SIZEWE),

    67

                   wx.Cursor(wx.CURSOR_SIZENS)]

    68

    69

    70

if wx.Platform == '__WXMSW__':

    71

    faces = {

    72

        'times': 'Times New Roman',

    73

        'mono':  'Courier New',

    74

        'helv':  'Arial',

    75

        'other': 'Comic Sans MS',

    76

        'size':  10,

    77

    }

    78

else:

    79

    faces = {

    80

        'times': 'Times',

    81

        'mono':  'FreeMono',

    82

        'helv':  'Helvetica',

    83

        'other': 'new century schoolbook',

    84

        'size':  10,

    85

    }

    86

    87

if wx.Platform == '__WXMSW__':

    88

    MAX_ZOOMIN = 4

    89

else:

    90

    MAX_ZOOMIN = 7

    91

ZOOM_FACTORS = [math.sqrt(2) ** x for x in xrange(-6, MAX_ZOOMIN)]

    92

    93

    96

def GetVariableCreationFunction(variable_type):

    97

    def variableCreationFunction(viewer, id, specific_values):

    98

        return FBD_Variable(viewer,

    99

                            variable_type,

   100

                            specific_values.name,

   101

                            specific_values.value_type,

   102

                            id,

   103

                            specific_values.execution_order)

   104

    return variableCreationFunction

   105

   106

   107

def GetConnectorCreationFunction(connector_type):

   108

    def connectorCreationFunction(viewer, id, specific_values):

   109

        return FBD_Connector(viewer,

   110

                             connector_type,

   111

                             specific_values.name,

   112

                             id)

   113

    return connectorCreationFunction

   114

   115

   116

def commentCreationFunction(viewer, id, specific_values):

   117

    return Comment(viewer, specific_values.content, id)

   118

   119

   120

def GetPowerRailCreationFunction(powerrail_type):

   121

    def powerRailCreationFunction(viewer, id, specific_values):

   122

        return LD_PowerRail(viewer,

   123

                            powerrail_type,

   124

                            id,

   125

                            specific_values.connectors)

   126

    return powerRailCreationFunction

   127

   128

   129

def NEGATED_VALUE(x):

   130

    return x if x is not None else False

   131

   132

   133

def MODIFIER_VALUE(x):

   134

    return x if x is not None else 'none'

   135

   136

   137

CONTACT_TYPES = {(True, "none"): CONTACT_REVERSE,

   138

                 (False, "rising"): CONTACT_RISING,

   139

                 (False, "falling"): CONTACT_FALLING}

   140

   141

   142

def contactCreationFunction(viewer, id, specific_values):

   143

    contact_type = CONTACT_TYPES.get((NEGATED_VALUE(specific_values.negated),

   144

                                      MODIFIER_VALUE(specific_values.edge)),

   145

                                     CONTACT_NORMAL)

   146

    return LD_Contact(viewer, contact_type, specific_values.name, id)

   147

   148

   149

COIL_TYPES = {(True, "none", "none"): COIL_REVERSE,

   150

              (False, "none", "set"): COIL_SET,

   151

              (False, "none", "reset"): COIL_RESET,

   152

              (False, "rising", "none"): COIL_RISING,

   153

              (False, "falling", "none"): COIL_FALLING}

   154

   155

   156

def coilCreationFunction(viewer, id, specific_values):

   157

    coil_type = COIL_TYPES.get((NEGATED_VALUE(specific_values.negated),

   158

                                MODIFIER_VALUE(specific_values.edge),

   159

                                MODIFIER_VALUE(specific_values.storage)),

   160

                               COIL_NORMAL)

   161

    return LD_Coil(viewer, coil_type, specific_values.name, id)

   162

   163

   164

def stepCreationFunction(viewer, id, specific_values):

   165

    step = SFC_Step(viewer,

   166

                    specific_values.name,

   167

                    specific_values.initial,

   168

                    id)

   169

    if specific_values.action is not None:

   170

        step.AddAction()

   171

        connector = step.GetActionConnector()

   172

        connector.SetPosition(wx.Point(*specific_values.action.position))

   173

    return step

   174

   175

   176

def transitionCreationFunction(viewer, id, specific_values):

   177

    transition = SFC_Transition(viewer,

   178

                                specific_values.condition_type,

   179

                                specific_values.condition,

   180

                                specific_values.priority,

   181

                                id)

   182

    return transition

   183

   184

   185

divergence_types = [SELECTION_DIVERGENCE,

   186

                    SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]

   187

   188

   189

def GetDivergenceCreationFunction(divergence_type):

   190

    def divergenceCreationFunction(viewer, id, specific_values):

   191

        return SFC_Divergence(viewer, divergence_type,

   192

                              specific_values.connectors, id)

   193

    return divergenceCreationFunction

   194

   195

   196

def jumpCreationFunction(viewer, id, specific_values):

   197

    return SFC_Jump(viewer, specific_values.target, id)

   198

   199

   200

def actionBlockCreationFunction(viewer, id, specific_values):

   201

    return SFC_ActionBlock(viewer, specific_values.actions, id)

   202

   203

   204

ElementCreationFunctions = {

   205

    "input": GetVariableCreationFunction(INPUT),

   206

    "output": GetVariableCreationFunction(OUTPUT),

   207

    "inout": GetVariableCreationFunction(INOUT),

   208

    "connector": GetConnectorCreationFunction(CONNECTOR),

   209

    "continuation": GetConnectorCreationFunction(CONTINUATION),

   210

    "comment": commentCreationFunction,

   211

    "leftPowerRail": GetPowerRailCreationFunction(LEFTRAIL),

   212

    "rightPowerRail": GetPowerRailCreationFunction(RIGHTRAIL),

   213

    "contact": contactCreationFunction,

   214

    "coil": coilCreationFunction,

   215

    "step": stepCreationFunction,

   216

    "transition": transitionCreationFunction,

   217

    "selectionDivergence": GetDivergenceCreationFunction(SELECTION_DIVERGENCE),

   218

    "selectionConvergence": GetDivergenceCreationFunction(SELECTION_CONVERGENCE),

   219

    "simultaneousDivergence": GetDivergenceCreationFunction(SIMULTANEOUS_DIVERGENCE),

   220

    "simultaneousConvergence": GetDivergenceCreationFunction(SIMULTANEOUS_CONVERGENCE),

   221

    "jump": jumpCreationFunction,

   222

    "actionBlock": actionBlockCreationFunction,

   223

}

   224

   225

   226

def sort_blocks(block_infos1, block_infos2):

   227

    x1, y1 = block_infos1[0].GetPosition()

   228

    x2, y2 = block_infos2[0].GetPosition()

   229

    if y1 == y2:

   230

        return cmp(x1, x2)

   231

    else:

   232

        return cmp(y1, y2)

   233

   234

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

   235

#                       Graphic elements Viewer base class

   236

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

   237

   238

   239

class ViewerDropTarget(wx.TextDropTarget):

   240

   241

    def __init__(self, parent):

   242

        wx.TextDropTarget.__init__(self)

   243

        self.ParentWindow = parent

   244

   245

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

   246

        self.ParentWindow.Select()

   247

        tagname = self.ParentWindow.GetTagName()

   248

        pou_name, pou_type = self.ParentWindow.Controler.GetEditedElementType(tagname, self.ParentWindow.Debug)

   249

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

   250

        x = int(x / self.ParentWindow.ViewScale[0])

   251

        y = int(y / self.ParentWindow.ViewScale[1])

   252

        scaling = self.ParentWindow.Scaling

   253

        message = None

   254

        try:

   255

            values = eval(data)

   256

        except Exception:

   257

            message = _("Invalid value \"%s\" for viewer block") % data

   258

            values = None

   259

        if not isinstance(values, tuple):

   260

            message = _("Invalid value \"%s\" for viewer block") % data

   261

            values = None

   262

        if values is not None:

   263

            if values[1] == "debug":

   264

                pass

   265

            elif values[1] == "program":

   266

                message = _("Programs can't be used by other POUs!")

   267

            elif values[1] in ["function", "functionBlock"]:

   268

                if pou_name == values[0]:

   269

                    message = _("\"%s\" can't use itself!") % pou_name

   270

                elif pou_type == "function" and values[1] != "function":

   271

                    message = _("Function Blocks can't be used in Functions!")

   272

                elif self.ParentWindow.Controler.PouIsUsedBy(pou_name, values[0], self.ParentWindow.Debug):

   273

                    message = _("\"{a1}\" is already used by \"{a2}\"!").format(a1=pou_name, a2=values[0])

   274

                else:

   275

                    blockname = values[2]

   276

                    if len(values) > 3:

   277

                        blockinputs = values[3]

   278

                    else:

   279

                        blockinputs = None

   280

                    if values[1] != "function" and blockname == "":

   281

                        blockname = self.ParentWindow.GenerateNewName(blocktype=values[0])

   282

                    if blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   283

                        message = _("\"%s\" pou already exists!") % blockname

   284

                    elif blockname.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   285

                        message = _("\"%s\" element for this pou already exists!") % blockname

   286

                    else:

   287

                        id = self.ParentWindow.GetNewId()

   288

                        block = FBD_Block(self.ParentWindow, values[0], blockname, id, inputs=blockinputs)

   289

                        width, height = block.GetMinSize()

   290

                        if scaling is not None:

   291

                            x = round(x / scaling[0]) * scaling[0]

   292

                            y = round(y / scaling[1]) * scaling[1]

   293

                            width = round(width / scaling[0] + 0.5) * scaling[0]

   294

                            height = round(height / scaling[1] + 0.5) * scaling[1]

   295

                        block.SetPosition(x, y)

   296

                        block.SetSize(width, height)

   297

                        self.ParentWindow.AddBlock(block)

   298

                        self.ParentWindow.Controler.AddEditedElementBlock(tagname, id, values[0], blockname)

   299

                        self.ParentWindow.RefreshBlockModel(block)

   300

                        self.ParentWindow.RefreshBuffer()

   301

                        self.ParentWindow.RefreshScrollBars()

   302

                        self.ParentWindow.RefreshVisibleElements()

   303

                        self.ParentWindow.RefreshVariablePanel()

   304

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   305

                        self.ParentWindow.Refresh(False)

   306

            elif values[1] == "location":

   307

                if pou_type == "program":

   308

                    location = values[0]

   309

                    if not location.startswith("%"):

   310

                        dialog = wx.SingleChoiceDialog(

   311

                            self.ParentWindow.ParentWindow,

   312

                            _("Select a variable class:"),

   313

                            _("Variable class"),

   314

                            [_("Input"), _("Output"), _("Memory")],

   315

                            wx.DEFAULT_DIALOG_STYLE | wx.OK | wx.CANCEL)

   316

                        if dialog.ShowModal() == wx.ID_OK:

   317

                            selected = dialog.GetSelection()

   318

                        else:

   319

                            selected = None

   320

                        dialog.Destroy()

   321

                        if selected is None:

   322

                            return False

   323

                        if selected == 0:

   324

                            location = "%I" + location

   325

                        elif selected == 1:

   326

                            location = "%Q" + location

   327

                        else:

   328

                            location = "%M" + location

   329

                    var_name = values[3]

   330

                    dlg = wx.TextEntryDialog(

   331

                        self.ParentWindow.ParentWindow,

   332

                        _("Confirm or change variable name"),

   333

                        _('Variable Drop'), var_name)

   334

                    dlg.SetValue(var_name)

   335

                    var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   336

                    dlg.Destroy()

   337

                    if var_name is None:

   338

                        return False

   339

                    elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   340

                        message = _("\"%s\" pou already exists!") % var_name

   341

                    elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   342

                        if location[1] == "Q":

   343

                            var_class = OUTPUT

   344

                        else:

   345

                            var_class = INPUT

   346

                        if values[2] is not None:

   347

                            var_type = values[2]

   348

                        else:

   349

                            var_type = LOCATIONDATATYPES.get(location[2], ["BOOL"])[0]

   350

                        self.ParentWindow.Controler.AddEditedElementPouVar(tagname, var_type, var_name, location=location, description=values[4])

   351

                        self.ParentWindow.RefreshVariablePanel()

   352

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   353

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   354

                    else:

   355

                        message = _("\"%s\" element for this pou already exists!") % var_name

   356

            elif values[1] == "NamedConstant":

   357

                if pou_type == "program":

   358

                    initval = values[0]

   359

                    var_name = values[3]

   360

                    dlg = wx.TextEntryDialog(

   361

                        self.ParentWindow.ParentWindow,

   362

                        _("Confirm or change variable name"),

   363

                        _('Variable Drop'), var_name)

   364

                    dlg.SetValue(var_name)

   365

                    var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   366

                    dlg.Destroy()

   367

                    if var_name is None:

   368

                        return False

   369

                    elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   370

                        message = _("\"%s\" pou already exists!") % var_name

   371

                    elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   372

                        var_class = INPUT

   373

                        var_type = values[2]

   374

                        self.ParentWindow.Controler.AddEditedElementPouVar(tagname, var_type, var_name, description=values[4], initval=initval)

   375

                        self.ParentWindow.RefreshVariablePanel()

   376

                        self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   377

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   378

                    else:

   379

                        message = _("\"%s\" element for this pou already exists!") % var_name

   380

            elif values[1] == "Global":

   381

                var_name = values[0]

   382

                dlg = wx.TextEntryDialog(

   383

                    self.ParentWindow.ParentWindow,

   384

                    _("Confirm or change variable name"),

   385

                    _('Variable Drop'), var_name)

   386

                dlg.SetValue(var_name)

   387

                var_name = dlg.GetValue() if dlg.ShowModal() == wx.ID_OK else None

   388

                dlg.Destroy()

   389

                if var_name is None:

   390

                    return False

   391

                elif var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetProjectPouNames(self.ParentWindow.Debug)]:

   392

                    message = _("\"%s\" pou already exists!") % var_name

   393

                elif not var_name.upper() in [name.upper() for name in self.ParentWindow.Controler.GetEditedElementVariables(tagname, self.ParentWindow.Debug)]:

   394

                    kwargs = dict(description=values[4]) if len(values)>4 else {}

   395

                    self.ParentWindow.Controler.AddEditedElementPouExternalVar(tagname, values[2], var_name, **kwargs)

   396

                    self.ParentWindow.RefreshVariablePanel()

   397

                    self.ParentWindow.ParentWindow.RefreshPouInstanceVariablesPanel()

   398

                    self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, var_name, values[2])

   399

                else:

   400

                    message = _("\"%s\" element for this pou already exists!") % var_name

   401

            elif values[1] == "Constant":

   402

                self.ParentWindow.AddVariableBlock(x, y, scaling, INPUT, values[0], None)

   403

            elif values[3] == tagname:

   404

                if values[1] == "Output":

   405

                    var_class = OUTPUT

   406

                elif values[1] == "InOut":

   407

                    var_class = INPUT

   408

                else:

   409

                    var_class = INPUT

   410

                tree = dict([(var.Name, var.Tree) for var in self.ParentWindow.Controler.GetEditedElementInterfaceVars(tagname, True, self.ParentWindow.Debug)]).get(values[0], None)

   411

                if tree is not None:

   412

                    if len(tree[0]) > 0:

   413

                        menu = wx.Menu(title='')

   414

                        self.GenerateTreeMenu(x, y, scaling, menu, "", var_class, [(values[0], values[2], tree)])

   415

                        self.ParentWindow.PopupMenu(menu)

   416

                    else:

   417

                        self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, values[0], values[2])

   418

                else:

   419

                    message = _("Unknown variable \"%s\" for this POU!") % values[0]

   420

            else:

   421

                message = _("Variable don't belong to this POU!")

   422

        if message is not None:

   423

            wx.CallAfter(self.ShowMessage, message)

   424

            return False

   425

        return True

   426

   427

    def GenerateTreeMenu(self, x, y, scaling, menu, base_path, var_class, tree):

   428

        for child_name, child_type, (child_tree, child_dimensions) in tree:

   429

            if base_path:

   430

                child_path = "%s.%s" % (base_path, child_name)

   431

            else:

   432

                child_path = child_name

   433

            if len(child_dimensions) > 0:

   434

                child_path += "[%s]" % ",".join([str(dimension[0]) for dimension in child_dimensions])

   435

                child_name += "[]"

   436

   437

            item = self.AppendItem(menu,

   438

                child_name,

   439

                self.GetAddVariableBlockFunction(x, y, scaling, var_class, child_path, child_type))

   440

            if len(child_tree) > 0:

   441

                child_menu = wx.Menu(title='')

   442

                self.GenerateTreeMenu(x, y, scaling, child_menu, child_path, var_class, child_tree)

   443

                menu.AppendMenu(wx.ID_ANY, "%s." % child_name, child_menu)

   444

   445

    def GetAddVariableBlockFunction(self, x, y, scaling, var_class, var_name, var_type):

   446

        def AddVariableFunction(event):

   447

            self.ParentWindow.AddVariableBlock(x, y, scaling, var_class, var_name, var_type)

   448

        return AddVariableFunction

   449

   450

    def ShowMessage(self, message):

   451

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

   452

        message.ShowModal()

   453

        message.Destroy()

   454

   455

   456

class DebugInstanceName(DebugDataConsumer):

   457

    VALUE_TRANSLATION = None

   458

   459

    def __init__(self, parent):

   460

        DebugDataConsumer.__init__(self)

   461

        self.Parent = parent

   462

        self.ActionLastState = None

   463

        self.ActionState = None

   464

        self.x_offset = 2

   465

        self.y_offset = 2

   466

   467

        if self.VALUE_TRANSLATION is None:

   468

            self.__class__.VALUE_TRANSLATION = {True: _("Active"), False: _("Inactive")}

   469

   470

    def SetValue(self, value):

   471

        self.ActionState = value

   472

        if self.ActionState != self.ActionLastState:

   473

            self.ActionLastState = self.ActionState

   474

            wx.CallAfter(self.Parent.ElementNeedRefresh, self)

   475

   476

    def GetInstanceName(self):

   477

        return _("Debug: %s") % self.Parent.InstancePath

   478

   479

    def GetRedrawRect(self):

   480

        x, y = self.Parent.CalcUnscrolledPosition(self.x_offset, self.y_offset)

   481

        dc = self.Parent.GetLogicalDC()

   482

        ipw, _iph = dc.GetTextExtent(self.GetInstanceName())

   483

        vw, vh = 0, 0

   484

        for value in self.VALUE_TRANSLATION.itervalues():

   485

            w, h = dc.GetTextExtent(" (%s)" % value)

   486

            vw = max(vw, w)

   487

            vh = max(vh, h)

   488

        return wx.Rect(ipw + x, y, vw, vh)

   489

   490

    def Draw(self, dc):

   491

        scalex, scaley = dc.GetUserScale()

   492

        dc.SetUserScale(1, 1)

   493

        x, y = self.Parent.CalcUnscrolledPosition(self.x_offset, self.y_offset)

   494

   495

        text = self.GetInstanceName()

   496

        if self.ActionState is not None: