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

import re

    29

    30

    31

# Dictionary associating PLCOpen variable categories to the corresponding 

    32

# IEC 61131-3 variable categories

    33

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

    34

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

    35

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

    36

    37

    38

# Dictionary associating PLCOpen POU categories to the corresponding 

    39

# IEC 61131-3 POU categories

    40

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

    41

    42

    43

# Helper function for reindenting text

    44

def ReIndentText(text, nb_spaces):

    45

    compute = ""

    46

    lines = text.splitlines()

    47

    if len(lines) > 0:

    48

        line_num = 0

    49

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

    50

            line_num += 1

    51

        if line_num < len(lines):

    52

            spaces = 0

    53

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

    54

                spaces += 1

    55

            indent = ""

    56

            for i in xrange(spaces, nb_spaces):

    57

                indent += " "

    58

            for line in lines:

    59

                if line != "":

    60

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

    61

                else:

    62

                    compute += "\n"

    63

    return compute

    64

    65

def SortInstances(a, b):

    66

    ax, ay = int(a.getx()), int(a.gety())

    67

    bx, by = int(b.getx()), int(b.gety())

    68

    if abs(ay - by) < 10:

    69

        return cmp(ax, bx)

    70

    else:

    71

        return cmp(ay, by)

    72

    73

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

    74

#                  Specific exception for PLC generating errors

    75

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

    76

    77

    78

class PLCGenException(Exception):

    79

    pass

    80

    81

    82

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

    83

#                           Generator of PLC program

    84

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

    85

    86

    87

