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 PLCOpenParser

    26

from plcopen.structures import *

    27

from types import *

    28

import re

    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

errorVarTypes = {

    43

    "VAR_INPUT": "var_input",

    44

    "VAR_OUTPUT": "var_output",

    45

    "VAR_INOUT": "var_inout",

    46

}

    47

    48

# Helper function for reindenting text

    49

def ReIndentText(text, nb_spaces):

    50

    compute = ""

    51

    lines = text.splitlines()

    52

    if len(lines) > 0:

    53

        line_num = 0

    54

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

    55

            line_num += 1

    56

        if line_num < len(lines):

    57

            spaces = 0

    58

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

    59

                spaces += 1

    60

            indent = ""

    61

            for i in xrange(spaces, nb_spaces):

    62

                indent += " "

    63

            for line in lines:

    64

                if line != "":

    65

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

    66

                else:

    67

                    compute += "\n"

    68

    return compute

    69

    70

def SortInstances(a, b):

    71

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

    72

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

    73

    if abs(ay - by) < 10:

    74

        return cmp(ax, bx)

    75

    else:

    76

        return cmp(ay, by)

    77

    78

# Helper for emulate join on element list

    79

def JoinList(separator, mylist):

    80

    if len(mylist) > 0 :

    81

        return reduce(lambda x, y: x + separator + y, mylist)

    82

    else :

    83

        return mylist

    84

    85

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

    86

#                  Specific exception for PLC generating errors

    87

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

    88

    89

    90

class PLCGenException(Exception):

    91

    pass

    92

    93

    94

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

    95

#                           Generator of PLC program

    96

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

    97

    98

    99

