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

   128

LOAD_POU_PROJECT_TEMPLATE = """

   129

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

   130

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

   131

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

   132

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

   133

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

   134

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

   135

  <contentHeader name="paste_project">

   136

    <coordinateInfo>

   137

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

   138

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

   139

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

   140

    </coordinateInfo>

   141

  </contentHeader>

   142

  <types>

   143

    <dataTypes/>

   144

    <pous>%s</pous>

   145

  </types>

   146

  <instances>

   147

    <configurations/>

   148

  </instances>

   149

</project>

   150

"""

   151

   152

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   153

    return LOAD_POU_PROJECT_TEMPLATE % """

   154

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

   155

  <body>

   156

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

   157

  </body>

   158

</pou>""" % locals()

   159

   160

def LoadProject(filepath):

   161

    project_file = open(filepath)

   162

    project_xml = project_file.read().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

    project_file.close()

   170

   171

    return etree.fromstring(project_xml, PLCOpenParser)

   172

   173

def LoadPou(xml_string):

   174

    root = etree.fromstring(

   175

        LOAD_POU_PROJECT_TEMPLATE % xml_string, 

   176

        PLCOpenParser)

   177

    return root.xpath(

   178

        "/ppx:project/ppx:types/ppx:pous/ppx:pou",

   179

        namespaces=PLCOpenParser.NSMAP)[0]

   180

   181

