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

# 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

REAL_MODEL = re.compile("[0-9]+\.[0-9]+$")

    79

INTEGER_MODEL = re.compile("[0-9]+$")

    80

    81

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

    82

#                  Specific exception for PLC generating errors

    83

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

    84

    85

    86

class PLCGenException(Exception):

    87

    pass

    88

    89

    90

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

    91

#                           Generator of PLC program

    92

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

    93

    94

    95

class ProgramGenerator:

    96

    97

    # Create a new PCL program generator

    98

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

    99

        # Keep reference of the controler and project

   100

        self.Controler = controler

   101

        self.Project = project

   102

        # Reset the internal variables used to generate PLC programs

   103

        self.Program = []

   104

        self.DatatypeComputed = {}

   105

        self.PouComputed = {}

   106

        self.Errors = errors

   107

        self.Warnings = warnings

   108

   109

    # Compute value according to type given

   110

    def ComputeValue(self, value, var_type):

   111

        base_type = self.Controler.GetBaseType(var_type)

   112

        if base_type == "STRING":

   113

            return "'%s'"%value

   114

        elif base_type == "WSTRING":

   115

            return "\"%s\""%value

   116

        return value

   117

   118

    # Generate a data type from its name

   119

    def GenerateDataType(self, datatype_name):

   120

        # Verify that data type hasn't been generated yet

   121

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

   122

            # If not mark data type as computed

   123

            self.DatatypeComputed[datatype_name] = True

   124

   125

            # Getting datatype model from project

   126

            datatype = self.Project.getdataType(datatype_name)

   127

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

   128

            datatype_def = [("  ", ()), 

   129

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

   130

                            (" : ", ())]

   131

            basetype_content = datatype.baseType.getcontent()

   132

            # Data type derived directly from a string type 

   133

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

   134

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

   135

            # Data type derived directly from a user defined type 

   136

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

   137

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

   138

                self.GenerateDataType(basetype_name)

   139

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

   140

            # Data type is a subrange

   141

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

   142

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

   143

                # Subrange derived directly from a user defined type 

   144

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

   145

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

   146

                    self.GenerateDataType(basetype_name)

   147

                # Subrange derived directly from an elementary type 

   148

                else:

   149

                    basetype_name = base_type["name"]

   150

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

   151

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

   152

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

   153

                                 (" (", ()),

   154

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

   155

                                 ("..", ()),

   156

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

   157

                                 (")",())]

   158

            # Data type is an enumerated type

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

            # Data type is an array

   166

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

   167

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

   168

                # Array derived directly from a user defined type 

   169

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

   170

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

   171

                    self.GenerateDataType(basetype_name)

   172

                # Array derived directly from a string type 

   173

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

   174

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

   175

                # Array derived directly from an elementary type 

   176

                else:

   177

                    basetype_name = base_type["name"]

   178

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

   179

                               ("..", ()),

   180

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

   181

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

   182

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

   183

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

   184

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

   185

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

   186

            # Data type is a structure

   187

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

   188

                elements = []

   189

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

   190

                    element_type = element.type.getcontent()

   191

                    # Structure element derived directly from a user defined type 

   192

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

   193

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

   194

                        self.GenerateDataType(elementtype_name)

   195

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

   196

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

   197

                        # Array derived directly from a user defined type 

   198

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

   199

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

   200

                            self.GenerateDataType(basetype_name)

   201

                        # Array derived directly from a string type 

   202

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

   203

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

   204

                        # Array derived directly from an elementary type 

   205

                        else:

   206

                            basetype_name = base_type["name"]

   207

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

   208

                                      for dimension in element_type["value"].getdimension()]

   209

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

   210

                    # Structure element derived directly from a string type 

   211

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

   212

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

   213

                    # Structure element derived directly from an elementary type 

   214

                    else:

   215

                        elementtype_name = element_type["name"]

   216

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

   217

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

   218

                                    (" : ", ()),

   219

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

   220

                    if element.initialValue is not None:

   221

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

   222

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

   223

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

   224

                    elements.append(element_text)

   225

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

   226

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

   227

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

   228

            # Data type derived directly from a elementary type 

   229

            else:

   230

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

   231

            # Data type has an initial value

   232

            if datatype.initialValue is not None:

   233

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

   234

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

   235

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

   236

            self.Program += datatype_def

   237

   238

    # Generate a POU from its name

   239

    def GeneratePouProgram(self, pou_name):

   240

        # Verify that POU hasn't been generated yet

   241

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

   242

            # If not mark POU as computed

   243

            self.PouComputed[pou_name] = True

   244

   245

            # Getting POU model from project

   246

            pou = self.Project.getpou(pou_name)

   247

            pou_type = pou.getpouType()

   248

            # Verify that POU type exists

   249

            if pouTypeNames.has_key(pou_type):

   250

                # Create a POU program generator

   251

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

   252

                program = pou_program.GenerateProgram(pou)

   253

                self.Program += program

   254

            else:

   255

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

   256

   257

    # Generate a POU defined and used in text

   258

    def GeneratePouProgramInText(self, text):

   259

        for pou_name in self.PouComputed.keys():

   260

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

   261

            if model.search(text) is not None:

   262

                self.GeneratePouProgram(pou_name)

   263

   264

    # Generate a configuration from its model

   265

    def GenerateConfiguration(self, configuration):

   266

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

   267

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

   268

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

   269

                  ("\n", ())]

   270

        var_number = 0

   271

        # Generate any global variable in configuration

   272

        for varlist in configuration.getglobalVars():

   273

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

   274

            # Generate variable block with modifier

   275

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

   276

            if varlist.getconstant():

   277

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

   278

            elif varlist.getretain():

   279

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

   280

            elif varlist.getnonretain():

   281

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

   282

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

   283

            # Generate any variable of this block

   284

            for var in varlist.getvariable():

   285

                vartype_content = var.gettype().getcontent()

   286

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

   287

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

   288

                    self.GenerateDataType(var_type)

   289

                else:

   290

                    var_type = var.gettypeAsText()

   291

   292

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

   293

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

   294

                           (" ", ())]

   295

                # Generate variable address if exists

   296

                address = var.getaddress()

   297

                if address:

   298

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

   299

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

   300

                               (" ", ())]

   301

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

   302

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

   303

                # Generate variable initial value if exists

   304

                initial = var.getinitialValue()

   305

                if initial:

   306

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

   307

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

   308

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

   309

                var_number += 1

   310

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

   311

        # Generate any resource in the configuration

   312

        for resource in configuration.getresource():

   313

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

   314

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

   315

        return config

   316

   317

    # Generate a resource from its model

   318

    def GenerateResource(self, resource, config_name):

   319

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

   320

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

   321

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

   322

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

   323

        var_number = 0

   324

        # Generate any global variable in configuration

   325

        for varlist in resource.getglobalVars():

   326

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

   327

            # Generate variable block with modifier

   328

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

   329

            if varlist.getconstant():

   330

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

   331

            elif varlist.getretain():

   332

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

   333

            elif varlist.getnonretain():

   334

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

   335

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

   336

            # Generate any variable of this block

   337

            for var in varlist.getvariable():

   338

                vartype_content = var.gettype().getcontent()

   339

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

   340

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

   341

                    self.GenerateDataType(var_type)

   342

                else:

   343

                    var_type = var.gettypeAsText()

   344

   345

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

   346

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

   347

                           (" ", ())]

   348

                address = var.getaddress()

   349

                # Generate variable address if exists

   350

                if address:

   351

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

   352

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

   353

                               (" ", ())]

   354

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

   355

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

   356

                # Generate variable initial value if exists

   357

                initial = var.getinitialValue()

   358

                if initial:

   359

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

   360

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

   361

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

   362

                var_number += 1

   363

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

   364

        # Generate any task in the resource

   365

        tasks = resource.gettask()

   366

        task_number = 0

   367

        for task in tasks:

   368

            # Task declaration

   369

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

   370

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

   371

                       ("(", ())]

   372

            args = []

   373

            single = task.getsingle()

   374

            # Single argument if exists

   375

            if single:

   376

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

   377

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

   378

                           (",", ())]

   379

            # Interval argument if exists

   380

            interval = task.getinterval()

   381

            if interval:

   382

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

   383

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

   384

                           (",", ())]

   385

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

   386

