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

   114

def TestTextElement(text, criteria):

   115

    lines = text.splitlines()

   116

    if not criteria["case_sensitive"]:

   117

        text = text.upper()

   118

    test_result = []

   119

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

   120

    while result is not None:

   121

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

   122

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

   123

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

   124

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

   125

    return test_result

   126

   127

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

   128

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

   129

   130

LOAD_POU_PROJECT_TEMPLATE = """

   131

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

   132

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

   133

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

   134

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

   135

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

   136

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

   137

  <contentHeader name="paste_project">

   138

    <coordinateInfo>

   139

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

   140

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

   141

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

   142

    </coordinateInfo>

   143

  </contentHeader>

   144

  <types>

   145

    <dataTypes/>

   146

    <pous>%s</pous>

   147

  </types>

   148

  <instances>

   149

    <configurations/>

   150

  </instances>

   151

</project>

   152

"""

   153

   154

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   155

    return LOAD_POU_PROJECT_TEMPLATE % """

   156

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

   157

  <body>

   158

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

   159

  </body>

   160

</pou>""" % locals()

   161

   162

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

   163

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   164

PLCOpen_v1_file.close()

   165

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   166

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

   167

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

   168

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

   169

   170

# XPath for file compatibility process

   171

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

   172

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

   173

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

   174

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   175

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

   176

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   177

   178

