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

    27

import os, re

    28

from lxml import etree

    29

from collections import OrderedDict

    30

    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

PLCOpen_XPath = lambda xpath: etree.XPath(xpath, namespaces=PLCOpenParser.NSMAP)

   128

   129

LOAD_POU_PROJECT_TEMPLATE = """

   130

<project xmlns:ns1="http://www.plcopen.org/xml/tc6_0201" 

   131

         xmlns:xhtml="http://www.w3.org/1999/xhtml" 

   132

         xmlns:xsd="http://www.w3.org/2001/XMLSchema" 

   133

         xmlns="http://www.plcopen.org/xml/tc6_0201">

   134

  <fileHeader companyName="" productName="" productVersion="" 

   135

              creationDateTime="1970-01-01T00:00:00"/>

   136

  <contentHeader name="paste_project">

   137

    <coordinateInfo>

   138

      <fbd><scaling x="0" y="0"/></fbd>

   139

      <ld><scaling x="0" y="0"/></ld>

   140

      <sfc><scaling x="0" y="0"/></sfc>

   141

    </coordinateInfo>

   142

  </contentHeader>

   143

  <types>

   144

    <dataTypes/>

   145

    <pous>%s</pous>

   146

  </types>

   147

  <instances>

   148

    <configurations/>

   149

  </instances>

   150

</project>

   151

"""

   152

   153

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   154

    return LOAD_POU_PROJECT_TEMPLATE % """

   155

<pou name="paste_pou" pouType="program">

   156

  <body>

   157

    <%(body_type)s>%%s</%(body_type)s>

   158

  </body>

   159

</pou>""" % locals()

   160

   177

def LoadProjectXML(project_xml):

   178

    project_xml = project_xml.replace(

   179

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

   180

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

   181

    for cre, repl in [

   182

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

   183

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

   184

        project_xml = cre.sub(repl, project_xml)

   185

   186

    try:

   187

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   251

    except Exception, e:

   252

        return None, e.message

   253

   254

def LoadProject(filepath):

   255

    project_file = open(filepath)

   256

    project_xml = project_file.read()

   257

    project_file.close()

   258

    return LoadProjectXML(project_xml)

   259

   260

project_pou_xpath = PLCOpen_XPath("/ppx:project/ppx:types/ppx:pous/ppx:pou")

   261

def LoadPou(xml_string):

   262

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   263

    return project_pou_xpath(root)[0], error

   264

   265

project_pou_instances_xpath = {

   266

    body_type: PLCOpen_XPath(

   267

        "/ppx:project/ppx:types/ppx:pous/ppx:pou[@name='paste_pou']/ppx:body/ppx:%s/*" % body_type)

   268

    for body_type in ["FBD", "LD", "SFC"]}

   269

def LoadPouInstances(xml_string, body_type):

   270

    root, error = LoadProjectXML(

   271

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   272

    return project_pou_instances_xpath[body_type](root), error

   273

   274

def SaveProject(project, filepath):

   275

    project_file = open(filepath, 'w')

   276

    project_file.write(etree.tostring(

   277

        project, 

   278

        pretty_print=True, 

   279

        xml_declaration=True, 

   280

        encoding='utf-8'))

   281

    project_file.close()

   282

   283

cls = PLCOpenParser.GetElementClass("formattedText")

   284

if cls:

   285

    def updateElementName(self, old_name, new_name):

   286

        text = self.getanyText()

   287

        index = text.find(old_name)

   288

        while index != -1:

   289

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

   290

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

   291

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

   292

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

   293

            else:

   294

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

   295

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

   296

        self.setanyText(text)

   297

    setattr(cls, "updateElementName", updateElementName)

   298

   299

    def updateElementAddress(self, address_model, new_leading):

   300

        text = self.getanyText()

   301

        startpos = 0

   302

        result = address_model.search(text, startpos)

   303

        while result is not None:

   304

            groups = result.groups()

   305

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

   306

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

   307

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

   308

            result = address_model.search(text, startpos)

   309

        self.setanyText(text)

   310

    setattr(cls, "updateElementAddress", updateElementAddress)

   311

   312

    def hasblock(self, block_type):

   313

        text = self.getanyText().upper()

   314

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

   315

        while index != -1:

   316

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

   317

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

   318

                return True

   319

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

   320

        return False

   321

    setattr(cls, "hasblock", hasblock)

   322

   323

    def Search(self, criteria, parent_infos):

   324

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

   325

    setattr(cls, "Search", Search)

   326

   327

cls = PLCOpenParser.GetElementClass("project")

   328

if cls:

   329

   330

    def setname(self, name):

   331

        self.contentHeader.setname(name)

   332

    setattr(cls, "setname", setname)

   333

   334

    def getname(self):

   335

        return self.contentHeader.getname()

   336

    setattr(cls, "getname", getname)

   337

   338

    def getfileHeader(self):

   339

        fileheader_obj = self.fileHeader

   340

        return {

   341

            attr: value if value is not None else ""

   342

            for attr, value in [

   343

                ("companyName", fileheader_obj.getcompanyName()),

   344

                ("companyURL", fileheader_obj.getcompanyURL()),

   345

                ("productName", fileheader_obj.getproductName()),

   346

                ("productVersion", fileheader_obj.getproductVersion()),

   347

                ("productRelease", fileheader_obj.getproductRelease()),

   348

                ("creationDateTime", fileheader_obj.getcreationDateTime()),

   349

                ("contentDescription", fileheader_obj.getcontentDescription())]

   350

        }

   351

    setattr(cls, "getfileHeader", getfileHeader)

   352

   353

    def setfileHeader(self, fileheader):

   354

        fileheader_obj = self.fileHeader

   355

        for attr in ["companyName", "companyURL", "productName",

   356

                     "productVersion", "productRelease", "creationDateTime",

   357

                     "contentDescription"]:

   358

            value = fileheader.get(attr)

   359

            if value is not None:

   360

                setattr(fileheader_obj, attr, value)

   361

    setattr(cls, "setfileHeader", setfileHeader)

   362

   363

    def getcontentHeader(self):

   364

        contentheader_obj = self.contentHeader

   365

        contentheader = {

   366

            attr: value if value is not None else ""

   367

            for attr, value in [

   368

                ("projectName", contentheader_obj.getname()),

   369

                ("projectVersion", contentheader_obj.getversion()),

   370

                ("modificationDateTime", contentheader_obj.getmodificationDateTime()),

   371

                ("organization", contentheader_obj.getorganization()),

   372

                ("authorName", contentheader_obj.getauthor()),

   373

                ("language", contentheader_obj.getlanguage())]

   374

        }

   375

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

   376

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

   377

        return contentheader

   378

    setattr(cls, "getcontentHeader", getcontentHeader)

   379

   380

    def setcontentHeader(self, contentheader):

   381

        contentheader_obj = self.contentHeader

   382

        for attr, value in contentheader.iteritems():

   383

            func = {"projectName": contentheader_obj.setname,

   384

                    "projectVersion": contentheader_obj.setversion,

   385

                    "authorName": contentheader_obj.setauthor,

   386

                    "pageSize": lambda v: contentheader_obj.setpageSize(*v),

   387

                    "scaling": contentheader_obj.setscaling}.get(attr)

   388

            if func is not None:

   389

                func(value)

   390

            elif attr in ["modificationDateTime", "organization", "language"]:

   391

                setattr(contentheader_obj, attr, value)

   392

    setattr(cls, "setcontentHeader", setcontentHeader)

   393

   394

    def gettypeElementFunc(element_type):

   395

        elements_xpath = PLCOpen_XPath(

   396

            "ppx:types/ppx:%(element_type)ss/ppx:%(element_type)s[@name=$name]" % locals())

   397

        def gettypeElement(self, name):

   398

            elements = elements_xpath(self, name=name)

   399

            if len(elements) == 1:

   400

                return elements[0]

   401

            return None

   402

        return gettypeElement

   403

   404

    datatypes_xpath = PLCOpen_XPath("ppx:types/ppx:dataTypes/ppx:dataType")

   405

    filtered_datatypes_xpath = PLCOpen_XPath(

   406

        "ppx:types/ppx:dataTypes/ppx:dataType[@name!=$exclude]")

   407

    def getdataTypes(self, exclude=None):

   408

        if exclude is not None:

   409

            return filtered_datatypes_xpath(self, exclude=exclude)

   410

        return datatypes_xpath(self)

   411

    setattr(cls, "getdataTypes", getdataTypes)

   412

   413

    setattr(cls, "getdataType", gettypeElementFunc("dataType"))

   414

   415

    def appenddataType(self, name):

   416

        if self.getdataType(name) is not None:

   417

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

   418

        self.types.appenddataTypeElement(name)

   419

    setattr(cls, "appenddataType", appenddataType)

   420

   421

    def insertdataType(self, index, datatype):

   422

        self.types.insertdataTypeElement(index, datatype)

   423

    setattr(cls, "insertdataType", insertdataType)

   424

   425

    def removedataType(self, name):

   426

        self.types.removedataTypeElement(name)

   427

    setattr(cls, "removedataType", removedataType)

   428

   429

    def getpous(self, exclude=None, filter=[]):

   430

        return self.xpath(

   431

            "ppx:types/ppx:pous/ppx:pou%s%s" % 

   432

                (("[@name!='%s']" % exclude) if exclude is not None else '',

   433

                 ("[%s]" % " or ".join(

   434

                    map(lambda x: "@pouType='%s'" % x, filter)))

   435

                 if len(filter) > 0 else ""),

   436

            namespaces=PLCOpenParser.NSMAP)

   437

    setattr(cls, "getpous", getpous)

   438

   439

    setattr(cls, "getpou", gettypeElementFunc("pou"))

   440

   441

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

   442

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

   443

    setattr(cls, "appendpou", appendpou)

   444

   445

    def insertpou(self, index, pou):

   446

        self.types.insertpouElement(index, pou)

   447

    setattr(cls, "insertpou", insertpou)

   448

   449

    def removepou(self, name):

   450

        self.types.removepouElement(name)

   451

    setattr(cls, "removepou", removepou)

   452

   453

    configurations_xpath = PLCOpen_XPath(

   454

        "ppx:instances/ppx:configurations/ppx:configuration")

   455

    def getconfigurations(self):

   456

        return configurations_xpath(self)

   457

    setattr(cls, "getconfigurations", getconfigurations)

   458

   459

    configuration_xpath = PLCOpen_XPath(

   460

        "ppx:instances/ppx:configurations/ppx:configuration[@name=$name]")

   461

    def getconfiguration(self, name):

   462

        configurations = configuration_xpath(self, name=name)

   463

        if len(configurations) == 1:

   464

            return configurations[0]

   465

        return None

   466

    setattr(cls, "getconfiguration", getconfiguration)

   467

   468

    def addconfiguration(self, name):

   469

        if self.getconfiguration(name) is not None:

   470

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

   471

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

   472

        new_configuration.setname(name)

   473

        self.instances.configurations.appendconfiguration(new_configuration)

   474

    setattr(cls, "addconfiguration", addconfiguration)    

   475

   476

    def removeconfiguration(self, name):

   477

        configuration = self.getconfiguration(name)

   478

        if configuration is None:

   479

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

   480

        self.instances.configurations.remove(configuration)

   481

    setattr(cls, "removeconfiguration", removeconfiguration)

   482

   483

    resources_xpath = PLCOpen_XPath(

   484

        "ppx:instances/ppx:configurations/ppx:configuration[@name=$configname]/ppx:resource[@name=$name]")

   485

    def getconfigurationResource(self, config_name, name):

   486

        resources = resources_xpath(self, configname=config_name, name=name)

   487

        if len(resources) == 1:

   488

            return resources[0]

   489

        return None

   490

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   491

   492

    def addconfigurationResource(self, config_name, name):

   493

        if self.getconfigurationResource(config_name, name) is not None:

   494

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

   495

        configuration = self.getconfiguration(config_name)

   496

        if configuration is not None:

   497

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

   498

            new_resource.setname(name)

   499

            configuration.appendresource(new_resource)

   500

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   501

   502

    def removeconfigurationResource(self, config_name, name):

   503

        configuration = self.getconfiguration(config_name)

   504

        found = False

   505