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, PLCOpenTypes = 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

    cls.text = ""

    52

    53

    def getText(self):

    54

        return self.text

    55

    setattr(cls, "getText", getText)

    56

    57

    def setText(self, text):

    58

        self.text = text

    59

    setattr(cls, "setText", setText)

    60

    61

    def loadXMLTree(self, tree):

    62

        self.text = GetAttributeValue(tree)

    63

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

    64

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

    65

    setattr(cls, "loadXMLTree", loadXMLTree)

    66

    67

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

    68

        ind1, ind2 = getIndent(indent, name)

    69

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

    70

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

    71

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

    72

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

    73

            return text

    74

        else:

    75

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

    76

    setattr(cls, "generateXMLText", generateXMLText)

    77

    78

    def updateElementName(self, old_name, new_name):

    79

        index = self.text.find(old_name)

    80

        while index != -1:

    81

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

    82

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

    83

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

    84

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

    85

            else:

    86

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

    87

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

    88

    setattr(cls, "updateElementName", updateElementName)

    89

    90

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

    91

if cls:

    92

    cls.singleLineAttributes = False

    93

    94

    def setName(self, name):

    95

        self.contentHeader.setName(name)

    96

    setattr(cls, "setName", setName)

    97

    98

    def getName(self):

    99

        return self.contentHeader.getName()

   100

    setattr(cls, "getName", getName)

   101

   102

    def getFileHeader(self):

   103

        fileheader = {}

   104

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

   105

        if self.fileHeader.getCompanyURL():

   106

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

   107

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

   108

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

   109

        if self.fileHeader.getProductRelease():

   110

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

   111

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

   112

        if self.fileHeader.getContentDescription():

   113

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

   114

        return fileheader

   115

    setattr(cls, "getFileHeader", getFileHeader)

   116

   117

    def setFileHeader(self, fileheader):

   118

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

   119

        if "companyURL" in fileheader:

   120

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

   121

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

   122

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

   123

        if "productRelease" in fileheader:

   124

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

   125

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

   126

        if "contentDescription" in fileheader:

   127

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

   128

    setattr(cls, "setFileHeader", setFileHeader)

   129

   130

    def getContentHeader(self):

   131

        contentheader = {}

   132

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

   133

        if self.contentHeader.getVersion():

   134

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

   135

        if self.contentHeader.getModificationDateTime():

   136

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

   137

        if self.contentHeader.getOrganization():

   138

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

   139

        if self.contentHeader.getAuthor():

   140

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

   141

        if self.contentHeader.getLanguage():

   142

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

   143

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

   144

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

   145

        return contentheader

   146

    setattr(cls, "getContentHeader", getContentHeader)

   147

   148

    def setContentHeader(self, contentheader):

   149

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

   150

        if "projectVersion" in contentheader:

   151

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

   152

        if "modificationDateTime" in contentheader:

   153

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

   154

        if "organization" in contentheader:

   155

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

   156

        if "authorName" in contentheader:

   157

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

   158

        if "language" in contentheader:

   159

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

   160

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

   161

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

   162

    setattr(cls, "setContentHeader", setContentHeader)

   163

   164

    def getDataTypes(self):

   165

        return self.types.getDataTypeElements()

   166

    setattr(cls, "getDataTypes", getDataTypes)

   167

   168

    def getDataType(self, name):

   169

        return self.types.getDataTypeElement(name)

   170

    setattr(cls, "getDataType", getDataType)

   171

   172

    def appendDataType(self, name):

   173

        self.types.appendDataTypeElement(name)

   174

    setattr(cls, "appendDataType", appendDataType)

   175

   176

    def insertDataType(self, index, datatype):

   177

        self.types.insertDataTypeElement(index, datatype)

   178

    setattr(cls, "insertDataType", insertDataType)

   179

   180

    def removeDataType(self, name):

   181

        self.types.removeDataTypeElement(name)

   182

    setattr(cls, "removeDataType", removeDataType)

   183

   184

    def getPous(self):

   185

        return self.types.getPouElements()

   186

    setattr(cls, "getPous", getPous)

   187

   188

    def getPou(self, name):

   189

        return self.types.getPouElement(name)

   190

    setattr(cls, "getPou", getPou)

   191

   192

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

   193

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

   194

    setattr(cls, "appendPou", appendPou)

   195

   196

    def insertPou(self, index, pou):

   197

        self.types.insertPouElement(index, pou)

   198

    setattr(cls, "insertPou", insertPou)

   199

   200

    def removePou(self, name):

   201

        self.types.removePouElement(name)

   202

    setattr(cls, "removePou", removePou)

   203

   204

    def getConfigurations(self):

   205

        configurations = self.instances.configurations.getConfiguration()

   206

        if configurations:

   207

            return configurations

   208

        return []

   209

    setattr(cls, "getConfigurations", getConfigurations)

   210

   211

    def getConfiguration(self, name):

   212

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

   213

            if configuration.getName() == name:

   214

                return configuration

   215

        return None

   216

    setattr(cls, "getConfiguration", getConfiguration)

   217

   218

    def addConfiguration(self, name):

   219

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

   220

            if configuration.getName() == name:

   221

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

   222

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   223

        new_configuration.setName(name)

   224

        self.instances.configurations.appendConfiguration(new_configuration)

   225

    setattr(cls, "addConfiguration", addConfiguration)    

   226

   227

    def removeConfiguration(self, name):

   228

        found = False

   229

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

   230

            if configuration.getName() == name:

   231

                self.instances.configurations.removeConfiguration(idx)

   232

                found = True

   233

                break

   234

        if not found:

   235

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

   236

    setattr(cls, "removeConfiguration", removeConfiguration)

   237

   238

    def getConfigurationResource(self, config_name, name):

   239

        configuration = self.getConfiguration(config_name)

   240

        if configuration:

   241

            for resource in configuration.getResource():

   242

                if resource.getName() == name:

   243

                    return resource

   244

        return None

   245

    setattr(cls, "getConfigurationResource", getConfigurationResource)

   246

   247

    def addConfigurationResource(self, config_name, name):

   248

        configuration = self.getConfiguration(config_name)

   249

        if configuration:

   250

            for resource in configuration.getResource():

   251

                if resource.getName() == name:

   252

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

   253

            new_resource = PLCOpenClasses["configuration_resource"]()

   254

            new_resource.setName(name)

   255

            configuration.appendResource(new_resource)

   256

    setattr(cls, "addConfigurationResource", addConfigurationResource)

   257

   258

    def removeConfigurationResource(self, config_name, name):

   259

        configuration = self.getConfiguration(config_name)

   260

        if configuration:

   261

            found = False

   262

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

   263

                if resource.getName() == name:

   264

                    configuration.removeResource(idx)

   265

                    found = True

   266

                    break

   267

            if not found:

   268

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

   269

    setattr(cls, "removeConfigurationResource", removeConfigurationResource)

   270

   271

    def updateElementName(self, old_name, new_name):

   272

        for pou in self.types.getPouElements():

   273

            pou.updateElementName(old_name, new_name)

   274

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

   275

            configuration.updateElementName(old_name, new_name)

   276

    setattr(cls, "updateElementName", updateElementName)

   277

   278

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

   279

