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 *

    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

if "project" in PLCOpenClasses:

   110

    cls = PLCOpenClasses["project"]

   111

    cls.singleLineAttributes = False

   112

   113

    def getFileHeader(self):

   114

        fileheader = {}

   115

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

   116

        if self.fileHeader.getCompanyURL():

   117

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

   118

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

   119

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

   120

        if self.fileHeader.getProductRelease():

   121

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

   122

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

   123

        if self.fileHeader.getContentDescription():

   124

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

   125

        return fileheader

   126

    setattr(cls, "getFileHeader", getFileHeader)

   127

   128

    def setFileHeader(self, fileheader):

   129

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

   130

        if "companyURL" in fileheader:

   131

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

   132

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

   133

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

   134

        if "productRelease" in fileheader:

   135

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

   136

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

   137

        if "contentDescription" in fileheader:

   138

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

   139

    setattr(cls, "setFileHeader", setFileHeader)

   140

   141

    def setName(self, name):

   142

        self.contentHeader.setName(name)

   143

    setattr(cls, "setName", setName)

   144

   145

    def getName(self):

   146

        return self.contentHeader.getName()

   147

    setattr(cls, "getName", getName)

   148

   149

    def getPous(self):

   150

        return self.types.getPouElements()

   151

    setattr(cls, "getPous", getPous)

   152

   153

    def getPou(self, name):

   154

        return self.types.getPouElement(name)

   155

    setattr(cls, "getPou", getPou)

   156

   157

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

   158

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

   159

    setattr(cls, "appendPou", appendPou)

   160

   161

    def insertPou(self, index, pou):

   162

        self.types.insertPouElement(index, pou)

   163

    setattr(cls, "insertPou", insertPou)

   164

   165

    def removePou(self, name):

   166

        self.types.removePouElement(name)

   167

    setattr(cls, "removePou", removePou)

   168

   169

    def getConfigurations(self):

   170

        configurations = self.instances.configurations.getConfiguration()

   171

        if configurations:

   172

            return configurations

   173

        return []

   174

    setattr(cls, "getConfigurations", getConfigurations)

   175

   176

    def getConfiguration(self, name):

   177

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

   178

            if configuration.getName() == name:

   179

                return configuration

   180

        return None

   181

    setattr(cls, "getConfiguration", getConfiguration)

   182

   183

    def addConfiguration(self, name):

   184

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

   185

            if configuration.getName() == name:

   186

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

   187

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   188

        new_configuration.setName(name)

   189

        self.instances.configurations.appendConfiguration(new_configuration)

   190

    setattr(cls, "addConfiguration", addConfiguration)    

   191

   192

    def removeConfiguration(self, name):

   193

        found = False

   194

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

   195

            if configuration.getName() == name:

   196

                self.instances.configurations.removeConfiguration(idx)

   197

                found = True

   198

                break

   199

        if not found:

   200

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

   201

    setattr(cls, "removeConfiguration", removeConfiguration)

   202

   203

    def getConfigurationResource(self, config_name, name):

   204

        configuration = self.getConfiguration(config_name)

   205

        if configuration:

   206

            for resource in configuration.getResource():

   207

                if resource.getName() == name:

   208

                    return resource

   209

        return None

   210

    setattr(cls, "getConfigurationResource", getConfigurationResource)

   211

   212

    def addConfigurationResource(self, config_name, name):

   213

        configuration = self.getConfiguration(config_name)

   214

        if configuration:

   215

            for resource in configuration.getResource():

   216

                if resource.getName() == name:

   217

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

   218

            new_resource = PLCOpenClasses["configuration_resource"]()

   219

            new_resource.setName(name)

   220

            configuration.appendResource(new_resource)

   221

    setattr(cls, "addConfigurationResource", addConfigurationResource)    

   222

   223

    def removeConfigurationResource(self, config_name, name):

   224

        configuration = self.getConfiguration(config_name)

   225

        if configuration:

   226

            found = False

   227

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

   228

                if resource.getName() == name:

   229

                    configuration.removeResource(idx)

   230

                    found = True

   231

                    break

   232

            if not found:

   233

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

   234

    setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   235

   236

PLCOpenClasses["project_fileHeader"].singleLineAttributes = False

   237

   238