def LoadPouInstances(xml_string, body_type):

   182

    root = etree.fromstring(

   183

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string, 

   184

        PLCOpenParser)

   185

    return root.xpath(

   186

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

   187

        namespaces=PLCOpenParser.NSMAP)

   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, value in fileheader.iteritems():

   271

            setattr(fileheader_obj, attr, value)

   272

    setattr(cls, "setfileHeader", setfileHeader)

   273

   274

    def getcontentHeader(self):

   275

        contentheader_obj = self.contentHeader

   276

        contentheader = {

   277

            attr: value if value is not None else ""

   278

            for attr, value in [

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

        }

   286

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

   287

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

   288

        return contentheader

   289

    setattr(cls, "getcontentHeader", getcontentHeader)

   290

   291

    def setcontentHeader(self, contentheader):

   292

        contentheader_obj = self.contentHeader

   293

        for attr, value in contentheader.iteritems():

   294

            if attr == "projectName":

   295

                contentheader_obj.setname(value)

   296

            elif attr == "projectVersion":

   297

                contentheader_obj.setversion(value)

   298

            elif attr == "pageSize":

   299

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

   300

            elif attr == "scaling":

   301

                contentheader_obj.setscaling(contentheader["scaling"])

   302

            else:

   303

                setattr(contentheader_obj, attr, value)

   304

    setattr(cls, "setcontentHeader", setcontentHeader)

   305

   310

        if name is None:

   311

            return elements

   312

        elif len(elements) == 1:

   313

            return elements[0]

   314

        return None

   315

    setattr(cls, "gettypeElement", gettypeElement)

   316

   322

    setattr(cls, "getdataTypes", getdataTypes)

   323

   325

        return self.gettypeElement("dataType", name)

   326

    setattr(cls, "getdataType", getdataType)

   327

   328

    def appenddataType(self, name):

   329

        if self.getdataType(name) is not None:

   330

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

   331

        self.types.appenddataTypeElement(name)

   332

    setattr(cls, "appenddataType", appenddataType)

   333

   334

    def insertdataType(self, index, datatype):

   335

        self.types.insertdataTypeElement(index, datatype)

   336

    setattr(cls, "insertdataType", insertdataType)

   337

   338

    def removedataType(self, name):

   339

        self.types.removedataTypeElement(name)

   340

    setattr(cls, "removedataType", removedataType)

   341

   350

    setattr(cls, "getpous", getpous)

   351

   353

        return self.gettypeElement("pou", name)

   354

    setattr(cls, "getpou", getpou)

   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

    def getconfigurations(self):

   369

        return self.getconfiguration()

   370

    setattr(cls, "getconfigurations", getconfigurations)

   371

   372

    def getconfiguration(self, name=None):

   373

        configurations = self.xpath(

   374

            "ppx:instances/ppx:configurations/ppx:configuration%s" %

   375

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

   376

            namespaces=PLCOpenParser.NSMAP)

   377

        if name is None:

   378

            return configurations

   379

        elif len(configurations) == 1:

   380

            return configurations[0]

   381

        return None

   382

    setattr(cls, "getconfiguration", getconfiguration)

   383

   384

    def addconfiguration(self, name):

   385

        if self.getconfiguration(name) is not None:

   386

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

   387

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

   388

        new_configuration.setname(name)

   389

        self.instances.configurations.appendconfiguration(new_configuration)

   390

    setattr(cls, "addconfiguration", addconfiguration)    

   391

   392

    def removeconfiguration(self, name):

   393

        configuration = self.getconfiguration(name)

   394

        if configuration is None:

   395

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

   396

        self.instances.configurations.remove(configuration)

   397

    setattr(cls, "removeconfiguration", removeconfiguration)

   398

   399

    def getconfigurationResource(self, config_name, name):

   400

        resources = self.xpath(

   401

            "ppx:instances/ppx:configurations/ppx:configuration[@name='%s']/ppx:resource[@name='%s']" % 

   402

            (config_name, name),

   403

            namespaces=PLCOpenParser.NSMAP)

   404

        if len(resources) == 1:

   405

            return resources[0]

   406

        return None

   407

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   408

   409

    def addconfigurationResource(self, config_name, name):

   410

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

   411

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

   412

        configuration = self.getconfiguration(config_name)

   413

        if configuration is not None:

   414

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

   415

            new_resource.setname(name)

   416

            configuration.appendresource(new_resource)

   417

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   418

   419

    def removeconfigurationResource(self, config_name, name):

   420

        configuration = self.getconfiguration(config_name)

   421

        found = False

   422

        if configuration is not None:

   423

            resource = self.getconfigurationResource(config_name, name)

   424

            if resource is not None:

   425

                configuration.remove(resource)

   426

                found = True

   427

        if not found:

   428

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

   429

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   430

   431

    def updateElementName(self, old_name, new_name):

   432

        for datatype in self.getdataTypes():

   433

            datatype.updateElementName(old_name, new_name)

   434

        for pou in self.getpous():

   435

            pou.updateElementName(old_name, new_name)

   436

        for configuration in self.getconfigurations():

   437

            configuration.updateElementName(old_name, new_name)

   438

    setattr(cls, "updateElementName", updateElementName)

   439

   440

    def updateElementAddress(self, old_leading, new_leading):

   441

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   442

        for pou in self.getpous():

   443

            pou.updateElementAddress(address_model, new_leading)

   444

        for configuration in self.getconfigurations():

   445

            configuration.updateElementAddress(address_model, new_leading)

   446

    setattr(cls, "updateElementAddress", updateElementAddress)

   447

   448

    def removeVariableByAddress(self, address):

   449

        for pou in self.getpous():

   450

            pou.removeVariableByAddress(address)

   451

        for configuration in self.getconfigurations():

   452

            configuration.removeVariableByAddress(address)

   453

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   454

   455

    def removeVariableByFilter(self, leading):

   456

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   457

        for pou in self.getpous():

   458

            pou.removeVariableByFilter(address_model)

   459

        for configuration in self.getconfigurations():

   460

            configuration.removeVariableByFilter(address_model)

   461

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   462

   463

    def GetEnumeratedDataTypeValues(self):

   464

        return [

   465

            value.getname() 

   466

            for value in self.xpath(

   467

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

   468

                namespaces=PLCOpenParser.NSMAP)]

   469

    setattr(cls, "GetEnumeratedDataTypeValues", GetEnumeratedDataTypeValues)

   470

   471

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

   472

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

   473

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

   474

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

   475

        return result

   476

    setattr(cls, "Search", Search)

   477

   478

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

   479

if cls:

   480

   481

    def setpageSize(self, width, height):

   482

        self.coordinateInfo.setpageSize(width, height)

   483

    setattr(cls, "setpageSize", setpageSize)

   484

   485

    def getpageSize(self):

   486

        return self.coordinateInfo.getpageSize()

   487

    setattr(cls, "getpageSize", getpageSize)

   488

   489

    def setscaling(self, scaling):

   490

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

   491

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

   492

    setattr(cls, "setscaling", setscaling)

   493

   494

    def getscaling(self):

   495

        scaling = {}

   496

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

   497

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

   498

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

   499

        return scaling

   500

    setattr(cls, "getscaling", getscaling)

   501

   502

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

   503

if cls:

   504

    def setpageSize(self, width, height):

   505

        if width == 0 and height == 0:

   506

            self.deletepageSize()

   507

        else:

   508

            if self.pageSize is None:

   509

                self.addpageSize()