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

    28

from types import *

    29

import re

    30

from collections import OrderedDict

    31

    32

from lxml import etree

    33

    34

from xmlclass import *

    35

import util.paths as paths

    36

    37

    38

#: Dictionary that makes the relation between var names

    39

#: in plcopen and displayed values

    40

    41

VarTypes = {

    42

    "Local":    "localVars",

    43

    "Temp":     "tempVars",

    44

    "Input":    "inputVars",

    45

    "Output":   "outputVars",

    46

    "InOut":    "inOutVars",

    47

    "External": "externalVars",

    48

    "Global":   "globalVars",

    49

    "Access":   "accessVars"

    50

}

    51

    52

searchResultVarTypes = {

    53

    "inputVars":  "var_input",

    54

    "outputVars": "var_output",

    55

    "inOutVars":  "var_inout"

    56

}

    57

    58

    59

#: Define in which order var types must be displayed

    60

    61

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

    62

    63

    64

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

    65

    66

QualifierList = OrderedDict([

    67

    ("N", False),

    68

    ("R", False),

    69

    ("S", False),

    70

    ("L", True),

    71

    ("D", True),

    72

    ("P", False),

    73

    ("P0", False),

    74

    ("P1", False),

    75

    ("SD", True),

    76

    ("DS", True),

    77

    ("SL", True)])

    78

    79

    80

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

    81

    82

    83

def update_address(address, address_model, new_leading):

    84

    result = address_model.match(address)

    85

    if result is None:

    86

        return address

    87

    groups = result.groups()

    88

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

    89

    90

    91

def _init_and_compare(function, v1, v2):

    92

    if v1 is None:

    93

        return v2

    94

    if v2 is not None:

    95

        return function(v1, v2)

    96

    return v1

    97

    98

    99

class rect(object):

   100

    """

   101

    Helper class for bounding_box calculation

   102

    """

   103

   104

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

   105

        self.x_min = x

   106

        self.x_max = None

   107

        self.y_min = y

   108

        self.y_max = None

   109

        if width is not None and x is not None:

   110

            self.x_max = x + width

   111

        if height is not None and y is not None:

   112

            self.y_max = y + height

   113

   114

    def update(self, x, y):

   115

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

   116

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

   117

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

   118

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

   119

   120

    def union(self, rect):

   121

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

   122

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

   123

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

   124

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

   125

   126

    def bounding_box(self):

   127

        width = height = None

   128

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

   129

            width = self.x_max - self.x_min

   130

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

   131

            height = self.y_max - self.y_min

   132

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

   133

   134

   135

def TextLenInRowColumn(text):

   136

    if text == "":

   137

        return (0, 0)

   138

    lines = text.split("\n")

   139

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

   140

   141

   142

def CompilePattern(criteria):

   143

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

   144

    find_pattern = criteria["find_pattern"]

   145

    if not criteria["regular_expression"]:

   146

        find_pattern = re.escape(find_pattern)

   147

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

   148

   149

   150

def TestTextElement(text, criteria):

   151

    lines = text.splitlines()

   152

    test_result = []

   153

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

   154

    while result is not None:

   155

        prev_pos = result.endpos

   156

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

   157

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

   158

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

   159

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

   160

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

   161

            break

   162

    return test_result

   163

   164

   165

def TextMatched(str1, str2):

   166

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

   167

   168

   169

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

   170

   171

   172

def PLCOpen_XPath(xpath):

   173

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

   174

   175

   176

LOAD_POU_PROJECT_TEMPLATE = """

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

  <contentHeader name="paste_project">

   184

    <coordinateInfo>

   185

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

   186

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

   187

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

   188

    </coordinateInfo>

   189

  </contentHeader>

   190

  <types>

   191

    <dataTypes/>

   192

    <pous>%s</pous>

   193

  </types>

   194

  <instances>

   195

    <configurations/>

   196

  </instances>

   197

</project>

   198

"""

   199

   200

   201

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   202

    return LOAD_POU_PROJECT_TEMPLATE % """

   203

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

   204

  <body>

   205

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

   206

  </body>

   207

</pou>""" % locals()

   208

   209

   210

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

   211

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   212