if "project_types" in PLCOpenClasses:

   239

    cls = PLCOpenClasses["project_types"]

   240

   241

    def getPouElements(self):

   242

        return self.pous.getPou()

   243

    setattr(cls, "getPouElements", getPouElements)

   244

   245

    def getPouElement(self, name):

   246

        elements = self.pous.getPou()

   247

        for element in elements:

   248

            if element.getName() == name:

   249

                return element

   250

        return None

   251

    setattr(cls, "getPouElement", getPouElement)

   252

   253

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

   254

        for element in self.pous.getPou():

   255

            if element.getName() == name:

   256

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

   257

        new_pou = PLCOpenClasses["pous_pou"]()

   258

        new_pou.setName(name)

   259

        new_pou.pouType.setValue(pou_type)

   260

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

   261

        new_pou.setBodyType(body_type)

   262

        self.pous.appendPou(new_pou)

   263

    setattr(cls, "appendPouElement", appendPouElement)

   264

   265

    def insertPouElement(self, index, pou):

   266

        self.pous.insertPou(index, pou)

   267

    setattr(cls, "insertPouElement", insertPouElement)

   268

   269

    def removePouElement(self, name):

   270

        found = False

   271

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

   272

            if element.getName() == name:

   273

                self.pous.removePou(idx)

   274

                found = True

   275

                break

   276

        if not found:

   277

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

   278

    setattr(cls, "removePouElement", removePouElement)

   279

   280

def setBodyType(self, type):

   281

    if type == "IL":

   282

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

   283

    elif type == "ST":

   284

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

   285

    elif type == "LD":

   286

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

   287

    elif type == "FBD":

   288

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

   289

    elif type == "SFC":

   290

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

   291

    else:

   292

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

   293

   294

def getBodyType(self):

   295

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

   296

   297

def addInstance(self, name, instance):

   298

    self.body.appendContentInstance(name, instance)

   299

   300

def getInstances(self):

   301

    return self.body.getContentInstances()

   302

   303

def getInstance(self, id):

   304

    return self.body.getContentInstance(id)

   305

   306

def getRandomInstance(self, exclude):

   307

    return self.body.getContentRandomInstance(exclude)

   308

   309

def getInstanceByName(self, name):

   310

    return self.body.getContentInstanceByName(name)

   311

   312

def removeInstance(self, id):

   313

    self.body.removeContentInstance(id)

   314

   315

def setText(self, text):

   316

    self.body.setText(text)

   317

   318

def getText(self):

   319

    return self.body.getText()

   320

setattr(cls, "getText", getText)

   321

   322

if "pous_pou" in PLCOpenClasses:

   323

    cls = PLCOpenClasses["pous_pou"]

   324

   325

    setattr(cls, "setBodyType", setBodyType)

   326

    setattr(cls, "getBodyType", getBodyType)

   327

    setattr(cls, "addInstance", addInstance)

   328

    setattr(cls, "getInstances", getInstances)

   329

    setattr(cls, "getInstance", getInstance)

   330

    setattr(cls, "getRandomInstance", getRandomInstance)

   331

    setattr(cls, "getInstanceByName", getInstanceByName)

   332

    setattr(cls, "removeInstance", removeInstance)

   333

    setattr(cls, "setText", setText)

   334

    setattr(cls, "getText", getText)

   335

   336

    def getVars(self):

   337

        vars = []

   338

        reverse_types = {}

   339

        for name, value in VarTypes.items():

   340

            reverse_types[value] = name

   341

        for varlist in self.interface.getContent():

   342

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

   343

        return vars

   344

    setattr(cls, "getVars", getVars)

   345

   346

    def setVars(self, vars):

   347

        self.interface.setContent([])

   348

        for vartype, varlist in vars:

   349

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

   350

    setattr(cls, "setVars", setVars)

   351

   352

    def addTransition(self, name, type):

   353

        if not self.transitions:

   354

            self.addTransitions()

   355

            self.transitions.setTransition([])

   356

        transition = PLCOpenClasses["transitions_transition"]()

   357

        transition.setName(name)

   358

        transition.setBodyType(type)

   359

        self.transitions.appendTransition(transition)

   360

    setattr(cls, "addTransition", addTransition)

   361

   362

    def getTransition(self, name):

   363

        if self.transitions:

   364

            for transition in self.transitions.getTransition():

   365

                if transition.getName() == name:

   366

                    return transition

   367

        return None

   368

    setattr(cls, "getTransition", getTransition)

   369

   370

    def getTransitionList(self):

   371

        if self.transitions:

   372

            return self.transitions.getTransition()

   373

        return []

   374

    setattr(cls, "getTransitionList", getTransitionList)

   375

   376

    def removeTransition(self, name):

   377

        if self.transitions:

   378

            transitions = self.transitions.getTransition()

   379

            i = 0

   380

            removed = False

   381

            while i < len(transitions) and not removed:

   382

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

   383

                    transitions.pop(i)

   384

                    removed = True

   385

                i += 1

   386

            if not removed:

   387

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

   388

    setattr(cls, "removeTransition", removeTransition)

   389

   390

    def addAction(self, name, type):

   391

        if not self.actions:

   392

            self.addActions()

   393

            self.actions.setAction([])

   394

        action = PLCOpenClasses["actions_action"]()

   395

        action.setName(name)

   396

        action.setBodyType(type)

   397

        self.actions.appendAction(action)

   398

    setattr(cls, "addAction", addAction)

   399

   400

    def getAction(self, name):

   401

        if self.actions:

   402

            for action in self.actions.getAction():

   403

                if action.getName() == name:

   404

                    return action

   405

        return None

   406

    setattr(cls, "getAction", getAction)

   407

   408

    def getActionList(self):

   409

        if self.actions:

   410

            return self.actions.getAction()

   411

        return []

   412

    setattr(cls, "getActionList", getActionList)

   413

   414

    def removeAction(self, name):

   415

        if self.actions:

   416

            actions = self.actions.getAction()

   417

            i = 0

   418

            removed = False

   419

            while i < len(actions) and not removed:

   420

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

   421

                    actions.pop(i)

   422

                    removed = True

   423

                i += 1

   424

            if not removed:

   425

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

   426

    setattr(cls, "removeAction", removeAction)

   427

   428

