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 types import *

    27

import os

    28

import re

    29

from collections import OrderedDict

    30

    31

from lxml import etree

    32

    33

from xmlclass import *

    34

import util.paths as paths

    35

    36

    37

#: Dictionary that makes the relation between var names

    38

#: in plcopen and displayed values

    39

    40

VarTypes = {

    41

    "Local":    "localVars",

    42

    "Temp":     "tempVars",

    43

    "Input":    "inputVars",

    44

    "Output":   "outputVars",

    45

    "InOut":    "inOutVars",

    46

    "External": "externalVars",

    47

    "Global":   "globalVars",

    48

    "Access":   "accessVars"

    49

}

    50

    51

searchResultVarTypes = {

    52

    "inputVars":  "var_input",

    53

    "outputVars": "var_output",

    54

    "inOutVars":  "var_inout"

    55

}

    56

    57

    58

#: Define in which order var types must be displayed

    59

    60

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

    61

    62

    63

#:  Define which action qualifier must be associated with a duration

    64

    65

QualifierList = OrderedDict([

    66

    ("N", False),

    67

    ("R", False),

    68

    ("S", False),

    69

    ("L", True),

    70

    ("D", True),

    71

    ("P", False),

    72

    ("P0", False),

    73

    ("P1", False),

    74

    ("SD", True),

    75

    ("DS", True),

    76

    ("SL", True)])

    77

    78

    79

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

    80

    81

    82

def update_address(address, address_model, new_leading):

    83

    result = address_model.match(address)

    84

    if result is None:

    85

        return address

    86

    groups = result.groups()

    87

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

    88

    89

    90

def _init_and_compare(function, v1, v2):

    91

    if v1 is None:

    92

        return v2

    93

    if v2 is not None:

    94

        return function(v1, v2)

    95

    return v1

    96

    97

    98

class rect(object):

    99

    """

   100

    Helper class for bounding_box calculation

   101

    """

   102

   103

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

   104

        self.x_min = x

   105

        self.x_max = None

   106

        self.y_min = y

   107

        self.y_max = None

   108

        if width is not None and x is not None:

   109

            self.x_max = x + width

   110

        if height is not None and y is not None:

   111

            self.y_max = y + height

   112

   113

    def update(self, x, y):

   114

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

   115

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

   116

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

   117

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

   118

   119

    def union(self, rect):

   120

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

   121

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

   122

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

   123

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

   124

   125

    def bounding_box(self):

   126

        width = height = None

   127

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

   128

            width = self.x_max - self.x_min

   129

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

   130

            height = self.y_max - self.y_min

   131

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

   132

   133

   134

def TextLenInRowColumn(text):

   135

    if text == "":

   136

        return (0, 0)

   137

    lines = text.split("\n")

   138

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

   139

   140

   141

def CompilePattern(criteria):

   142

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

   143

    find_pattern = criteria["find_pattern"]

   144

    if not criteria["regular_expression"]:

   145

        find_pattern = re.escape(find_pattern)

   146

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

   147

   148

   149

def TestTextElement(text, criteria):

   150

    lines = text.splitlines()

   151

    test_result = []

   152

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

   153

    while result is not None:

   154

        prev_pos = result.endpos

   155

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

   156

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

   157

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

   158

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

   159

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

   160

            break

   161

    return test_result

   162

   163

   164

def TextMatched(str1, str2):

   165

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

   166

   167

   168

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

   169

   170

   171

def PLCOpen_XPath(xpath):

   172

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

   173

   174

   175

LOAD_POU_PROJECT_TEMPLATE = """

   176

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

   177

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

   178

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

   179

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

   180

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

   181

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

   182

  <contentHeader name="paste_project">

   183

    <coordinateInfo>

   184

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

   185

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

   186

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

   187

    </coordinateInfo>

   188

  </contentHeader>

   189

  <types>

   190

    <dataTypes/>

   191

    <pous>%s</pous>

   192

  </types>

   193

  <instances>

   194

    <configurations/>

   195

  </instances>

   196

</project>

   197

"""

   198

   199

   200

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   201

    return LOAD_POU_PROJECT_TEMPLATE % """

   202

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

   203

  <body>

   204

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

   205

  </body>

   206

</pou>""" % locals()

   207

   208

   209

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

   210

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   211

