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): 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

#Lesser 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

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

    49

CreateClasses(PLCOpenClasses, PLCOpenTypes)

    50

    51

if "dataType" in PLCOpenClasses:

    52

    cls = PLCOpenClasses["dataType"]

    53

    cls.value = None

    54

    55

    def getValue(self):

    56

        return self.value

    57

    setattr(cls, "getValue", getValue)

    58

    59

    def setValue(self, value):

    60

        self.value = value

    61

    setattr(cls, "setValue", setValue)

    62

    63

    def loadXMLTree(self, tree):

    64

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

    65

    setattr(cls, "loadXMLTree", loadXMLTree)

    66

    67

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

    68

        ind1, ind2 = getIndent(indent, name)

    69

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

    70

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

    71

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

    72

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

    73

        return text

    74

    setattr(cls, "generateXMLText", generateXMLText)

    75

    76

if "formattedText" in PLCOpenClasses:

    77

    cls = PLCOpenClasses["formattedText"]

    78

    cls.text = ""

    79

    80

    def getText(self):

    81

        return self.text

    82

    setattr(cls, "getText", getText)

    83

    84

    def setText(self, text):

    85

        self.text = text

    86

    setattr(cls, "setText", setText)

    87

    88

    def loadXMLTree(self, tree):

    89

        self.text = GetAttributeValue(tree)

    90

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

    91

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

    92

    setattr(cls, "loadXMLTree", loadXMLTree)

    93

    94

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

    95

        ind1, ind2 = getIndent(indent, name)

    96

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

    97

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

    98

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

    99

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

   100

            return text

   101

        else:

   102

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

   103

    setattr(cls, "generateXMLText", generateXMLText)

   104

   105

if "project" in PLCOpenClasses:

   106

    cls = PLCOpenClasses["project"]

   107

    cls.singleLineAttributes = False

   108

   109

    def getFileHeader(self):

   110

        fileheader = {}

   111

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

   112

        if self.fileHeader.getCompanyURL():

   113

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

   114

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

   115

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

   116

        if self.fileHeader.getProductRelease():

   117

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

   118

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

   119

        if self.fileHeader.getContentDescription():

   120

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

   121

        return fileheader

   122

    setattr(cls, "getFileHeader", getFileHeader)

   123

   124

    def setFileHeader(self, fileheader):

   125

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

   126

        if "companyURL" in fileheader:

   127

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

   128

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

   129

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

   130

        if "productRelease" in fileheader:

   131

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

   132

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

   133

        if "contentDescription" in fileheader:

   134

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

   135

    setattr(cls, "setFileHeader", setFileHeader)

   136

   137

    def setName(self, name):

   138

        self.contentHeader.setName(name)

   139

    setattr(cls, "setName", setName)

   140

   141

    def getName(self):

   142

        return self.contentHeader.getName()

   143

    setattr(cls, "getName", getName)

   144

   145

    def getPous(self):

   146

        return self.types.getPouElements()

   147

    setattr(cls, "getPous", getPous)

   148

   149

    def getPou(self, name):

   150

        return self.types.getPouElement(name)

   151

    setattr(cls, "getPou", getPou)

   152

   153

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

   154

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

   155

    setattr(cls, "appendPou", appendPou)

   156

   157

    def insertPou(self, index, pou):

   158

        self.types.insertPouElement(index, pou)

   159

    setattr(cls, "insertPou", insertPou)

   160

   161

    def removePou(self, name):

   162

        self.types.removePouElement(name)

   163

    setattr(cls, "removePou", removePou)

   164

   165

    def getConfigurations(self):

   166

        configurations = self.instances.configurations.getConfiguration()

   167

        if configurations:

   168

            return configurations

   169

        return []

   170

    setattr(cls, "getConfigurations", getConfigurations)

   171

   172

    def getConfiguration(self, name):

   173

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

   174

            if configuration.getName() == name:

   175

                return configuration

   176

        return None

   177

    setattr(cls, "getConfiguration", getConfiguration)

   178

   179

    def addConfiguration(self, name):

   180

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

   181

            if configuration.getName() == name:

   182

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

   183

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   184

        new_configuration.setName(name)

   185

        self.instances.configurations.appendConfiguration(new_configuration)

   186

    setattr(cls, "addConfiguration", addConfiguration)    

   187

   188

    def removeConfiguration(self, name):

   189

        found = False

   190

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

   191

            if configuration.getName() == name:

   192

                self.instances.configurations.removeConfiguration(idx)

   193

                found = True

   194

                break

   195

        if not found:

   196

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

   197

    setattr(cls, "removeConfiguration", removeConfiguration)

   198

   199

    def getConfigurationResource(self, config_name, name):

   200

        configuration = self.getConfiguration(config_name)

   201

        if configuration:

   202

            for resource in configuration.getResource():

   203

                if resource.getName() == name:

   204

                    return resource

   205

        return None

   206

    setattr(cls, "getConfigurationResource", getConfigurationResource)

   207

   208

    def addConfigurationResource(self, config_name, name):

   209

        configuration = self.getConfiguration(config_name)

   210

        if configuration:

   211

            for resource in configuration.getResource():

   212

                if resource.getName() == name:

   213

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

   214

            new_resource = PLCOpenClasses["configuration_resource"]()

   215

            new_resource.setName(name)

   216

            configuration.appendResource(new_resource)

   217

    setattr(cls, "addConfigurationResource", addConfigurationResource)    

   218

   219

    def removeConfigurationResource(self, config_name, name):

   220

        configuration = self.getConfiguration(config_name)

   221

        if configuration:

   222

            found = False

   223

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

   224

                if resource.getName() == name:

   225

                    configuration.removeResource(idx)

   226

                    found = True

   227

                    break

   228

            if not found:

   229

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

   230

    setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   231

   232

