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

from lxml import etree

    30

from collections import OrderedDict

    31

"""

    32

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

    33

"""

    34

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

    35

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

    36

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

    37

    38

searchResultVarTypes = {

    39

    "inputVars": "var_input",

    40

    "outputVars": "var_output",

    41

    "inOutVars": "var_inout"

    42

}

    43

    44

"""

    45

Define in which order var types must be displayed

    46

"""

    47

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

    48

    49

"""

    50

Define which action qualifier must be associated with a duration 

    51

"""

    52

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

    53

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

    54

    55

    56

FILTER_ADDRESS_MODEL = "(%%[IQM](?:[XBWDL])?)(%s)((?:\.[0-9]+)*)" 

    57

    58

def update_address(address, address_model, new_leading):

    59

    result = address_model.match(address)

    60

    if result is None:

    61

        return address

    62

    groups = result.groups()

    63

    return groups[0] + new_leading + groups[2]

    64

    65

def _init_and_compare(function, v1, v2):

    66

    if v1 is None:

    67

        return v2

    68

    if v2 is not None:

    69

        return function(v1, v2)

    70

    return v1

    71

    72

"""

    73

Helper class for bounding_box calculation 

    74

"""

    75

class rect:

    76

    77

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

    78

        self.x_min = x

    79

        self.x_max = None

    80

        self.y_min = y

    81

        self.y_max = None

    82

        if width is not None and x is not None:

    83

            self.x_max = x + width

    84

        if height is not None and y is not None:

    85

            self.y_max = y + height

    86

    87

    def update(self, x, y):

    88

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

    89

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

    90

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

    91

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

    92

    93

    def union(self, rect):

    94

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

    95

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

    96

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

    97

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

    98

    99

    def bounding_box(self):

   100

        width = height = None

   101

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

   102

            width = self.x_max - self.x_min

   103

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

   104

            height = self.y_max - self.y_min

   105

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

   106

   107

def TextLenInRowColumn(text):

   108

    if text == "":

   109

        return (0, 0)

   110

    lines = text.split("\n")

   111

    return len(lines) - 1, len(lines[-1])

   112

   113

def TestTextElement(text, criteria):

   114

    lines = text.splitlines()

   115

    if not criteria["case_sensitive"]:

   116

        text = text.upper()

   117

    test_result = []

   118

    result = criteria["pattern"].search(text)

   119

    while result is not None:

   120

        start = TextLenInRowColumn(text[:result.start()])

   121

        end = TextLenInRowColumn(text[:result.end() - 1])

   122

        test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1])))

   123

        result = criteria["pattern"].search(text, result.end())

   124

    return test_result

   125

   126

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

   127

   128

