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

    58

def _init_and_compare(function, v1, v2):

    59

    if v1 is None:

    60

        return v2

    61

    if v2 is not None:

    62

        return function(v1, v2)

    63

    return v1

    64

    65

"""

    66

Helper class for bounding_box calculation 

    67

"""

    68

class rect:

    69

    70

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

    71

        self.x_min = x

    72

        self.x_max = None

    73

        self.y_min = y

    74

        self.y_max = None

    75

        if width is not None and x is not None:

    76

            self.x_max = x + width

    77

        if height is not None and y is not None:

    78

            self.y_max = y + height

    79

    80

    def update(self, x, y):

    81

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

    82

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

    83

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

    84

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

    85

    86

    def union(self, rect):

    87

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

    88

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

    89

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

    90

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

    91

    92

    def bounding_box(self):

    93

        width = height = None

    94

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

    95

            width = self.x_max - self.x_min

    96

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

    97

            height = self.y_max - self.y_min

    98

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

    99

   100

   101

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

   102

   103

ElementNameToClass = {}

   104

   105

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

   106

if cls:

   107

    def updateElementName(self, old_name, new_name):

   108

        index = self.text.find(old_name)

   109

        while index != -1:

   110

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

   111

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

   112

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

   113

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

   114

            else:

   115

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

   116

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

   117

    setattr(cls, "updateElementName", updateElementName)

   118

   130

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

   131

