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) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

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

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

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

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

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

    22

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

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from minixsv import pyxsval

    26

from xml.dom import minidom

    27

from types import StringType, UnicodeType

    28

import cPickle

    29

import os,sys,re

    31

from datetime import *

    32

    33

from plcopen import plcopen

    34

from plcopen.structures import *

    35

from graphics.GraphicCommons import *

    36

from PLCGenerator import *

    37

    38

duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:.[0-9]*)?)ms)?")

    39

    40

[ITEM_UNEDITABLE, ITEM_PROJECT, ITEM_POU, ITEM_CLASS, ITEM_VARIABLE,

    41

 ITEM_TRANSITION, ITEM_ACTION, ITEM_CONFIGURATION, ITEM_RESOURCE, 

    42

 ITEM_DATATYPE] = range(10)

    43

    44

ScriptDirectory = os.path.split(os.path.realpath(__file__))[0]

    45

    46

"""

    47

pyxsval is not complete and the parts that are not supported print some error

    48

reports. This class is used for not displaying them

    49

"""

    50

class HolePseudoFile:

    51

    """ Base class for file like objects to facilitate StdOut for the Shell."""

    52

    def __init__(self, output = None):

    53

        if output is None: output = []

    54

        self.output = output

    55

    56

    def writelines(self, l):

    57

        map(self.write, l)

    58

    59

    def write(self, s):

    60

        pass

    61

    62

    def flush(self):

    63

        pass

    64

    65

    def isatty(self):

    66

        return false

    67

    68

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

    69

#                         Undo Buffer for PLCOpenEditor

    70

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

    71

    72

# Length of the buffer

    73

UNDO_BUFFER_LENGTH = 20

    74

    75

"""

    76

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

    77

"""

    78

class UndoBuffer:

    79

    80

    # Constructor initialising buffer

    81

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

    82

        self.Buffer = []

    83

        self.CurrentIndex = -1

    84

        self.MinIndex = -1

    85

        self.MaxIndex = -1

    86

        # if current state is defined

    87

        if currentstate:

    88

            self.CurrentIndex = 0

    89

            self.MinIndex = 0

    90

            self.MaxIndex = 0

    91

        # Initialising buffer with currentstate at the first place

    92

        for i in xrange(UNDO_BUFFER_LENGTH):

    93

            if i == 0:

    94

                self.Buffer.append(currentstate)

    95

            else:

    96

                self.Buffer.append(None)

    97

        # Initialising index of state saved

    98

        if issaved:

    99

            self.LastSave = 0

   100

        else:

   101

            self.LastSave = -1

   102

   103

    # Add a new state in buffer

   104

    def Buffering(self, currentstate):

   105

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

   106

        self.Buffer[self.CurrentIndex] = currentstate

   107

        # Actualising buffer limits

   108

        self.MaxIndex = self.CurrentIndex

   109

        if self.MinIndex == self.CurrentIndex:

   110

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

   111

            if self.LastSave == self.MinIndex:

   112

                self.LastSave = -1

   113

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

   114

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

   115

   116

    # Return current state of buffer

   117

    def Current(self):

   118

        return self.Buffer[self.CurrentIndex]

   119

   120

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

   121

    def Previous(self):

   122

        if self.CurrentIndex != self.MinIndex:

   123

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

   124

            return self.Buffer[self.CurrentIndex]

   125

        return None

   126

   127

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

   128

    def Next(self):

   129

        if self.CurrentIndex != self.MaxIndex:

   130

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

   131

            return self.Buffer[self.CurrentIndex]

   132

        return None

   133

   134

    # Return True if current state is the first in buffer

   135

    def IsFirst(self):

   136

        return self.CurrentIndex == self.MinIndex

   137

   138

    # Return True if current state is the last in buffer

   139

    def IsLast(self):

   140

        return self.CurrentIndex == self.MaxIndex

   141

   142

    # Note that current state is saved

   143

    def CurrentSaved(self):

   144

        self.LastSave = self.CurrentIndex

   145

   146

    # Return True if current state is saved

   147

    def IsCurrentSaved(self):

   148

        return self.LastSave == self.CurrentIndex

   149

   150

   151

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

   152

