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 = OrderedDict([("N", False), ("R", False), ("S", False), 

    53

    ("L", True), ("D", True), ("P", False), ("P0", False), 

    54

    ("P1", False), ("SD", True), ("DS", True), ("SL", True)])

    55

    56

    57

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

    58

    59

def update_address(address, address_model, new_leading):

    60

    result = address_model.match(address)

    61

    if result is None:

    62

        return address

    63

    groups = result.groups()

    64

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

    65

    66

def _init_and_compare(function, v1, v2):

    67

    if v1 is None:

    68

        return v2

    69

    if v2 is not None:

    70

        return function(v1, v2)

    71

    return v1

    72

    73

"""

    74

Helper class for bounding_box calculation 

    75

"""

    76

class rect:

    77

    78

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

    79

        self.x_min = x

    80

        self.x_max = None

    81

        self.y_min = y

    82

        self.y_max = None

    83

        if width is not None and x is not None:

    84

            self.x_max = x + width

    85

        if height is not None and y is not None:

    86

            self.y_max = y + height

    87

    88

    def update(self, x, y):

    89

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

    90

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

    91

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

    92

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

    93

    94

    def union(self, rect):

    95

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

    96

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

    97

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

    98

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

    99

   100

    def bounding_box(self):

   101

        width = height = None

   102

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

   103

            width = self.x_max - self.x_min

   104

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

   105

            height = self.y_max - self.y_min

   106

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

   107

   108

def TextLenInRowColumn(text):

   109

    if text == "":

   110

        return (0, 0)

   111

    lines = text.split("\n")

   112

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

   113

   121

def TestTextElement(text, criteria):

   122

    lines = text.splitlines()

   123

    test_result = []

   124

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

   125

    while result is not None:

   126

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

   127

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

   128

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

   129

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

   130

    return test_result

   131

   132

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

   133

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

   134

   135

LOAD_POU_PROJECT_TEMPLATE = """

   136

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

   137

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

   138

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

   139

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

   140

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

   141

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

   142

  <contentHeader name="paste_project">

   143

    <coordinateInfo>

   144

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

   145

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

   146

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

   147

    </coordinateInfo>

   148

  </contentHeader>

   149

  <types>

   150

    <dataTypes/>

   151

    <pous>%s</pous>

   152

  </types>

   153

  <instances>

   154

    <configurations/>

   155

  </instances>

   156

</project>

   157

"""

   158

   159

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   160

    return LOAD_POU_PROJECT_TEMPLATE % """

   161

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

   162

  <body>

   163

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

   164

  </body>

   165

</pou>""" % locals()

   166

   167

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

   168

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   169

PLCOpen_v1_file.close()

   170

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   171

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

   172

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

   173

PLCOpen_v1_xsd = etree.XMLSchema(etree.fromstring(PLCOpen_v1_xml))

   174

   175

# XPath for file compatibility process

   176

ProjectResourcesXPath = PLCOpen_XPath("ppx:instances/ppx:configurations/ppx:configuration/ppx:resource")

   177

ResourceInstancesXpath = PLCOpen_XPath("ppx:pouInstance | ppx:task/ppx:pouInstance")

   178

TransitionsConditionXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:transition/ppx:condition")

   179

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   180

ActionBlocksXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:actionBlock")

   181

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   182

   183

