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 plcopen import plcopen

    26

from plcopen.structures import *

    27

from types import *

    28

    29

    30

# Dictionary associating PLCOpen variable categories to the corresponding 

    31

# IEC 61131-3 variable categories

    32

varTypeNames = {"localVars" : "VAR", "tempVars" : "VAR_TEMP", "inputVars" : "VAR_INPUT", 

    33

                "outputVars" : "VAR_OUTPUT", "inOutVars" : "VAR_IN_OUT", "externalVars" : "VAR_EXTERNAL",

    34

                "globalVars" : "VAR_GLOBAL", "accessVars" : "VAR_ACCESS"}

    35

    36

    37

# Dictionary associating PLCOpen POU categories to the corresponding 

    38

# IEC 61131-3 POU categories

    39

pouTypeNames = {"function" : "FUNCTION", "functionBlock" : "FUNCTION_BLOCK", "program" : "PROGRAM"}

    40

    41

    42

# Helper function for reindenting text

    43

def ReIndentText(text, nb_spaces):

    44

    compute = ""

    45

    lines = text.splitlines()

    46

    if len(lines) > 0:

    47

        line_num = 0

    48

        while line_num < len(lines) and len(lines[line_num].strip()) == 0:

    49

            line_num += 1

    50

        if line_num < len(lines):

    51

            spaces = 0

    52

            while lines[line_num][spaces] == " ":

    53

                spaces += 1

    54

            indent = ""

    55

            for i in xrange(spaces, nb_spaces):

    56

                indent += " "

    57

            for line in lines:

    58

                if line != "":

    59

                    compute += "%s%s\n"%(indent, line)

    60

                else:

    61

                    compute += "\n"

    62

    return compute

    63

    64

    65

#-------------------------------------------------------------------------------

    66

#                  Specific exception for PLC generating errors

    67

#-------------------------------------------------------------------------------

    68

    69

    70

class PLCGenException(Exception):

    71

    pass

    72

    73

    74

#-------------------------------------------------------------------------------

    75

#                           Generator of PLC program

    76

#-------------------------------------------------------------------------------

    77

    78

    79

