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

"""

    30

Dictionary that makes the relation between var names in plcopen and displayed values

    31

"""

    32

VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",

    33

            "Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars",

    34

            "Global" : "globalVars", "Access" : "accessVars"}

    35

    36

searchResultVarTypes = {

    37

    "inputVars": "var_input",

    38

    "outputVars": "var_output",

    39

    "inOutVars": "var_inout"

    40

}

    41

    42

"""

    43

Define in which order var types must be displayed

    44

"""

    45

VarOrder = ["Local","Temp","Input","Output","InOut","External","Global","Access"]

    46

    47

"""

    48

Define which action qualifier must be associated with a duration 

    49

"""

    50

QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, 

    51

    "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True}

    52

    53

    54

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

    55

    56

def update_address(address, address_model, new_leading):

    57

    result = address_model.match(address)

    58

    if result is None:

    59

        return address

    60

    groups = result.groups()

    61

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

    62

    63

def _init_and_compare(function, v1, v2):

    64

    if v1 is None:

    65

        return v2

    66

    if v2 is not None:

    67

        return function(v1, v2)

    68

    return v1

    69

    70

"""

    71

Helper class for bounding_box calculation 

    72

"""

    73

class rect:

    74

    75

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

    76

        self.x_min = x

    77

        self.x_max = None

    78

        self.y_min = y

    79

        self.y_max = None

    80

        if width is not None and x is not None:

    81

            self.x_max = x + width

    82

        if height is not None and y is not None:

    83

            self.y_max = y + height

    84

    85

    def update(self, x, y):

    86

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

    87

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

    88

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

    89

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

    90

    91

    def union(self, rect):

    92

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

    93

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

    94

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

    95

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

    96

    97

    def bounding_box(self):

    98

        width = height = None

    99

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

   100

            width = self.x_max - self.x_min

   101

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

   102

            height = self.y_max - self.y_min

   103

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

   104

   105

def TextLenInRowColumn(text):

   106

    if text == "":

   107

        return (0, 0)

   108

    lines = text.split("\n")

   109

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

   110

   111

def TestTextElement(text, criteria):

   112

    lines = text.splitlines()

   113

    if not criteria["case_sensitive"]:

   114

        text = text.upper()

   115

    test_result = []

   116

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

   117

    while result is not None:

   118

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

   119

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

   120

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

   121

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

   122

    return test_result

   123

   124

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

   125

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

   126

   127

LOAD_POU_PROJECT_TEMPLATE = """

   128

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

   129

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

   130

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

   131

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

   132

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

   133

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

   134

  <contentHeader name="paste_project">

   135

    <coordinateInfo>

   136

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

   137

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

   138

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

   139

    </coordinateInfo>

   140

  </contentHeader>

   141

  <types>

   142

    <dataTypes/>

   143

    <pous>%s</pous>

   144

  </types>

   145

  <instances>

   146

    <configurations/>

   147

  </instances>

   148

</project>

   149

"""

   150

   151

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   152

    return LOAD_POU_PROJECT_TEMPLATE % """

   153

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

   154

  <body>

   155

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

   156

  </body>

   157

</pou>""" % locals()

   158

   159

