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 xml.dom import minidom

    26

from types import StringType, UnicodeType

    27

import cPickle

    28

import os,sys,re

    29

from time import localtime

    30

from datetime import *

    31

    32

from plcopen import plcopen

    33

from plcopen.structures import *

    34

from graphics.GraphicCommons import *

    35

from PLCGenerator import *

    36

    37

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)?")

    38

    39

ITEMS_EDITABLE = [ITEM_PROJECT,

    40

                    ITEM_POU,

    41

                    ITEM_VARIABLE,

    42

                    ITEM_TRANSITION,

    43

                    ITEM_ACTION,

    44

                    ITEM_CONFIGURATION,

    45

                    ITEM_RESOURCE,

    46

                    ITEM_DATATYPE] = range(8)

    47

    48

ITEMS_UNEDITABLE=[ITEM_DATATYPES,

    49

                  ITEM_FUNCTION,

    50

                  ITEM_FUNCTIONBLOCK,

    51

                  ITEM_PROGRAM,

    52

                  ITEM_TRANSITIONS,

    53

                  ITEM_ACTIONS,

    54

                  ITEM_CONFIGURATIONS,

    55

                  ITEM_RESOURCES,

    56

                  ITEM_PROPERTIES,

    57

                  ]=range(9,18)

    58

    59

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

    60

    61

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

    62

#                         Undo Buffer for PLCOpenEditor

    63

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

    64

    65

# Length of the buffer

    66

UNDO_BUFFER_LENGTH = 20

    67

    68

"""

    69

Class implementing a buffer of changes made on the current editing model

    70

"""

    71

class UndoBuffer:

    72

    73

    # Constructor initialising buffer

    74

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

    75

        self.Buffer = []

    76

        self.CurrentIndex = -1

    77

        self.MinIndex = -1

    78

        self.MaxIndex = -1

    79

        # if current state is defined

    80

        if currentstate:

    81

            self.CurrentIndex = 0

    82

            self.MinIndex = 0

    83

            self.MaxIndex = 0

    84

        # Initialising buffer with currentstate at the first place

    85

        for i in xrange(UNDO_BUFFER_LENGTH):

    86

            if i == 0:

    87

                self.Buffer.append(currentstate)

    88

            else:

    89

                self.Buffer.append(None)

    90

        # Initialising index of state saved

    91

        if issaved:

    92

            self.LastSave = 0

    93

        else:

    94

            self.LastSave = -1

    95

    96

    # Add a new state in buffer

    97

    def Buffering(self, currentstate):

    98

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

    99

        self.Buffer[self.CurrentIndex] = currentstate

   100

        # Actualising buffer limits

   101

        self.MaxIndex = self.CurrentIndex

   102

        if self.MinIndex == self.CurrentIndex:

   103

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

   104

            if self.LastSave == self.MinIndex:

   105

                self.LastSave = -1

   106

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

   107

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

   108

   109

    # Return current state of buffer

   110

    def Current(self):

   111

        return self.Buffer[self.CurrentIndex]

   112

   113

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

   114

    def Previous(self):

   115

        if self.CurrentIndex != self.MinIndex:

   116

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

   117

            return self.Buffer[self.CurrentIndex]

   118

        return None

   119

   120

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

   121

    def Next(self):

   122

        if self.CurrentIndex != self.MaxIndex:

   123

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

   124

            return self.Buffer[self.CurrentIndex]

   125

        return None

   126

   127

    # Return True if current state is the first in buffer

   128

    def IsFirst(self):

   129

        return self.CurrentIndex == self.MinIndex

   130

   131

    # Return True if current state is the last in buffer

   132

    def IsLast(self):

   133

        return self.CurrentIndex == self.MaxIndex

   134

   135

    # Note that current state is saved

   136

    def CurrentSaved(self):

   137

        self.LastSave = self.CurrentIndex

   138

   139

    # Return True if current state is saved

   140

    def IsCurrentSaved(self):

   141

        return self.LastSave == self.CurrentIndex

   142

   143

   144

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

   145

#                           Controler for PLCOpenEditor

   146

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

   147

   148

"""

   149

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

   150

"""

   151

class PLCControler:

   152

   153

    # Create a new PLCControler

   154

    def __init__(self):

   155

        self.LastNewIndex = 0

   156

        self.Reset()

   157

   158

    # Reset PLCControler internal variables

   159

    def Reset(self):

   160

        self.Project = None

   161

        self.ProjectBuffer = None

   162

        self.Buffering = False

   163

        self.FilePath = ""

   164

        self.FileName = ""

   165

        self.ProgramChunks = []

   166

        self.PluginTypes = []

   167

        self.ProgramFilePath = ""

   168

   169

    def GetQualifierTypes(self):

   170

        return plcopen.QualifierList

   171

   172

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

   173

