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()\

   131

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

   132

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

   133

        .replace("<![CDATA[", "<xhtml:p><![CDATA[")\

   134

        .replace("]]>", "]]></xhtml:p>")

   135

    project_file.close()

   136

   137

    return etree.fromstring(project_xml, PLCOpenParser)

   138

   139

def SaveProject(project, filepath):

   140

    project_file = open(filepath, 'w')

   141

    project_file.write(etree.tostring(

   142

        project, 

   143

        pretty_print=True, 

   144

        xml_declaration=True, 

   145

        encoding='utf-8'))

   146

    project_file.close()

   147

   148

cls = PLCOpenParser.GetElementClass("formattedText")

   149

if cls:

   150

    def updateElementName(self, old_name, new_name):

   151

        text = self.text

   152

        index = text.find(old_name)

   153

        while index != -1:

   154

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

   155

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

   156

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

   157

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

   158

            else:

   159

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

   160

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

   161

        self.text = text

   162

    setattr(cls, "updateElementName", updateElementName)

   163

   164

    def updateElementAddress(self, address_model, new_leading):

   165

        text = self.text

   166

        startpos = 0

   167

        result = address_model.search(text, startpos)

   168

        while result is not None:

   169

            groups = result.groups()

   170

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

   171

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

   172

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

   173

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

   174

        self.text = text

   175

    setattr(cls, "updateElementAddress", updateElementAddress)

   176

   177

    def hasblock(self, block_type):

   178

        text = self.text.upper()

   179

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

   180

        while index != -1:

   181

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

   182

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

   183

                return True

   184

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

   185

        return False

   186

    setattr(cls, "hasblock", hasblock)

   187

   188

    def Search(self, criteria, parent_infos):

   189

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

   190

    setattr(cls, "Search", Search)

   191

   192

cls = PLCOpenParser.GetElementClass("project")

   193