if cls:

   280

    cls.singleLineAttributes = False

   281

   282

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

   283

if cls:

   284

    cls.singleLineAttributes = False

   285

   286

    def setPageSize(self, width, height):

   287

        self.coordinateInfo.setPageSize(width, height)

   288

    setattr(cls, "setPageSize", setPageSize)

   289

   290

    def getPageSize(self):

   291

        return self.coordinateInfo.getPageSize()

   292

    setattr(cls, "getPageSize", getPageSize)

   293

   294

    def setScaling(self, scaling):

   295

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

   296

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

   297

    setattr(cls, "setScaling", setScaling)

   298

   299

    def getScaling(self):

   300

        scaling = {}

   301

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

   302

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

   303

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

   304

        return scaling

   305

    setattr(cls, "getScaling", getScaling)

   306

   307

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

   308

if cls:

   309

    def setPageSize(self, width, height):

   310

        if width == 0 and height == 0:

   311

            self.deletePageSize()

   312

        else:

   313

            if self.pageSize is None:

   314

                self.addPageSize()

   315

            self.pageSize.setX(width)

   316

            self.pageSize.setY(height)

   317

    setattr(cls, "setPageSize", setPageSize)

   318

   319

    def getPageSize(self):

   320

        if self.pageSize is not None:

   321

            return self.pageSize.getX(), self.pageSize.getY()

   322

        return 0, 0

   323

    setattr(cls, "getPageSize", getPageSize)

   324

   325

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

   326

        if language == "FBD":

   327

            self.fbd.scaling.setX(x)

   328

            self.fbd.scaling.setY(y)

   329

        elif language == "LD":

   330

            self.ld.scaling.setX(x)

   331

            self.ld.scaling.setY(y)

   332

        elif language == "SFC":

   333

            self.sfc.scaling.setX(x)

   334

            self.sfc.scaling.setY(y)

   335

    setattr(cls, "setScaling", setScaling)

   336

   337

    def getScaling(self, language):

   338

        if language == "FBD":

   339

            return self.fbd.scaling.getX(), self.fbd.scaling.getY()

   340

        elif language == "LD":

   341

            return self.ld.scaling.getX(), self.ld.scaling.getY()

   342

        elif language == "SFC":

   343

            return self.sfc.scaling.getX(), self.sfc.scaling.getY()

   344

        return 0, 0

   345

    setattr(cls, "getScaling", getScaling)

   346

   347

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

   348

if cls:

   349

    def updateElementName(self, old_name, new_name):

   350

        for resource in self.getResource():

   351

            resource.updateElementName(old_name, new_name)

   352

    setattr(cls, "updateElementName", updateElementName)

   353

   354

   355

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

   356

