1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

#This library is free software; you can redistribute it and/or

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

#version 2.1 of the License, or (at your option) any later version.

    15

#

    16

#This library is distributed in the hope that it will be useful,

    17

#but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    19

#General Public License for more details.

    20

#

    21

#You should have received a copy of the GNU General Public

    22

#License along with this library; if not, write to the Free Software

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from xmlclass import *

    26

from types import *

    27

import os

    28

    29

"""

    30

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

    31

"""

    32

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

    33

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

    34

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

    35

    36

"""

    37

Define in which order var types must be displayed

    38

"""

    39

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

    40

    41

"""

    42

Define which action qualifier must be associated with a duration 

    43

"""

    44

QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, 

    45

    "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True}

    46

    47

PLCOpenClasses, PLCOpenTypes = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd"))

    48

    49

cls = PLCOpenClasses.get("dataType", None)

    50

if cls:

    51

    cls.value = None

    52

    53

    def getValue(self):

    54

        return self.value

    55

    setattr(cls, "getValue", getValue)

    56

    57

    def setValue(self, value):

    58

        self.value = value

    59

    setattr(cls, "setValue", setValue)

    60

    61

    def loadXMLTree(self, tree):

    62

        node = tree.childNodes[1]

    63

        if node.nodeName == "derived":

    64

            self.value = PLCOpenClasses["derived"]()

    65

            self.value.loadXMLTree(node)

    66

        else:

    67

            self.value = node.nodeName

    68

    setattr(cls, "loadXMLTree", loadXMLTree)

    69

    70

    def generateXMLText(self, name, indent, extras = {}):

    71

        ind1, ind2 = getIndent(indent, name)

    72

        text = ind1 + "<%s>\n"%name

    73

        if isinstance(self.value, (StringType, UnicodeType)):

    74

            ind3, ind4 = getIndent(indent + 1, self.value)

    75

            text += ind3 + "<%s/>\n"%self.value

    76

        else:

    77

            text += self.value.generateXMLText("derived", indent + 1)

    78

        text += ind1 + "</%s>\n"%name

    79

        return text

    80

    setattr(cls, "generateXMLText", generateXMLText)

    81

    82

cls = PLCOpenClasses.get("formattedText", None)

    83

if cls:

    84

    cls.text = ""

    85

    86

    def getText(self):

    87

        return self.text

    88

    setattr(cls, "getText", getText)

    89

    90

    def setText(self, text):

    91

        self.text = text

    92

    setattr(cls, "setText", setText)

    93

    94

    def loadXMLTree(self, tree):

    95

        self.text = GetAttributeValue(tree)

    96

        if len(self.text.splitlines()) > 1:

    97

            self.text = self.text[1:].rstrip()

    98

    setattr(cls, "loadXMLTree", loadXMLTree)

    99

   100

    def generateXMLText(self, name, indent, extras = {}):

   101

        ind1, ind2 = getIndent(indent, name)

   102

        if len(self.text.splitlines()) > 1:

   103

            text = ind1 + "<%s>\n<![CDATA[\n"%name

   104

            text += "%s\n"%self.text

   105

            text += "]]>\n" + ind1 + "</%s>\n"%name

   106

            return text

   107

        else:

   108

            return ind1 + "<%s><![CDATA[%s]]></%s>\n"%(name, self.text, name)

   109

    setattr(cls, "generateXMLText", generateXMLText)

   110

   111

    def updateElementName(self, old_name, new_name):

   112

        index = self.text.find(old_name)

   113

        while index != -1:

   114

            if index > 0 and (self.text[index - 1].isalnum() or self.text[index - 1] == "_"):

   115

                index = self.text.find(old_name, index + len(old_name))

   116

            elif index < len(self.text) - len(old_name) and (self.text[index + len(old_name)].isalnum() or self.text[index + len(old_name)] == "_"):

   117

                index = self.text.find(old_name, index + len(old_name))

   118

            else:

   119

                self.text = self.text[:index] + new_name + self.text[index + len(old_name):]

   120

                index = self.text.find(old_name, index + len(new_name))

   121

    setattr(cls, "updateElementName", updateElementName)

   122

   123

