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 addInstance(self, name, instance):

   353

    self.body.appendContentInstance(name, instance)

   354

   355

def getInstances(self):

   356

    return self.body.getContentInstances()

   357

   358

def getInstance(self, id):

   359

    return self.body.getContentInstance(id)

   360

   361

def getRandomInstance(self, exclude):

   362

    return self.body.getContentRandomInstance(exclude)

   363

   364

def getInstanceByName(self, name):

   365

    return self.body.getContentInstanceByName(name)

   366

   367

def removeInstance(self, id):

   368

    self.body.removeContentInstance(id)

   369

   370

def setText(self, text):

   371

    self.body.setText(text)

   372

   373

def getText(self):

   374

    return self.body.getText()

   375

setattr(cls, "getText", getText)

   376

   377

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

   378

if cls:

   379

    setattr(cls, "setBodyType", setBodyType)

   380

    setattr(cls, "getBodyType", getBodyType)

   381

    setattr(cls, "addInstance", addInstance)

   382

    setattr(cls, "getInstances", getInstances)

   383

    setattr(cls, "getInstance", getInstance)

   384

    setattr(cls, "getRandomInstance", getRandomInstance)

   385

    setattr(cls, "getInstanceByName", getInstanceByName)

   386

    setattr(cls, "removeInstance", removeInstance)

   387

    setattr(cls, "setText", setText)

   388

    setattr(cls, "getText", getText)

   389

   390

    def getVars(self):

   391

        vars = []

   392

        reverse_types = {}

   393

        for name, value in VarTypes.items():

   394

            reverse_types[value] = name

   395

        for varlist in self.interface.getContent():

   396

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

   397

        return vars

   398

    setattr(cls, "getVars", getVars)

   399

   400

    def setVars(self, vars):

   401

        self.interface.setContent([])

   402

        for vartype, varlist in vars:

   403

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

   404

    setattr(cls, "setVars", setVars)

   405

   406

    def addPouVar(self, type, name):

   407

        content = self.interface.getContent()

   408

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

   409

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

   410

        else:

   411

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

   412

            variables = varlist.getVariable()

   413

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

   414

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

   415

        var = PLCOpenClasses["varListPlain_variable"]()

   416

        var.setName(name)

   417

        var_type = PLCOpenClasses["dataType"]()

   418

        derived_type = PLCOpenClasses["derived"]()

   419

        derived_type.setName(type)

   420

        var_type.setValue(derived_type)

   421

        var.setType(var_type)

   422

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

   423

    setattr(cls, "addPouVar", addPouVar)

   424

   425

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

   426

        content = self.interface.getContent()

   427

        for varlist in content:

   428

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

   429

            for var in variables:

   430

                if var.getName() == old_name:

   431

                    var_type = var.getType().getValue()

   432

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

   433

                        var.setName(new_name)

   434

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

   435

                        return

   436

    setattr(cls, "changePouVar", changePouVar)

   437

   438

    def removePouVar(self, type, name):

   439

        content = self.interface.getContent()

   440

        for varlist in content:

   441

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

   442

            for var in variables:

   443

                if var.getName() == name:

   444

                    var_type = var.getType().getValue()

   445

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

   446

                        variables.remove(var)

   447

                        break

   448

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

   449

                content.remove(varlist)

   450

                break

   451

    setattr(cls, "removePouVar", removePouVar)

   452

   453

    def hasBlock(self, name):

   454

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

   455

            for instance in self.getInstances():

   456

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

   457

                    return True

   458

            if self.transitions:

   459

                for transition in self.transitions.getTransition():

   460

                    result = transition.hasBlock(name)

   461

                    if result:

   462

                        return result

   463

            if self.actions:

   464

                for action in self.actions.getAction():

   465

                    result = action.hasBlock(name)

   466

                    if result:

   467

                        return result

   468

        return False

   469

    setattr(cls, "hasBlock", hasBlock)

   470

   471

    def addTransition(self, name, type):

   472

        if not self.transitions:

   473

            self.addTransitions()

   474

            self.transitions.setTransition([])

   475

        transition = PLCOpenClasses["transitions_transition"]()

   476

        transition.setName(name)

   477

        transition.setBodyType(type)

   478

        self.transitions.appendTransition(transition)

   479

    setattr(cls, "addTransition", addTransition)

   480

   481

    def getTransition(self, name):

   482

        if self.transitions:

   483

            for transition in self.transitions.getTransition():

   484

                if transition.getName() == name:

   485

                    return transition

   486

        return None

   487

    setattr(cls, "getTransition", getTransition)

   488

   489

    def getTransitionList(self):

   490

        if self.transitions:

   491

            return self.transitions.getTransition()

   492

        return []

   493

    setattr(cls, "getTransitionList", getTransitionList)

   494

   495

    def removeTransition(self, name):