class ProgramGenerator:

   100

   101

    # Create a new PCL program generator

   102

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

   103

        # Keep reference of the controler and project

   104

        self.Controler = controler

   105

        self.Project = project

   106

        # Reset the internal variables used to generate PLC programs

   107

        self.Program = []

   108

        self.DatatypeComputed = {}

   109

        self.PouComputed = {}

   110

        self.Errors = errors

   111

        self.Warnings = warnings

   112

   113

    # Compute value according to type given

   114

    def ComputeValue(self, value, var_type):

   115

        base_type = self.Controler.GetBaseType(var_type)

   116

        if base_type == "STRING" and not value.startswith("'") and not value.endswith("'"):

   117

            return "'%s'"%value

   118

        elif base_type == "WSTRING" and not value.startswith('"') and not value.endswith('"'):

   119

            return "\"%s\""%value

   120

        return value

   121

   122

    # Generate a data type from its name

   123

    def GenerateDataType(self, datatype_name):

   124

        # Verify that data type hasn't been generated yet

   125

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

   126

            # If not mark data type as computed

   127

            self.DatatypeComputed[datatype_name] = True

   128

   129

            # Getting datatype model from project

   130

            datatype = self.Project.getdataType(datatype_name)

   131

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

   132

            datatype_def = [("  ", ()), 

   133

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

   134

                            (" : ", ())]

   135

            basetype_content = datatype.baseType.getcontent()

   136

            basetype_content_type = basetype_content.getLocalTag()

   137

            # Data type derived directly from a user defined type 

   138

            if basetype_content_type == "derived":

   139

                basetype_name = basetype_content.getname()

   140

                self.GenerateDataType(basetype_name)

   141

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

   142

            # Data type is a subrange

   143

            elif basetype_content_type in ["subrangeSigned", "subrangeUnsigned"]:

   144

                base_type = basetype_content.baseType.getcontent()

   145

                base_type_type = base_type.getLocalTag()

   146

                # Subrange derived directly from a user defined type 

   147

                if base_type_type == "derived":

   148

                    basetype_name = base_type_type.getname()

   149

                    self.GenerateDataType(basetype_name)

   150

                # Subrange derived directly from an elementary type 

   151

                else:

   152

                    basetype_name = base_type_type

   153

                min_value = basetype_content.range.getlower()

   154

                max_value = basetype_content.range.getupper()

   155

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

   156

                                 (" (", ()),

   157

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

   158

                                 ("..", ()),

   159

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

   160

                                 (")",())]

   161

            # Data type is an enumerated type

   162

            elif basetype_content_type == "enum":

   163

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

   164

                          for i, value in enumerate(

   165

                              basetype_content.xpath("ppx:values/ppx:value", 

   166

                                  namespaces=PLCOpenParser.NSMAP))]

   167

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

   168

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

   169

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

   170

            # Data type is an array

   171

            elif basetype_content_type == "array":

   172

                base_type = basetype_content.baseType.getcontent()

   173

                base_type_type = base_type.getLocalTag()

   174

                # Array derived directly from a user defined type 

   175

                if base_type_type == "derived":

   176

                    basetype_name = base_type.getname()

   177

                    self.GenerateDataType(basetype_name)

   178

                # Array derived directly from an elementary type 

   179

                else:

   180

                    basetype_name = base_type_type.upper()

   181

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

   182

                               ("..", ()),

   183

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

   184

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

   185

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

   186

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

   187

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

   188

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

   189

            # Data type is a structure

   190

            elif basetype_content_type == "struct":

   191

                elements = []

   192

                for i, element in enumerate(basetype_content.getvariable()):

   193

                    element_type = element.type.getcontent()

   194

                    element_type_type = element_type.getLocalTag()

   195

                    # Structure element derived directly from a user defined type 

   196

                    if element_type_type == "derived":

   197

                        elementtype_name = element_type.getname()

   198

                        self.GenerateDataType(elementtype_name)

   199

                    elif element_type_type == "array":

   200

                        base_type = element_type.baseType.getcontent()

   201

                        base_type_type = base_type.getLocalTag()

   202

                        # Array derived directly from a user defined type 

   203

                        if base_type_type == "derived":

   204

                            basetype_name = base_type.getname()

   205

                            self.GenerateDataType(basetype_name)

   206

                        # Array derived directly from an elementary type 

   207

                        else:

   208

                            basetype_name = base_type_type.upper()

   209

                        dimensions = ["%s..%s" % (dimension.getlower(), dimension.getupper())

   210

                                      for dimension in element_type.getdimension()]

   211

                        elementtype_name = "ARRAY [%s] OF %s" % (",".join(dimensions), basetype_name)

   212

                    # Structure element derived directly from an elementary type 

   213

                    else:

   214

                        elementtype_name = element_type_type.upper()

   215

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

   216

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

   217

                                    (" : ", ()),

   218

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

   219

                    if element.initialValue is not None:

   220

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

   221

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

   222

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

   223

                    elements.append(element_text)

   224

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

   225

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

   226

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

   227

            # Data type derived directly from a elementary type 

   228

            else:

   229

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

   230

            # Data type has an initial value

   231

            if datatype.initialValue is not None:

   232

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

   233

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

   234

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

   235

            self.Program += datatype_def

   236

   237

    # Generate a POU from its name

   238

    def GeneratePouProgram(self, pou_name):

   239

        # Verify that POU hasn't been generated yet

   240

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

   241

            # If not mark POU as computed

   242

            self.PouComputed[pou_name] = True

   243

   244

            # Getting POU model from project

   245

            pou = self.Project.getpou(pou_name)

   246

            pou_type = pou.getpouType()

   247

            # Verify that POU type exists

   248

            if pouTypeNames.has_key(pou_type):

   249

                # Create a POU program generator

   250

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

   251

                program = pou_program.GenerateProgram(pou)

   252

                self.Program += program

   253

            else:

   254

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

   255

   256

    # Generate a POU defined and used in text

   257

    def GeneratePouProgramInText(self, text):

   258

        for pou_name in self.PouComputed.keys():

   259

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

   260

            if model.search(text) is not None:

   261

                self.GeneratePouProgram(pou_name)

   262

   263

    # Generate a configuration from its model

   264

    def GenerateConfiguration(self, configuration):

   265

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

   266

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

   267

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

   268

                  ("\n", ())]

   269

        var_number = 0

   270

   271

        varlists = [(varlist, varlist.getvariable()[:]) for varlist in configuration.getglobalVars()]

   272

   273

        extra_variables = self.Controler.GetConfigurationExtraVariables()

   274

        extra_global_vars = None

   275

        if len(extra_variables) > 0 and len(varlists) == 0:

   276

            extra_global_vars = PLCOpenParser.CreateElement("globalVars", "interface")

   277

            configuration.setglobalVars([extra_global_vars])

   278

            varlists = [(extra_global_vars, [])]

   279

   280

        for variable in extra_variables:

   281

            varlists[-1][0].appendvariable(variable)

   282

            varlists[-1][1].append(variable)

   283

   284

        # Generate any global variable in configuration

   285

        for varlist, varlist_variables in varlists:

   286

            variable_type = errorVarTypes.get("VAR_GLOBAL", "var_local")

   287

            # Generate variable block with modifier

   288

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

   289

            if varlist.getconstant():

   290

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

   291

            elif varlist.getretain():

   292

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

   293

            elif varlist.getnonretain():

   294

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

   295

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

   296

            # Generate any variable of this block

   297

            for var in varlist_variables:

   298

                vartype_content = var.gettype().getcontent()

   299

                if vartype_content.getLocalTag() == "derived":

   300

                    var_type = vartype_content.getname()

   301

                    self.GenerateDataType(var_type)

   302

                else:

   303

                    var_type = var.gettypeAsText()

   304

   305

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

   306

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

   307

                           (" ", ())]

   308

                # Generate variable address if exists

   309

                address = var.getaddress()

   310

                if address:

   311

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

   312

                               (address, (tagname, variable_type, var_number, "location")),

   313

                               (" ", ())]

   314

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

   315

                           (var.gettypeAsText(), (tagname, variable_type, var_number, "type"))]

   316

                # Generate variable initial value if exists

   317

                initial = var.getinitialValue()

   318

                if initial is not None:

   319

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

   320

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

   321

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

   322

                var_number += 1

   323

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

   324

   325

        if extra_global_vars is not None:

   326

            configuration.remove(extra_global_vars)

   327

        else:

   328

            for variable in extra_variables:

   329

                varlists[-1][1].remove(variable)

   330

   331

        # Generate any resource in the configuration

   332

        for resource in configuration.getresource():

   333

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

   334

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

   335

        return config

   336

   337

    # Generate a resource from its model

   338

    def GenerateResource(self, resource, config_name):

   339

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

   340

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

   341

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

   342

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

   343

        var_number = 0

   344

        # Generate any global variable in configuration

   345

        for varlist in resource.getglobalVars():

   346

            variable_type = errorVarTypes.get("VAR_GLOBAL", "var_local")

   347

            # Generate variable block with modifier

   348

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

   349

            if varlist.getconstant():

   350

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

   351

            elif varlist.getretain():

   352

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

   353

            elif varlist.getnonretain():

   354

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

   355

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

   356

            # Generate any variable of this block

   357

            for var in varlist.getvariable():

   358

                vartype_content = var.gettype().getcontent()

   359

                if vartype_content.getLocalTag() == "derived":

   360

                    var_type = vartype_content.getname()

   361

                    self.GenerateDataType(var_type)

   362

                else:

   363

                    var_type = var.gettypeAsText()

   364

   365

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

   366

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

   367

                           (" ", ())]

   368

                address = var.getaddress()

   369

                # Generate variable address if exists

   370

                if address:

   371

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

   372

                               (address, (tagname, variable_type, var_number, "location")),

   373

                               (" ", ())]

   374

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

   375

                           (var.gettypeAsText(), (tagname, variable_type, var_number, "type"))]

   376

                # Generate variable initial value if exists

   377

                initial = var.getinitialValue()

   378

                if initial is not None:

   379

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

   380

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

   381

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

   382

                var_number += 1

   383

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

   384

        # Generate any task in the resource

   385

        tasks = resource.gettask()

   386

        task_number = 0

   387

        for task in tasks:

   388

            # Task declaration

   389

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

   390

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

   391

                       ("(", ())]

   392

            args = []

   393

            single = task.getsingle()

   394

            # Single argument if exists

   395

            if single is not None:

   396

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

   397

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

   398

                           (",", ())]

   399

            # Interval argument if exists

   400

            interval = task.getinterval()

   401

            if interval is not None:

   402

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

   403

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

   404

                           (",", ())]

   405

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

   406