cls = PLCOpenClasses.get("project", None)

   124

if cls:

   125

    cls.singleLineAttributes = False

   126

   127

    def getFileHeader(self):

   128

        fileheader = {}

   129

        fileheader["companyName"] = self.fileHeader.getCompanyName()

   130

        if self.fileHeader.getCompanyURL():

   131

            fileheader["companyURL"] = self.fileHeader.getCompanyURL()

   132

        fileheader["productName"] = self.fileHeader.getProductName()

   133

        fileheader["productVersion"] = self.fileHeader.getProductVersion()

   134

        if self.fileHeader.getProductRelease():

   135

            fileheader["productRelease"] = self.fileHeader.getProductRelease()

   136

        fileheader["creationDateTime"] = self.fileHeader.getCreationDateTime()

   137

        if self.fileHeader.getContentDescription():

   138

            fileheader["contentDescription"] = self.fileHeader.getContentDescription()

   139

        return fileheader

   140

    setattr(cls, "getFileHeader", getFileHeader)

   141

   142

    def setFileHeader(self, fileheader):

   143

        self.fileHeader.setCompanyName(fileheader["companyName"])

   144

        if "companyURL" in fileheader:

   145

            self.fileHeader.setCompanyURL(fileheader["companyURL"])

   146

        self.fileHeader.setProductName(fileheader["productName"])

   147

        self.fileHeader.setProductVersion(fileheader["productVersion"])

   148

        if "productRelease" in fileheader:

   149

            self.fileHeader.setProductRelease(fileheader["productRelease"])

   150

        self.fileHeader.setCreationDateTime(fileheader["creationDateTime"])

   151

        if "contentDescription" in fileheader:

   152

            self.fileHeader.setContentDescription(fileheader["contentDescription"])

   153

    setattr(cls, "setFileHeader", setFileHeader)

   154

   155

    def setName(self, name):

   156

        self.contentHeader.setName(name)

   157

    setattr(cls, "setName", setName)

   158

   159

    def getName(self):

   160

        return self.contentHeader.getName()

   161

    setattr(cls, "getName", getName)

   162

   163

    def getPous(self):

   164

        return self.types.getPouElements()

   165

    setattr(cls, "getPous", getPous)

   166

   167

    def getPou(self, name):

   168

        return self.types.getPouElement(name)

   169

    setattr(cls, "getPou", getPou)

   170

   171

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

   172

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

   173

    setattr(cls, "appendPou", appendPou)

   174

   175

    def insertPou(self, index, pou):

   176

        self.types.insertPouElement(index, pou)

   177

    setattr(cls, "insertPou", insertPou)

   178

   179

    def removePou(self, name):

   180

        self.types.removePouElement(name)

   181

    setattr(cls, "removePou", removePou)

   182

   183

    def getConfigurations(self):

   184

        configurations = self.instances.configurations.getConfiguration()

   185

        if configurations:

   186

            return configurations

   187

        return []

   188

    setattr(cls, "getConfigurations", getConfigurations)

   189

   190

    def getConfiguration(self, name):

   191

        for configuration in self.instances.configurations.getConfiguration():

   192

            if configuration.getName() == name:

   193

                return configuration

   194

        return None

   195

    setattr(cls, "getConfiguration", getConfiguration)

   196

   197

    def addConfiguration(self, name):

   198

        for configuration in self.instances.configurations.getConfiguration():

   199

            if configuration.getName() == name:

   200

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

   201

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   202

        new_configuration.setName(name)

   203

        self.instances.configurations.appendConfiguration(new_configuration)

   204

    setattr(cls, "addConfiguration", addConfiguration)    

   205

   206

    def removeConfiguration(self, name):

   207

        found = False

   208

        for idx, configuration in enumerate(self.instances.configurations.getConfiguration()):

   209

            if configuration.getName() == name:

   210

                self.instances.configurations.removeConfiguration(idx)

   211

                found = True

   212

                break

   213

        if not found:

   214

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

   215

    setattr(cls, "removeConfiguration", removeConfiguration)

   216

   217

    def getConfigurationResource(self, config_name, name):

   218

        configuration = self.getConfiguration(config_name)

   219

        if configuration:

   220

            for resource in configuration.getResource():

   221

                if resource.getName() == name:

   222

                    return resource

   223

        return None

   224

    setattr(cls, "getConfigurationResource", getConfigurationResource)

   225

   226

    def addConfigurationResource(self, config_name, name):

   227

        configuration = self.getConfiguration(config_name)

   228

        if configuration:

   229

            for resource in configuration.getResource():

   230

                if resource.getName() == name:

   231

                    raise ValueError, "\"%s\" resource already exists in \"%s\" configuration !!!"%(name, config_name)

   232

            new_resource = PLCOpenClasses["configuration_resource"]()

   233

            new_resource.setName(name)

   234

            configuration.appendResource(new_resource)

   235

    setattr(cls, "addConfigurationResource", addConfigurationResource)    

   236

   237

    def removeConfigurationResource(self, config_name, name):

   238

        configuration = self.getConfiguration(config_name)

   239

        if configuration:

   240

            found = False

   241

            for idx, resource in enumerate(configuration.getResource()):

   242

                if resource.getName() == name:

   243

                    configuration.removeResource(idx)

   244

                    found = True

   245

                    break

   246

            if not found:

   247

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

   248

    setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   249

   250

    def updateElementName(self, old_name, new_name):

   251

        for pou in self.types.getPouElements():

   252

            pou.updateElementName(old_name, new_name)

   253

        for configuration in self.instances.configurations.getConfiguration():

   254

            configuration.updateElementName(old_name, new_name)

   255

    setattr(cls, "updateElementName", updateElementName)

   256

   257

