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

    62

def update_address(address, address_model, new_leading):

    63

    result = address_model.match(address)

    64

    if result is None:

    65

        return address

    66

    groups = result.groups()

    67

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

    68

    69

def _init_and_compare(function, v1, v2):

    70

    if v1 is None:

    71

        return v2

    72

    if v2 is not None:

    73

        return function(v1, v2)

    74

    return v1

    75

    76

"""

    77

Helper class for bounding_box calculation

    78

"""

    79

class rect:

    80

    81

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

    82

        self.x_min = x

    83

        self.x_max = None

    84

        self.y_min = y

    85

        self.y_max = None

    86

        if width is not None and x is not None:

    87

            self.x_max = x + width

    88

        if height is not None and y is not None:

    89

            self.y_max = y + height

    90

    91

    def update(self, x, y):

    92

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

    93

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

    94

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

    95

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

    96

    97

    def union(self, rect):

    98

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

    99

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

   100

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

   101

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

   102

   103

    def bounding_box(self):

   104

        width = height = None

   105

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

   106

            width = self.x_max - self.x_min

   107

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

   108

            height = self.y_max - self.y_min

   109

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

   110

   111

def TextLenInRowColumn(text):

   112

    if text == "":

   113

        return (0, 0)

   114

    lines = text.split("\n")

   115

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

   116

   117

def CompilePattern(criteria):

   118

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

   119

    find_pattern = criteria["find_pattern"]

   120

    if not criteria["regular_expression"]:

   121

        find_pattern = re.escape(find_pattern)

   122

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

   123

   124

def TestTextElement(text, criteria):

   125

    lines = text.splitlines()

   126

    test_result = []

   127

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

   128

    while result is not None:

   129

        prev_pos=result.endpos

   130

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

   131

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

   132

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

   133

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

   134

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

   135

            break

   136

    return test_result

   137

   138

def TextMatched(str1, str2):

   139

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

   140

   141

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

   142

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

   143

   144

LOAD_POU_PROJECT_TEMPLATE = """

   145

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

   146

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

   147

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

   148

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

   149

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

   150

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

   151

  <contentHeader name="paste_project">

   152

    <coordinateInfo>

   153

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

   154

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

   155

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

   156

    </coordinateInfo>

   157

  </contentHeader>

   158

  <types>

   159

    <dataTypes/>

   160

    <pous>%s</pous>

   161

  </types>

   162

  <instances>

   163

    <configurations/>

   164

  </instances>

   165

</project>

   166

"""

   167

   168

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   169

    return LOAD_POU_PROJECT_TEMPLATE % """

   170

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

   171

  <body>

   172

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

   173

  </body>

   174

</pou>""" % locals()

   175

   176

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

   177

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   178

PLCOpen_v1_file.close()

   179

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   180

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

   181

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

   182

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

   183

   184

# XPath for file compatibility process

   185

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

   186

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

   187

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

   188

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   189

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

   190

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   191

   192

