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 *

    27

import os, sys

    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 = {}

    48

PLCOpenTypes = {}

    49

base_folder = ""

    50

for path in sys.path:

    51

    if os.path.isfile(os.path.join(path, "plcopen/TC6_XML_V10_B.xsd")):

    52

        base_folder = path

    53

GenerateClassesFromXSD(os.path.join(base_folder, "plcopen/TC6_XML_V10_B.xsd"))

    54

CreateClasses(PLCOpenClasses, PLCOpenTypes)

    55

    58

    cls.value = None

    59

    60

    def getValue(self):

    61

        return self.value

    62

    setattr(cls, "getValue", getValue)

    63

    64

    def setValue(self, value):

    65

        self.value = value

    66

    setattr(cls, "setValue", setValue)

    67

    68

    def loadXMLTree(self, tree):

    75

    setattr(cls, "loadXMLTree", loadXMLTree)

    76

    77

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

    78

        ind1, ind2 = getIndent(indent, name)

    79

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

    85

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

    86

        return text

    87

    setattr(cls, "generateXMLText", generateXMLText)

    88

    91

    cls.text = ""

    92

    93

    def getText(self):

    94

        return self.text

    95

    setattr(cls, "getText", getText)

    96

    97

    def setText(self, text):

    98

        self.text = text

    99

    setattr(cls, "setText", setText)

   100

   101

    def loadXMLTree(self, tree):

   102

        self.text = GetAttributeValue(tree)

   103

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

   104

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

   105

    setattr(cls, "loadXMLTree", loadXMLTree)

   106

   107

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

   108

        ind1, ind2 = getIndent(indent, name)

   109

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

   111

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

   113

            return text

   114

        else:

   116

    setattr(cls, "generateXMLText", generateXMLText)

   117

   118

    def updateElementName(self, old_name, new_name):

   119

        index = self.text.find(old_name)

   120

        while index != -1:

   121

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

   122

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

   123

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

   124

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

   125

            else:

   126

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

   127

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

   128

    setattr(cls, "updateElementName", updateElementName)

   129

   132

    cls.singleLineAttributes = False

   133

   134

    def getFileHeader(self):

   135

        fileheader = {}

   136

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

   137

        if self.fileHeader.getCompanyURL():

   138

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

   139

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

   140

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

   141

        if self.fileHeader.getProductRelease():

   142

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

   143

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

   144

        if self.fileHeader.getContentDescription():

   145

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

   146

        return fileheader

   147

    setattr(cls, "getFileHeader", getFileHeader)

   148

   149

    def setFileHeader(self, fileheader):

   150

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

   151

        if "companyURL" in fileheader:

   152

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

   153

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

   154

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

   155

        if "productRelease" in fileheader:

   156

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

   157

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

   158

        if "contentDescription" in fileheader:

   159

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

   160

    setattr(cls, "setFileHeader", setFileHeader)

   161

   162

    def setName(self, name):

   163

        self.contentHeader.setName(name)

   164

    setattr(cls, "setName", setName)

   165

   166

    def getName(self):

   167

        return self.contentHeader.getName()

   168

    setattr(cls, "getName", getName)

   169

   170

    def getPous(self):

   171

        return self.types.getPouElements()

   172

    setattr(cls, "getPous", getPous)

   173

   174

    def getPou(self, name):

   175

        return self.types.getPouElement(name)

   176

    setattr(cls, "getPou", getPou)

   177

   178

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

   179

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

   180

    setattr(cls, "appendPou", appendPou)

   181

   182

    def insertPou(self, index, pou):

   183

        self.types.insertPouElement(index, pou)

   184

    setattr(cls, "insertPou", insertPou)

   185

   186

    def removePou(self, name):

   187

        self.types.removePouElement(name)

   188

    setattr(cls, "removePou", removePou)

   189

   190

    def getConfigurations(self):

   191

        configurations = self.instances.configurations.getConfiguration()

   192

        if configurations:

   193

            return configurations

   194

        return []

   195

    setattr(cls, "getConfigurations", getConfigurations)

   196

   197

    def getConfiguration(self, name):

   198

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

   199

            if configuration.getName() == name:

   200

                return configuration

   201

        return None

   202

    setattr(cls, "getConfiguration", getConfiguration)

   203

   204

    def addConfiguration(self, name):

   205

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

   206

            if configuration.getName() == name:

   207

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

   208

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   209

        new_configuration.setName(name)

   210

        self.instances.configurations.appendConfiguration(new_configuration)

   211

    setattr(cls, "addConfiguration", addConfiguration)    

   212

   213

    def removeConfiguration(self, name):

   214

        found = False

   215

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

   216

            if configuration.getName() == name:

   217

                self.instances.configurations.removeConfiguration(idx)

   218

                found = True

   219

                break

   220

        if not found:

   221

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

   222

    setattr(cls, "removeConfiguration", removeConfiguration)

   223

   224

    def getConfigurationResource(self, config_name, name):

   225

        configuration = self.getConfiguration(config_name)

   226

        if configuration:

   227

            for resource in configuration.getResource():

   228

                if resource.getName() == name:

   229

                    return resource

   230

        return None

   231

    setattr(cls, "getConfigurationResource", getConfigurationResource)

   232

   233

    def addConfigurationResource(self, config_name, name):

   234

        configuration = self.getConfiguration(config_name)

   235

        if configuration:

   236

            for resource in configuration.getResource():

   237

                if resource.getName() == name:

   238

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

   239

            new_resource = PLCOpenClasses["configuration_resource"]()

   240

            new_resource.setName(name)

   241

            configuration.appendResource(new_resource)

   242

    setattr(cls, "addConfigurationResource", addConfigurationResource)    

   243

   244

    def removeConfigurationResource(self, config_name, name):

   245

        configuration = self.getConfiguration(config_name)

   246

        if configuration:

   247

            found = False

   248

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

   249

                if resource.getName() == name:

   250

                    configuration.removeResource(idx)

   251

                    found = True

   252

                    break

   253

            if not found:

   254

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

   255

    setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   256

   257

    def updateElementName(self, old_name, new_name):

   258

        for pou in self.types.getPouElements():

   259

            pou.updateElementName(old_name, new_name)

   260

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

   261

            configuration.updateElementName(old_name, new_name)

   262

    setattr(cls, "updateElementName", updateElementName)

   263

   270

    def updateElementName(self, old_name, new_name):

   271

        for resource in self.getResource():

   272

            resource.updateElementName(old_name, new_name)

   273

    setattr(cls, "updateElementName", updateElementName)

   274

   275

   278

    def updateElementName(self, old_name, new_name):

   279

        for instance in self.getPouInstance():

   280

            instance.updateElementName(old_name, new_name)

   281

        for task in self.getTask():

   282

            task.updateElementName(old_name, new_name)

   283

    setattr(cls, "updateElementName", updateElementName)

   284

   287

    def updateElementName(self, old_name, new_name):

   288

        if self.single == old_name:

   289

            self.single = new_name

   290

        for instance in self.getPouInstance():

   291

            instance.updateElementName(old_name, new_name)

   292

    setattr(cls, "updateElementName", updateElementName)

   293

   296

    def updateElementName(self, old_name, new_name):

   297

        if self.type == old_name:

   298

            self.type = new_name

   299

    setattr(cls, "updateElementName", updateElementName)

   300

   303

    def getPouElements(self):

   304

        return self.pous.getPou()

   305

    setattr(cls, "getPouElements", getPouElements)

   306

   307

    def getPouElement(self, name):

   308

        elements = self.pous.getPou()

   309

        for element in elements:

   310

            if element.getName() == name:

   311

                return element

   312

        return None

   313

    setattr(cls, "getPouElement", getPouElement)

   314

   315

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

   316

        for element in self.pous.getPou():

   317

            if element.getName() == name:

   318

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

   319

        new_pou = PLCOpenClasses["pous_pou"]()

   320

        new_pou.setName(name)

   321

        new_pou.pouType.setValue(pou_type)

   322

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

   323

        new_pou.setBodyType(body_type)

   324

        self.pous.appendPou(new_pou)

   325

    setattr(cls, "appendPouElement", appendPouElement)

   326

   327

    def insertPouElement(self, index, pou):

   328

        self.pous.insertPou(index, pou)

   329

    setattr(cls, "insertPouElement", insertPouElement)

   330

   331

    def removePouElement(self, name):

   332

        found = False

   333

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

   334

            if element.getName() == name:

   335

                self.pous.removePou(idx)

   336

                found = True

   337

                break

   338

        if not found:

   339

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

   340

    setattr(cls, "removePouElement", removePouElement)

   341

   342