PLCOpenClasses["project_fileHeader"].singleLineAttributes = False

   233

   234

if "project_types" in PLCOpenClasses:

   235

    cls = PLCOpenClasses["project_types"]

   236

   237

    def getPouElements(self):

   238

        return self.pous.getPou()

   239

    setattr(cls, "getPouElements", getPouElements)

   240

   241

    def getPouElement(self, name):

   242

        elements = self.pous.getPou()

   243

        for element in elements:

   244

            if element.getName() == name:

   245

                return element

   246

        return None

   247

    setattr(cls, "getPouElement", getPouElement)

   248

   249

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

   250

        for element in self.pous.getPou():

   251

            if element.getName() == name:

   252

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

   253

        new_pou = PLCOpenClasses["pous_pou"]()

   254

        new_pou.setName(name)

   255

        new_pou.pouType.setValue(pou_type)

   256

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

   257

        new_pou.setBodyType(body_type)

   258

        self.pous.appendPou(new_pou)

   259

    setattr(cls, "appendPouElement", appendPouElement)

   260

   261

    def insertPouElement(self, index, pou):

   262

        self.pous.insertPou(index, pou)

   263

    setattr(cls, "insertPouElement", insertPouElement)

   264

   265

    def removePouElement(self, name):

   266

        found = False

   267

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

   268

            if element.getName() == name:

   269

                self.pous.removePou(idx)

   270

                found = True

   271

                break

   272

        if not found:

   273

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

   274

    setattr(cls, "removePouElement", removePouElement)

   275

   276

def setBodyType(self, type):

   277

    if type == "IL":

   278

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

   279

    elif type == "ST":

   280

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

   281

    elif type == "LD":

   282

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

   283

    elif type == "FBD":

   284

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

   285

    elif type == "SFC":

   286

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

   287

    else:

   288

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

   289

   290

def getBodyType(self):

   291

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

   292

   293

def addInstance(self, name, instance):

   294

    self.body.appendContentInstance(name, instance)

   295

   296

def getInstances(self):

   297

    return self.body.getContentInstances()

   298

   299

