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.ElementUsingTree = {}

   245

    cls.CustomBlockTypes = OrderedDict()

   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):

   268

    setattr(cls, "getfileHeader", getfileHeader)

   269

   270

    def setfileHeader(self, fileheader):

   274

    setattr(cls, "setfileHeader", setfileHeader)

   275

   276

    def getcontentHeader(self):

   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):

   306

    setattr(cls, "setcontentHeader", setcontentHeader)

   307

   319

    def getdataTypes(self):

   321

    setattr(cls, "getdataTypes", getdataTypes)

   322

   325

    setattr(cls, "getdataType", getdataType)

   326

   327

    def appenddataType(self, name):

   329

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

   330

        self.types.appenddataTypeElement(name)

   331

    setattr(cls, "appenddataType", appenddataType)

   332

   333

    def insertdataType(self, index, datatype):

   334

        self.types.insertdataTypeElement(index, datatype)

   335

    setattr(cls, "insertdataType", insertdataType)

   336

   337

    def removedataType(self, name):

   338

        self.types.removedataTypeElement(name)

   339

        self.RefreshElementUsingTree()

   340

    setattr(cls, "removedataType", removedataType)

   341

   342

    def getpous(self):

   344

    setattr(cls, "getpous", getpous)

   345

   348

    setattr(cls, "getpou", getpou)

   349

   350

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

   351

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

   352

        self.AddCustomBlockType(self.getpou(name))

   353

    setattr(cls, "appendpou", appendpou)

   354

   355

    def insertpou(self, index, pou):

   356

        self.types.insertpouElement(index, pou)

   357

        self.AddCustomBlockType(pou)

   358

    setattr(cls, "insertpou", insertpou)

   359

   360

    def removepou(self, name):

   361

        self.types.removepouElement(name)

   362

        self.RefreshCustomBlockTypes()

   363

        self.RefreshElementUsingTree()

   364

    setattr(cls, "removepou", removepou)

   365

   366

    def getconfigurations(self):

   376

            return configurations

   379

        return None

   380

    setattr(cls, "getconfiguration", getconfiguration)

   381

   382

    def addconfiguration(self, 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):

   395

    setattr(cls, "removeconfiguration", removeconfiguration)

   396

   397

    def getconfigurationResource(self, config_name, 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)

   420

        if configuration is not None:

   427

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   428

   429

    def updateElementName(self, old_name, new_name):

   431

            datatype.updateElementName(old_name, new_name)

   433

            pou.updateElementName(old_name, new_name)

   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)

   441

            pou.updateElementAddress(address_model, new_leading)

   443

            configuration.updateElementAddress(address_model, new_leading)

   444

    setattr(cls, "updateElementAddress", updateElementAddress)

   445

   446

    def removeVariableByAddress(self, address):

   448

            pou.removeVariableByAddress(address)

   450

            configuration.removeVariableByAddress(address)

   451

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   452

   453

    def removeVariableByFilter(self, leading):

   454

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   456

            pou.removeVariableByFilter(address_model)

   458

            configuration.removeVariableByFilter(address_model)

   459

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   460

   461

    # Update Block types with user-defined pou added

   462

    def RefreshCustomBlockTypes(self):

   463

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

   464

        self.CustomBlockTypes = OrderedDict()

   465

        for pou in self.getpous():

   466

            self.AddCustomBlockType(pou)

   467

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   468

   469

    def AddCustomBlockType(self, pou): 

   470

        pou_name = pou.getname()

   471

        pou_type = pou.getpouType()

   472

        block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False,

   473

                       "inputs" : [], "outputs" : [], "comment" : pou.getdescription(),

   474

                       "generate" : generate_block, "initialise" : initialise_block}

   475

        if pou.interface is not None:

   476

            return_type = pou.interface.getreturnType()

   477

            if return_type is not None:

   478

                var_type = return_type.getcontent()

   479

                var_type_name = var_type.getLocalTag()

   480

                if var_type_name == "derived":

   481

                    block_infos["outputs"].append(("OUT", var_type.getname(), "none"))

   482

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

   483

                    block_infos["outputs"].append(("OUT", var_type_name.upper(), "none"))

   484

                else:

   485

                    block_infos["outputs"].append(("OUT", var_type_name, "none"))

   486

            for type, varlist in pou.getvars():

   487

                if type == "InOut":

   488

                    for var in varlist.getvariable():

   489

                        var_type = var.type.getcontent()

   490

                        var_type_name = var_type.getLocalTag()

   491

                        if var_type_name == "derived":

   492

                            block_infos["inputs"].append((var.getname(), var_type.getname(), "none"))

   493

                            block_infos["outputs"].append((var.getname(), var_type.getname(), "none"))

   494

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

   495

                            block_infos["inputs"].append((var.getname(), var_type_name.upper(), "none"))

   496

                            block_infos["outputs"].append((var.getname(), var_type_name.upper(), "none"))

   497

                        else:

   498

                            block_infos["inputs"].append((var.getname(), var_type_name, "none"))

   499

                            block_infos["outputs"].append((var.getname(), var_type_name, "none"))

   500

                elif type == "Input":

   501

                    for var in varlist.getvariable():

   502

                        var_type = var.type.getcontent()

   503

                        var_type_name = var_type.getLocalTag()

   504

                        if var_type_name == "derived":

   505

                            block_infos["inputs"].append((var.getname(), var_type.getname(), "none"))

   506

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

   507

                            block_infos["inputs"].append((var.getname(), var_type_name.upper(), "none"))

   508

                        else: