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, re

    29

from lxml import etree

    30

from collections import OrderedDict

    31

import util.paths as paths

    32

    33

"""

    34

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

    35

"""

    36

VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",

    37

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

    38

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

    39

    40

searchResultVarTypes = {

    41

    "inputVars": "var_input",

    42

    "outputVars": "var_output",

    43

    "inOutVars": "var_inout"

    44

}

    45

    46

"""

    47

Define in which order var types must be displayed

    48

"""

    49

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

    50

    51

"""

    52

Define which action qualifier must be associated with a duration 

    53

"""

    54

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

    55

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

    56

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

    57

    58

    59

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

    60

    61

def update_address(address, address_model, new_leading):

    62

    result = address_model.match(address)

    63

    if result is None:

    64

        return address

    65

    groups = result.groups()

    66

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

    67

    68

def _init_and_compare(function, v1, v2):

    69

    if v1 is None:

    70

        return v2

    71

    if v2 is not None:

    72

        return function(v1, v2)

    73

    return v1

    74

    75

"""

    76

Helper class for bounding_box calculation 

    77

"""

    78

class rect:

    79

    80

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

    81

        self.x_min = x

    82

        self.x_max = None

    83

        self.y_min = y

    84

        self.y_max = None

    85

        if width is not None and x is not None:

    86

            self.x_max = x + width

    87

        if height is not None and y is not None:

    88

            self.y_max = y + height

    89

    90

    def update(self, x, y):

    91

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

    92

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

    93

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

    94

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

    95

    96

    def union(self, rect):

    97

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

    98

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

    99

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

   100

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

   101

   102

    def bounding_box(self):

   103

        width = height = None

   104

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

   105

            width = self.x_max - self.x_min

   106

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

   107

            height = self.y_max - self.y_min

   108

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

   109

   110

def TextLenInRowColumn(text):

   111

    if text == "":

   112

        return (0, 0)

   113

    lines = text.split("\n")

   114

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

   115

   116

def CompilePattern(criteria):

   117

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

   118

    find_pattern = criteria["find_pattern"]

   119

    if not criteria["regular_expression"]:

   120

        find_pattern = re.escape(find_pattern)

   121

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

   122

   123

def TestTextElement(text, criteria):

   124

    lines = text.splitlines()

   125

    test_result = []

   126

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

   127

    while result is not None:

   128

        prev_pos=result.endpos        

   129

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

   130

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

   131

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

   132

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

   133

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

   134

            break

   135

    return test_result

   136

   137

def TextMatched(str1, str2):

   138

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

   139

   140

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

   141

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

   142

   143

LOAD_POU_PROJECT_TEMPLATE = """

   144

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

   145

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

   146

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

   147

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

   148

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

   149

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

   150

  <contentHeader name="paste_project">

   151

    <coordinateInfo>

   152

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

   153

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

   154

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

   155

    </coordinateInfo>

   156

  </contentHeader>

   157

  <types>

   158

    <dataTypes/>

   159

    <pous>%s</pous>

   160

  </types>

   161

  <instances>

   162

    <configurations/>

   163

  </instances>

   164

</project>

   165

"""

   166

   167

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   168

    return LOAD_POU_PROJECT_TEMPLATE % """

   169

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

   170

  <body>

   171

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

   172

  </body>

   173

</pou>""" % locals()

   174

   175

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

   176

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   177

PLCOpen_v1_file.close()

   178

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   179

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

   180

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

   181

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

   182

   183

# XPath for file compatibility process

   184

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

   185

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

   186

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

   187

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   188

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

   189

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   190

   191

