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

    27

import re

    28

from collections import OrderedDict

    29

    30

from lxml import etree

    31

    32

from xmlclass import *

    33

import util.paths as paths

    34

    35

    36

#: Dictionary that makes the relation between var names

    37

#: in plcopen and displayed values

    38

    39

VarTypes = {

    40

    "Local":    "localVars",

    41

    "Temp":     "tempVars",

    42

    "Input":    "inputVars",

    43

    "Output":   "outputVars",

    44

    "InOut":    "inOutVars",

    45

    "External": "externalVars",

    46

    "Global":   "globalVars",

    47

    "Access":   "accessVars"

    48

}

    49

    50

searchResultVarTypes = {

    51

    "inputVars":  "var_input",

    52

    "outputVars": "var_output",

    53

    "inOutVars":  "var_inout"

    54

}

    55

    56

    57

#: Define in which order var types must be displayed

    58

    59

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

    60

    61

    62

#:  Define which action qualifier must be associated with a duration

    63

    64

QualifierList = OrderedDict([

    65

    ("N", False),

    66

    ("R", False),

    67

    ("S", False),

    68

    ("L", True),

    69

    ("D", True),

    70

    ("P", False),

    71

    ("P0", False),

    72

    ("P1", False),

    73

    ("SD", True),

    74

    ("DS", True),

    75

    ("SL", True)])

    76

    77

    78

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

    79

    80

    81

def update_address(address, address_model, new_leading):

    82

    result = address_model.match(address)

    83

    if result is None:

    84

        return address

    85

    groups = result.groups()

    86

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

    87

    88

    89

def _init_and_compare(function, v1, v2):

    90

    if v1 is None:

    91

        return v2

    92

    if v2 is not None:

    93

        return function(v1, v2)

    94

    return v1

    95

    96

    97

class rect(object):

    98

    """

    99

    Helper class for bounding_box calculation

   100

    """

   101

   102

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

   103

        self.x_min = x

   104

        self.x_max = None

   105

        self.y_min = y

   106

        self.y_max = None

   107

        if width is not None and x is not None:

   108

            self.x_max = x + width

   109

        if height is not None and y is not None:

   110

            self.y_max = y + height

   111

   112

    def update(self, x, y):

   113

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

   114

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

   115

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

   116

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

   117

   118

    def union(self, rect):

   119

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

   120

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

   121

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

   122

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

   123

   124

    def bounding_box(self):

   125

        width = height = None

   126

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

   127

            width = self.x_max - self.x_min

   128

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

   129

            height = self.y_max - self.y_min

   130

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

   131

   132

   133

def TextLenInRowColumn(text):

   134

    if text == "":

   135

        return (0, 0)

   136

    lines = text.split("\n")

   137

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

   138

   139

   140

def CompilePattern(criteria):

   141

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

   142

    find_pattern = criteria["find_pattern"]

   143

    if not criteria["regular_expression"]:

   144

        find_pattern = re.escape(find_pattern)

   145

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

   146

   147

   148

def TestTextElement(text, criteria):

   149

    lines = text.splitlines()

   150

    test_result = []

   151

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

   152

    while result is not None:

   153

        prev_pos = result.span()[1]

   154

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

   155

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

   156

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

   157

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

   158

        if result is not None and prev_pos == result.end():

   159

            break

   160

    return test_result

   161

   162

   163

def TextMatched(str1, str2):

   164

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

   165

   166

   167

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

   168

   169

   170

def PLCOpen_XPath(xpath):

   171

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

   172

   173

   174

LOAD_POU_PROJECT_TEMPLATE = """

   175

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

   176

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

   177

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

   178

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

   179

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

   180

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

   181

  <contentHeader name="paste_project">

   182

    <coordinateInfo>

   183

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

   184

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

   185

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

   186

    </coordinateInfo>

   187

  </contentHeader>

   188

  <types>

   189

    <dataTypes/>

   190

    <pous>%s</pous>

   191

  </types>

   192

  <instances>

   193

    <configurations/>

   194

  </instances>

   195

</project>

   196

"""

   197

   198

   199

def LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type):

   200

    return LOAD_POU_PROJECT_TEMPLATE % """

   201

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

   202

  <body>

   203

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

   204

  </body>

   205

</pou>""" % locals()

   206

   207

   208

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

   209

PLCOpen_v1_xml = PLCOpen_v1_file.read()

   210

PLCOpen_v1_file.close()

   211