class ProgramGenerator:

    88

    89

    # Create a new PCL program generator

    90

    def __init__(self, controler, project, errors, warnings):

    91

        # Keep reference of the controler and project

    92

        self.Controler = controler

    93

        self.Project = project

    94

        # Reset the internal variables used to generate PLC programs

    95

        self.Program = []

    96

        self.DatatypeComputed = {}

    97

        self.PouComputed = {}

    98

        self.Errors = errors

    99

        self.Warnings = warnings

   100

   101

    # Compute value according to type given

   102

    def ComputeValue(self, value, var_type):

   103

        base_type = self.Controler.GetBaseType(var_type)

   104

        if base_type == "STRING":

   105

            return "'%s'"%value

   106

        elif base_type == "WSTRING":

   107

            return "\"%s\""%value

   108

        return value

   109

   110

    # Generate a data type from its name

   111

    def GenerateDataType(self, datatype_name):

   112

        # Verify that data type hasn't been generated yet

   113

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

   114

            # If not mark data type as computed

   115

            self.DatatypeComputed[datatype_name] = True

   116

   117

            # Getting datatype model from project

   118

            datatype = self.Project.getdataType(datatype_name)

   119

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

   120

            datatype_def = [("  ", ()), 

   121

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

   122

                            (" : ", ())]

   123

            basetype_content = datatype.baseType.getcontent()

   124

            # Data type derived directly from a string type 

   125

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

   126

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

   127

            # Data type derived directly from a user defined type 

   128

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

   129

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

   130

                self.GenerateDataType(basetype_name)

   131

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

   132

            # Data type is a subrange

   133

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

   134

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

   135

                # Subrange derived directly from a user defined type 

   136

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

   137

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

   138

                    self.GenerateDataType(basetype_name)

   139

                # Subrange derived directly from an elementary type 

   140

                else:

   141

                    basetype_name = base_type["name"]

   142

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

   143

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

   144

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

   145

                                 (" (", ()),

   146

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

   147

                                 ("..", ()),

   148

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

   149

                                 (")",())]

   150

            # Data type is an enumerated type

   151

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

   152

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

   153

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

   154

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

   155

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

   156

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

   157

            # Data type is an array

   158

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

   159

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

   160

                # Array derived directly from a user defined type 

   161

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

   162

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

   163

                    self.GenerateDataType(basetype_name)

   164

                # Array derived directly from a string type 

   165

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

   166

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

   167

                # Array derived directly from an elementary type 

   168

                else:

   169

                    basetype_name = base_type["name"]

   170

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

   171

                               ("..", ()),

   172

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

   173

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

   174

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

   175

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

   176

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

   177

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

   178

            # Data type is a structure

   179

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

   180

                elements = []

   181

                for i, element in enumerate(basetype_content["value"].getvariable()):

   182

                    element_type = element.type.getcontent()

   183

                    # Structure element derived directly from a user defined type 

   184

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

   185

                        elementtype_name = element_type["value"].getname()

   186

                        self.GenerateDataType(elementtype_name)

   187

                    # Structure element derived directly from a string type 

   188

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

   189

                        elementtype_name = element_type["name"].upper()

   190

                    # Structure element derived directly from an elementary type 

   191

                    else:

   192

                        elementtype_name = element_type["name"]

   193

                    element_text = [("\n    ", ()),

   194

                                    (element.getname(), (tagname, "struct", i, "name")),

   195

                                    (" : ", ()),

   196

                                    (elementtype_name, (tagname, "struct", i, "type"))]

   197

                    if element.initialValue is not None:

   198

                        element_text.extend([(" := ", ()),

   199

                                             (self.ComputeValue(element.initialValue.getvalue(), elementtype_name), (tagname, "struct", i, "initial"))])

   200

                    element_text.append((";", ()))

   201

                    elements.append(element_text)

   202

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

   203

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

   204

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

   205

            # Data type derived directly from a elementary type 

   206

            else:

   207

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

   208

            # Data type has an initial value

   209

            if datatype.initialValue is not None:

   210

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

   211

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

   212

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

   213

            self.Program += datatype_def

   214

   215

    # Generate a POU from its name

   216

    def GeneratePouProgram(self, pou_name):

   217

        # Verify that POU hasn't been generated yet

   218

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

   219

            # If not mark POU as computed

   220

            self.PouComputed[pou_name] = True

   221

   222

            # Getting POU model from project

   223

            pou = self.Project.getpou(pou_name)

   224

            pou_type = pou.getpouType()

   225

            # Verify that POU type exists

   226

            if pouTypeNames.has_key(pou_type):

   227

                # Create a POU program generator

   228

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

   229

                program = pou_program.GenerateProgram(pou)

   230

                self.Program += program

   231

            else:

   232

                raise PLCGenException, _("Undefined pou type \"%s\"")%pou_type

   233

   234

    # Generate a POU defined and used in text

   235

    def GeneratePouProgramInText(self, text):

   236

        for pou_name in self.PouComputed.keys():

   237

            model = re.compile("(?:^|[^0-9^A-Z])%s(?:$|[^0-9^A-Z])"%pou_name.upper())

   238

            if model.search(text) is not None:

   239

                self.GeneratePouProgram(pou_name)

   240

   241

    # Generate a configuration from its model

   242

    def GenerateConfiguration(self, configuration):

   243

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

   244

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

   245

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

   246

                  ("\n", ())]

   247

        var_number = 0

   248

        # Generate any global variable in configuration

   249

        for varlist in configuration.getglobalVars():

   250

            # Generate variable block with modifier

   251

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

   252

            if varlist.getconstant():

   253

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

   254

            elif varlist.getretain():

   255

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

   256

            elif varlist.getretain():

   257

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

   258

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

   259

            # Generate any variable of this block

   260

            for var in varlist.getvariable():

   261

                vartype_content = var.gettype().getcontent()

   262

                # Variable type is a user data type

   263

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

   264

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

   265

                # Variable type is a string type

   266

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

   267

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

   268

                # Variable type is an array

   269

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

   270

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

   271

                    # Array derived directly from a user defined type 

   272

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

   273

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

   274

                        self.GenerateDataType(basetype_name)

   275

                    # Array derived directly from a string type 

   276

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

   277

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

   278

                    # Array derived directly from an elementary type 

   279

                    else:

   280

                        basetype_name = base_type["name"]

   281

                    var_type = "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (dimension.getlower(), dimension.getupper()), vartype_content["value"].getdimension())), basetype_name)

   282

                # Variable type is an elementary type

   283

                else:

   284

                    var_type = vartype_content["name"]

   285

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

   286

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

   287

                           (" ", ())]

   288

                # Generate variable address if exists

   289

                address = var.getaddress()

   290

                if address:

   291

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

   292

                               (address, (tagname, "variable", var_number, "address")),

   293

                               (" ", ())]

   294

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

   295

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

   296

                # Generate variable initial value if exists

   297

                initial = var.getinitialValue()

   298

                if initial:

   299

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

   300

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

   301

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

   302

                var_number += 1

   303

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

   304

        # Generate any resource in the configuration

   305

        for resource in configuration.getresource():

   306

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

   307

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

   308

        return config

   309

   310

    # Generate a resource from its model

   311

    def GenerateResource(self, resource, config_name):

   312

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

   313

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

   314

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

   315

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

   316

        var_number = 0

   317

        # Generate any global variable in configuration

   318

        for varlist in resource.getglobalVars():

   319

            # Generate variable block with modifier

   320

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

   321

            if varlist.getconstant():

   322

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

   323

            elif varlist.getretain():

   324

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

   325

            elif varlist.getnonretain():

   326

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

   327

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

   328

            # Generate any variable of this block

   329

            for var in varlist.getvariable():

   330

                vartype_content = var.gettype().getcontent()

   331

                # Variable type is a user data type

   332

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

   333

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

   334

                # Variable type is a string type

   335

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

   336

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

   337

                # Variable type is an array

   338

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

   339

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

   340

                    # Array derived directly from a user defined type 

   341

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

   342

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

   343

                        self.GenerateDataType(basetype_name)

   344

                    # Array derived directly from a string type 

   345

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

   346

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

   347

                    # Array derived directly from an elementary type 

   348

                    else:

   349

                        basetype_name = base_type["name"]

   350

                    var_type = "ARRAY [%s] OF %s" % (",".join(map(lambda x : "%s..%s" % (dimension.getlower(), dimension.getupper()), vartype_content["value"].getdimension())), basetype_name)

   351

                # Variable type is an elementary type

   352

                else:

   353

                    var_type = vartype_content["name"]

   354

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

   355

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

   356

                           (" ", ())]

   357

                address = var.getaddress()

   358

                # Generate variable address if exists

   359

                if address:

   360

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

   361

                               (address, (tagname, "variable", var_number, "address")),

   362

                               (" ", ())]

   363

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

   364

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

   365

                # Generate variable initial value if exists

   366

                initial = var.getinitialValue()

   367

                if initial:

   368

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

   369

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

   370

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

   371

                var_number += 1

   372

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

   373

        # Generate any task in the resource

   374

        tasks = resource.gettask()

   375

        task_number = 0

   376

        for task in tasks:

   377

            # Task declaration

   378

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

   379

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

   380

                       ("(", ())]

   381

            args = []

   382

            single = task.getsingle()

   383

            # Single argument if exists

   384

            if single:

   385

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

   386

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

   387

                           (",", ())]

   388

            # Interval argument if exists

   389

            interval = task.getinterval()

   390

            if interval:

   391

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

   392

                           (interval, (tagname, "task", task_number, "interval")),

   393

                           (",", ())]

   394

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

   395

