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("formattedText", None)

    50

if cls:

    51

    cls.text = ""

    52

    53

    def getText(self):

    54

        return self.text

    55

    setattr(cls, "getText", getText)

    56

    57

    def setText(self, text):

    58

        self.text = text

    59

    setattr(cls, "setText", setText)

    60

    61

    def loadXMLTree(self, tree):

    62

        self.text = GetAttributeValue(tree)

    63

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

    64

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

    65

    setattr(cls, "loadXMLTree", loadXMLTree)

    66

    67

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

    68

        ind1, ind2 = getIndent(indent, name)

    69

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

    70

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

    71

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

    72

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

    73

            return text

    74

        else:

    75

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

    76

    setattr(cls, "generateXMLText", generateXMLText)

    77

    78

    def updateElementName(self, old_name, new_name):

    79

        index = self.text.find(old_name)

    80

        while index != -1:

    81

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

    82

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

    83

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

    84

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

    85

            else:

    86

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

    87

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

    88

    setattr(cls, "updateElementName", updateElementName)

    89

    90

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

    91

if cls:

    92

    cls.singleLineAttributes = False

    93

    94

    def getFileHeader(self):

    95

        fileheader = {}

    96

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

    97

        if self.fileHeader.getCompanyURL():

    98

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

    99

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

   100

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

   101

        if self.fileHeader.getProductRelease():

   102

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

   103

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

   104

        if self.fileHeader.getContentDescription():

   105

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

   106

        return fileheader

   107

    setattr(cls, "getFileHeader", getFileHeader)

   108

   109

    def setFileHeader(self, fileheader):

   110

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

   111

        if "companyURL" in fileheader:

   112

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

   113

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

   114

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

   115

        if "productRelease" in fileheader:

   116

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

   117

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

   118

        if "contentDescription" in fileheader:

   119

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

   120

    setattr(cls, "setFileHeader", setFileHeader)

   121

   122

    def setName(self, name):

   123

        self.contentHeader.setName(name)

   124

    setattr(cls, "setName", setName)

   125

   126

    def getName(self):

   127

        return self.contentHeader.getName()

   128

    setattr(cls, "getName", getName)

   129

   130

    def getDataTypes(self):

   131

        return self.types.getDataTypeElements()

   132

    setattr(cls, "getDataTypes", getDataTypes)

   133

   134

    def getDataType(self, name):

   135

        return self.types.getDataTypeElement(name)

   136

    setattr(cls, "getDataType", getDataType)

   137

   138

    def appendDataType(self, name):

   139

        self.types.appendDataTypeElement(name)

   140

    setattr(cls, "appendDataType", appendDataType)

   141

   142

    def insertDataType(self, index, datatype):

   143

        self.types.insertDataTypeElement(index, datatype)

   144

    setattr(cls, "insertDataType", insertDataType)

   145

   146

    def removeDataType(self, name):

   147

        self.types.removeDataTypeElement(name)

   148

    setattr(cls, "removeDataType", removeDataType)

   149

   150

    def getPous(self):

   151

        return self.types.getPouElements()

   152

    setattr(cls, "getPous", getPous)

   153

   154

    def getPou(self, name):

   155

        return self.types.getPouElement(name)

   156

    setattr(cls, "getPou", getPou)

   157

   158

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

   159

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

   160

    setattr(cls, "appendPou", appendPou)

   161

   162

    def insertPou(self, index, pou):

   163

        self.types.insertPouElement(index, pou)

   164

    setattr(cls, "insertPou", insertPou)

   165

   166

    def removePou(self, name):

   167

        self.types.removePouElement(name)

   168

    setattr(cls, "removePou", removePou)

   169

   170

    def getConfigurations(self):

   171

        configurations = self.instances.configurations.getConfiguration()

   172

        if configurations:

   173

            return configurations

   174

        return []

   175

    setattr(cls, "getConfigurations", getConfigurations)

   176

   177

    def getConfiguration(self, name):

   178

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

   179

            if configuration.getName() == name:

   180

                return configuration

   181

        return None

   182

    setattr(cls, "getConfiguration", getConfiguration)

   183

   184

    def addConfiguration(self, name):

   185

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

   186

            if configuration.getName() == name:

   187

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

   188

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   189

        new_configuration.setName(name)

   190

        self.instances.configurations.appendConfiguration(new_configuration)

   191

    setattr(cls, "addConfiguration", addConfiguration)    

   192

   193

    def removeConfiguration(self, name):

   194

        found = False

   195

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

   196

            if configuration.getName() == name:

   197

                self.instances.configurations.removeConfiguration(idx)

   198

                found = True

   199

                break

   200

        if not found:

   201

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

   202

    setattr(cls, "removeConfiguration", removeConfiguration)

   203

   204

    def getConfigurationResource(self, config_name, name):

   205

        configuration = self.getConfiguration(config_name)

   206

        if configuration:

   207

            for resource in configuration.getResource():

   208

                if resource.getName() == name:

   209

                    return resource

   210

        return None

   211

    setattr(cls, "getConfigurationResource", getConfigurationResource)

   212

   213

    def addConfigurationResource(self, config_name, name):

   214

        configuration = self.getConfiguration(config_name)

   215

        if configuration:

   216

            for resource in configuration.getResource():

   217

                if resource.getName() == name:

   218

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

   219

            new_resource = PLCOpenClasses["configuration_resource"]()

   220

            new_resource.setName(name)

   221

            configuration.appendResource(new_resource)

   222

    setattr(cls, "addConfigurationResource", addConfigurationResource)    

   223

   224

    def removeConfigurationResource(self, config_name, name):

   225

        configuration = self.getConfiguration(config_name)

   226

        if configuration:

   227

            found = False

   228

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

   229

                if resource.getName() == name:

   230

                    configuration.removeResource(idx)

   231

                    found = True

   232

                    break

   233

            if not found:

   234

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

   235

    setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   236

   237

    def updateElementName(self, old_name, new_name):

   238

        for pou in self.types.getPouElements():

   239

            pou.updateElementName(old_name, new_name)

   240

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

   241

            configuration.updateElementName(old_name, new_name)

   242

    setattr(cls, "updateElementName", updateElementName)

   243

   244

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

   245

if cls:

   246

    cls.singleLineAttributes = False

   247

   248

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

   249

if cls:

   250

    def updateElementName(self, old_name, new_name):

   251

        for resource in self.getResource():

   252

            resource.updateElementName(old_name, new_name)

   253

    setattr(cls, "updateElementName", updateElementName)

   254

   255

   256

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

   257

if cls:

   258

    def updateElementName(self, old_name, new_name):

   259

        for instance in self.getPouInstance():

   260

            instance.updateElementName(old_name, new_name)

   261

        for task in self.getTask():

   262

            task.updateElementName(old_name, new_name)

   263

    setattr(cls, "updateElementName", updateElementName)

   264

   265

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

   266

if cls:

   267

    def updateElementName(self, old_name, new_name):

   268

        if self.single == old_name:

   269

            self.single = new_name

   270

        for instance in self.getPouInstance():

   271

            instance.updateElementName(old_name, new_name)

   272

    setattr(cls, "updateElementName", updateElementName)

   273

   274

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

   275

if cls:

   276

    def updateElementName(self, old_name, new_name):

   277

        if self.type == old_name:

   278

            self.type = new_name

   279

    setattr(cls, "updateElementName", updateElementName)

   280

   281

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

   282

if cls:

   283

    def getDataTypeElements(self):

   284

        return self.dataTypes.getDataType()

   285

    setattr(cls, "getDataTypeElements", getDataTypeElements)

   286

   287

    def getDataTypeElement(self, name):

   288

        elements = self.dataTypes.getDataType()

   289

        for element in elements:

   290

            if element.getName() == name:

   291

                return element

   292

        return None

   293

    setattr(cls, "getDataTypeElement", getDataTypeElement)

   294

   295

    def appendDataTypeElement(self, name):

   296

        for element in self.dataTypes.getDataType():

   297

            if element.getName() == name:

   298

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

   299

        new_datatype = PLCOpenClasses["dataTypes_dataType"]()

   300

        new_datatype.setName(name)

   301

        new_datatype.baseType.setContent("BOOL", None)

   302

        self.dataTypes.appendDataType(new_datatype)

   303

    setattr(cls, "appendDataTypeElement", appendDataTypeElement)

   304

   305

    def insertDataTypeElement(self, index, datatype):

   306

        self.dataTypes.insertDataType(index, datatype)

   307

    setattr(cls, "insertDataTypeElement", insertDataTypeElement)

   308

   309

    def removeDataTypeElement(self, name):

   310

        found = False

   311

        for idx, element in enumerate(self.dataTypes.getDataType()):

   312

            if element.getName() == name:

   313

                self.dataTypes.removeDataType(idx)

   314

                found = True

   315

                break

   316

        if not found:

   317

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

   318

    setattr(cls, "removeDataTypeElement", removeDataTypeElement)

   319

   320

    def getPouElements(self):

   321

        return self.pous.getPou()

   322

    setattr(cls, "getPouElements", getPouElements)

   323

   324

    def getPouElement(self, name):

   325

        elements = self.pous.getPou()

   326

        for element in elements:

   327

            if element.getName() == name:

   328

                return element

   329

        return None

   330

    setattr(cls, "getPouElement", getPouElement)

   331

   332

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

   333

        for element in self.pous.getPou():

   334

            if element.getName() == name:

   335

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

   336

        new_pou = PLCOpenClasses["pous_pou"]()

   337

        new_pou.setName(name)

   338

        new_pou.pouType.setValue(pou_type)

   339

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

   340

        new_pou.setBodyType(body_type)

   341

        self.pous.appendPou(new_pou)

   342

    setattr(cls, "appendPouElement", appendPouElement)

   343

   344

    def insertPouElement(self, index, pou):

   345

        self.pous.insertPou(index, pou)

   346

    setattr(cls, "insertPouElement", insertPouElement)

   347

   348

    def removePouElement(self, name):

   349

        found = False

   350

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

   351

            if element.getName() == name:

   352

                self.pous.removePou(idx)

   353

                found = True

   354

                break

   355

        if not found:

   356

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

   357

    setattr(cls, "removePouElement", removePouElement)

   358

   359

