1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

from xmlclass import *

    26

from types import *

    27

import os, re

    28

from lxml import etree

    29

from collections import OrderedDict

    30

    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 = OrderedDict([("N", False), ("R", False), ("S", False), 

    53

    ("L", True), ("D", True), ("P", False), ("P0", False), 

    54

    ("P1", False), ("SD", True), ("DS", True), ("SL", True)])

    55

    56

    57

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

    58

    59

def update_address(address, address_model, new_leading):

    60

    result = address_model.match(address)

    61

    if result is None:

    62

        return address

    63

    groups = result.groups()

    64

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

    65

    66

def _init_and_compare(function, v1, v2):

    67

    if v1 is None:

    68

        return v2

    69

    if v2 is not None:

    70

        return function(v1, v2)

    71

    return v1

    72

    73

"""

    74

Helper class for bounding_box calculation 

    75

"""

    76

class rect:

    77

    78

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

    79

        self.x_min = x

    80

        self.x_max = None

    81

        self.y_min = y

    82

        self.y_max = None

    83

        if width is not None and x is not None:

    84

            self.x_max = x + width

    85

        if height is not None and y is not None:

    86

            self.y_max = y + height

    87

    88

    def update(self, x, y):

    89

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

    90

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

    91

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

    92

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

    93

    94

    def union(self, rect):

    95

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

    96

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

    97

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

    98

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

    99

   100

    def bounding_box(self):

   101

        width = height = None

   102

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

   103

            width = self.x_max - self.x_min

   104

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

   105

            height = self.y_max - self.y_min

   106

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

   107

   108

def TextLenInRowColumn(text):

   109

    if text == "":

   110

        return (0, 0)

   111

    lines = text.split("\n")

   112

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

   113

   114

def CompilePattern(criteria):

   115

    flag = 0 if criteria["case_sensitive"] else re.IGNORECASE

   116

    find_pattern = criteria["find_pattern"]

   117

    if not criteria["regular_expression"]:

   118

        find_pattern = re.escape(find_pattern)

   119

    criteria["pattern"] = re.compile(find_pattern, flag)

   120

   121

def TestTextElement(text, criteria):

   122

    lines = text.splitlines()

   123

    test_result = []

   124

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

   125

    while result is not None:

   126

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

   127

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

   128

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

   129

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

   130

    return test_result

   131

   132

def TextMatched(str1, str2):

   133

    return str1 and str2 and (str1.upper() == str2.upper())

   134

   135

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

   136

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

   137

   138

LOAD_POU_PROJECT_TEMPLATE = """

   139

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

   140

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

   141

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

   142

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

   143

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

   144

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

   145

  <contentHeader name="paste_project">

   146

    <coordinateInfo>

   147

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

   148

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

   149

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

   150

    </coordinateInfo>

   151

  </contentHeader>

   152

  <types>

   153

    <dataTypes/>

   154

    <pous>%s</pous>

   155

  </types>

   156

  <instances>

   157

    <configurations/>

   158

  </instances>

   159

</project>

   160

"""

   161

   162

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   163

    return LOAD_POU_PROJECT_TEMPLATE % """

   164

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

   165

  <body>

   166

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

   167

  </body>

   168

</pou>""" % locals()

   169

   170

