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

    27

from types import *

    28

import os, re

    29

from lxml import etree

    30

from collections import OrderedDict

    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 LoadProject(filepath):

   162

    project_file = open(filepath)

   163

    project_xml = project_file.read().replace(

   164

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

   165

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

   166

    for cre, repl in [

   167

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

   168

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

   169

        project_xml = cre.sub(repl, project_xml)

   170

    project_file.close()

   171

   172

    return etree.fromstring(project_xml, PLCOpenParser)

   173

   174

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

   175

def LoadPou(xml_string):

   176

    root = etree.fromstring(

   177

        LOAD_POU_PROJECT_TEMPLATE % xml_string, 

   178

        PLCOpenParser)

   179

    return project_pou_xpath(root)[0]

   180

   181

project_pou_instances_xpath = {

   182

    body_type: PLCOpen_XPath(

   183

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

   184

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

   185

def LoadPouInstances(xml_string, body_type):

   186

    root = etree.fromstring(

   187

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string, 

   188

        PLCOpenParser)

   189

    return project_pou_instances_xpath[body_type](root)

   190

   191

def SaveProject(project, filepath):

   192

    project_file = open(filepath, 'w')

   193

    project_file.write(etree.tostring(

   194

        project, 

   195

        pretty_print=True, 

   196

        xml_declaration=True, 

   197

        encoding='utf-8'))

   198

    project_file.close()

   199

   200

cls = PLCOpenParser.GetElementClass("formattedText")

   201

if cls:

   202

    def updateElementName(self, old_name, new_name):

   203

        text = self.getanyText()

   204

        index = text.find(old_name)

   205

        while index != -1:

   206

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

   207

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

   208

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

   209

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

   210

            else:

   211

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

   212

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

   213

        self.setanyText(text)

   214

    setattr(cls, "updateElementName", updateElementName)

   215

   216

    def updateElementAddress(self, address_model, new_leading):

   217

        text = self.getanyText()

   218

        startpos = 0

   219

        result = address_model.search(text, startpos)

   220

        while result is not None:

   221

            groups = result.groups()

   222

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

   223

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

   224

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

   225

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

   226

        self.setanyText(text)

   227

    setattr(cls, "updateElementAddress", updateElementAddress)

   228

   229

    def hasblock(self, block_type):

   230

        text = self.getanyText().upper()

   231

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

   232

        while index != -1:

   233

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

   234

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

   235

                return True

   236

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

   237

        return False

   238

    setattr(cls, "hasblock", hasblock)

   239

   240

    def Search(self, criteria, parent_infos):

   241

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

   242

    setattr(cls, "Search", Search)

   243

   244

cls = PLCOpenParser.GetElementClass("project")

   245

if cls:

   246

   247

    def setname(self, name):

   248

        self.contentHeader.setname(name)

   249

    setattr(cls, "setname", setname)

   250

   251

    def getname(self):

   252

        return self.contentHeader.getname()

   253

    setattr(cls, "getname", getname)

   254

   255

    def getfileHeader(self):

   256

        fileheader_obj = self.fileHeader

   257

        return {

   258

            attr: value if value is not None else ""

   259

            for attr, value in [

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

        }

   268

    setattr(cls, "getfileHeader", getfileHeader)

   269

   270

    def setfileHeader(self, fileheader):

   271

        fileheader_obj = self.fileHeader

   272

        for attr, value in fileheader.iteritems():

   273

            setattr(fileheader_obj, attr, value)

   274

    setattr(cls, "setfileHeader", setfileHeader)

   275

   276

    def getcontentHeader(self):

   277

        contentheader_obj = self.contentHeader

   278

        contentheader = {

   279

            attr: value if value is not None else ""

   280

            for attr, value in [

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

        }

   288

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

   289

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

   290

        return contentheader

   291

    setattr(cls, "getcontentHeader", getcontentHeader)

   292

   293

    def setcontentHeader(self, contentheader):

   294

        contentheader_obj = self.contentHeader

   295

        for attr, value in contentheader.iteritems():

   296

            if attr == "projectName":

   297

                contentheader_obj.setname(value)

   298

            elif attr == "projectVersion":

   299

                contentheader_obj.setversion(value)

   300

            elif attr == "pageSize":

   301

                contentheader_obj.setpageSize(*contentheader["pageSize"])

   302

            elif attr == "scaling":

   303

                contentheader_obj.setscaling(contentheader["scaling"])

   304

            else:

   305

                setattr(contentheader_obj, attr, value)

   306

    setattr(cls, "setcontentHeader", setcontentHeader)

   307

   308

    def gettypeElementFunc(element_type):

   309

        elements_xpath = PLCOpen_XPath(

   310

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

   311

        def gettypeElement(self, name):

   312

            elements = elements_xpath(self, name=name)

   313

            if len(elements) == 1:

   314

                return elements[0]

   315

            return None

   316

        return gettypeElement

   317

   318

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

   319

    filtered_datatypes_xpath = PLCOpen_XPath(

   320

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

   321

    def getdataTypes(self, exclude=None):

   322

        if exclude is not None:

   323

            return filtered_datatypes_xpath(self, exclude=exclude)

   324

        return datatypes_xpath(self)

   325

    setattr(cls, "getdataTypes", getdataTypes)

   326

   327

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

   328

   329

    def appenddataType(self, name):

   330

        if self.getdataType(name) is not None:

   331

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

   332

        self.types.appenddataTypeElement(name)

   333

    setattr(cls, "appenddataType", appenddataType)

   334

   335

    def insertdataType(self, index, datatype):

   336

        self.types.insertdataTypeElement(index, datatype)

   337

    setattr(cls, "insertdataType", insertdataType)

   338

   339

    def removedataType(self, name):

   340

        self.types.removedataTypeElement(name)

   341

    setattr(cls, "removedataType", removedataType)

   342

   343

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

   344

        return self.xpath(

   345

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

   346

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

   347

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

   348

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

   349

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

   350

            namespaces=PLCOpenParser.NSMAP)

   351

    setattr(cls, "getpous", getpous)

   352

   353

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

   354

   355

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

   356

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

   357

    setattr(cls, "appendpou", appendpou)

   358

   359

    def insertpou(self, index, pou):

   360

        self.types.insertpouElement(index, pou)

   361

    setattr(cls, "insertpou", insertpou)

   362

   363

    def removepou(self, name):

   364

        self.types.removepouElement(name)

   365

    setattr(cls, "removepou", removepou)

   366

   367

    configurations_xpath = PLCOpen_XPath(

   368

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

   369

    def getconfigurations(self):

   370

        return configurations_xpath(self)

   371

    setattr(cls, "getconfigurations", getconfigurations)

   372

   373

    configuration_xpath = PLCOpen_XPath(

   374

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

   375

    def getconfiguration(self, name):

   376

        configurations = configuration_xpath(self, name=name)

   377

        if len(configurations) == 1:

   378

            return configurations[0]

   379

        return None

   380

    setattr(cls, "getconfiguration", getconfiguration)

   381

   382

    def addconfiguration(self, name):

   383

        if self.getconfiguration(name) is not None:

   384

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

   385

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

   386

        new_configuration.setname(name)

   387

        self.instances.configurations.appendconfiguration(new_configuration)

   388

    setattr(cls, "addconfiguration", addconfiguration)    

   389

   390

    def removeconfiguration(self, name):

   391

        configuration = self.getconfiguration(name)

   392

        if configuration is None:

   393

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

   394

        self.instances.configurations.remove(configuration)

   395

    setattr(cls, "removeconfiguration", removeconfiguration)

   396

   397

    resources_xpath = PLCOpen_XPath(

   398

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

   399

    def getconfigurationResource(self, config_name, name):

   400

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

   401

        if len(resources) == 1:

   402

            return resources[0]

   403

        return None

   404

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   405

   406

    def addconfigurationResource(self, config_name, name):

   407

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

   408

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

   409

        configuration = self.getconfiguration(config_name)

   410

        if configuration is not None:

   411

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

   412

            new_resource.setname(name)

   413

            configuration.appendresource(new_resource)

   414

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   415

   416

    def removeconfigurationResource(self, config_name, name):

   417

        configuration = self.getconfiguration(config_name)

   418

        found = False

   419

        if configuration is not None:

   420

            resource = self.getconfigurationResource(config_name, name)

   421

            if resource is not None:

   422

                configuration.remove(resource)

   423

                found = True

   424

        if not found:

   425

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

   426

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   427

   428

    def updateElementName(self, old_name, new_name):

   429

        for datatype in self.getdataTypes():

   430

            datatype.updateElementName(old_name, new_name)

   431

        for pou in self.getpous():

   432

            pou.updateElementName(old_name, new_name)

   433

        for configuration in self.getconfigurations():

   434

            configuration.updateElementName(old_name, new_name)

   435

    setattr(cls, "updateElementName", updateElementName)

   436

   437

    def updateElementAddress(self, old_leading, new_leading):

   438

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   439

        for pou in self.getpous():

   440

            pou.updateElementAddress(address_model, new_leading)

   441

        for configuration in self.getconfigurations():

   442

            configuration.updateElementAddress(address_model, new_leading)

   443

    setattr(cls, "updateElementAddress", updateElementAddress)

   444

   445

    def removeVariableByAddress(self, address):

   446

        for pou in self.getpous():

   447

            pou.removeVariableByAddress(address)

   448

        for configuration in self.getconfigurations():

   449

            configuration.removeVariableByAddress(address)

   450

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   451

   452

    def removeVariableByFilter(self, leading):

   453

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   454

        for pou in self.getpous():

   455

            pou.removeVariableByFilter(address_model)

   456

        for configuration in self.getconfigurations():

   457

            configuration.removeVariableByFilter(address_model)

   458

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   459

   460

    enumerated_values_xpath = PLCOpen_XPath(

   461

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

   462

    def GetEnumeratedDataTypeValues(self):

   463

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

   464

    setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues)

   465

   466

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

   467

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

   468

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

   469

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

   470

        return result

   471

    setattr(cls, "Search", Search)

   472

   473

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

   474

if cls:

   475

   476

    def setpageSize(self, width, height):

   477

        self.coordinateInfo.setpageSize(width, height)

   478

    setattr(cls, "setpageSize", setpageSize)

   479

   480

    def getpageSize(self):

   481

        return self.coordinateInfo.getpageSize()

   482

    setattr(cls, "getpageSize", getpageSize)

   483

   484

    def setscaling(self, scaling):

   485

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

   486

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

   487

    setattr(cls, "setscaling", setscaling)

   488

   489

    def getscaling(self):

   490

        scaling = {}

   491

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

   492

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

   493

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

   494

        return scaling

   495

    setattr(cls, "getscaling", getscaling)

   496

   497

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

   498

if cls:

   499

    def setpageSize(self, width, height):

   500

        if width == 0 and height == 0:

   501

            self.deletepageSize()

   502

        else:

   503

            if self.pageSize is None:

   504

                self.addpageSize()

   505

            self.pageSize.setx(width)

   506

            self.pageSize.sety(height)

   507

    setattr(cls, "setpageSize", setpageSize)

   508