cls = PLCOpenClasses.get("project_fileHeader", None)

   258

if cls:

   259

    cls.singleLineAttributes = False

   260

   261

cls = PLCOpenClasses.get("configurations_configuration", None)

   262

if cls:

   263

    def updateElementName(self, old_name, new_name):

   264

        for resource in self.getResource():

   265

            resource.updateElementName(old_name, new_name)

   266

    setattr(cls, "updateElementName", updateElementName)

   267

   268

   269

cls = PLCOpenClasses.get("configuration_resource", None)

   270

if cls:

   271

    def updateElementName(self, old_name, new_name):

   272

        for instance in self.getPouInstance():

   273

            instance.updateElementName(old_name, new_name)

   274

        for task in self.getTask():

   275

            task.updateElementName(old_name, new_name)

   276

    setattr(cls, "updateElementName", updateElementName)

   277

   278

cls = PLCOpenClasses.get("resource_task", None)

   279

if cls:

   280

    def updateElementName(self, old_name, new_name):

   281

        if self.single == old_name:

   282

            self.single = new_name

   283

        for instance in self.getPouInstance():

   284

            instance.updateElementName(old_name, new_name)

   285

    setattr(cls, "updateElementName", updateElementName)

   286

   287

cls = PLCOpenClasses.get("pouInstance", None)

   288

if cls:

   289

    def updateElementName(self, old_name, new_name):

   290

        if self.type == old_name:

   291

            self.type = new_name

   292

    setattr(cls, "updateElementName", updateElementName)

   293

   294

cls = PLCOpenClasses.get("project_types", None)

   295

