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

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

   129

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

   130

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

   131

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

   132

    return test_result

   133

   134

def TextMatched(str1, str2):

   135

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

   136

   137

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

   138

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

   139

   140

LOAD_POU_PROJECT_TEMPLATE = """

   141

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

   142

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

   143

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

   144

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

   145

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

   146

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

   147

  <contentHeader name="paste_project">

   148

    <coordinateInfo>

   149

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

   150

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

   151

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

   152

    </coordinateInfo>

   153

  </contentHeader>

   154

  <types>

   155

    <dataTypes/>

   156

    <pous>%s</pous>

   157

  </types>

   158

  <instances>

   159

    <configurations/>

   160

  </instances>

   161

</project>

   162

"""

   163

   164

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   165

    return LOAD_POU_PROJECT_TEMPLATE % """

   166

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

   167

  <body>

   168

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

   169

  </body>

   170

</pou>""" % locals()

   171

   172

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

   173

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   174

PLCOpen_v1_file.close()

   175

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   176

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

   177

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

   178

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

   179

   180

# XPath for file compatibility process

   181

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

   182

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

   183

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

   184

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   185

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

   186

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   187

   188

def LoadProjectXML(project_xml):

   189

    project_xml = project_xml.replace(

   190

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

   191

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

   192

    for cre, repl in [

   193

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

   194

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

   195

        project_xml = cre.sub(repl, project_xml)

   196

   197

    try:

   198

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   199

        if error is None:

   200

            return tree, None

   201

   202

        if PLCOpen_v1_xsd.validate(tree):

   203

            # Make file compatible with PLCOpen v2

   204

   205

            # Update resource interval value

   206

            for resource in ProjectResourcesXPath(tree):

   207

                for task in resource.gettask():

   208

                    interval = task.get("interval")

   209

                    if interval is not None:

   210

                        result = time_model.match(interval)

   211

                        if result is not None:

   212

                            values = result.groups()

   213

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

   214

                            seconds = float(values[2])

   215

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

   216

                            text = "T#"

   217

                            if time_values[0] != 0:

   218

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

   219

                            if time_values[1] != 0:

   220

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

   221

                            if time_values[2] != 0:

   222

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

   223

                            if time_values[3] != 0:

   224

                                if time_values[3] % 1000 != 0:

   225

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

   226

                                else:

   227

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

   228

                            task.set("interval", text)

   229

   230

                # Update resources pou instance attributes

   231

                for pouInstance in ResourceInstancesXpath(resource):

   232

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

   233

                    if type_name is not None:

   234

                        pouInstance.set("typeName", type_name)

   235

   236

            # Update transitions condition

   237

            for transition_condition in TransitionsConditionXPath(tree):

   238

                connections = ConditionConnectionsXPath(transition_condition)

   239

                if len(connections) > 0:

   240

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

   241

                    transition_condition.setcontent(connectionPointIn)

   242

                    connectionPointIn.setrelPositionXY(0, 0)

   243

                    for connection in connections:

   244

                        connectionPointIn.append(connection)

   245

   246

            # Update actionBlocks

   247

            for actionBlock in ActionBlocksXPath(tree):

   248

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   249

                    actionBlock.remove(connectionPointOut)

   250

   251

                for action in actionBlock.getaction():

   252

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

   253

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

   254

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

   255

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

   256

                    action.setrelPosition(relPosition)

   257

   258

            return tree, None

   259

   260

        return tree, error

   261

   262

    except Exception, e:

   263

        return None, e.message

   264

   265

def LoadProject(filepath):

   266

    project_file = open(filepath)

   267

    project_xml = project_file.read()

   268

    project_file.close()

   269

    return LoadProjectXML(project_xml)

   270

   271

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

   272

def LoadPou(xml_string):

   273

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   274

    return project_pou_xpath(root)[0], error

   275

   276

project_pou_instances_xpath = {

   277

    body_type: PLCOpen_XPath(

   278

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

   279

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

   280

def LoadPouInstances(xml_string, body_type):

   281

    root, error = LoadProjectXML(

   282

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   283

    return project_pou_instances_xpath[body_type](root), error

   284

   285

def SaveProject(project, filepath):

   286

    project_file = open(filepath, 'w')

   287

    project_file.write(etree.tostring(

   288

        project, 

   289

        pretty_print=True, 

   290

        xml_declaration=True, 

   291

        encoding='utf-8'))

   292

    project_file.close()

   293

   294

cls = PLCOpenParser.GetElementClass("formattedText")

   295

if cls:

   296

    def updateElementName(self, old_name, new_name):

   297

        text = self.getanyText()

   298

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

   299

        text = pattern.sub(new_name, text)

   300

        self.setanyText(text)

   301

    setattr(cls, "updateElementName", updateElementName)

   302

   303

    def updateElementAddress(self, address_model, new_leading):

   304

        text = self.getanyText()

   305

        startpos = 0

   306

        result = address_model.search(text, startpos)

   307

        while result is not None:

   308

            groups = result.groups()

   309

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

   310

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

   311

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

   312

            result = address_model.search(text, startpos)

   313

        self.setanyText(text)

   314

    setattr(cls, "updateElementAddress", updateElementAddress)

   315

   316

    def hasblock(self, block_type):

   317

        text = self.getanyText()        

   318

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

   319

        return pattern.search(text) is not None

   320

    setattr(cls, "hasblock", hasblock)

   321

   322

    def Search(self, criteria, parent_infos):

   323

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

   324

    setattr(cls, "Search", Search)

   325

   326

cls = PLCOpenParser.GetElementClass("project")

   327

if cls:

   328

   329

    def setname(self, name):

   330

        self.contentHeader.setname(name)

   331

    setattr(cls, "setname", setname)

   332

   333

    def getname(self):

   334

        return self.contentHeader.getname()

   335

    setattr(cls, "getname", getname)

   336

   337

    def getfileHeader(self):

   338

        fileheader_obj = self.fileHeader

   339

        return {

   340

            attr: value if value is not None else ""

   341

            for attr, value in [

   342

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

   343

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

   344

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

   345

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

   346

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

   347

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

   348

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

   349

        }

   350

    setattr(cls, "getfileHeader", getfileHeader)

   351

   352

    def setfileHeader(self, fileheader):

   353

        fileheader_obj = self.fileHeader

   354

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

   355

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

   356

                     "contentDescription"]:

   357

            value = fileheader.get(attr)

   358

            if value is not None:

   359

                setattr(fileheader_obj, attr, value)

   360

    setattr(cls, "setfileHeader", setfileHeader)

   361

   362

    def getcontentHeader(self):

   363

        contentheader_obj = self.contentHeader

   364

        contentheader = {

   365

            attr: value if value is not None else ""

   366

            for attr, value in [

   367

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

   368

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

   369

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

   370

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

   371

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

   372

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

   373

        }

   374

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

   375

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

   376

        return contentheader

   377

    setattr(cls, "getcontentHeader", getcontentHeader)

   378

   379

    def setcontentHeader(self, contentheader):

   380

        contentheader_obj = self.contentHeader

   381

        for attr, value in contentheader.iteritems():

   382

            func = {"projectName": contentheader_obj.setname,

   383

                    "projectVersion": contentheader_obj.setversion,

   384

                    "authorName": contentheader_obj.setauthor,

   385

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

   386

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

   387

            if func is not None:

   388

                func(value)

   389

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

   390

                setattr(contentheader_obj, attr, value)

   391

    setattr(cls, "setcontentHeader", setcontentHeader)

   392

   393

    def gettypeElementFunc(element_type):

   394

        elements_xpath = PLCOpen_XPath(

   395

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

   396

        def gettypeElement(self, name):

   397

            elements = elements_xpath(self, name=name)

   398

            if len(elements) == 1:

   399

                return elements[0]

   400

            return None

   401

        return gettypeElement

   402

   403

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

   404

    filtered_datatypes_xpath = PLCOpen_XPath(

   405

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

   406

    def getdataTypes(self, exclude=None):

   407

        if exclude is not None:

   408

            return filtered_datatypes_xpath(self, exclude=exclude)

   409

        return datatypes_xpath(self)

   410

    setattr(cls, "getdataTypes", getdataTypes)

   411

   412

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

   413

   414

    def appenddataType(self, name):

   415

        if self.getdataType(name) is not None:

   416

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

   417

        self.types.appenddataTypeElement(name)

   418

    setattr(cls, "appenddataType", appenddataType)

   419

   420

    def insertdataType(self, index, datatype):

   421

        self.types.insertdataTypeElement(index, datatype)

   422

    setattr(cls, "insertdataType", insertdataType)

   423

   424

    def removedataType(self, name):

   425

        self.types.removedataTypeElement(name)

   426

    setattr(cls, "removedataType", removedataType)

   427

   428

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

   429

        return self.xpath(

   430

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

   431

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

   432

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

   433

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

   434

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

   435

            namespaces=PLCOpenParser.NSMAP)

   436

    setattr(cls, "getpous", getpous)

   437

   438

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

   439

   440

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

   441

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

   442

    setattr(cls, "appendpou", appendpou)

   443

   444

    def insertpou(self, index, pou):

   445

        self.types.insertpouElement(index, pou)

   446

    setattr(cls, "insertpou", insertpou)

   447

   448

    def removepou(self, name):

   449

        self.types.removepouElement(name)

   450

    setattr(cls, "removepou", removepou)

   451

   452

    configurations_xpath = PLCOpen_XPath(

   453

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

   454

    def getconfigurations(self):

   455

        return configurations_xpath(self)

   456

    setattr(cls, "getconfigurations", getconfigurations)

   457

   458

    configuration_xpath = PLCOpen_XPath(

   459

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

   460

    def getconfiguration(self, name):

   461

        configurations = configuration_xpath(self, name=name)

   462

        if len(configurations) == 1:

   463

            return configurations[0]

   464

        return None

   465

    setattr(cls, "getconfiguration", getconfiguration)

   466

   467

    def addconfiguration(self, name):

   468

        if self.getconfiguration(name) is not None:

   469

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

   470

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

   471

        new_configuration.setname(name)

   472

        self.instances.configurations.appendconfiguration(new_configuration)

   473

    setattr(cls, "addconfiguration", addconfiguration)    

   474

   475

    def removeconfiguration(self, name):

   476

        configuration = self.getconfiguration(name)

   477

        if configuration is None:

   478

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

   479

        self.instances.configurations.remove(configuration)

   480

    setattr(cls, "removeconfiguration", removeconfiguration)

   481

   482

    resources_xpath = PLCOpen_XPath(

   483

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

   484

    def getconfigurationResource(self, config_name, name):

   485

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

   486

        if len(resources) == 1:

   487

            return resources[0]

   488

        return None

   489

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   490

   491

    def addconfigurationResource(self, config_name, name):

   492

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

   493

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

   494

            raise ValueError, msg

   495

        configuration = self.getconfiguration(config_name)

   496

        if configuration is not None:

   497

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

   498

            new_resource.setname(name)

   499

            configuration.appendresource(new_resource)

   500

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   501