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

#

     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

    20

#

    21

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

    22

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

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from plcopen import plcopen

    26

from plcopen.structures import *

    27

from types import *

    28

    29

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

    30

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

    31

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

    32

    33

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

    34

    35

def ReIndentText(text, nb_spaces):

    36

    compute = ""

    37

    lines = text.splitlines()

    38

    if len(lines) > 0:

    39

        spaces = 0

    40

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

    41

            spaces += 1

    42

        indent = ""

    43

        for i in xrange(spaces, nb_spaces):

    44

            indent += " "

    45

        for line in lines:

    46

            if line != "":

    47

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

    48

            else:

    49

                compute += "\n"

    50

    return compute

    51

    52

"""

    53

Module implementing methods for generating PLC programs in ST or IL

    54

"""

    55

    56

class PouProgram:

    57

    58

    def __init__(self, name, type):

    59

        self.Name = name

    60

        self.Type = type

    61

        self.ReturnType = None

    62

        self.Interface = []

    63

        self.InitialSteps = []

    64

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

    65

        self.ActionNumber = 0

    66

        self.Program = ""

    67

    68

    def GetActionNumber(self):

    69

        self.ActionNumber += 1

    70

        return self.ActionNumber

    71

    72

    def IsAlreadyDefined(self, name):

    73

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

    74

            for var_type, var_name, var_address, var_initial in vars:

    75

                if name == var_name:

    76

                    return True

    77

        return False

    78

    79

    def GenerateInterface(self, interface):

    80

        if self.Type == "FUNCTION":

    81

            self.ReturnType = interface.getReturnType().getValue()

    82

        for varlist in interface.getContent():

    83

            variables = []

    84

            located = False

    85

            for var in varlist["value"].getVariable():

    86

                type = var.getType().getValue()

    87

                initial = var.getInitialValue()

    88

                if initial:

    89

                    initial_value = initial.getValue()

    90

                else:

    91

                    initial_value = None

    92

                address = var.getAddress()

    93

                if address == "":

    94

                    address = None

    95

                else:

    96

                    located = True

    97

                variables.append((type, var.getName(), address, initial_value))

    98

            self.Interface.append((varTypeNames[varlist["name"]], varlist["value"].getRetain(), 

    99

                            varlist["value"].getConstant(), located, variables))

   100

   101

    def GenerateProgram(self, pou):

   102

        body = pou.getBody()

   103

        body_content = body.getContent()

   104

        body_type = body_content["name"]

   105

        if body_type in ["IL","ST"]:

   106

            self.Program = ReIndentText(body_content["value"].getText(), 2)

   107

        elif body_type == "FBD":

   108

            for instance in body.getContentInstances():

   109

                if isinstance(instance, plcopen.outVariable):

   110

                    var = instance.getExpression()

   111

                    connections = instance.connectionPointIn.getConnections()

   112

                    if connections and len(connections) == 1:

   113

                        expression = self.ComputeFBDExpression(body, connections[0])

   114

                        self.Program += "  %s := %s;\n"%(var, expression)

   115

        elif body_type == "LD":

   116

            for instance in body.getContentInstances():

   117

                if isinstance(instance, plcopen.coil):

   118

                    paths = self.GenerateLDPaths(instance, body)

   119

                    variable = self.ExtractModifier(instance, instance.getVariable())

   120

                    expression = self.ComputeLDExpression(paths, True)

   121

                    self.Program += "  %s := %s;\n"%(variable, expression)

   122

        elif body_type == "SFC":

   123

            for instance in body.getContentInstances():

   124

                if isinstance(instance, plcopen.step):

   125

                    self.GenerateSFCStep(instance, pou)

   126

                elif isinstance(instance, plcopen.actionBlock):

   127

                    self.GenerateSFCStepActions(instance, pou)

   128

                elif isinstance(instance, plcopen.transition):

   129

                    self.GenerateSFCTransition(instance, pou)

   130

                elif isinstance(instance, plcopen.jumpStep):

   131

                    self.GenerateSFCJump(instance, pou)

   132

            for initialstep in self.InitialSteps:

   133

                self.ComputeSFCStep(initialstep)

   134

   135

    def ComputeFBDExpression(self, body, link):

   136

        localid = link.getRefLocalId()

   137

        instance = body.getContentInstance(localid)

   138

        if isinstance(instance, plcopen.inVariable):

   139

            return instance.getExpression()

   140

        elif isinstance(instance, plcopen.block):

   141

            name = instance.getInstanceName()

   142

            type = instance.getTypeName()

   143

            block_infos = GetBlockType(type)

   144

            if block_infos["type"] == "function":

   145

                vars = []

   146

                for variable in instance.inputVariables.getVariable():

   147

                    connections = variable.connectionPointIn.getConnections()

   148

                    if connections and len(connections) == 1:

   149

                        value = self.ComputeFBDExpression(body, connections[0])

   150

                        vars.append(self.ExtractModifier(variable, value))

   151

                variable = instance.outputVariables.getVariable()[0]

   152

                return self.ExtractModifier(variable, "%s(%s)"%(type, ", ".join(vars)))

   153

            elif block_infos["type"] == "functionBlock":

   154

                if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] or self.Interface[-1][2] or self.Interface[-1][3]:

   155

                    self.Interface.append(("VAR", False, False, False, []))

   156

                if not self.IsAlreadyDefined(name):

   157

                    self.Interface[-1][4].append((type, name, None, None))

   158

                    vars = []

   159

                    for variable in instance.inputVariables.getVariable():

   160

                        connections = variable.connectionPointIn.getConnections()

   161

                        if connections and len(connections) == 1:

   162

                            parameter = variable.getFormalParameter()

   163

                            value = self.ComputeFBDExpression(body, connections[0])

   164

                            vars.append(self.ExtractModifier(variable, "%s := %s"%(parameter, value)))

   165

                    self.Program += "  %s(%s);\n"%(name, ", ".join(vars))

   166

                connectionPoint = link.getPosition()[-1]

   167

                for variable in instance.outputVariables.getVariable():

   168

                    blockPointx, blockPointy = variable.connectionPointOut.getRelPosition()

   169

                    if instance.getX() + blockPointx == connectionPoint.getX() and instance.getY() + blockPointy == connectionPoint.getY():

   170

                        return self.ExtractModifier(variable, "%s.%s"%(name, variable.getFormalParameter()))

   171

                raise ValueError, "No output variable found"

   172

   173

    def GenerateLDPaths(self, instance, body):

   174

        paths = []

   175

        variable = self.ExtractModifier(instance, instance.getVariable())

   176

        connections = instance.connectionPointIn.getConnections()

   177

        for connection in connections:

   178

            localId = connection.getRefLocalId()

   179

            next = body.getContentInstance(localId)

   180

            if isinstance(next, plcopen.leftPowerRail):

   181

                paths.append(None)

   182

            else:

   183

                paths.append(self.GenerateLDPaths(next, body))

   184

        if isinstance(instance, plcopen.coil):

   185

            if len(paths) > 1:

   186

                return tuple(paths)

   187

            else:

   188

                return paths

   189

        else:

   190

            if len(paths) > 1:

   191

                return [variable, tuple(paths)]

   192

            elif type(paths[0]) == ListType:

   193

                return [variable] + paths[0]

   194

            elif paths[0]:

   195

                return [variable, paths[0]]

   196

            else:

   197

                return variable

   198

   199

    def ExtractDivergenceInput(self, divergence, pou):

   200

        connectionPointIn = divergence.getConnectionPointIn()

   201

        if connectionPointIn:

   202

            connections = connectionPointIn.getConnections()

   203

            if len(connections) == 1:

   204

                instanceLocalId = connections[0].getRefLocalId()

   205

                return pou.body.getContentInstance(instanceLocalId)

   206

        return None

   207

   208

    def ExtractConvergenceInputs(self, convergence, pou):

   209

        instances = []

   210

        for connectionPointIn in convergence.getConnectionPointIn():

   211

            connections = connectionPointIn.getConnections()

   212

            if len(connections) == 1:

   213

                instanceLocalId = connections[0].getRefLocalId()

   214

                instances.append(pou.body.getContentInstance(instanceLocalId))

   215

        return instances

   216

   217

    def GenerateSFCStep(self, step, pou):

   218

        step_name = step.getName()

   219

        if step_name not in self.SFCNetworks["Steps"].keys():

   220

            if step.getInitialStep():

   221

                self.InitialSteps.append(step_name)

   222

            step_infos = {"initial" : step.getInitialStep(), "transitions" : [], "actions" : []}

   223

            if step.connectionPointIn:

   224

                instances = []

   225

                connections = step.connectionPointIn.getConnections()

   226

                if len(connections) == 1:

   227

                    instanceLocalId = connections[0].getRefLocalId()

   228

                    instance = pou.body.getContentInstance(instanceLocalId)

   229

                    if isinstance(instance, plcopen.transition):

   230

                        instances.append(instance)

   231

                    elif isinstance(instance, plcopen.selectionConvergence):

   232

                        instances.extend(self.ExtractConvergenceInputs(instance, pou))

   233

                    elif isinstance(instance, plcopen.simultaneousDivergence):

   234

                        transition = self.ExtractDivergenceInput(instance, pou)

   235

                        if transition:

   236

                            if isinstance(transition, plcopen.transition):

   237

                                instances.append(transition)

   238

                            elif isinstance(transition, plcopen.selectionConvergence):

   239

                                instances.extend(self.ExtractConvergenceInputs(transition, pou))

   240

                for instance in instances:

   241

                    self.GenerateSFCTransition(instance, pou)

   242

                    if instance in self.SFCNetworks["Transitions"].keys():

   243

                        self.SFCNetworks["Transitions"][instance]["to"].append(step_name)

   244

            self.SFCNetworks["Steps"][step_name] = step_infos

   245

   246

    def GenerateSFCJump(self, jump, pou):

   247

        jump_target = jump.getTargetName()

   248

        if jump.connectionPointIn:

   249

            instances = []

   250

            connections = jump.connectionPointIn.getConnections()

   251

            if len(connections) == 1:

   252

                instanceLocalId = connections[0].getRefLocalId()

   253

                instance = pou.body.getContentInstance(instanceLocalId)

   254

                if isinstance(instance, plcopen.transition):

   255

                    instances.append(instance)

   256

                elif isinstance(instance, plcopen.selectionConvergence):

   257

                    instances.extend(self.ExtractConvergenceInputs(instance, pou))

   258

                elif isinstance(instance, plcopen.simultaneousDivergence):

   259

                    transition = self.ExtractDivergenceInput(instance, pou)

   260

                    if transition:

   261

                        if isinstance(transition, plcopen.transition):

   262

                            instances.append(transition)

   263

                        elif isinstance(transition, plcopen.selectionConvergence):

   264

                            instances.extend(self.ExtractConvergenceInputs(transition, pou))

   265

            for instance in instances:

   266

                self.GenerateSFCTransition(instance, pou)

   267

                if instance in self.SFCNetworks["Transitions"].keys():

   268

                    self.SFCNetworks["Transitions"][instance]["to"].append(jump_target)

   269

   270

    def GenerateSFCStepActions(self, actionBlock, pou):

   271

        connections = actionBlock.connectionPointIn.getConnections()

   272

        if len(connections) == 1:

   273

            stepLocalId = connections[0].getRefLocalId()

   274

            step = pou.body.getContentInstance(stepLocalId)

   275

            self.GenerateSFCStep(step, pou)

   276

            step_name = step.getName()

   277

            if step_name in self.SFCNetworks["Steps"].keys():

   278

                actions = actionBlock.getActions()

   279

                for action in actions:

   280

                    action_infos = {"qualifier" : action["qualifier"], "content" : action["value"]}

   281

                    if "duration" in action:

   282

                        action_infos["duration"] = action["duration"]

   283

                    if "indicator" in action:

   284

                        action_infos["indicator"] = action["indicator"]

   285

                    if action["type"] == "reference":

   286

                        self.GenerateSFCAction(action["value"], pou)

   287

                    else:

   288

                        action_name = "INLINE%d"%self.GetActionNumber()

   289

                        self.SFCNetworks["Actions"][action_name] = "    %s\n"%action["value"]

   290

                        action_infos["content"] = action_name

   291

                    self.SFCNetworks["Steps"][step_name]["actions"].append(action_infos)

   292

   293

    def GenerateSFCAction(self, action_name, pou):

   294

        if action_name not in self.SFCNetworks["Actions"].keys():

   295

            actionContent = pou.getAction(action_name)

   296

            if actionContent:

   297

                actionType = actionContent.getBodyType()

   298

                actionBody = actionContent.getBody()

   299

                if actionType in ["ST", "IL"]:

   300

                    self.SFCNetworks["Actions"][action_name] = ReIndentText(actionContent.getText(), 4)

   301

                elif actionType == "FBD":

   302

                    for instance in actionBody.getContentInstances():

   303

                        if isinstance(instance, plcopen.outVariable):

   304

                            var = instance.getExpression()

   305

                            connections = instance.connectionPointIn.getConnections()

   306

                            if connections and len(connections) == 1:

   307

                                expression = self.ComputeFBDExpression(actionBody, connections[0])

   308

                                self.SFCNetworks["Actions"][action_name] = self.Program + "  %s := %s;\n"%(var, expression)

   309

                                self.Program = ""

   310

                elif actionType == "LD":

   311

                    for instance in actionbody.getContentInstances():

   312

                        if isinstance(instance, plcopen.coil):

   313

                            paths = self.GenerateLDPaths(instance, actionBody)

   314

                            variable = self.ExtractModifier(instance, instance.getVariable())

   315

                            expression = self.ComputeLDExpression(paths, True)

   316

                            self.SFCNetworks["Actions"][action_name] = self.Program + "  %s := %s;\n"%(variable, expression)

   317

                            self.Program = ""

   318

   319

    def GenerateSFCTransition(self, transition, pou):

   320

        if transition not in self.SFCNetworks["Transitions"].keys():

   321

            steps = []

   322

            connections = transition.connectionPointIn.getConnections()

   323

            if len(connections) == 1:

   324

                instanceLocalId = connections[0].getRefLocalId()

   325

                instance = pou.body.getContentInstance(instanceLocalId)

   326

                if isinstance(instance, plcopen.step):

   327

                    steps.append(instance)

   328

                elif isinstance(instance, plcopen.selectionDivergence):

   329

                    step = self.ExtractDivergenceInput(instance, pou)

   330

                    if step:

   331

                        if isinstance(step, plcopen.step):

   332

                            steps.append(step)

   333

                        elif isinstance(step, plcopen.simultaneousConvergence):

   334

                            steps.extend(self.ExtractConvergenceInputs(step, pou))

   335

                elif isinstance(instance, plcopen.simultaneousConvergence):

   336

                    steps.extend(self.ExtractConvergenceInputs(instance, pou))

   337

            transition_infos = {"from": [], "to" : []}

   338

            transitionValues = transition.getConditionContent()

   339

            if transitionValues["type"] == "inline":

   340

                transition_infos["content"] = "\n    := %s;\n"%transitionValues["value"]

   341

            else:

   342

                transitionContent = pou.getTransition(transitionValues["value"])

   343

                transitionType = transitionContent.getBodyType()

   344

                transitionBody = transitionContent.getBody()

   345

                if transitionType == "IL":

   346

                    transition_infos["content"] = ":\n%s"%ReIndentText(transitionBody.getText(), 4)

   347

                elif transitionType == "ST":

   348

                    transition_infos["content"] = "\n%s"%ReIndentText(transitionBody.getText(), 4)

   349

                elif conditionType == "FBD":

   350

                    for instance in transitionBody.getContentInstances():

   351

                        if isinstance(instance, plcopen.outVariable):

   352

                            connections = instance.connectionPointIn.getConnections()

   353

                            if connections and len(connections) == 1:

   354

                                expression = self.ComputeFBDExpression(actionBody, connections[0])

   355

                                transition_infos["content"] = "\n    := %s;\n"%(var, expression)

   356

                elif actionType == "LD":

   357

                    for instance in transitionbody.getContentInstances():

   358

                        if isinstance(instance, plcopen.coil):

   359

                            paths = self.GenerateLDPaths(instance, conditionBody)

   360

                            expression = self.ComputeLDExpression(paths, True)

   361

                            transition_infos["content"] = "\n    := %s;\n"%expression

   362

            for step in steps:

   363

                self.GenerateSFCStep(step, pou)

   364

                step_name = step.getName()

   365

                if step_name in self.SFCNetworks["Steps"].keys():

   366

                    transition_infos["from"].append(step_name)

   367

                    self.SFCNetworks["Steps"][step_name]["transitions"].append(transition)

   368

            self.SFCNetworks["Transitions"][transition] = transition_infos

   369

   370

    def ComputeSFCStep(self, step_name):

   371

        if step_name in self.SFCNetworks["Steps"].keys():

   372

            step_infos = self.SFCNetworks["Steps"].pop(step_name)

   373

            if step_infos["initial"]:

   374

                self.Program += "  INITIAL_STEP %s:\n"%step_name

   375

            else:

   376

                self.Program += "  STEP %s:\n"%step_name

   377

            actions = []

   378

            for action_infos in step_infos["actions"]:

   379

                actions.append(action_infos["content"])

   380

                self.Program += "    %(content)s(%(qualifier)s"%action_infos

   381

                if "duration" in action_infos:

   382

                    self.Program += ", %(duration)s"%action_infos

   383

                if "indicator" in action_infos:

   384

                    self.Program += ", %(indicator)s"%action_infos

   385

                self.Program += ");\n"

   386

            self.Program += "  END_STEP\n\n"

   387

            for action in actions:

   388

                self.ComputeSFCAction(action)

   389

            for transition in step_infos["transitions"]:

   390

                self.ComputeSFCTransition(transition)

   391

   392

    def ComputeSFCAction(self, action_name):

   393

        if action_name in self.SFCNetworks["Actions"].keys():

   394

            action_content = self.SFCNetworks["Actions"].pop(action_name)

   395

            self.Program += "  ACTION %s:\n%s  END_ACTION\n\n"%(action_name, action_content)

   396

   397

    def ComputeSFCTransition(self, transition):

   398

        if transition in self.SFCNetworks["Transitions"].keys():

   399

            transition_infos = self.SFCNetworks["Transitions"].pop(transition)

   400

            self.Program += "  TRANSITION FROM "

   401

            if len(transition_infos["from"]) > 1:

   402

                self.Program += "(%s)"%", ".join(transition_infos["from"])

   403

            else:

   404

                self.Program += "%s"%transition_infos["from"][0]

   405

            self.Program += " TO "

   406

            if len(transition_infos["to"]) > 1:

   407

                self.Program += "(%s)"%", ".join(transition_infos["to"])

   408

            else:

   409

                self.Program += "%s"%transition_infos["to"][0]

   410

            self.Program += transition_infos["content"]

   411

            self.Program += "  END_TRANSITION\n\n"

   412

            for step_name in transition_infos["to"]:

   413

                self.ComputeSFCStep(step_name)

   414

   415

    def ComputeLDExpression(self, paths, first = False):

   416

        if type(paths) == TupleType:

   417

            if None in paths:

   418

                return "TRUE"

   419

            else:

   420

                var = [self.ComputeLDExpression(path) for path in paths]

   421

                if first:

   422

                    return " OR ".join(var)

   423

                else:

   424

                    return "(%s)"%" OR ".join(var)

   425

        elif type(paths) == ListType:

   426

            var = [self.ComputeLDExpression(path) for path in paths]

   427

            return " AND ".join(var)

   428

        else:

   429

            return paths

   430

   431

    def ExtractModifier(self, variable, text):

   432

        if variable.getNegated():

   433

            return "NOT(%s)"%text

   434

        else:

   435

            edge = variable.getEdge()

   436

            if edge:

   437

                if edge.getValue() == "rising":

   438

                    return self.AddTrigger("R_TRIG", text)

   439

                elif edge.getValue() == "falling":

   440

                    return self.AddTrigger("F_TRIG", text)

   441

        return text

   442

   443

    def AddTrigger(self, edge, text):

   444

        if self.Interface[-1][0] != "VAR" or self.Interface[-1][1] or self.Interface[-1][2] or self.Interface[-1][3]:

   445

            self.Interface.append(("VAR", False, False, False, []))

   446

        i = 1

   447

        name = "%s%d"%(edge, i)

   448

        while self.IsAlreadyDefined(name):

   449

            i += 1

   450

            name = "%s%d"%(edge, i)

   451

        self.Interface[-1][4].append((edge, name, None, None))

   452

        self.Program += "  %s(CLK := %s);\n"%(name, text)

   453

        return "%s.Q"%name

   454

   455

    def GenerateSTProgram(self):

   456

        if self.ReturnType:

   457

            program = "%s %s : %s\n"%(self.Type, self.Name, self.ReturnType)

   458

        else:

   459

            program = "%s %s\n"%(self.Type, self.Name)

   460

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

   461

            program += "  %s"%list_type

   462

            if retain:

   463

                program += " RETAIN"

   464

            if constant:

   465

                program += " CONSTANT"

   466

            program += "\n"

   467

            for var_type, var_name, var_address, var_initial in variables:

   468

                program += "    %s "%var_name

   469

                if var_address != None:

   470

                    program += "AT %s "%var_address

   471

                program += ": %s"%var_type

   472

                if var_initial != None:

   473

                    value = {"TRUE":"0","FALSE":"1"}.get(str(var_initial).upper(), str(var_initial))

   474

                    if var_type == "STRING":

   475

                        program += " := '%s'"%value

   476

                    elif var_type == "WSTRING":

   477

                        program += " := \"%s\""%value

   478

                    else:

   479

                        program += " := %s"%value

   480

                program += ";\n"

   481

            program += "  END_VAR\n"

   482

        program += "\n"

   483

        program += self.Program

   484

        program += "END_%s\n\n"%self.Type

   485

        return program

   486

   487

    def GenerateConfiguration(self, configuration):

   488

        config = "\nCONFIGURATION %s\n"%configuration.getName()

   489

        for varlist in configuration.getGlobalVars():

   490

            config += "  VAR_GLOBAL"

   491

            if varlist.getRetain():

   492

                config += " RETAIN"

   493

            if varlist.getConstant():

   494

                config += " CONSTANT"

   495

            config += "\n"

   496

            for var in varlist.getVariable():

   497

                var_type = var.getType().getValue()

   498

                config += "    %s "%var.getName()

   499

                address = var.getAddress()

   500

                if address:

   501

                    config += "AT %s "%address

   502

                config += ": %s"%var_type

   503