##                if interval.hour != 0:

   387

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

   388

##                if interval.minute != 0:

   389

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

   390

##                if interval.second != 0:

   391

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

   392

##                if interval.microsecond != 0:

   393

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

   394

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

   395

            # Priority argument

   396

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

   397

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

   398

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

   399

            task_number += 1

   400

        instance_number = 0

   401

        # Generate any program assign to each task

   402

        for task in tasks:

   403

            for instance in task.getpouInstance():

   404

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

   405

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

   406

                           (" WITH ", ()),

   407

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

   408

                           (" : ", ()),

   409

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

   410

                           (";\n", ())]

   411

                instance_number += 1

   412

        # Generate any program assign to no task

   413

        for instance in resource.getpouInstance():

   414

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

   415

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

   416

                           (" : ", ()),

   417

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

   418

                           (";\n", ())]

   419

            instance_number += 1

   420

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

   421

        return resrce

   422

   423

    # Generate the entire program for current project

   424

    def GenerateProgram(self):        

   425

        # Find all data types defined

   426

        for datatype in self.Project.getdataTypes():

   427

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

   428

        # Find all data types defined

   429

        for pou in self.Project.getpous():

   430

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

   431

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

   432

        # type defined

   433

        if len(self.DatatypeComputed) > 0:

   434

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

   435

            # Generate every data types defined

   436

            for datatype_name in self.DatatypeComputed.keys():

   437

                self.GenerateDataType(datatype_name)

   438

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

   439

        # Generate every POUs defined

   440

        for pou_name in self.PouComputed.keys():

   441

            self.GeneratePouProgram(pou_name)

   442

        # Generate every configurations defined

   443

        for config in self.Project.getconfigurations():

   444

            self.Program += self.GenerateConfiguration(config)

   445

   446

    # Return generated program

   447

    def GetGeneratedProgram(self):

   448

        return self.Program

   449

   450

   451

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

   452