def setBodyType(self, type):

   360

    if type == "IL":

   361

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

   362

    elif type == "ST":

   363

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

   364

    elif type == "LD":

   365

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

   366

    elif type == "FBD":

   367

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

   368

    elif type == "SFC":

   369

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

   370

    else:

   371

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

   372

   373

def getBodyType(self):

   374

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

   375

   376

def resetExecutionOrder(self):

   377

    self.body.resetExecutionOrder()

   378

   379

def compileExecutionOrder(self):

   380

    self.body.compileExecutionOrder()

   381

   382

def setElementExecutionOrder(self, instance, new_executionOrder):

   383

    self.body.setElementExecutionOrder(instance, new_executionOrder)

   384

   385

def addInstance(self, name, instance):

   386

    self.body.appendContentInstance(name, instance)

   387

   388

def getInstances(self):

   389

    return self.body.getContentInstances()

   390

   391

def getInstance(self, id):

   392

    return self.body.getContentInstance(id)

   393

   394

def getRandomInstance(self, exclude):

   395

    return self.body.getContentRandomInstance(exclude)

   396

   397

def getInstanceByName(self, name):

   398

    return self.body.getContentInstanceByName(name)

   399

   400

def removeInstance(self, id):

   401

    self.body.removeContentInstance(id)

   402

   403

def setText(self, text):

   404

    self.body.setText(text)

   405

   406

def getText(self):

   407

    return self.body.getText()

   408

setattr(cls, "getText", getText)

   409

   410

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

   411

if cls:

   412

    setattr(cls, "setBodyType", setBodyType)

   413

    setattr(cls, "getBodyType", getBodyType)

   414

    setattr(cls, "resetExecutionOrder", resetExecutionOrder)

   415

    setattr(cls, "compileExecutionOrder", compileExecutionOrder)

   416

    setattr(cls, "setElementExecutionOrder", setElementExecutionOrder)

   417

    setattr(cls, "addInstance", addInstance)

   418

    setattr(cls, "getInstances", getInstances)

   419

    setattr(cls, "getInstance", getInstance)

   420

    setattr(cls, "getRandomInstance", getRandomInstance)

   421

    setattr(cls, "getInstanceByName", getInstanceByName)

   422

    setattr(cls, "removeInstance", removeInstance)

   423

    setattr(cls, "setText", setText)

   424

    setattr(cls, "getText", getText)

   425

   426

    def getVars(self):

   427

        vars = []

   428

        reverse_types = {}

   429

        for name, value in VarTypes.items():

   430

            reverse_types[value] = name

   431

        for varlist in self.interface.getContent():

   432

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

   433

        return vars

   434

    setattr(cls, "getVars", getVars)

   435

   436

    def setVars(self, vars):

   437

        self.interface.setContent([])

   438

        for vartype, varlist in vars:

   439

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

   440

    setattr(cls, "setVars", setVars)

   441

   442

    def addPouVar(self, type, name):

   443

        content = self.interface.getContent()

   444

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

   445

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

   446

        else:

   447

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

   448

            variables = varlist.getVariable()

   449

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

   450

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

   451

        var = PLCOpenClasses["varListPlain_variable"]()

   452

        var.setName(name)

   453

        var_type = PLCOpenClasses["dataType"]()

   454

        derived_type = PLCOpenClasses["derived"]()

   455

        derived_type.setName(type)

   456

        var_type.setValue(derived_type)

   457

        var.setType(var_type)

   458

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

   459

    setattr(cls, "addPouVar", addPouVar)

   460

   461

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

   462

        content = self.interface.getContent()

   463

        for varlist in content:

   464

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

   465

            for var in variables:

   466

                if var.getName() == old_name:

   467

                    vartype_content = var.getType().getContent()

   468

                    if vartype_content["value"] is not None and vartype_content["value"].getName() == old_type:

   469

                        var.setName(new_name)

   470

                        vartype_content["value"].setName(new_type)

   471

                        return

   472

    setattr(cls, "changePouVar", changePouVar)

   473

   474

    def removePouVar(self, type, name):

   475

        content = self.interface.getContent()

   476

        for varlist in content:

   477

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

   478

            for var in variables:

   479

                if var.getName() == name:

   480

                    var_type = var.getType().getValue()

   481

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

   482

                        variables.remove(var)

   483

                        break

   484

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

   485

                content.remove(varlist)

   486

                break

   487

    setattr(cls, "removePouVar", removePouVar)

   488

   489

    def hasBlock(self, name):

   490

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

   491

            for instance in self.getInstances():

   492

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

   493

                    return True

   494

            if self.transitions:

   495

                for transition in self.transitions.getTransition():