##                if interval.hour != 0:

   407

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

   408

##                if interval.minute != 0:

   409

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

   410

##                if interval.second != 0:

   411

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

   412

##                if interval.microsecond != 0:

   413

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

   414

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

   415

            # Priority argument

   416

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

   417

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

   418

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

   419

            task_number += 1

   420

        instance_number = 0

   421

        # Generate any program assign to each task

   422

        for task in tasks:

   423

            for instance in task.getpouInstance():

   424

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

   425

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

   426

                           (" WITH ", ()),

   427

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

   428

                           (" : ", ()),

   429

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

   430

                           (";\n", ())]

   431

                instance_number += 1

   432

        # Generate any program assign to no task

   433

        for instance in resource.getpouInstance():

   434

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

   435

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

   436

                           (" : ", ()),

   437

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

   438

                           (";\n", ())]

   439

            instance_number += 1

   440

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

   441

        return resrce

   442

   443

    # Generate the entire program for current project

   444

    def GenerateProgram(self):        

   445

        # Find all data types defined

   446

        for datatype in self.Project.getdataTypes():

   447

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

   448

        # Find all data types defined

   449

        for pou in self.Project.getpous():

   450

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

   451

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

   452

        # type defined

   453

        if len(self.DatatypeComputed) > 0:

   454

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

   455

            # Generate every data types defined

   456

            for datatype_name in self.DatatypeComputed.keys():

   457

                self.GenerateDataType(datatype_name)

   458

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

   459

        # Generate every POUs defined

   460

        for pou_name in self.PouComputed.keys():

   461

            self.GeneratePouProgram(pou_name)

   462

        # Generate every configurations defined

   463

        for config in self.Project.getconfigurations():

   464

            self.Program += self.GenerateConfiguration(config)

   465

   466

    # Return generated program

   467

    def GetGeneratedProgram(self):

   468

        return self.Program

   469

   470

   471

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

   472

