1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program 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

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

from __future__ import absolute_import

    27

from types import *

    28

import re

    29

from plcopen import PLCOpenParser

    30

from plcopen.structures import *

    31

    32

    33

# Dictionary associating PLCOpen variable categories to the corresponding

    34

# IEC 61131-3 variable categories

    35

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

    36

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

    37

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

    38

    39

    40

# Dictionary associating PLCOpen POU categories to the corresponding

    41

# IEC 61131-3 POU categories

    42

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

    43

    44

    45

errorVarTypes = {

    46

    "VAR_INPUT": "var_input",

    47

    "VAR_OUTPUT": "var_output",

    48

    "VAR_INOUT": "var_inout",

    49

}

    50

    51

    52

def ReIndentText(text, nb_spaces):

    53

    """ Helper function for reindenting text """

    54

    compute = ""

    55

    lines = text.splitlines()

    56

    if len(lines) > 0:

    57

        line_num = 0

    58

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

    59

            line_num += 1

    60

        if line_num < len(lines):

    61

            spaces = 0

    62

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

    63

                spaces += 1

    64

            indent = ""

    65

            for dummy in xrange(spaces, nb_spaces):

    66

                indent += " "

    67

            for line in lines:

    68

                if line != "":

    69

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

    70

                else:

    71

                    compute += "\n"

    72

    return compute

    73

    74

    75

def SortInstances(a, b):

    76

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

    77

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

    78

    if abs(ay - by) < 10:

    79

        return cmp(ax, bx)

    80

    else:

    81

        return cmp(ay, by)

    82

    83

    84

def JoinList(separator, mylist):

    85

    """ Helper for emulate join on element list """

    86

    if len(mylist) > 0:

    87

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

    88

    else:

    89

        return mylist

    90

    91

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

    92

#                  Specific exception for PLC generating errors

    93

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

    94

    95

    96

class PLCGenException(Exception):

    97

    pass

    98

    99

   100

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

   101

#                           Generator of PLC program

   102

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

   103

   104

   105