def getInstance(self, id):

   300

    return self.body.getContentInstance(id)

   301

   302

def getRandomInstance(self, exclude):

   303

    return self.body.getContentRandomInstance(exclude)

   304

   305

def getInstanceByName(self, name):

   306

    return self.body.getContentInstanceByName(name)

   307

   308

def removeInstance(self, id):

   309

    self.body.removeContentInstance(id)

   310

   311

def setText(self, text):

   312

    self.body.setText(text)

   313

   314

def getText(self):

   315

    return self.body.getText()

   316

setattr(cls, "getText", getText)

   317

   318

if "pous_pou" in PLCOpenClasses:

   319

    cls = PLCOpenClasses["pous_pou"]

   320

   321

    setattr(cls, "setBodyType", setBodyType)

   322

    setattr(cls, "getBodyType", getBodyType)

   323

    setattr(cls, "addInstance", addInstance)

   324

    setattr(cls, "getInstances", getInstances)

   325

    setattr(cls, "getInstance", getInstance)

   326

    setattr(cls, "getRandomInstance", getRandomInstance)

   327

    setattr(cls, "getInstanceByName", getInstanceByName)

   328

    setattr(cls, "removeInstance", removeInstance)

   329

    setattr(cls, "setText", setText)

   330

    setattr(cls, "getText", getText)

   331

   332

    def getVars(self):

   333

        vars = []

   334

        reverse_types = {}

   335

        for name, value in VarTypes.items():

   336

            reverse_types[value] = name

   337

        for varlist in self.interface.getContent():

   338

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

   339

        return vars

   340

    setattr(cls, "getVars", getVars)

   341

   342

    def setVars(self, vars):

   343

        self.interface.setContent([])

   344

        for vartype, varlist in vars:

   345

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

   346

    setattr(cls, "setVars", setVars)

   347

   348

    def addTransition(self, name, type):

   349

        if not self.transitions:

   350

            self.addTransitions()

   351

            self.transitions.setTransition([])

   352

        transition = PLCOpenClasses["transitions_transition"]()

   353

        transition.setName(name)

   354

        transition.setBodyType(type)

   355

        self.transitions.appendTransition(transition)

   356

    setattr(cls, "addTransition", addTransition)

   357

   358

    def getTransition(self, name):

   359

        if self.transitions:

   360

            for transition in self.transitions.getTransition():

   361

                if transition.getName() == name:

   362

                    return transition

   363

        return None

   364

    setattr(cls, "getTransition", getTransition)

   365

   366

    def getTransitionList(self):

   367

        if self.transitions:

   368

            return self.transitions.getTransition()

   369

        return []

   370

    setattr(cls, "getTransitionList", getTransitionList)

   371

   372

    def removeTransition(self, name):

   373

        if self.transitions:

   374

            transitions = self.transitions.getTransition()

   375

            i = 0

   376

            removed = False

   377

            while i < len(transitions) and not removed:

   378

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

   379

                    transitions.removeTransition(i)

   380

                    removed = True

   381

                i += 1

   382

            if not removed:

   383

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

   384

    setattr(cls, "removeTransition", removeTransition)

   385

   386

    def addAction(self, name, type):

   387

        if not self.actions:

   388

            self.addActions()

   389

            self.actions.setAction([])

   390

        action = PLCOpenClasses["actions_action"]()

   391

        action.setName(name)

   392

        action.setBodyType(type)

   393

        self.actions.appendAction(action)

   394

    setattr(cls, "addAction", addAction)

   395

   396

    def getAction(self, name):

   397

        if self.actions:

   398

            for action in self.actions.getAction():

   399

                if action.getName() == name:

   400

                    return action

   401

        return None

   402

    setattr(cls, "getAction", getAction)

   403

   404

    def getActionList(self):

   405

        if self.actions:

   406

            return self.actions.getAction()

   407

        return []

   408

    setattr(cls, "getActionList", getActionList)

   409

   410

    def removeAction(self, name):

   411

        if self.actions:

   412

            actions = self.actions.getAction()

   413

            i = 0

   414

            removed = False

   415

            while i < len(actions) and not removed:

   416

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

   417

                    actions.removeAction(i)

   418

                    removed = True

   419

                i += 1

   420

            if not removed:

   421

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

   422

    setattr(cls, "removeAction", removeAction)

   423

   424

