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

   161

def LoadProjectXML(project_xml):

   162

    project_xml = project_xml.replace(

   163

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

   164

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

   165

    for cre, repl in [

   166

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

   167

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

   168

        project_xml = cre.sub(repl, project_xml)

   169

   170

    try:

   171

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   172

        if error is not None:

   173

            # TODO Validate file according to PLCOpen v1 and modify it for

   174

            # compatibility with PLCOpen v2

   175

            return tree, error

   176

        return tree, None

   177

    except Exception, e:

   178

        return None, e.message

   179

   180

def LoadProject(filepath):

   181

    project_file = open(filepath)

   182

    project_xml = project_file.read()

   183

    project_file.close()

   184

    return LoadProjectXML(project_xml)

   185

   186

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

   187

def LoadPou(xml_string):

   188

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   189

    return project_pou_xpath(root)[0], error

   190

   191

project_pou_instances_xpath = {

   192

    body_type: PLCOpen_XPath(

   193

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

   194

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

   195

def LoadPouInstances(xml_string, body_type):

   196

    root, error = LoadProjectXML(

   197

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   198

    return project_pou_instances_xpath[body_type](root), error

   199

   200

def SaveProject(project, filepath):

   201

    project_file = open(filepath, 'w')

   202

    project_file.write(etree.tostring(

   203

        project, 

   204

        pretty_print=True, 

   205

        xml_declaration=True, 

   206

        encoding='utf-8'))

   207

    project_file.close()

   208

   209

cls = PLCOpenParser.GetElementClass("formattedText")

   210

if cls:

   211

    def updateElementName(self, old_name, new_name):

   212

        text = self.getanyText()

   213

        index = text.find(old_name)

   214

        while index != -1:

   215

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

   216

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

   217

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

   218

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

   219

            else:

   220

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

   221

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

   222

        self.setanyText(text)

   223

    setattr(cls, "updateElementName", updateElementName)

   224

   225

    def updateElementAddress(self, address_model, new_leading):

   226

        text = self.getanyText()

   227

        startpos = 0

   228

        result = address_model.search(text, startpos)

   229

        while result is not None:

   230

            groups = result.groups()

   231

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

   232

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

   233

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

   234

            result = address_model.search(text, startpos)

   235

        self.setanyText(text)

   236

    setattr(cls, "updateElementAddress", updateElementAddress)

   237

   238

    def hasblock(self, block_type):

   239

        text = self.getanyText().upper()

   240

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

   241

        while index != -1:

   242

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

   243

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

   244

                return True

   245

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

   246

        return False

   247

    setattr(cls, "hasblock", hasblock)

   248

   249

    def Search(self, criteria, parent_infos):

   250

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

   251

    setattr(cls, "Search", Search)

   252

   253

cls = PLCOpenParser.GetElementClass("project")

   254

if cls:

   255

   256

    def setname(self, name):

   257

        self.contentHeader.setname(name)

   258

    setattr(cls, "setname", setname)

   259

   260

    def getname(self):

   261

        return self.contentHeader.getname()

   262

    setattr(cls, "getname", getname)

   263

   264

    def getfileHeader(self):

   265

        fileheader_obj = self.fileHeader

   266

        return {

   267

            attr: value if value is not None else ""

   268

            for attr, value in [

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

        }

   277

    setattr(cls, "getfileHeader", getfileHeader)

   278

   279

    def setfileHeader(self, fileheader):

   280

        fileheader_obj = self.fileHeader

   281

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

   282

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

   283

                     "contentDescription"]:

   284

            value = fileheader.get(attr)

   285

            if value is not None:

   286

                setattr(fileheader_obj, attr, value)

   287

    setattr(cls, "setfileHeader", setfileHeader)

   288

   289

    def getcontentHeader(self):

   290

        contentheader_obj = self.contentHeader

   291

        contentheader = {

   292

            attr: value if value is not None else ""

   293

            for attr, value in [

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

        }

   301

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

   302

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

   303

        return contentheader

   304

    setattr(cls, "getcontentHeader", getcontentHeader)

   305

   306

    def setcontentHeader(self, contentheader):

   307

        contentheader_obj = self.contentHeader

   308

        for attr, value in contentheader.iteritems():

   309

            func = {"projectName": contentheader_obj.setname,

   310

                    "projectVersion": contentheader_obj.setversion,

   311

                    "authorName": contentheader_obj.setauthor,

   312

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

   313

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

   314

            if func is not None:

   315

                func(value)

   316

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

   317

                setattr(contentheader_obj, attr, value)

   318

    setattr(cls, "setcontentHeader", setcontentHeader)

   319

   320

    def gettypeElementFunc(element_type):

   321

        elements_xpath = PLCOpen_XPath(

   322

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

   323

        def gettypeElement(self, name):

   324

            elements = elements_xpath(self, name=name)

   325

            if len(elements) == 1:

   326

                return elements[0]

   327

            return None

   328

        return gettypeElement

   329

   330

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

   331

    filtered_datatypes_xpath = PLCOpen_XPath(

   332

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

   333

    def getdataTypes(self, exclude=None):

   334

        if exclude is not None:

   335

            return filtered_datatypes_xpath(self, exclude=exclude)

   336

        return datatypes_xpath(self)

   337

    setattr(cls, "getdataTypes", getdataTypes)

   338

   339

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

   340

   341

    def appenddataType(self, name):

   342

        if self.getdataType(name) is not None:

   343

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

   344

        self.types.appenddataTypeElement(name)

   345

    setattr(cls, "appenddataType", appenddataType)

   346

   347

    def insertdataType(self, index, datatype):

   348

        self.types.insertdataTypeElement(index, datatype)

   349

    setattr(cls, "insertdataType", insertdataType)

   350

   351

    def removedataType(self, name):

   352

        self.types.removedataTypeElement(name)

   353

    setattr(cls, "removedataType", removedataType)

   354

   355

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

   356

        return self.xpath(

   357

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

   358

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

   359

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

   360

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

   361

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

   362

            namespaces=PLCOpenParser.NSMAP)

   363

    setattr(cls, "getpous", getpous)

   364

   365

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

   366

   367

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

   368

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

   369

    setattr(cls, "appendpou", appendpou)

   370

   371

    def insertpou(self, index, pou):

   372

        self.types.insertpouElement(index, pou)

   373

    setattr(cls, "insertpou", insertpou)

   374

   375

    def removepou(self, name):

   376

        self.types.removepouElement(name)

   377

    setattr(cls, "removepou", removepou)

   378

   379

    configurations_xpath = PLCOpen_XPath(

   380

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

   381

    def getconfigurations(self):

   382

        return configurations_xpath(self)

   383

    setattr(cls, "getconfigurations", getconfigurations)

   384

   385

    configuration_xpath = PLCOpen_XPath(

   386

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

   387

    def getconfiguration(self, name):

   388

        configurations = configuration_xpath(self, name=name)

   389

        if len(configurations) == 1:

   390

            return configurations[0]

   391

        return None

   392

    setattr(cls, "getconfiguration", getconfiguration)

   393

   394

    def addconfiguration(self, name):

   395

        if self.getconfiguration(name) is not None:

   396

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

   397

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

   398

        new_configuration.setname(name)

   399

        self.instances.configurations.appendconfiguration(new_configuration)

   400

    setattr(cls, "addconfiguration", addconfiguration)    

   401

   402

    def removeconfiguration(self, name):

   403

        configuration = self.getconfiguration(name)

   404

        if configuration is None:

   405

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

   406

        self.instances.configurations.remove(configuration)

   407

    setattr(cls, "removeconfiguration", removeconfiguration)

   408

   409

    resources_xpath = PLCOpen_XPath(

   410

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

   411

    def getconfigurationResource(self, config_name, name):

   412

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

   413

        if len(resources) == 1:

   414

            return resources[0]

   415

        return None

   416

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   417

   418

    def addconfigurationResource(self, config_name, name):

   419

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

   420

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

   421

        configuration = self.getconfiguration(config_name)

   422

        if configuration is not None:

   423

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

   424

            new_resource.setname(name)

   425

            configuration.appendresource(new_resource)

   426

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   427

   428

    def removeconfigurationResource(self, config_name, name):

   429

        configuration = self.getconfiguration(config_name)

   430

        found = False

   431

        if configuration is not None:

   432

            resource = self.getconfigurationResource(config_name, name)

   433

            if resource is not None:

   434

                configuration.remove(resource)

   435

                found = True

   436

        if not found:

   437

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

   438

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   439

   440

    def updateElementName(self, old_name, new_name):

   441

        for datatype in self.getdataTypes():

   442

            datatype.updateElementName(old_name, new_name)

   443

        for pou in self.getpous():

   444

            pou.updateElementName(old_name, new_name)

   445

        for configuration in self.getconfigurations():

   446

            configuration.updateElementName(old_name, new_name)

   447

    setattr(cls, "updateElementName", updateElementName)

   448

   449

    def updateElementAddress(self, old_leading, new_leading):

   450

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   451

        for pou in self.getpous():

   452

            pou.updateElementAddress(address_model, new_leading)

   453

        for configuration in self.getconfigurations():

   454

            configuration.updateElementAddress(address_model, new_leading)

   455

    setattr(cls, "updateElementAddress", updateElementAddress)

   456

   457

    def removeVariableByAddress(self, address):

   458

        for pou in self.getpous():

   459

            pou.removeVariableByAddress(address)

   460

        for configuration in self.getconfigurations():

   461

            configuration.removeVariableByAddress(address)

   462

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   463

   464

    def removeVariableByFilter(self, leading):

   465

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   466

        for pou in self.getpous():

   467

            pou.removeVariableByFilter(address_model)

   468

        for configuration in self.getconfigurations():

   469

            configuration.removeVariableByFilter(address_model)

   470

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   471

   472

    enumerated_values_xpath = PLCOpen_XPath(

   473

        "ppx:types/ppx:dataTypes/ppx:dataType/ppx:baseType/ppx:enum/ppx:values/ppx:value")

   474

    def GetEnumeratedDataTypeValues(self):

   475

        return [value.getname() for value in enumerated_values_xpath(self)]

   476

    setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues)

   477

   478

    def Search(self, criteria, parent_infos=[]):

   479

        result = self.types.Search(criteria, parent_infos)

   480

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

   481

            result.extend(configuration.Search(criteria, parent_infos))

   482

        return result

   483

    setattr(cls, "Search", Search)

   484

   485

cls = PLCOpenParser.GetElementClass("contentHeader", "project")

   486

if cls:

   487

   488

    def setpageSize(self, width, height):

   489

        self.coordinateInfo.setpageSize(width, height)

   490

    setattr(cls, "setpageSize", setpageSize)

   491

   492

    def getpageSize(self):

   493

        return self.coordinateInfo.getpageSize()

   494

    setattr(cls, "getpageSize", getpageSize)

   495

   496

    def setscaling(self, scaling):

   497

        for language, (x, y) in scaling.items():

   498

            self.coordinateInfo.setscaling(language, x, y)

   499

    setattr(cls, "setscaling", setscaling)

   500

   501

    def getscaling(self):

   502

        scaling = {}

   503

        scaling["FBD"] = self.coordinateInfo.getscaling("FBD")

   504

        scaling["LD"] = self.coordinateInfo.getscaling("LD")

   505

        scaling["SFC"] = self.coordinateInfo.getscaling("SFC")

   506

        return scaling

   507