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 xmlclass import *

    26

from structures import *

    27

from types import *

    28

import os, re

    29

    30

"""

    31

Dictionary that makes the relation between var names in plcopen and displayed values

    32

"""

    33

VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",

    34

            "Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars",

    35

            "Global" : "globalVars", "Access" : "accessVars"}

    36

    37

"""

    38

Define in which order var types must be displayed

    39

"""

    40

VarOrder = ["Local","Temp","Input","Output","InOut","External","Global","Access"]

    41

    42

"""

    43

Define which action qualifier must be associated with a duration 

    44

"""

    45

QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, 

    46

    "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True}

    47

    48

    49

def _init_and_compare(function, v1, v2):

    50

    if v1 is None:

    51

        return v2

    52

    if v2 is not None:

    53

        return function(v1, v2)

    54

    return v1

    55

    56

"""

    57

Helper class for bounding_box calculation 

    58

"""

    59

class rect:

    60

    61

    def __init__(self, x=None, y=None, width=None, height=None):

    62

        self.x_min = x

    63

        self.x_max = None

    64

        self.y_min = y

    65

        self.y_max = None

    66

        if width is not None and x is not None:

    67

            self.x_max = x + width

    68

        if height is not None and y is not None:

    69

            self.y_max = y + height

    70

    71

    def update(self, x, y):

    72

        self.x_min = _init_and_compare(min, self.x_min, x)

    73

        self.x_max = _init_and_compare(max, self.x_max, x)

    74

        self.y_min = _init_and_compare(min, self.y_min, y)

    75

        self.y_max = _init_and_compare(max, self.y_max, y)

    76

    77

    def union(self, rect):

    78

        self.x_min = _init_and_compare(min, self.x_min, rect.x_min)

    79

        self.x_max = _init_and_compare(max, self.x_max, rect.x_max)

    80

        self.y_min = _init_and_compare(min, self.y_min, rect.y_min)

    81

        self.y_max = _init_and_compare(max, self.y_max, rect.y_max)

    82

    83

    def bounding_box(self):

    84

        width = height = None

    85

        if self.x_min is not None and self.x_max is not None:

    86

            width = self.x_max - self.x_min

    87

        if self.y_min is not None and self.y_max is not None:

    88

            height = self.y_max - self.y_min

    89

        return self.x_min, self.y_min, width, height

    90

    91

    92

PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))

    93

    94

ElementNameToClass = {}

    95

    96

cls = PLCOpenClasses.get("formattedText", None)

    97

if cls:

    98

    def updateElementName(self, old_name, new_name):

    99

        index = self.text.find(old_name)

   100

        while index != -1:

   101

            if index > 0 and (self.text[index - 1].isalnum() or self.text[index - 1] == "_"):

   102

                index = self.text.find(old_name, index + len(old_name))

   103

            elif index < len(self.text) - len(old_name) and (self.text[index + len(old_name)].isalnum() or self.text[index + len(old_name)] == "_"):

   104

                index = self.text.find(old_name, index + len(old_name))

   105

            else:

   106

                self.text = self.text[:index] + new_name + self.text[index + len(old_name):]

   107

                index = self.text.find(old_name, index + len(new_name))

   108

    setattr(cls, "updateElementName", updateElementName)

   109

   110

cls = PLCOpenClasses.get("project", None)

   111