if "transitions_transition" in PLCOpenClasses:

   425

    cls = PLCOpenClasses["transitions_transition"]

   426

   427

    setattr(cls, "setBodyType", setBodyType)

   428

    setattr(cls, "getBodyType", getBodyType)

   429

    setattr(cls, "addInstance", addInstance)

   430

    setattr(cls, "getInstances", getInstances)

   431

    setattr(cls, "getInstance", getInstance)

   432

    setattr(cls, "getRandomInstance", getRandomInstance)

   433

    setattr(cls, "getInstanceByName", getInstanceByName)

   434

    setattr(cls, "removeInstance", removeInstance)

   435

    setattr(cls, "setText", setText)

   436

    setattr(cls, "getText", getText)

   437

   438

if "actions_action" in PLCOpenClasses:

   439

    cls = PLCOpenClasses["actions_action"]

   440

   441

    setattr(cls, "setBodyType", setBodyType)

   442

    setattr(cls, "getBodyType", getBodyType)

   443

    setattr(cls, "addInstance", addInstance)

   444

    setattr(cls, "getInstances", getInstances)

   445

    setattr(cls, "getInstance", getInstance)

   446

    setattr(cls, "getRandomInstance", getRandomInstance)

   447

    setattr(cls, "getInstanceByName", getInstanceByName)

   448

    setattr(cls, "removeInstance", removeInstance)

   449

    setattr(cls, "setText", setText)

   450

    setattr(cls, "getText", getText)

   451

   452

if "body" in PLCOpenClasses:

   453

    cls = PLCOpenClasses["body"]

   454

   455

    def appendContentInstance(self, name, instance):

   456

        if self.content["name"] in ["LD","FBD","SFC"]:

   457

            self.content["value"].appendContent(name, instance)

   458

        else:

   459

            raise TypeError, "%s body don't have instances!"%self.content["name"]

   460

    setattr(cls, "appendContentInstance", appendContentInstance)

   461

   462

    def getContentInstances(self):

   463

        if self.content["name"] in ["LD","FBD","SFC"]:

   464

            instances = []

   465

            for element in self.content["value"].getContent():

   466

                instances.append(element["value"])

   467

            return instances

   468

        else:

   469

            raise TypeError, "%s body don't have instances!"%self.content["name"]

   470

    setattr(cls, "getContentInstances", getContentInstances)

   471

   472

    def getContentInstance(self, id):

   473

        if self.content["name"] in ["LD","FBD","SFC"]:

   474

            for element in self.content["value"].getContent():

   475

                if element["value"].getLocalId() == id:

   476

                    return element["value"]

   477

            return None

   478

        else:

   479

            raise TypeError, "%s body don't have instances!"%self.content["name"]

   480

    setattr(cls, "getContentInstance", getContentInstance)

   481

   482

    def getContentRandomInstance(self, exclude):

   483

        if self.content["name"] in ["LD","FBD","SFC"]:

   484

            for element in self.content["value"].getContent():

   485

                if element["value"].getLocalId() not in exclude:

   486

                    return element["value"]

   487

            return None

   488

        else:

   489

            raise TypeError, "%s body don't have instances!"%self.content["name"]

   490

    setattr(cls, "getContentRandomInstance", getContentRandomInstance)

   491

   492

    def getContentInstanceByName(self, name):

   493

        if self.content["name"] in ["LD","FBD","SFC"]:

   494

            for element in self.content["value"].getContent():

   495

                if element["value"].getLocalId() == name:

   496

                    return element["value"]

   497

        else:

   498

            raise TypeError, "%s body don't have instances!"%self.content["name"]