def LoadProjectXML(project_xml):

   184

    project_xml = project_xml.replace(

   185

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

   186

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

   187

    for cre, repl in [

   188

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

   189

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

   190

        project_xml = cre.sub(repl, project_xml)

   191

   192

    try:

   193

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   194

        if error is None:

   195

            return tree, None

   196

   197

        if PLCOpen_v1_xsd.validate(tree):

   198

            # Make file compatible with PLCOpen v2

   199

   200

            # Update resource interval value

   201

            for resource in ProjectResourcesXPath(tree):

   202

                for task in resource.gettask():

   203

                    interval = task.get("interval")

   204

                    if interval is not None:

   205

                        result = time_model.match(interval)

   206

                        if result is not None:

   207

                            values = result.groups()

   208

                            time_values = [int(v) for v in values[:2]]

   209

                            seconds = float(values[2])

   210

                            time_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   211

                            text = "T#"

   212

                            if time_values[0] != 0:

   213

                                text += "%dh"%time_values[0]

   214

                            if time_values[1] != 0:

   215

                                text += "%dm"%time_values[1]

   216

                            if time_values[2] != 0:

   217

                                text += "%ds"%time_values[2]

   218

                            if time_values[3] != 0:

   219

                                if time_values[3] % 1000 != 0:

   220

                                    text += "%.3fms"%(float(time_values[3]) / 1000)

   221

                                else:

   222

                                    text += "%dms"%(time_values[3] / 1000)

   223

                            task.set("interval", text)

   224

   225

                # Update resources pou instance attributes

   226

                for pouInstance in ResourceInstancesXpath(resource):

   227

                    type_name = pouInstance.attrib.pop("type")

   228

                    if type_name is not None:

   229

                        pouInstance.set("typeName", type_name)

   230

   231

            # Update transitions condition

   232

            for transition_condition in TransitionsConditionXPath(tree):

   233

                connections = ConditionConnectionsXPath(transition_condition)

   234

                if len(connections) > 0:

   235

                    connectionPointIn = PLCOpenParser.CreateElement("connectionPointIn", "condition")

   236

                    transition_condition.setcontent(connectionPointIn)

   237

                    connectionPointIn.setrelPositionXY(0, 0)

   238

                    for connection in connections:

   239

                        connectionPointIn.append(connection)

   240

   241

            # Update actionBlocks

   242

            for actionBlock in ActionBlocksXPath(tree):

   243

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   244

                    actionBlock.remove(connectionPointOut)

   245

   246

                for action in actionBlock.getaction():

   247

                    action.set("localId", "0")

   248

                    relPosition = PLCOpenParser.CreateElement("relPosition", "action")

   249

                    relPosition.set("x", "0")

   250

                    relPosition.set("y", "0")

   251

                    action.setrelPosition(relPosition)

   252

   253

            return tree, None

   254

   255

        return tree, error

   256

   257

    except Exception, e:

   258

        return None, e.message

   259

   260

def LoadProject(filepath):

   261

    project_file = open(filepath)

   262

    project_xml = project_file.read()

   263

    project_file.close()

   264

    return LoadProjectXML(project_xml)

   265

   266

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

   267

def LoadPou(xml_string):

   268

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   269

    return project_pou_xpath(root)[0], error

   270

   271

project_pou_instances_xpath = {

   272

    body_type: PLCOpen_XPath(

   273

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

   274

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

   275

def LoadPouInstances(xml_string, body_type):

   276

    root, error = LoadProjectXML(

   277

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   278

    return project_pou_instances_xpath[body_type](root), error

   279

   280

def SaveProject(project, filepath):

   281

    project_file = open(filepath, 'w')

   282

    project_file.write(etree.tostring(

   283

        project, 

   284

        pretty_print=True, 

   285

        xml_declaration=True, 

   286

        encoding='utf-8'))

   287

    project_file.close()

   288

   289

cls = PLCOpenParser.GetElementClass("formattedText")

   290

if cls:

   291

    def updateElementName(self, old_name, new_name):

   292

        text = self.getanyText()

   293

        index = text.find(old_name)

   294

        while index != -1:

   295

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

   296

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

   297

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

   298

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

   299

            else:

   300

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

   301

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

   302

        self.setanyText(text)

   303

    setattr(cls, "updateElementName", updateElementName)

   304

   305

    def updateElementAddress(self, address_model, new_leading):

   306

        text = self.getanyText()

   307

        startpos = 0

   308

        result = address_model.search(text, startpos)

   309

        while result is not None:

   310

            groups = result.groups()

   311

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

   312

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

   313

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

   314

            result = address_model.search(text, startpos)

   315

        self.setanyText(text)

   316

    setattr(cls, "updateElementAddress", updateElementAddress)

   317

   318

    def hasblock(self, block_type):

   319

        text = self.getanyText().upper()

   320

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

   321

        while index != -1:

   322

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

   323

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

   324

                return True

   325

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

   326

        return False

   327

    setattr(cls, "hasblock", hasblock)

   328

   329

    def Search(self, criteria, parent_infos):

   330

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

   331

    setattr(cls, "Search", Search)

   332

   333

cls = PLCOpenParser.GetElementClass("project")

   334

if cls:

   335

   336

    def setname(self, name):

   337

        self.contentHeader.setname(name)

   338

    setattr(cls, "setname", setname)

   339

   340

    def getname(self):

   341

        return self.contentHeader.getname()

   342

    setattr(cls, "getname", getname)

   343

   344

    def getfileHeader(self):

   345

        fileheader_obj = self.fileHeader

   346

        return {

   347

            attr: value if value is not None else ""

   348

            for attr, value in [

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

        }

   357

    setattr(cls, "getfileHeader", getfileHeader)

   358

   359

    def setfileHeader(self, fileheader):

   360

        fileheader_obj = self.fileHeader

   361

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

   362

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

   363

                     "contentDescription"]:

   364

            value = fileheader.get(attr)

   365

            if value is not None:

   366

                setattr(fileheader_obj, attr, value)

   367

    setattr(cls, "setfileHeader", setfileHeader)

   368

   369

    def getcontentHeader(self):

   370

        contentheader_obj = self.contentHeader

   371

        contentheader = {

   372

            attr: value if value is not None else ""

   373

            for attr, value in [

   374

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

   375

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

   376

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

   377

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

   378

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

   379

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

   380

        }

   381

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

   382

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

   383

        return contentheader

   384

    setattr(cls, "getcontentHeader", getcontentHeader)

   385

   386

    def setcontentHeader(self, contentheader):

   387

        contentheader_obj = self.contentHeader

   388

        for attr, value in contentheader.iteritems():

   389

            func = {"projectName": contentheader_obj.setname,

   390

                    "projectVersion": contentheader_obj.setversion,

   391

                    "authorName": contentheader_obj.setauthor,

   392

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

   393

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

   394

            if func is not None:

   395

                func(value)

   396

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

   397

                setattr(contentheader_obj, attr, value)

   398

    setattr(cls, "setcontentHeader", setcontentHeader)

   399

   400

    def gettypeElementFunc(element_type):

   401

        elements_xpath = PLCOpen_XPath(

   402

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

   403

        def gettypeElement(self, name):

   404

            elements = elements_xpath(self, name=name)

   405

            if len(elements) == 1:

   406

                return elements[0]

   407

            return None

   408

        return gettypeElement

   409

   410

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

   411

    filtered_datatypes_xpath = PLCOpen_XPath(

   412

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

   413

    def getdataTypes(self, exclude=None):

   414

        if exclude is not None:

   415

            return filtered_datatypes_xpath(self, exclude=exclude)

   416

        return datatypes_xpath(self)

   417

    setattr(cls, "getdataTypes", getdataTypes)

   418

   419

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

   420

   421

    def appenddataType(self, name):

   422

        if self.getdataType(name) is not None:

   423

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

   424

        self.types.appenddataTypeElement(name)

   425

    setattr(cls, "appenddataType", appenddataType)

   426

   427

    def insertdataType(self, index, datatype):

   428

        self.types.insertdataTypeElement(index, datatype)

   429

    setattr(cls, "insertdataType", insertdataType)

   430

   431

    def removedataType(self, name):

   432

        self.types.removedataTypeElement(name)

   433

    setattr(cls, "removedataType", removedataType)

   434

   435

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

   436

        return self.xpath(

   437

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

   438

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

   439

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

   440

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

   441

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

   442

            namespaces=PLCOpenParser.NSMAP)

   443

    setattr(cls, "getpous", getpous)

   444

   445

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

   446

   447

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

   448

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

   449

    setattr(cls, "appendpou", appendpou)

   450

   451

    def insertpou(self, index, pou):

   452

        self.types.insertpouElement(index, pou)

   453

    setattr(cls, "insertpou", insertpou)

   454

   455

    def removepou(self, name):

   456

        self.types.removepouElement(name)

   457

    setattr(cls, "removepou", removepou)

   458

   459

    configurations_xpath = PLCOpen_XPath(

   460

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

   461

    def getconfigurations(self):

   462

        return configurations_xpath(self)

   463

    setattr(cls, "getconfigurations", getconfigurations)

   464

   465

    configuration_xpath = PLCOpen_XPath(

   466

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

   467

    def getconfiguration(self, name):

   468

        configurations = configuration_xpath(self, name=name)

   469

        if len(configurations) == 1:

   470

            return configurations[0]

   471

        return None

   472

    setattr(cls, "getconfiguration", getconfiguration)

   473

   474

    def addconfiguration(self, name):

   475

        if self.getconfiguration(name) is not None:

   476

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

   477

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

   478

        new_configuration.setname(name)

   479

        self.instances.configurations.appendconfiguration(new_configuration)

   480

    setattr(cls, "addconfiguration", addconfiguration)    

   481

   482

    def removeconfiguration(self, name):

   483

        configuration = self.getconfiguration(name)

   484

        if configuration is None:

   485

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

   486

        self.instances.configurations.remove(configuration)

   487

    setattr(cls, "removeconfiguration", removeconfiguration)

   488

   489

    resources_xpath = PLCOpen_XPath(

   490

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

   491

    def getconfigurationResource(self, config_name, name):

   492

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

   493

        if len(resources) == 1:

   494

            return resources[0]

   495

        return None

   496

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   497

   498

    def addconfigurationResource(self, config_name, name):

   499

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

   500

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

   501

        configuration = self.getconfiguration(config_name)

   502

        if configuration is not None:

   503

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

   504