PLCOpen_v1_file = open(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd"))

   171

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   172

PLCOpen_v1_file.close()

   173

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   174

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

   175

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

   176

PLCOpen_v1_xsd = etree.XMLSchema(etree.fromstring(PLCOpen_v1_xml))

   177

   178

# XPath for file compatibility process

   179

ProjectResourcesXPath = PLCOpen_XPath("ppx:instances/ppx:configurations/ppx:configuration/ppx:resource")

   180

ResourceInstancesXpath = PLCOpen_XPath("ppx:pouInstance | ppx:task/ppx:pouInstance")

   181

TransitionsConditionXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:transition/ppx:condition")

   182

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   183

ActionBlocksXPath = PLCOpen_XPath("ppx:types/ppx:pous/ppx:pou/ppx:body/*/ppx:actionBlock")

   184

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   185

   186

def LoadProjectXML(project_xml):

   187

    project_xml = project_xml.replace(

   188

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

   189

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

   190

    for cre, repl in [

   191

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

   192

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

   193

        project_xml = cre.sub(repl, project_xml)

   194

   195

    try:

   196

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   197

        if error is None:

   198

            return tree, None

   199

   200

        if PLCOpen_v1_xsd.validate(tree):

   201

            # Make file compatible with PLCOpen v2

   202

   203

            # Update resource interval value

   204

            for resource in ProjectResourcesXPath(tree):

   205

                for task in resource.gettask():

   206

                    interval = task.get("interval")

   207

                    if interval is not None:

   208

                        result = time_model.match(interval)

   209

                        if result is not None:

   210

                            values = result.groups()

   211

                            time_values = [int(v) for v in values[:2]]

   212

                            seconds = float(values[2])

   213

                            time_values.extend([int(seconds), int((seconds % 1) * 1000000)])

   214

                            text = "T#"

   215

                            if time_values[0] != 0:

   216

                                text += "%dh"%time_values[0]

   217

                            if time_values[1] != 0:

   218

                                text += "%dm"%time_values[1]

   219

                            if time_values[2] != 0:

   220

                                text += "%ds"%time_values[2]

   221

                            if time_values[3] != 0:

   222

                                if time_values[3] % 1000 != 0:

   223

                                    text += "%.3fms"%(float(time_values[3]) / 1000)

   224

                                else:

   225

                                    text += "%dms"%(time_values[3] / 1000)

   226

                            task.set("interval", text)

   227

   228

                # Update resources pou instance attributes

   229

                for pouInstance in ResourceInstancesXpath(resource):

   230

                    type_name = pouInstance.attrib.pop("type")

   231

                    if type_name is not None:

   232

                        pouInstance.set("typeName", type_name)

   233

   234

            # Update transitions condition

   235

            for transition_condition in TransitionsConditionXPath(tree):

   236

                connections = ConditionConnectionsXPath(transition_condition)

   237

                if len(connections) > 0:

   238

                    connectionPointIn = PLCOpenParser.CreateElement("connectionPointIn", "condition")

   239

                    transition_condition.setcontent(connectionPointIn)

   240

                    connectionPointIn.setrelPositionXY(0, 0)

   241

                    for connection in connections:

   242

                        connectionPointIn.append(connection)

   243

   244

            # Update actionBlocks

   245

            for actionBlock in ActionBlocksXPath(tree):

   246

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   247

                    actionBlock.remove(connectionPointOut)

   248

   249

                for action in actionBlock.getaction():

   250

                    action.set("localId", "0")

   251

                    relPosition = PLCOpenParser.CreateElement("relPosition", "action")

   252

                    relPosition.set("x", "0")

   253

                    relPosition.set("y", "0")

   254

                    action.setrelPosition(relPosition)

   255

   256

            return tree, None

   257

   258

        return tree, error

   259

   260

    except Exception, e:

   261

        return None, e.message

   262

   263

def LoadProject(filepath):

   264

    project_file = open(filepath)

   265

    project_xml = project_file.read()

   266

    project_file.close()

   267

    return LoadProjectXML(project_xml)

   268

   269

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

   270

def LoadPou(xml_string):

   271

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   272

    return project_pou_xpath(root)[0], error

   273

   274

project_pou_instances_xpath = {

   275

    body_type: PLCOpen_XPath(

   276

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

   277

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

   278

def LoadPouInstances(xml_string, body_type):

   279

    root, error = LoadProjectXML(

   280

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   281

    return project_pou_instances_xpath[body_type](root), error

   282

   283

def SaveProject(project, filepath):

   284

    project_file = open(filepath, 'w')

   285

    project_file.write(etree.tostring(

   286

        project, 

   287

        pretty_print=True, 

   288

        xml_declaration=True, 

   289

        encoding='utf-8'))

   290

    project_file.close()

   291

   292

cls = PLCOpenParser.GetElementClass("formattedText")

   293

if cls:

   294

    def updateElementName(self, old_name, new_name):

   295

        text = self.getanyText()

   296

        pattern = re.compile('\\b' + old_name + '\\b', re.IGNORECASE)

   297

        text = pattern.sub(new_name, text)

   298

        self.setanyText(text)

   299

    setattr(cls, "updateElementName", updateElementName)

   300

   301

    def updateElementAddress(self, address_model, new_leading):

   302

        text = self.getanyText()

   303

        startpos = 0

   304

        result = address_model.search(text, startpos)

   305

        while result is not None:

   306

            groups = result.groups()

   307

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

   308

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

   309

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

   310

            result = address_model.search(text, startpos)

   311

        self.setanyText(text)

   312

    setattr(cls, "updateElementAddress", updateElementAddress)

   313

   314

    def hasblock(self, block_type):

   315

        text = self.getanyText()        

   316

        pattern = re.compile('\\b' + block_type + '\\b', re.IGNORECASE)

   317

        return pattern.search(text) is not None

   318

    setattr(cls, "hasblock", hasblock)

   319

   320

    def Search(self, criteria, parent_infos):

   321

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

   322

    setattr(cls, "Search", Search)

   323

   324

cls = PLCOpenParser.GetElementClass("project")

   325

if cls:

   326

   327

    def setname(self, name):

   328

        self.contentHeader.setname(name)

   329

    setattr(cls, "setname", setname)

   330

   331

    def getname(self):

   332

        return self.contentHeader.getname()

   333

    setattr(cls, "getname", getname)

   334

   335

    def getfileHeader(self):

   336

        fileheader_obj = self.fileHeader

   337

        return {

   338

            attr: value if value is not None else ""

   339

            for attr, value in [

   340

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

   341

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

   342

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

   343

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

   344

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

   345

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

   346

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

   347

        }

   348

    setattr(cls, "getfileHeader", getfileHeader)

   349

   350

    def setfileHeader(self, fileheader):

   351

        fileheader_obj = self.fileHeader

   352

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

   353

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

   354

                     "contentDescription"]:

   355

            value = fileheader.get(attr)

   356

            if value is not None:

   357

                setattr(fileheader_obj, attr, value)

   358

    setattr(cls, "setfileHeader", setfileHeader)

   359

   360

    def getcontentHeader(self):

   361

        contentheader_obj = self.contentHeader

   362

        contentheader = {

   363

            attr: value if value is not None else ""

   364

            for attr, value in [

   365

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

   366

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

   367

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

   368

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

   369

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

   370

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

   371

        }

   372

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

   373

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

   374

        return contentheader

   375

    setattr(cls, "getcontentHeader", getcontentHeader)

   376

   377

    def setcontentHeader(self, contentheader):

   378

        contentheader_obj = self.contentHeader

   379

        for attr, value in contentheader.iteritems():

   380

            func = {"projectName": contentheader_obj.setname,

   381

                    "projectVersion": contentheader_obj.setversion,

   382

                    "authorName": contentheader_obj.setauthor,

   383

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

   384

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

   385

            if func is not None:

   386

                func(value)

   387

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

   388

                setattr(contentheader_obj, attr, value)

   389

    setattr(cls, "setcontentHeader", setcontentHeader)

   390

   391

    def gettypeElementFunc(element_type):

   392

        elements_xpath = PLCOpen_XPath(

   393

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

   394

        def gettypeElement(self, name):

   395

            elements = elements_xpath(self, name=name)

   396

            if len(elements) == 1:

   397

                return elements[0]

   398

            return None

   399

        return gettypeElement

   400

   401

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

   402

    filtered_datatypes_xpath = PLCOpen_XPath(

   403

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

   404

    def getdataTypes(self, exclude=None):

   405

        if exclude is not None:

   406

            return filtered_datatypes_xpath(self, exclude=exclude)

   407

        return datatypes_xpath(self)

   408

    setattr(cls, "getdataTypes", getdataTypes)

   409

   410

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

   411

   412

    def appenddataType(self, name):

   413

        if self.getdataType(name) is not None:

   414

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

   415

        self.types.appenddataTypeElement(name)

   416

    setattr(cls, "appenddataType", appenddataType)

   417

   418

    def insertdataType(self, index, datatype):

   419

        self.types.insertdataTypeElement(index, datatype)

   420

    setattr(cls, "insertdataType", insertdataType)

   421

   422

    def removedataType(self, name):

   423

        self.types.removedataTypeElement(name)

   424

    setattr(cls, "removedataType", removedataType)

   425

   426

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

   427

        return self.xpath(

   428

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

   429

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

   430

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

   431

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

   432

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

   433

            namespaces=PLCOpenParser.NSMAP)

   434

    setattr(cls, "getpous", getpous)

   435

   436

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

   437

   438

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

   439

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

   440

    setattr(cls, "appendpou", appendpou)

   441

   442

    def insertpou(self, index, pou):

   443

        self.types.insertpouElement(index, pou)

   444

    setattr(cls, "insertpou", insertpou)

   445

   446

    def removepou(self, name):

   447

        self.types.removepouElement(name)

   448

    setattr(cls, "removepou", removepou)

   449

   450

    configurations_xpath = PLCOpen_XPath(

   451

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

   452

    def getconfigurations(self):

   453

        return configurations_xpath(self)

   454

    setattr(cls, "getconfigurations", getconfigurations)

   455

   456

    configuration_xpath = PLCOpen_XPath(

   457

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

   458

    def getconfiguration(self, name):

   459

        configurations = configuration_xpath(self, name=name)

   460

        if len(configurations) == 1:

   461

            return configurations[0]

   462

        return None

   463

    setattr(cls, "getconfiguration", getconfiguration)

   464

   465

    def addconfiguration(self, name):

   466

        if self.getconfiguration(name) is not None:

   467

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

   468

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

   469

        new_configuration.setname(name)

   470

        self.instances.configurations.appendconfiguration(new_configuration)

   471

    setattr(cls, "addconfiguration", addconfiguration)    

   472

   473

    def removeconfiguration(self, name):

   474

        configuration = self.getconfiguration(name)

   475

        if configuration is None:

   476

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

   477

        self.instances.configurations.remove(configuration)

   478

    setattr(cls, "removeconfiguration", removeconfiguration)

   479

   480

    resources_xpath = PLCOpen_XPath(

   481

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

   482

    def getconfigurationResource(self, config_name, name):

   483

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

   484

        if len(resources) == 1:

   485

            return resources[0]

   486

        return None

   487

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   488

   489

    def addconfigurationResource(self, config_name, name):

   490

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

   491

            msg = _("\"{a1}\" resource already exists in \"{a2}\" configuration !!!").format(a1 = name, a2 = config_name)

   492

            raise ValueError, msg

   493

        configuration = self.getconfiguration(config_name)

   494

        if configuration is not None:

   495

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

   496

            new_resource.setname(name)

   497

            configuration.appendresource(new_resource)

   498

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   499

   500

    def removeconfigurationResource(self, config_name, name):

   501

        configuration = self.getconfiguration(config_name)