#                         Project management functions

   174

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

   175

   176

    # Return if a project is opened

   177

    def HasOpenedProject(self):

   178

        return self.Project != None

   179

   180

    # Create a new project by replacing the current one

   181

    def CreateNewProject(self, properties):

   182

        # Create the project

   183

        self.Project = plcopen.project()

   184

        properties["creationDateTime"] = datetime(*localtime()[:6])

   185

        self.Project.setfileHeader(properties)

   186

        self.Project.setcontentHeader(properties)

   187

        self.SetFilePath("")

   188

        # Initialize the project buffer

   189

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

   190

        self.Buffering = False

   191

   192

    # Return project data type names

   193

    def GetProjectDataTypeNames(self):

   194

        if self.Project:

   195

            return [datatype.getname() for datatype in self.Project.getdataTypes()]

   196

        return []

   197

   198

    # Return project pou names

   199

    def GetProjectPouNames(self):

   200

        if self.Project:

   201

            return [pou.getname() for pou in self.Project.getpous()]

   202

        return []

   203

   204

    # Return project pou names

   205

    def GetProjectConfigNames(self):

   206

        if self.Project:

   207

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

   208

        return []

   209

   210

    # Return project pou variables

   211

    def GetProjectPouVariables(self, pou_name=None):

   212

        variables = []

   213

        for pou in self.Project.getpous():

   214

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

   215

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

   216

                for transition in pou.gettransitionList():

   217

                    variables.append(transition.getname())

   218

                for action in pou.getactionList():

   219

                    variables.append(action.getname())

   220

        return variables

   221

   222

    # Return if project is saved

   223

    def ProjectIsSaved(self):

   224

        return self.ProjectBuffer.IsCurrentSaved()

   225

   226

    # Return file path if project is an open file

   227

    def GetFilePath(self):

   228

        return self.FilePath

   229

   230

    # Return file path if project is an open file

   231

    def GetProgramFilePath(self):

   232

        return self.ProgramFilePath

   233

   234

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

   235

    def GetFilename(self):

   236

        if self.ProjectBuffer.IsCurrentSaved():

   237

            return self.FileName

   238

        else:

   239

            return "~%s~"%self.FileName

   240

   241

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

   242

    def SetFilePath(self, filepath):

   243

        self.FilePath = filepath

   244

        if filepath == "":

   245

            self.LastNewIndex += 1

   246

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

   247

        else:

   248

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

   249

   250

    # Change project properties

   251

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

   252

        if name != None:

   253

            self.Project.setname(name)

   254

        if properties != None:

   255

            self.Project.setfileHeader(properties)

   256

            self.Project.setcontentHeader(properties)

   257

        if name != None or properties != None:

   258

            self.BufferProject()

   259

   260

    # Return project properties

   261

    def GetProjectProperties(self):

   262

        properties = self.Project.getfileHeader()

   263

        properties.update(self.Project.getcontentHeader())

   264

        return properties

   265

   266

    # Return project informations

   267

    def GetProjectInfos(self):

   268

        if self.Project:

   269

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

   270

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

   271

            for datatype in self.Project.getdataTypes():

   272

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

   273

                    "tagname": self.ComputeDataTypeName(datatype.getname()), "values": []})

   274

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

   275

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

   276

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

   277

            for pou in self.Project.getpous():

   278

                pou_type = pou.getpouType()

   279

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

   280

                             "tagname": self.ComputePouName(pou.getname())}

   281

                pou_values = []

   282

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

   283

                    transitions = []

   284

                    for transition in pou.gettransitionList():

   285

                        transitions.append({"name": transition.getname(), "type": ITEM_TRANSITION, 

   286

                            "tagname": self.ComputePouTransitionName(pou.getname(), transition.getname()), 

   287

                            "values": []})

   288

                    pou_values.append({"name": "Transitions", "type": ITEM_TRANSITIONS, 

   289

                                       "tagname": "", "values": transitions})

   290

                    actions = []

   291

                    for action in pou.getactionList():

   292

                        actions.append({"name": action.getname(), "type": ITEM_ACTION, 

   293

                            "tagname": self.ComputePouActionName(pou.getname(), action.getname()), 

   294

                            "values": []})

   295

                    pou_values.append({"name": "Actions", "type": ITEM_ACTIONS, 

   296

                                       "tagname": "", "values": actions})

   297

                if pou_type in pou_types:

   298

                    pou_infos["values"] = pou_values

   299

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

   300

            configurations = {"name": "Configurations", "type": ITEM_CONFIGURATIONS, 

   301

                              "tagname": "", "values": []}

   302

            for config in self.Project.getconfigurations():

   303

                config_name = config.getname()

   304

                config_infos = {"name": config_name, "type": ITEM_CONFIGURATION, 

   305

                    "tagname": self.ComputeConfigurationName(config.getname()), 

   306

                    "values": []}

   307

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

   308

                for resource in config.getresource():

   309

                    resource_name = resource.getname()

   310

                    resource_infos = {"name": resource_name, "type": ITEM_RESOURCE, 

   311

                        "tagname": self.ComputeConfigurationResourceName(config.getname(), resource.getname()), 

   312

                        "values": []}

   313

                    resources["values"].append(resource_infos)

   314

                config_infos["values"] = [resources]

   315

                configurations["values"].append(config_infos)

   316

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

   317

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

   318

                               pou_types["program"], configurations]

   319

            return infos

   320

        return None

   321

   322

    # Return project topology informations

   323

    def GetProjectTopology(self):

   324

        if self.Project:

   325

            infos = {"name": self.Project.getname(), "type": ITEM_PROJECT, "values" : []}

   326

            for config in self.Project.getconfigurations():

   327

                config_infos = {"name" : config.getname(), "type": ITEM_CONFIGURATION, "values" : []}

   328

                for resource in config.getresource():

   329

                    resource_infos = {"name" : resource.getname(), "type": ITEM_RESOURCE, "values": []}

   330

                    for task in resource.gettask():

   331

                        for pou in task.getpouInstance():

   332

                            instance_infos = self.GetPouTopology(pou.getname(), pou.gettype())

   333

                            if instance_infos is not None:

   334

                                resource_infos["values"].append(instance_infos)

   335

                    for pou in resource.getpouInstance():

   336

                        instance_infos = self.GetPouTopology(pou.getname(), pou.gettype())

   337

                        if instance_infos is not None:

   338

                            resource_infos["values"].append(instance_infos)

   339

                    for varlist in resource.getglobalVars():

   340

                        for variable in varlist.getvariable():

   341

                            vartype_content = variable.gettype().getcontent()

   342

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

   343

                                var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname())

   344

                                if var_infos is not None:

   345

                                    resource_infos["values"].append(var_infos)

   346

                            elif vartype_content["name"] in ["string", "wstring"]:

   347

                                resource_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"].upper()), 

   348

                                                                 "type" : ITEM_VARIABLE, "values" : []})

   349

                            else:

   350

                                resource_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"]), 

   351

                                                                 "type" : ITEM_VARIABLE, "values" : []})

   352

                    config_infos["values"].append(resource_infos)

   353

                for varlist in config.getglobalVars():

   354

                    for variable in varlist.getvariable():

   355

                        vartype_content = variable.gettype().getcontent()

   356

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

   357

                            var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname())

   358

                            if var_infos is not None:

   359

                                config_infos["values"].append(var_infos)

   360

                        elif vartype_content["name"] in ["string", "wstring"]:

   361

                            config_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"].upper()), 

   362

                                                           "type" : ITEM_VARIABLE, "values" : []})

   363

                        else:

   364

                            config_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"]), 

   365

                                                           "type" : ITEM_VARIABLE, "values" : []})

   366

                infos["values"].append(config_infos)

   367

            return infos

   368

        return None

   369

   370

    # Return pou topology informations

   371

    def GetPouTopology(self, name, type):

   372

        if self.Project:

   373

            pou = self.Project.getpou(type)

   374

            if pou is not None:

   375

                pou_infos = {"name" : "%s(%s)"%(name, type), "type" : ITEM_POU, "values" : []}

   376

                if pou.interface:

   377

                    # Extract variables from every varLists

   378

                    for type, varlist in pou.getvars():

   379

                        for variable in varlist.getvariable():

   380

                            vartype_content = variable.gettype().getcontent()

   381

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

   382

                                var_infos = self.GetPouTopology(variable.getname(), vartype_content["value"].getname())

   383

                                if var_infos is not None:

   384

                                    pou_infos["values"].append(var_infos)

   385

                            elif vartype_content["name"] in ["string", "wstring"]:

   386

                                pou_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"].upper()), 

   387

                                                               "type" : ITEM_VARIABLE, "values" : []})

   388

                            else:

   389

                                pou_infos["values"].append({"name" : "%s(%s)"%(variable.getname(), vartype_content["name"]), 

   390

                                                               "type" : ITEM_VARIABLE, "values" : []})

   391

                return pou_infos

   392

            block_infos = self.GetBlockType(type)

   393

            if block_infos is not None and block_infos["type"] != "function":

   394

                pou_infos = {"name" : "%s(%s)"%(name, type), "type" : ITEM_POU, "values" : []}

   395

                for varname, vartype, varmodifier in block_infos["inputs"]:

   396

                    pou_infos["values"].append({"name" : "%s(%s)"%(varname, vartype), "type" : ITEM_VARIABLE, "values" : []})

   397

                for varname, vartype, varmodifier in block_infos["outputs"]:

   398

                    pou_infos["values"].append({"name" : "%s(%s)"%(varname, vartype), "type" : ITEM_VARIABLE, "values" : []})

   399

                return pou_infos

   400

   401

            if type in TypeHierarchy:

   402

                return {"name" : "%s(%s)"%(name, type), "type" : ITEM_VARIABLE, "values" : []}

   403

   404

        return None

   405

   406

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

   407

    def DataTypeIsUsed(self, name):

   408

        return self.Project.ElementIsUsed(name) or self.Project.DataTypeIsDerived(name)

   409

   410

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

   411

    def PouIsUsed(self, name):

   412

        return self.Project.ElementIsUsed(name)

   413

   414

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

   415

    def PouIsUsedBy(self, name, reference):

   416

        return self.Project.ElementIsUsedBy(name, reference)

   417

   418

    def GenerateProgram(self, filepath):

   419

        if self.Project:

   420

            try:

   421

                self.ProgramChunks = GenerateCurrentProgram(self, self.Project)

   422

                program_text = "".join([item[0] for item in self.ProgramChunks])

   423

                programfile = open(filepath, "w")

   424

                programfile.write(program_text)

   425

                programfile.close()

   426

                self.ProgramFilePath = filepath

   427

                return None

   428

            except PLCGenException, e:

   429

                return e.message

   430

        return "No project opened"

   431

   432

    def GetChunkInfos(self, from_location, to_location):

   433

        row = col = 1

   434

        infos = []

   435

        for chunk, chunk_infos in self.ProgramChunks:

   436

            lines = chunk.split("\n")

   437

            if len(lines) > 1:

   438

                next_row = row + len(lines) - 1

   439

                next_col = len(lines[-1]) + 1

   440

            else:

   441

                next_col = col + len(chunk)

   442

            if (next_row > from_location[0] or next_row == from_location[0] and next_col >= from_location[1]) and len(chunk_infos) > 0:

   443

                infos.append((chunk_infos, (row, col)))

   444

            if next_row == to_location[0] and next_col > to_location[1] or next_row > to_location[0]:

   445

                return infos

   446

            row, col = next_row, next_col

   447

        return infos

   448

   449

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

   450