class ProgramGenerator:

    80

    81

    # Create a new PCL program generator

    82

    def __init__(self, controler, project):

    83

        # Keep reference of the controler and project

    84

        self.Controler = controler

    85

        self.Project = project

    86

        # Reset the internal variables used to generate PLC programs

    87

        self.Program = []

    88

        self.DatatypeComputed = {}

    89

        self.PouComputed = {}

    90

    91

    # Compute value according to type given

    92

    def ComputeValue(self, value, var_type):

    93

        base_type = self.Controler.GetBaseType(var_type)

    94

        if base_type == "STRING":

    95

            return "'%s'"%value

    96

        elif base_type == "WSTRING":

    97

            return "\"%s\""%value

    98

        return value

    99

   100

    # Generate a data type from its name

   101

    def GenerateDataType(self, datatype_name):

   102

        # Verify that data type hasn't been generated yet

   103

        if not self.DatatypeComputed.get(datatype_name, True):

   104

            # If not mark data type as computed

   105

            self.DatatypeComputed[datatype_name] = True

   106

   107

            # Getting datatype model from project

   108

            datatype = self.Project.getdataType(datatype_name)

   109

            tagname = self.Controler.ComputeDataTypeName(datatype.getname())

   110

            datatype_def = [("  ", ()), 

   111

                            (datatype.getname(), (tagname, "name")),

   112

                            (" : ", ())]

   113

            basetype_content = datatype.baseType.getcontent()

   114

            # Data type derived directly from a string type 

   115

            if basetype_content["name"] in ["string", "wstring"]:

   116

                datatype_def += [(basetype_content["name"].upper(), (tagname, "base"))]

   117

            # Data type derived directly from a user defined type 

   118

            elif basetype_content["name"] == "derived":

   119

                basetype_name = basetype_content["value"].getname()

   120

                self.GenerateDataType(basetype_name)

   121

                datatype_def += [(basetype_name, (tagname, "base"))]

   122

            # Data type is a subrange

   123

            elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:

   124

                base_type = basetype_content["value"].baseType.getcontent()

   125

                # Subrange derived directly from a user defined type 

   126

                if base_type["name"] == "derived":

   127

                    basetype_name = base_type["value"].getname()

   128

                    self.GenerateDataType(basetype_name)

   129

                # Subrange derived directly from an elementary type 

   130

                else:

   131

                    basetype_name = base_type["name"]

   132

                min_value = basetype_content["value"].range.getlower()

   133

                max_value = basetype_content["value"].range.getupper()

   134

                datatype_def += [(basetype_name, (tagname, "base")),

   135

                                 (" (", ()),

   136

                                 ("%d"%min_value, (tagname, "lower")),

   137

                                 ("..", ()),

   138

                                 ("%d"%max_value, (tagname, "upper")),

   139

                                 (")",())]

   140

            # Data type is an enumerated type

   141

            elif basetype_content["name"] == "enum":

   142

                values = [[(value.getname(), (tagname, "value", i))]

   143

                          for i, value in enumerate(basetype_content["value"].values.getvalue())]

   144

                datatype_def += [("(", ())]

   145

                datatype_def += JoinList([(", ", ())], values)

   146

                datatype_def += [(")", ())]

   147

            # Data type is an array

   148

            elif basetype_content["name"] == "array":

   149

                base_type = basetype_content["value"].baseType.getcontent()

   150

                # Array derived directly from a user defined type 

   151

                if base_type["name"] == "derived":

   152

                    basetype_name = base_type["value"].getname()

   153

                    self.GenerateDataType(basetype_name)

   154

                # Array derived directly from a string type 

   155

                elif base_type["name"] in ["string", "wstring"]:

   156

                    basetype_name = base_type["name"].upper()

   157

                # Array derived directly from an elementary type 

   158

                else:

   159

                    basetype_name = base_type["name"]

   160

                dimensions = [[("%d"%dimension.getlower(), (tagname, "range", i, "lower")),

   161

                               ("..", ()),

   162

                               ("%d"%dimension.getupper(), (tagname, "range", i, "upper"))] 

   163

                              for i, dimension in enumerate(basetype_content["value"].getdimension())]

   164

                datatype_def += [("ARRAY [", ())]

   165

                datatype_def += JoinList([(",", ())], dimensions)

   166

                datatype_def += [("] OF " , ()),

   167

                                 (basetype_name, (tagname, "base"))]

   168

            # Data type derived directly from a elementary type 

   169

            else:

   170

                datatype_def += [(basetype_content["name"], (tagname, "base"))]

   171

            # Data type has an initial value

   172

            if datatype.initialValue is not None:

   173

                datatype_def += [(" := ", ()),

   174

                                 (self.ComputeValue(datatype.initialValue.getvalue(), datatype_name), (tagname, "initial"))]

   175

            datatype_def += [(";\n", ())]

   176

            return datatype_def

   177

   178

    # Generate a POU from its name

   179

    def GeneratePouProgram(self, pou_name):

   180

        # Verify that POU hasn't been generated yet

   181

        if not self.PouComputed.get(pou_name, True):

   182

            # If not mark POU as computed

   183

            self.PouComputed[pou_name] = True

   184

   185

            # Getting POU model from project

   186

            pou = self.Project.getpou(pou_name)

   187

            pou_type = pou.getpouType()

   188

            # Verify that POU type exists

   189

            if pou_type in pouTypeNames:

   190

                # Create a POU program generator

   191

                pou_program = PouProgramGenerator(self, pou.getname(), pouTypeNames[pou_type])

   192

                program = pou_program.GenerateProgram(pou)

   193

                self.Program += program

   194

            else:

   195

                raise PLCGenException, "Undefined pou type \"%s\""%pou_type

   196

   197

    # Generate a configuration from its model

   198

    def GenerateConfiguration(self, configuration):

   199

        tagname = self.Controler.ComputeConfigurationName(configuration.getname())

   200

        config = [("\nCONFIGURATION ", ()),

   201

                  (configuration.getname(), (tagname, "name")),

   202

                  ("\n", ())]

   203

        var_number = 0

   204

        # Generate any global variable in configuration

   205

        for varlist in configuration.getglobalVars():

   206

            # Generate variable block with modifier

   207

            config += [("  VAR_GLOBAL", ())]

   208

            if varlist.getretain():

   209

                config += [(" RETAIN", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "retain"))]

   210

            if varlist.getconstant():

   211

                config += [(" CONSTANT", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "constant"))]

   212

            config += [("\n", ())]

   213

            # Generate any variable of this block

   214

            for var in varlist.getvariable():

   215

                vartype_content = var.gettype().getcontent()

   216

                # Variable type is a user data type

   217

                if vartype_content["name"] == "derived":

   218

                    var_type = vartype_content["value"].getname()

   219

                # Variable type is a string type

   220

                elif vartype_content["name"] in ["string", "wstring"]:

   221

                    var_type = vartype_content["name"].upper()

   222

                # Variable type is an elementary type

   223

                else:

   224

                    var_type = vartype_content["name"]

   225

                config += [("    ", ()),

   226

                           (var.getname(), (tagname, "variable", var_number, "name")),

   227

                           (" ", ())]

   228

                # Generate variable address if exists

   229

                address = var.getaddress()

   230

                if address:

   231

                    config += [("AT ", ()),

   232

                               (address, (tagename, "variable", var_number, "address")),

   233

                               (" ", ())]

   234

                config += [(": ", ()),

   235

                           (var_type, (tagename, "variable", var_number, "type"))]

   236

                # Generate variable initial value if exists

   237

                initial = var.getinitialValue()

   238

                if initial:

   239

                    config += [(" := ", ()),

   240

                               (self.ComputeValue(initial.getvalue(), var_type), (tagename, "variable", var_number, "initial"))]

   241

                config += [(";\n", ())]

   242

                var_number += 1

   243

            config += [("  END_VAR\n", ())]

   244

        # Generate any resource in the configuration

   245

        for resource in configuration.getresource():

   246

            config += self.GenerateResource(resource, configuration.getname())

   247

        config += [("END_CONFIGURATION\n", ())]

   248

        return config

   249

   250

    # Generate a resource from its model

   251

    def GenerateResource(self, resource, config_name):

   252

        tagname = self.Controler.ComputeConfigurationResourceName(config_name, resource.getname())

   253

        resrce = [("\n  RESOURCE ", ()),

   254

                  (resource.getname(), (tagname, "name")),

   255

                  (" ON PLC\n", ())]

   256

        var_number = 0

   257

        # Generate any global variable in configuration

   258

        for varlist in resource.getglobalVars():

   259

            # Generate variable block with modifier

   260

            resrce += [("    VAR_GLOBAL", ())]

   261

            if varlist.getretain():

   262

                resrce += [(" RETAIN", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "retain"))]

   263

            if varlist.getconstant():

   264

                resrce += [(" CONSTANT", (tagname, "variable", (var_number, var_number + len(varlist.getvariable())), "constant"))]

   265

            resrce += "\n"

   266

            # Generate any variable of this block

   267

            for var in varlist.getvariable():

   268

                vartype_content = var.gettype().getcontent()

   269

                # Variable type is a user data type

   270

                if vartype_content["name"] == "derived":

   271

                    var_type = vartype_content["value"].getname()

   272

                # Variable type is a string type

   273

                elif vartype_content["name"] in ["string", "wstring"]:

   274

                    var_type = vartype_content["name"].upper()

   275

                # Variable type is an elementary type

   276

                else:

   277

                    var_type = vartype_content["name"]

   278

                resrce += [("      ", ()),

   279

                           (var.getname(), (tagname, "variable", var_number, "name")),

   280

                           (" ", ())]

   281

                address = var.getaddress()

   282

                # Generate variable address if exists

   283

                if address:

   284

                    resrce += [("AT ", ()),

   285

                               (address, (tagename, "variable", var_number, "address")),

   286

                               (" ", ())]

   287

                resrce += [(": ", ()),

   288

                           (var_type, (tagename, "variable", var_number, "type"))]

   289

                # Generate variable initial value if exists

   290

                initial = var.getinitialValue()

   291

                if initial:

   292

                    resrce += [(" := ", ()),

   293

                               (self.ComputeValue(initial.getvalue(), var_type), (tagename, "variable", var_number, "initial"))]

   294

                resrce += [(";\n", ())]

   295

                var_number += 1

   296

            resrce += [("    END_VAR\n", ())]

   297

        # Generate any task in the resource

   298

        tasks = resource.gettask()

   299

        task_number = 0

   300

        for task in tasks:

   301

            # Task declaration

   302

            resrce += [("    TASK ", ()),

   303

                       (task.getname(), (tagname, "task", task_number, "name")),

   304

                       ("(", ())]

   305

            args = []

   306

            single = task.getsingle()

   307

            # Single argument if exists

   308

            if single:

   309

                resrce += [("SINGLE := ", ()),

   310

                           (single, (tagname, "task", task_number, "single")),

   311

                           (",", ())]

   312

            # Interval argument if exists

   313

            interval = task.getinterval()

   314

            if interval:

   315

                resrce += [("INTERVAL := t#", ())]

   316

                if interval.hour != 0:

   317

                    resrce += [("%dh"%interval.hour, (tagname, "task", task_number, "interval", "hour"))]

   318

                if interval.minute != 0:

   319

                    resrce += [("%dm"%interval.minute, (tagname, "task", task_number, "interval", "minute"))]

   320

                if interval.second != 0:

   321

                    resrce += [("%ds"%interval.second, (tagname, "task", task_number, "interval", "second"))]

   322

                if interval.microsecond != 0:

   323

                    resrce += [("%dms"%(interval.microsecond / 1000), (tagname, "task", task_number, "interval", "millisecond"))]

   324

                resrce += [(",", ())]

   325

            # Priority argument

   326

            resrce += [("PRIORITY := ", ()), 

   327

                       ("%d"%task.getpriority(), (tagname, "task", task_number, "priority")),

   328

                       (");\n", ())]

   329

            task_number += 1

   330

        instance_number = 0

   331

        # Generate any program assign to each task

   332

        for task in tasks:

   333

            for instance in task.getpouInstance():

   334

                resrce += [("    PROGRAM ", ()),

   335

                           (instance.getname(), (tagname, "instance", instance_number, "name")),

   336

                           (" WITH ", ()),

   337

                           (task.getname(), (tagname, "instance", instance_number, "task")),

   338

                           (" : ", ()),

   339

                           (instance.gettype(), (tagname, "instance", instance_number, "type")),

   340

                           (";\n", ())]

   341

                instance_number += 1

   342

        # Generate any program assign to no task

   343

        for instance in resource.getpouInstance():

   344

            resrce += [("    PROGRAM ", ()),

   345

                           (instance.getname(), (tagname, "instance", instance_number, "name")),

   346

                           (" : ", ()),

   347

                           (instance.gettype(), (tagname, "instance", instance_number, "type")),

   348

                           (";\n", ())]

   349

            instance_number += 1

   350

        resrce += [("  END_RESOURCE\n", ())]

   351

        return resrce

   352

   353

    # Generate the entire program for current project

   354

    def GenerateProgram(self):        

   355

        # Find all data types defined

   356

        for datatype in self.Project.getdataTypes():

   357

            self.DatatypeComputed[datatype.getname()] = False

   358

        # Find all data types defined

   359

        for pou in self.Project.getpous():

   360

            self.PouComputed[pou.getname()] = False

   361

        # Generate data type declaration structure if there is at least one data 

   362

        # type defined

   363

        if len(self.DatatypeComputed) > 0:

   364

            self.Program += [("TYPE\n", ())]

   365

            # Generate every data types defined

   366

            for datatype_name in self.DatatypeComputed.keys():

   367

                self.Program += self.GenerateDataType(datatype_name)

   368

            self.Program += [("END_TYPE\n\n", ())]

   369

        # Generate every POUs defined

   370

        for pou_name in self.PouComputed.keys():

   371

            self.GeneratePouProgram(pou_name)

   372

        # Generate every configurations defined

   373

        for config in self.Project.getconfigurations():

   374

            self.Program += self.GenerateConfiguration(config)

   375

   376

    # Return generated program

   377

    def GetGeneratedProgram(self):

   378

        return self.Program

   379

   380

   381