class ProgramGenerator(object):

   106

   107

    # Create a new PCL program generator

   108

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

   109

        # Keep reference of the controler and project

   110

        self.Controler = controler

   111

        self.Project = project

   112

        # Reset the internal variables used to generate PLC programs

   113

        self.Program = []

   114

        self.DatatypeComputed = {}

   115

        self.PouComputed = {}

   116

        self.Errors = errors

   117

        self.Warnings = warnings

   118

   119

    # Compute value according to type given

   120

    def ComputeValue(self, value, var_type):

   121

        base_type = self.Controler.GetBaseType(var_type)

   122

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

   123

            return "'%s'" % value

   124

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

   125

            return "\"%s\"" % value

   126

        return value

   127

   128

    # Generate a data type from its name

   129

    def GenerateDataType(self, datatype_name):

   130

        # Verify that data type hasn't been generated yet

   131

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

   132

            # If not mark data type as computed

   133

            self.DatatypeComputed[datatype_name] = True

   134

   135

            # Getting datatype model from project

   136

            datatype = self.Project.getdataType(datatype_name)

   137

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

   138

            datatype_def = [("  ", ()),

   139

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

   140

                            (" : ", ())]

   141

            basetype_content = datatype.baseType.getcontent()

   142

            basetype_content_type = basetype_content.getLocalTag()

   143

            # Data type derived directly from a user defined type

   144

            if basetype_content_type == "derived":

   145

                basetype_name = basetype_content.getname()

   146

                self.GenerateDataType(basetype_name)

   147

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

   148

            # Data type is a subrange

   149

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

   150

                base_type = basetype_content.baseType.getcontent()

   151

                base_type_type = base_type.getLocalTag()

   152

                # Subrange derived directly from a user defined type

   153

                if base_type_type == "derived":

   154

                    basetype_name = base_type_type.getname()

   155

                    self.GenerateDataType(basetype_name)

   156

                # Subrange derived directly from an elementary type

   157

                else:

   158

                    basetype_name = base_type_type

   159

                min_value = basetype_content.range.getlower()

   160

                max_value = basetype_content.range.getupper()

   161

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

   162

                                 (" (", ()),

   163

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

   164

                                 ("..", ()),

   165

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

   166

                                 (")", ())]

   167

            # Data type is an enumerated type

   168

            elif basetype_content_type == "enum":

   169

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

   170

                          for i, value in enumerate(

   171

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

   172

                                                     namespaces=PLCOpenParser.NSMAP))]

   173

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

   174

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

   175

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

   176

            # Data type is an array

   177

            elif basetype_content_type == "array":

   178

                base_type = basetype_content.baseType.getcontent()

   179

                base_type_type = base_type.getLocalTag()

   180

                # Array derived directly from a user defined type

   181

                if base_type_type == "derived":

   182

                    basetype_name = base_type.getname()

   183

                    self.GenerateDataType(basetype_name)

   184

                # Array derived directly from an elementary type

   185

                else:

   186

                    basetype_name = base_type_type.upper()

   187

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

   188

                               ("..", ()),

   189

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

   190

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

   191

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

   192

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

   193

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

   194

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

   195

            # Data type is a structure

   196

            elif basetype_content_type == "struct":

   197

                elements = []

   198

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

   199

                    element_type = element.type.getcontent()

   200

                    element_type_type = element_type.getLocalTag()

   201

                    # Structure element derived directly from a user defined type

   202

                    if element_type_type == "derived":

   203

                        elementtype_name = element_type.getname()

   204

                        self.GenerateDataType(elementtype_name)

   205

                    elif element_type_type == "array":

   206

                        base_type = element_type.baseType.getcontent()

   207

                        base_type_type = base_type.getLocalTag()

   208

                        # Array derived directly from a user defined type

   209

                        if base_type_type == "derived":

   210

                            basetype_name = base_type.getname()

   211

                            self.GenerateDataType(basetype_name)

   212

                        # Array derived directly from an elementary type

   213

                        else:

   214

                            basetype_name = base_type_type.upper()

   215

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

   216

                                      for dimension in element_type.getdimension()]

   217

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

   218

                    # Structure element derived directly from an elementary type

   219

                    else:

   220

                        elementtype_name = element_type_type.upper()

   221

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

   222

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

   223

                                    (" : ", ()),

   224

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

   225

                    if element.initialValue is not None:

   226

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

   227

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

   228

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

   229

                    elements.append(element_text)

   230

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

   231

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

   232

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

   233

            # Data type derived directly from a elementary type

   234

            else:

   235

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

   236

            # Data type has an initial value

   237

            if datatype.initialValue is not None:

   238

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

   239

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

   240

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

   241

            self.Program += datatype_def

   242

   243

    # Generate a POU from its name

   244

    def GeneratePouProgram(self, pou_name):

   245

        # Verify that POU hasn't been generated yet

   246

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

   247

            # If not mark POU as computed

   248

            self.PouComputed[pou_name] = True

   249

   250

            # Getting POU model from project

   251

            pou = self.Project.getpou(pou_name)

   252

            pou_type = pou.getpouType()

   253

            # Verify that POU type exists

   254

            if pou_type in pouTypeNames:

   255

                # Create a POU program generator

   256

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

   257

                program = pou_program.GenerateProgram(pou)

   258

                self.Program += program

   259

            else:

   260

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

   261

   262

    # Generate a POU defined and used in text

   263

    def GeneratePouProgramInText(self, text):

   264

        for pou_name in self.PouComputed.keys():

   265

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

   266

            if model.search(text) is not None:

   267

                self.GeneratePouProgram(pou_name)

   268

   269

    # Generate a configuration from its model

   270

    def GenerateConfiguration(self, configuration):

   271

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

   272

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

   273

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

   274

                  ("\n", ())]

   275

        var_number = 0

   276

   277

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

   278

   279

        extra_variables = self.Controler.GetConfigurationExtraVariables()

   280

        extra_global_vars = None

   281

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

   282

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

   283

            configuration.setglobalVars([extra_global_vars])

   284

            varlists = [(extra_global_vars, [])]

   285

   286

        for variable in extra_variables:

   287

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

   288

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

   289

   290

        # Generate any global variable in configuration

   291

        for varlist, varlist_variables in varlists:

   292

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

   293

            # Generate variable block with modifier

   294

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

   295

            if varlist.getconstant():

   296

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

   297

            elif varlist.getretain():

   298

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

   299

            elif varlist.getnonretain():

   300

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

   301

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

   302

            # Generate any variable of this block

   303

            for var in varlist_variables:

   304

                vartype_content = var.gettype().getcontent()

   305

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

   306

                    var_type = vartype_content.getname()

   307

                    self.GenerateDataType(var_type)

   308

                else:

   309

                    var_type = var.gettypeAsText()

   310

   311

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

   312

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

   313

                           (" ", ())]

   314

                # Generate variable address if exists

   315

                address = var.getaddress()

   316

                if address:

   317

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

   318

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

   319

                               (" ", ())]

   320

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

   321

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

   322

                # Generate variable initial value if exists

   323

                initial = var.getinitialValue()

   324

                if initial is not None:

   325

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

   326

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

   327

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

   328

                var_number += 1

   329

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

   330

   331

        if extra_global_vars is not None:

   332

            configuration.remove(extra_global_vars)

   333

        else:

   334

            for variable in extra_variables:

   335

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

   336

   337

        # Generate any resource in the configuration

   338

        for resource in configuration.getresource():

   339

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

   340

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

   341

        return config

   342

   343

    # Generate a resource from its model

   344

    def GenerateResource(self, resource, config_name):

   345

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

   346

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

   347

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

   348

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

   349

        var_number = 0

   350

        # Generate any global variable in configuration

   351

        for varlist in resource.getglobalVars():

   352

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

   353

            # Generate variable block with modifier

   354

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

   355

            if varlist.getconstant():

   356

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

   357

            elif varlist.getretain():

   358

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

   359

            elif varlist.getnonretain():

   360

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

   361

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

   362

            # Generate any variable of this block

   363

            for var in varlist.getvariable():

   364

                vartype_content = var.gettype().getcontent()

   365

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

   366

                    var_type = vartype_content.getname()

   367

                    self.GenerateDataType(var_type)

   368

                else:

   369

                    var_type = var.gettypeAsText()

   370

   371

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

   372

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

   373

                           (" ", ())]

   374

                address = var.getaddress()

   375

                # Generate variable address if exists

   376

                if address:

   377

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

   378

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

   379

                               (" ", ())]

   380

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

   381

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

   382

                # Generate variable initial value if exists

   383

                initial = var.getinitialValue()

   384

                if initial is not None:

   385

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

   386

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

   387

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

   388

                var_number += 1

   389

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

   390

        # Generate any task in the resource

   391

        tasks = resource.gettask()

   392

        task_number = 0

   393

        for task in tasks:

   394

            # Task declaration

   395

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

   396

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

   397

                       ("(", ())]

   398

            single = task.getsingle()

   399

            # Single argument if exists

   400

            if single is not None:

   401

                if len(single) == 0:

   402

                    raise PLCGenException(

   403

                        _("Source signal has to be defined for single task '{a1}' in resource '{a2}.{a3}'.").

   404

                        format(a1=task.getname(), a2=config_name, a3=resource.getname()))

   405

   406

                if single[0] == '[' and single[-1] == ']':

   407

                    SNGLKW = "MULTI"

   408

                else:

   409

                    SNGLKW = "SINGLE"

   410

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

   411

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

   412

                           (",", ())]

   413

            # Interval argument if exists

   414

            interval = task.getinterval()

   415

            if interval is not None:

   416

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

   417

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

   418

                           (",", ())]

   419

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

   420