##                if interval.hour != 0:

   396

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

   397

##                if interval.minute != 0:

   398

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

   399

##                if interval.second != 0:

   400

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

   401

##                if interval.microsecond != 0:

   402

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

   403

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

   404

            # Priority argument

   405

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

   406

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

   407

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

   408

            task_number += 1

   409

        instance_number = 0

   410

        # Generate any program assign to each task

   411

        for task in tasks:

   412

            for instance in task.getpouInstance():

   413

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

   414

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

   415

                           (" WITH ", ()),

   416

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

   417

                           (" : ", ()),

   418

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

   419

                           (";\n", ())]

   420

                instance_number += 1

   421

        # Generate any program assign to no task

   422

        for instance in resource.getpouInstance():

   423

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

   424

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

   425

                           (" : ", ()),

   426

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

   427

                           (";\n", ())]

   428

            instance_number += 1

   429

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

   430

        return resrce

   431

   432

    # Generate the entire program for current project

   433

    def GenerateProgram(self):        

   434

        # Find all data types defined

   435

        for datatype in self.Project.getdataTypes():

   436

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

   437

        # Find all data types defined

   438

        for pou in self.Project.getpous():

   439

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

   440

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

   441

        # type defined

   442

        if len(self.DatatypeComputed) > 0:

   443

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

   444

            # Generate every data types defined

   445

            for datatype_name in self.DatatypeComputed.keys():

   446

                self.GenerateDataType(datatype_name)

   447

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

   448

        # Generate every POUs defined

   449

        for pou_name in self.PouComputed.keys():

   450

            self.GeneratePouProgram(pou_name)

   451

        # Generate every configurations defined

   452

        for config in self.Project.getconfigurations():

   453

            self.Program += self.GenerateConfiguration(config)

   454

   455

    # Return generated program

   456

    def GetGeneratedProgram(self):

   457

        return self.Program

   458

   459

   460

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

   461

#                           Generator of POU programs

   462

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

   463

   464

   465

class PouProgramGenerator:

   466

   467

    # Create a new POU program generator

   468

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

   469

        # Keep Reference to the parent generator

   470

        self.ParentGenerator = parent

   471

        self.Name = name

   472

        self.Type = type

   473

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

   474

        self.CurrentIndent = "  "

   475

        self.ReturnType = None

   476

        self.Interface = []

   477

        self.InitialSteps = []

   478

        self.ComputedBlocks = {}

   479

        self.ComputedConnectors = {}

   480

        self.ConnectionTypes = {}

   481

        self.RelatedConnections = []

   482

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

   483

        self.SFCComputedBlocks = []

   484

        self.ActionNumber = 0

   485

        self.Program = []

   486

        self.Errors = errors

   487

        self.Warnings = warnings

   488

   489

    def GetBlockType(self, type):

   490

        return self.ParentGenerator.Controler.GetBlockType(type)

   491

   492

    def IndentLeft(self):