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

#Lesser General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU Lesser 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 minixsv import pyxsval

    26

import cPickle

    27

import os,sys,re

    28

    29

from plcopen import plcopen

    30

from plcopen.structures import *

    31

from graphics.GraphicCommons import *

    32

from PLCGenerator import *

    33

    34

[ITEM_UNEDITABLE, ITEM_PROJECT, ITEM_POU, ITEM_CLASS, ITEM_VARIABLE,

    35

 ITEM_TRANSITION, ITEM_ACTION, ITEM_CONFIGURATION, ITEM_RESOURCE] = range(9)

    36

    37

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

    38

#                         Undo Buffer for PLCOpenEditor

    39

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

    40

    41

# Length of the buffer

    42

UNDO_BUFFER_LENGTH = 20

    43

    44

"""

    45

Class implementing a buffer of changes made on the current editing Object Dictionary

    46

"""

    47

class UndoBuffer:

    48

    49

    # Constructor initialising buffer

    50

    def __init__(self, currentstate, issaved = False):

    51

        self.Buffer = []

    52

        self.CurrentIndex = -1

    53

        self.MinIndex = -1

    54

        self.MaxIndex = -1

    55

        # if current state is defined

    56

        if currentstate:

    57

            self.CurrentIndex = 0

    58

            self.MinIndex = 0

    59

            self.MaxIndex = 0

    60

        # Initialising buffer with currentstate at the first place

    61

        for i in xrange(UNDO_BUFFER_LENGTH):

    62

            if i == 0:

    63

                self.Buffer.append(currentstate)

    64

            else:

    65

                self.Buffer.append(None)

    66

        # Initialising index of state saved

    67

        if issaved:

    68

            self.LastSave = 0

    69

        else:

    70

            self.LastSave = -1

    71

    72

    # Add a new state in buffer

    73

    def Buffering(self, currentstate):

    74

        self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

    75

        self.Buffer[self.CurrentIndex] = currentstate

    76

        # Actualising buffer limits

    77

        self.MaxIndex = self.CurrentIndex

    78

        if self.MinIndex == self.CurrentIndex:

    79

            # If the removed state was the state saved, there is no state saved in the buffer

    80

            if self.LastSave == self.MinIndex:

    81

                self.LastSave = -1

    82

            self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH

    83

        self.MinIndex = max(self.MinIndex, 0)

    84

    85

    # Return current state of buffer

    86

    def Current(self):

    87

        return self.Buffer[self.CurrentIndex]

    88

    89

    # Change current state to previous in buffer and return new current state

    90

    def Previous(self):

    91

        if self.CurrentIndex != self.MinIndex:

    92

            self.CurrentIndex = (self.CurrentIndex - 1) % UNDO_BUFFER_LENGTH

    93

            return self.Buffer[self.CurrentIndex]

    94

        return None

    95

    96

    # Change current state to next in buffer and return new current state

    97

    def Next(self):

    98

        if self.CurrentIndex != self.MaxIndex:

    99

            self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

   100

            return self.Buffer[self.CurrentIndex]

   101

        return None

   102

   103

    # Return True if current state is the first in buffer

   104

    def IsFirst(self):

   105

        return self.CurrentIndex == self.MinIndex

   106

   107

    # Return True if current state is the last in buffer

   108

    def IsLast(self):

   109

        return self.CurrentIndex == self.MaxIndex

   110

   111

    # Note that current state is saved

   112

    def CurrentSaved(self):

   113

        self.LastSave = self.CurrentIndex

   114

   115

    # Return True if current state is saved

   116

    def IsCurrentSaved(self):

   117

        return self.LastSave == self.CurrentIndex

   118

   119

   120

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

   121

#                           Controler for PLCOpenEditor

   122

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

   123

   124

"""

   125

Class which controls the operations made on the plcopen model and answers to view requests

   126

"""

   127

class PLCControler:

   128

   129

    # Create a new PLCControler

   130

    def __init__(self):

   131

        self.LastNewIndex = 0

   132

        self.Reset()

   133

   134

    # Reset PLCControler internal variables

   135

    def Reset(self):

   136

        self.Project = None

   137

        self.ProjectBuffer = None

   138

        self.FilePath = ""

   139

        self.FileName = ""

   140

        self.ElementsOpened = []

   141

        self.CurrentElementEditing = None

   142

        self.RefreshPouUsingTree()

   143

        self.RefreshBlockTypes()

   144

   145

    def GetQualifierTypes(self):

   146

        return plcopen.QualifierList

   147

   148

   149

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

   150