#                if interval.hour != 0:

   421

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

   422

#                if interval.minute != 0:

   423

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

   424

#                if interval.second != 0:

   425

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

   426

#                if interval.microsecond != 0:

   427

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

   428

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

   429

            # Priority argument

   430

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

   431

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

   432

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

   433

            task_number += 1

   434

        instance_number = 0

   435

        # Generate any program assign to each task

   436

        for task in tasks:

   437

            for instance in task.getpouInstance():

   438

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

   439

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

   440

                           (" WITH ", ()),

   441

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

   442

                           (" : ", ()),

   443

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

   444

                           (";\n", ())]

   445

                instance_number += 1

   446

        # Generate any program assign to no task

   447

        for instance in resource.getpouInstance():

   448

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

   449

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

   450

                       (" : ", ()),

   451

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

   452

                       (";\n", ())]

   453

            instance_number += 1

   454

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

   455

        return resrce

   456

   457

    # Generate the entire program for current project

   458

    def GenerateProgram(self):

   459

        # Find all data types defined

   460

        for datatype in self.Project.getdataTypes():

   461

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

   462

        # Find all data types defined

   463

        for pou in self.Project.getpous():

   464

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

   465

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

   466

        # type defined

   467

        if len(self.DatatypeComputed) > 0:

   468

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

   469

            # Generate every data types defined

   470

            for datatype_name in self.DatatypeComputed.keys():

   471

                self.GenerateDataType(datatype_name)

   472

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

   473

        # Generate every POUs defined

   474

        for pou_name in self.PouComputed.keys():

   475

            self.GeneratePouProgram(pou_name)

   476

        # Generate every configurations defined

   477

        for config in self.Project.getconfigurations():

   478

            self.Program += self.GenerateConfiguration(config)

   479

   480

    # Return generated program

   481

    def GetGeneratedProgram(self):

   482

        return self.Program

   483

   484

   485

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

   486

#                           Generator of POU programs

   487

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

   488

   489

[ConnectorClass, ContinuationClass, ActionBlockClass] = [

   490

    PLCOpenParser.GetElementClass(instance_name, "commonObjects")

   491

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

   492

[InVariableClass, InOutVariableClass, OutVariableClass, BlockClass] = [

   493

    PLCOpenParser.GetElementClass(instance_name, "fbdObjects")

   494

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

   495

[ContactClass, CoilClass, LeftPowerRailClass, RightPowerRailClass] = [

   496

    PLCOpenParser.GetElementClass(instance_name, "ldObjects")

   497

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

   498

[StepClass, TransitionClass, JumpStepClass,

   499

 SelectionConvergenceClass, SelectionDivergenceClass,

   500

 SimultaneousConvergenceClass, SimultaneousDivergenceClass] = [

   501

     PLCOpenParser.GetElementClass(instance_name, "sfcObjects")

   502

     for instance_name in ["step",

   503

                           "transition",