#                           Controler for PLCOpenEditor

   153

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

   154

   155

"""

   156

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

   157

"""

   158

class PLCControler:

   159

   160

    # Create a new PLCControler

   161

    def __init__(self):

   162

        self.LastNewIndex = 0

   163

        self.Reset()

   164

   165

    # Reset PLCControler internal variables

   166

    def Reset(self):

   167

        self.VerifyXML = False

   168

        self.Project = None

   169

        self.ProjectBuffer = None

   170

        self.Buffering = False

   171

        self.FilePath = ""

   172

        self.FileName = ""

   173

        self.ProgramFilePath = ""

   174

        self.RefreshDataTypeUsingTree()

   175

        self.RefreshDataTypes()

   176

        self.RefreshPouUsingTree()

   177

        self.RefreshBlockTypes()

   178

   179

    def GetQualifierTypes(self):

   180

        return plcopen.QualifierList

   181

   182

   183

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

   184

#                         Project management functions

   185

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

   186

   187

    # Return if a project is opened

   188

    def HasOpenedProject(self):

   189

        return self.Project != None

   190

   191

    # Create a new project by replacing the current one

   193

        # Create the project

   194

        self.Project = plcopen.project()

   198

        self.SetFilePath("")

   199

        # Initialize the project buffer

   200

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

   201

        self.Buffering = False

   202

   203

    # Return project data type names

   204

    def GetProjectDataTypeNames(self):

   205

        if self.Project:

   206

            return [datatype.getName() for datatype in self.Project.getDataTypes()]

   207

        return []

   208

   209

    # Return project pou names

   210

    def GetProjectPouNames(self):

   211

        if self.Project:

   212

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

   213

        return []

   214

   215

    # Return project pou names

   216

    def GetProjectConfigNames(self):

   217

        if self.Project:

   218

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

   219

        return []

   220

   221

    # Return project pou variables

   222

    def GetProjectPouVariables(self, pou_name=None):

   223

        variables = []

   224

        for pou in self.Project.getPous():

   225

            if not pou_name or pou_name == pou.getName():

   226

                variables.extend([var["Name"] for var in self.GetPouInterfaceVars(pou)])

   227

                for transition in pou.getTransitionList():

   228

                    variables.append(transition.getName())

   229

                for action in pou.getActionList():

   230

                    variables.append(action.getName())

   231

        return variables

   232

   233

    # Return if project is saved

   234

    def ProjectIsSaved(self):

   235

        return self.ProjectBuffer.IsCurrentSaved()

   236

   237

    # Return file path if project is an open file

   238

    def GetFilePath(self):

   239

        return self.FilePath

   240

   241

    # Return file path if project is an open file

   242

    def GetProgramFilePath(self):

   243

        return self.ProgramFilePath

   244

   245

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

   246

    def GetFilename(self):

   247

        if self.ProjectBuffer.IsCurrentSaved():

   248

            return self.FileName

   249

        else:

   250

            return "~%s~"%self.FileName

   251

   252

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

   253

    def SetFilePath(self, filepath):

   254

        self.FilePath = filepath

   255

        if filepath == "":

   256

            self.LastNewIndex += 1

   257

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

   258

        else:

   259

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

   260

   261

    # Change project properties

   262

    def SetProjectProperties(self, name = None, properties = None):

   263

        if name != None:

   264

            self.Project.setName(name)

   265

        if properties != None:

   266

            self.Project.setFileHeader(properties)

   268

        if name != None or properties != None:

   269

            self.BufferProject()

   270

   271

    # Return project properties

   272

    def GetProjectProperties(self):

   273

        properties = self.Project.getFileHeader()

   275

        return properties

   276

   277

    # Return project informations

   278

    def GetProjectInfos(self):

   279

        if self.Project:

   280

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

   281

            datatypes = {"name": "Data Types", "type": ITEM_UNEDITABLE, "values":[]}

   282

            for datatype in self.Project.getDataTypes():

   283

                datatypes["values"].append({"name": datatype.getName(), "type": ITEM_DATATYPE, "values": []})

   284

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

   285

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

   286

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

   287

            for pou in self.Project.getPous():

   288

                pou_type = pou.getPouType().getValue()

   289

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

   290

                pou_values = []

   291

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

   292

                    transitions = []

   293

                    for transition in pou.getTransitionList():

   294

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

   295

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

   296

                    actions = []

   297

                    for action in pou.getActionList():

   298

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

   299

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

   300

                if pou_type in pou_types:

   301

                    pou_infos["values"] = pou_values

   302

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

   303

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

   304

            for config in self.Project.getConfigurations():

   305

                config_name = config.getName()

   306

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

   307

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

   308

                for resource in config.getResource():

   309

                    resource_name = resource.getName()

   310

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

   311

                    resources["values"].append(resource_infos)

   312

                config_infos["values"] = [resources]

   313

                configurations["values"].append(config_infos)

   314

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

   315

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

   316

                               pou_types["program"], configurations]

   317

            return infos

   318

        return None

   319

   320

    # Refresh the tree of user-defined data type cross-use

   321

    def RefreshDataTypeUsingTree(self):

   322

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

   323

        self.DataTypeUsingTree = {}

   324

        if self.Project:

   325

            datatypes = self.Project.getDataTypes()

   326

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

   327

            # user-defined data type cross-use

   328

            datatypenames = [datatype.getName() for datatype in datatypes]

   329

            for name in datatypenames:

   330

                self.DataTypeUsingTree[name] = []

   331

            # Analyze each data type

   332

            for datatype in datatypes:

   333

                name = datatype.getName()

   334

                basetype_content = datatype.getBaseType().getContent()

   335

                if basetype_content["name"] == "derived":

   336

                    basetype_name = basetype_content["value"].getName()

   337

                    if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]:

   338

                        self.DataTypeUsingTree[basetype_name].append(name)

   339

                elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:

   340

                    base_type = basetype_content["value"].baseType.getContent()

   341

                    if base_type["value"] is not None:

   342

                        basetype_name = base_type["value"].getName()

   343

                        if basetype_name in datatypenames and name not in self.DataTypeUsingTree[basetype_name]:

   344

                            self.DataTypeUsingTree[basetype_name].append(name)

   345

   346

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

   347

    def RefreshPouUsingTree(self):

   348

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

   349

        self.PouUsingTree = {}

   350

        if self.Project:

   351

            pous = self.Project.getPous()

   352

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

   353

            # user-defined pou cross-use

   354

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

   355

            for name in pounames:

   356

                self.PouUsingTree[name] = []

   357

            # Analyze each pou 

   358

            for pou in pous:

   359

                name = pou.getName()

   360

                if pou.interface:

   361

                    # Extract variables from every varLists

   362

                    for type, varlist in pou.getVars():

   363

                        for var in varlist.getVariable():

   364

                            vartype_content = var.getType().getContent()

   365

                            if vartype_content["name"] == "derived":

   366

                                typename = vartype_content["value"].getName()

   367

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

   368

                                    self.PouUsingTree[typename].append(name)

   369

                bodytype = pou.getBodyType()

   370

                # If pou is written in a graphical language

   371

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

   372

                    # Analyze each instance of the pou

   373

                    for instance in pou.getInstances():

   374

                        if isinstance(instance, plcopen.block):

   375

                            typename = instance.getTypeName()

   376

                            # Update tree if there is a cross-use

   377

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

   378

                                 self.PouUsingTree[typename].append(name)

   379

                # If pou is written in a textual language

   380

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

   381

                    text = pou.getText()

   382

                    # Search if each pou is mentioned in the pou text

   383

                    for typename in pounames:

   384

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

   385

                        # Update tree if there is a cross-use

   386

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

   387

                            self.PouUsingTree[typename].append(name)

   388

   389

    # Return if data type given by name is used by another data type or pou

   390

    def DataTypeIsUsed(self, name):

   391

        if name in self.DataTypeUsingTree:

   392

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

   393

        return False

   394

   395

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

   396

    def PouIsUsed(self, name):

   397

        if name in self.PouUsingTree:

   398

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

   399

        return False

   400

   401

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

   402

    def DataTypeIsUsedBy(self, name, reference):

   403

        if name in self.DataTypeUsingTree:

   404

            list = self.DataTypeUsingTree[name]

   405

            # Test if data type is directly used by reference

   406

            if reference in list:

   407

                return True

   408

            else:

   409

                # Test if data type is undirectly used by reference, by testing if data types 

   410

                # that directly use data type is directly or undirectly used by reference

   411

                used = False

   412

                for element in list:

   413

                    used |= self.DataTypeIsUsedBy(element, reference)

   414

                return used

   415

        return False

   416

   417

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

   418

    def PouIsUsedBy(self, name, reference):

   419

        if name in self.PouUsingTree:

   420

            list = self.PouUsingTree[name]

   421

            # Test if pou is directly used by reference

   422

            if reference in list:

   423

                return True

   424

            else:

   425

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

   426

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

   427

                used = False

   428

                for element in list:

   429

                    used |= self.PouIsUsedBy(element, reference)

   430

                return used

   431

        return False

   432

   433

    def GenerateProgram(self, filepath):

   434

        if self.Project:

   435

            try:

   436

                program = GenerateCurrentProgram(self.Project)

   437

                programfile = open(filepath, "w")

   438

                programfile.write(program)

   439

                programfile.close()

   440

                self.ProgramFilePath = filepath

   441

                return True

   442

            except:

   443

                pass

   444

        return False

   445

   446

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

   447