if cls:

   194

    cls.EnumeratedDataTypeValues = {}

   195

    cls.CustomDataTypeRange = {}

   196

    cls.CustomTypeHierarchy = {}

   197

    cls.ElementUsingTree = {}

   198

    cls.CustomBlockTypes = OrderedDict()

   199

   200

    def setname(self, name):

   201

        self.contentHeader.setname(name)

   202

    setattr(cls, "setname", setname)

   203

   204

    def getname(self):

   205

        return self.contentHeader.getname()

   206

    setattr(cls, "getname", getname)

   207

   208

    def getfileHeader(self):

   209

        fileheader = {}

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

            if value is not None:

   218

                fileheader[name] = value

   219

            else:

   220

                fileheader[name] = ""

   221

        return fileheader

   222

    setattr(cls, "getfileHeader", getfileHeader)

   223

   224

    def setfileHeader(self, fileheader):

   225

        if fileheader.has_key("companyName"):

   226

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

   227

        if fileheader.has_key("companyURL"):

   228

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

   229

        if fileheader.has_key("productName"):

   230

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

   231

        if fileheader.has_key("productVersion"):

   232

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

   233

        if fileheader.has_key("productRelease"):

   234

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

   235

        if fileheader.has_key("creationDateTime"):

   236

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

   237

        if fileheader.has_key("contentDescription"):

   238

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

   239

    setattr(cls, "setfileHeader", setfileHeader)

   240

   241

    def getcontentHeader(self):

   242

        contentheader = {}

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

            if value is not None:

   250

                contentheader[name] = value

   251

            else:

   252

                contentheader[name] = ""

   253

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

   254

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

   255

        return contentheader

   256

    setattr(cls, "getcontentHeader", getcontentHeader)

   257

   258

    def setcontentHeader(self, contentheader):

   259

        if contentheader.has_key("projectName"):

   260

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

   261

        if contentheader.has_key("projectVersion"):

   262

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

   263

        if contentheader.has_key("modificationDateTime"):

   264

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

   265

        if contentheader.has_key("organization"):

   266

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

   267

        if contentheader.has_key("authorName"):

   268

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

   269

        if contentheader.has_key("language"):

   270

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

   271

        if contentheader.has_key("pageSize"):

   272

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

   273

        if contentheader.has_key("scaling"):

   274

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

   275

    setattr(cls, "setcontentHeader", setcontentHeader)

   276

   277

    def getdataTypes(self):

   278

        return self.types.getdataTypeElements()

   279

    setattr(cls, "getdataTypes", getdataTypes)

   280

   281

    def getdataType(self, name):

   282

        return self.types.getdataTypeElement(name)

   283

    setattr(cls, "getdataType", getdataType)

   284

   285

    def appenddataType(self, name):

   286

        if self.CustomTypeHierarchy.has_key(name):

   287

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

   288

        self.types.appenddataTypeElement(name)

   289

        self.AddCustomDataType(self.getdataType(name))

   290

    setattr(cls, "appenddataType", appenddataType)

   291

   292

    def insertdataType(self, index, datatype):

   293

        self.types.insertdataTypeElement(index, datatype)

   294

        self.AddCustomDataType(datatype)

   295

    setattr(cls, "insertdataType", insertdataType)

   296

   297

    def removedataType(self, name):

   298

        self.types.removedataTypeElement(name)

   299

        self.RefreshDataTypeHierarchy()

   300

        self.RefreshElementUsingTree()

   301

    setattr(cls, "removedataType", removedataType)

   302

   303

    def getpous(self):

   304

        return self.types.getpouElements()

   305

    setattr(cls, "getpous", getpous)

   306

   307

    def getpou(self, name):

   308

        return self.types.getpouElement(name)

   309

    setattr(cls, "getpou", getpou)

   310

   311

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

   312

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

   313

        self.AddCustomBlockType(self.getpou(name))

   314

    setattr(cls, "appendpou", appendpou)

   315

   316

    def insertpou(self, index, pou):

   317

        self.types.insertpouElement(index, pou)

   318

        self.AddCustomBlockType(pou)

   319

    setattr(cls, "insertpou", insertpou)

   320

   321

    def removepou(self, name):

   322

        self.types.removepouElement(name)

   323

        self.RefreshCustomBlockTypes()

   324

        self.RefreshElementUsingTree()

   325

    setattr(cls, "removepou", removepou)

   326

   327

    def getconfigurations(self):

   328

        configurations = self.instances.configurations.getconfiguration()

   329

        if configurations:

   330

            return configurations

   331

        return []

   332

    setattr(cls, "getconfigurations", getconfigurations)

   333

   334

    def getconfiguration(self, name):

   335

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

   336

            if configuration.getname() == name:

   337

                return configuration

   338

        return None

   339

    setattr(cls, "getconfiguration", getconfiguration)

   340

   341

    def addconfiguration(self, name):

   342

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

   343

            if configuration.getname() == name:

   344

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

   345

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

   346

        new_configuration.setname(name)

   347

        self.instances.configurations.appendconfiguration(new_configuration)

   348

    setattr(cls, "addconfiguration", addconfiguration)    

   349

   350

    def removeconfiguration(self, name):

   351

        found = False

   352

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

   353

            if configuration.getname() == name:

   354

                self.instances.configurations.removeconfiguration(idx)

   355

                found = True

   356

                break

   357

        if not found:

   358

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

   359

    setattr(cls, "removeconfiguration", removeconfiguration)

   360

   361

    def getconfigurationResource(self, config_name, name):

   362

        configuration = self.getconfiguration(config_name)

   363

        if configuration:

   364

            for resource in configuration.getresource():

   365

                if resource.getname() == name:

   366

                    return resource

   367

        return None

   368

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   369

   370

    def addconfigurationResource(self, config_name, name):

   371

        configuration = self.getconfiguration(config_name)

   372

        if configuration:

   373

            for resource in configuration.getresource():

   374

                if resource.getname() == name:

   375

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

   376

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

   377

            new_resource.setname(name)

   378

            configuration.appendresource(new_resource)

   379

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   380

   381

    def removeconfigurationResource(self, config_name, name):

   382

        configuration = self.getconfiguration(config_name)

   383

        if configuration:

   384

            found = False

   385

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

   386

                if resource.getname() == name:

   387

                    configuration.removeresource(idx)

   388

                    found = True

   389

                    break

   390

            if not found:

   391

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

   392

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   393

   394

    def updateElementName(self, old_name, new_name):

   395

        for datatype in self.types.getdataTypeElements():

   396

            datatype.updateElementName(old_name, new_name)

   397

        for pou in self.types.getpouElements():

   398

            pou.updateElementName(old_name, new_name)

   399

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

   400

            configuration.updateElementName(old_name, new_name)

   401

    setattr(cls, "updateElementName", updateElementName)

   402

   403

    def updateElementAddress(self, old_leading, new_leading):

   404

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   405

        for pou in self.types.getpouElements():

   406

            pou.updateElementAddress(address_model, new_leading)

   407

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

   408

            configuration.updateElementAddress(address_model, new_leading)

   409

    setattr(cls, "updateElementAddress", updateElementAddress)

   410

   411

    def removeVariableByAddress(self, address):

   412

        for pou in self.types.getpouElements():

   413

            pou.removeVariableByAddress(address)

   414

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

   415

            configuration.removeVariableByAddress(address)

   416

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   417

   418

    def removeVariableByFilter(self, leading):

   419

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   420

        for pou in self.types.getpouElements():

   421

            pou.removeVariableByFilter(address_model)

   422

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

   423

            configuration.removeVariableByFilter(address_model)

   424

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   425

   426

    def RefreshDataTypeHierarchy(self):

   427

        self.EnumeratedDataTypeValues = {}

   428

        self.CustomDataTypeRange = {}

   429

        self.CustomTypeHierarchy = {}

   430

        for datatype in self.getdataTypes():

   431

            self.AddCustomDataType(datatype)

   432

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   433

   434

    def AddCustomDataType(self, datatype):

   435

        name = datatype.getname()

   436

        basetype_content = datatype.getbaseType().getcontent()

   437

        basetype_content_name = basetype_content.getLocalTag()

   438

        if basetype_content.__class__ == DefaultElementClass:

   439

            self.CustomTypeHierarchy[name] = basetype_content_name

   440

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

   441

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

   442

        elif basetype_content_name == "derived":

   443

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

   444

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

   445

            range = (basetype_content.range.getlower(), 

   446

                     basetype_content.range.getupper())

   447

            self.CustomDataTypeRange[name] = range

   448

            base_type = basetype_content.baseType.getcontent()

   449

            if base_type.__class__ == DefaultElementClass:

   450

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

   451

            else:

   452

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

   453

        else:

   454

            if basetype_content_name == "enum":

   455

                values = []

   456

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

   457

                    values.append(value.getname())

   458

                self.EnumeratedDataTypeValues[name] = values

   459

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   460

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   461

   462

    # Update Block types with user-defined pou added

   463

    def RefreshCustomBlockTypes(self):

   464

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

   465

        self.CustomBlockTypes = OrderedDict()

   466

        for pou in self.getpous():

   467

            self.AddCustomBlockType(pou)

   468

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   469

   470

    def AddCustomBlockType(self, pou): 

   471

        pou_name = pou.getname()

   472

        pou_type = pou.getpouType()

   473

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

   474

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

   475

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

   476

        if pou.interface is not None:

   477

            return_type = pou.interface.getreturnType()

   478

            if return_type is not None:

   479

                var_type = return_type.getcontent()

   480

                var_type_name = var_type.getLocalTag()

   481

                if var_type_name == "derived":

   482

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

   483

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

   484

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

   485

                else:

   486

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

   487

            for type, varlist in pou.getvars():

   488

                if type == "InOut":

   489

                    for var in varlist.getvariable():

   490

                        var_type = var.type.getcontent()

   491

                        var_type_name = var_type.getLocalTag()

   492

                        if var_type_name == "derived":

   493

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

   494

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

   495

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

   496

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

   497

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

   498

                        else:

   499

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

   500

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

   501

                elif type == "Input":

   502

                    for var in varlist.getvariable():

   503

                        var_type = var.type.getcontent()

   504

                        var_type_name = var_type.getLocalTag()

   505

                        if var_type_name == "derived":

   506

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

   507

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

   508

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

   509

                        else:

   510

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

   511

                elif type == "Output":

   512

                    for var in varlist.getvariable():

   513

                        var_type = var.type.getcontent()

   514

                        var_type_name = var_type.getLocalTag()

   515

                        if var_type_name == "derived":

   516

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

   517

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

   518

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

   519

                        else:

   520