def setBodyType(self, type):

   343

    if type == "IL":

   344

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

   345

    elif type == "ST":

   346

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

   347

    elif type == "LD":

   348

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

   349

    elif type == "FBD":

   350

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

   351

    elif type == "SFC":

   352

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

   353

    else:

   354

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

   355

   356

def getBodyType(self):

   357

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

   358

   359

def addInstance(self, name, instance):

   360

    self.body.appendContentInstance(name, instance)

   361

   362

def getInstances(self):

   363

    return self.body.getContentInstances()

   364

   365

def getInstance(self, id):

   366

    return self.body.getContentInstance(id)

   367

   368

def getRandomInstance(self, exclude):

   369

    return self.body.getContentRandomInstance(exclude)

   370

   371

def getInstanceByName(self, name):

   372

    return self.body.getContentInstanceByName(name)

   373

   374

def removeInstance(self, id):

   375

    self.body.removeContentInstance(id)

   376

   377

def setText(self, text):

   378

    self.body.setText(text)

   379

   380

def getText(self):

   381

    return self.body.getText()

   382

setattr(cls, "getText", getText)

   383

   386

    setattr(cls, "setBodyType", setBodyType)

   387

    setattr(cls, "getBodyType", getBodyType)

   388

    setattr(cls, "addInstance", addInstance)

   389

    setattr(cls, "getInstances", getInstances)

   390

    setattr(cls, "getInstance", getInstance)

   391

    setattr(cls, "getRandomInstance", getRandomInstance)

   392

    setattr(cls, "getInstanceByName", getInstanceByName)

   393

    setattr(cls, "removeInstance", removeInstance)

   394

    setattr(cls, "setText", setText)

   395

    setattr(cls, "getText", getText)

   396

   397

    def getVars(self):

   398

        vars = []

   399

        reverse_types = {}

   400

        for name, value in VarTypes.items():

   401

            reverse_types[value] = name

   402

        for varlist in self.interface.getContent():

   403

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

   404

        return vars

   405

    setattr(cls, "getVars", getVars)

   406

   407

    def setVars(self, vars):

   408

        self.interface.setContent([])

   409

        for vartype, varlist in vars:

   410

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

   411

    setattr(cls, "setVars", setVars)

   412

   442

    def addTransition(self, name, type):

   443

        if not self.transitions:

   444

            self.addTransitions()

   445

            self.transitions.setTransition([])

   446

        transition = PLCOpenClasses["transitions_transition"]()

   447

        transition.setName(name)

   448

        transition.setBodyType(type)

   449

        self.transitions.appendTransition(transition)

   450

    setattr(cls, "addTransition", addTransition)

   451

   452

    def getTransition(self, name):

   453

        if self.transitions:

   454

            for transition in self.transitions.getTransition():

   455

                if transition.getName() == name:

   456

                    return transition

   457

        return None

   458

    setattr(cls, "getTransition", getTransition)

   459

   460

    def getTransitionList(self):

   461

        if self.transitions:

   462

            return self.transitions.getTransition()

   463

        return []

   464

    setattr(cls, "getTransitionList", getTransitionList)

   465

   466

    def removeTransition(self, name):

   467

        if self.transitions:

   468

            transitions = self.transitions.getTransition()

   469

            i = 0

   470

            removed = False

   471

            while i < len(transitions) and not removed:

   472

                if transitions[i].getName() == name:

   473

                    transitions.pop(i)

   474

                    removed = True

   475

                i += 1

   476

            if not removed:

   477

                raise ValueError, "Transition with name %s doesn't exists!"%name

   478

    setattr(cls, "removeTransition", removeTransition)

   479

   480

    def addAction(self, name, type):

   481

        if not self.actions:

   482

            self.addActions()

   483

            self.actions.setAction([])

   484

        action = PLCOpenClasses["actions_action"]()

   485

        action.setName(name)

   486

        action.setBodyType(type)

   487

        self.actions.appendAction(action)

   488

    setattr(cls, "addAction", addAction)

   489

   490

    def getAction(self, name):

   491

        if self.actions:

   492

            for action in self.actions.getAction():

   493

                if action.getName() == name:

   494

                    return action

   495

        return None

   496