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

"""

    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

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

   156

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

   157

   158

LOAD_POU_PROJECT_TEMPLATE = """

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

  <contentHeader name="paste_project">

   166

    <coordinateInfo>

   167

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

   168

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

   169

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

   170

    </coordinateInfo>

   171

  </contentHeader>

   172

  <types>

   173

    <dataTypes/>

   174

    <pous>%s</pous>

   175

  </types>

   176

  <instances>

   177

    <configurations/>

   178

  </instances>

   179

</project>

   180

"""

   181

   182

   183

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   184

    return LOAD_POU_PROJECT_TEMPLATE % """

   185

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

   186

  <body>

   187

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

   188

  </body>

   189

</pou>""" % locals()

   190

   191

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

   192

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   193

PLCOpen_v1_file.close()

   194

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   195

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

   196

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

   197

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

   198

   199

# XPath for file compatibility process

   200

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

   201

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

   202

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

   203

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   204

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

   205

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   206

   207

   208

def LoadProjectXML(project_xml):

   209

    project_xml = project_xml.replace(

   210

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

   211

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

   212

    for cre, repl in [

   213

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

   214

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

   215

        project_xml = cre.sub(repl, project_xml)

   216

   217

    try:

   218

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   219

        if error is None:

   220

            return tree, None

   221

   222

        if PLCOpen_v1_xsd.validate(tree):

   223

            # Make file compatible with PLCOpen v2

   224

   225

            # Update resource interval value

   226

            for resource in ProjectResourcesXPath(tree):

   227

                for task in resource.gettask():

   228

                    interval = task.get("interval")

   229

                    if interval is not None:

   230

                        result = time_model.match(interval)

   231

                        if result is not None:

   232

                            values = result.groups()

   233

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

   234

                            seconds = float(values[2])

   235

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

   236

                            text = "T#"

   237

                            if time_values[0] != 0:

   238

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

   239

                            if time_values[1] != 0:

   240

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

   241

                            if time_values[2] != 0:

   242

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

   243

                            if time_values[3] != 0:

   244

                                if time_values[3] % 1000 != 0:

   245

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

   246

                                else:

   247

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

   248

                            task.set("interval", text)

   249

   250

                # Update resources pou instance attributes

   251

                for pouInstance in ResourceInstancesXpath(resource):

   252

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

   253

                    if type_name is not None:

   254

                        pouInstance.set("typeName", type_name)

   255

   256

            # Update transitions condition

   257

            for transition_condition in TransitionsConditionXPath(tree):

   258

                connections = ConditionConnectionsXPath(transition_condition)

   259

                if len(connections) > 0:

   260

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

   261

                    transition_condition.setcontent(connectionPointIn)

   262

                    connectionPointIn.setrelPositionXY(0, 0)

   263

                    for connection in connections:

   264

                        connectionPointIn.append(connection)

   265

   266

            # Update actionBlocks

   267

            for actionBlock in ActionBlocksXPath(tree):

   268

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   269

                    actionBlock.remove(connectionPointOut)

   270

   271

                for action in actionBlock.getaction():

   272

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

   273

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

   274

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

   275

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

   276

                    action.setrelPosition(relPosition)

   277

   278

            return tree, None

   279

   280

        return tree, error

   281

   282

    except Exception, e:

   283

        return None, e.message

   284

   285

   286

def LoadProject(filepath):

   287

    project_file = open(filepath)

   288

    project_xml = project_file.read()

   289

    project_file.close()

   290

    return LoadProjectXML(project_xml)

   291

   292

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

   293

   294

   295

def LoadPou(xml_string):

   296

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   297

    return project_pou_xpath(root)[0], error

   298

   299

project_pou_instances_xpath = {

   300

    body_type: PLCOpen_XPath(

   301

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

   302

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

   303

   304

   305

def LoadPouInstances(xml_string, body_type):

   306

    root, error = LoadProjectXML(

   307

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   308

    return project_pou_instances_xpath[body_type](root), error

   309

   310

   311

def SaveProject(project, filepath):

   312

    project_file = open(filepath, 'w')

   313

    project_file.write(etree.tostring(

   314

        project,

   315

        pretty_print=True,

   316

        xml_declaration=True,

   317

        encoding='utf-8'))

   318

    project_file.close()

   319

   320

cls = PLCOpenParser.GetElementClass("formattedText")

   321

if cls:

   322

    def updateElementName(self, old_name, new_name):

   323

        text = self.getanyText()

   324

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

   325

        text = pattern.sub(new_name, text)

   326

        self.setanyText(text)

   327

    setattr(cls, "updateElementName", updateElementName)

   328

   329

    def updateElementAddress(self, address_model, new_leading):

   330

        text = self.getanyText()

   331

        startpos = 0

   332

        result = address_model.search(text, startpos)

   333

        while result is not None:

   334

            groups = result.groups()

   335

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

   336

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

   337

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

   338

            result = address_model.search(text, startpos)

   339

        self.setanyText(text)

   340

    setattr(cls, "updateElementAddress", updateElementAddress)

   341

   342

    def hasblock(self, block_type):

   343

        text = self.getanyText()

   344

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

   345

        return pattern.search(text) is not None

   346

    setattr(cls, "hasblock", hasblock)

   347

   348

    def Search(self, criteria, parent_infos):

   349

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

   350

    setattr(cls, "Search", Search)

   351

   352

cls = PLCOpenParser.GetElementClass("project")

   353

if cls:

   354

   355

    def setname(self, name):

   356

        self.contentHeader.setname(name)

   357

    setattr(cls, "setname", setname)

   358

   359

    def getname(self):

   360

        return self.contentHeader.getname()

   361

    setattr(cls, "getname", getname)

   362

   363

    def getfileHeader(self):

   364

        fileheader_obj = self.fileHeader

   365

        return {

   366

            attr: value if value is not None else ""

   367

            for attr, value in [

   368

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

   369

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

   370

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

   371

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

   372

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

   373

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

   374

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

   375

        }

   376

    setattr(cls, "getfileHeader", getfileHeader)

   377

   378

    def setfileHeader(self, fileheader):

   379

        fileheader_obj = self.fileHeader

   380

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

   381

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

   382

                     "contentDescription"]:

   383

            value = fileheader.get(attr)

   384

            if value is not None:

   385

                setattr(fileheader_obj, attr, value)

   386

    setattr(cls, "setfileHeader", setfileHeader)

   387

   388

    def getcontentHeader(self):

   389

        contentheader_obj = self.contentHeader

   390

        contentheader = {

   391

            attr: value if value is not None else ""

   392

            for attr, value in [

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

        }

   400

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

   401

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

   402

        return contentheader

   403

    setattr(cls, "getcontentHeader", getcontentHeader)

   404

   405

    def setcontentHeader(self, contentheader):

   406

        contentheader_obj = self.contentHeader

   407

        for attr, value in contentheader.iteritems():

   408

            func = {"projectName": contentheader_obj.setname,

   409

                    "projectVersion": contentheader_obj.setversion,

   410

                    "authorName": contentheader_obj.setauthor,

   411

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

   412

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

   413

            if func is not None:

   414

                func(value)

   415

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

   416

                setattr(contentheader_obj, attr, value)

   417

    setattr(cls, "setcontentHeader", setcontentHeader)

   418

   419

    def gettypeElementFunc(element_type):

   420

        elements_xpath = PLCOpen_XPath(

   421

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

   422

        def gettypeElement(self, name):

   423

            elements = elements_xpath(self, name=name)

   424

            if len(elements) == 1:

   425

                return elements[0]

   426

            return None

   427

        return gettypeElement

   428

   429

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

   430

    filtered_datatypes_xpath = PLCOpen_XPath(

   431

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

   432

    def getdataTypes(self, exclude=None):

   433

        if exclude is not None:

   434

            return filtered_datatypes_xpath(self, exclude=exclude)

   435

        return datatypes_xpath(self)

   436

    setattr(cls, "getdataTypes", getdataTypes)

   437

   438

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

   439

   440

    def appenddataType(self, name):

   441

        if self.getdataType(name) is not None:

   442

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

   443

        self.types.appenddataTypeElement(name)

   444

    setattr(cls, "appenddataType", appenddataType)

   445

   446

    def insertdataType(self, index, datatype):

   447

        self.types.insertdataTypeElement(index, datatype)

   448

    setattr(cls, "insertdataType", insertdataType)

   449

   450

    def removedataType(self, name):

   451

        self.types.removedataTypeElement(name)

   452

    setattr(cls, "removedataType", removedataType)

   453

   454

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

   455

        return self.xpath(

   456

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

   457

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

   458

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

   459

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

   460

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

   461

            namespaces=PLCOpenParser.NSMAP)

   462

    setattr(cls, "getpous", getpous)

   463

   464

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

   465

   466

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

   467

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

   468

    setattr(cls, "appendpou", appendpou)

   469

   470

    def insertpou(self, index, pou):

   471

        self.types.insertpouElement(index, pou)

   472

    setattr(cls, "insertpou", insertpou)

   473

   474

    def removepou(self, name):

   475

        self.types.removepouElement(name)

   476

    setattr(cls, "removepou", removepou)

   477

   478

    configurations_xpath = PLCOpen_XPath(

   479

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

   480

    def getconfigurations(self):

   481

        return configurations_xpath(self)

   482

    setattr(cls, "getconfigurations", getconfigurations)

   483

   484

    configuration_xpath = PLCOpen_XPath(

   485

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

   486

    def getconfiguration(self, name):

   487

        configurations = configuration_xpath(self, name=name)

   488

        if len(configurations) == 1:

   489

            return configurations[0]

   490

        return None

   491

    setattr(cls, "getconfiguration", getconfiguration)

   492