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 = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "TC6_XML_V10_B.xsd"))

    48

    49

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

    50

if cls:

    51

    def updateElementName(self, old_name, new_name):

    52

        index = self.text.find(old_name)

    53

        while index != -1:

    54

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

    55

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

    56

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

    57

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

    58

            else:

    59

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

    60

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

    61

    setattr(cls, "updateElementName", updateElementName)

    62

    63

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

    64

if cls:

    65

    cls.singleLineAttributes = False

    66

    67

    def setname(self, name):

    68

        self.contentHeader.setname(name)

    69

    setattr(cls, "setname", setname)

    70

    71

    def getname(self):

    72

        return self.contentHeader.getname()

    73

    setattr(cls, "getname", getname)

    74

    75

    def getfileHeader(self):

    76

        fileheader = {}

    77

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

    78

        if self.fileHeader.getcompanyURL():

    79

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

    80

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

    81

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

    82

        if self.fileHeader.getproductRelease():

    83

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

    84

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

    85

        if self.fileHeader.getcontentDescription():

    86

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

    87

        return fileheader

    88

    setattr(cls, "getfileHeader", getfileHeader)

    89

    90

    def setfileHeader(self, fileheader):

    91

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

    92

        if "companyURL" in fileheader:

    93

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

    94

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

    95

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

    96

        if "productRelease" in fileheader:

    97

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

    98

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

    99

        if "contentDescription" in fileheader:

   100

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

   101

    setattr(cls, "setfileHeader", setfileHeader)

   102

   103

    def getcontentHeader(self):

   104

        contentheader = {}

   105

        contentheader["projectName"] = self.contentHeader.getname()

   106

        if self.contentHeader.getversion():

   107

            contentheader["projectVersion"] = self.contentHeader.getversion()

   108

        if self.contentHeader.getmodificationDateTime():

   109

            contentheader["modificationDateTime"] = self.contentHeader.getmodificationDateTime()

   110

        if self.contentHeader.getorganization():

   111

            contentheader["organization"] = self.contentHeader.getorganization()

   112

        if self.contentHeader.getauthor():

   113

            contentheader["authorName"] = self.contentHeader.getauthor()

   114

        if self.contentHeader.getlanguage():

   115

            contentheader["language"] = self.contentHeader.getlanguage()

   116

        contentheader["pageSize"] = self.contentHeader.getpageSize()

   117

        contentheader["scaling"] = self.contentHeader.getscaling()

   118

        return contentheader

   119

    setattr(cls, "getcontentHeader", getcontentHeader)

   120

   121

    def setcontentHeader(self, contentheader):

   122

        self.contentHeader.setname(contentheader["projectName"])

   123

        if "projectVersion" in contentheader:

   124

            self.contentHeader.setversion(contentheader["projectVersion"])

   125

        if "modificationDateTime" in contentheader:

   126

            self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])

   127

        if "organization" in contentheader:

   128

            self.contentHeader.setorganization(contentheader["organization"])

   129

        if "authorName" in contentheader:

   130

            self.contentHeader.setauthor(contentheader["authorName"])

   131

        if "language" in contentheader:

   132

            self.contentHeader.setlanguage(contentheader["language"])

   133

        self.contentHeader.setpageSize(*contentheader["pageSize"])

   134

        self.contentHeader.setscaling(contentheader["scaling"])

   135

    setattr(cls, "setcontentHeader", setcontentHeader)

   136

   137

    def getdataTypes(self):

   138

        return self.types.getdataTypeElements()

   139

    setattr(cls, "getdataTypes", getdataTypes)

   140

   141

    def getdataType(self, name):

   142

        return self.types.getdataTypeElement(name)

   143

    setattr(cls, "getdataType", getdataType)

   144

   145

    def appenddataType(self, name):

   146

        self.types.appenddataTypeElement(name)

   147

    setattr(cls, "appenddataType", appenddataType)

   148

   149

    def insertdataType(self, index, datatype):

   150

        self.types.insertdataTypeElement(index, datatype)

   151

    setattr(cls, "insertdataType", insertdataType)

   152

   153

    def removedataType(self, name):

   154

        self.types.removedataTypeElement(name)

   155

    setattr(cls, "removedataType", removedataType)

   156

   157

    def getpous(self):

   158

        return self.types.getpouElements()

   159

    setattr(cls, "getpous", getpous)

   160

   161

    def getpou(self, name):

   162

        return self.types.getpouElement(name)

   163

    setattr(cls, "getpou", getpou)

   164

   165

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

   166

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

   167

    setattr(cls, "appendpou", appendpou)

   168

   169

    def insertpou(self, index, pou):

   170

        self.types.insertpouElement(index, pou)

   171

    setattr(cls, "insertpou", insertpou)

   172

   173

    def removepou(self, name):

   174

        self.types.removepouElement(name)

   175

    setattr(cls, "removepou", removepou)

   176

   177

    def getconfigurations(self):

   178

        configurations = self.instances.configurations.getconfiguration()

   179

        if configurations:

   180

            return configurations

   181

        return []

   182

    setattr(cls, "getconfigurations", getconfigurations)

   183

   184

    def getconfiguration(self, name):

   185

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

   186

            if configuration.getname() == name:

   187

                return configuration

   188

        return None

   189

    setattr(cls, "getconfiguration", getconfiguration)

   190

   191

    def addconfiguration(self, name):

   192

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

   193

            if configuration.getname() == name:

   194

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

   195

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   196

        new_configuration.setname(name)

   197

        self.instances.configurations.appendconfiguration(new_configuration)

   198

    setattr(cls, "addconfiguration", addconfiguration)    

   199

   200

    def removeconfiguration(self, name):

   201

        found = False

   202

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

   203

            if configuration.getname() == name:

   204

                self.instances.configurations.removeconfiguration(idx)

   205

                found = True

   206

                break

   207

        if not found:

   208

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

   209

    setattr(cls, "removeconfiguration", removeconfiguration)

   210

   211

    def getconfigurationResource(self, config_name, name):

   212

        configuration = self.getconfiguration(config_name)

   213

        if configuration:

   214

            for resource in configuration.getresource():

   215

                if resource.getname() == name:

   216

                    return resource

   217

        return None

   218

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   219

   220

    def addconfigurationResource(self, config_name, name):

   221

        configuration = self.getconfiguration(config_name)

   222

        if configuration:

   223

            for resource in configuration.getresource():

   224

                if resource.getname() == name:

   225

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

   226

            new_resource = PLCOpenClasses["configuration_resource"]()

   227

            new_resource.setname(name)

   228

            configuration.appendresource(new_resource)

   229

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   230

   231

    def removeconfigurationResource(self, config_name, name):

   232

        configuration = self.getconfiguration(config_name)

   233

        if configuration:

   234

            found = False

   235

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

   236

                if resource.getname() == name:

   237

                    configuration.removeresource(idx)

   238

                    found = True

   239

                    break

   240

            if not found:

   241

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

   242

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   243

   244

    def updateElementName(self, old_name, new_name):

   245

        for pou in self.types.getpouElements():

   246

            pou.updateElementName(old_name, new_name)

   247

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

   248

            configuration.updateElementName(old_name, new_name)

   249

    setattr(cls, "updateElementName", updateElementName)

   250

   251

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

   252

if cls:

   253

    cls.singleLineAttributes = False

   254

   255

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

   256

if cls:

   257

    cls.singleLineAttributes = False

   258

   259

    def setpageSize(self, width, height):

   260

        self.coordinateInfo.setpageSize(width, height)

   261

    setattr(cls, "setpageSize", setpageSize)

   262

   263

    def getpageSize(self):

   264

        return self.coordinateInfo.getpageSize()

   265

    setattr(cls, "getpageSize", getpageSize)

   266

   267

    def setscaling(self, scaling):

   268

        for language, (x, y) in scaling.items():

   269

            self.coordinateInfo.setscaling(language, x, y)

   270

    setattr(cls, "setscaling", setscaling)

   271

   272

    def getscaling(self):

   273

        scaling = {}

   274

        scaling["FBD"] = self.coordinateInfo.getscaling("FBD")

   275

        scaling["LD"] = self.coordinateInfo.getscaling("LD")

   276

        scaling["SFC"] = self.coordinateInfo.getscaling("SFC")

   277

        return scaling

   278

    setattr(cls, "getscaling", getscaling)

   279

   280

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

   281

if cls:

   282

    def setpageSize(self, width, height):

   283

        if width == 0 and height == 0:

   284

            self.deletepageSize()

   285

        else:

   286

            if self.pageSize is None:

   287

                self.addpageSize()

   288

            self.pageSize.setx(width)

   289

            self.pageSize.sety(height)

   290

    setattr(cls, "setpageSize", setpageSize)

   291

   292

    def getpageSize(self):

   293

        if self.pageSize is not None:

   294

            return self.pageSize.getx(), self.pageSize.gety()

   295

        return 0, 0

   296

    setattr(cls, "getpageSize", getpageSize)

   297

   298

    def setscaling(self, language, x, y):

   299

        if language == "FBD":

   300

            self.fbd.scaling.setx(x)

   301

            self.fbd.scaling.sety(y)

   302

        elif language == "LD":

   303

            self.ld.scaling.setx(x)

   304

            self.ld.scaling.sety(y)

   305

        elif language == "SFC":

   306

            self.sfc.scaling.setx(x)

   307

            self.sfc.scaling.sety(y)

   308

    setattr(cls, "setscaling", setscaling)

   309

   310

    def getscaling(self, language):

   311

        if language == "FBD":

   312

            return self.fbd.scaling.getx(), self.fbd.scaling.gety()

   313

        elif language == "LD":

   314

            return self.ld.scaling.getx(), self.ld.scaling.gety()

   315

        elif language == "SFC":

   316

            return self.sfc.scaling.getx(), self.sfc.scaling.gety()

   317

        return 0, 0

   318

    setattr(cls, "getscaling", getscaling)

   319

   320

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

   321

