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

import os, sys

    27

    28

"""

    29

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

    30

"""

    31

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

    32

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

    33

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

    34

    35

"""

    36

Define in which order var types must be displayed

    37

"""

    38

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

    39

    40

"""

    41

Define which action qualifier must be associated with a duration 

    42

"""

    43

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

    44

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

    45

    46

PLCOpenClasses = {}

    47

PLCOpenTypes = {}

    48

base_folder = ""

    49

for path in sys.path:

    50

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

    51

        base_folder = path

    52

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

    53

CreateClasses(PLCOpenClasses, PLCOpenTypes)

    54

    55

if "dataType" in PLCOpenClasses:

    56

    cls = PLCOpenClasses["dataType"]

    57

    cls.value = None

    58

    59

    def getValue(self):

    60

        return self.value

    61

    setattr(cls, "getValue", getValue)

    62

    63

    def setValue(self, value):

    64

        self.value = value

    65

    setattr(cls, "setValue", setValue)

    66

    67

    def loadXMLTree(self, tree):

    68

        self.value = tree.childNodes[1].nodeName

    69

    setattr(cls, "loadXMLTree", loadXMLTree)

    70

    71

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

    72

        ind1, ind2 = getIndent(indent, name)

    73

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

    74

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

    75

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

    76

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

    77

        return text

    78

    setattr(cls, "generateXMLText", generateXMLText)

    79

    80

if "formattedText" in PLCOpenClasses:

    81

    cls = PLCOpenClasses["formattedText"]

    82

    cls.text = ""

    83

    84

    def getText(self):

    85

        return self.text

    86

    setattr(cls, "getText", getText)

    87

    88

    def setText(self, text):

    89

        self.text = text

    90

    setattr(cls, "setText", setText)

    91

    92

    def loadXMLTree(self, tree):

    93

        self.text = GetAttributeValue(tree)

    94

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

    95

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

    96

    setattr(cls, "loadXMLTree", loadXMLTree)

    97

    98

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

    99

        ind1, ind2 = getIndent(indent, name)

   100

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

   101

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

   102

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

   103

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

   104

            return text

   105

        else:

   106

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

   107

    setattr(cls, "generateXMLText", generateXMLText)

   108

   109

    def updateElementName(self, old_name, new_name):

   110

        index = self.text.find(old_name)

   111

        while index != -1:

   112

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

   113

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

   114

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

   115

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

   116

            else:

   117

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

   118

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

   119

    setattr(cls, "updateElementName", updateElementName)

   120

   121

if "project" in PLCOpenClasses:

   122

    cls = PLCOpenClasses["project"]

   123

    cls.singleLineAttributes = False

   124

   125

    def getFileHeader(self):

   126

        fileheader = {}

   127

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

   128

        if self.fileHeader.getCompanyURL():

   129

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

   130

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

   131

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

   132

        if self.fileHeader.getProductRelease():

   133

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

   134

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

   135

        if self.fileHeader.getContentDescription():

   136

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

   137

        return fileheader

   138

    setattr(cls, "getFileHeader", getFileHeader)

   139

   140

    def setFileHeader(self, fileheader):

   141

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

   142

        if "companyURL" in fileheader:

   143

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

   144

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

   145

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

   146

        if "productRelease" in fileheader:

   147

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

   148

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

   149

        if "contentDescription" in fileheader:

   150

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

   151

    setattr(cls, "setFileHeader", setFileHeader)

   152

   153

    def setName(self, name):

   154

        self.contentHeader.setName(name)

   155

    setattr(cls, "setName", setName)

   156

   157

    def getName(self):

   158

        return self.contentHeader.getName()

   159

    setattr(cls, "getName", getName)

   160

   161

    def getPous(self):

   162

        return self.types.getPouElements()

   163

    setattr(cls, "getPous", getPous)

   164

   165

    def getPou(self, name):

   166

        return self.types.getPouElement(name)

   167

    setattr(cls, "getPou", getPou)

   168

   169

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

   170

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

   171

    setattr(cls, "appendPou", appendPou)

   172

   173

    def insertPou(self, index, pou):

   174

        self.types.insertPouElement(index, pou)

   175

    setattr(cls, "insertPou", insertPou)

   176

   177

    def removePou(self, name):

   178

        self.types.removePouElement(name)

   179

    setattr(cls, "removePou", removePou)

   180

   181

    def getConfigurations(self):

   182

        configurations = self.instances.configurations.getConfiguration()

   183

        if configurations:

   184

            return configurations

   185

        return []

   186

    setattr(cls, "getConfigurations", getConfigurations)

   187

   188

    def getConfiguration(self, name):

   189

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

   190

            if configuration.getName() == name:

   191

                return configuration

   192

        return None

   193

    setattr(cls, "getConfiguration", getConfiguration)

   194

   195

    def addConfiguration(self, name):

   196

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

   197

            if configuration.getName() == name:

   198

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

   199

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   200

        new_configuration.setName(name)

   201

        self.instances.configurations.appendConfiguration(new_configuration)

   202

    setattr(cls, "addConfiguration", addConfiguration)    

   203

   204

    def removeConfiguration(self, name):

   205

        found = False

   206

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

   207

            if configuration.getName() == name:

   208

                self.instances.configurations.removeConfiguration(idx)

   209

                found = True

   210

                break

   211

        if not found:

   212

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

   213

    setattr(cls, "removeConfiguration", removeConfiguration)

   214

   215

    def getConfigurationResource(self, config_name, name):

   216

        configuration = self.getConfiguration(config_name)

   217

        if configuration:

   218

            for resource in configuration.getResource():

   219

                if resource.getName() == name:

   220

                    return resource

   221

        return None

   222

    setattr(cls, "getConfigurationResource", getConfigurationResource)

   223

   224

    def addConfigurationResource(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

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

   230

            new_resource = PLCOpenClasses["configuration_resource"]()

   231

            new_resource.setName(name)

   232

            configuration.appendResource(new_resource)

   233

    setattr(cls, "addConfigurationResource", addConfigurationResource)    

   234

   235

    def removeConfigurationResource(self, config_name, name):

   236

        configuration = self.getConfiguration(config_name)

   237

        if configuration:

   238

            found = False

   239

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

   240

                if resource.getName() == name:

   241

                    configuration.removeResource(idx)

   242

                    found = True

   243

                    break

   244

            if not found:

   245

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

   246

    setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   247

   248

    def updateElementName(self, old_name, new_name):

   249

        for pou in self.types.getPouElements():

   250

            pou.updateElementName(old_name, new_name)

   251

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

   252

            configuration.updateElementName(old_name, new_name)

   253

    setattr(cls, "updateElementName", updateElementName)

   254

   255

PLCOpenClasses["project_fileHeader"].singleLineAttributes = False

   256

   257

if "configurations_configuration" in PLCOpenClasses:

   258

    cls = PLCOpenClasses["configurations_configuration"]

   259

   260

    def updateElementName(self, old_name, new_name):

   261

        for resource in self.getResource():

   262

            resource.updateElementName(old_name, new_name)

   263

    setattr(cls, "updateElementName", updateElementName)

   264

   265

   266

if "configuration_resource" in PLCOpenClasses:

   267

    cls = PLCOpenClasses["configuration_resource"]

   268

   269

    def updateElementName(self, old_name, new_name):

   270

        for instance in self.getPouInstance():

   271

            instance.updateElementName(old_name, new_name)

   272

        for task in self.getTask():

   273

            task.updateElementName(old_name, new_name)

   274

    setattr(cls, "updateElementName", updateElementName)

   275

   276

if "resource_task" in PLCOpenClasses:

   277

    cls = PLCOpenClasses["resource_task"]

   278

   279

    def updateElementName(self, old_name, new_name):

   280

        if self.single == old_name:

   281

            self.single = new_name

   282

        for instance in self.getPouInstance():

   283

            instance.updateElementName(old_name, new_name)

   284

    setattr(cls, "updateElementName", updateElementName)

   285

   286

if "pouInstance" in PLCOpenClasses:

   287

    cls = PLCOpenClasses["pouInstance"]

   288

   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

if "project_types" in PLCOpenClasses:

   295

    cls = PLCOpenClasses["project_types"]

   296

   297

    def getPouElements(self):

   298

        return self.pous.getPou()

   299

    setattr(cls, "getPouElements", getPouElements)

   300

   301

    def getPouElement(self, name):

   302

        elements = self.pous.getPou()

   303

        for element in elements:

   304

            if element.getName() == name:

   305

                return element

   306

        return None

   307

    setattr(cls, "getPouElement", getPouElement)

   308

   309

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

   310

        for element in self.pous.getPou():

   311

            if element.getName() == name:

   312

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

   313

        new_pou = PLCOpenClasses["pous_pou"]()

   314

        new_pou.setName(name)

   315

        new_pou.pouType.setValue(pou_type)

   316

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

   317

        new_pou.setBodyType(body_type)

   318

        self.pous.appendPou(new_pou)

   319

    setattr(cls, "appendPouElement", appendPouElement)

   320

   321

    def insertPouElement(self, index, pou):

   322

        self.pous.insertPou(index, pou)

   323

    setattr(cls, "insertPouElement", insertPouElement)

   324

   325

    def removePouElement(self, name):

   326

        found = False

   327

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

   328

            if element.getName() == name:

   329

                self.pous.removePou(idx)

   330

                found = True

   331

                break

   332

        if not found:

   333

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

   334

    setattr(cls, "removePouElement", removePouElement)

   335

   336

def setBodyType(self, type):

   337

    if type == "IL":

   338

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

   339

    elif type == "ST":

   340

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

   341

    elif type == "LD":

   342

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

   343

    elif type == "FBD":

   344

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

   345

    elif type == "SFC":

   346

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

   347

    else:

   348

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

   349

   350

def getBodyType(self):

   351

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

   352

   353

def addInstance(self, name, instance):

   354

    self.body.appendContentInstance(name, instance)

   355

   356

def getInstances(self):

   357

    return self.body.getContentInstances()

   358

   359

def getInstance(self, id):

   360

    return self.body.getContentInstance(id)

   361

   362

def getRandomInstance(self, exclude):

   363

    return self.body.getContentRandomInstance(exclude)

   364

   365

def getInstanceByName(self, name):

   366

    return self.body.getContentInstanceByName(name)

   367

   368

def removeInstance(self, id):

   369

    self.body.removeContentInstance(id)

   370

   371

def setText(self, text):

   372

    self.body.setText(text)

   373

   374

def getText(self):

   375

    return self.body.getText()

   376

setattr(cls, "getText", getText)

   377

   378

if "pous_pou" in PLCOpenClasses:

   379

    cls = PLCOpenClasses["pous_pou"]

   380

   381

    setattr(cls, "setBodyType", setBodyType)

   382

    setattr(cls, "getBodyType", getBodyType)

   383

    setattr(cls, "addInstance", addInstance)

   384

    setattr(cls, "getInstances", getInstances)

   385

    setattr(cls, "getInstance", getInstance)

   386

    setattr(cls, "getRandomInstance", getRandomInstance)

   387

    setattr(cls, "getInstanceByName", getInstanceByName)

   388

    setattr(cls, "removeInstance", removeInstance)

   389

    setattr(cls, "setText", setText)

   390

    setattr(cls, "getText", getText)

   391

   392

    def getVars(self):

   393

        vars = []

   394

        reverse_types = {}

   395

        for name, value in VarTypes.items():

   396

            reverse_types[value] = name

   397

        for varlist in self.interface.getContent():

   398

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

   399

        return vars

   400

    setattr(cls, "getVars", getVars)

   401

   402

    def setVars(self, vars):

   403

        self.interface.setContent([])

   404

        for vartype, varlist in vars:

   405

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

   406

    setattr(cls, "setVars", setVars)

   407

   408

    def addTransition(self, name, type):

   409

        if not self.transitions:

   410

            self.addTransitions()

   411

            self.transitions.setTransition([])

   412

        transition = PLCOpenClasses["transitions_transition"]()

   413

        transition.setName(name)

   414

        transition.setBodyType(type)

   415

        self.transitions.appendTransition(transition)

   416

    setattr(cls, "addTransition", addTransition)

   417

   418

    def getTransition(self, name):

   419

        if self.transitions:

   420

            for transition in self.transitions.getTransition():

   421

                if transition.getName() == name:

   422

                    return transition

   423

        return None

   424

    setattr(cls, "getTransition", getTransition)

   425

   426

    def getTransitionList(self):

   427

        if self.transitions:

   428

            return self.transitions.getTransition()

   429

        return []

   430

    setattr(cls, "getTransitionList", getTransitionList)

   431

   432

    def removeTransition(self, name):

   433

        if self.transitions:

   434

            transitions = self.transitions.getTransition()

   435

            i = 0

   436

            removed = False

   437

            while i < len(transitions) and not removed:

   438

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

   439

                    transitions.pop(i)

   440

                    removed = True

   441

                i += 1

   442

            if not removed:

   443

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

   444

    setattr(cls, "removeTransition", removeTransition)

   445

   446

    def addAction(self, name, type):

   447

        if not self.actions:

   448

            self.addActions()

   449

            self.actions.setAction([])

   450

        action = PLCOpenClasses["actions_action"]()

   451

        action.setName(name)

   452

        action.setBodyType(type)

   453

        self.actions.appendAction(action)

   454

    setattr(cls, "addAction", addAction)

   455

   456

    def getAction(self, name):

   457

        if self.actions:

   458

            for action in self.actions.getAction():

   459

                if action.getName() == name:

   460

                    return action

   461

        return None

   462

    setattr(cls, "getAction", getAction)

   463

   464

    def getActionList(self):

   465

        if self.actions:

   466

            return self.actions.getAction()

   467

        return []

   468

    setattr(cls, "getActionList", getActionList)

   469

   470

    def removeAction(self, name):

   471

        if self.actions:

   472

            actions = self.actions.getAction()

   473

            i = 0

   474

            removed = False

   475

            while i < len(actions) and not removed:

   476

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

   477

                    actions.pop(i)

   478

                    removed = True

   479

                i += 1

   480

            if not removed:

   481

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

   482

    setattr(cls, "removeAction", removeAction)

   483

   484

    def updateElementName(self, old_name, new_name):

   485

        self.body.updateElementName(old_name, new_name)

   486

        for action in self.getActionList():

   487

            action.updateElementName(old_name, new_name)

   488

        for transition in self.getTransitionList():

   489

            transition.updateElementName(old_name, new_name)

   490

    setattr(cls, "updateElementName", updateElementName)

   491

   492

if "transitions_transition" in PLCOpenClasses:

   493

    cls = PLCOpenClasses["transitions_transition"]

   494

   495

    setattr(cls, "setBodyType", setBodyType)

   496

    setattr(cls, "getBodyType", getBodyType)

   497

    setattr(cls, "addInstance", addInstance)