if cls:

   112

    cls.singleLineAttributes = False

   113

    cls.EnumeratedDataTypeValues = {}

   114

    cls.CustomDataTypeRange = {}

   115

    cls.CustomTypeHierarchy = {}

   116

    cls.ElementUsingTree = {}

   117

    cls.CustomBlockTypes = []

   118

   119

    def setname(self, name):

   120

        self.contentHeader.setname(name)

   121

    setattr(cls, "setname", setname)

   122

   123

    def getname(self):

   124

        return self.contentHeader.getname()

   125

    setattr(cls, "getname", getname)

   126

   127

    def getfileHeader(self):

   128

        fileheader = {}

   129

        fileheader["companyName"] = self.fileHeader.getcompanyName()

   130

        if self.fileHeader.getcompanyURL():

   131

            fileheader["companyURL"] = self.fileHeader.getcompanyURL()

   132

        fileheader["productName"] = self.fileHeader.getproductName()

   133

        fileheader["productVersion"] = self.fileHeader.getproductVersion()

   134

        if self.fileHeader.getproductRelease():

   135

            fileheader["productRelease"] = self.fileHeader.getproductRelease()

   136

        fileheader["creationDateTime"] = self.fileHeader.getcreationDateTime()

   137

        if self.fileHeader.getcontentDescription():

   138

            fileheader["contentDescription"] = self.fileHeader.getcontentDescription()

   139

        return fileheader

   140

    setattr(cls, "getfileHeader", getfileHeader)

   141

   142

    def setfileHeader(self, fileheader):

   143

        self.fileHeader.setcompanyName(fileheader["companyName"])

   144

        if fileheader.has_key("companyURL"):

   145

            self.fileHeader.setcompanyURL(fileheader["companyURL"])

   146

        self.fileHeader.setproductName(fileheader["productName"])

   147

        self.fileHeader.setproductVersion(fileheader["productVersion"])

   148

        if fileheader.has_key("productRelease"):

   149

            self.fileHeader.setproductRelease(fileheader["productRelease"])

   150

        self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])

   151

        if fileheader.has_key("contentDescription"):

   152

            self.fileHeader.setcontentDescription(fileheader["contentDescription"])

   153

    setattr(cls, "setfileHeader", setfileHeader)

   154

   155

    def getcontentHeader(self):

   156

        contentheader = {}

   157

        contentheader["projectName"] = self.contentHeader.getname()

   158

        if self.contentHeader.getversion():

   159

            contentheader["projectVersion"] = self.contentHeader.getversion()

   160

        if self.contentHeader.getmodificationDateTime():

   161

            contentheader["modificationDateTime"] = self.contentHeader.getmodificationDateTime()

   162

        if self.contentHeader.getorganization():

   163

            contentheader["organization"] = self.contentHeader.getorganization()

   164

        if self.contentHeader.getauthor():

   165

            contentheader["authorName"] = self.contentHeader.getauthor()

   166

        if self.contentHeader.getlanguage():

   167

            contentheader["language"] = self.contentHeader.getlanguage()

   168

        contentheader["pageSize"] = self.contentHeader.getpageSize()

   169

        contentheader["scaling"] = self.contentHeader.getscaling()

   170

        return contentheader

   171

    setattr(cls, "getcontentHeader", getcontentHeader)

   172

   173

    def setcontentHeader(self, contentheader):

   174

        self.contentHeader.setname(contentheader["projectName"])

   175

        if contentheader.has_key("projectVersion"):

   176

            self.contentHeader.setversion(contentheader["projectVersion"])

   177

        if contentheader.has_key("modificationDateTime"):

   178

            self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])

   179

        if contentheader.has_key("organization"):

   180

            self.contentHeader.setorganization(contentheader["organization"])

   181

        if contentheader.has_key("authorName"):

   182

            self.contentHeader.setauthor(contentheader["authorName"])

   183

        if contentheader.has_key("language"):

   184

            self.contentHeader.setlanguage(contentheader["language"])

   185

        self.contentHeader.setpageSize(*contentheader["pageSize"])

   186

        self.contentHeader.setscaling(contentheader["scaling"])

   187

    setattr(cls, "setcontentHeader", setcontentHeader)

   188

   189

    def getdataTypes(self):

   190

        return self.types.getdataTypeElements()

   191

    setattr(cls, "getdataTypes", getdataTypes)

   192

   193

    def getdataType(self, name):

   194

        return self.types.getdataTypeElement(name)

   195

    setattr(cls, "getdataType", getdataType)

   196

   197

    def appenddataType(self, name):

   198

        if self.CustomTypeHierarchy.has_key(name):

   199

            raise ValueError, "\"%s\" Data Type already exists !!!"%name

   200

        self.types.appenddataTypeElement(name)

   201

        self.AddCustomDataType(self.getdataType(name))

   202

    setattr(cls, "appenddataType", appenddataType)

   203

   204

    def insertdataType(self, index, datatype):

   205

        self.types.insertdataTypeElement(index, datatype)

   206

        self.AddCustomDataType(datatype)

   207

    setattr(cls, "insertdataType", insertdataType)

   208

   209

    def removedataType(self, name):

   210

        self.types.removedataTypeElement(name)

   211

        self.RefreshDataTypeHierarchy()

   212

        self.RefreshElementUsingTree()

   213

    setattr(cls, "removedataType", removedataType)

   214

   215

    def getpous(self):

   216

        return self.types.getpouElements()

   217

    setattr(cls, "getpous", getpous)

   218

   219

    def getpou(self, name):

   220

        return self.types.getpouElement(name)

   221

    setattr(cls, "getpou", getpou)

   222

   223

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

   224

        self.types.appendpouElement(name, pou_type, body_type)

   225

        self.AddCustomBlockType(self.getpou(name))

   226

    setattr(cls, "appendpou", appendpou)

   227

   228

    def insertpou(self, index, pou):

   229

        self.types.insertpouElement(index, pou)

   230

        self.AddCustomBlockType(pou)

   231

    setattr(cls, "insertpou", insertpou)

   232

   233

    def removepou(self, name):

   234

        self.types.removepouElement(name)

   235

        self.RefreshCustomBlockTypes()

   236

        self.RefreshElementUsingTree()

   237

    setattr(cls, "removepou", removepou)

   238

   239

    def getconfigurations(self):

   240

        configurations = self.instances.configurations.getconfiguration()

   241

        if configurations:

   242

            return configurations

   243

        return []

   244

    setattr(cls, "getconfigurations", getconfigurations)

   245

   246

    def getconfiguration(self, name):

   247

        for configuration in self.instances.configurations.getconfiguration():

   248

            if configuration.getname() == name:

   249

                return configuration

   250

        return None

   251

    setattr(cls, "getconfiguration", getconfiguration)

   252

   253

    def addconfiguration(self, name):

   254

        for configuration in self.instances.configurations.getconfiguration():

   255

            if configuration.getname() == name:

   256

                raise ValueError, _("\"%s\" configuration already exists !!!")%name

   257

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   258

        new_configuration.setname(name)

   259

        self.instances.configurations.appendconfiguration(new_configuration)

   260

    setattr(cls, "addconfiguration", addconfiguration)    

   261

   262

    def removeconfiguration(self, name):

   263

        found = False

   264

        for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):

   265

            if configuration.getname() == name:

   266

                self.instances.configurations.removeconfiguration(idx)

   267

                found = True

   268

                break

   269

        if not found:

   270

            raise ValueError, ("\"%s\" configuration doesn't exist !!!")%name

   271

    setattr(cls, "removeconfiguration", removeconfiguration)

   272

   273

    def getconfigurationResource(self, config_name, name):

   274

        configuration = self.getconfiguration(config_name)

   275

        if configuration:

   276

            for resource in configuration.getresource():

   277

                if resource.getname() == name:

   278

                    return resource

   279

        return None

   280

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   281

   282

    def addconfigurationResource(self, config_name, name):

   283

        configuration = self.getconfiguration(config_name)

   284

        if configuration:

   285

            for resource in configuration.getresource():

   286

                if resource.getname() == name:

   287

                    raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name)

   288

            new_resource = PLCOpenClasses["configuration_resource"]()

   289

            new_resource.setname(name)

   290

            configuration.appendresource(new_resource)

   291

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   292

   293

    def removeconfigurationResource(self, config_name, name):

   294

        configuration = self.getconfiguration(config_name)

   295

        if configuration:

   296

            found = False

   297

            for idx, resource in enumerate(configuration.getresource()):

   298

                if resource.getname() == name:

   299

                    configuration.removeresource(idx)

   300

                    found = True

   301

                    break

   302

            if not found:

   303

                raise ValueError, _("\"%s\" resource doesn't exist in \"%s\" configuration !!!")%(name, config_name)

   304

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   305

   306

    def updateElementName(self, old_name, new_name):

   307

        for datatype in self.types.getdataTypeElements():

   308

            datatype_content = datatype.baseType.getcontent()

   309

            if datatype_content["name"] == "derived" and datatype_content["value"].getname() == old_name:

   310

                datatype_content["value"].setname(new_name)

   311

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

   312

                basetype_content = datatype_content["value"].baseType.getcontent()

   313

                if basetype_content["name"] == "derived" and basetype_content["value"].getname() == old_name:

   314

                    basetype_content["value"].setname(new_name)

   315

            elif datatype_content["name"] == "struct":

   316

                for element in datatype_content["value"].getvariable():

   317

                    element_type = element.type.getcontent()

   318

                    if element_type["name"] == "derived" and element_type["value"].getname() == old_name:

   319

                        element_type["value"].setname(new_name)

   320

        for pou in self.types.getpouElements():

   321

            pou.updateElementName(old_name, new_name)

   322

        for configuration in self.instances.configurations.getconfiguration():

   323

            configuration.updateElementName(old_name, new_name)

   324

    setattr(cls, "updateElementName", updateElementName)

   325

   326

    def RefreshDataTypeHierarchy(self):

   327

        self.EnumeratedDataTypeValues = {}

   328

        self.CustomDataTypeRange = {}

   329

        self.CustomTypeHierarchy = {}

   330

        for datatype in self.getdataTypes():

   331

            self.AddCustomDataType(datatype)

   332

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   333

   334

    def AddCustomDataType(self, datatype):

   335

        name = datatype.getname()

   336

        basetype_content = datatype.getbaseType().getcontent()

   337

        if basetype_content["value"] is None:

   338

            self.CustomTypeHierarchy[name] = basetype_content["name"]

   339

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

   340

            self.CustomTypeHierarchy[name] = basetype_content["name"].upper()

   341

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

   342

            self.CustomTypeHierarchy[name] = basetype_content["value"].getname()

   343

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

   344

            range = (basetype_content["value"].range.getlower(), 

   345

                     basetype_content["value"].range.getupper())

   346

            self.CustomDataTypeRange[name] = range

   347

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

   348

            if base_type["value"] is None:

   349

                self.CustomTypeHierarchy[name] = base_type["name"]

   350

            else:

   351

                self.CustomTypeHierarchy[name] = base_type["value"].getname()

   352

        else:

   353

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

   354

                values = []

   355

                for value in basetype_content["value"].values.getvalue():

   356

                    values.append(value.getname())

   357

                self.EnumeratedDataTypeValues[name] = values

   358

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   359

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   360

   361

    # Update Block types with user-defined pou added

   362

    def RefreshCustomBlockTypes(self):

   363

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

   364

        self.CustomBlockTypes = []

   365

        for pou in self.getpous():

   366

            self.AddCustomBlockType(pou)

   367

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   368

   369

    def AddCustomBlockType(self, pou): 

   370

        pou_name = pou.getname()

   371

        pou_type = pou.getpouType()

   372

        block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False,

   373

                       "inputs" : [], "outputs" : [], "comment" : "",

   374

                       "generate" : generate_block, "initialise" : initialise_block}

   375

        if pou.getinterface():

   376

            return_type = pou.interface.getreturnType()

   377

            if return_type:

   378

                var_type = return_type.getcontent()

   379

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

   380

                    block_infos["outputs"].append(("", var_type["value"].getname(), "none"))

   381

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

   382

                    block_infos["outputs"].append(("", var_type["name"].upper(), "none"))

   383

                else:

   384

                    block_infos["outputs"].append(("", var_type["name"], "none"))

   385

            for type, varlist in pou.getvars():

   386

                if type == "InOut":

   387

                    for var in varlist.getvariable():

   388

                        var_type = var.type.getcontent()

   389

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

   390

                            block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))

   391

                            block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))

   392

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

   393

                            block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))

   394

                            block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))

   395

                        else:

   396

                            block_infos["inputs"].append((var.getname(), var_type["name"], "none"))

   397

                            block_infos["outputs"].append((var.getname(), var_type["name"], "none"))

   398

                elif type == "Input":

   399

                    for var in varlist.getvariable():

   400

                        var_type = var.type.getcontent()

   401

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

   402

                            block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))

   403

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

   404

                            block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))

   405

                        else:

   406

                            block_infos["inputs"].append((var.getname(), var_type["name"], "none"))

   407

                elif type == "Output":

   408

                    for var in varlist.getvariable():

   409

                        var_type = var.type.getcontent()

   410

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

   411

                            block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))

   412

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

   413

                            block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))

   414

                        else:

   415

                            block_infos["outputs"].append((var.getname(), var_type["name"], "none"))    

   416

        if pou.getbodyType() in ["FBD","LD","SFC"]:

   417

            for instance in pou.getinstances():

   418

                if isinstance(instance, PLCOpenClasses.get("commonObjects_comment", None)):

   419

                    block_infos["comment"] = instance.getcontentText()

   420

        self.CustomBlockTypes.append(block_infos)

   421

    setattr(cls, "AddCustomBlockType", AddCustomBlockType)

   422

   423

    def RefreshElementUsingTree(self):

   424

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

   425

        self.ElementUsingTree = {}

   426

        pous = self.getpous()

   427

        datatypes = self.getdataTypes()

   428

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

   429

        # user-defined elemnt cross-use

   430

        elementnames = [datatype.getname() for datatype in datatypes] + \

   431

                       [pou.getname() for pou in pous]

   432

        for name in elementnames:

   433

            self.ElementUsingTree[name] = []

   434

        # Analyze each datatype

   435

        for datatype in datatypes:

   436

            name = datatype.getname()

   437

            basetype_content = datatype.baseType.getcontent()

   438

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

   439

                typename = basetype_content["value"].getname()

   440

                if name in self.ElementUsingTree[typename]:

   441

                    self.ElementUsingTree[typename].append(name)

   442

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

   443

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

   444

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

   445

                    typename = base_type["value"].getname()

   446

                    if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:

   447

                        self.ElementUsingTree[typename].append(name)

   448

            elif basetype_content["name"] == "struct":

   449

                for element in basetype_content["value"].getvariable():

   450

                    type_content = element.type.getcontent()

   451

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

   452

                        typename = type_content["value"].getname()

   453

                        if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:

   454

                            self.ElementUsingTree[typename].append(name)

   455

        # Analyze each pou

   456

        for pou in pous:

   457

            name = pou.getname()

   458

            if pou.interface:

   459

                # Extract variables from every varLists

   460

                for type, varlist in pou.getvars():

   461

                    for var in varlist.getvariable():

   462

                        vartype_content = var.gettype().getcontent()

   463

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

   464

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

   465

                            if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:

   466

                                self.ElementUsingTree[typename].append(name)

   467

    setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree)

   468

   469

    def GetParentType(self, type):

   470

        if self.CustomTypeHierarchy.has_key(type):

   471

            return self.CustomTypeHierarchy[type]

   472

        elif TypeHierarchy.has_key(type):

   473

            return TypeHierarchy[type]

   474

        return None

   475

    setattr(cls, "GetParentType", GetParentType)

   476

   477

    def GetBaseType(self, type):

   478

        parent_type = self.GetParentType(type)

   479

        if parent_type is not None:

   480

            if parent_type.startswith("ANY"):

   481

                return type

   482

            else:

   483

                return self.GetBaseType(parent_type)

   484

        return None

   485

    setattr(cls, "GetBaseType", GetBaseType)

   486

   487

    def GetSubrangeBaseTypes(self, exclude):

   488

        derived = []

   489

        for type in self.CustomTypeHierarchy.keys():

   490

            for base_type in DataTypeRange.keys():

   491

                if self.IsOfType(type, base_type) and not self.IsOfType(type, exclude):

   492