if cls:

   296

    def getPouElements(self):

   297

        return self.pous.getPou()

   298

    setattr(cls, "getPouElements", getPouElements)

   299

   300

    def getPouElement(self, name):

   301

        elements = self.pous.getPou()

   302

        for element in elements:

   303

            if element.getName() == name:

   304

                return element

   305

        return None

   306

    setattr(cls, "getPouElement", getPouElement)

   307

   308

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

   309

        for element in self.pous.getPou():

   310

            if element.getName() == name:

   311

                raise ValueError, "\"%s\" POU already exists !!!"%name

   312

        new_pou = PLCOpenClasses["pous_pou"]()

   313

        new_pou.setName(name)

   314

        new_pou.pouType.setValue(pou_type)

   315

        new_pou.setBody(PLCOpenClasses["body"]())

   316

        new_pou.setBodyType(body_type)

   317

        self.pous.appendPou(new_pou)

   318

    setattr(cls, "appendPouElement", appendPouElement)

   319

   320

    def insertPouElement(self, index, pou):

   321

        self.pous.insertPou(index, pou)

   322

    setattr(cls, "insertPouElement", insertPouElement)

   323

   324

    def removePouElement(self, name):

   325

        found = False

   326

        for idx, element in enumerate(self.pous.getPou()):

   327

            if element.getName() == name:

   328

                self.pous.removePou(idx)

   329

                found = True

   330

                break

   331

        if not found:

   332

            raise ValueError, "\"%s\" POU doesn't exist !!!"%name

   333

    setattr(cls, "removePouElement", removePouElement)

   334

   335

def setBodyType(self, type):

   336

    if type == "IL":

   337

        self.body.setContent("IL", PLCOpenClasses["formattedText"]())

   338

    elif type == "ST":

   339

        self.body.setContent("ST", PLCOpenClasses["formattedText"]())

   340

    elif type == "LD":

   341

        self.body.setContent("LD", PLCOpenClasses["body_LD"]())

   342

    elif type == "FBD":

   343

        self.body.setContent("FBD", PLCOpenClasses["body_FBD"]())

   344

    elif type == "SFC":

   345

        self.body.setContent("SFC", PLCOpenClasses["body_SFC"]())

   346

    else:

   347

        raise ValueError, "%s isn't a valid body type!"%type

   348

   349

def getBodyType(self):

   350

    return self.body.getContent()["name"]

   351

   352

def resetExecutionOrder(self):

   353

    self.body.resetExecutionOrder()

   354

   355

def compileExecutionOrder(self):

   356

    self.body.compileExecutionOrder()

   357

   358

def setElementExecutionOrder(self, instance, new_executionOrder):

   359

    self.body.setElementExecutionOrder(instance, new_executionOrder)

   360

   361

def addInstance(self, name, instance):

   362

    self.body.appendContentInstance(name, instance)

   363

   364

def getInstances(self):

   365

    return self.body.getContentInstances()

   366

   367

def getInstance(self, id):

   368

    return self.body.getContentInstance(id)

   369

   370

def getRandomInstance(self, exclude):

   371

    return self.body.getContentRandomInstance(exclude)

   372

   373

def getInstanceByName(self, name):

   374

    return self.body.getContentInstanceByName(name)

   375

   376

def removeInstance(self, id):

   377

    self.body.removeContentInstance(id)

   378

   379

def setText(self, text):

   380

    self.body.setText(text)

   381

   382

def getText(self):

   383

    return self.body.getText()

   384

setattr(cls, "getText", getText)

   385

   386

cls = PLCOpenClasses.get("pous_pou", None)

   387