def LoadProject(filepath):

   160

    project_file = open(filepath)

   161

    project_xml = project_file.read().replace(

   162

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

   163

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

   164

    for cre, repl in [

   165

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

   166

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

   167

        project_xml = cre.sub(repl, project_xml)

   168

    project_file.close()

   169

   170

    return etree.fromstring(project_xml, PLCOpenParser)

   171

   172

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

   173

def LoadPou(xml_string):

   174

    root = etree.fromstring(

   175

        LOAD_POU_PROJECT_TEMPLATE % xml_string, 

   176

        PLCOpenParser)

   177

    return project_pou_xpath(root)[0]

   178

   179

project_pou_instances_xpath = {

   180

    body_type: PLCOpen_XPath(

   181

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

   182

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

   183

def LoadPouInstances(xml_string, body_type):

   184

    root = etree.fromstring(

   185

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string, 

   186

        PLCOpenParser)

   187

    return project_pou_instances_xpath[body_type](root)

   188

   189

def SaveProject(project, filepath):

   190

    project_file = open(filepath, 'w')

   191

    project_file.write(etree.tostring(

   192

        project, 

   193

        pretty_print=True, 

   194

        xml_declaration=True, 

   195

        encoding='utf-8'))

   196

    project_file.close()

   197

   198

cls = PLCOpenParser.GetElementClass("formattedText")

   199

if cls:

   200

    def updateElementName(self, old_name, new_name):

   201

        text = self.getanyText()

   202

        index = text.find(old_name)

   203

        while index != -1:

   204

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

   205

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

   206

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

   207

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

   208

            else:

   209

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

   210

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

   211

        self.setanyText(text)

   212

    setattr(cls, "updateElementName", updateElementName)

   213

   214

    def updateElementAddress(self, address_model, new_leading):

   215

        text = self.getanyText()

   216

        startpos = 0

   217

        result = address_model.search(text, startpos)

   218

        while result is not None:

   219

            groups = result.groups()

   220

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

   221

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

   222

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

   223

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

   224

        self.setanyText(text)

   225

    setattr(cls, "updateElementAddress", updateElementAddress)

   226

   227

    def hasblock(self, block_type):

   228

        text = self.getanyText().upper()

   229

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

   230

        while index != -1:

   231

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

   232

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

   233

                return True

   234

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

   235

        return False

   236

    setattr(cls, "hasblock", hasblock)

   237

   238

    def Search(self, criteria, parent_infos):

   239

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

   240

    setattr(cls, "Search", Search)

   241

   242

cls = PLCOpenParser.GetElementClass("project")

   243

if cls:

   244

   245

    def setname(self, name):

   246

        self.contentHeader.setname(name)

   247

    setattr(cls, "setname", setname)

   248

   249

    def getname(self):

   250

        return self.contentHeader.getname()

   251

    setattr(cls, "getname", getname)

   252

   253

    def getfileHeader(self):

   254

        fileheader_obj = self.fileHeader

   255

        return {

   256

            attr: value if value is not None else ""

   257

            for attr, value in [

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

        }

   266

    setattr(cls, "getfileHeader", getfileHeader)

   267

   268

    def setfileHeader(self, fileheader):

   269

        fileheader_obj = self.fileHeader

   270

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

   271

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

   272

                     "contentDescription"]:

   273

            value = fileheader.get(attr)

   274

            if value is not None:

   275

                setattr(fileheader_obj, attr, value)

   276

    setattr(cls, "setfileHeader", setfileHeader)

   277

   278

    def getcontentHeader(self):

   279

        contentheader_obj = self.contentHeader

   280

        contentheader = {

   281

            attr: value if value is not None else ""

   282

            for attr, value in [

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

        }

   290

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

   291

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

   292

        return contentheader

   293

    setattr(cls, "getcontentHeader", getcontentHeader)

   294

   295

    def setcontentHeader(self, contentheader):

   296

        contentheader_obj = self.contentHeader

   297

        for attr, value in contentheader.iteritems():

   298

            func = {"projectName": contentheader_obj.setname,

   299

                    "projectVersion": contentheader_obj.setversion,

   300

                    "authorName": contentheader_obj.setauthor,

   301

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

   302

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

   303

            if func is not None:

   304

                func(value)

   305

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

   306

                setattr(contentheader_obj, attr, value)

   307

    setattr(cls, "setcontentHeader", setcontentHeader)

   308

   309

    def gettypeElementFunc(element_type):

   310

        elements_xpath = PLCOpen_XPath(

   311

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

   312

        def gettypeElement(self, name):

   313

            elements = elements_xpath(self, name=name)

   314

            if len(elements) == 1:

   315

                return elements[0]

   316

            return None

   317

        return gettypeElement

   318

   319

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

   320

    filtered_datatypes_xpath = PLCOpen_XPath(

   321

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

   322

    def getdataTypes(self, exclude=None):

   323

        if exclude is not None:

   324

            return filtered_datatypes_xpath(self, exclude=exclude)

   325

        return datatypes_xpath(self)

   326

    setattr(cls, "getdataTypes", getdataTypes)

   327

   328

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

   329

   330

    def appenddataType(self, name):

   331

        if self.getdataType(name) is not None:

   332

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

   333

        self.types.appenddataTypeElement(name)

   334

    setattr(cls, "appenddataType", appenddataType)

   335

   336

    def insertdataType(self, index, datatype):

   337

        self.types.insertdataTypeElement(index, datatype)

   338

    setattr(cls, "insertdataType", insertdataType)

   339

   340

    def removedataType(self, name):

   341

        self.types.removedataTypeElement(name)

   342

    setattr(cls, "removedataType", removedataType)

   343

   344

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

   345

        return self.xpath(

   346

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

   347

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

   348

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

   349

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

   350

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

   351

            namespaces=PLCOpenParser.NSMAP)

   352

    setattr(cls, "getpous", getpous)

   353

   354

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

   355

   356

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

   357

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

   358

    setattr(cls, "appendpou", appendpou)

   359

   360

    def insertpou(self, index, pou):

   361

        self.types.insertpouElement(index, pou)

   362

    setattr(cls, "insertpou", insertpou)

   363

   364

    def removepou(self, name):

   365

        self.types.removepouElement(name)

   366

    setattr(cls, "removepou", removepou)

   367

   368

    configurations_xpath = PLCOpen_XPath(

   369

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

   370

    def getconfigurations(self):

   371

        return configurations_xpath(self)

   372

    setattr(cls, "getconfigurations", getconfigurations)

   373

   374

    configuration_xpath = PLCOpen_XPath(

   375

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

   376

    def getconfiguration(self, name):

   377

        configurations = configuration_xpath(self, name=name)

   378

        if len(configurations) == 1:

   379

            return configurations[0]

   380

        return None

   381

    setattr(cls, "getconfiguration", getconfiguration)

   382

   383

    def addconfiguration(self, name):

   384

        if self.getconfiguration(name) is not None:

   385

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

   386

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

   387

        new_configuration.setname(name)

   388

        self.instances.configurations.appendconfiguration(new_configuration)

   389

    setattr(cls, "addconfiguration", addconfiguration)    

   390

   391

    def removeconfiguration(self, name):

   392

        configuration = self.getconfiguration(name)

   393

        if configuration is None:

   394

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

   395

        self.instances.configurations.remove(configuration)

   396

    setattr(cls, "removeconfiguration", removeconfiguration)

   397

   398

    resources_xpath = PLCOpen_XPath(

   399

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

   400

    def getconfigurationResource(self, config_name, name):

   401

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

   402

        if len(resources) == 1:

   403

            return resources[0]

   404

        return None

   405

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   406

   407

    def addconfigurationResource(self, config_name, name):

   408

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

   409

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

   410

        configuration = self.getconfiguration(config_name)

   411

        if configuration is not None:

   412

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

   413

            new_resource.setname(name)

   414

            configuration.appendresource(new_resource)

   415

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   416

   417

    def removeconfigurationResource(self, config_name, name):

   418

        configuration = self.getconfiguration(config_name)

   419

        found = False

   420

        if configuration is not None:

   421

            resource = self.getconfigurationResource(config_name, name)

   422

            if resource is not None:

   423

                configuration.remove(resource)

   424

                found = True

   425

        if not found:

   426

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

   427

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   428

   429

    def updateElementName(self, old_name, new_name):

   430

        for datatype in self.getdataTypes():

   431

            datatype.updateElementName(old_name, new_name)

   432

        for pou in self.getpous():

   433

            pou.updateElementName(old_name, new_name)

   434

        for configuration in self.getconfigurations():

   435

            configuration.updateElementName(old_name, new_name)

   436

    setattr(cls, "updateElementName", updateElementName)

   437

   438

    def updateElementAddress(self, old_leading, new_leading):

   439

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   440

        for pou in self.getpous():

   441

            pou.updateElementAddress(address_model, new_leading)

   442

        for configuration in self.getconfigurations():

   443

            configuration.updateElementAddress(address_model, new_leading)

   444

    setattr(cls, "updateElementAddress", updateElementAddress)

   445

   446

    def removeVariableByAddress(self, address):

   447

        for pou in self.getpous():

   448

            pou.removeVariableByAddress(address)

   449

        for configuration in self.getconfigurations():

   450

            configuration.removeVariableByAddress(address)

   451

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   452

   453

    def removeVariableByFilter(self, leading):

   454

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   455

        for pou in self.getpous():

   456

            pou.removeVariableByFilter(address_model)

   457

        for configuration in self.getconfigurations():

   458

            configuration.removeVariableByFilter(address_model)

   459

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   460

   461

    enumerated_values_xpath = PLCOpen_XPath(

   462

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

   463

    def GetEnumeratedDataTypeValues(self):

   464

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

   465

    setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues)

   466

   467

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

   468

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

   469

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

   470

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

   471

        return result

   472

    setattr(cls, "Search", Search)

   473

   474

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

   475

if cls:

   476

   477

    def setpageSize(self, width, height):

   478

        self.coordinateInfo.setpageSize(width, height)

   479

    setattr(cls, "setpageSize", setpageSize)

   480

   481

    def getpageSize(self):

   482

        return self.coordinateInfo.getpageSize()

   483

    setattr(cls, "getpageSize", getpageSize)

   484

   485

    def setscaling(self, scaling):

   486

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

   487

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

   488

    setattr(cls, "setscaling", setscaling)

   489

   490

    def getscaling(self):

   491

        scaling = {}

   492

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

   493

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

   494

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

   495

        return scaling

   496

    setattr(cls, "getscaling", getscaling)

   497

   498

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

   499

if cls:

   500

    def setpageSize(self, width, height):

   501

        if width == 0 and height == 0:

   502

            self.deletepageSize()

   503

        else:

   504

            if self.pageSize is None:

   505

                self.addpageSize()

   506

            self.pageSize.setx(width)

   507

            self.pageSize.sety(height)

   508