def LoadProjectXML(project_xml):

   179

    project_xml = project_xml.replace(

   180

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

   181

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

   182

    for cre, repl in [

   183

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

   184

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

   185

        project_xml = cre.sub(repl, project_xml)

   186

   187

    try:

   188

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   189

        if error is None:

   190

            return tree, None

   191

   192

        if PLCOpen_v1_xsd.validate(tree):

   193

            # Make file compatible with PLCOpen v2

   194

   195

            # Update resource interval value

   196

            for resource in ProjectResourcesXPath(tree):

   197

                for task in resource.gettask():

   198

                    interval = task.get("interval")

   199

                    if interval is not None:

   200

                        result = time_model.match(interval)

   201

                        if result is not None:

   202

                            values = result.groups()

   203

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

   204

                            seconds = float(values[2])

   205

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

   206

                            text = "T#"

   207

                            if time_values[0] != 0:

   208

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

   209

                            if time_values[1] != 0:

   210

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

   211

                            if time_values[2] != 0:

   212

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

   213

                            if time_values[3] != 0:

   214

                                if time_values[3] % 1000 != 0:

   215

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

   216

                                else:

   217

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

   218

                            task.set("interval", text)

   219

   220

                # Update resources pou instance attributes

   221

                for pouInstance in ResourceInstancesXpath(resource):

   222

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

   223

                    if type_name is not None:

   224

                        pouInstance.set("typeName", type_name)

   225

   226

            # Update transitions condition

   227

            for transition_condition in TransitionsConditionXPath(tree):

   228

                connections = ConditionConnectionsXPath(transition_condition)

   229

                if len(connections) > 0:

   230

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

   231

                    transition_condition.setcontent(connectionPointIn)

   232

                    connectionPointIn.setrelPositionXY(0, 0)

   233

                    for connection in connections:

   234

                        connectionPointIn.append(connection)

   235

   236

            # Update actionBlocks

   237

            for actionBlock in ActionBlocksXPath(tree):

   238

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   239

                    actionBlock.remove(connectionPointOut)

   240

   241

                for action in actionBlock.getaction():

   242

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

   243

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

   244

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

   245

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

   246

                    action.setrelPosition(relPosition)

   247

   248

            return tree, None

   249

   250

        return tree, error

   251

   252

    except Exception, e:

   253

        return None, e.message

   254

   255

def LoadProject(filepath):

   256

    project_file = open(filepath)

   257

    project_xml = project_file.read()

   258

    project_file.close()

   259

    return LoadProjectXML(project_xml)

   260

   261

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

   262

def LoadPou(xml_string):

   263

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   264

    return project_pou_xpath(root)[0], error

   265

   266

project_pou_instances_xpath = {

   267

    body_type: PLCOpen_XPath(

   268

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

   269

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

   270

def LoadPouInstances(xml_string, body_type):

   271

    root, error = LoadProjectXML(

   272

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   273

    return project_pou_instances_xpath[body_type](root), error

   274

   275

def SaveProject(project, filepath):

   276

    project_file = open(filepath, 'w')

   277

    project_file.write(etree.tostring(

   278

        project, 

   279

        pretty_print=True, 

   280

        xml_declaration=True, 

   281

        encoding='utf-8'))

   282

    project_file.close()

   283

   284

cls = PLCOpenParser.GetElementClass("formattedText")

   285

if cls:

   286

    def updateElementName(self, old_name, new_name):

   287

        text = self.getanyText()

   288

        index = text.find(old_name)

   289

        while index != -1:

   290

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

   291

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

   292

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

   293

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

   294

            else:

   295

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

   296

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

   297

        self.setanyText(text)

   298

    setattr(cls, "updateElementName", updateElementName)

   299

   300

    def updateElementAddress(self, address_model, new_leading):

   301

        text = self.getanyText()

   302

        startpos = 0

   303

        result = address_model.search(text, startpos)

   304

        while result is not None:

   305

            groups = result.groups()

   306

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

   307

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

   308

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

   309

            result = address_model.search(text, startpos)

   310

        self.setanyText(text)

   311

    setattr(cls, "updateElementAddress", updateElementAddress)

   312

   313

    def hasblock(self, block_type):

   314

        text = self.getanyText().upper()

   315

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

   316

        while index != -1:

   317

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

   318

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

   319

                return True

   320

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

   321

        return False

   322

    setattr(cls, "hasblock", hasblock)

   323

   324

    def Search(self, criteria, parent_infos):

   325

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

   326

    setattr(cls, "Search", Search)

   327

   328

cls = PLCOpenParser.GetElementClass("project")

   329

if cls:

   330

   331

    def setname(self, name):

   332

        self.contentHeader.setname(name)

   333

    setattr(cls, "setname", setname)

   334

   335

    def getname(self):

   336

        return self.contentHeader.getname()

   337

    setattr(cls, "getname", getname)

   338

   339

    def getfileHeader(self):

   340

        fileheader_obj = self.fileHeader

   341

        return {

   342

            attr: value if value is not None else ""

   343

            for attr, value in [

   344

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

   345

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

   346

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

   347

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

   348

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

   349

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

   350

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

   351

        }

   352

    setattr(cls, "getfileHeader", getfileHeader)

   353

   354

    def setfileHeader(self, fileheader):

   355

        fileheader_obj = self.fileHeader

   356

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

   357

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

   358

                     "contentDescription"]:

   359

            value = fileheader.get(attr)

   360

            if value is not None:

   361

                setattr(fileheader_obj, attr, value)

   362

    setattr(cls, "setfileHeader", setfileHeader)

   363

   364

    def getcontentHeader(self):

   365

        contentheader_obj = self.contentHeader

   366

        contentheader = {

   367

            attr: value if value is not None else ""

   368

            for attr, value in [

   369

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

   370

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

   371

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

   372

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

   373

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

   374

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

   375

        }

   376

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

   377

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

   378

        return contentheader

   379

    setattr(cls, "getcontentHeader", getcontentHeader)

   380

   381

    def setcontentHeader(self, contentheader):

   382

        contentheader_obj = self.contentHeader

   383

        for attr, value in contentheader.iteritems():

   384

            func = {"projectName": contentheader_obj.setname,

   385

                    "projectVersion": contentheader_obj.setversion,

   386

                    "authorName": contentheader_obj.setauthor,

   387

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

   388

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

   389

            if func is not None:

   390

                func(value)

   391

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

   392

                setattr(contentheader_obj, attr, value)

   393

    setattr(cls, "setcontentHeader", setcontentHeader)

   394

   395

    def gettypeElementFunc(element_type):

   396

        elements_xpath = PLCOpen_XPath(

   397

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

   398

        def gettypeElement(self, name):

   399

            elements = elements_xpath(self, name=name)

   400

            if len(elements) == 1:

   401

                return elements[0]

   402

            return None

   403

        return gettypeElement

   404

   405

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

   406

    filtered_datatypes_xpath = PLCOpen_XPath(

   407

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

   408

    def getdataTypes(self, exclude=None):

   409

        if exclude is not None:

   410

            return filtered_datatypes_xpath(self, exclude=exclude)

   411

        return datatypes_xpath(self)

   412

    setattr(cls, "getdataTypes", getdataTypes)

   413

   414

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

   415

   416

    def appenddataType(self, name):

   417

        if self.getdataType(name) is not None:

   418

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

   419

        self.types.appenddataTypeElement(name)

   420

    setattr(cls, "appenddataType", appenddataType)

   421

   422

    def insertdataType(self, index, datatype):

   423

        self.types.insertdataTypeElement(index, datatype)

   424

    setattr(cls, "insertdataType", insertdataType)

   425

   426

    def removedataType(self, name):

   427

        self.types.removedataTypeElement(name)

   428

    setattr(cls, "removedataType", removedataType)

   429

   430

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

   431

        return self.xpath(

   432

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

   433

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

   434

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

   435

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

   436

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

   437

            namespaces=PLCOpenParser.NSMAP)

   438

    setattr(cls, "getpous", getpous)

   439

   440

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

   441

   442

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

   443

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

   444

    setattr(cls, "appendpou", appendpou)

   445

   446

    def insertpou(self, index, pou):

   447

        self.types.insertpouElement(index, pou)

   448

    setattr(cls, "insertpou", insertpou)

   449

   450

    def removepou(self, name):

   451

        self.types.removepouElement(name)

   452

    setattr(cls, "removepou", removepou)

   453

   454

    configurations_xpath = PLCOpen_XPath(

   455

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

   456

    def getconfigurations(self):

   457

        return configurations_xpath(self)

   458

    setattr(cls, "getconfigurations", getconfigurations)

   459

   460

    configuration_xpath = PLCOpen_XPath(

   461

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

   462

    def getconfiguration(self, name):

   463

        configurations = configuration_xpath(self, name=name)

   464

        if len(configurations) == 1:

   465

            return configurations[0]

   466

        return None

   467

    setattr(cls, "getconfiguration", getconfiguration)

   468

   469

    def addconfiguration(self, name):

   470

        if self.getconfiguration(name) is not None:

   471

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

   472

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

   473

        new_configuration.setname(name)

   474

        self.instances.configurations.appendconfiguration(new_configuration)

   475

    setattr(cls, "addconfiguration", addconfiguration)    

   476

   477

    def removeconfiguration(self, name):

   478

        configuration = self.getconfiguration(name)

   479

        if configuration is None:

   480

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

   481

        self.instances.configurations.remove(configuration)

   482

    setattr(cls, "removeconfiguration", removeconfiguration)

   483

   484

    resources_xpath = PLCOpen_XPath(

   485

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

   486

    def getconfigurationResource(self, config_name, name):

   487

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

   488

        if len(resources) == 1:

   489

            return resources[0]

   490

        return None

   491

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   492

   493

    def addconfigurationResource(self, config_name, name):

   494

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

   495

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

   496

        configuration = self.getconfiguration(config_name)

   497

        if configuration is not None:

   498

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

   499

            new_resource.setname(name)

   500

            configuration.appendresource(new_resource)

   501

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   502

   503

    def removeconfigurationResource(self, config_name, name):

   504

        configuration = self.getconfiguration(config_name)