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

   157

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

   158

   159

LOAD_POU_PROJECT_TEMPLATE = """

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

  <contentHeader name="paste_project">

   167

    <coordinateInfo>

   168

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

   169

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

   170

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

   171

    </coordinateInfo>

   172

  </contentHeader>

   173

  <types>

   174

    <dataTypes/>

   175

    <pous>%s</pous>

   176

  </types>

   177

  <instances>

   178

    <configurations/>

   179

  </instances>

   180

</project>

   181

"""

   182

   183

   184

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   185

    return LOAD_POU_PROJECT_TEMPLATE % """

   186

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

   187

  <body>

   188

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

   189

  </body>

   190

</pou>""" % locals()

   191

   192

   193

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

   194

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   195

PLCOpen_v1_file.close()

   196

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   197

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

   198

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

   199

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

   200

   201

# XPath for file compatibility process

   202

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

   203

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

   204

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

   205

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   206

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

   207

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   208

   209

   210

def LoadProjectXML(project_xml):

   211

    project_xml = project_xml.replace(

   212

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

   213

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

   214

    for cre, repl in [

   215

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

   216

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

   217

        project_xml = cre.sub(repl, project_xml)

   218

   219

    try:

   220

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   221

        if error is None:

   222

            return tree, None

   223

   224

        if PLCOpen_v1_xsd.validate(tree):

   225

            # Make file compatible with PLCOpen v2

   226

   227

            # Update resource interval value

   228

            for resource in ProjectResourcesXPath(tree):

   229

                for task in resource.gettask():

   230

                    interval = task.get("interval")

   231

                    if interval is not None:

   232

                        result = time_model.match(interval)

   233

                        if result is not None:

   234

                            values = result.groups()

   235

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

   236

                            seconds = float(values[2])

   237

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

   238

                            text = "T#"

   239

                            if time_values[0] != 0:

   240

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

   241

                            if time_values[1] != 0:

   242

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

   243

                            if time_values[2] != 0:

   244

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

   245

                            if time_values[3] != 0:

   246

                                if time_values[3] % 1000 != 0:

   247

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

   248

                                else:

   249

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

   250

                            task.set("interval", text)

   251

   252

                # Update resources pou instance attributes

   253

                for pouInstance in ResourceInstancesXpath(resource):

   254

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

   255

                    if type_name is not None:

   256

                        pouInstance.set("typeName", type_name)

   257

   258

            # Update transitions condition

   259

            for transition_condition in TransitionsConditionXPath(tree):

   260

                connections = ConditionConnectionsXPath(transition_condition)

   261

                if len(connections) > 0:

   262

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

   263

                    transition_condition.setcontent(connectionPointIn)

   264

                    connectionPointIn.setrelPositionXY(0, 0)

   265

                    for connection in connections:

   266

                        connectionPointIn.append(connection)

   267

   268

            # Update actionBlocks

   269

            for actionBlock in ActionBlocksXPath(tree):

   270

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   271

                    actionBlock.remove(connectionPointOut)

   272

   273

                for action in actionBlock.getaction():

   274

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

   275

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

   276

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

   277

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

   278

                    action.setrelPosition(relPosition)

   279

   280

            return tree, None

   281

   282

        return tree, error

   283

   284

    except Exception, e:

   285

        return None, e.message

   286

   287

   288

def LoadProject(filepath):

   289

    project_file = open(filepath)

   290

    project_xml = project_file.read()

   291

    project_file.close()

   292

    return LoadProjectXML(project_xml)

   293

   294

   295

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

   296

   297

   298

def LoadPou(xml_string):

   299

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   300

    return project_pou_xpath(root)[0], error

   301

   302

   303

project_pou_instances_xpath = {

   304

    body_type: PLCOpen_XPath(

   305

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

   306

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

   307

   308

   309

def LoadPouInstances(xml_string, body_type):

   310

    root, error = LoadProjectXML(

   311

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   312

    return project_pou_instances_xpath[body_type](root), error

   313

   314

   315

def SaveProject(project, filepath):

   316

    project_file = open(filepath, 'w')

   317

    project_file.write(etree.tostring(

   318

        project,

   319

        pretty_print=True,

   320

        xml_declaration=True,

   321

        encoding='utf-8'))

   322

    project_file.close()

   323

   324

   325

cls = PLCOpenParser.GetElementClass("formattedText")

   326

if cls:

   327

    def updateElementName(self, old_name, new_name):

   328

        text = self.getanyText()

   329

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

   330

        text = pattern.sub(new_name, text)

   331

        self.setanyText(text)

   332

    setattr(cls, "updateElementName", updateElementName)

   333

   334

    def updateElementAddress(self, address_model, new_leading):

   335

        text = self.getanyText()

   336

        startpos = 0

   337

        result = address_model.search(text, startpos)

   338

        while result is not None:

   339

            groups = result.groups()

   340

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

   341

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

   342

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

   343

            result = address_model.search(text, startpos)

   344

        self.setanyText(text)

   345

    setattr(cls, "updateElementAddress", updateElementAddress)

   346

   347

    def hasblock(self, block_type):

   348

        text = self.getanyText()

   349

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

   350

        return pattern.search(text) is not None

   351

    setattr(cls, "hasblock", hasblock)

   352

   353

    def Search(self, criteria, parent_infos):

   354

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

   355

    setattr(cls, "Search", Search)

   356

   357

cls = PLCOpenParser.GetElementClass("project")

   358

if cls:

   359

   360

    def setname(self, name):

   361

        self.contentHeader.setname(name)

   362

    setattr(cls, "setname", setname)

   363

   364

    def getname(self):

   365

        return self.contentHeader.getname()

   366

    setattr(cls, "getname", getname)

   367

   368

    def getfileHeader(self):

   369

        fileheader_obj = self.fileHeader

   370

        return {

   371

            attr: value if value is not None else ""

   372

            for attr, value in [

   373

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

   374

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

   375

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

   376

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

   377

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

   378

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

   379

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

   380

        }

   381

    setattr(cls, "getfileHeader", getfileHeader)

   382

   383

    def setfileHeader(self, fileheader):

   384

        fileheader_obj = self.fileHeader

   385

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

   386

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

   387

                     "contentDescription"]:

   388

            value = fileheader.get(attr)

   389

            if value is not None:

   390

                setattr(fileheader_obj, attr, value)

   391

    setattr(cls, "setfileHeader", setfileHeader)

   392

   393

    def getcontentHeader(self):

   394

        contentheader_obj = self.contentHeader

   395

        contentheader = {

   396

            attr: value if value is not None else ""

   397

            for attr, value in [

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

        }

   405

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

   406

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

   407

        return contentheader

   408

    setattr(cls, "getcontentHeader", getcontentHeader)

   409

   410

    def setcontentHeader(self, contentheader):

   411

        contentheader_obj = self.contentHeader

   412

        for attr, value in contentheader.iteritems():

   413

            func = {"projectName": contentheader_obj.setname,

   414

                    "projectVersion": contentheader_obj.setversion,

   415

                    "authorName": contentheader_obj.setauthor,

   416

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

   417

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

   418

            if func is not None:

   419

                func(value)

   420

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

   421

                setattr(contentheader_obj, attr, value)

   422

    setattr(cls, "setcontentHeader", setcontentHeader)

   423

   424

    def gettypeElementFunc(element_type):

   425

        elements_xpath = PLCOpen_XPath(

   426

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

   428

        def gettypeElement(self, name):

   429

            elements = elements_xpath(self, name=name)

   430

            if len(elements) == 1:

   431

                return elements[0]

   432

            return None

   433

        return gettypeElement

   434

   435

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

   436

    filtered_datatypes_xpath = PLCOpen_XPath(

   437

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

   438

    def getdataTypes(self, exclude=None):

   439

        if exclude is not None:

   440

            return filtered_datatypes_xpath(self, exclude=exclude)

   441

        return datatypes_xpath(self)

   442

    setattr(cls, "getdataTypes", getdataTypes)

   443

   444

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

   445

   446

    def appenddataType(self, name):

   447

        if self.getdataType(name) is not None:

   448

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

   449

        self.types.appenddataTypeElement(name)

   450

    setattr(cls, "appenddataType", appenddataType)

   451

   452

    def insertdataType(self, index, datatype):

   453

        self.types.insertdataTypeElement(index, datatype)

   454

    setattr(cls, "insertdataType", insertdataType)

   455

   456

    def removedataType(self, name):

   457

        self.types.removedataTypeElement(name)

   458

    setattr(cls, "removedataType", removedataType)

   459

   460

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

   461

        return self.xpath(

   462

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

   463

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

   464

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

   465

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

   466

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

   467

            namespaces=PLCOpenParser.NSMAP)

   468

    setattr(cls, "getpous", getpous)

   469

   470

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

   471

   472

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

   473

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

   474

    setattr(cls, "appendpou", appendpou)

   475

   476

    def insertpou(self, index, pou):

   477

        self.types.insertpouElement(index, pou)

   478

    setattr(cls, "insertpou", insertpou)

   479

   480

    def removepou(self, name):

   481

        self.types.removepouElement(name)

   482

    setattr(cls, "removepou", removepou)

   483

   484

    configurations_xpath = PLCOpen_XPath(

   485

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

   486

    def getconfigurations(self):

   487

        return configurations_xpath(self)

   488

    setattr(cls, "getconfigurations", getconfigurations)

   489

   490

    configuration_xpath = PLCOpen_XPath(

   491

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