#                        Project Pous management functions

   451

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

   452

   453

    # Add a Data Type to Project

   454

    def ProjectAddDataType(self, datatype_name):

   455

        # Add the pou to project

   456

        self.Project.appenddataType(datatype_name)

   457

        self.BufferProject()

   458

   459

    # Remove a Data Type from project

   460

    def ProjectRemoveDataType(self, datatype_name):

   461

        self.Project.removedataType(datatype_name)

   462

        self.BufferProject()

   463

   464

    # Add a Pou to Project

   465

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

   466

        # Add the pou to project

   467

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

   468

        if pou_type == "function":

   469

            self.SetPouInterfaceReturnType(pou_name, "BOOL")

   470

        self.BufferProject()

   471

   472

    # Remove a Pou from project

   473

    def ProjectRemovePou(self, pou_name):

   474

        self.Project.removepou(pou_name)

   475

        self.BufferProject()

   476

   477

    # Add a configuration to Project

   478

    def ProjectAddConfiguration(self, config_name):

   479

        self.Project.addconfiguration(config_name)

   480

        self.BufferProject()

   481

   482

    # Remove a configuration from project

   483

    def ProjectRemoveConfiguration(self, config_name):

   484

        self.Project.removeconfiguration(config_name)

   485

        self.BufferProject()

   486

   487

    # Add a resource to a configuration of the Project

   488

    def ProjectAddConfigurationResource(self, config_name, resource_name):

   489

        self.Project.addconfigurationResource(config_name, resource_name)

   490

        self.BufferProject()

   491

   492

    # Remove a resource from a configuration of the project

   493

    def ProjectRemoveConfigurationResource(self, config_name, resource_name):

   494

        self.Project.removeconfigurationResource(config_name, resource_name)

   495

        self.BufferProject()

   496

   497

    # Add a Transition to a Project Pou

   498

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

   499

        pou = self.Project.getpou(pou_name)

   500

        pou.addtransition(transition_name, transition_type)

   501