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 = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",

    38

            "Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars",

    39

            "Global" : "globalVars", "Access" : "accessVars"}

    40

    41

searchResultVarTypes = {

    42

    "inputVars": "var_input",

    43

    "outputVars": "var_output",

    44

    "inOutVars": "var_inout"

    45

}

    46

    47

"""

    48

Define in which order var types must be displayed

    49

"""

    50

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

    51

    52

"""

    53

Define which action qualifier must be associated with a duration

    54

"""

    55

QualifierList = OrderedDict([("N", False), ("R", False), ("S", False),

    56

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

    57

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

    58

    59

    60

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

    61

    63

def update_address(address, address_model, new_leading):

    64

    result = address_model.match(address)

    65

    if result is None:

    66

        return address

    67

    groups = result.groups()

    68

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

    69

    71

def _init_and_compare(function, v1, v2):

    72

    if v1 is None:

    73

        return v2

    74

    if v2 is not None:

    75

        return function(v1, v2)

    76

    return v1

    77

    79

class rect:

    83

    84

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

    85

        self.x_min = x

    86

        self.x_max = None

    87

        self.y_min = y

    88

        self.y_max = None

    89

        if width is not None and x is not None:

    90

            self.x_max = x + width

    91

        if height is not None and y is not None:

    92

            self.y_max = y + height

    93

    94

    def update(self, x, y):

    95

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

    96

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

    97

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

    98

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

    99

   100

    def union(self, rect):

   101

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

   102

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

   103

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

   104

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

   105

   106

    def bounding_box(self):

   107

        width = height = None

   108

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

   109

            width = self.x_max - self.x_min

   110

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

   111

            height = self.y_max - self.y_min

   112

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

   113

   115

def TextLenInRowColumn(text):

   116

    if text == "":

   117

        return (0, 0)

   118

    lines = text.split("\n")

   119

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

   120

   122

def CompilePattern(criteria):

   123

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

   124

    find_pattern = criteria["find_pattern"]

   125

    if not criteria["regular_expression"]:

   126

        find_pattern = re.escape(find_pattern)

   127

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

   128

   130

def TestTextElement(text, criteria):

   131

    lines = text.splitlines()

   132

    test_result = []

   133

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

   134

    while result is not None:

   135

        prev_pos=result.endpos

   136

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

   137

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

   138

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

   139

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

   140

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

   141

            break

   142

    return test_result

   143

   145

def TextMatched(str1, str2):

   146

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

   147

   148

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

   149

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

   150

   151

LOAD_POU_PROJECT_TEMPLATE = """

   152

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

   153

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

   154

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

   155

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

   156

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

   157

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

   158

  <contentHeader name="paste_project">

   159

    <coordinateInfo>

   160

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

   161

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

   162

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

   163

    </coordinateInfo>

   164

  </contentHeader>

   165

  <types>

   166

    <dataTypes/>

   167

    <pous>%s</pous>

   168

  </types>

   169

  <instances>

   170

    <configurations/>

   171

  </instances>

   172

</project>

   173

"""

   174

   176

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   177

    return LOAD_POU_PROJECT_TEMPLATE % """

   178

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

   179

  <body>

   180

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

   181

  </body>

   182

</pou>""" % locals()

   183

   184

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

   185

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   186

PLCOpen_v1_file.close()

   187

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   188

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

   189

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

   190

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

   191

   192

# XPath for file compatibility process

   193

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

   194

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

   195

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

   196

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   197

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

   198

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   199

   201

def LoadProjectXML(project_xml):

   202

    project_xml = project_xml.replace(

   203

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

   204

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

   205

    for cre, repl in [

   206

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

   207

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

   208

        project_xml = cre.sub(repl, project_xml)

   209

   210

    try:

   211

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   212

        if error is None:

   213

            return tree, None

   214

   215

        if PLCOpen_v1_xsd.validate(tree):

   216

            # Make file compatible with PLCOpen v2

   217

   218

            # Update resource interval value

   219

            for resource in ProjectResourcesXPath(tree):

   220

                for task in resource.gettask():

   221

                    interval = task.get("interval")

   222

                    if interval is not None:

   223

                        result = time_model.match(interval)

   224

                        if result is not None:

   225

                            values = result.groups()

   226

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

   227

                            seconds = float(values[2])

   228

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

   229

                            text = "T#"

   230

                            if time_values[0] != 0:

   231

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

   232

                            if time_values[1] != 0:

   233

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

   234

                            if time_values[2] != 0:

   235

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

   236

                            if time_values[3] != 0:

   237

                                if time_values[3] % 1000 != 0:

   238

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

   239

                                else:

   240

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

   241

                            task.set("interval", text)

   242

   243

                # Update resources pou instance attributes

   244

                for pouInstance in ResourceInstancesXpath(resource):

   245

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

   246

                    if type_name is not None:

   247

                        pouInstance.set("typeName", type_name)

   248

   249

            # Update transitions condition

   250

            for transition_condition in TransitionsConditionXPath(tree):

   251

                connections = ConditionConnectionsXPath(transition_condition)

   252

                if len(connections) > 0:

   253

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

   254

                    transition_condition.setcontent(connectionPointIn)

   255

                    connectionPointIn.setrelPositionXY(0, 0)

   256

                    for connection in connections:

   257

                        connectionPointIn.append(connection)

   258

   259

            # Update actionBlocks

   260

            for actionBlock in ActionBlocksXPath(tree):

   261

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   262

                    actionBlock.remove(connectionPointOut)

   263

   264

                for action in actionBlock.getaction():

   265

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

   266

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

   267

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

   268

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

   269

                    action.setrelPosition(relPosition)

   270

   271

            return tree, None

   272

   273

        return tree, error

   274

   275

    except Exception, e:

   276

        return None, e.message

   277

   279

def LoadProject(filepath):

   280

    project_file = open(filepath)

   281

    project_xml = project_file.read()

   282

    project_file.close()

   283

    return LoadProjectXML(project_xml)

   284

   285

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

   288

def LoadPou(xml_string):

   289

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   290

    return project_pou_xpath(root)[0], error

   291

   292

project_pou_instances_xpath = {

   293

    body_type: PLCOpen_XPath(

   294

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

   295

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

   298

def LoadPouInstances(xml_string, body_type):

   299

    root, error = LoadProjectXML(

   300

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   301

    return project_pou_instances_xpath[body_type](root), error

   302

   304

def SaveProject(project, filepath):

   305

    project_file = open(filepath, 'w')

   306

    project_file.write(etree.tostring(

   307

        project,

   308

        pretty_print=True,

   309

        xml_declaration=True,

   310

        encoding='utf-8'))

   311

    project_file.close()

   312

   313

cls = PLCOpenParser.GetElementClass("formattedText")

   314

if cls:

   315

    def updateElementName(self, old_name, new_name):

   316

        text = self.getanyText()

   317

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

   318

        text = pattern.sub(new_name, text)

   319

        self.setanyText(text)

   320

    setattr(cls, "updateElementName", updateElementName)

   321

   322

    def updateElementAddress(self, address_model, new_leading):

   323

        text = self.getanyText()

   324

        startpos = 0

   325

        result = address_model.search(text, startpos)

   326

        while result is not None:

   327

            groups = result.groups()

   328

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

   329

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

   330

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

   331

            result = address_model.search(text, startpos)

   332

        self.setanyText(text)

   333

    setattr(cls, "updateElementAddress", updateElementAddress)

   334

   335

    def hasblock(self, block_type):

   336

        text = self.getanyText()

   337

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

   338

        return pattern.search(text) is not None

   339

    setattr(cls, "hasblock", hasblock)

   340

   341

    def Search(self, criteria, parent_infos):

   342

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

   343

    setattr(cls, "Search", Search)

   344

   345

cls = PLCOpenParser.GetElementClass("project")

   346

if cls:

   347

   348

    def setname(self, name):

   349

        self.contentHeader.setname(name)

   350

    setattr(cls, "setname", setname)

   351

   352

    def getname(self):

   353

        return self.contentHeader.getname()

   354

    setattr(cls, "getname", getname)

   355

   356

    def getfileHeader(self):

   357

        fileheader_obj = self.fileHeader

   358

        return {

   359

            attr: value if value is not None else ""

   360

            for attr, value in [

   361

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

   362

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

   363

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

   364

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

   365

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

   366

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

   367

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

   368

        }

   369

    setattr(cls, "getfileHeader", getfileHeader)

   370

   371

    def setfileHeader(self, fileheader):

   372

        fileheader_obj = self.fileHeader

   373

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

   374

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

   375

                     "contentDescription"]:

   376

            value = fileheader.get(attr)

   377

            if value is not None:

   378

                setattr(fileheader_obj, attr, value)

   379

    setattr(cls, "setfileHeader", setfileHeader)

   380

   381

    def getcontentHeader(self):

   382

        contentheader_obj = self.contentHeader

   383

        contentheader = {

   384

            attr: value if value is not None else ""

   385

            for attr, value in [

   386

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

   387

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

   388

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

   389

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

   390

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

   391

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

   392

        }

   393

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

   394

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

   395

        return contentheader

   396

    setattr(cls, "getcontentHeader", getcontentHeader)

   397

   398

    def setcontentHeader(self, contentheader):

   399

        contentheader_obj = self.contentHeader

   400

        for attr, value in contentheader.iteritems():

   401

            func = {"projectName": contentheader_obj.setname,

   402

                    "projectVersion": contentheader_obj.setversion,

   403

                    "authorName": contentheader_obj.setauthor,

   404

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

   405

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

   406

            if func is not None:

   407

                func(value)

   408

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

   409

                setattr(contentheader_obj, attr, value)

   410

    setattr(cls, "setcontentHeader", setcontentHeader)

   411

   412

    def gettypeElementFunc(element_type):

   413

        elements_xpath = PLCOpen_XPath(

   414

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

   415

        def gettypeElement(self, name):

   416

            elements = elements_xpath(self, name=name)

   417

            if len(elements) == 1:

   418

                return elements[0]

   419

            return None

   420

        return gettypeElement

   421

   422

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

   423

    filtered_datatypes_xpath = PLCOpen_XPath(

   424

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

   425

    def getdataTypes(self, exclude=None):

   426

        if exclude is not None:

   427

            return filtered_datatypes_xpath(self, exclude=exclude)

   428

        return datatypes_xpath(self)

   429

    setattr(cls, "getdataTypes", getdataTypes)

   430

   431

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

   432

   433

    def appenddataType(self, name):

   434

        if self.getdataType(name) is not None:

   435

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

   436

        self.types.appenddataTypeElement(name)

   437

    setattr(cls, "appenddataType", appenddataType)

   438

   439

    def insertdataType(self, index, datatype):

   440

        self.types.insertdataTypeElement(index, datatype)

   441

    setattr(cls, "insertdataType", insertdataType)

   442

   443

    def removedataType(self, name):

   444

        self.types.removedataTypeElement(name)

   445

    setattr(cls, "removedataType", removedataType)

   446

   447

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

   448

        return self.xpath(

   449

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

   450

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

   451

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

   452

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

   453

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

   454

            namespaces=PLCOpenParser.NSMAP)

   455

    setattr(cls, "getpous", getpous)

   456

   457

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

   458

   459

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

   460

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

   461

    setattr(cls, "appendpou", appendpou)

   462

   463

    def insertpou(self, index, pou):

   464

        self.types.insertpouElement(index, pou)

   465

    setattr(cls, "insertpou", insertpou)

   466

   467

    def removepou(self, name):

   468

        self.types.removepouElement(name)

   469

    setattr(cls, "removepou", removepou)

   470

   471

    configurations_xpath = PLCOpen_XPath(

   472

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

   473

    def getconfigurations(self):

   474

        return configurations_xpath(self)

   475

    setattr(cls, "getconfigurations", getconfigurations)

   476

   477

    configuration_xpath = PLCOpen_XPath(

   478

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

   479

    def getconfiguration(self, name):

   480

        configurations = configuration_xpath(self, name=name)

   481

        if len(configurations) == 1:

   482

            return configurations[0]

   483

        return None

   484

    setattr(cls, "getconfiguration", getconfiguration)

   485

   486

    def addconfiguration(self, name):

   487

        if self.getconfiguration(name) is not None:

   488

            raise ValueError, _("\"%s\" configuration already exists !!!") % name

   489

        new_configuration = PLCOpenParser.CreateElement("configuration", "configurations")

   490

        new_configuration.setname(name)

   491

        self.instances.configurations.appendconfiguration(new_configuration)

   492

    setattr(cls, "addconfiguration", addconfiguration)

   493