def LoadProjectXML(project_xml):

   192

    project_xml = project_xml.replace(

   193

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

   194

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

   195

    for cre, repl in [

   196

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

   197

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

   198

        project_xml = cre.sub(repl, project_xml)

   199

   200

    try:

   201

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   202

        if error is None:

   203

            return tree, None

   204

   205

        if PLCOpen_v1_xsd.validate(tree):

   206

            # Make file compatible with PLCOpen v2

   207

   208

            # Update resource interval value

   209

            for resource in ProjectResourcesXPath(tree):

   210

                for task in resource.gettask():

   211

                    interval = task.get("interval")

   212

                    if interval is not None:

   213

                        result = time_model.match(interval)

   214

                        if result is not None:

   215

                            values = result.groups()

   216

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

   217

                            seconds = float(values[2])

   218

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

   219

                            text = "T#"

   220

                            if time_values[0] != 0:

   221

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

   222

                            if time_values[1] != 0:

   223

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

   224

                            if time_values[2] != 0:

   225

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

   226

                            if time_values[3] != 0:

   227

                                if time_values[3] % 1000 != 0:

   228

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

   229

                                else:

   230

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

   231

                            task.set("interval", text)

   232

   233

                # Update resources pou instance attributes

   234

                for pouInstance in ResourceInstancesXpath(resource):

   235

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

   236

                    if type_name is not None:

   237

                        pouInstance.set("typeName", type_name)

   238

   239

            # Update transitions condition

   240

            for transition_condition in TransitionsConditionXPath(tree):

   241

                connections = ConditionConnectionsXPath(transition_condition)

   242

                if len(connections) > 0:

   243

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

   244

                    transition_condition.setcontent(connectionPointIn)

   245

                    connectionPointIn.setrelPositionXY(0, 0)

   246

                    for connection in connections:

   247

                        connectionPointIn.append(connection)

   248

   249

            # Update actionBlocks

   250

            for actionBlock in ActionBlocksXPath(tree):

   251

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   252

                    actionBlock.remove(connectionPointOut)

   253

   254

                for action in actionBlock.getaction():

   255

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

   256

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

   257

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

   258

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

   259

                    action.setrelPosition(relPosition)

   260

   261

            return tree, None

   262

   263

        return tree, error

   264

   265

    except Exception, e:

   266

        return None, e.message

   267

   268

def LoadProject(filepath):

   269

    project_file = open(filepath)

   270

    project_xml = project_file.read()

   271

    project_file.close()

   272

    return LoadProjectXML(project_xml)

   273

   274

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

   275

def LoadPou(xml_string):

   276

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   277

    return project_pou_xpath(root)[0], error

   278

   279

project_pou_instances_xpath = {

   280

    body_type: PLCOpen_XPath(

   281

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

   282

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

   283

def LoadPouInstances(xml_string, body_type):

   284

    root, error = LoadProjectXML(

   285

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   286

    return project_pou_instances_xpath[body_type](root), error

   287

   288

def SaveProject(project, filepath):

   289

    project_file = open(filepath, 'w')

   290

    project_file.write(etree.tostring(

   291

        project, 

   292

        pretty_print=True, 

   293

        xml_declaration=True, 

   294

        encoding='utf-8'))

   295

    project_file.close()

   296

   297

cls = PLCOpenParser.GetElementClass("formattedText")

   298

if cls:

   299

    def updateElementName(self, old_name, new_name):

   300

        text = self.getanyText()

   301

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

   302

        text = pattern.sub(new_name, text)

   303

        self.setanyText(text)

   304

    setattr(cls, "updateElementName", updateElementName)

   305

   306

    def updateElementAddress(self, address_model, new_leading):

   307

        text = self.getanyText()

   308

        startpos = 0

   309

        result = address_model.search(text, startpos)

   310

        while result is not None:

   311

            groups = result.groups()

   312

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

   313

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

   314

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

   315

            result = address_model.search(text, startpos)

   316

        self.setanyText(text)

   317

    setattr(cls, "updateElementAddress", updateElementAddress)

   318

   319

    def hasblock(self, block_type):

   320

        text = self.getanyText()        

   321

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

   322

        return pattern.search(text) is not None

   323

    setattr(cls, "hasblock", hasblock)

   324

   325

    def Search(self, criteria, parent_infos):

   326

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

   327

    setattr(cls, "Search", Search)

   328

   329

cls = PLCOpenParser.GetElementClass("project")

   330

if cls:

   331

   332

    def setname(self, name):

   333

        self.contentHeader.setname(name)

   334

    setattr(cls, "setname", setname)

   335

   336

    def getname(self):

   337

        return self.contentHeader.getname()

   338

    setattr(cls, "getname", getname)

   339

   340

    def getfileHeader(self):

   341

        fileheader_obj = self.fileHeader

   342

        return {

   343

            attr: value if value is not None else ""

   344

            for attr, value in [

   345

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

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

        }

   353

    setattr(cls, "getfileHeader", getfileHeader)

   354

   355

    def setfileHeader(self, fileheader):

   356

        fileheader_obj = self.fileHeader

   357

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

   358

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

   359

                     "contentDescription"]:

   360

            value = fileheader.get(attr)

   361

            if value is not None:

   362

                setattr(fileheader_obj, attr, value)

   363

    setattr(cls, "setfileHeader", setfileHeader)

   364

   365

    def getcontentHeader(self):

   366

        contentheader_obj = self.contentHeader

   367

        contentheader = {

   368

            attr: value if value is not None else ""

   369

            for attr, value in [

   370

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

   371

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

   372

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

   373

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

   374

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

   375

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

   376

        }

   377

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

   378

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

   379

        return contentheader

   380

    setattr(cls, "getcontentHeader", getcontentHeader)

   381

   382

    def setcontentHeader(self, contentheader):

   383

        contentheader_obj = self.contentHeader

   384

        for attr, value in contentheader.iteritems():

   385

            func = {"projectName": contentheader_obj.setname,

   386

                    "projectVersion": contentheader_obj.setversion,

   387

                    "authorName": contentheader_obj.setauthor,

   388

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

   389

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

   390

            if func is not None:

   391

                func(value)

   392

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

   393

                setattr(contentheader_obj, attr, value)

   394

    setattr(cls, "setcontentHeader", setcontentHeader)

   395

   396

    def gettypeElementFunc(element_type):

   397

        elements_xpath = PLCOpen_XPath(

   398

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

   399

        def gettypeElement(self, name):

   400

            elements = elements_xpath(self, name=name)

   401

            if len(elements) == 1:

   402

                return elements[0]

   403

            return None

   404

        return gettypeElement

   405

   406

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

   407

    filtered_datatypes_xpath = PLCOpen_XPath(

   408

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

   409

    def getdataTypes(self, exclude=None):

   410

        if exclude is not None:

   411

            return filtered_datatypes_xpath(self, exclude=exclude)

   412

        return datatypes_xpath(self)

   413

    setattr(cls, "getdataTypes", getdataTypes)

   414

   415

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

   416

   417

    def appenddataType(self, name):

   418

        if self.getdataType(name) is not None:

   419

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

   420

        self.types.appenddataTypeElement(name)

   421

    setattr(cls, "appenddataType", appenddataType)

   422

   423

    def insertdataType(self, index, datatype):

   424

        self.types.insertdataTypeElement(index, datatype)

   425

    setattr(cls, "insertdataType", insertdataType)

   426

   427

    def removedataType(self, name):

   428

        self.types.removedataTypeElement(name)

   429

    setattr(cls, "removedataType", removedataType)

   430

   431

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

   432

        return self.xpath(

   433

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

   434

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

   435

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

   436

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

   437

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

   438

            namespaces=PLCOpenParser.NSMAP)

   439

    setattr(cls, "getpous", getpous)

   440

   441

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

   442

   443

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

   444

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

   445

    setattr(cls, "appendpou", appendpou)

   446

   447

    def insertpou(self, index, pou):

   448

        self.types.insertpouElement(index, pou)

   449

    setattr(cls, "insertpou", insertpou)

   450

   451

    def removepou(self, name):

   452

        self.types.removepouElement(name)

   453

    setattr(cls, "removepou", removepou)

   454

   455

    configurations_xpath = PLCOpen_XPath(

   456

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

   457

    def getconfigurations(self):

   458

        return configurations_xpath(self)

   459

    setattr(cls, "getconfigurations", getconfigurations)

   460

   461

    configuration_xpath = PLCOpen_XPath(

   462

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

   463

    def getconfiguration(self, name):

   464

        configurations = configuration_xpath(self, name=name)

   465

        if len(configurations) == 1:

   466

            return configurations[0]

   467

        return None

   468

    setattr(cls, "getconfiguration", getconfiguration)

   469

   470

    def addconfiguration(self, name):

   471

        if self.getconfiguration(name) is not None:

   472

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

   473

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

   474

        new_configuration.setname(name)

   475

        self.instances.configurations.appendconfiguration(new_configuration)

   476

    setattr(cls, "addconfiguration", addconfiguration)    

   477

   478

    def removeconfiguration(self, name):

   479

        configuration = self.getconfiguration(name)

   480

        if configuration is None:

   481

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

   482

        self.instances.configurations.remove(configuration)

   483

    setattr(cls, "removeconfiguration", removeconfiguration)

   484

   485

    resources_xpath = PLCOpen_XPath(

   486

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

   487

    def getconfigurationResource(self, config_name, name):

   488

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

   489

        if len(resources) == 1:

   490

            return resources[0]

   491

        return None

   492

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   493

   494

    def addconfigurationResource(self, config_name, name):

   495

        if self.getconfigurationResource(config_name, name) is not None:

   496

            msg = _("\"{a1}\" resource already exists in \"{a2}\" configuration !!!").format(a1 = name, a2 = config_name)

   497

            raise ValueError, msg

   498

        configuration = self.getconfiguration(config_name)

   499

        if configuration is not None:

   500

            new_resource = PLCOpenParser.CreateElement("resource", "configuration")

   501

            new_resource.setname(name)