def LoadProject(filepath):

   129

    project_file = open(filepath)

   130

    project_xml = project_file.read().replace(

   131

        "http://www.plcopen.org/xml/tc6.xsd", 

   132

        "http://www.plcopen.org/xml/tc6_0201")

   133

    for cre, repl in [

   134

        (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),

   135

        (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:

   136

        project_xml = cre.sub(repl, project_xml)

   137

    project_file.close()

   138

   139

    return etree.fromstring(project_xml, PLCOpenParser)

   140

   141

def SaveProject(project, filepath):

   142

    project_file = open(filepath, 'w')

   143

    project_file.write(etree.tostring(

   144

        project, 

   145

        pretty_print=True, 

   146

        xml_declaration=True, 

   147

        encoding='utf-8'))

   148

    project_file.close()

   149

   150

cls = PLCOpenParser.GetElementClass("formattedText")

   151

if cls:

   152

    def updateElementName(self, old_name, new_name):

   153

        text = self.getanyText()

   154

        index = text.find(old_name)

   155

        while index != -1:

   156

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

   157

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

   158

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

   159

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

   160

            else:

   161

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

   162

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

   163

        self.setanyText(text)

   164

    setattr(cls, "updateElementName", updateElementName)

   165

   166

    def updateElementAddress(self, address_model, new_leading):

   167

        text = self.getanyText()

   168

        startpos = 0

   169

        result = address_model.search(text, startpos)

   170

        while result is not None:

   171

            groups = result.groups()

   172

            new_address = groups[0] + new_leading + groups[2]

   173

            text = text[:result.start()] + new_address + text[result.end():]

   174

            startpos = result.start() + len(new_address)

   175

            result = address_model.search(self.text, startpos)

   176

        self.setanyText(text)

   177

    setattr(cls, "updateElementAddress", updateElementAddress)

   178

   179

    def hasblock(self, block_type):

   180

        text = self.getanyText().upper()

   181

        index = text.find(block_type.upper())

   182

        while index != -1:

   183

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

   184

                not (index < len(text) - len(block_type) and text[index + len(block_type)] != "(")):

   185

                return True

   186

            index = text.find(block_type.upper(), index + len(block_type))

   187

        return False

   188

    setattr(cls, "hasblock", hasblock)

   189

   190

    def Search(self, criteria, parent_infos):

   191

        return [(tuple(parent_infos),) + result for result in TestTextElement(self.getanyText(), criteria)]

   192

    setattr(cls, "Search", Search)

   193

   194

cls = PLCOpenParser.GetElementClass("project")

   195

if cls:

   196

    cls.EnumeratedDataTypeValues = {}

   197

    cls.CustomDataTypeRange = {}

   198

    cls.CustomTypeHierarchy = {}

   199

    cls.ElementUsingTree = {}

   200

    cls.CustomBlockTypes = OrderedDict()

   201

   202

    def setname(self, name):

   203

        self.contentHeader.setname(name)

   204

    setattr(cls, "setname", setname)

   205

   206

    def getname(self):

   207

        return self.contentHeader.getname()

   208

    setattr(cls, "getname", getname)

   209

   210

    def getfileHeader(self):

   211

        fileheader = {}

   212

        for name, value in [("companyName", self.fileHeader.getcompanyName()),

   213

                            ("companyURL", self.fileHeader.getcompanyURL()),

   214

                            ("productName", self.fileHeader.getproductName()),

   215

                            ("productVersion", self.fileHeader.getproductVersion()),

   216

                            ("productRelease", self.fileHeader.getproductRelease()),

   217

                            ("creationDateTime", self.fileHeader.getcreationDateTime()),

   218

                            ("contentDescription", self.fileHeader.getcontentDescription())]:

   219

            if value is not None:

   220

                fileheader[name] = value

   221

            else:

   222

                fileheader[name] = ""

   223

        return fileheader

   224

    setattr(cls, "getfileHeader", getfileHeader)

   225

   226

    def setfileHeader(self, fileheader):

   227

        if fileheader.has_key("companyName"):

   228

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

   229

        if fileheader.has_key("companyURL"):

   230

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

   231

        if fileheader.has_key("productName"):

   232

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

   233

        if fileheader.has_key("productVersion"):

   234

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

   235

        if fileheader.has_key("productRelease"):

   236

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

   237

        if fileheader.has_key("creationDateTime"):

   238

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

   239

        if fileheader.has_key("contentDescription"):

   240

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

   241

    setattr(cls, "setfileHeader", setfileHeader)

   242

   243

    def getcontentHeader(self):

   244

        contentheader = {}

   245

        for name, value in [("projectName", self.contentHeader.getname()),

   246

                            ("projectVersion", self.contentHeader.getversion()),

   247

                            ("modificationDateTime", self.contentHeader.getmodificationDateTime()),

   248

                            ("organization", self.contentHeader.getorganization()),

   249

                            ("authorName", self.contentHeader.getauthor()),

   250

                            ("language", self.contentHeader.getlanguage())]:

   251

            if value is not None:

   252

                contentheader[name] = value

   253

            else:

   254

                contentheader[name] = ""

   255

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

   256

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

   257

        return contentheader

   258

    setattr(cls, "getcontentHeader", getcontentHeader)

   259

   260

    def setcontentHeader(self, contentheader):

   261

        if contentheader.has_key("projectName"):

   262

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

   263

        if contentheader.has_key("projectVersion"):

   264

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

   265

        if contentheader.has_key("modificationDateTime"):

   266

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

   267

        if contentheader.has_key("organization"):

   268

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

   269

        if contentheader.has_key("authorName"):

   270

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

   271

        if contentheader.has_key("language"):

   272

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

   273

        if contentheader.has_key("pageSize"):

   274

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

   275

        if contentheader.has_key("scaling"):

   276

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

   277

    setattr(cls, "setcontentHeader", setcontentHeader)

   278

   279

    def getdataTypes(self):

   280

        return self.types.getdataTypeElements()

   281

    setattr(cls, "getdataTypes", getdataTypes)

   282

   283

    def getdataType(self, name):

   284

        return self.types.getdataTypeElement(name)

   285

    setattr(cls, "getdataType", getdataType)

   286

   287

    def appenddataType(self, name):

   288

        if self.CustomTypeHierarchy.has_key(name):

   289

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

   290

        self.types.appenddataTypeElement(name)

   291

        self.AddCustomDataType(self.getdataType(name))

   292

    setattr(cls, "appenddataType", appenddataType)

   293

   294

    def insertdataType(self, index, datatype):

   295

        self.types.insertdataTypeElement(index, datatype)

   296

        self.AddCustomDataType(datatype)

   297

    setattr(cls, "insertdataType", insertdataType)

   298

   299

    def removedataType(self, name):

   300

        self.types.removedataTypeElement(name)

   301

        self.RefreshDataTypeHierarchy()

   302

        self.RefreshElementUsingTree()

   303

    setattr(cls, "removedataType", removedataType)

   304

   305

    def getpous(self):

   306

        return self.types.getpouElements()

   307

    setattr(cls, "getpous", getpous)

   308

   309

    def getpou(self, name):

   310

        return self.types.getpouElement(name)

   311

    setattr(cls, "getpou", getpou)

   312

   313

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

   314

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

   315

        self.AddCustomBlockType(self.getpou(name))

   316

    setattr(cls, "appendpou", appendpou)

   317

   318

    def insertpou(self, index, pou):

   319

        self.types.insertpouElement(index, pou)

   320

        self.AddCustomBlockType(pou)

   321

    setattr(cls, "insertpou", insertpou)

   322

   323

    def removepou(self, name):

   324

        self.types.removepouElement(name)

   325

        self.RefreshCustomBlockTypes()

   326

        self.RefreshElementUsingTree()

   327

    setattr(cls, "removepou", removepou)

   328

   329

    def getconfigurations(self):

   330

        configurations = self.instances.configurations.getconfiguration()

   331

        if configurations is not None:

   332

            return configurations

   333

        return []

   334

    setattr(cls, "getconfigurations", getconfigurations)

   335

   336

    def getconfiguration(self, name):

   337

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

   338

            if configuration.getname() == name:

   339

                return configuration

   340

        return None

   341

    setattr(cls, "getconfiguration", getconfiguration)

   342

   343

    def addconfiguration(self, name):

   344

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

   345

            if configuration.getname() == name:

   346

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

   347

        new_configuration = PLCOpenParser.CreateElement("configuration", "configurations")

   348

        new_configuration.setname(name)

   349

        self.instances.configurations.appendconfiguration(new_configuration)

   350

    setattr(cls, "addconfiguration", addconfiguration)    

   351

   352

    def removeconfiguration(self, name):

   353

        found = False

   354

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

   355

            if configuration.getname() == name:

   356

                self.instances.configurations.removeconfiguration(idx)

   357

                found = True

   358

                break

   359

        if not found:

   360

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

   361

    setattr(cls, "removeconfiguration", removeconfiguration)

   362

   363

    def getconfigurationResource(self, config_name, name):

   364

        configuration = self.getconfiguration(config_name)

   365

        if configuration is not None:

   366

            for resource in configuration.getresource():

   367

                if resource.getname() == name:

   368

                    return resource

   369

        return None

   370

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   371

   372

    def addconfigurationResource(self, config_name, name):

   373

        configuration = self.getconfiguration(config_name)

   374

        if configuration is not None:

   375

            for resource in configuration.getresource():

   376

                if resource.getname() == name:

   377

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

   378

            new_resource = PLCOpenParser.CreateElement("resource", "configuration")

   379

            new_resource.setname(name)

   380

            configuration.appendresource(new_resource)

   381

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   382

   383

    def removeconfigurationResource(self, config_name, name):

   384

        configuration = self.getconfiguration(config_name)

   385

        if configuration is not None:

   386

            found = False

   387

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

   388

                if resource.getname() == name:

   389

                    configuration.removeresource(idx)

   390

                    found = True

   391

                    break

   392

            if not found:

   393

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

   394

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   395

   396

    def updateElementName(self, old_name, new_name):

   397

        for datatype in self.types.getdataTypeElements():

   398

            datatype.updateElementName(old_name, new_name)

   399

        for pou in self.types.getpouElements():

   400

            pou.updateElementName(old_name, new_name)

   401

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

   402

            configuration.updateElementName(old_name, new_name)

   403

    setattr(cls, "updateElementName", updateElementName)

   404

   405

    def updateElementAddress(self, old_leading, new_leading):

   406

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   407

        for pou in self.types.getpouElements():

   408

            pou.updateElementAddress(address_model, new_leading)

   409

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

   410

            configuration.updateElementAddress(address_model, new_leading)

   411

    setattr(cls, "updateElementAddress", updateElementAddress)

   412

   413

    def removeVariableByAddress(self, address):

   414

        for pou in self.types.getpouElements():

   415

            pou.removeVariableByAddress(address)

   416

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

   417

            configuration.removeVariableByAddress(address)

   418

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   419

   420

    def removeVariableByFilter(self, leading):

   421

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   422

        for pou in self.types.getpouElements():

   423

            pou.removeVariableByFilter(address_model)

   424

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

   425

            configuration.removeVariableByFilter(address_model)

   426

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   427

   428

    def RefreshDataTypeHierarchy(self):

   429

        self.EnumeratedDataTypeValues = {}

   430

        self.CustomDataTypeRange = {}

   431

        self.CustomTypeHierarchy = {}

   432

        for datatype in self.getdataTypes():

   433

            self.AddCustomDataType(datatype)

   434

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   435

   436

    def AddCustomDataType(self, datatype):

   437

        name = datatype.getname()

   438

        basetype_content = datatype.getbaseType().getcontent()

   439

        basetype_content_name = basetype_content.getLocalTag()

   440

        if basetype_content.__class__ == DefaultElementClass:

   441

            self.CustomTypeHierarchy[name] = basetype_content_name

   442

        elif basetype_content_name in ["string", "wstring"]:

   443

            self.CustomTypeHierarchy[name] = basetype_content_name.upper()

   444

        elif basetype_content_name == "derived":

   445

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

   446

        elif basetype_content_name in ["subrangeSigned", "subrangeUnsigned"]:

   447

            range = (basetype_content.range.getlower(), 

   448

                     basetype_content.range.getupper())

   449

            self.CustomDataTypeRange[name] = range

   450

            base_type = basetype_content.baseType.getcontent()

   451

            if base_type.__class__ == DefaultElementClass:

   452

                self.CustomTypeHierarchy[name] = base_type.getLocalTag()

   453

            else:

   454

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

   455

        else:

   456

            if basetype_content_name == "enum":

   457

                values = []

   458

                for value in basetype_content.xpath("ppx:values/ppx:value", namespaces=PLCOpenParser.NSMAP):

   459

                    values.append(value.getname())

   460

                self.EnumeratedDataTypeValues[name] = values

   461

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   462

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   463

   464

    # Update Block types with user-defined pou added

   465

    def RefreshCustomBlockTypes(self):

   466

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

   467

        self.CustomBlockTypes = OrderedDict()

   468

        for pou in self.getpous():

   469

            self.AddCustomBlockType(pou)

   470

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   471

   472

    def AddCustomBlockType(self, pou): 

   473

        pou_name = pou.getname()

   474

        pou_type = pou.getpouType()

   475

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

   476

                       "inputs" : [], "outputs" : [], "comment" : pou.getdescription(),

   477

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

   478

        if pou.interface is not None:

   479

            return_type = pou.interface.getreturnType()

   480

            if return_type is not None:

   481

                var_type = return_type.getcontent()

   482

                var_type_name = var_type.getLocalTag()

   483

                if var_type_name == "derived":

   484

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

   485

                elif var_type_name in ["string", "wstring"]:

   486

                    block_infos["outputs"].append(("OUT", var_type_name.upper(), "none"))

   487

                else:

   488

                    block_infos["outputs"].append(("OUT", var_type_name, "none"))

   489

            for type, varlist in pou.getvars():

   490

                if type == "InOut":

   491

                    for var in varlist.getvariable():

   492

                        var_type = var.type.getcontent()

   493

                        var_type_name = var_type.getLocalTag()

   494

                        if var_type_name == "derived":

   495

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

   496

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

   497

                        elif var_type_name in ["string", "wstring"]:

   498

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

   499

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

   500

                        else:

   501

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

   502

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

   503

                elif type == "Input":

   504

                    for var in varlist.getvariable():

   505

                        var_type = var.type.getcontent()

   506

                        var_type_name = var_type.getLocalTag()

   507

                        if var_type_name == "derived":

   508

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

   509

                        elif var_type_name in ["string", "wstring"]:

   510

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

   511

                        else:

   512

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

   513

                elif type == "Output":

   514

                    for var in varlist.getvariable():

   515

                        var_type = var.type.getcontent()

   516

                        var_type_name = var_type.getLocalTag()

   517

                        if var_type_name == "derived":

   518

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

   519