#                         Project management functions

   151

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

   152

   153

    # Return if a project is opened

   154

    def HasOpenedProject(self):

   155

        return self.Project != None

   156

   157

    # Create a new project by replacing the current one

   158

    def CreateNewProject(self, name):

   159

        # Create the project

   160

        self.Project = plcopen.project()

   161

        self.Project.setName(name)

   162

        # Initialize the project buffer

   163

        self.ProjectBuffer = UndoBuffer(self.Copy(self.Project))

   164

   165

    # Change project name

   166

    def SetProjectName(self, name):

   167

        self.Project.setName(name)

   168

   169

    # Return project name

   170

    def GetProjectName(self):

   171

        return self.Project.getName()

   172

   173

    # Return project pou names

   174

    def GetProjectPouNames(self):

   175

        return [pou.getName() for pou in self.Project.getPous()]

   176

   177

    # Return project pou names

   178

    def GetProjectConfigNames(self):

   179

        return [config.getName() for config in self.Project.getConfigurations()]

   180

   181

    # Return file path if project is an open file

   182

    def GetFilePath(self):

   183

        return self.FilePath

   184

   185

    # Return file name and point out if file is up to date

   186

    def GetFilename(self):

   187

        if self.ProjectBuffer.IsCurrentSaved():

   188

            return self.FileName

   189

        else:

   190

            return "~%s~"%self.FileName

   191

   192

    # Change file path and save file name or create a default one if file path not defined

   193

    def SetFilePath(self, filepath):

   194

        self.FilePath = filepath

   195

        if filepath == "":

   196

            self.LastNewIndex += 1

   197

            self.FileName = "Unnamed%d"%self.LastNewIndex

   198

        else:

   199

            self.FileName = os.path.splitext(os.path.basename(filepath))[0]

   200

   201

    # Change project properties

   202

    def SetProjectProperties(self, values):

   203

        self.Project.setFileHeader(values)

   204

   205

    # Return project properties

   206

    def GetProjectProperties(self):

   207

        return self.Project.getFileHeader()

   208

   209

    # Return project informations

   210

    def GetProjectInfos(self):

   211

        if self.Project:

   212

            infos = {"name": self.Project.getName(), "type": ITEM_PROJECT}

   213

            pou_types = {"function": {"name": "Functions", "type": ITEM_UNEDITABLE, "values":[]},

   214

                         "functionBlock": {"name": "Function Blocks", "type": ITEM_UNEDITABLE, "values":[]},

   215

                         "program": {"name": "Programs", "type": ITEM_UNEDITABLE, "values":[]}}

   216

            for pou in self.Project.getPous():

   217

                pou_type = pou.getPouType().getValue()

   218

                pou_infos = {"name": pou.getName(), "type": ITEM_POU}

   219

                var_types = {"Input": {"name": "Input", "type": ITEM_CLASS, "values": []},

   220

                         "Output": {"name": "Output", "type": ITEM_CLASS, "values": []},

   221

                         "InOut": {"name": "InOut", "type": ITEM_CLASS, "values": []},

   222

                         "External": {"name": "External", "type": ITEM_CLASS, "values": []},

   223

                         "Local": {"name": "Local", "type": ITEM_CLASS, "values": []},

   224

                         "Temp": {"name": "Temp", "type": ITEM_CLASS, "values": []},

   225

                         "Global": {"name": "Global", "type": ITEM_CLASS, "values": []}}

   226

                for var in self.GetPouInterfaceVars(pou):

   227

                    var_values = {"name": var["Name"], "type": ITEM_VARIABLE, "values": []}

   228

                    if var["Class"] in var_types.keys():

   229

                        var_types[var["Class"]]["values"].append(var_values)

   230

                pou_values = []

   231

                pou_values.append({"name": "Interface", "type": ITEM_CLASS, 

   232

                    "values": [var_types["Input"], var_types["Output"], var_types["InOut"], var_types["External"]]})

   233

                pou_values.append({"name": "Variables", "type": ITEM_CLASS, 

   234

                    "values": [var_types["Local"], var_types["Temp"]]})

   235

                if pou_type == "program":

   236

                    pou_values.append(var_types["Global"])

   237

                if pou.getBodyType() == "SFC":

   238

                    transitions = []

   239

                    for transition in pou.getTransitionList():

   240

                        transitions.append({"name": transition.getName(), "type": ITEM_TRANSITION, "values": []})

   241

                    pou_values.append({"name": "Transitions", "type": ITEM_UNEDITABLE, "values": transitions})

   242

                    actions = []

   243

                    for action in pou.getActionList():

   244

                        actions.append({"name": action.getName(), "type": ITEM_ACTION, "values": []})

   245

                    pou_values.append({"name": "Actions", "type": ITEM_UNEDITABLE, "values": actions})

   246

                if pou_type in pou_types:

   247

                    pou_infos["values"] = pou_values

   248

                    pou_types[pou_type]["values"].append(pou_infos)

   249

            configurations = {"name": "Configurations", "type": ITEM_UNEDITABLE, "values": []}

   250

            for config in self.Project.getConfigurations():

   251

                config_name = config.getName()

   252

                config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, "values": []}

   253

                config_vars = {"name": "Global", "type": ITEM_CLASS, "values": []}

   254

                for var in self.GetConfigurationGlobalVars(config_name):

   255

                    var_values = {"name": var["Name"], "type": ITEM_VARIABLE, "values": []}

   256

                    config_vars["values"].append(var_values)

   257

                resources = {"name": "Resources", "type": ITEM_UNEDITABLE, "values": []}

   258

                for resource in config.getResource():

   259

                    resource_name = resource.getName()

   260

                    resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, "values": []}

   261

                    resource_vars = {"name": "Global", "type": ITEM_CLASS, "values": []}

   262

                    for var in self.GetConfigurationResourceGlobalVars(config_name, resource_name):

   263

                        var_values = {"name": var["Name"], "type": ITEM_VARIABLE, "values": []}

   264

                        resource_vars["values"].append(var_values)

   265

                    resource_infos["values"].append(resource_vars)

   266

                    resources["values"].append(resource_infos)

   267

                config_infos["values"] = [config_vars, resources]

   268

                configurations["values"].append(config_infos)

   269

            infos["values"] = [{"name": "Properties", "type": ITEM_UNEDITABLE, "values": []},

   270

                               pou_types["function"], pou_types["functionBlock"], 

   271

                               pou_types["program"], configurations]

   272

            return infos

   273

        return None

   274

   275

    # Refresh the tree of user-defined pou cross-use

   276

    def RefreshPouUsingTree(self):

   277

        # Reset the tree of user-defined pou cross-use

   278

        self.PouUsingTree = {}

   279

        if self.Project:

   280

            pous = self.Project.getPous()

   281

            # Reference all the user-defined pou names and initialize the tree of 

   282

            # user-defined pou cross-use

   283

            pounames = [pou.getName() for pou in pous]

   284

            for name in pounames:

   285

                self.PouUsingTree[name] = []

   286

            # Analyze each pou 

   287

            for pou in pous:

   288

                name = pou.getName()

   289

                bodytype = pou.getBodyType()

   290

                # If pou is written in a graphical language

   291

                if bodytype in ["FBD","LD","SFC"]:

   292

                    # Analyze each instance of the pou

   293

                    for instance in pou.getInstances():

   294

                        if isinstance(instance, plcopen.block):

   295

                            typename = instance.getTypeName()

   296

                            # Update tree if there is a cross-use

   297

                            if typename in pounames and name not in self.PouUsingTree[typename]:

   298

                                 self.PouUsingTree[typename].append(name)

   299

                # If pou is written in a textual language

   300

                elif bodytype in ["IL", "ST"]:

   301

                    text = pou.getText()

   302

                    # Search if each pou is mentioned in the pou text

   303

                    for typename in pounames:

   304

                        typename_model = re.compile("[ \t\n]%s[ \t\n]"%typename)

   305

                        # Update tree if there is a cross-use

   306

                        if typename != name and typename_model.search(text):

   307

                            self.PouUsingTree[typename].append(name)

   308

   309

    # Return if pou given by name is used by another pou

   310

    def PouIsUsed(self, name):

   311

        if name in self.PouUsingTree:

   312

            return len(self.PouUsingTree[name]) > 0

   313

        return False

   314

   315

    # Return if pou given by name is directly or undirectly used by the reference pou

   316

    def PouIsUsedBy(self, name, reference):

   317

        if name in self.PouUsingTree:

   318

            list = self.PouUsingTree[name]

   319

            # Test if pou is directly used by reference

   320

            if reference in list:

   321

                return True

   322

            else:

   323

                # Test if pou is undirectly used by reference, by testing if pous 

   324

                # that directly use pou is directly or undirectly used by reference

   325

                used = False

   326

                for element in list:

   327

                    used |= self.PouIsUsedBy(element, reference)

   328

                return used

   329

        return False

   330

   331

    def GenerateProgram(self):

   332

        if self.Project:

   333

            program = GenerateCurrentProgram(self.Project)

   334

            programfile = open("test.st", "w")

   335

            programfile.write(program)

   336

            programfile.close()

   337

   338

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

   339