PLCOpen_v1_file.close()

   213

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   214

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

   215

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

   216

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

   217

   218

# XPath for file compatibility process

   219

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

   220

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

   221

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

   222

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   223

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

   224

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   225

   226

   227

def LoadProjectXML(project_xml):

   228

    project_xml = project_xml.replace(

   229

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

   230

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

   231

    for cre, repl in [

   232

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

   233

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

   234

        project_xml = cre.sub(repl, project_xml)

   235

   236

    try:

   237

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   238

        if error is None:

   239

            return tree, None

   240

   241

        if PLCOpen_v1_xsd.validate(tree):

   242

            # Make file compatible with PLCOpen v2

   243

   244

            # Update resource interval value

   245

            for resource in ProjectResourcesXPath(tree):

   246

                for task in resource.gettask():

   247

                    interval = task.get("interval")

   248

                    if interval is not None:

   249

                        result = time_model.match(interval)

   250

                        if result is not None:

   251

                            values = result.groups()

   252

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

   253

                            seconds = float(values[2])

   254

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

   255

                            text = "T#"

   256

                            if time_values[0] != 0:

   257

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

   258

                            if time_values[1] != 0:

   259

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

   260

                            if time_values[2] != 0:

   261

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

   262

                            if time_values[3] != 0:

   263

                                if time_values[3] % 1000 != 0:

   264

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

   265

                                else:

   266

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

   267

                            task.set("interval", text)

   268

   269

                # Update resources pou instance attributes

   270

                for pouInstance in ResourceInstancesXpath(resource):

   271

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

   272

                    if type_name is not None:

   273

                        pouInstance.set("typeName", type_name)

   274

   275

            # Update transitions condition

   276

            for transition_condition in TransitionsConditionXPath(tree):

   277

                connections = ConditionConnectionsXPath(transition_condition)

   278

                if len(connections) > 0:

   279

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

   280

                    transition_condition.setcontent(connectionPointIn)

   281

                    connectionPointIn.setrelPositionXY(0, 0)

   282

                    for connection in connections:

   283

                        connectionPointIn.append(connection)

   284

   285

            # Update actionBlocks

   286

            for actionBlock in ActionBlocksXPath(tree):

   287

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   288

                    actionBlock.remove(connectionPointOut)

   289

   290

                for action in actionBlock.getaction():

   291

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

   292

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

   293

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

   294

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

   295

                    action.setrelPosition(relPosition)

   296

   297

            return tree, None

   298

   299

        return tree, error

   300

   301

    except Exception, e:

   302

        return None, e.message

   303

   304

   305

def LoadProject(filepath):

   306

    project_file = open(filepath)

   307

    project_xml = project_file.read()

   308

    project_file.close()

   309

    return LoadProjectXML(project_xml)

   310

   311

   312

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

   313

   314

   315

def LoadPou(xml_string):

   316

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   317

    return project_pou_xpath(root)[0], error

   318

   319

   320

project_pou_instances_xpath = {

   321

    body_type: PLCOpen_XPath(

   322

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

   323

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

   324

   325

   326

def LoadPouInstances(xml_string, body_type):

   327

    root, error = LoadProjectXML(

   328

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   329

    return project_pou_instances_xpath[body_type](root), error

   330

   331

   332

def SaveProject(project, filepath):

   333

    project_file = open(filepath, 'w')

   334

    project_file.write(etree.tostring(

   335

        project,

   336

        pretty_print=True,

   337

        xml_declaration=True,

   338

        encoding='utf-8'))

   339

    project_file.close()

   340

   341

   342

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

   343

   344

   345

def _updateFormattedTextClass(cls):

   346

    def updateElementName(self, old_name, new_name):

   347

        text = self.getanyText()

   348

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

   349

        text = pattern.sub(new_name, text)

   350

        self.setanyText(text)

   351

    setattr(cls, "updateElementName", updateElementName)

   352

   353

    def updateElementAddress(self, address_model, new_leading):

   354

        text = self.getanyText()

   355

        startpos = 0

   356

        result = address_model.search(text, startpos)

   357

        while result is not None:

   358

            groups = result.groups()

   359

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

   360

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

   361

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

   362

            result = address_model.search(text, startpos)

   363

        self.setanyText(text)

   364

    setattr(cls, "updateElementAddress", updateElementAddress)

   365

   366

    def hasblock(self, block_type):

   367

        text = self.getanyText()

   368

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

   369

        return pattern.search(text) is not None

   370

    setattr(cls, "hasblock", hasblock)

   371

   372

    def Search(self, criteria, parent_infos):

   373

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

   374

    setattr(cls, "Search", Search)

   375

   376

   377

cls = PLCOpenParser.GetElementClass("formattedText")

   378

if cls:

   379

    _updateFormattedTextClass(cls)

   380

   381

   382

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

   383

   384

   385

def _updateProjectClass(cls):

   386

    def setname(self, name):

   387

        self.contentHeader.setname(name)

   388

    setattr(cls, "setname", setname)

   389

   390

    def getname(self):

   391

        return self.contentHeader.getname()

   392

    setattr(cls, "getname", getname)

   393

   394

    def getfileHeader(self):

   395

        fileheader_obj = self.fileHeader

   396

        return {

   397

            attr: value if value is not None else ""

   398

            for attr, value in [

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

        }

   407

    setattr(cls, "getfileHeader", getfileHeader)

   408

   409

    def setfileHeader(self, fileheader):

   410

        fileheader_obj = self.fileHeader

   411

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

   412

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

   413

                     "contentDescription"]:

   414

            value = fileheader.get(attr)

   415

            if value is not None:

   416

                setattr(fileheader_obj, attr, value)

   417

    setattr(cls, "setfileHeader", setfileHeader)

   418

   419

    def getcontentHeader(self):

   420

        contentheader_obj = self.contentHeader

   421

        contentheader = {

   422

            attr: value if value is not None else ""

   423

            for attr, value in [

   424

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

   425

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

   426

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

   427

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

   428

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

   429

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

   430

        }

   431

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

   432

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

   433

        return contentheader

   434

    setattr(cls, "getcontentHeader", getcontentHeader)

   435

   436

    def setcontentHeader(self, contentheader):

   437

        contentheader_obj = self.contentHeader

   438

        for attr, value in contentheader.iteritems():

   439

            func = {"projectName": contentheader_obj.setname,

   440

                    "projectVersion": contentheader_obj.setversion,

   441

                    "authorName": contentheader_obj.setauthor,

   442

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

   443

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

   444

            if func is not None:

   445

                func(value)

   446

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

   447

                setattr(contentheader_obj, attr, value)

   448

    setattr(cls, "setcontentHeader", setcontentHeader)

   449

   450

    def gettypeElementFunc(element_type):

   451

        elements_xpath = PLCOpen_XPath(

   452

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

   453

   454

        def gettypeElement(self, name):

   455

            elements = elements_xpath(self, name=name)

   456

            if len(elements) == 1:

   457

                return elements[0]

   458

            return None

   459

        return gettypeElement

   460

   461

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

   462

    filtered_datatypes_xpath = PLCOpen_XPath(

   463

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

   464

   465

    def getdataTypes(self, exclude=None):

   466

        if exclude is not None:

   467

            return filtered_datatypes_xpath(self, exclude=exclude)

   468

        return datatypes_xpath(self)

   469

    setattr(cls, "getdataTypes", getdataTypes)

   470

   471

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

   472

   473

    def appenddataType(self, name):

   474

        if self.getdataType(name) is not None:

   475

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

   476

        self.types.appenddataTypeElement(name)

   477

    setattr(cls, "appenddataType", appenddataType)

   478

   479

    def insertdataType(self, index, datatype):

   480

        self.types.insertdataTypeElement(index, datatype)

   481

    setattr(cls, "insertdataType", insertdataType)

   482

   483

    def removedataType(self, name):

   484

        self.types.removedataTypeElement(name)

   485

    setattr(cls, "removedataType", removedataType)

   486

   487

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

   488

        filter = [] if filter is None else filter

   489

        return self.xpath(

   490

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