def LoadProjectXML(project_xml):

   193

    project_xml = project_xml.replace(

   194

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

   195

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

   196

    for cre, repl in [

   197

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

   198

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

   199

        project_xml = cre.sub(repl, project_xml)

   200

   201

    try:

   202

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   203

        if error is None:

   204

            return tree, None

   205

   206

        if PLCOpen_v1_xsd.validate(tree):

   207

            # Make file compatible with PLCOpen v2

   208

   209

            # Update resource interval value

   210

            for resource in ProjectResourcesXPath(tree):

   211

                for task in resource.gettask():

   212

                    interval = task.get("interval")

   213

                    if interval is not None:

   214

                        result = time_model.match(interval)

   215

                        if result is not None:

   216

                            values = result.groups()

   217

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

   218

                            seconds = float(values[2])

   219

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

   220

                            text = "T#"

   221

                            if time_values[0] != 0:

   223

                            if time_values[1] != 0:

   225

                            if time_values[2] != 0:

   227

                            if time_values[3] != 0:

   228

                                if time_values[3] % 1000 != 0:

   230

                                else:

   232

                            task.set("interval", text)

   233

   234

                # Update resources pou instance attributes

   235

                for pouInstance in ResourceInstancesXpath(resource):

   236

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

   237

                    if type_name is not None:

   238

                        pouInstance.set("typeName", type_name)

   239

   240

            # Update transitions condition

   241

            for transition_condition in TransitionsConditionXPath(tree):

   242

                connections = ConditionConnectionsXPath(transition_condition)

   243

                if len(connections) > 0:

   244

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

   245

                    transition_condition.setcontent(connectionPointIn)

   246

                    connectionPointIn.setrelPositionXY(0, 0)

   247

                    for connection in connections:

   248

                        connectionPointIn.append(connection)

   249

   250

            # Update actionBlocks

   251

            for actionBlock in ActionBlocksXPath(tree):

   252

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   253

                    actionBlock.remove(connectionPointOut)

   254

   255

                for action in actionBlock.getaction():

   256

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

   257

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

   258

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

   259

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

   260

                    action.setrelPosition(relPosition)

   261

   262

            return tree, None

   263

   264

        return tree, error

   265

   266

    except Exception, e:

   267

        return None, e.message

   268

   269

def LoadProject(filepath):

   270

    project_file = open(filepath)

   271

    project_xml = project_file.read()

   272

    project_file.close()

   273

    return LoadProjectXML(project_xml)

   274

   275

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

   276

def LoadPou(xml_string):

   277

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   278

    return project_pou_xpath(root)[0], error

   279

   280

project_pou_instances_xpath = {

   281

    body_type: PLCOpen_XPath(

   282

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

   283

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

   284

def LoadPouInstances(xml_string, body_type):

   285

    root, error = LoadProjectXML(

   286

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   287

    return project_pou_instances_xpath[body_type](root), error

   288

   289

def SaveProject(project, filepath):

   290

    project_file = open(filepath, 'w')

   291

    project_file.write(etree.tostring(

   292

        project,

   293

        pretty_print=True,

   294

        xml_declaration=True,

   295

        encoding='utf-8'))

   296

    project_file.close()

   297

   298

cls = PLCOpenParser.GetElementClass("formattedText")

   299

if cls:

   300

    def updateElementName(self, old_name, new_name):

   301

        text = self.getanyText()

   302

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

   303

        text = pattern.sub(new_name, text)

   304

        self.setanyText(text)

   305

    setattr(cls, "updateElementName", updateElementName)

   306

   307

    def updateElementAddress(self, address_model, new_leading):

   308

        text = self.getanyText()

   309

        startpos = 0

   310

        result = address_model.search(text, startpos)

   311

        while result is not None:

   312

            groups = result.groups()

   313

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

   314

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

   315

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

   316

            result = address_model.search(text, startpos)

   317

        self.setanyText(text)

   318

    setattr(cls, "updateElementAddress", updateElementAddress)

   319

   320

    def hasblock(self, block_type):

   321

        text = self.getanyText()

   322

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

   323

        return pattern.search(text) is not None

   324

    setattr(cls, "hasblock", hasblock)

   325

   326

    def Search(self, criteria, parent_infos):

   327

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

   328

    setattr(cls, "Search", Search)

   329

   330

cls = PLCOpenParser.GetElementClass("project")

   331

if cls:

   332

   333

    def setname(self, name):

   334

        self.contentHeader.setname(name)

   335

    setattr(cls, "setname", setname)

   336

   337

    def getname(self):

   338

        return self.contentHeader.getname()

   339

    setattr(cls, "getname", getname)

   340

   341

    def getfileHeader(self):

   342

        fileheader_obj = self.fileHeader

   343

        return {

   344

            attr: value if value is not None else ""

   345

            for attr, value in [

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

        }

   354

    setattr(cls, "getfileHeader", getfileHeader)

   355

   356

    def setfileHeader(self, fileheader):

   357

        fileheader_obj = self.fileHeader

   358

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

   359

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

   360

                     "contentDescription"]:

   361

            value = fileheader.get(attr)

   362

            if value is not None:

   363

                setattr(fileheader_obj, attr, value)

   364

    setattr(cls, "setfileHeader", setfileHeader)

   365

   366

    def getcontentHeader(self):

   367

        contentheader_obj = self.contentHeader

   368

        contentheader = {

   369

            attr: value if value is not None else ""

   370

            for attr, value in [

   371

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

   372

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

   373

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

   374

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

   375

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

   376

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

   377

        }

   378

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

   379

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

   380

        return contentheader

   381

    setattr(cls, "getcontentHeader", getcontentHeader)

   382

   383

    def setcontentHeader(self, contentheader):

   384

        contentheader_obj = self.contentHeader

   385

        for attr, value in contentheader.iteritems():

   386

            func = {"projectName": contentheader_obj.setname,

   387

                    "projectVersion": contentheader_obj.setversion,

   388

                    "authorName": contentheader_obj.setauthor,

   389

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

   390

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

   391

            if func is not None:

   392

                func(value)

   393

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

   394

                setattr(contentheader_obj, attr, value)

   395

    setattr(cls, "setcontentHeader", setcontentHeader)

   396

   397

    def gettypeElementFunc(element_type):

   398

        elements_xpath = PLCOpen_XPath(

   399

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

   400

        def gettypeElement(self, name):

   401

            elements = elements_xpath(self, name=name)

   402

            if len(elements) == 1:

   403

                return elements[0]

   404

            return None

   405

        return gettypeElement

   406

   407

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

   408

    filtered_datatypes_xpath = PLCOpen_XPath(

   409

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

   410

    def getdataTypes(self, exclude=None):

   411

        if exclude is not None:

   412

            return filtered_datatypes_xpath(self, exclude=exclude)

   413

        return datatypes_xpath(self)

   414

    setattr(cls, "getdataTypes", getdataTypes)

   415

   416

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

   417

   418

    def appenddataType(self, name):

   419

        if self.getdataType(name) is not None:

   421

        self.types.appenddataTypeElement(name)

   422

    setattr(cls, "appenddataType", appenddataType)

   423

   424

    def insertdataType(self, index, datatype):

   425

        self.types.insertdataTypeElement(index, datatype)

   426

    setattr(cls, "insertdataType", insertdataType)

   427

   428

    def removedataType(self, name):

   429

        self.types.removedataTypeElement(name)

   430

    setattr(cls, "removedataType", removedataType)

   431

   432

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

   433

        return self.xpath(

   434

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

   435

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

   436

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

   437

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

   438

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

   439

            namespaces=PLCOpenParser.NSMAP)

   440

    setattr(cls, "getpous", getpous)

   441

   442

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

   443

   444

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

   445

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

   446

    setattr(cls, "appendpou", appendpou)

   447

   448

    def insertpou(self, index, pou):

   449

        self.types.insertpouElement(index, pou)

   450

    setattr(cls, "insertpou", insertpou)

   451

   452

    def removepou(self, name):

   453

        self.types.removepouElement(name)

   454

    setattr(cls, "removepou", removepou)

   455

   456

    configurations_xpath = PLCOpen_XPath(

   457

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

   458

    def getconfigurations(self):

   459

        return configurations_xpath(self)

   460

    setattr(cls, "getconfigurations", getconfigurations)

   461

   462

    configuration_xpath = PLCOpen_XPath(

   463

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

   464

    def getconfiguration(self, name):

   465

        configurations = configuration_xpath(self, name=name)

   466

        if len(configurations) == 1:

   467

            return configurations[0]

   468

        return None

   469

    setattr(cls, "getconfiguration", getconfiguration)

   470

   471

    def addconfiguration(self, name):

   472

        if self.getconfiguration(name) is not None:

   473

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

   474

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

   475

        new_configuration.setname(name)

   476

        self.instances.configurations.appendconfiguration(new_configuration)

   477

    setattr(cls, "addconfiguration", addconfiguration)

   478

   479

    def removeconfiguration(self, name):

   480

        configuration = self.getconfiguration(name)

   481

        if configuration is None:

   482

            raise ValueError, ("\"%s\" configuration doesn't exist !!!") % name

   483

        self.instances.configurations.remove(configuration)

   484

    setattr(cls, "removeconfiguration", removeconfiguration)

   485

   486

    resources_xpath = PLCOpen_XPath(

   487

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

   488

    def getconfigurationResource(self, config_name, name):

   489

        resources = resources_xpath(self, configname=config_name, name=name)

   490

        if len(resources) == 1:

   491

            return resources[0]

   492

        return None

   493

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   494