#                        Project Pous management functions

   340

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

   341

   342

    # Add a Pou to Project

   343

    def ProjectAddPou(self, name, pou_type, body_type):

   344

        # Add the pou to project

   345

        self.Project.appendPou(name, pou_type, body_type)

   346

        self.RefreshPouUsingTree()

   347

        self.RefreshBlockTypes()

   348

   349

    # Remove a pou from project

   350

    def ProjectRemovePou(self, name):

   351

        removed = None

   352

        # Search if the pou removed is currently opened

   353

        for i, pou in enumerate(self.ElementsOpened):

   354

            if pou == name:

   355

                removed = i

   356

        # If found, remove pou from list of opened pous and actualize current edited

   357

        if removed != None:

   358

            self.ElementsOpened.pop(removed)

   359

            if self.CurrentElementEditing > removed:

   360

                self.CurrentElementEditing -= 1

   361

            if len(self.ElementsOpened) > 0:

   362

                self.CurrentElementEditing = max(0, min(self.CurrentElementEditing, len(self.ElementsOpened) - 1))

   363

            else:

   364

                self.CurrentElementEditing = None

   365

        # Remove pou from project

   366

        self.Project.removePou(name)

   367

        self.RefreshPouUsingTree()

   368

        self.RefreshBlockTypes()

   369

   370

    # Add a configuration to Project

   371

    def ProjectAddConfiguration(self, name):

   372

        self.Project.addConfiguration(name)

   373

        self.RefreshPouUsingTree()

   374

        self.RefreshBlockTypes()

   375

   376

    # Remove a configuration from project

   377

    def ProjectRemoveConfiguration(self, name):

   378

        self.Project.removeConfiguration(name)

   379

        self.RefreshPouUsingTree()

   380

        self.RefreshBlockTypes()

   381

   382

    # Add a resource to a configuration of the Project

   383

    def ProjectAddConfigurationResource(self, config, name):

   384

        self.Project.addConfigurationResource(config, name)

   385

        self.RefreshPouUsingTree()

   386

        self.RefreshBlockTypes()

   387

   388

    # Remove a resource from a configuration of the project

   389

    def ProjectRemoveConfigurationResource(self, config, name):

   390

        self.Project.removeConfigurationResource(config, name)

   391

        self.RefreshPouUsingTree()

   392

        self.RefreshBlockTypes()

   393

   394

    # Add a Transition to a Project Pou

   395

    def ProjectAddPouTransition(self, pou_name, transition_name, transition_type):

   396

        pou = self.Project.getPou(pou_name)

   397

        pou.addTransition(transition_name, transition_type)

   398

   399

    # Add a Transition to a Project Pou

   400

    def ProjectAddPouAction(self, pou_name, action_name, action_type):

   401

        pou = self.Project.getPou(pou_name)

   402

        pou.addAction(action_name, action_type)

   403

   404

    # Change the name of a pou

   405

    def ChangePouName(self, old_name, new_name):

   406

        # Found the pou corresponding to old name and change its name to new name

   407

        pou = self.Project.getPou(old_name)

   408

        pou.setName(new_name)

   409

        # If pou is currently opened, change its name in the list of opened pous

   410

        if old_name in self.ElementsOpened:

   411

            idx = self.ElementsOpened.index(old_name)

   412

            self.ElementsOpened[idx] = new_name

   413

        self.RefreshPouUsingTree()

   414

        self.RefreshBlockTypes()

   415

   416

    # Change the name of a pou transition

   417

    def ChangePouTransitionName(self, pou_name, old_name, new_name):

   418

        # Found the pou transition corresponding to old name and change its name to new name

   419

        pou = self.Project.getPou(pou_name)

   420

        transition = pou.getTransition(old_name)

   421

        transition.setName(new_name)

   422

        # If pou transition is currently opened, change its name in the list of opened elements

   423

        old_computedname = self.ComputePouTransitionName(pou_name, old_name)

   424

        new_computedname = self.ComputePouTransitionName(pou_name, new_name)

   425

        if old_computedname in self.ElementsOpened:

   426

            idx = self.ElementsOpened.index(old_computedname)

   427

            self.ElementsOpened[idx] = new_computedname

   428

   429

    # Change the name of a pou action

   430

    def ChangePouActionName(self, pou_name, old_name, new_name):

   431

        # Found the pou action corresponding to old name and change its name to new name

   432

        pou = self.Project.getPou(pou_name)

   433

        action = pou.getAction(old_name)

   434

        action.setName(new_name)

   435

        # If pou action is currently opened, change its name in the list of opened elements

   436

        old_computedname = self.ComputePouActionName(pou_name, old_name)

   437

        new_computedname = self.ComputePouActionName(pou_name, new_name)

   438

        if old_computedname in self.ElementsOpened:

   439

            idx = self.ElementsOpened.index(old_computedname)

   440

            self.ElementsOpened[idx] = new_computedname

   441

   442

    # Change the name of a configuration

   443

    def ChangeConfigurationName(self, old_name, new_name):

   444

        # Found the configuration corresponding to old name and change its name to new name

   445

        configuration = self.Project.getConfiguration(old_name)

   446

        configuration.setName(new_name)

   447

        # If configuration is currently opened, change its name in the list of opened elements

   448

        for idx, element in enumerate(self.ElementsOpened):

   449

            self.ElementsOpened[idx] = element.replace(old_name, new_name)

   450

   451

    # Change the name of a configuration resource

   452

    def ChangeConfigurationResourceName(self, config_name, old_name, new_name):

   453

        # Found the resource corresponding to old name and change its name to new name

   454

        resource = self.Project.getConfigurationResource(config_name)

   455

        resource.setName(new_name)

   456

        # If resource is currently opened, change its name in the list of opened elements

   457

        old_computedname = self.ComputeConfigurationResourceName(config_name, old_name)

   458

        new_computedname = self.ComputeConfigurationResourceName(config_name, new_name)

   459

        if old_computedname in self.ElementsOpened:

   460

            idx = self.ElementsOpened.index(old_computedname)

   461

            self.ElementsOpened[idx] = new_computedname

   462

   463

    # Return the type of the pou given by its name

   464

    def GetPouType(self, name):

   465

        # Found the pou correponding to name and return its type

   466

        pou = self.Project.getPou(name)

   467

        return pou.pouType.getValue()

   468

   469

    # Return pous with SFC language

   470

    def GetSFCPous(self):

   471

        list = []

   472

        if self.Project:

   473

            for pou in self.Project.getPous():

   474

                if pou.getBodyType() == "SFC":

   475

                    list.append(pou.getName())

   476

        return list

   477

   478

    # Return the body language of the pou given by its name

   479

    def GetPouBodyType(self, name):

   480

        # Found the pou correponding to name and return its body language

   481

        pou = self.Project.getPou(name)

   482

        return pou.getBodyType()

   483

   484

    # Return the body language of the transition given by its name

   485

    def GetTransitionBodyType(self, pou_name, pou_transition):

   486

        # Found the pou correponding to name and return its body language

   487

        pou = self.Project.getPou(pou_name)

   488

        transition = pou.getTransition(pou_transition)

   489

        return transition.getBodyType()

   490

   491

    # Return the body language of the pou given by its name

   492

    def GetActionBodyType(self, pou_name, pou_action):

   493

        # Found the pou correponding to name and return its body language

   494

        pou = self.Project.getPou(pou_name)

   495

        action = pou.getAction(pou_action)

   496

        return action.getBodyType()

   497

   498

    # Extract varlists from a list of vars

   499

    def ExtractVarLists(self, vars):

   500

        varlist_list = []

   501

        current_varlist = None

   502

        current_type = None

   503

        for var in vars:

   504

            if current_type != (var["Class"], var["Retain"], var["Constant"]):

   505

                current_type = (var["Class"], var["Retain"], var["Constant"])

   506

                current_varlist = plcopen.varList()

   507

                varlist_list.append((var["Class"], current_varlist))

   508

                if var["Retain"] == "Yes":

   509

                    varlist.setRetain(True)

   510

                if var["Constant"] == "Yes":

   511

                    varlist.setConstant(True)

   512

            # Create variable and change its properties

   513

            tempvar = plcopen.varListPlain_variable()

   514

            tempvar.setName(var["Name"])

   515

            var_type = plcopen.dataType()

   516

            var_type.setValue(var["Type"])

   517

            tempvar.setType(var_type)

   518

            if var["Initial Value"] != "":

   519

                value = plcopen.value()

   520

                value.setValue(var["Initial Value"])

   521

                tempvar.setInitialValue(value)

   522

            if var["Location"] != "":

   523

                tempvar.setAddress(var["Location"])

   524

            # Add variable to varList

   525

            current_varlist.appendVariable(tempvar)

   526

        return varlist_list

   527

   528

    # Replace the configuration globalvars by those given

   529

    def SetConfigurationGlobalVars(self, name, vars):

   530

        # Found the configuration corresponding to name