#                           Generator of POU programs

   453

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

   454

   455

   456

class PouProgramGenerator:

   457

   458

    # Create a new POU program generator

   459

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

   460

        # Keep Reference to the parent generator

   461

        self.ParentGenerator = parent

   462

        self.Name = name

   463

        self.Type = type

   464

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

   465

        self.CurrentIndent = "  "

   466

        self.ReturnType = None

   467

        self.Interface = []

   468

        self.InitialSteps = []

   469

        self.ComputedBlocks = {}

   470

        self.ComputedConnectors = {}

   471

        self.ConnectionTypes = {}

   472

        self.RelatedConnections = []

   473

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

   474

        self.SFCComputedBlocks = []

   475

        self.ActionNumber = 0

   476

        self.Program = []

   477

        self.Errors = errors

   478

        self.Warnings = warnings

   479

   480

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

   481

        return self.ParentGenerator.Controler.GetBlockType(type, inputs)

   482

   483

    def IndentLeft(self):

   484

        if len(self.CurrentIndent) >= 2:

   485

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

   486

   487

    def IndentRight(self):

   488

        self.CurrentIndent += "  "

   489

   490

    # Generator of unique ID for inline actions

   491

    def GetActionNumber(self):

   492

        self.ActionNumber += 1

   493

        return self.ActionNumber

   494

   495

    # Test if a variable has already been defined

   496

    def IsAlreadyDefined(self, name):

   497

        for list_type, option, located, vars in self.Interface:

   498

            for var_type, var_name, var_address, var_initial in vars:

   499

                if name == var_name:

   500

                    return True

   501

        return False

   502

   503

    # Return the type of a variable defined in interface

   504

    def GetVariableType(self, name):

   505

        parts = name.split('.')

   506

        current_type = None

   507

        if len(parts) > 0:

   508

            name = parts.pop(0)

   509

            for list_type, option, located, vars in self.Interface:

   510

                for var_type, var_name, var_address, var_initial in vars:

   511

                    if name == var_name:

   512

                        current_type = var_type

   513

                        break

   514

            while current_type is not None and len(parts) > 0:

   515

                tagname = self.ParentGenerator.Controler.ComputeDataTypeName(current_type)

   516

                infos = self.ParentGenerator.Controler.GetDataTypeInfos(tagname)

   517

                name = parts.pop(0)

   518

                current_type = None

   519

                if infos is not None and infos["type"] == "Structure":

   520

                    for element in infos["elements"]:

   521

                        if element["Name"] == name:

   522

                            current_type = element["Type"]

   523

                            break

   524

        return current_type

   525

   526

    # Return connectors linked by a connection to the given connector

   527

    def GetConnectedConnector(self, connector, body):

   528

        links = connector.getconnections()