if cls:

   322

    def updateElementName(self, old_name, new_name):

   323

        for resource in self.getresource():

   324

            resource.updateElementName(old_name, new_name)

   325

    setattr(cls, "updateElementName", updateElementName)

   326

   327

   328

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

   329

if cls:

   330

    def updateElementName(self, old_name, new_name):

   331

        for instance in self.getPouInstance():

   332

            instance.updateElementName(old_name, new_name)

   333

        for task in self.getTask():

   334

            task.updateElementName(old_name, new_name)

   335

    setattr(cls, "updateElementName", updateElementName)

   336

   337

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

   338

if cls:

   339

    def updateElementName(self, old_name, new_name):

   340

        if self.single == old_name:

   341

            self.single = new_name

   342

        for instance in self.getPouInstance():

   343

            instance.updateElementName(old_name, new_name)

   344

    setattr(cls, "updateElementName", updateElementName)

   345

   346

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

   347

if cls:

   348

    def updateElementName(self, old_name, new_name):

   349

        if self.type == old_name:

   350

            self.type = new_name

   351

    setattr(cls, "updateElementName", updateElementName)

   352

   353

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

   354

if cls:

   355

    def getdataTypeElements(self):

   356

        return self.dataTypes.getdataType()

   357

    setattr(cls, "getdataTypeElements", getdataTypeElements)

   358

   359

    def getdataTypeElement(self, name):

   360

        elements = self.dataTypes.getdataType()

   361

        for element in elements:

   362

            if element.getname() == name:

   363

                return element

   364

        return None

   365

    setattr(cls, "getdataTypeElement", getdataTypeElement)

   366

   367

    def appenddataTypeElement(self, name):

   368

        for element in self.dataTypes.getdataType():

   369

            if element.getname() == name:

   370

                raise ValueError, "\"%s\" Data Type already exists !!!"%name

   371

        new_datatype = PLCOpenClasses["dataTypes_dataType"]()

   372

        new_datatype.setname(name)

   373

        new_datatype.baseType.setcontent({"name" : "BOOL", "value" : None})

   374

        self.dataTypes.appenddataType(new_datatype)

   375

    setattr(cls, "appenddataTypeElement", appenddataTypeElement)

   376

   377

    def insertdataTypeElement(self, index, dataType):

   378

        self.dataTypes.insertdataType(index, dataType)

   379

    setattr(cls, "insertdataTypeElement", insertdataTypeElement)

   380

   381

    def removedataTypeElement(self, name):

   382

        found = False

   383

        for idx, element in enumerate(self.dataTypes.getdataType()):

   384

            if element.getname() == name:

   385

                self.dataTypes.removedataType(idx)

   386

                found = True

   387

                break

   388

        if not found:

   389

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

   390

    setattr(cls, "removedataTypeElement", removedataTypeElement)

   391

   392

    def getpouElements(self):

   393

        return self.pous.getpou()

   394

    setattr(cls, "getpouElements", getpouElements)

   395

   396

    def getpouElement(self, name):

   397

        elements = self.pous.getpou()

   398

        for element in elements:

   399

            if element.getname() == name:

   400

                return element

   401

        return None

   402

    setattr(cls, "getpouElement", getpouElement)

   403

   404

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

   405

        for element in self.pous.getpou():

   406

            if element.getname() == name:

   407

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

   408

        new_pou = PLCOpenClasses["pous_pou"]()

   409

        new_pou.setname(name)

   410

        new_pou.setpouType(pou_type)

   411

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

   412

        new_pou.setbodyType(body_type)

   413

        self.pous.appendpou(new_pou)

   414

    setattr(cls, "appendpouElement", appendpouElement)

   415

   416

    def insertpouElement(self, index, pou):

   417

        self.pous.insertpou(index, pou)

   418

    setattr(cls, "insertpouElement", insertpouElement)

   419

   420

    def removepouElement(self, name):

   421

        found = False

   422

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

   423

            if element.getname() == name:

   424

                self.pous.removepou(idx)

   425

                found = True

   426

                break

   427

        if not found:

   428

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

   429

    setattr(cls, "removepouElement", removepouElement)

   430

   431