if cls:

   132

    cls.singleLineAttributes = False

   133

    cls.EnumeratedDataTypeValues = {}

   134

    cls.CustomDataTypeRange = {}

   135

    cls.CustomTypeHierarchy = {}

   136

    cls.ElementUsingTree = {}

   137

    cls.CustomBlockTypes = []

   138

   139

    def setname(self, name):

   140

        self.contentHeader.setname(name)

   141

    setattr(cls, "setname", setname)

   142

   143

    def getname(self):

   144

        return self.contentHeader.getname()

   145

    setattr(cls, "getname", getname)

   146

   147

    def getfileHeader(self):

   148

        fileheader = {}

   149

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

   150

        if self.fileHeader.getcompanyURL():

   151

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

   152

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

   153

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

   154

        if self.fileHeader.getproductRelease():

   155

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

   156

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

   157

        if self.fileHeader.getcontentDescription():

   158

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

   159

        return fileheader

   160

    setattr(cls, "getfileHeader", getfileHeader)

   161

   162

    def setfileHeader(self, fileheader):

   163

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

   164

        if fileheader.has_key("companyURL"):

   165

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

   166

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

   167

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

   168

        if fileheader.has_key("productRelease"):

   169

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

   170

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

   171

        if fileheader.has_key("contentDescription"):

   172

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

   173

    setattr(cls, "setfileHeader", setfileHeader)

   174

   175

    def getcontentHeader(self):

   176

        contentheader = {}

   177

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

   178

        if self.contentHeader.getversion():

   179

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

   180

        if self.contentHeader.getmodificationDateTime():

   181

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

   182

        if self.contentHeader.getorganization():

   183

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

   184

        if self.contentHeader.getauthor():

   185

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

   186

        if self.contentHeader.getlanguage():

   187

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

   188

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

   189

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

   190

        return contentheader

   191

    setattr(cls, "getcontentHeader", getcontentHeader)

   192

   193

    def setcontentHeader(self, contentheader):

   194

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

   195

        if contentheader.has_key("projectVersion"):

   196

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

   197

        if contentheader.has_key("modificationDateTime"):

   198

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

   199

        if contentheader.has_key("organization"):

   200

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

   201

        if contentheader.has_key("authorName"):

   202

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

   203

        if contentheader.has_key("language"):

   204

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

   205

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

   206

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

   207

    setattr(cls, "setcontentHeader", setcontentHeader)

   208

   209

    def getdataTypes(self):

   210

        return self.types.getdataTypeElements()

   211

    setattr(cls, "getdataTypes", getdataTypes)

   212

   213

    def getdataType(self, name):

   214

        return self.types.getdataTypeElement(name)

   215

    setattr(cls, "getdataType", getdataType)

   216

   217

    def appenddataType(self, name):

   218

        if self.CustomTypeHierarchy.has_key(name):

   219

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

   220

        self.types.appenddataTypeElement(name)

   221

        self.AddCustomDataType(self.getdataType(name))

   222

    setattr(cls, "appenddataType", appenddataType)

   223

   224

    def insertdataType(self, index, datatype):

   225

        self.types.insertdataTypeElement(index, datatype)

   226

        self.AddCustomDataType(datatype)

   227

    setattr(cls, "insertdataType", insertdataType)

   228

   229

    def removedataType(self, name):

   230

        self.types.removedataTypeElement(name)

   231

        self.RefreshDataTypeHierarchy()

   232

        self.RefreshElementUsingTree()

   233

    setattr(cls, "removedataType", removedataType)

   234

   235

    def getpous(self):

   236

        return self.types.getpouElements()

   237

    setattr(cls, "getpous", getpous)

   238

   239

    def getpou(self, name):

   240

        return self.types.getpouElement(name)

   241

    setattr(cls, "getpou", getpou)

   242

   243

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

   244

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

   245

        self.AddCustomBlockType(self.getpou(name))

   246

    setattr(cls, "appendpou", appendpou)

   247

   248

    def insertpou(self, index, pou):

   249

        self.types.insertpouElement(index, pou)

   250

        self.AddCustomBlockType(pou)

   251

    setattr(cls, "insertpou", insertpou)

   252

   253

    def removepou(self, name):

   254

        self.types.removepouElement(name)

   255

        self.RefreshCustomBlockTypes()

   256

        self.RefreshElementUsingTree()

   257

    setattr(cls, "removepou", removepou)

   258

   259

    def getconfigurations(self):

   260

        configurations = self.instances.configurations.getconfiguration()

   261

        if configurations:

   262

            return configurations

   263

        return []

   264

    setattr(cls, "getconfigurations", getconfigurations)

   265

   266

    def getconfiguration(self, name):

   267

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

   268

            if configuration.getname() == name:

   269

                return configuration

   270

        return None

   271

    setattr(cls, "getconfiguration", getconfiguration)

   272

   273

    def addconfiguration(self, name):

   274

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

   275

            if configuration.getname() == name:

   276

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

   277

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   278

        new_configuration.setname(name)

   279

        self.instances.configurations.appendconfiguration(new_configuration)

   280

    setattr(cls, "addconfiguration", addconfiguration)    

   281

   282

    def removeconfiguration(self, name):

   283

        found = False

   284

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

   285

            if configuration.getname() == name:

   286

                self.instances.configurations.removeconfiguration(idx)

   287

                found = True

   288

                break

   289

        if not found:

   290

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

   291

    setattr(cls, "removeconfiguration", removeconfiguration)

   292

   293

    def getconfigurationResource(self, config_name, name):

   294

        configuration = self.getconfiguration(config_name)

   295

        if configuration:

   296

            for resource in configuration.getresource():

   297

                if resource.getname() == name:

   298

                    return resource

   299

        return None

   300

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   301

   302

    def addconfigurationResource(self, config_name, name):

   303

        configuration = self.getconfiguration(config_name)

   304

        if configuration:

   305

            for resource in configuration.getresource():

   306

                if resource.getname() == name:

   307

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

   308

            new_resource = PLCOpenClasses["configuration_resource"]()

   309

            new_resource.setname(name)

   310

            configuration.appendresource(new_resource)

   311

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   312

   313

    def removeconfigurationResource(self, config_name, name):

   314

        configuration = self.getconfiguration(config_name)

   315

        if configuration:

   316

            found = False

   317

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

   318

                if resource.getname() == name:

   319

                    configuration.removeresource(idx)

   320

                    found = True

   321

                    break

   322

            if not found:

   323

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

   324

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   325

   326

    def updateElementName(self, old_name, new_name):

   327

        for datatype in self.types.getdataTypeElements():

   328

            datatype_content = datatype.baseType.getcontent()

   329

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

   330

                datatype_content["value"].setname(new_name)

   331

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

   332

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

   333

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

   334

                    basetype_content["value"].setname(new_name)

   335

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

   336

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

   337

                    element_type = element.type.getcontent()

   338

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

   339

                        element_type["value"].setname(new_name)

   340

        for pou in self.types.getpouElements():

   341

            pou.updateElementName(old_name, new_name)

   342

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

   343

            configuration.updateElementName(old_name, new_name)

   344

    setattr(cls, "updateElementName", updateElementName)

   345

   369

    def RefreshDataTypeHierarchy(self):

   370

        self.EnumeratedDataTypeValues = {}

   371

        self.CustomDataTypeRange = {}

   372

        self.CustomTypeHierarchy = {}

   373

        for datatype in self.getdataTypes():

   374

            self.AddCustomDataType(datatype)

   375

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   376

   377

    def AddCustomDataType(self, datatype):

   378

        name = datatype.getname()

   379

        basetype_content = datatype.getbaseType().getcontent()

   380

        if basetype_content["value"] is None:

   381

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

   382

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

   383

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

   384

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

   385

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

   386

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

   387

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

   388

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

   389

            self.CustomDataTypeRange[name] = range

   390

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

   391

            if base_type["value"] is None:

   392

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

   393

            else:

   394

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

   395

        else:

   396

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

   397

                values = []

   398

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

   399

                    values.append(value.getname())

   400

                self.EnumeratedDataTypeValues[name] = values

   401

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   402

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   403

   404

    # Update Block types with user-defined pou added

   405

    def RefreshCustomBlockTypes(self):

   406

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

   407

        self.CustomBlockTypes = []

   408

        for pou in self.getpous():

   409

            self.AddCustomBlockType(pou)

   410

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   411

   412

    def AddCustomBlockType(self, pou): 

   413

        pou_name = pou.getname()

   414

        pou_type = pou.getpouType()

   415

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

   416

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

   417

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

   418

        if pou.getinterface():

   419

            return_type = pou.interface.getreturnType()

   420

            if return_type:

   421

                var_type = return_type.getcontent()

   422

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

   423

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

   424

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

   425

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

   426

                else:

   427

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

   428

            for type, varlist in pou.getvars():

   429

                if type == "InOut":

   430

                    for var in varlist.getvariable():

   431

                        var_type = var.type.getcontent()

   432

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

   433

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

   434

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

   435

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

   436

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

   437

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

   438

                        else:

   439

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

   440

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

   441

                elif type == "Input":

   442

                    for var in varlist.getvariable():

   443

                        var_type = var.type.getcontent()

   444

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

   445

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

   446

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

   447

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

   448

                        else:

   449

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

   450

                elif type == "Output":

   451

                    for var in varlist.getvariable():

   452

                        var_type = var.type.getcontent()

   453

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

   454

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

   455

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

   456

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

   457

                        else:

   458

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

   459

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

   460

            for instance in pou.getinstances():

   461

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

   462

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

   463

        self.CustomBlockTypes.append(block_infos)

   464

    setattr(cls, "AddCustomBlockType", AddCustomBlockType)

   465

   466

    def RefreshElementUsingTree(self):

   467

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

   468

        self.ElementUsingTree = {}

   469

        pous = self.getpous()

   470

        datatypes = self.getdataTypes()

   471

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

   472

        # user-defined elemnt cross-use

   473

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

   474

                       [pou.getname() for pou in pous]

   475

        for name in elementnames:

   476

            self.ElementUsingTree[name] = []

   477

        # Analyze each datatype

   478

        for datatype in datatypes:

   479

            name = datatype.getname()

   480

            basetype_content = datatype.baseType.getcontent()

   481

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

   482

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

   483

                if name in self.ElementUsingTree[typename]:

   484

                    self.ElementUsingTree[typename].append(name)

   485

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

   486

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

   487

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

   488

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

   489

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

   490

                        self.ElementUsingTree[typename].append(name)

   491

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

   492

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