if cls:

   388

    setattr(cls, "setBodyType", setBodyType)

   389

    setattr(cls, "getBodyType", getBodyType)

   390

    setattr(cls, "resetExecutionOrder", resetExecutionOrder)

   391

    setattr(cls, "compileExecutionOrder", compileExecutionOrder)

   392

    setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)

   393

    setattr(cls, "addInstance", addInstance)

   394

    setattr(cls, "getInstances", getInstances)

   395

    setattr(cls, "getInstance", getInstance)

   396

    setattr(cls, "getRandomInstance", getRandomInstance)

   397

    setattr(cls, "getInstanceByName", getInstanceByName)

   398

    setattr(cls, "removeInstance", removeInstance)

   399

    setattr(cls, "setText", setText)

   400

    setattr(cls, "getText", getText)

   401

   402

    def getVars(self):

   403

        vars = []

   404

        reverse_types = {}

   405

        for name, value in VarTypes.items():

   406

            reverse_types[value] = name

   407

        for varlist in self.interface.getContent():

   408

            vars.append((reverse_types[varlist["name"]], varlist["value"]))

   409

        return vars

   410

    setattr(cls, "getVars", getVars)

   411

   412

    def setVars(self, vars):

   413

        self.interface.setContent([])

   414

        for vartype, varlist in vars:

   415

            self.interface.appendContent(VarTypes[vartype], varlist)

   416

    setattr(cls, "setVars", setVars)

   417

   418

    def addPouVar(self, type, name):

   419

        content = self.interface.getContent()

   420

        if len(content) == 0 or content[-1]["name"] != "localVars":

   421

            content.append({"name" : "localVars", "value" : PLCOpenClasses["varList"]()})

   422

        else:

   423

            varlist = content[-1]["value"]

   424

            variables = varlist.getVariable()

   425

            if varlist.getConstant() or varlist.getRetain() or len(variables) > 0 and variables[0].getAddress():

   426

                content.append({"name" : "localVars", "value" : PLCOpenClasses["varList"]()})

   427

        var = PLCOpenClasses["varListPlain_variable"]()

   428

        var.setName(name)

   429

        var_type = PLCOpenClasses["dataType"]()

   430

        derived_type = PLCOpenClasses["derived"]()

   431

        derived_type.setName(type)

   432

        var_type.setValue(derived_type)

   433

        var.setType(var_type)

   434

        content[-1]["value"].appendVariable(var)

   435

    setattr(cls, "addPouVar", addPouVar)

   436

   437

    def changePouVar(self, old_type, old_name, new_type, new_name):

   438

        content = self.interface.getContent()

   439

        for varlist in content:

   440

            variables = varlist["value"].getVariable()

   441

            for var in variables:

   442

                if var.getName() == old_name:

   443

                    var_type = var.getType().getValue()

   444

                    if isinstance(var_type, PLCOpenClasses["derived"]) and var_type.getName() == old_type:

   445

                        var.setName(new_name)

   446

                        var.getType().getValue().setName(new_type)

   447

                        return

   448

    setattr(cls, "changePouVar", changePouVar)

   449

   450

    def removePouVar(self, type, name):

   451

        content = self.interface.getContent()

   452

        for varlist in content:

   453

            variables = varlist["value"].getVariable()

   454

            for var in variables:

   455

                if var.getName() == name:

   456

                    var_type = var.getType().getValue()

   457

                    if isinstance(var_type, PLCOpenClasses["derived"]) and var_type.getName() == type:

   458

                        variables.remove(var)

   459

                        break

   460

            if len(varlist["value"].getVariable()) == 0:

   461

                content.remove(varlist)

   462

                break

   463

    setattr(cls, "removePouVar", removePouVar)

   464

   465

    def hasBlock(self, name):

   466

        if self.getBodyType() in ["FBD", "LD", "SFC"]:

   467

            for instance in self.getInstances():

   468

                if isinstance(instance, PLCOpenClasses["block"]) and instance.getInstanceName() == name:

   469

                    return True

   470

            if self.transitions:

   471

                for transition in self.transitions.getTransition():

   472

                    result = transition.hasBlock(name)

   473

                    if result:

   474

                        return result

   475

            if self.actions:

   476

                for action in self.actions.getAction():

   477

                    result = action.hasBlock(name)

   478

                    if result:

   479

                        return result

   480

        return False

   481

    setattr(cls, "hasBlock", hasBlock)

   482

   483

    def addTransition(self, name, type):

   484

        if not self.transitions:

   485

            self.addTransitions()

   486

            self.transitions.setTransition([])

   487

        transition = PLCOpenClasses["transitions_transition"]()

   488

        transition.setName(name)

   489

        transition.setBodyType(type)

   490

        self.transitions.appendTransition(transition)

   491

    setattr(cls, "addTransition", addTransition)

   492

   493

    def getTransition(self, name):

   494

        if self.transitions:

   495

            for transition in self.transitions.getTransition():