if cls:

   357

    def updateElementName(self, old_name, new_name):

   358

        for instance in self.getPouInstance():

   359

            instance.updateElementName(old_name, new_name)

   360

        for task in self.getTask():

   361

            task.updateElementName(old_name, new_name)

   362

    setattr(cls, "updateElementName", updateElementName)

   363

   364

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

   365

if cls:

   366

    def updateElementName(self, old_name, new_name):

   367

        if self.single == old_name:

   368

            self.single = new_name

   369

        for instance in self.getPouInstance():

   370

            instance.updateElementName(old_name, new_name)

   371

    setattr(cls, "updateElementName", updateElementName)

   372

   373

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

   374

if cls:

   375

    def updateElementName(self, old_name, new_name):

   376

        if self.type == old_name:

   377

            self.type = new_name

   378

    setattr(cls, "updateElementName", updateElementName)

   379

   380

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

   381

if cls:

   382

    def getDataTypeElements(self):

   383

        return self.dataTypes.getDataType()

   384

    setattr(cls, "getDataTypeElements", getDataTypeElements)

   385

   386

    def getDataTypeElement(self, name):

   387

        elements = self.dataTypes.getDataType()

   388

        for element in elements:

   389

            if element.getName() == name:

   390

                return element

   391

        return None

   392

    setattr(cls, "getDataTypeElement", getDataTypeElement)

   393

   394

    def appendDataTypeElement(self, name):

   395

        for element in self.dataTypes.getDataType():

   396

            if element.getName() == name:

   397

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

   398

        new_datatype = PLCOpenClasses["dataTypes_dataType"]()

   399

        new_datatype.setName(name)

   400

        new_datatype.baseType.setContent("BOOL", None)

   401

        self.dataTypes.appendDataType(new_datatype)

   402

    setattr(cls, "appendDataTypeElement", appendDataTypeElement)

   403

   404

    def insertDataTypeElement(self, index, datatype):

   405

        self.dataTypes.insertDataType(index, datatype)

   406

    setattr(cls, "insertDataTypeElement", insertDataTypeElement)

   407

   408

    def removeDataTypeElement(self, name):

   409

        found = False

   410

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

   411

            if element.getName() == name:

   412

                self.dataTypes.removeDataType(idx)

   413

                found = True

   414

                break

   415

        if not found:

   416

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

   417

    setattr(cls, "removeDataTypeElement", removeDataTypeElement)

   418

   419

    def getPouElements(self):

   420

        return self.pous.getPou()

   421

    setattr(cls, "getPouElements", getPouElements)

   422

   423

    def getPouElement(self, name):

   424

        elements = self.pous.getPou()

   425

        for element in elements:

   426

            if element.getName() == name:

   427

                return element

   428

        return None

   429

    setattr(cls, "getPouElement", getPouElement)

   430

   431

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

   432

        for element in self.pous.getPou():

   433

            if element.getName() == name:

   434

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

   435

        new_pou = PLCOpenClasses["pous_pou"]()

   436

        new_pou.setName(name)

   437

        new_pou.pouType.setValue(pou_type)

   438

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

   439

        new_pou.setBodyType(body_type)

   440

        self.pous.appendPou(new_pou)

   441

    setattr(cls, "appendPouElement", appendPouElement)

   442

   443

    def insertPouElement(self, index, pou):

   444

        self.pous.insertPou(index, pou)

   445

    setattr(cls, "insertPouElement", insertPouElement)

   446

   447

    def removePouElement(self, name):

   448

        found = False

   449

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

   450

            if element.getName() == name:

   451

                self.pous.removePou(idx)

   452

                found = True

   453

                break

   454

        if not found:

   455

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

   456

    setattr(cls, "removePouElement", removePouElement)

   457

   458

def setBodyType(self, type):

   459

    if type == "IL":

   460

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

   461

    elif type == "ST":

   462

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

   463

    elif type == "LD":

   464

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

   465

    elif type == "FBD":

   466

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

   467

    elif type == "SFC":

   468

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

   469

    else:

   470

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

   471

   472

def getBodyType(self):

   473

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

   474

   475

def resetExecutionOrder(self):

   476

    self.body.resetExecutionOrder()

   477

   478

def compileExecutionOrder(self):

   479

    self.body.compileExecutionOrder()

   480

   481

def setElementExecutionOrder(self, instance, new_executionOrder):

   482

    self.body.setElementExecutionOrder(instance, new_executionOrder)

   483

   484

def addInstance(self, name, instance):

   485

    self.body.appendContentInstance(name, instance)

   486

   487

def getInstances(self):

   488

    return self.body.getContentInstances()

   489

   490

def getInstance(self, id):

   491

    return self.body.getContentInstance(id)

   492

   493

def getRandomInstance(self, exclude):

   494

    return self.body.getContentRandomInstance(exclude)

   495

   496

def getInstanceByName(self, name):