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([

    63

    ("N", False), ("R", False), ("S", False),

    64

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

    65

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

    66

    67

    68

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

    69

    70

    71

def update_address(address, address_model, new_leading):

    72

    result = address_model.match(address)

    73

    if result is None:

    74

        return address

    75

    groups = result.groups()

    76

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

    77

    78

    79

def _init_and_compare(function, v1, v2):

    80

    if v1 is None:

    81

        return v2

    82

    if v2 is not None:

    83

        return function(v1, v2)

    84

    return v1

    85

    86

    87

class rect:

    88

    """

    89

    Helper class for bounding_box calculation

    90

    """

    91

    92

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

    93

        self.x_min = x

    94

        self.x_max = None

    95

        self.y_min = y

    96

        self.y_max = None

    97

        if width is not None and x is not None:

    98

            self.x_max = x + width

    99

        if height is not None and y is not None:

   100

            self.y_max = y + height

   101

   102

    def update(self, x, y):

   103

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

   104

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

   105

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

   106

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

   107

   108

    def union(self, rect):

   109

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

   110

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

   111

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

   112

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

   113

   114

    def bounding_box(self):

   115

        width = height = None

   116

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

   117

            width = self.x_max - self.x_min

   118

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

   119

            height = self.y_max - self.y_min

   120

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

   121

   122

   123

def TextLenInRowColumn(text):

   124

    if text == "":

   125

        return (0, 0)

   126

    lines = text.split("\n")

   127

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

   128

   129

   130

def CompilePattern(criteria):

   131

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

   132

    find_pattern = criteria["find_pattern"]

   133

    if not criteria["regular_expression"]:

   134

        find_pattern = re.escape(find_pattern)

   135

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

   136

   137

   138

def TestTextElement(text, criteria):

   139

    lines = text.splitlines()

   140

    test_result = []

   141

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

   142

    while result is not None:

   143

        prev_pos = result.endpos

   144

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

   145

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

   146

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

   147

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

   148

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

   149

            break

   150

    return test_result

   151

   152

   153

def TextMatched(str1, str2):

   154

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

   155

   156

   157

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

   158

   159

   160

def PLCOpen_XPath(xpath):

   161

    return etree.XPath(xpath, namespaces=PLCOpenParser.NSMAP)

   162

   163

   164

LOAD_POU_PROJECT_TEMPLATE = """

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

  <contentHeader name="paste_project">

   172

    <coordinateInfo>

   173

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

   174

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

   175

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

   176

    </coordinateInfo>

   177

  </contentHeader>

   178

  <types>

   179

    <dataTypes/>

   180

    <pous>%s</pous>

   181

  </types>

   182

  <instances>

   183

    <configurations/>

   184

  </instances>

   185

</project>

   186

"""

   187

   188

   189

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   190

    return LOAD_POU_PROJECT_TEMPLATE % """

   191

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

   192

  <body>

   193

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

   194

  </body>

   195

</pou>""" % locals()

   196

   197

   198

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

   199

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   200

PLCOpen_v1_file.close()

   201

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   202

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

   203

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

   204

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

   205

   206

# XPath for file compatibility process

   207

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

   208

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

   209

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

   210

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   211

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

   212

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   213

   214

   215

def LoadProjectXML(project_xml):

   216

    project_xml = project_xml.replace(

   217

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

   218

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

   219

    for cre, repl in [

   220

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

   221

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

   222

        project_xml = cre.sub(repl, project_xml)

   223

   224

    try:

   225

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   226

        if error is None:

   227

            return tree, None

   228

   229

        if PLCOpen_v1_xsd.validate(tree):

   230

            # Make file compatible with PLCOpen v2

   231

   232

            # Update resource interval value

   233

            for resource in ProjectResourcesXPath(tree):

   234

                for task in resource.gettask():

   235

                    interval = task.get("interval")

   236

                    if interval is not None:

   237

                        result = time_model.match(interval)

   238

                        if result is not None:

   239

                            values = result.groups()

   240

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

   241

                            seconds = float(values[2])

   242

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

   243

                            text = "T#"

   244

                            if time_values[0] != 0:

   245

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

   246

                            if time_values[1] != 0:

   247

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

   248

                            if time_values[2] != 0:

   249

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

   250

                            if time_values[3] != 0:

   251

                                if time_values[3] % 1000 != 0:

   252

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

   253

                                else:

   254

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

   255

                            task.set("interval", text)

   256

   257

                # Update resources pou instance attributes

   258

                for pouInstance in ResourceInstancesXpath(resource):

   259

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

   260

                    if type_name is not None:

   261

                        pouInstance.set("typeName", type_name)

   262

   263

            # Update transitions condition

   264

            for transition_condition in TransitionsConditionXPath(tree):

   265

                connections = ConditionConnectionsXPath(transition_condition)

   266

                if len(connections) > 0:

   267

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

   268

                    transition_condition.setcontent(connectionPointIn)

   269

                    connectionPointIn.setrelPositionXY(0, 0)

   270

                    for connection in connections:

   271

                        connectionPointIn.append(connection)

   272

   273

            # Update actionBlocks

   274

            for actionBlock in ActionBlocksXPath(tree):

   275

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   276

                    actionBlock.remove(connectionPointOut)

   277

   278

                for action in actionBlock.getaction():

   279

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

   280

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

   281

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

   282

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

   283

                    action.setrelPosition(relPosition)

   284

   285

            return tree, None

   286

   287

        return tree, error

   288

   289

    except Exception, e:

   290

        return None, e.message

   291

   292

   293

def LoadProject(filepath):

   294

    project_file = open(filepath)

   295

    project_xml = project_file.read()

   296

    project_file.close()

   297

    return LoadProjectXML(project_xml)

   298

   299

   300

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

   301

   302

   303

def LoadPou(xml_string):

   304

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   305

    return project_pou_xpath(root)[0], error

   306

   307

   308

project_pou_instances_xpath = {

   309

    body_type: PLCOpen_XPath(

   310

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

   311

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

   312

   313

   314

def LoadPouInstances(xml_string, body_type):

   315

    root, error = LoadProjectXML(

   316

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   317

    return project_pou_instances_xpath[body_type](root), error

   318

   319

   320

def SaveProject(project, filepath):

   321

    project_file = open(filepath, 'w')

   322

    project_file.write(etree.tostring(

   323

        project,

   324

        pretty_print=True,

   325

        xml_declaration=True,

   326

        encoding='utf-8'))

   327

    project_file.close()

   328

   329

   330

cls = PLCOpenParser.GetElementClass("formattedText")

   331

if cls:

   332

    def updateElementName(self, old_name, new_name):

   333

        text = self.getanyText()

   334

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

   335

        text = pattern.sub(new_name, text)

   336

        self.setanyText(text)

   337

    setattr(cls, "updateElementName", updateElementName)

   338

   339

    def updateElementAddress(self, address_model, new_leading):

   340

        text = self.getanyText()

   341

        startpos = 0

   342

        result = address_model.search(text, startpos)

   343

        while result is not None:

   344

            groups = result.groups()

   345

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

   346

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

   347

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

   348

            result = address_model.search(text, startpos)

   349

        self.setanyText(text)

   350

    setattr(cls, "updateElementAddress", updateElementAddress)

   351

   352

    def hasblock(self, block_type):

   353

        text = self.getanyText()

   354

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

   355

        return pattern.search(text) is not None

   356

    setattr(cls, "hasblock", hasblock)

   357

   358

    def Search(self, criteria, parent_infos):

   359

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

   360

    setattr(cls, "Search", Search)

   361

   362

cls = PLCOpenParser.GetElementClass("project")

   363

if cls:

   364

   365

    def setname(self, name):

   366

        self.contentHeader.setname(name)

   367

    setattr(cls, "setname", setname)

   368

   369

    def getname(self):

   370

        return self.contentHeader.getname()

   371

    setattr(cls, "getname", getname)

   372

   373

    def getfileHeader(self):

   374

        fileheader_obj = self.fileHeader

   375

        return {

   376

            attr: value if value is not None else ""

   377

            for attr, value in [

   378

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

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

        }

   386

    setattr(cls, "getfileHeader", getfileHeader)

   387

   388

    def setfileHeader(self, fileheader):

   389

        fileheader_obj = self.fileHeader

   390

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

   391

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

   392

                     "contentDescription"]:

   393

            value = fileheader.get(attr)

   394

            if value is not None:

   395

                setattr(fileheader_obj, attr, value)

   396

    setattr(cls, "setfileHeader", setfileHeader)

   397

   398

    def getcontentHeader(self):

   399

        contentheader_obj = self.contentHeader

   400

        contentheader = {

   401

            attr: value if value is not None else ""

   402

            for attr, value in [

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

        }

   410

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

   411

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

   412

        return contentheader

   413

    setattr(cls, "getcontentHeader", getcontentHeader)

   414

   415

    def setcontentHeader(self, contentheader):

   416

        contentheader_obj = self.contentHeader

   417

        for attr, value in contentheader.iteritems():

   418

            func = {"projectName": contentheader_obj.setname,

   419

                    "projectVersion": contentheader_obj.setversion,

   420

                    "authorName": contentheader_obj.setauthor,

   421

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

   422

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

   423

            if func is not None:

   424

                func(value)

   425

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

   426

                setattr(contentheader_obj, attr, value)

   427

    setattr(cls, "setcontentHeader", setcontentHeader)

   428

   429

    def gettypeElementFunc(element_type):

   430

        elements_xpath = PLCOpen_XPath(

   431

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

   432

   433

        def gettypeElement(self, name):

   434

            elements = elements_xpath(self, name=name)

   435

            if len(elements) == 1:

   436

                return elements[0]

   437

            return None

   438

        return gettypeElement

   439

   440

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

   441

    filtered_datatypes_xpath = PLCOpen_XPath(

   442

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

   443

   444

    def getdataTypes(self, exclude=None):

   445

        if exclude is not None:

   446

            return filtered_datatypes_xpath(self, exclude=exclude)

   447

        return datatypes_xpath(self)

   448

    setattr(cls, "getdataTypes", getdataTypes)

   449

   450

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

   451

   452

    def appenddataType(self, name):

   453

        if self.getdataType(name) is not None:

   454

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

   455

        self.types.appenddataTypeElement(name)

   456

    setattr(cls, "appenddataType", appenddataType)

   457

   458

    def insertdataType(self, index, datatype):

   459

        self.types.insertdataTypeElement(index, datatype)

   460

    setattr(cls, "insertdataType", insertdataType)

   461

   462

    def removedataType(self, name):

   463

        self.types.removedataTypeElement(name)

   464

    setattr(cls, "removedataType", removedataType)

   465

   466

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

   467

        return self.xpath(

   468

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

   469

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

   470

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

   471

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

   472

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

   473

            namespaces=PLCOpenParser.NSMAP)

   474

    setattr(cls, "getpous", getpous)

   475

   476

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

   477

   478

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

   479

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

   480

    setattr(cls, "appendpou", appendpou)

   481

   482

    def insertpou(self, index, pou):

   483

        self.types.insertpouElement(index, pou)

   484

    setattr(cls, "insertpou", insertpou)

   485

   486

    def removepou(self, name):

   487

        self.types.removepouElement(name)

   488

    setattr(cls, "removepou", removepou)

   489