#                           Generator of POU programs

   473

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

   474

   475

[ConnectorClass, ContinuationClass, ActionBlockClass] = [

   476

    PLCOpenParser.GetElementClass(instance_name, "commonObjects")

   477

    for instance_name in ["connector", "continuation", "actionBlock"]]

   478

[InVariableClass, InOutVariableClass, OutVariableClass, BlockClass] = [

   479

    PLCOpenParser.GetElementClass(instance_name, "fbdObjects")

   480

    for instance_name in ["inVariable", "inOutVariable", "outVariable", "block"]]

   481

[ContactClass, CoilClass, LeftPowerRailClass, RightPowerRailClass] = [

   482

    PLCOpenParser.GetElementClass(instance_name, "ldObjects")

   483

    for instance_name in ["contact", "coil", "leftPowerRail", "rightPowerRail"]]

   484

[StepClass, TransitionClass, JumpStepClass, 

   485

 SelectionConvergenceClass, SelectionDivergenceClass,

   486

 SimultaneousConvergenceClass, SimultaneousDivergenceClass] = [

   487

    PLCOpenParser.GetElementClass(instance_name, "sfcObjects")

   488

    for instance_name in ["step", "transition", "jumpStep", 

   489

        "selectionConvergence", "selectionDivergence",

   490

        "simultaneousConvergence", "simultaneousDivergence"]]

   491

TransitionObjClass = PLCOpenParser.GetElementClass("transition", "transitions")

   492

ActionObjClass = PLCOpenParser.GetElementClass("action", "actions")

   493

   494

class PouProgramGenerator:

   495

   496

    # Create a new POU program generator

   497

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

   498

        # Keep Reference to the parent generator

   499

        self.ParentGenerator = parent

   500

        self.Name = name

   501

        self.Type = type

   502

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

   503

        self.CurrentIndent = "  "

   504

        self.ReturnType = None

   505

        self.Interface = []

   506

        self.InitialSteps = []

   507

        self.ComputedBlocks = {}

   508

        self.ComputedConnectors = {}

   509

        self.ConnectionTypes = {}

   510

        self.RelatedConnections = []

   511

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

   512

        self.SFCComputedBlocks = []

   513

        self.ActionNumber = 0

   514

        self.Program = []

   515

        self.Errors = errors

   516

        self.Warnings = warnings

   517

   518

    def GetBlockType(self, type, inputs=None):