def setbodyType(self, type):

   432

    if type == "IL":

   433

        self.body.setcontent({"name" : "IL", "value" : PLCOpenClasses["formattedText"]()})

   434

    elif type == "ST":

   435

        self.body.setcontent({"name" : "ST", "value" : PLCOpenClasses["formattedText"]()})

   436

    elif type == "LD":

   437

        self.body.setcontent({"name" : "LD", "value" : PLCOpenClasses["body_LD"]()})

   438

    elif type == "FBD":

   439

        self.body.setcontent({"name" : "FBD", "value" : PLCOpenClasses["body_FBD"]()})

   440

    elif type == "SFC":

   441

        self.body.setcontent({"name" : "SFC", "value" : PLCOpenClasses["body_SFC"]()})

   442

    else:

   443

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

   444

   445

def getbodyType(self):

   446

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

   447

   448

def resetexecutionOrder(self):

   449

    self.body.resetexecutionOrder()

   450

   451

def compileexecutionOrder(self):

   452

    self.body.compileexecutionOrder()

   453

   454

def setelementExecutionOrder(self, instance, new_executionOrder):

   455

    self.body.setelementExecutionOrder(instance, new_executionOrder)

   456

   457

def addinstance(self, name, instance):

   458

    self.body.appendcontentInstance(name, instance)

   459

   460

def getinstances(self):

   461

    return self.body.getcontentInstances()

   462

   463

def getinstance(self, id):

   464

    return self.body.getcontentInstance(id)

   465

   466

def getrandomInstance(self, exclude):

   467

    return self.body.getcontentRandomInstance(exclude)

   468

   469

def getinstanceByName(self, name):

   470

    return self.body.getcontentInstanceByName(name)

   471

   472

def removeinstance(self, id):

   473

    self.body.removecontentInstance(id)

   474

   475

def settext(self, text):

   476

    self.body.settext(text)

   477

   478

def gettext(self):

   479

    return self.body.gettext()

   480

setattr(cls, "gettext", gettext)

   481

   482

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

   483

if cls:

   484

    setattr(cls, "setbodyType", setbodyType)

   485

    setattr(cls, "getbodyType", getbodyType)

   486

    setattr(cls, "resetexecutionOrder", resetexecutionOrder)

   487

    setattr(cls, "compileexecutionOrder", compileexecutionOrder)

   488

    setattr(cls, "setelementExecutionOrder", setelementExecutionOrder)

   489

    setattr(cls, "addinstance", addinstance)