PLCOpen_v1_file.close()

   212

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   213

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

   214

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

   215

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

   216

   217

# XPath for file compatibility process

   218

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

   219

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

   220

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

   221

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   222

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

   223

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   224

   225

   226

def LoadProjectXML(project_xml):

   227

    project_xml = project_xml.replace(

   228

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

   229

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

   230

    for cre, repl in [

   231

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

   232

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

   233

        project_xml = cre.sub(repl, project_xml)

   234

   235

    try:

   236

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   237

        if error is None:

   238

            return tree, None

   239

   240

        if PLCOpen_v1_xsd.validate(tree):

   241

            # Make file compatible with PLCOpen v2

   242

   243

            # Update resource interval value

   244

            for resource in ProjectResourcesXPath(tree):

   245

                for task in resource.gettask():

   246

                    interval = task.get("interval")

   247

                    if interval is not None:

   248

                        result = time_model.match(interval)

   249

                        if result is not None:

   250

                            values = result.groups()

   251

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

   252

                            seconds = float(values[2])

   253

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

   254

                            text = "T#"

   255

                            if time_values[0] != 0:

   256

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

   257

                            if time_values[1] != 0:

   258

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

   259

                            if time_values[2] != 0:

   260

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

   261

                            if time_values[3] != 0:

   262

                                if time_values[3] % 1000 != 0:

   263

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

   264

                                else:

   265

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

   266

                            task.set("interval", text)

   267

   268

                # Update resources pou instance attributes

   269

                for pouInstance in ResourceInstancesXpath(resource):

   270

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

   271

                    if type_name is not None:

   272

                        pouInstance.set("typeName", type_name)

   273

   274

            # Update transitions condition

   275

            for transition_condition in TransitionsConditionXPath(tree):

   276

                connections = ConditionConnectionsXPath(transition_condition)

   277

                if len(connections) > 0:

   278

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

   279

                    transition_condition.setcontent(connectionPointIn)

   280

                    connectionPointIn.setrelPositionXY(0, 0)

   281

                    for connection in connections:

   282

                        connectionPointIn.append(connection)

   283

   284

            # Update actionBlocks

   285

            for actionBlock in ActionBlocksXPath(tree):

   286

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   287

                    actionBlock.remove(connectionPointOut)

   288

   289

                for action in actionBlock.getaction():

   290

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

   291

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

   292

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

   293

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

   294

                    action.setrelPosition(relPosition)

   295

   296

            return tree, None

   297

   298

        return tree, error

   299

   300

    except Exception, e:

   301

        return None, e.message

   302

   303

   304

def LoadProject(filepath):

   305

    project_file = open(filepath)

   306

    project_xml = project_file.read()

   307

    project_file.close()

   308

    return LoadProjectXML(project_xml)

   309

   310

   311

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

   312

   313

   314

def LoadPou(xml_string):

   315

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   316

    return project_pou_xpath(root)[0], error

   317

   318

   319

project_pou_instances_xpath = {

   320

    body_type: PLCOpen_XPath(

   321

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

   322

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

   323

   324

   325

def LoadPouInstances(xml_string, body_type):

   326

    root, error = LoadProjectXML(

   327

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   328

    return project_pou_instances_xpath[body_type](root), error

   329

   330

   331

def SaveProject(project, filepath):

   332

    project_file = open(filepath, 'w')

   333

    project_file.write(etree.tostring(

   334

        project,

   335

        pretty_print=True,

   336

        xml_declaration=True,

   337

        encoding='utf-8'))

   338

    project_file.close()

   339

   340

   341

# ----------------------------------------------------------------------

   342

   343

   344

def _updateFormattedTextClass(cls):

   345

    def updateElementName(self, old_name, new_name):

   346

        text = self.getanyText()

   347

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

   348

        text = pattern.sub(new_name, text)

   349

        self.setanyText(text)

   350

    setattr(cls, "updateElementName", updateElementName)

   351

   352

    def updateElementAddress(self, address_model, new_leading):

   353

        text = self.getanyText()

   354

        startpos = 0

   355

        result = address_model.search(text, startpos)

   356

        while result is not None:

   357

            groups = result.groups()

   358

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

   359

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

   360

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

   361

            result = address_model.search(text, startpos)

   362

        self.setanyText(text)

   363

    setattr(cls, "updateElementAddress", updateElementAddress)

   364

   365

    def hasblock(self, block_type):

   366

        text = self.getanyText()

   367

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

   368

        return pattern.search(text) is not None

   369

    setattr(cls, "hasblock", hasblock)

   370

   371

    def Search(self, criteria, parent_infos):

   372

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

   373

    setattr(cls, "Search", Search)

   374

   375

   376

cls = PLCOpenParser.GetElementClass("formattedText")

   377

if cls:

   378

    _updateFormattedTextClass(cls)

   379

   380

   381

# ----------------------------------------------------------------------

   382

   383

   384

def _updateProjectClass(cls):

   385

    def setname(self, name):

   386

        self.contentHeader.setname(name)

   387

    setattr(cls, "setname", setname)

   388

   389

    def getname(self):

   390

        return self.contentHeader.getname()

   391

    setattr(cls, "getname", getname)

   392

   393

    def getfileHeader(self):

   394

        fileheader_obj = self.fileHeader

   395

        return {

   396

            attr: value if value is not None else ""

   397

            for attr, value in [

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

        }

   406

    setattr(cls, "getfileHeader", getfileHeader)

   407

   408

    def setfileHeader(self, fileheader):

   409

        fileheader_obj = self.fileHeader

   410

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

   411

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

   412

                     "contentDescription"]:

   413

            value = fileheader.get(attr)

   414

            if value is not None:

   415

                setattr(fileheader_obj, attr, value)

   416

    setattr(cls, "setfileHeader", setfileHeader)

   417

   418

    def getcontentHeader(self):

   419

        contentheader_obj = self.contentHeader

   420

        contentheader = {

   421

            attr: value if value is not None else ""

   422

            for attr, value in [

   423

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

   424

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

   425

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

   426

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

   427

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

   428

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

   429

        }

   430

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

   431

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

   432

        return contentheader

   433

    setattr(cls, "getcontentHeader", getcontentHeader)

   434

   435

    def setcontentHeader(self, contentheader):

   436

        contentheader_obj = self.contentHeader

   437

        for attr, value in contentheader.iteritems():

   438

            func = {"projectName": contentheader_obj.setname,

   439

                    "projectVersion": contentheader_obj.setversion,

   440

                    "authorName": contentheader_obj.setauthor,

   441

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

   442

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

   443

            if func is not None:

   444

                func(value)

   445

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

   446

                setattr(contentheader_obj, attr, value)

   447

    setattr(cls, "setcontentHeader", setcontentHeader)

   448

   449

    def gettypeElementFunc(element_type):

   450

        elements_xpath = PLCOpen_XPath(

   451

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

   452

   453

        def gettypeElement(self, name):

   454

            elements = elements_xpath(self, name=name)

   455

            if len(elements) == 1:

   456

                return elements[0]

   457

            return None

   458

        return gettypeElement

   459

   460

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

   461

    filtered_datatypes_xpath = PLCOpen_XPath(

   462

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

   463

   464

    def getdataTypes(self, exclude=None):

   465

        if exclude is not None:

   466

            return filtered_datatypes_xpath(self, exclude=exclude)

   467

        return datatypes_xpath(self)

   468

    setattr(cls, "getdataTypes", getdataTypes)

   469

   470

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

   471

   472

    def appenddataType(self, name):

   473

        if self.getdataType(name) is not None:

   474

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

   475

        self.types.appenddataTypeElement(name)

   476

    setattr(cls, "appenddataType", appenddataType)

   477

   478

    def insertdataType(self, index, datatype):

   479

        self.types.insertdataTypeElement(index, datatype)

   480

    setattr(cls, "insertdataType", insertdataType)

   481

   482

    def removedataType(self, name):

   483

        self.types.removedataTypeElement(name)

   484

    setattr(cls, "removedataType", removedataType)

   485

   486

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

   487

        return self.xpath(

   488

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

   489

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

   490

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