#-------------------------------------------------------------------------------

   382

#                           Generator of POU programs

   383

#-------------------------------------------------------------------------------

   384

   385

   386

class PouProgramGenerator:

   387

   388

    # Create a new POU program generator

   389

    def __init__(self, parent, name, type):

   390

        # Keep Reference to the parent generator

   391

        self.ParentGenerator = parent

   392

        self.Name = name

   393

        self.Type = type

   394

        self.TagName = self.ParentGenerator.Controler.ComputePouName(name)

   395

        self.CurrentIndent = "  "

   396

        self.ReturnType = None

   397

        self.Interface = []

   398

        self.InitialSteps = []

   399

        self.ComputedBlocks = {}

   400

        self.ComputedConnectors = {}

   401

        self.ConnectionTypes = {}

   402

        self.RelatedConnections = []

   403

        self.SFCNetworks = {"Steps":{}, "Transitions":{}, "Actions":{}}

   404

        self.SFCComputedBlocks = []

   405

        self.ActionNumber = 0

   406

        self.Program = []

   407

   408

    def GetBlockType(self, type):

   409

        return self.ParentGenerator.Controler.GetBlockType(type)

   410

   411

    def IndentLeft(self):

   412

        if len(self.CurrentIndent) >= 2:

   413

            self.CurrentIndent = self.CurrentIndent[:-2]

   414

   415

    def IndentRight(self):

   416

        self.CurrentIndent += "  "

   417

   418

    # Generator of unique ID for inline actions

   419

    def GetActionNumber(self):

   420

        self.ActionNumber += 1

   421

        return self.ActionNumber

   422

   423

    # Test if a variable has already been defined

   424

    def IsAlreadyDefined(self, name):

   425

        for list_type, retain, constant, located, vars in self.Interface:

   426

            for var_type, var_name, var_address, var_initial in vars:

   427

                if name == var_name:

   428

                    return True

   429

        return False

   430

   431

    # Return the type of a variable defined in interface

   432

    def GetVariableType(self, name):

   433

        for list_type, retain, constant, located, vars in self.Interface:

   434

            for var_type, var_name, var_address, var_initial in vars:

   435

                if name == var_name:

   436

                    return var_type

   437

        return None

   438

   439

    # Return connectors linked by a connection to the given connector

   440

    def GetConnectedConnector(self, connector, body):

   441

        links = connector.getconnections()

   442

        if links and len(links) == 1:

   443

            return self.GetLinkedConnector(links[0], body)

   444

        return None        

   445

   446

    def GetLinkedConnector(self, link, body):

   447

        parameter = link.getformalParameter()

   448

        instance = body.getcontentInstance(link.getrefLocalId())

   449

        if isinstance(instance, (plcopen.fbdObjects_inVariable, plcopen.fbdObjects_inOutVariable, plcopen.commonObjects_continuation, plcopen.ldObjects_contact, plcopen.ldObjects_coil)):

   450

            return instance.connectionPointOut

   451

        elif isinstance(instance, plcopen.fbdObjects_block):

   452

            outputvariables = instance.outputVariables.getvariable()

   453

            if len(outputvariables) == 1:

   454

                return outputvariables[0].connectionPointOut

   455

            elif parameter:

   456

                for variable in outputvariables:

   457

                    if variable.getformalParameter() == parameter:

   458

                        return variable.connectionPointOut

   459

            else:

   460

                point = link.getPosition()[-1]

   461

                for variable in outputvariables:

   462

                    relposition = variable.connectionPointOut.getrelPositionXY()

   463

                    blockposition = instance.getposition()

   464

                    if point.x == blockposition.x + relposition[0] and point.y == blockposition.y + relposition[1]:

   465

                        return variable.connectionPointOut

   466

        elif isinstance(instance, plcopen.ldObjects_leftPowerRail):

   467

            outputconnections = instance.getconnectionPointOut()

   468

            if len(outputconnections) == 1:

   469

                return outputconnections[0]

   470

            else:

   471

                point = link.getposition()[-1]

   472

                for outputconnection in outputconnections:

   473

                    relposition = outputconnection.getrelPositionXY()

   474

                    powerrailposition = instance.getposition()

   475

                    if point.x == powerrailposition.x + relposition[0] and point.y == powerrailposition.y + relposition[1]:

   476

                        return outputconnection

   477

        return None

   478

   479

    def ExtractRelatedConnections(self, connection):

   480

        for i, related in enumerate(self.RelatedConnections):

   481

            if connection in related:

   482

                return self.RelatedConnections.pop(i)

   483

        return [connection]

   484

   485

    def ComputeInterface(self, pou):

   486

        interface = pou.getinterface()

   487

        if interface is not None:

   488

            body = pou.getbody()

   489

            body_content = body.getcontent()

   490

            if self.Type == "FUNCTION":

   491

                returntype_content = interface.getreturnType().getcontent()

   492

                if returntype_content["name"] == "derived":

   493

                    self.ReturnType = returntype_content["value"].getname()

   494

                elif returntype_content["name"] in ["string", "wstring"]: