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

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

    49

    50

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

    51

if cls:

    52

    def updateElementName(self, old_name, new_name):

    53

        index = self.text.find(old_name)

    54

        while index != -1:

    55

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

    56

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

    57

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

    58

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

    59

            else:

    60

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

    61

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

    62

    setattr(cls, "updateElementName", updateElementName)

    63

    64

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

    65

if cls:

    66

    cls.singleLineAttributes = False

    67

    cls.EnumeratedDataTypeValues = {}

    68

    cls.CustomDataTypeRange = {}

    69

    cls.CustomTypeHierarchy = {}

    70

    cls.ElementUsingTree = {}

    71

    cls.CustomBlockTypes = []

    72

    73

    def setname(self, name):

    74

        self.contentHeader.setname(name)

    75

    setattr(cls, "setname", setname)

    76

    77

    def getname(self):

    78

        return self.contentHeader.getname()

    79

    setattr(cls, "getname", getname)

    80

    81

    def getfileHeader(self):

    82

        fileheader = {}

    83

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

    84

        if self.fileHeader.getcompanyURL():

    85

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

    86

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

    87

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

    88

        if self.fileHeader.getproductRelease():

    89

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

    90

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

    91

        if self.fileHeader.getcontentDescription():

    92

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

    93

        return fileheader

    94

    setattr(cls, "getfileHeader", getfileHeader)

    95

    96

    def setfileHeader(self, fileheader):

    97

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

    98

        if fileheader.has_key("companyURL"):

    99

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

   100

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

   101

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

   102

        if fileheader.has_key("productRelease"):

   103

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

   104

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

   105

        if fileheader.has_key("contentDescription"):

   106

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

   107

    setattr(cls, "setfileHeader", setfileHeader)

   108

   109

    def getcontentHeader(self):

   110

        contentheader = {}

   111

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

   112

        if self.contentHeader.getversion():

   113

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

   114

        if self.contentHeader.getmodificationDateTime():

   115

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

   116

        if self.contentHeader.getorganization():

   117

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

   118

        if self.contentHeader.getauthor():

   119

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

   120

        if self.contentHeader.getlanguage():

   121

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

   122

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

   123

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

   124

        return contentheader

   125

    setattr(cls, "getcontentHeader", getcontentHeader)

   126

   127

    def setcontentHeader(self, contentheader):

   128

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

   129

        if contentheader.has_key("projectVersion"):

   130

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

   131

        if contentheader.has_key("modificationDateTime"):

   132

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

   133

        if contentheader.has_key("organization"):

   134

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

   135

        if contentheader.has_key("authorName"):

   136

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

   137

        if contentheader.has_key("language"):

   138

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

   139

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

   140

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

   141

    setattr(cls, "setcontentHeader", setcontentHeader)

   142

   143

    def getdataTypes(self):

   144

        return self.types.getdataTypeElements()

   145

    setattr(cls, "getdataTypes", getdataTypes)

   146

   147

    def getdataType(self, name):

   148

        return self.types.getdataTypeElement(name)

   149

    setattr(cls, "getdataType", getdataType)

   150

   151

    def appenddataType(self, name):

   152

        if self.CustomTypeHierarchy.has_key(name):

   153

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

   154

        self.types.appenddataTypeElement(name)

   155

        self.AddCustomDataType(self.getdataType(name))

   156

    setattr(cls, "appenddataType", appenddataType)

   157

   158

    def insertdataType(self, index, datatype):

   159

        self.types.insertdataTypeElement(index, datatype)

   160

        self.AddCustomDataType(datatype)

   161

    setattr(cls, "insertdataType", insertdataType)

   162

   163

    def removedataType(self, name):

   164

        self.types.removedataTypeElement(name)

   165

        self.RefreshDataTypeHierarchy()

   166

        self.RefreshElementUsingTree()

   167

    setattr(cls, "removedataType", removedataType)

   168

   169

    def getpous(self):

   170

        return self.types.getpouElements()

   171

    setattr(cls, "getpous", getpous)

   172

   173

    def getpou(self, name):

   174

        return self.types.getpouElement(name)

   175

    setattr(cls, "getpou", getpou)

   176

   177

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

   178

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

   179

        self.AddCustomBlockType(self.getpou(name))

   180

    setattr(cls, "appendpou", appendpou)

   181

   182

    def insertpou(self, index, pou):

   183

        self.types.insertpouElement(index, pou)

   184

        self.AddCustomBlockType(pou)

   185

    setattr(cls, "insertpou", insertpou)

   186

   187

    def removepou(self, name):

   188

        self.types.removepouElement(name)

   189

        self.RefreshCustomBlockTypes()

   190

        self.RefreshElementUsingTree()

   191

    setattr(cls, "removepou", removepou)

   192

   193

    def getconfigurations(self):

   194

        configurations = self.instances.configurations.getconfiguration()

   195

        if configurations:

   196

            return configurations

   197

        return []

   198

    setattr(cls, "getconfigurations", getconfigurations)

   199

   200

    def getconfiguration(self, name):

   201

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

   202

            if configuration.getname() == name:

   203

                return configuration

   204

        return None

   205

    setattr(cls, "getconfiguration", getconfiguration)

   206

   207

    def addconfiguration(self, name):

   208

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

   209

            if configuration.getname() == name:

   210

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

   211

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   212

        new_configuration.setname(name)

   213

        self.instances.configurations.appendconfiguration(new_configuration)

   214

    setattr(cls, "addconfiguration", addconfiguration)    

   215

   216

    def removeconfiguration(self, name):

   217

        found = False

   218

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

   219

            if configuration.getname() == name:

   220

                self.instances.configurations.removeconfiguration(idx)

   221

                found = True

   222

                break

   223

        if not found:

   224

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

   225

    setattr(cls, "removeconfiguration", removeconfiguration)

   226

   227

    def getconfigurationResource(self, config_name, name):

   228

        configuration = self.getconfiguration(config_name)

   229

        if configuration:

   230

            for resource in configuration.getresource():

   231

                if resource.getname() == name:

   232

                    return resource

   233

        return None

   234

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   235

   236

    def addconfigurationResource(self, config_name, name):

   237

        configuration = self.getconfiguration(config_name)

   238

        if configuration:

   239

            for resource in configuration.getresource():

   240

                if resource.getname() == name:

   241

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

   242

            new_resource = PLCOpenClasses["configuration_resource"]()

   243

            new_resource.setname(name)

   244

            configuration.appendresource(new_resource)

   245

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   246

   247

    def removeconfigurationResource(self, config_name, name):

   248

        configuration = self.getconfiguration(config_name)

   249

        if configuration:

   250

            found = False

   251

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

   252

                if resource.getname() == name:

   253

                    configuration.removeresource(idx)

   254

                    found = True

   255

                    break

   256

            if not found:

   257

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

   258

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   259

   260

    def updateElementName(self, old_name, new_name):

   261

        for datatype in self.types.getdataTypeElements():

   262

            datatype_content = datatype.baseType.getcontent()

   263

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

   264

                datatype_content["value"].setname(new_name)

   265

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

   266

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

   267

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

   268

                    basetype_content["value"].setname(new_name)

   269

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

   270

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

   271

                    element_type = element.type.getcontent()

   272

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

   273

                        element_type["value"].setname(new_name)

   274

        for pou in self.types.getpouElements():

   275

            pou.updateElementName(old_name, new_name)

   276

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

   277

            configuration.updateElementName(old_name, new_name)

   278

    setattr(cls, "updateElementName", updateElementName)

   279

   280

    def RefreshDataTypeHierarchy(self):

   281

        self.EnumeratedDataTypeValues = {}

   282

        self.CustomDataTypeRange = {}

   283

        self.CustomTypeHierarchy = {}

   284

        for datatype in self.getdataTypes():

   285

            self.AddCustomDataType(datatype)

   286

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   287

   288

    def AddCustomDataType(self, datatype):

   289

        name = datatype.getname()

   290

        basetype_content = datatype.getbaseType().getcontent()

   291

        if basetype_content["value"] is None:

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

            self.CustomDataTypeRange[name] = range

   301

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

   302

            if base_type["value"] is None:

   303

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

   304

            else:

   305

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

   306

        else:

   307

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

   308

                values = []

   309

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

   310

                    values.append(value.getname())

   311

                self.EnumeratedDataTypeValues[name] = values

   312

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   313

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   314

   315

    # Update Block types with user-defined pou added

   316

    def RefreshCustomBlockTypes(self):

   317

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

   318

        self.CustomBlockTypes = []

   319

        for pou in self.getpous():

   320

            self.AddCustomBlockType(pou)

   321

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   322

   323

    def AddCustomBlockType(self, pou): 

   324

        pou_name = pou.getname()

   325

        pou_type = pou.getpouType()

   326

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

   327

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

   328

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

   329

        if pou.getinterface():

   330

            return_type = pou.interface.getreturnType()

   331

            if return_type:

   332

                var_type = return_type.getcontent()

   333

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

   334

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

   335

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

   336

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

   337

                else:

   338

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

   339

            for type, varlist in pou.getvars():

   340

                if type == "InOut":

   341

                    for var in varlist.getvariable():

   342

                        var_type = var.type.getcontent()

   343

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

   344

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

   345

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

   346

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

   347

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

   348

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

   349

                        else:

   350

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

   351

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

   352

                elif type == "Input":

   353

                    for var in varlist.getvariable():

   354

                        var_type = var.type.getcontent()

   355

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

   356

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

   357

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

   358

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

   359

                        else:

   360

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

   361

                elif type == "Output":

   362

                    for var in varlist.getvariable():

   363

                        var_type = var.type.getcontent()

   364

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

   365

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

   366

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

   367

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

   368

                        else:

   369

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

   370

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

   371

            for instance in pou.getinstances():

   372

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

   373

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

   374

        self.CustomBlockTypes.append(block_infos)

   375

    setattr(cls, "AddCustomBlockType", AddCustomBlockType)

   376

   377

    def RefreshElementUsingTree(self):

   378

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

   379

        self.ElementUsingTree = {}

   380

        pous = self.getpous()

   381

        datatypes = self.getdataTypes()

   382

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

   383

        # user-defined elemnt cross-use

   384

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

   385

                       [pou.getname() for pou in pous]

   386

        for name in elementnames:

   387

            self.ElementUsingTree[name] = []

   388

        # Analyze each datatype

   389

        for datatype in datatypes:

   390

            name = datatype.getname()

   391

            basetype_content = datatype.baseType.getcontent()

   392

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

   393

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

   394

                if name in self.ElementUsingTree[typename]:

   395

                    self.ElementUsingTree[typename].append(name)

   396

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

   397

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

   398

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

   399

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

   400

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

   401

                        self.ElementUsingTree[typename].append(name)

   402

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

   403

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

   404

                    type_content = element.type.getcontent()

   405

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

   406

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

   407

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

   408

                            self.ElementUsingTree[typename].append(name)

   409

        # Analyze each pou

   410

        for pou in pous:

   411

            name = pou.getname()

   412

            if pou.interface:

   413

                # Extract variables from every varLists

   414

                for type, varlist in pou.getvars():

   415

                    for var in varlist.getvariable():

   416

                        vartype_content = var.gettype().getcontent()

   417

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

   418

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

   419

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

   420

                                self.ElementUsingTree[typename].append(name)

   421

    setattr(cls, "RefreshElementUsingTree", RefreshElementUsingTree)

   422

   423

    def GetParentType(self, type):

   424

        if self.CustomTypeHierarchy.has_key(type):

   425

            return self.CustomTypeHierarchy[type]

   426

        elif TypeHierarchy.has_key(type):

   427

            return TypeHierarchy[type]

   428

        return None

   429

    setattr(cls, "GetParentType", GetParentType)

   430

   431

    def GetBaseType(self, type):

   432

        parent_type = self.GetParentType(type)

   433

        if parent_type is not None:

   434

            if parent_type.startswith("ANY"):

   435

                return type

   436

            else:

   437

                return self.GetBaseType(parent_type)

   438

        return None

   439

    setattr(cls, "GetBaseType", GetBaseType)

   440

   441

    def GetSubrangeBaseTypes(self, exclude):

   442

        derived = []

   443

        for type in self.CustomTypeHierarchy.keys():

   444

            for base_type in DataTypeRange.keys():

   445

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

   446

                    derived.append(type)

   447

                    break

   448

        return DataTypeRange.keys() + derived

   449

    setattr(cls, "GetSubrangeBaseTypes", GetSubrangeBaseTypes)

   450

   451

    """

   452

    returns true if the given data type is the same that "reference" meta-type or one of its types.

   453

    """

   454

    def IsOfType(self, type, reference):

   455

        if reference is None:

   456

            return True

   457

        elif type == reference:

   458

            return True

   459

        else:

   460

            parent_type = self.GetParentType(type)

   461

            if parent_type is not None:

   462

                return self.IsOfType(parent_type, reference)

   463

        return False

   464

    setattr(cls, "IsOfType", IsOfType)

   465

   466

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

   467

    def ElementIsUsed(self, name):

   468

        if self.ElementUsingTree.has_key(name):

   469

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

   470

        return False

   471

    setattr(cls, "ElementIsUsed", ElementIsUsed)

   472

   473

    def DataTypeIsDerived(self, name):

   474

        return name in self.CustomTypeHierarchy.values()

   475

    setattr(cls, "DataTypeIsDerived", DataTypeIsDerived)

   476

   477

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

   478

    def ElementIsUsedBy(self, name, reference):

   479

        if self.ElementUsingTree.has_key(name):

   480

            list = self.ElementUsingTree[name]

   481

            # Test if pou is directly used by reference

   482

            if reference in list:

   483

                return True

   484

            else:

   485

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

   486

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

   487

                used = False

   488

                for element in list:

   489

                    used |= self.ElementIsUsedBy(element, reference)

   490

                return used

   491

        return False

   492