PLCOpen_v1_xml = PLCOpen_v1_xml.replace(

   212

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

   213

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

   214

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

   215

   216

# XPath for file compatibility process

   217

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

   218

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

   219

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

   220

ConditionConnectionsXPath = PLCOpen_XPath("ppx:connection")

   221

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

   222

ActionBlocksConnectionPointOutXPath = PLCOpen_XPath("ppx:connectionPointOut")

   223

   224

   225

def LoadProjectXML(project_xml):

   226

    project_xml = project_xml.replace(

   227

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

   228

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

   229

    for cre, repl in [

   230

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

   231

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

   232

        project_xml = cre.sub(repl, project_xml)

   233

   234

    try:

   235

        tree, error = PLCOpenParser.LoadXMLString(project_xml)

   236

        if error is None:

   237

            return tree, None

   238

   239

        if PLCOpen_v1_xsd.validate(tree):

   240

            # Make file compatible with PLCOpen v2

   241

   242

            # Update resource interval value

   243

            for resource in ProjectResourcesXPath(tree):

   244

                for task in resource.gettask():

   245

                    interval = task.get("interval")

   246

                    if interval is not None:

   247

                        result = time_model.match(interval)

   248

                        if result is not None:

   249

                            values = result.groups()

   250

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

   251

                            seconds = float(values[2])

   252

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

   253

                            text = "T#"

   254

                            if time_values[0] != 0:

   255

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

   256

                            if time_values[1] != 0:

   257

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

   258

                            if time_values[2] != 0:

   259

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

   260

                            if time_values[3] != 0:

   261

                                if time_values[3] % 1000 != 0:

   262

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

   263

                                else:

   264

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

   265

                            task.set("interval", text)

   266

   267

                # Update resources pou instance attributes

   268

                for pouInstance in ResourceInstancesXpath(resource):

   269

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

   270

                    if type_name is not None:

   271

                        pouInstance.set("typeName", type_name)

   272

   273

            # Update transitions condition

   274

            for transition_condition in TransitionsConditionXPath(tree):

   275

                connections = ConditionConnectionsXPath(transition_condition)

   276

                if len(connections) > 0:

   277

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

   278

                    transition_condition.setcontent(connectionPointIn)

   279

                    connectionPointIn.setrelPositionXY(0, 0)

   280

                    for connection in connections:

   281

                        connectionPointIn.append(connection)

   282

   283

            # Update actionBlocks

   284

            for actionBlock in ActionBlocksXPath(tree):

   285

                for connectionPointOut in ActionBlocksConnectionPointOutXPath(actionBlock):

   286

                    actionBlock.remove(connectionPointOut)

   287

   288

                for action in actionBlock.getaction():

   289

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

   290

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

   291

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

   292

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

   293

                    action.setrelPosition(relPosition)

   294

   295

            return tree, None

   296

   297

        return tree, error

   298

   299

    except Exception as e:

   300

        return None, str(e)

   301

   302

   303

def LoadProject(filepath):

   304

    project_file = open(filepath, encoding='utf-8')

   305

    project_xml = project_file.read()

   306

    project_file.close()

   307

    return LoadProjectXML(project_xml)

   308

   309

   310

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

   311

   312

   313

def LoadPou(xml_string):

   314

    root, error = LoadProjectXML(LOAD_POU_PROJECT_TEMPLATE % xml_string)

   315

    return project_pou_xpath(root)[0], error

   316

   317

   318

project_pou_instances_xpath = {

   319

    body_type: PLCOpen_XPath(

   320

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

   321

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

   322

   323

   324

def LoadPouInstances(xml_string, body_type):

   325

    root, error = LoadProjectXML(

   326

        LOAD_POU_INSTANCES_PROJECT_TEMPLATE(body_type) % xml_string)

   327

    return project_pou_instances_xpath[body_type](root), error

   328

   329

   330

def SaveProject(project, filepath):

   331

    content = etree.tostring(

   332

        project,

   333

        pretty_print=True,

   334

        xml_declaration=True,

   335

        encoding='utf-8').decode()

   336

   337

    assert len(content) != 0

   338

   339

    project_file = open(filepath, 'w', encoding='utf-8')

   340

    project_file.write(content)

   341

    project_file.close()

   342

   343

   344

# ----------------------------------------------------------------------

   345

   346

   347

def _updateFormattedTextClass(cls):

   348

    def updateElementName(self, old_name, new_name):

   349

        text = self.getanyText()

   350

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

   351

        text = pattern.sub(new_name, text)

   352

        self.setanyText(text)

   353

    setattr(cls, "updateElementName", updateElementName)

   354

   355

    def updateElementAddress(self, address_model, new_leading):

   356

        text = self.getanyText()

   357

        startpos = 0

   358

        result = address_model.search(text, startpos)

   359

        while result is not None:

   360

            groups = result.groups()

   361

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

   362

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

   363

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

   364

            result = address_model.search(text, startpos)

   365

        self.setanyText(text)

   366

    setattr(cls, "updateElementAddress", updateElementAddress)

   367

   368

    def hasblock(self, block_type):

   369

        text = self.getanyText()

   370

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

   371

        return pattern.search(text) is not None

   372

    setattr(cls, "hasblock", hasblock)

   373

   374

    def Search(self, criteria, parent_infos):

   375

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

   376

    setattr(cls, "Search", Search)

   377

   378

   379

cls = PLCOpenParser.GetElementClass("formattedText")

   380

if cls:

   381

    _updateFormattedTextClass(cls)

   382

   383

   384

# ----------------------------------------------------------------------

   385

   386

   387

def _updateProjectClass(cls):

   388

    def setname(self, name):

   389

        self.contentHeader.setname(name)

   390

    setattr(cls, "setname", setname)

   391

   392

    def getname(self):

   393

        return self.contentHeader.getname()

   394

    setattr(cls, "getname", getname)

   395

   396

    def getfileHeader(self):

   397

        fileheader_obj = self.fileHeader

   398

        return {

   399

            attr: value if value is not None else ""

   400

            for attr, value in [

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

        }

   409

    setattr(cls, "getfileHeader", getfileHeader)

   410

   411

    def setfileHeader(self, fileheader):

   412

        fileheader_obj = self.fileHeader

   413

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

   414

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

   415

                     "contentDescription"]:

   416

            value = fileheader.get(attr)

   417

            if value is not None:

   418

                setattr(fileheader_obj, attr, value)

   419

    setattr(cls, "setfileHeader", setfileHeader)

   420

   421

    def getcontentHeader(self):

   422

        contentheader_obj = self.contentHeader

   423

        contentheader = {

   424

            attr: value if value is not None else ""

   425

            for attr, value in [

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

        }

   433

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

   434

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

   435

        return contentheader

   436

    setattr(cls, "getcontentHeader", getcontentHeader)

   437

   438

    def setcontentHeader(self, contentheader):

   439

        contentheader_obj = self.contentHeader

   440

        for attr, value in contentheader.items():

   441

            func = {"projectName": contentheader_obj.setname,

   442

                    "projectVersion": contentheader_obj.setversion,

   443

                    "authorName": contentheader_obj.setauthor,

   444

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

   445

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

   446

            if func is not None and value is not None:

   447

                func(value)

   448

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

   449

                setattr(contentheader_obj, attr, value)

   450

    setattr(cls, "setcontentHeader", setcontentHeader)

   451

   452

    def gettypeElementFunc(element_type):

   453

        elements_xpath = PLCOpen_XPath(

   454

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

   455

   456

        def gettypeElement(self, name):

   457

            elements = elements_xpath(self, name=name)

   458

            if len(elements) == 1:

   459

                return elements[0]

   460

            return None

   461

        return gettypeElement

   462

   463

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

   464

    filtered_datatypes_xpath = PLCOpen_XPath(

   465

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

   466

   467

    def getdataTypes(self, exclude=None):

   468

        if exclude is not None:

   469

            return filtered_datatypes_xpath(self, exclude=exclude)

   470

        return datatypes_xpath(self)

   471

    setattr(cls, "getdataTypes", getdataTypes)

   472

   473

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

   474

   475

    def appenddataType(self, name):

   476

        if self.getdataType(name) is not None:

   477

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

   478

        self.types.appenddataTypeElement(name)

   479

    setattr(cls, "appenddataType", appenddataType)

   480

   481

    def insertdataType(self, index, datatype):

   482

        self.types.insertdataTypeElement(index, datatype)

   483

    setattr(cls, "insertdataType", insertdataType)

   484

   485

    def removedataType(self, name):

   486

        self.types.removedataTypeElement(name)

   487

    setattr(cls, "removedataType", removedataType)

   488

   489

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

   490

        filter = [] if filter is None else filter