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

    cls.EnumeratedDataTypeValues = {}

   245

    cls.CustomDataTypeRange = {}

   246

    cls.CustomTypeHierarchy = {}

   247

    cls.ElementUsingTree = {}

   248

    cls.CustomBlockTypes = OrderedDict()

   249

   250

    def setname(self, name):

   251

        self.contentHeader.setname(name)

   252

    setattr(cls, "setname", setname)

   253

   254

    def getname(self):

   255

        return self.contentHeader.getname()

   256

    setattr(cls, "getname", getname)

   257

   258

    def getfileHeader(self):

   259

        fileheader = {}

   260

        for name, value in [("companyName", self.fileHeader.getcompanyName()),

   261

                            ("companyURL", self.fileHeader.getcompanyURL()),

   262

                            ("productName", self.fileHeader.getproductName()),

   263

                            ("productVersion", self.fileHeader.getproductVersion()),

   264

                            ("productRelease", self.fileHeader.getproductRelease()),

   265

                            ("creationDateTime", self.fileHeader.getcreationDateTime()),

   266

                            ("contentDescription", self.fileHeader.getcontentDescription())]:

   267

            if value is not None:

   268

                fileheader[name] = value

   269

            else:

   270

                fileheader[name] = ""

   271

        return fileheader

   272

    setattr(cls, "getfileHeader", getfileHeader)

   273

   274

    def setfileHeader(self, fileheader):

   275

        if fileheader.has_key("companyName"):

   276

            self.fileHeader.setcompanyName(fileheader["companyName"])

   277

        if fileheader.has_key("companyURL"):

   278

            self.fileHeader.setcompanyURL(fileheader["companyURL"])

   279

        if fileheader.has_key("productName"):

   280

            self.fileHeader.setproductName(fileheader["productName"])

   281

        if fileheader.has_key("productVersion"):

   282

            self.fileHeader.setproductVersion(fileheader["productVersion"])

   283

        if fileheader.has_key("productRelease"):

   284

            self.fileHeader.setproductRelease(fileheader["productRelease"])

   285

        if fileheader.has_key("creationDateTime"):

   286

            self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])

   287

        if fileheader.has_key("contentDescription"):

   288

            self.fileHeader.setcontentDescription(fileheader["contentDescription"])

   289

    setattr(cls, "setfileHeader", setfileHeader)

   290

   291

    def getcontentHeader(self):

   292

        contentheader = {}

   293

        for name, value in [("projectName", self.contentHeader.getname()),

   294

                            ("projectVersion", self.contentHeader.getversion()),

   295

                            ("modificationDateTime", self.contentHeader.getmodificationDateTime()),

   296

                            ("organization", self.contentHeader.getorganization()),

   297

                            ("authorName", self.contentHeader.getauthor()),

   298

                            ("language", self.contentHeader.getlanguage())]:

   299

            if value is not None:

   300

                contentheader[name] = value

   301

            else:

   302

                contentheader[name] = ""

   303

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

   304

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

   305

        return contentheader

   306

    setattr(cls, "getcontentHeader", getcontentHeader)

   307

   308

    def setcontentHeader(self, contentheader):

   309

        if contentheader.has_key("projectName"):

   310

            self.contentHeader.setname(contentheader["projectName"])

   311

        if contentheader.has_key("projectVersion"):

   312

            self.contentHeader.setversion(contentheader["projectVersion"])

   313

        if contentheader.has_key("modificationDateTime"):

   314

            self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])

   315

        if contentheader.has_key("organization"):

   316

            self.contentHeader.setorganization(contentheader["organization"])

   317

        if contentheader.has_key("authorName"):

   318

            self.contentHeader.setauthor(contentheader["authorName"])

   319

        if contentheader.has_key("language"):

   320

            self.contentHeader.setlanguage(contentheader["language"])

   321

        if contentheader.has_key("pageSize"):

   322

            self.contentHeader.setpageSize(*contentheader["pageSize"])

   323

        if contentheader.has_key("scaling"):

   324

            self.contentHeader.setscaling(contentheader["scaling"])

   325

    setattr(cls, "setcontentHeader", setcontentHeader)

   326

   327

    def getdataTypes(self):

   328

        return self.types.getdataTypeElements()

   329

    setattr(cls, "getdataTypes", getdataTypes)

   330

   331

    def getdataType(self, name):

   332

        return self.types.getdataTypeElement(name)

   333

    setattr(cls, "getdataType", getdataType)

   334

   335

    def appenddataType(self, name):

   336

        if self.CustomTypeHierarchy.has_key(name):

   337

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

   338

        self.types.appenddataTypeElement(name)

   339

        self.AddCustomDataType(self.getdataType(name))

   340

    setattr(cls, "appenddataType", appenddataType)

   341

   342

    def insertdataType(self, index, datatype):

   343

        self.types.insertdataTypeElement(index, datatype)

   344

        self.AddCustomDataType(datatype)

   345

    setattr(cls, "insertdataType", insertdataType)

   346

   347

    def removedataType(self, name):

   348

        self.types.removedataTypeElement(name)

   349

        self.RefreshDataTypeHierarchy()

   350

        self.RefreshElementUsingTree()

   351

    setattr(cls, "removedataType", removedataType)

   352

   353

    def getpous(self):

   354

        return self.types.getpouElements()

   355

    setattr(cls, "getpous", getpous)

   356

   357

    def getpou(self, name):

   358

        return self.types.getpouElement(name)

   359

    setattr(cls, "getpou", getpou)

   360

   361

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

   362

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

   363

        self.AddCustomBlockType(self.getpou(name))

   364

    setattr(cls, "appendpou", appendpou)

   365

   366

    def insertpou(self, index, pou):

   367

        self.types.insertpouElement(index, pou)

   368

        self.AddCustomBlockType(pou)

   369

    setattr(cls, "insertpou", insertpou)

   370

   371

    def removepou(self, name):

   372

        self.types.removepouElement(name)

   373

        self.RefreshCustomBlockTypes()

   374

        self.RefreshElementUsingTree()

   375

    setattr(cls, "removepou", removepou)

   376

   377

    def getconfigurations(self):

   378

        configurations = self.instances.configurations.getconfiguration()

   379

        if configurations is not None:

   380

            return configurations

   381

        return []

   382

    setattr(cls, "getconfigurations", getconfigurations)

   383

   384

    def getconfiguration(self, name):

   385

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

   386

            if configuration.getname() == name:

   387

                return configuration

   388

        return None

   389

    setattr(cls, "getconfiguration", getconfiguration)

   390

   391

    def addconfiguration(self, name):

   392

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

   393

            if configuration.getname() == name:

   394

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

   395

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

   396

        new_configuration.setname(name)

   397

        self.instances.configurations.appendconfiguration(new_configuration)

   398

    setattr(cls, "addconfiguration", addconfiguration)    

   399

   400

    def removeconfiguration(self, name):

   401

        found = False

   402

        for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):

   403

            if configuration.getname() == name:

   404

                self.instances.configurations.removeconfiguration(idx)

   405

                found = True

   406

                break

   407

        if not found:

   408

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

   409

    setattr(cls, "removeconfiguration", removeconfiguration)

   410

   411

    def getconfigurationResource(self, config_name, name):

   412

        configuration = self.getconfiguration(config_name)

   413

        if configuration is not None:

   414

            for resource in configuration.getresource():

   415

                if resource.getname() == name:

   416

                    return resource

   417

        return None

   418

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   419

   420

    def addconfigurationResource(self, config_name, name):

   421

        configuration = self.getconfiguration(config_name)

   422

        if configuration is not None:

   423

            for resource in configuration.getresource():

   424

                if resource.getname() == name:

   425

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

   426

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

   427

            new_resource.setname(name)

   428

            configuration.appendresource(new_resource)

   429

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   430

   431

    def removeconfigurationResource(self, config_name, name):

   432

        configuration = self.getconfiguration(config_name)

   433

        if configuration is not None:

   434

            found = False

   435

            for idx, resource in enumerate(configuration.getresource()):

   436

                if resource.getname() == name:

   437

                    configuration.removeresource(idx)

   438

                    found = True

   439

                    break

   440

            if not found:

   441

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

   442

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   443

   444

    def updateElementName(self, old_name, new_name):

   445

        for datatype in self.types.getdataTypeElements():

   446

            datatype.updateElementName(old_name, new_name)

   447

        for pou in self.types.getpouElements():

   448

            pou.updateElementName(old_name, new_name)

   449

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

   450

            configuration.updateElementName(old_name, new_name)

   451

    setattr(cls, "updateElementName", updateElementName)

   452

   453

    def updateElementAddress(self, old_leading, new_leading):

   454

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   455

        for pou in self.types.getpouElements():

   456

            pou.updateElementAddress(address_model, new_leading)

   457

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

   458

            configuration.updateElementAddress(address_model, new_leading)

   459

    setattr(cls, "updateElementAddress", updateElementAddress)

   460

   461

    def removeVariableByAddress(self, address):

   462

        for pou in self.types.getpouElements():

   463

            pou.removeVariableByAddress(address)

   464

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

   465

            configuration.removeVariableByAddress(address)

   466

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   467

   468

    def removeVariableByFilter(self, leading):

   469

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   470

        for pou in self.types.getpouElements():

   471

            pou.removeVariableByFilter(address_model)

   472

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

   473

            configuration.removeVariableByFilter(address_model)

   474

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   475

   476

    def RefreshDataTypeHierarchy(self):

   477

        self.EnumeratedDataTypeValues = {}

   478

        self.CustomDataTypeRange = {}

   479

        self.CustomTypeHierarchy = {}

   480

        for datatype in self.getdataTypes():

   481

            self.AddCustomDataType(datatype)

   482

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   483

   484

    def AddCustomDataType(self, datatype):

   485

        name = datatype.getname()

   486

        basetype_content = datatype.getbaseType().getcontent()

   487

        basetype_content_name = basetype_content.getLocalTag()

   488

        if basetype_content.__class__ == DefaultElementClass:

   489

            self.CustomTypeHierarchy[name] = basetype_content_name

   490

        elif basetype_content_name in ["string", "wstring"]:

   491

            self.CustomTypeHierarchy[name] = basetype_content_name.upper()

   492

        elif basetype_content_name == "derived":

   493

            self.CustomTypeHierarchy[name] = basetype_content.getname()

   494

        elif basetype_content_name in ["subrangeSigned", "subrangeUnsigned"]:

   495

            range = (basetype_content.range.getlower(), 

   496

                     basetype_content.range.getupper())

   497

            self.CustomDataTypeRange[name] = range

   498

            base_type = basetype_content.baseType.getcontent()

   499

            if base_type.__class__ == DefaultElementClass:

   500

                self.CustomTypeHierarchy[name] = base_type.getLocalTag()

   501

            else:

   502

                self.CustomTypeHierarchy[name] = base_type.getname()

   503

        else:

   504

            if basetype_content_name == "enum":

   505

                values = []

   506

                for value in basetype_content.xpath("ppx:values/ppx:value", namespaces=PLCOpenParser.NSMAP):

   507

                    values.append(value.getname())

   508

                self.EnumeratedDataTypeValues[name] = values

   509

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   510

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   511

   512

    # Update Block types with user-defined pou added

   513

    def RefreshCustomBlockTypes(self):

   514

        # Reset the tree of user-defined pou cross-use

   515

        self.CustomBlockTypes = OrderedDict()

   516

        for pou in self.getpous():

   517

            self.AddCustomBlockType(pou)

   518

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)