#                        Project Pous management functions

   448

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

   449

   450

    # Add a Data Type to Project

   451

    def ProjectAddDataType(self, datatype_name):

   452

        # Add the pou to project

   453

        self.Project.appendDataType(datatype_name)

   454

        self.RefreshDataTypeUsingTree()

   455

        self.RefreshDataTypes()

   456

        self.BufferProject()

   457

   458

    # Remove a Data Type from project

   459

    def ProjectRemoveDataType(self, datatype_name):

   460

        self.Project.removeDataType(datatype_name)

   461

        self.RefreshDataTypeUsingTree()

   462

        self.RefreshDataTypes()

   463

        self.BufferProject()

   464

   465

    # Add a Pou to Project

   466

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

   467

        # Add the pou to project

   468

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

   469

        if pou_type == "function":

   470

            self.SetPouInterfaceReturnType(pou_name, "BOOL")

   471

        self.RefreshPouUsingTree()

   472

        self.RefreshBlockTypes()

   473

        self.BufferProject()

   474

   475

    # Remove a Pou from project

   476

    def ProjectRemovePou(self, pou_name):

   477

        self.Project.removePou(pou_name)

   478

        self.RefreshPouUsingTree()

   479

        self.RefreshBlockTypes()

   480

        self.BufferProject()

   481

   482

    # Add a configuration to Project

   483

    def ProjectAddConfiguration(self, config_name):

   484

        self.Project.addConfiguration(config_name)

   485

        self.BufferProject()

   486

   487

    # Remove a configuration from project

   488

    def ProjectRemoveConfiguration(self, config_name):

   489

        self.Project.removeConfiguration(config_name)

   490

        self.BufferProject()

   491

   492

    # Add a resource to a configuration of the Project

   493

    def ProjectAddConfigurationResource(self, config_name, resource_name):

   494

        self.Project.addConfigurationResource(config_name, resource_name)

   495

        self.BufferProject()

   496

   497

    # Remove a resource from a configuration of the project

   498

    def ProjectRemoveConfigurationResource(self, config_name, resource_name):

   499

        self.Project.removeConfigurationResource(config_name, resource_name)

   500

        self.BufferProject()

   501

   502

    # Add a Transition to a Project Pou

   503

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

   504

        pou = self.Project.getPou(pou_name)

   505

        pou.addTransition(transition_name, transition_type)

   506

        self.BufferProject()

   507

   508

    # Remove a Transition from a Project Pou

   509