if "transitions_transition" in PLCOpenClasses:

   429

    cls = PLCOpenClasses["transitions_transition"]

   430

   431

    setattr(cls, "setBodyType", setBodyType)

   432

    setattr(cls, "getBodyType", getBodyType)

   433

    setattr(cls, "addInstance", addInstance)

   434

    setattr(cls, "getInstances", getInstances)

   435

    setattr(cls, "getInstance", getInstance)

   436

    setattr(cls, "getRandomInstance", getRandomInstance)

   437

    setattr(cls, "getInstanceByName", getInstanceByName)

   438

    setattr(cls, "removeInstance", removeInstance)

   439

    setattr(cls, "setText", setText)

   440

    setattr(cls, "getText", getText)

   441

   442

if "actions_action" in PLCOpenClasses:

   443

    cls = PLCOpenClasses["actions_action"]

   444

   445

    setattr(cls, "setBodyType", setBodyType)

   446

    setattr(cls, "getBodyType", getBodyType)

   447

    setattr(cls, "addInstance", addInstance)

   448

    setattr(cls, "getInstances", getInstances)

   449

    setattr(cls, "getInstance", getInstance)

   450

    setattr(cls, "getRandomInstance", getRandomInstance)

   451

    setattr(cls, "getInstanceByName", getInstanceByName)

   452

    setattr(cls, "removeInstance", removeInstance)

   453

    setattr(cls, "setText", setText)

   454

    setattr(cls, "getText", getText)

   455

   456

if "body" in PLCOpenClasses:

   457

    cls = PLCOpenClasses["body"]

   458

   459

    def appendContentInstance(self, name, instance):

   460

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

   461

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

   462

        else:

   463

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

   464

    setattr(cls, "appendContentInstance", appendContentInstance)

   465

   466

    def getContentInstances(self):

   467

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

   468

            instances = []

   469

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

   470

                instances.append(element["value"])

   471

            return instances

   472

        else:

   473

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

   474

    setattr(cls, "getContentInstances", getContentInstances)

   475

   476

    def getContentInstance(self, id):

   477

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

   478

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

   479

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

   480

                    return element["value"]

   481

            return None

   482

        else:

   483

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

   484

    setattr(cls, "getContentInstance", getContentInstance)

   485

   486

    def getContentRandomInstance(self, exclude):

   487

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

   488

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

   489

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

   490

                    return element["value"]

   491

            return None

   492

        else:

   493

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

   494

    setattr(cls, "getContentRandomInstance", getContentRandomInstance)

   495

   496

    def getContentInstanceByName(self, name):

   497

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

   498

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