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

    31

from lxml import etree

    34

import util.paths as paths

    35

    36

"""

    37

Dictionary that makes the relation between var names in plcopen and displayed values

    38

"""

    39

VarTypes = {

    40

    "Local":    "localVars",

    41

    "Temp":     "tempVars",

    42

    "Input":    "inputVars",

    43

    "Output":   "outputVars",

    44

    "InOut":    "inOutVars",

    45

    "External": "externalVars",

    46

    "Global":   "globalVars",

    47

    "Access":   "accessVars"

    48

}

    49

    50

searchResultVarTypes = {

    51

    "inputVars":  "var_input",

    52

    "outputVars": "var_output",

    53

    "inOutVars":  "var_inout"

    54

}

    55

    56

"""

    57

Define in which order var types must be displayed

    58

"""

    59

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

    60

    61

"""

    62

Define which action qualifier must be associated with a duration

    63

"""

    64

QualifierList = OrderedDict([

    65

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

    66

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

    67

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

    68

    69

    70

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

    71

    72

    73

def update_address(address, address_model, new_leading):

    74

    result = address_model.match(address)

    75

    if result is None:

    76

        return address

    77

    groups = result.groups()

    78

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

    79

    80

    81

def _init_and_compare(function, v1, v2):

    82

    if v1 is None:

    83

        return v2

    84

    if v2 is not None:

    85

        return function(v1, v2)

    86

    return v1

    87

    88

    89

class rect(object):

    90

    """

    91

    Helper class for bounding_box calculation

    92

    """

    93

    94

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

    95

        self.x_min = x

    96

        self.x_max = None

    97

        self.y_min = y

    98

        self.y_max = None

    99

        if width is not None and x is not None:

   100

            self.x_max = x + width

   101

        if height is not None and y is not None:

   102

            self.y_max = y + height

   103

   104

    def update(self, x, y):

   105

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

   106

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

   107

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

   108

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

   109

   110

    def union(self, rect):

   111

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

   112

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

   113

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

   114

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

   115

   116

    def bounding_box(self):

   117

        width = height = None

   118

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

   119

            width = self.x_max - self.x_min

   120

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

   121

            height = self.y_max - self.y_min

   122

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

   123

   124

   125

def TextLenInRowColumn(text):

   126

    if text == "":

   127

        return (0, 0)

   128

    lines = text.split("\n")

   129

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

   130

   131

   132

def CompilePattern(criteria):

   133

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

   134

    find_pattern = criteria["find_pattern"]

   135

    if not criteria["regular_expression"]:

   136

        find_pattern = re.escape(find_pattern)

   137

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

   138

   139

   140

def TestTextElement(text, criteria):

   141

    lines = text.splitlines()

   142

    test_result = []

   143

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

   144

    while result is not None:

   145

        prev_pos = result.endpos

   146

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

   147

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

   148

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

   149

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

   150

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

   151

            break

   152

    return test_result

   153

   154

   155

def TextMatched(str1, str2):

   156

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

   157

   158

   159

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

   160

   161

   162

def PLCOpen_XPath(xpath):

   163

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

   164

   165

   166

LOAD_POU_PROJECT_TEMPLATE = """

   167

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

   168

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

   169

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

   170

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

   171

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

   172

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

   173

  <contentHeader name="paste_project">

   174

    <coordinateInfo>

   175

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

   176

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

   177

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

   178

    </coordinateInfo>

   179

  </contentHeader>

   180

  <types>

   181

    <dataTypes/>

   182

    <pous>%s</pous>

   183

  </types>

   184

  <instances>

   185

    <configurations/>

   186

  </instances>

   187

</project>

   188

"""

   189

   190

   191

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   192

    return LOAD_POU_PROJECT_TEMPLATE % """

   193

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

   194

  <body>

   195

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

   196

  </body>

   197

</pou>""" % locals()

   198

   199

   200

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

   201

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   202

PLCOpen_v1_file.close()

   203

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   204

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

   205

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

   206

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

   207

   208

# XPath for file compatibility process

   209

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

   210

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

   211

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

   212

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   213

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

   214

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   215

   216

   217

def LoadProjectXML(project_xml):

   218

    project_xml = project_xml.replace(

   219

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

   220

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

   221

    for cre, repl in [

   222

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

   223

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

   224

        project_xml = cre.sub(repl, project_xml)

   225

   226

    try:

   227

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   228

        if error is None:

   229

            return tree, None

   230

   231

        if PLCOpen_v1_xsd.validate(tree):

   232

            # Make file compatible with PLCOpen v2

   233

   234

            # Update resource interval value

   235

            for resource in ProjectResourcesXPath(tree):

   236

                for task in resource.gettask():

   237

                    interval = task.get("interval")

   238

                    if interval is not None:

   239

                        result = time_model.match(interval)

   240

                        if result is not None:

   241

                            values = result.groups()

   242

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

   243

                            seconds = float(values[2])

   244

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

   245

                            text = "T#"

   246

                            if time_values[0] != 0:

   247

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

   248

                            if time_values[1] != 0:

   249

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

   250

                            if time_values[2] != 0:

   251

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

   252

                            if time_values[3] != 0:

   253

                                if time_values[3] % 1000 != 0:

   254

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

   255

                                else:

   256

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

   257

                            task.set("interval", text)

   258

   259

                # Update resources pou instance attributes

   260

                for pouInstance in ResourceInstancesXpath(resource):

   261

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

   262

                    if type_name is not None:

   263

                        pouInstance.set("typeName", type_name)

   264

   265

            # Update transitions condition

   266

            for transition_condition in TransitionsConditionXPath(tree):

   267

                connections = ConditionConnectionsXPath(transition_condition)

   268

                if len(connections) > 0:

   269

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

   270

                    transition_condition.setcontent(connectionPointIn)

   271

                    connectionPointIn.setrelPositionXY(0, 0)

   272

                    for connection in connections:

   273

                        connectionPointIn.append(connection)

   274

   275

            # Update actionBlocks

   276

            for actionBlock in ActionBlocksXPath(tree):

   277

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   278

                    actionBlock.remove(connectionPointOut)

   279

   280

                for action in actionBlock.getaction():

   281

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

   282

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

   283

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

   284

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

   285

                    action.setrelPosition(relPosition)

   286

   287

            return tree, None

   288

   289

        return tree, error

   290

   291

    except Exception, e:

   292

        return None, e.message

   293

   294

   295

def LoadProject(filepath):

   296

    project_file = open(filepath)

   297

    project_xml = project_file.read()

   298

    project_file.close()

   299

    return LoadProjectXML(project_xml)

   300

   301

   302

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

   303

   304

   305

def LoadPou(xml_string):

   306

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   307

    return project_pou_xpath(root)[0], error

   308

   309

   310

project_pou_instances_xpath = {

   311

    body_type: PLCOpen_XPath(

   312

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

   313

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

   314

   315

   316

def LoadPouInstances(xml_string, body_type):

   317

    root, error = LoadProjectXML(

   318

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   319

    return project_pou_instances_xpath[body_type](root), error

   320

   321

   322

def SaveProject(project, filepath):

   323

    project_file = open(filepath, 'w')

   324

    project_file.write(etree.tostring(

   325

        project,

   326

        pretty_print=True,

   327

        xml_declaration=True,

   328

        encoding='utf-8'))

   329

    project_file.close()

   330

   331

   332

cls = PLCOpenParser.GetElementClass("formattedText")

   333

if cls:

   334

    def updateElementName(self, old_name, new_name):

   335

        text = self.getanyText()

   336

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

   337

        text = pattern.sub(new_name, text)

   338

        self.setanyText(text)

   339

    setattr(cls, "updateElementName", updateElementName)

   340

   341

    def updateElementAddress(self, address_model, new_leading):

   342

        text = self.getanyText()

   343

        startpos = 0

   344

        result = address_model.search(text, startpos)

   345

        while result is not None:

   346

            groups = result.groups()

   347

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

   348

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

   349

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

   350

            result = address_model.search(text, startpos)

   351

        self.setanyText(text)

   352

    setattr(cls, "updateElementAddress", updateElementAddress)

   353

   354

    def hasblock(self, block_type):

   355

        text = self.getanyText()

   356

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

   357

        return pattern.search(text) is not None

   358

    setattr(cls, "hasblock", hasblock)

   359

   360

    def Search(self, criteria, parent_infos):

   361

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

   362

    setattr(cls, "Search", Search)

   363

   364

cls = PLCOpenParser.GetElementClass("project")

   365

if cls:

   366

   367

    def setname(self, name):

   368

        self.contentHeader.setname(name)

   369

    setattr(cls, "setname", setname)

   370

   371

    def getname(self):

   372

        return self.contentHeader.getname()

   373

    setattr(cls, "getname", getname)

   374

   375

    def getfileHeader(self):

   376

        fileheader_obj = self.fileHeader

   377

        return {

   378

            attr: value if value is not None else ""

   379

            for attr, value in [

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

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

   387

        }

   388

    setattr(cls, "getfileHeader", getfileHeader)

   389

   390

    def setfileHeader(self, fileheader):

   391

        fileheader_obj = self.fileHeader

   392

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

   393

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

   394

                     "contentDescription"]:

   395

            value = fileheader.get(attr)

   396

            if value is not None:

   397

                setattr(fileheader_obj, attr, value)

   398

    setattr(cls, "setfileHeader", setfileHeader)

   399

   400

    def getcontentHeader(self):

   401

        contentheader_obj = self.contentHeader

   402

        contentheader = {

   403

            attr: value if value is not None else ""

   404

            for attr, value in [

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

        }

   412

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

   413

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

   414

        return contentheader

   415

    setattr(cls, "getcontentHeader", getcontentHeader)

   416

   417

    def setcontentHeader(self, contentheader):

   418

        contentheader_obj = self.contentHeader

   419

        for attr, value in contentheader.iteritems():

   420

            func = {"projectName": contentheader_obj.setname,

   421

                    "projectVersion": contentheader_obj.setversion,

   422

                    "authorName": contentheader_obj.setauthor,

   423

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

   424

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

   425

            if func is not None:

   426

                func(value)

   427

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

   428

                setattr(contentheader_obj, attr, value)

   429

    setattr(cls, "setcontentHeader", setcontentHeader)

   430

   431

    def gettypeElementFunc(element_type):

   432

        elements_xpath = PLCOpen_XPath(

   433

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

   434

   435

        def gettypeElement(self, name):

   436

            elements = elements_xpath(self, name=name)

   437

            if len(elements) == 1:

   438

                return elements[0]

   439

            return None

   440

        return gettypeElement

   441

   442

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

   443

    filtered_datatypes_xpath = PLCOpen_XPath(

   444

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

   445

   446

    def getdataTypes(self, exclude=None):

   447

        if exclude is not None:

   448

            return filtered_datatypes_xpath(self, exclude=exclude)

   449

        return datatypes_xpath(self)

   450

    setattr(cls, "getdataTypes", getdataTypes)

   451

   452

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

   453

   454

    def appenddataType(self, name):

   455

        if self.getdataType(name) is not None:

   456

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

   457

        self.types.appenddataTypeElement(name)

   458

    setattr(cls, "appenddataType", appenddataType)

   459

   460

    def insertdataType(self, index, datatype):

   461

        self.types.insertdataTypeElement(index, datatype)

   462

    setattr(cls, "insertdataType", insertdataType)

   463

   464

    def removedataType(self, name):

   465

        self.types.removedataTypeElement(name)

   466

    setattr(cls, "removedataType", removedataType)

   467

   468

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

   469

        return self.xpath(

   470

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

   471

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

   472

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

   473

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

   474

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

   475

            namespaces=PLCOpenParser.NSMAP)

   476

    setattr(cls, "getpous", getpous)

   477

   478

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

   479

   480

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

   481

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

   482

    setattr(cls, "appendpou", appendpou)

   483

   484

    def insertpou(self, index, pou):

   485

        self.types.insertpouElement(index, pou)

   486

    setattr(cls, "insertpou", insertpou)

   487

   488

    def removepou(self, name):

   489

        self.types.removepouElement(name)

   490

    setattr(cls, "removepou", removepou)

   491