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

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

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

    14

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

    15

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

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

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

    24

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

    25

    26

from xmlclass import *

    27

from types import *

    28

import os

    29

import re

    30

from lxml import etree

    31

from collections import OrderedDict

    32

import util.paths as paths

    33

    34

"""

    35

Dictionary that makes the relation between var names in plcopen and displayed values

    36

"""

    37

VarTypes = {

    38

    "Local":    "localVars",

    39

    "Temp":     "tempVars",

    40

    "Input":    "inputVars",

    41

    "Output":   "outputVars",

    42

    "InOut":    "inOutVars",

    43

    "External": "externalVars",

    44

    "Global":   "globalVars",

    45

    "Access":   "accessVars"

    46

}

    47

    48

searchResultVarTypes = {

    49

    "inputVars":  "var_input",

    50

    "outputVars": "var_output",

    51

    "inOutVars":  "var_inout"

    52

}

    53

    54

"""

    55

Define in which order var types must be displayed

    56

"""

    57

VarOrder = ["Local", "Temp", "Input", "Output", "InOut", "External", "Global", "Access"]

    58

    59

"""

    60

Define which action qualifier must be associated with a duration

    61

"""

    62

QualifierList = OrderedDict([("N", False), ("R", False), ("S", False),

    63

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

    64

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

    65

    66

    67

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

    68

    69

    70

def update_address(address, address_model, new_leading):

    71

    result = address_model.match(address)

    72

    if result is None:

    73

        return address

    74

    groups = result.groups()

    75

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

    76

    77

    78

def _init_and_compare(function, v1, v2):

    79

    if v1 is None:

    80

        return v2

    81

    if v2 is not None:

    82

        return function(v1, v2)

    83

    return v1

    84

    85

    86

class rect:

    87

    """

    88

    Helper class for bounding_box calculation

    89

    """

    90

    91

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

    92

        self.x_min = x

    93

        self.x_max = None

    94

        self.y_min = y

    95

        self.y_max = None

    96

        if width is not None and x is not None:

    97

            self.x_max = x + width

    98

        if height is not None and y is not None:

    99

            self.y_max = y + height

   100

   101

    def update(self, x, y):

   102

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

   103

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

   104

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

   105

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

   106

   107

    def union(self, rect):

   108

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

   109

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

   110

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

   111

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

   112

   113

    def bounding_box(self):

   114

        width = height = None

   115

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

   116

            width = self.x_max - self.x_min

   117

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

   118

            height = self.y_max - self.y_min

   119

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

   120

   121

   122

def TextLenInRowColumn(text):

   123

    if text == "":

   124

        return (0, 0)

   125

    lines = text.split("\n")

   126

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

   127

   128

   129

def CompilePattern(criteria):

   130

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

   131

    find_pattern = criteria["find_pattern"]

   132

    if not criteria["regular_expression"]:

   133

        find_pattern = re.escape(find_pattern)

   134

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

   135

   136

   137

def TestTextElement(text, criteria):

   138

    lines = text.splitlines()

   139

    test_result = []

   140

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

   141

    while result is not None:

   142

        prev_pos = result.endpos

   143

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

   144

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

   145

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

   146

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

   147

        if result is not None and prev_pos == result.endpos:

   148

            break

   149

    return test_result

   150

   151

   152

def TextMatched(str1, str2):

   153

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

   154

   155

   156

PLCOpenParser = GenerateParserFromXSD(paths.AbsNeighbourFile(__file__, "tc6_xml_v201.xsd"))

   162

   163

LOAD_POU_PROJECT_TEMPLATE = """

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

  <contentHeader name="paste_project">

   171

    <coordinateInfo>

   172

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

   173

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

   174

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

   175

    </coordinateInfo>

   176

  </contentHeader>

   177

  <types>

   178

    <dataTypes/>

   179

    <pous>%s</pous>

   180

  </types>

   181

  <instances>

   182

    <configurations/>

   183

  </instances>

   184

</project>

   185

"""

   186

   187

   188

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   189

    return LOAD_POU_PROJECT_TEMPLATE % """

   190

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

   191

  <body>

   192

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

   193

  </body>

   194

</pou>""" % locals()

   195

   196

   197

PLCOpen_v1_file = open(paths.AbsNeighbourFile(__file__, "TC6_XML_V10_B.xsd"))

   198

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   199

PLCOpen_v1_file.close()

   200

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   201

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

   202

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

   203

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

   204

   205

# XPath for file compatibility process

   206

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

   207

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

   208

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

   209

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   210

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

   211

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   212

   213

   214

def LoadProjectXML(project_xml):

   215

    project_xml = project_xml.replace(

   216

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

   217

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

   218

    for cre, repl in [

   219

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

   220

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

   221

        project_xml = cre.sub(repl, project_xml)

   222

   223

    try:

   224

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   225

        if error is None:

   226

            return tree, None

   227

   228

        if PLCOpen_v1_xsd.validate(tree):

   229

            # Make file compatible with PLCOpen v2

   230

   231

            # Update resource interval value

   232

            for resource in ProjectResourcesXPath(tree):

   233

                for task in resource.gettask():

   234

                    interval = task.get("interval")

   235

                    if interval is not None:

   236

                        result = time_model.match(interval)

   237

                        if result is not None:

   238

                            values = result.groups()

   239

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

   240

                            seconds = float(values[2])

   241

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

   242

                            text = "T#"

   243

                            if time_values[0] != 0:

   244

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

   245

                            if time_values[1] != 0:

   246

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

   247

                            if time_values[2] != 0:

   248

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

   249

                            if time_values[3] != 0:

   250

                                if time_values[3] % 1000 != 0:

   251

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

   252

                                else:

   253

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

   254

                            task.set("interval", text)

   255

   256

                # Update resources pou instance attributes

   257

                for pouInstance in ResourceInstancesXpath(resource):

   258

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

   259

                    if type_name is not None:

   260

                        pouInstance.set("typeName", type_name)

   261

   262

            # Update transitions condition

   263

            for transition_condition in TransitionsConditionXPath(tree):

   264

                connections = ConditionConnectionsXPath(transition_condition)

   265

                if len(connections) > 0:

   266

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

   267

                    transition_condition.setcontent(connectionPointIn)

   268

                    connectionPointIn.setrelPositionXY(0, 0)

   269

                    for connection in connections:

   270

                        connectionPointIn.append(connection)

   271

   272

            # Update actionBlocks

   273

            for actionBlock in ActionBlocksXPath(tree):

   274

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   275

                    actionBlock.remove(connectionPointOut)

   276

   277

                for action in actionBlock.getaction():

   278

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

   279

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

   280

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

   281

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

   282

                    action.setrelPosition(relPosition)

   283

   284

            return tree, None

   285

   286

        return tree, error

   287

   288

    except Exception, e:

   289

        return None, e.message

   290

   291

   292

def LoadProject(filepath):

   293

    project_file = open(filepath)

   294

    project_xml = project_file.read()

   295

    project_file.close()

   296

    return LoadProjectXML(project_xml)

   297

   298

   299

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

   300

   301

   302

def LoadPou(xml_string):

   303

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   304

    return project_pou_xpath(root)[0], error

   305

   306

   307

project_pou_instances_xpath = {

   308

    body_type: PLCOpen_XPath(

   309

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

   310

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

   311

   312

   313

def LoadPouInstances(xml_string, body_type):

   314

    root, error = LoadProjectXML(

   315

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   316

    return project_pou_instances_xpath[body_type](root), error

   317

   318

   319

def SaveProject(project, filepath):

   320

    project_file = open(filepath, 'w')

   321

    project_file.write(etree.tostring(

   322

        project,

   323

        pretty_print=True,

   324

        xml_declaration=True,

   325

        encoding='utf-8'))

   326

    project_file.close()

   327

   328

   329

cls = PLCOpenParser.GetElementClass("formattedText")

   330

if cls:

   331

    def updateElementName(self, old_name, new_name):

   332

        text = self.getanyText()

   333

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

   334

        text = pattern.sub(new_name, text)

   335

        self.setanyText(text)

   336

    setattr(cls, "updateElementName", updateElementName)

   337

   338

    def updateElementAddress(self, address_model, new_leading):

   339

        text = self.getanyText()

   340

        startpos = 0

   341

        result = address_model.search(text, startpos)

   342

        while result is not None:

   343

            groups = result.groups()

   344

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

   345

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

   346

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

   347

            result = address_model.search(text, startpos)

   348

        self.setanyText(text)

   349

    setattr(cls, "updateElementAddress", updateElementAddress)

   350

   351

    def hasblock(self, block_type):

   352

        text = self.getanyText()

   353

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

   354

        return pattern.search(text) is not None

   355

    setattr(cls, "hasblock", hasblock)

   356

   357

    def Search(self, criteria, parent_infos):

   358

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

   359

    setattr(cls, "Search", Search)

   360

   361

cls = PLCOpenParser.GetElementClass("project")

   362

if cls:

   363

   364

    def setname(self, name):

   365

        self.contentHeader.setname(name)

   366

    setattr(cls, "setname", setname)

   367

   368

    def getname(self):

   369

        return self.contentHeader.getname()

   370

    setattr(cls, "getname", getname)

   371

   372

    def getfileHeader(self):

   373

        fileheader_obj = self.fileHeader

   374

        return {

   375

            attr: value if value is not None else ""

   376

            for attr, value in [

   377

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

   378

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

   379

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

   380

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

   381

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

   382

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

   383

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

   384

        }

   385

    setattr(cls, "getfileHeader", getfileHeader)

   386

   387

    def setfileHeader(self, fileheader):

   388

        fileheader_obj = self.fileHeader

   389

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

   390

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

   391

                     "contentDescription"]:

   392

            value = fileheader.get(attr)

   393

            if value is not None:

   394

                setattr(fileheader_obj, attr, value)

   395

    setattr(cls, "setfileHeader", setfileHeader)

   396

   397

    def getcontentHeader(self):

   398

        contentheader_obj = self.contentHeader

   399

        contentheader = {

   400

            attr: value if value is not None else ""

   401

            for attr, value in [

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

        }

   409

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

   410

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

   411

        return contentheader

   412

    setattr(cls, "getcontentHeader", getcontentHeader)

   413

   414

    def setcontentHeader(self, contentheader):

   415

        contentheader_obj = self.contentHeader

   416

        for attr, value in contentheader.iteritems():

   417

            func = {"projectName": contentheader_obj.setname,

   418

                    "projectVersion": contentheader_obj.setversion,

   419

                    "authorName": contentheader_obj.setauthor,

   420

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

   421

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

   422

            if func is not None:

   423

                func(value)

   424

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

   425

                setattr(contentheader_obj, attr, value)

   426

    setattr(cls, "setcontentHeader", setcontentHeader)

   427

   428

    def gettypeElementFunc(element_type):

   429

        elements_xpath = PLCOpen_XPath(

   430

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

   431

   432

        def gettypeElement(self, name):

   433

            elements = elements_xpath(self, name=name)

   434

            if len(elements) == 1:

   435

                return elements[0]

   436

            return None

   437

        return gettypeElement

   438

   439

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

   440

    filtered_datatypes_xpath = PLCOpen_XPath(

   441

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

   442

   443

    def getdataTypes(self, exclude=None):

   444

        if exclude is not None:

   445

            return filtered_datatypes_xpath(self, exclude=exclude)

   446

        return datatypes_xpath(self)

   447

    setattr(cls, "getdataTypes", getdataTypes)

   448

   449

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

   450

   451

    def appenddataType(self, name):

   452

        if self.getdataType(name) is not None:

   453

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

   454

        self.types.appenddataTypeElement(name)

   455

    setattr(cls, "appenddataType", appenddataType)

   456

   457

    def insertdataType(self, index, datatype):

   458

        self.types.insertdataTypeElement(index, datatype)

   459

    setattr(cls, "insertdataType", insertdataType)

   460

   461

    def removedataType(self, name):

   462

        self.types.removedataTypeElement(name)

   463

    setattr(cls, "removedataType", removedataType)

   464

   465

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

   466

        return self.xpath(

   467

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

   468

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

   469

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

   470

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

   471

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

   472

            namespaces=PLCOpenParser.NSMAP)

   473

    setattr(cls, "getpous", getpous)

   474

   475

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

   476

   477

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

   478

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

   479

    setattr(cls, "appendpou", appendpou)

   480

   481

    def insertpou(self, index, pou):

   482

        self.types.insertpouElement(index, pou)

   483

    setattr(cls, "insertpou", insertpou)

   484

   485

    def removepou(self, name):

   486

        self.types.removepouElement(name)

   487

    setattr(cls, "removepou", removepou)

   488

   489

    configurations_xpath = PLCOpen_XPath(

   490

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

   491